服务器网站建设软件有哪些,企业网站建设时优化关键词的问题,网站设计方案应该怎么做,企业做网站有用吗天涯文章目录 1#xff0c;AOP简介1.1 什么是AOP?1.2 AOP作用1.3 AOP核心概念 2#xff0c;AOP入门案例2.1 需求分析2.2 思路分析2.3 环境准备2.4 AOP实现步骤步骤1:添加依赖步骤2:定义接口与实现类步骤3:定义通知类和通知步骤4:定义切入点步骤5:制作切面步骤6:将通知类配给容器… 文章目录 1AOP简介1.1 什么是AOP?1.2 AOP作用1.3 AOP核心概念 2AOP入门案例2.1 需求分析2.2 思路分析2.3 环境准备2.4 AOP实现步骤步骤1:添加依赖步骤2:定义接口与实现类步骤3:定义通知类和通知步骤4:定义切入点步骤5:制作切面步骤6:将通知类配给容器并标识其为切面类步骤7:开启注解格式AOP功能步骤8:运行程序 知识点1EnableAspectJAutoProxy知识点2Aspect知识点3Pointcut知识点4Before 3AOP工作流程3.1 AOP工作流程流程1:Spring容器启动流程2:读取所有切面配置中的切入点流程3:初始化bean流程4:获取bean执行方法验证容器中是否为代理对象验证思路步骤1:修改App类,获取类的类型步骤2:修改MyAdvice类不增强步骤3:运行程序步骤4:修改MyAdvice类增强步骤5:运行程序 3.2 AOP核心概念 4AOP配置管理4.1 AOP切入点表达式4.1.1 语法格式4.1.2 通配符4.1.3 书写技巧 4.2 AOP通知类型4.2.1 类型介绍4.2.2 环境准备4.2.3 通知类型的使用前置通知后置通知环绕通知基本使用注意事项 返回后通知异常后通知通知类型总结知识点1After知识点2AfterReturning知识点3AfterThrowing知识点4Around 4.3 业务层接口执行效率4.3.1 需求分析4.3.2 环境准备4.3.3 功能开发步骤1:开启SpringAOP的注解功能步骤2:创建AOP的通知类步骤3:添加环绕通知步骤4:完成核心业务记录万次执行的时间步骤5:运行单元测试类步骤6:程序优化步骤7:运行单元测试类 4.4 AOP通知获取数据4.4.1 环境准备4.4.2 获取参数非环绕通知获取方式环绕通知获取方式 4.4.3 获取返回值环绕通知获取返回值返回后通知获取返回值 4.4.4 获取异常环绕通知获取异常抛出异常后通知获取异常 5AOP总结5.1 AOP的核心概念5.2 切入点表达式5.3 五种通知类型5.4 通知中获取参数 1AOP简介
前面我们在介绍Spring的时候说过Spring有两个核心的概念一个是IOC/DI一个是AOP。
前面已经对IOC/DI进行了系统的学习接下来要学习它的另一个核心内容就是AOP。
对于AOP,我们前面提过一句话是:AOP是在不改原有代码的前提下对其进行增强。
对于下面的内容我们主要就是围绕着这一句话进行展开学习主要学习两方面内容AOP核心概念,AOP作用:
1.1 什么是AOP?
AOP(Aspect Oriented Programming)面向切面编程一种编程范式指导开发者如何组织程序结构。 OOP(Object Oriented Programming)面向对象编程
我们都知道OOP是一种编程思想那么AOP也是一种编程思想编程思想主要的内容就是指导程序员该如何编写程序所以它们两个是不同的编程范式。
1.2 AOP作用
作用:在不惊动原始设计的基础上为其进行功能增强前面咱们有技术就可以实现这样的功能即代理模式。
前面咱们有技术就可以实现这样的功能即代理模式。
1.3 AOP核心概念
为了能更好的理解AOP的相关概念我们准备了一个环境整个环境的内容我们暂时可以不用关注最主要的类为:BookDaoImpl
Repository
public class BookDaoImpl implements BookDao {public void save() {//记录程序当前执行执行开始时间Long startTime System.currentTimeMillis();//业务执行万次for (int i 0;i10000;i) {System.out.println(book dao save ...);}//记录程序当前执行时间结束时间Long endTime System.currentTimeMillis();//计算时间差Long totalTime endTime-startTime;//输出信息System.out.println(执行万次消耗时间 totalTime ms);}public void update(){System.out.println(book dao update ...);}public void delete(){System.out.println(book dao delete ...);}public void select(){System.out.println(book dao select ...);}
}代码的内容相信大家都能够读懂对于save方法中有计算万次执行消耗的时间。
当在App类中从容器中获取bookDao对象后分别执行其save,delete,update和select方法后会有如下的打印结果: 这个时候我们就应该有些疑问?
对于计算万次执行消耗的时间只有save方法有为什么delete和update方法也会有呢?delete和update方法有那什么select方法为什么又没有呢?
这个案例中其实就使用了Spring的AOP在不惊动(改动)原有设计(代码)的前提下想给谁添加功能就给谁添加。这个也就是Spring的理念
无入侵式/无侵入式
说了这么多Spring到底是如何实现的呢? (1)前面一直在强调Spring的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的案例中BookServiceImpl中有save,update,delete和select方法,这些方法我们给起了一个名字叫连接点
(2)在BookServiceImpl的四个方法中update和delete只有打印没有计算万次执行消耗时间但是在运行的时候已经有该功能那也就是说update和delete方法都已经被增强所以对于需要增强的方法我们给起了一个名字叫切入点
(3)执行BookServiceImpl的update和delete方法的时候都被添加了一个计算万次执行消耗时间的功能将这个功能抽取到一个方法中换句话说就是存放共性功能的方法我们给起了个名字叫通知
(4)通知是要增强的内容会有多个切入点是需要被增强的方法也会有多个那哪个切入点需要添加哪个通知就需要提前将它们之间的关系描述清楚那么对于通知和切入点之间的关系描述我们给起了个名字叫切面
(5)通知是一个方法方法不能独立存在需要被写在一个类中这个类我们也给起了个名字叫通知类
至此AOP中的核心概念就已经介绍完了总结下:
连接点(JoinPoint)程序执行过程中的任意位置粒度为执行方法、抛出异常、设置变量等 在SpringAOP中理解为方法的执行 切入点(Pointcut):匹配连接点的式子 在SpringAOP中一个切入点可以描述一个具体方法也可也匹配多个方法 一个具体的方法:如com.lystar.dao包下的BookDao接口中的无形参无返回值的save方法匹配多个方法:所有的save方法所有的get开头的方法所有以Dao结尾的接口中的任意方法所有带有一个参数的方法 连接点范围要比切入点范围大是切入点的方法也一定是连接点但是是连接点的方法就不一定要被增强所以可能不是切入点。 通知(Advice):在切入点处执行的操作也就是共性功能 在SpringAOP中功能最终以方法的形式呈现 通知类定义通知的类切面(Aspect):描述通知与切入点的对应关系。
小结
这一节中主要讲解了AOP的概念与作用以及AOP中的核心概念学完以后大家需要能说出:
什么是AOP?AOP的作用是什么?AOP中核心概念分别指的是什么? 连接点切入点通知通知类切面
2AOP入门案例
2.1 需求分析
案例设定测算接口执行效率但是这个案例稍微复杂了点我们对其进行简化。
简化设定在方法执行前输出当前系统时间。
对于SpringAOP的开发有两种方式XML 和 注解我们使用哪个呢?
因为现在注解使用的比较多所以本次课程就采用注解完成AOP的开发。
总结需求为:使用SpringAOP的注解方式完成在方法执行的前打印出当前系统时间。
2.2 思路分析
需求明确后具体该如何实现都有哪些步骤我们先来分析下: 1.导入坐标(pom.xml) 2.制作连接点(原始操作Dao接口与实现类) 3.制作共性功能(通知类与通知) 4.定义切入点 5.绑定切入点与通知关系(切面) 2.3 环境准备 创建一个Maven项目 pom.xml添加Spring依赖 dependenciesdependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion5.2.10.RELEASE/version/dependency
/dependencies添加BookDao和BookDaoImpl类 public interface BookDao {public void save();public void update();
}Repository
public class BookDaoImpl implements BookDao {public void save() {System.out.println(System.currentTimeMillis());System.out.println(book dao save ...);}public void update(){System.out.println(book dao update ...);}
}创建Spring的配置类 Configuration
ComponentScan(com.lystar)
public class SpringConfig {
}编写App运行类 public class App {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao ctx.getBean(BookDao.class);bookDao.save();}
}最终创建好的项目结构如下: 说明:
目前打印save方法的时候因为方法中有打印系统时间所以运行的时候是可以看到系统时间对于update方法来说就没有该功能我们要使用SpringAOP的方式在不改变update方法的前提下让其具有打印系统时间的功能。
2.4 AOP实现步骤
步骤1:添加依赖
pom.xml
dependencygroupIdorg.aspectj/groupIdartifactIdaspectjweaver/artifactIdversion1.9.4/version
/dependency因为spring-context中已经导入了spring-aop,所以不需要再单独导入spring-aop导入AspectJ的jar包,AspectJ是AOP思想的一个具体实现Spring有自己的AOP实现但是相比于AspectJ来说比较麻烦所以我们直接采用Spring整合ApsectJ的方式进行AOP开发。
步骤2:定义接口与实现类
环境准备的时候BookDaoImpl已经准备好不需要做任何修改步骤3:定义通知类和通知
通知就是将共性功能抽取出来后形成的方法共性功能指的就是当前系统时间的打印。
public class MyAdvice {public void method(){System.out.println(System.currentTimeMillis());}
}类名和方法名没有要求可以任意。
步骤4:定义切入点
BookDaoImpl中有两个方法分别是save和update我们要增强的是update方法该如何定义呢?
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}public void method(){System.out.println(System.currentTimeMillis());}
}说明:
切入点定义依托一个不具有实际意义的方法进行即无参数、无返回值、方法体无实际逻辑。execution及后面编写的内容后面会有章节专门去学习。
步骤5:制作切面
切面是用来描述通知和切入点之间的关系如何进行关系的绑定?
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Before(pt())public void method(){System.out.println(System.currentTimeMillis());}
}绑定切入点与通知关系并指定通知添加到原始连接点的具体执行位置 说明:Before翻译过来是之前也就是说通知会在切入点方法执行之前执行除此之前还有其他四种类型后面会讲。
步骤6:将通知类配给容器并标识其为切面类
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Before(pt())public void method(){System.out.println(System.currentTimeMillis());}
}步骤7:开启注解格式AOP功能
Configuration
ComponentScan(com.lystar)
EnableAspectJAutoProxy
public class SpringConfig {
}步骤8:运行程序
public class App {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao ctx.getBean(BookDao.class);bookDao.update();}
}看到在执行update方法之前打印了系统时间戳说明对原始方法进行了增强AOP编程成功。 知识点1EnableAspectJAutoProxy
名称EnableAspectJAutoProxy类型配置类注解位置配置类定义上方作用开启注解格式AOP功能
知识点2Aspect
名称Aspect类型类注解位置切面类定义上方作用设置当前类为AOP切面类
知识点3Pointcut
名称Pointcut类型方法注解位置切入点方法定义上方作用设置切入点方法属性value默认切入点表达式
知识点4Before
名称Before类型方法注解位置通知方法定义上方作用设置当前通知方法与切入点之间的绑定关系当前通知方法在原始切入点方法前运行
3AOP工作流程
AOP的入门案例已经完成对于刚才案例的执行过程我们就得来分析分析这一节我们主要讲解两个知识点:AOP工作流程和AOP核心概念。其中核心概念是对前面核心概念的补充。
3.1 AOP工作流程
由于AOP是基于Spring容器管理的bean做的增强所以整个工作过程需要从Spring加载bean说起:
流程1:Spring容器启动
容器启动就需要去加载bean,哪些类需要被加载呢?需要被增强的类如:BookServiceImpl通知类如:MyAdvice注意此时bean对象还没有创建成功
流程2:读取所有切面配置中的切入点 上面这个例子中有两个切入点的配置但是第一个ptx()并没有被使用所以不会被读取。
流程3:初始化bean
判定bean对应的类中的方法是否匹配到任意切入点 注意第1步在容器启动的时候bean对象还没有被创建成功。 要被实例化bean对象的类中的方法和切入点进行匹配 匹配失败创建原始对象,如UserDao 匹配失败说明不需要增强直接调用原始对象的方法即可。 匹配成功创建原始对象目标对象的代理对象,如:BookDao 匹配成功说明需要对其进行增强对哪个类做增强这个类对应的对象就叫做目标对象因为要对目标对象进行功能增强而采用的技术是动态代理所以会为其创建一个代理对象最终运行的是代理对象的方法在该方法中会对原始方法进行功能增强
流程4:获取bean执行方法
获取的bean是原始对象时调用方法并执行完成操作获取的bean是代理对象时根据代理对象的运行模式运行原始方法与增强的内容完成操作
验证容器中是否为代理对象
为了验证IOC容器中创建的对象和我们刚才所说的结论是否一致首先先把结论理出来:
如果目标对象中的方法会被增强那么容器中将存入的是目标对象的代理对象如果目标对象中的方法不被增强那么容器中将存入的是目标对象本身。
验证思路 1.要执行的方法不被定义的切入点包含即不要增强打印当前类的getClass()方法 2.要执行的方法被定义的切入点包含即要增强打印出当前类的getClass()方法 3.观察两次打印的结果 步骤1:修改App类,获取类的类型
public class App {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao ctx.getBean(BookDao.class);System.out.println(bookDao);System.out.println(bookDao.getClass());}
}步骤2:修改MyAdvice类不增强
因为定义的切入点中被修改成update1,所以BookDao中的update方法在执行的时候就不会被增强
所以容器中的对象应该是目标对象本身。
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update1()))private void pt(){}Before(pt())public void method(){System.out.println(System.currentTimeMillis());}
}步骤3:运行程序
步骤4:修改MyAdvice类增强
因为定义的切入点中被修改成update,所以BookDao中的update方法在执行的时候就会被增强
所以容器中的对象应该是目标对象的代理对象
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Before(pt())public void method(){System.out.println(System.currentTimeMillis());}
}步骤5:运行程序 至此对于刚才的结论我们就得到了验证这块大家需要注意的是:
不能直接打印对象从上面两次结果中可以看出直接打印对象走的是对象的toString方法不管是不是代理对象打印的结果都是一样的原因是内部对toString方法进行了重写。
3.2 AOP核心概念
在上面介绍AOP的工作流程中我们提到了两个核心概念分别是:
目标对象(Target)原始功能去掉共性功能对应的类产生的对象这种对象是无法直接完成最终工作的代理(Proxy)目标对象无法直接完成工作需要对其进行功能回填通过原始对象的代理对象实现
上面这两个概念比较抽象简单来说
目标对象就是要增强的类[如:BookServiceImpl类]对应的对象也叫原始对象不能说它不能运行只能说它在运行的过程中对于要增强的内容是缺失的。
SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的它的底层采用的是代理模式实现的所以要对原始对象进行增强就需要对原始对象创建代理对象在代理对象中的方法把通知[如:MyAdvice中的method方法]内容加进去就实现了增强,这就是我们所说的代理(Proxy)。
小结
通过这一节中我们需要掌握的内容有
能说出AOP的工作流程AOP的核心概念 目标对象、连接点、切入点通知类、通知切面代理 SpringAOP的本质或者可以说底层实现是通过代理模式。
4AOP配置管理
4.1 AOP切入点表达式
前面的案例中有涉及到如下内容: 对于AOP中切入点表达式我们总共会学习三个内容分别是语法格式、通配符和书写技巧。
4.1.1 语法格式
首先我们先要明确两个概念:
切入点:要进行增强的方法切入点表达式:要进行增强的方法的描述方式
对于切入点的描述我们其实是有两中方式的先来看下前面的例子 描述方式一执行com.lystar.dao包下的BookDao接口中的无参数update方法
execution(void com.lystar.dao.BookDao.update())描述方式二执行com.lystar.dao.impl包下的BookDaoImpl类中的无参数update方法
execution(void com.lystar.dao.impl.BookDaoImpl.update())因为调用接口方法的时候最终运行的还是其实现类的方法所以上面两种描述方式都是可以的。
对于切入点表达式的语法为:
切入点表达式标准格式动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名
对于这个格式我们不需要硬记通过一个例子理解它:
execution(public User com.lystar.service.UserService.findById(int))execution动作关键字描述切入点的行为动作例如execution表示执行到指定切入点public:访问修饰符,还可以是publicprivate等可以省略User返回值写返回值类型com.lystar.service包名多级包使用点连接UserService:类/接口名称findById方法名int:参数直接写参数的类型多个类型用逗号隔开异常名方法定义中抛出指定异常可以省略
切入点表达式就是要找到需要增强的方法所以它就是对一个具体方法的描述但是方法的定义会有很多所以如果每一个方法对应一个切入点表达式想想这块就会觉得将来编写起来会比较麻烦有没有更简单的方式呢?
就需要用到下面所学习的通配符。
4.1.2 通配符
我们使用通配符描述切入点主要的目的就是简化之前的配置具体都有哪些通配符可以使用? *:单个独立的任意符号可以独立出现也可以作为前缀或者后缀的匹配符出现 executionpublic * com.lystar.*.UserService.find*(*))匹配com.lystar包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法 ..多个连续的任意符号可以独立出现常用于简化包名与参数的书写 executionpublic User com..UserService.findById(..))匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法 专用于匹配子类类型 execution(* *..*Service.*(..))这个使用率较低描述子类的咱们做JavaEE开发继承机会就一次使用都很慎重所以很少用它。*Service表示所有以Service结尾的接口的子类。
接下来我们把案例中使用到的切入点表达式来分析下: execution(void com.lystar.dao.BookDao.update())
匹配接口能匹配到
execution(void com.lystar.dao.impl.BookDaoImpl.update())
匹配实现类能匹配到
execution(* com.lystar.dao.impl.BookDaoImpl.update())
返回值任意能匹配到
execution(* com.lystar.dao.impl.BookDaoImpl.update(*))
返回值任意但是update方法必须要有一个参数无法匹配要想匹配需要在update接口和实现类添加参数
execution(void com.*.*.*.*.update())
返回值为void,com包下的任意包三层包下的任意类的update方法匹配到的是实现类能匹配
execution(void com.*.*.*.update())
返回值为void,com包下的任意两层包下的任意类的update方法匹配到的是接口能匹配
execution(void *..update())
返回值为void方法名是update的任意包下的任意类能匹配
execution(* *..*(..))
匹配项目中任意类的任意方法能匹配但是不建议使用这种方式影响范围广
execution(* *..u*(..))
匹配项目中任意包任意类下只要以u开头的方法update方法能满足能匹配
execution(* *..*e(..))
匹配项目中任意包任意类下只要以e结尾的方法update和save方法能满足能匹配
execution(void com..*())
返回值为voidcom包下的任意包任意类任意方法能匹配*代表的是方法
execution(* com.lystar.*.*Service.find*(..))
将项目中所有业务层方法的以find开头的方法匹配
execution(* com.lystar.*.*Service.save*(..))
将项目中所有业务层方法的以save开头的方法匹配后面两种更符合我们平常切入点表达式的编写规则
4.1.3 书写技巧
对于切入点表达式的编写其实是很灵活的那么在编写的时候有没有什么好的技巧让我们用用:
所有代码按照标准规范开发否则以下技巧全部失效描述切入点通**常描述接口**而不描述实现类,如果描述到实现类就出现紧耦合了访问控制修饰符针对接口开发均采用public描述可省略访问控制修饰符描述返回值类型对于增删改类使用精准类型加速匹配对于查询类使用*通配快速描述包名书写尽量不使用…匹配效率过低常用*做单个包描述匹配或精准匹配接口名/类名书写名称与模块相关的采用*匹配例如UserService书写成*Service绑定业务层接口名方法名书写以动词进行精准匹配名词采用匹配例如getById书写成getBy,selectAll书写成selectAll参数规则较为复杂根据业务方法灵活调整通常**不使用异常作为匹配**规则
4.2 AOP通知类型
前面的案例中有涉及到如下内容: 它所代表的含义是将通知添加到切入点方法执行的前面。
除了这个注解外还有没有其他的注解换个问题就是除了可以在前面加能不能在其他的地方加?
4.2.1 类型介绍
我们先来回顾下AOP通知:
AOP通知描述了抽取的共性功能根据共性功能抽取的位置不同最终运行代码时要将其加入到合理的位置
通知具体要添加到切入点的哪里?
共提供了5种通知类型:
前置通知后置通知环绕通知(重点)返回后通知(了解)抛出异常后通知(了解)
为了更好的理解这几种通知类型我们来看一张图 (1)前置通知追加功能到方法执行前,类似于在代码1或者代码2添加内容
(2)后置通知,追加功能到方法执行后,不管方法执行的过程中有没有抛出异常都会执行类似于在代码5添加内容
(3)返回后通知,追加功能到方法执行后只有方法正常执行结束后才进行,类似于在代码3添加内容如果方法执行抛出异常返回后通知将不会被添加
(4)抛出异常后通知,追加功能到方法抛出异常后只有方法执行出异常才进行,类似于在代码4添加内容只有方法抛出异常后才会被添加
(5)环绕通知,环绕通知功能比较强大它可以追加功能到方法执行的前后这也是比较常用的方式它可以实现其他四种通知类型的功能具体是如何实现的需要我们往下学习。
4.2.2 环境准备 创建一个Maven项目 pom.xml添加Spring依赖 dependenciesdependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion5.2.10.RELEASE/version/dependencydependencygroupIdorg.aspectj/groupIdartifactIdaspectjweaver/artifactIdversion1.9.4/version/dependency
/dependencies添加BookDao和BookDaoImpl类 public interface BookDao {public void update();public int select();
}Repository
public class BookDaoImpl implements BookDao {public void update(){System.out.println(book dao update ...);}public int select() {System.out.println(book dao select is running ...);return 100;}
}创建Spring的配置类 Configuration
ComponentScan(com.lystar)
EnableAspectJAutoProxy
public class SpringConfig {
}创建通知类 Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}public void before() {System.out.println(before advice ...);}public void after() {System.out.println(after advice ...);}public void around(){System.out.println(around before advice ...);System.out.println(around after advice ...);}public void afterReturning() {System.out.println(afterReturning advice ...);}public void afterThrowing() {System.out.println(afterThrowing advice ...);}
}编写App运行类 public class App {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao ctx.getBean(BookDao.class);bookDao.update();}
}4.2.3 通知类型的使用
前置通知
修改MyAdvice,在before方法上添加Before注解
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Before(pt())//此处也可以写成 Before(MyAdvice.pt()),不建议public void before() {System.out.println(before advice ...);}
}后置通知
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Before(pt())public void before() {System.out.println(before advice ...);}After(pt())public void after() {System.out.println(after advice ...);}
}环绕通知
基本使用
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Around(pt())public void around(){System.out.println(around before advice ...);System.out.println(around after advice ...);}
}运行结果中通知的内容打印出来但是原始方法的内容却没有被执行。
因为环绕通知需要在原始方法的前后进行增强所以环绕通知就必须要能对原始操作进行调用具体如何实现?
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Around(pt())public void around(ProceedingJoinPoint pjp) throws Throwable{System.out.println(around before advice ...);//表示对原始操作的调用pjp.proceed();System.out.println(around after advice ...);}
}**说明:**proceed()为什么要抛出异常?
原因很简单看下源码就知道了 再次运行程序可以看到原始方法已经被执行了 注意事项
(1)原始方法有返回值的处理
修改MyAdvice,对BookDao中的select方法添加环绕通知
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Pointcut(execution(int com.lystar.dao.BookDao.select()))private void pt2(){}Around(pt2())public void aroundSelect(ProceedingJoinPoint pjp) throws Throwable {System.out.println(around before advice ...);//表示对原始操作的调用pjp.proceed();System.out.println(around after advice ...);}
}修改App类调用select方法
public class App {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao ctx.getBean(BookDao.class);int num bookDao.select();System.out.println(num);}
}运行后会报错错误内容为:
Exception in thread “main” org.springframework.aop.AopInvocationException: Null return value from advice does not match primitive return type for: public abstract int com.lystar.dao.BookDao.select() at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:226) at com.sun.proxy.$Proxy19.select(Unknown Source) at com.lystar.App.main(App.java:12)
错误大概的意思是:空的返回不匹配原始方法的int返回
void就是返回Null原始方法就是BookDao下的select方法
所以如果我们使用环绕通知的话要根据原始方法的返回值来设置环绕通知的返回值具体解决方案为:
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Pointcut(execution(int com.lystar.dao.BookDao.select()))private void pt2(){}Around(pt2())public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {System.out.println(around before advice ...);//表示对原始操作的调用Object ret pjp.proceed();System.out.println(around after advice ...);return ret;}
}说明:
为什么返回的是Object而不是int的主要原因是Object类型更通用。
在环绕通知中是可以对原始方法返回值就行修改的。
返回后通知
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Pointcut(execution(int com.lystar.dao.BookDao.select()))private void pt2(){}AfterReturning(pt2())public void afterReturning() {System.out.println(afterReturning advice ...);}
}**注意**返回后通知是需要在原始方法select正常执行后才会被执行如果select()方法执行的过程中出现了异常那么返回后通知是不会被执行。后置通知是不管原始方法有没有抛出异常都会被执行。这个案例大家下去可以自己练习验证下。
异常后通知
Component
Aspect
public class MyAdvice {Pointcut(execution(void com.lystar.dao.BookDao.update()))private void pt(){}Pointcut(execution(int com.lystar.dao.BookDao.select()))private void pt2(){}AfterReturning(pt2())public void afterThrowing() {System.out.println(afterThrowing advice ...);}
}**注意**异常后通知是需要原始方法抛出异常可以在select()方法中添加一行代码int i 1/0即可。如果没有抛异常异常后通知将不会被执行。
学习完这5种通知类型我们来思考下环绕通知是如何实现其他通知类型的功能的?
因为环绕通知是可以控制原始方法执行的所以我们把增强的代码写在调用原始方法的不同位置就可以实现不同的通知类型的功能如: 通知类型总结
知识点1After
名称After类型方法注解位置通知方法定义上方作用设置当前通知方法与切入点之间的绑定关系当前通知方法在原始切入点方法后运行
知识点2AfterReturning
名称AfterReturning类型方法注解位置通知方法定义上方作用设置当前通知方法与切入点之间绑定关系当前通知方法在原始切入点方法正常执行完毕后执行
知识点3AfterThrowing
名称AfterThrowing类型方法注解位置通知方法定义上方作用设置当前通知方法与切入点之间绑定关系当前通知方法在原始切入点方法运行抛出异常后执行
知识点4Around
名称Around类型方法注解位置通知方法定义上方作用设置当前通知方法与切入点之间的绑定关系当前通知方法在原始切入点方法前后运行
环绕通知注意事项
环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用进而实现原始方法调用前后同时添加通知通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行对原始方法的调用可以不接收返回值通知方法设置成void即可如果接收返回值最好设定为Object类型原始方法的返回值如果是void类型通知方法的返回值类型可以设置成void,也可以设置成Object由于无法预知原始方法运行后是否会抛出异常因此环绕通知方法必须要处理Throwable异常
介绍完这么多种通知类型具体该选哪一种呢?
我们可以通过一些案例加深下对通知类型的学习。
4.3 业务层接口执行效率
4.3.1 需求分析
这个需求也比较简单前面我们在介绍AOP的时候已经演示过:
需求:任意业务层接口执行均可显示其执行效率执行时长
这个案例的目的是查看每个业务层执行的时间这样就可以监控出哪个业务比较耗时将其查找出来方便优化。
具体实现的思路:
(1) 开始执行方法之前记录一个时间
(2) 执行方法
(3) 执行完方法之后记录一个时间
(4) 用后一个时间减去前一个时间的差值就是我们需要的结果。
所以要在方法执行的前后添加业务经过分析我们将采用环绕通知。
**说明:**原始方法如果只执行一次时间太快两个时间差可能为0所以我们要执行万次来计算时间差。
4.3.2 环境准备 创建一个Maven项目 pom.xml添加Spring依赖 dependenciesdependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion5.2.10.RELEASE/version/dependencydependencygroupIdorg.springframework/groupIdartifactIdspring-jdbc/artifactIdversion5.2.10.RELEASE/version/dependencydependencygroupIdorg.springframework/groupIdartifactIdspring-test/artifactIdversion5.2.10.RELEASE/version/dependencydependencygroupIdorg.aspectj/groupIdartifactIdaspectjweaver/artifactIdversion1.9.4/version/dependencydependencygroupIdmysql/groupIdartifactIdmysql-connector-java/artifactIdversion5.1.47/version/dependencydependencygroupIdcom.alibaba/groupIdartifactIddruid/artifactIdversion1.1.16/version/dependencydependencygroupIdorg.mybatis/groupIdartifactIdmybatis/artifactIdversion3.5.6/version/dependencydependencygroupIdorg.mybatis/groupIdartifactIdmybatis-spring/artifactIdversion1.3.0/version/dependencydependencygroupIdjunit/groupIdartifactIdjunit/artifactIdversion4.12/versionscopetest/scope/dependency/dependencies添加AccountService、AccountServiceImpl、AccountDao与Account类 public interface AccountService {void save(Account account);void delete(Integer id);void update(Account account);ListAccount findAll();Account findById(Integer id);
}Service
public class AccountServiceImpl implements AccountService {Autowiredprivate AccountDao accountDao;public void save(Account account) {accountDao.save(account);}public void update(Account account){accountDao.update(account);}public void delete(Integer id) {accountDao.delete(id);}public Account findById(Integer id) {return accountDao.findById(id);}public ListAccount findAll() {return accountDao.findAll();}
}
public interface AccountDao {Insert(insert into tbl_account(name,money)values(#{name},#{money}))void save(Account account);Delete(delete from tbl_account where id #{id} )void delete(Integer id);Update(update tbl_account set name #{name} , money #{money} where id #{id} )void update(Account account);Select(select * from tbl_account)ListAccount findAll();Select(select * from tbl_account where id #{id} )Account findById(Integer id);
}public class Account implements Serializable {private Integer id;private String name;private Double money;//setter..getter..toString方法省略
}resources下提供一个jdbc.properties jdbc.drivercom.mysql.jdbc.Driver
jdbc.urljdbc:mysql://localhost:3306/spring_db?useSSLfalse
jdbc.usernameroot
jdbc.passwordroot创建相关配置类 //Spring配置类:SpringConfig
Configuration
ComponentScan(com.lystar)
PropertySource(classpath:jdbc.properties)
Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
//JdbcConfig配置类
public class JdbcConfig {Value(${jdbc.driver})private String driver;Value(${jdbc.url})private String url;Value(${jdbc.username})private String userName;Value(${jdbc.password})private String password;Beanpublic DataSource dataSource(){DruidDataSource ds new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(userName);ds.setPassword(password);return ds;}
}
//MybatisConfig配置类
public class MybatisConfig {Beanpublic SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){SqlSessionFactoryBean ssfb new SqlSessionFactoryBean();ssfb.setTypeAliasesPackage(com.lystar.domain);ssfb.setDataSource(dataSource);return ssfb;}Beanpublic MapperScannerConfigurer mapperScannerConfigurer(){MapperScannerConfigurer msc new MapperScannerConfigurer();msc.setBasePackage(com.lystar.dao);return msc;}
} 编写Spring整合Junit的测试类 RunWith(SpringJUnit4ClassRunner.class)
ContextConfiguration(classes SpringConfig.class)
public class AccountServiceTestCase {Autowiredprivate AccountService accountService;Testpublic void testFindById(){Account ac accountService.findById(2);}Testpublic void testFindAll(){ListAccount all accountService.findAll();}}最终创建好的项目结构如下: 4.3.3 功能开发
步骤1:开启SpringAOP的注解功能
在Spring的主配置文件SpringConfig类中添加注解
EnableAspectJAutoProxy步骤2:创建AOP的通知类 该类要被Spring管理需要添加Component 要标识该类是一个AOP的切面类需要添加Aspect 配置切入点表达式需要添加一个方法并添加Pointcut
Component
Aspect
public class ProjectAdvice {//配置业务层的所有方法Pointcut(execution(* com.lystar.service.*Service.*(..)))private void servicePt(){}public void runSpeed(){}
}步骤3:添加环绕通知
在runSpeed()方法上添加Around
Component
Aspect
public class ProjectAdvice {//配置业务层的所有方法Pointcut(execution(* com.lystar.service.*Service.*(..)))private void servicePt(){}//Around(ProjectAdvice.servicePt()) 可以简写为下面的方式Around(servicePt())public Object runSpeed(ProceedingJoinPoint pjp){Object ret pjp.proceed();return ret;}
}**注意:**目前并没有做任何增强
步骤4:完成核心业务记录万次执行的时间
Component
Aspect
public class ProjectAdvice {//配置业务层的所有方法Pointcut(execution(* com.lystar.service.*Service.*(..)))private void servicePt(){}//Around(ProjectAdvice.servicePt()) 可以简写为下面的方式Around(servicePt())public void runSpeed(ProceedingJoinPoint pjp){long start System.currentTimeMillis();for (int i 0; i 10000; i) {pjp.proceed();}long end System.currentTimeMillis();System.out.println(业务层接口万次执行时间: (end-start)ms);}
}步骤5:运行单元测试类 **注意:**因为程序每次执行的时长是不一样的所以运行多次最终的结果是不一样的。
步骤6:程序优化
目前程序所面临的问题是多个方法一起执行测试的时候控制台都打印的是:
业务层接口万次执行时间:xxxms
我们没有办法区分到底是哪个接口的哪个方法执行的具体时间具体如何优化?
Component
Aspect
public class ProjectAdvice {//配置业务层的所有方法Pointcut(execution(* com.lystar.service.*Service.*(..)))private void servicePt(){}//Around(ProjectAdvice.servicePt()) 可以简写为下面的方式Around(servicePt())public void runSpeed(ProceedingJoinPoint pjp){//获取执行签名信息Signature signature pjp.getSignature();//通过签名获取执行操作名称(接口名)String className signature.getDeclaringTypeName();//通过签名获取执行操作名称(方法名)String methodName signature.getName();long start System.currentTimeMillis();for (int i 0; i 10000; i) {pjp.proceed();}long end System.currentTimeMillis();System.out.println(万次执行 className.methodName---- (end-start) ms);}
}步骤7:运行单元测试类 补充说明
当前测试的接口执行效率仅仅是一个理论值并不是一次完整的执行过程。
这块只是通过该案例把AOP的使用进行了学习具体的实际值是有很多因素共同决定的。
4.4 AOP通知获取数据
目前我们写AOP仅仅是在原始方法前后追加一些操作接下来我们要说说AOP中数据相关的内容我们将从获取参数、获取返回值和获取异常三个方面来研究切入点的相关信息。
前面我们介绍通知类型的时候总共讲了五种那么对于这五种类型都会有参数返回值和异常吗?
我们先来一个个分析下:
获取切入点方法的参数所有的通知类型都可以获取参数 JoinPoint适用于前置、后置、返回后、抛出异常后通知ProceedingJoinPoint适用于环绕通知 获取切入点方法返回值前置和抛出异常后通知是没有返回值后置通知可有可无所以不做研究 返回后通知环绕通知 获取切入点方法运行异常信息前置和返回后通知是不会有后置通知可有可无所以不做研究 抛出异常后通知环绕通知
4.4.1 环境准备 创建一个Maven项目 pom.xml添加Spring依赖 dependenciesdependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion5.2.10.RELEASE/version/dependencydependencygroupIdorg.aspectj/groupIdartifactIdaspectjweaver/artifactIdversion1.9.4/version/dependency/dependencies添加BookDao和BookDaoImpl类 public interface BookDao {public String findName(int id);
}
Repository
public class BookDaoImpl implements BookDao {public String findName(int id) {System.out.println(id:id);return itcast;}
}创建Spring的配置类 Configuration
ComponentScan(com.lystar)
EnableAspectJAutoProxy
public class SpringConfig {
}编写通知类 Component
Aspect
public class MyAdvice {Pointcut(execution(* com.lystar.dao.BookDao.findName(..)))private void pt(){}Before(pt())public void before() {System.out.println(before advice ... );}After(pt())public void after() {System.out.println(after advice ...);}Around(pt())public Object around() throws Throwable{Object ret pjp.proceed();return ret;}AfterReturning(pt())public void afterReturning() {System.out.println(afterReturning advice ...);}AfterThrowing(pt())public void afterThrowing() {System.out.println(afterThrowing advice ...);}
}编写App运行类 public class App {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao ctx.getBean(BookDao.class);String name bookDao.findName(100);System.out.println(name);}
}最终创建好的项目结构如下: 4.4.2 获取参数
非环绕通知获取方式
在方法上添加JoinPoint,通过JoinPoint来获取参数
Component
Aspect
public class MyAdvice {Pointcut(execution(* com.lystar.dao.BookDao.findName(..)))private void pt(){}Before(pt())public void before(JoinPoint jp) Object[] args jp.getArgs();System.out.println(Arrays.toString(args));System.out.println(before advice ... );}//...其他的略
}运行App类可以获取如下内容说明参数100已经被获取 思考:方法的参数只有一个为什么获取的是一个数组?
因为参数的个数是不固定的所以使用数组更通配些。
如果将参数改成两个会是什么效果呢?
(1)修改BookDao接口和BookDaoImpl实现类
public interface BookDao {public String findName(int id,String password);
}
Repository
public class BookDaoImpl implements BookDao {public String findName(int id,String password) {System.out.println(id:id);return itcast;}
}(2)修改App类调用方法传入多个参数
public class App {public static void main(String[] args) {ApplicationContext ctx new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao ctx.getBean(BookDao.class);String name bookDao.findName(100,lystar);System.out.println(name);}
}(3)运行App查看结果,说明两个参数都已经被获取到 说明:
使用JoinPoint的方式获取参数适用于前置、后置、返回后、抛出异常后通知。剩下的大家自行去验证。
环绕通知获取方式
环绕通知使用的是ProceedingJoinPoint因为ProceedingJoinPoint是JoinPoint类的子类所以对于ProceedingJoinPoint类中应该也会有对应的getArgs()方法我们去验证下:
Component
Aspect
public class MyAdvice {Pointcut(execution(* com.lystar.dao.BookDao.findName(..)))private void pt(){}Around(pt())public Object around(ProceedingJoinPoint pjp)throws Throwable {Object[] args pjp.getArgs();System.out.println(Arrays.toString(args));Object ret pjp.proceed();return ret;}//其他的略
}运行App后查看运行结果说明ProceedingJoinPoint也是可以通过getArgs()获取参数 注意: pjp.proceed()方法是有两个构造方法分别是: 调用无参数的proceed当原始方法有参数会在调用的过程中自动传入参数 所以调用这两个方法的任意一个都可以完成功能 但是当需要修改原始方法的参数时就只能采用带有参数的方法,如下: Component
Aspect
public class MyAdvice {Pointcut(execution(* com.lystar.dao.BookDao.findName(..)))private void pt(){}Around(pt())public Object around(ProceedingJoinPoint pjp) throws Throwable{Object[] args pjp.getArgs();System.out.println(Arrays.toString(args));args[0] 666;Object ret pjp.proceed(args);return ret;}//其他的略
}有了这个特性后我们就可以在环绕通知中对原始方法的参数进行拦截过滤避免由于参数的问题导致程序无法正确运行保证代码的健壮性。
4.4.3 获取返回值
对于返回值只有返回后AfterReturing和环绕Around这两个通知类型可以获取具体如何获取?
环绕通知获取返回值
Component
Aspect
public class MyAdvice {Pointcut(execution(* com.lystar.dao.BookDao.findName(..)))private void pt(){}Around(pt())public Object around(ProceedingJoinPoint pjp) throws Throwable{Object[] args pjp.getArgs();System.out.println(Arrays.toString(args));args[0] 666;Object ret pjp.proceed(args);return ret;}//其他的略
}上述代码中ret就是方法的返回值我们是可以直接获取不但可以获取如果需要还可以进行修改。
返回后通知获取返回值
Component
Aspect
public class MyAdvice {Pointcut(execution(* com.lystar.dao.BookDao.findName(..)))private void pt(){}AfterReturning(value pt(),returning ret)public void afterReturning(Object ret) {System.out.println(afterReturning advice ...ret);}//其他的略
}注意:
(1)参数名的问题 (2)afterReturning方法参数类型的问题
参数类型可以写成String但是为了能匹配更多的参数类型建议写成Object类型
(3)afterReturning方法参数的顺序问题 运行App后查看运行结果说明返回值已经被获取到 4.4.4 获取异常
对于获取抛出的异常只有抛出异常后AfterThrowing和环绕Around这两个通知类型可以获取具体如何获取?
环绕通知获取异常
这块比较简单以前我们是抛出异常现在只需要将异常捕获就可以获取到原始方法的异常信息了
Component
Aspect
public class MyAdvice {Pointcut(execution(* com.lystar.dao.BookDao.findName(..)))private void pt(){}Around(pt())public Object around(ProceedingJoinPoint pjp){Object[] args pjp.getArgs();System.out.println(Arrays.toString(args));args[0] 666;Object ret null;try{ret pjp.proceed(args);}catch(Throwable throwable){t.printStackTrace();}return ret;}//其他的略
}在catch方法中就可以获取到异常至于获取到异常以后该如何处理这个就和你的业务需求有关了。
抛出异常后通知获取异常
Component
Aspect
public class MyAdvice {Pointcut(execution(* com.lystar.dao.BookDao.findName(..)))private void pt(){}AfterThrowing(value pt(),throwing t)public void afterThrowing(Throwable t) {System.out.println(afterThrowing advice ...t);}//其他的略
}如何让原始方法抛出异常方式有很多
Repository
public class BookDaoImpl implements BookDao {public String findName(int id,String password) {System.out.println(id:id);if(true){throw new NullPointerException();}return itcast;}
}注意: 运行App后查看控制台就能看的异常信息被打印到控制台 至此AOP通知如何获取数据就已经讲解完了数据中包含参数、返回值、异常(了解)。
5AOP总结
AOP的知识就已经讲解完了接下来对于AOP的知识进行一个总结:
5.1 AOP的核心概念
概念AOP(Aspect Oriented Programming)面向切面编程一种编程范式作用在不惊动原始设计的基础上为方法进行功能增强核心概念 代理ProxySpringAOP的核心本质是采用代理模式实现的连接点JoinPoint在SpringAOP中理解为任意方法的执行切入点Pointcut匹配连接点的式子也是具有共性功能的方法描述通知Advice若干个方法的共性功能在切入点处执行最终体现为一个方法切面Aspect描述通知与切入点的对应关系目标对象Target被代理的原始对象成为目标对象
5.2 切入点表达式 切入点表达式标准格式动作关键字(访问修饰符 返回值 包名.类/接口名.方法名参数异常名) execution(* com.lystar.service.*Service.*(..))切入点表达式描述通配符 作用用于快速描述范围描述*匹配任意符号常用.. 匹配多个连续的任意符号常用匹配子类类型 切入点表达式书写技巧 1.按标准规范开发 2.查询操作的返回值建议使用*匹配 3.减少使用…的形式描述包 4.对接口进行描述使用*表示模块名例如UserService的匹配描述为*Service 5.方法名书写保留动词例如get使用*表示名词例如getById匹配描述为getBy* 6.参数根据实际情况灵活调整
5.3 五种通知类型
前置通知后置通知环绕通知重点 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用环绕通知可以隔离原始方法的调用执行环绕通知返回值设置为Object类型环绕通知中可以对原始方法调用过程中出现的异常进行处理 返回后通知抛出异常后通知
5.4 通知中获取参数
获取切入点方法的参数所有的通知类型都可以获取参数 JoinPoint适用于前置、后置、返回后、抛出异常后通知ProceedingJoinPoint适用于环绕通知 获取切入点方法返回值前置和抛出异常后通知是没有返回值后置通知可有可无所以不做研究 返回后通知环绕通知 获取切入点方法运行异常信息前置和返回后通知是不会有后置通知可有可无所以不做研究 抛出异常后通知环绕通知
