主要讲解AOP基础知识,然后附加简单的示例。
学习Spring AOP时,开始以为AOP的知识会很多,但是和IOC知识比起来,发现少很多,但是如果放到一篇文章,感觉还是有点长,就分上-下两个部分,来讲解这块知识。
这两天更新的有点慢,感觉身体不太好,可能是早上起太早了,效率不太高,周末会好好休息一下,把状态调整过来。
如果说 IoC 是 Spring 的核心,那么面向切面编程就是 Spring 最为重要的功能之一了。
首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能:
周边功能在 Spring 的面向切面编程AOP思想里,即被定义为切面。在面向切面编程AOP的思想里面,核心业务功能和切面功能分别独立进行开发,然后把切面功能和核心业务功能 "编织" 在一起,这就叫AOP。
AOP能够将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务处理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性。
为了更好地理解 AOP,就需要对 AOP 的相关术语有一些了解,这些专业术语主要包含 Joinpoint、Pointcut、Advice、Target、Weaving、Proxy 和 Aspect,它们的含义如下表所示。
上面的讲解有点抽象,我们再进一步进行讲解:
什么?还是有点蒙圈?可以看看下面这位大神的总结,言简意赅,如果还不懂,那楼哥也没办法了。
切入点(Pointcut):在哪些类,哪些方法上切入(where) 通知(Advice):在方法执行的什么实际(when:方法前/方法后/方法前后)做什么(what:增强的功能) 切面(Aspect):切面 = 切入点 + 通知,通俗点就是:在什么时机,什么地方,做什么增强! 织入(Weaving):把切面加入到对象,并创建出代理对象的过程。(由 Spring 来完成)
学习语言最好的方式就是实战,其它的介绍我们就先不进行,直接看一个具体的使用示例,我们先定义一个实现类:
@Component("customerDao")
public class CustomerDaoImpl {
public void add() {
System.out.println("添加客户...");
}
public void update() {
System.out.println("修改客户...");
}
public void delete() {
System.out.println("删除客户...");
}
public void find() {
System.out.println("修改客户...");
}
}
然后再定义一个切面类:
@Component
public class MyAspect {
// 前置通知
public void myBefore(JoinPoint joinPoint) {
System.out.println("前置通知,方法名称:" + joinPoint.getSignature().getName());
}
// 后置通知
public void myAfterReturning(JoinPoint joinPoint) {
System.out.println("后置通知,方法名称:" + joinPoint.getSignature().getName());
}
// 环绕通知
public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕开始"); // 开始
Object obj = proceedingJoinPoint.proceed(); // 执行当前目标方法
System.out.println("环绕结束"); // 结束
return obj;
}
// 异常通知
public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
System.out.println("异常通知,出错了");
}
// 最终通知
public void myAfter() {
System.out.println("最终通知");
}
}
下面这个非常重要,就是在applicationContext.xml文件中增加相应配置:
<!-- 用于注解扫描 -->
<context:component-scan base-package="com.java.spring.aop.xml2" />
<context:component-scan base-package="com.java.spring.aop.customer" />
<!-- 使切面开启自动代理 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!--AOP 编程 -->
<aop:config>
<aop:aspect ref="myAspect">
<!-- 配置切入点,通知最后增强哪些方法 -->
<aop:pointcut expression="execution (* com.java.spring.aop.customer.*.* (..))" id="myPointCut" />
<!--前置通知,关联通知 Advice和切入点PointCut -->
<aop:before method="myBefore" pointcut-ref="myPointCut" />
<!--后置通知,在方法返回之后执行,就可以获得返回值returning 属性 -->
<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="returnVal" />
<!--环绕通知 -->
<aop:around method="myAround" pointcut-ref="myPointCut" />
<!--抛出通知:用于处理程序发生异常,可以接收当前方法产生的异常 -->
<!-- *注意:如果程序没有异常,则不会执行增强 -->
<!-- * throwing属性:用于设置通知第二个参数的名称,类型Throwable -->
<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e" />
<!--最终通知:无论程序发生任何事情,都将执行 -->
<aop:after method="myAfter" pointcut-ref="myPointCut" />
</aop:aspect>
</aop:config>
这里必须要开启“使切面开启自动代理”,否则AOP不生效,因为我都是通过注解扫描自动注入,所以不要忘记“用于注解扫描”中的内容,因为我的CustomerDaoImpl和MyAspect分别放到xml2和customer这两个包下面,所以需要扫描这两个包。
对于下面这个,我估计很多同学看到这个,第一时间处于蒙圈状态:
execution (* com.java.spring.aop.customer.*.* (..))
这个其实是Spring AOP表达式的写法:
任意公共方法的执行:
execution(public * *(..))
##public可以省略, 第一个* 代表方法的任意返回值 第二个参数代表任意包+类+方法 (..)表示任意参数
任何一个以“get”开始的方法的执行:
execution(* get*(..))
UserService接口的任意方法:
execution(* com.einblatt.service.UserService.*(..))
定义在com.einblatt.service包里的任意方法的执行:
execution(* com.einblatt.service.*.*(..))
#第一个 .* 代表任意类, 第二个 .* 代表任意方法
定义在service包和所有子包里的任意类的任意方法的执行:
execution(* com.einblatt.service..*.*(..))
# ..* 代表任意包或者子包
定义在com.einblatt包和所有子包里的UserService类的任意方法的执行:
execution(* com.einblatt..UserService.*(..))
我们再回顾一下上面的这个表达式,第一个“星号”表示任意返回值,com.java.spring.aop.custome是需要加强对象的包路径,第二个“星号”表示这个包路径下所有的文件,第三个“星号”表示文件中类的所有的方法,最后的两个“..”,表示可以是任意参数。
编辑器不能直接打“*”符号,会被当做排版符号,我就用“星号”代替。
对于applicationContext.xml文件中的其它内容,我们配置了切面myAspect,定义切面的切入点myPointCut,然后针对该切入点,配置了前置、后置、环绕、抛出异常和最终通知等功能,所以我们执行切入点中的方法时,都会通过切面中的方法进行增强,下面的示例:
public class XMLTest {
@Test
public void test() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
CustomerDaoImpl customerDao = (CustomerDaoImpl) applicationContext.getBean("customerDao");
// 执行方法
customerDao.add();
}
}
// 输出:
// 前置通知,方法名称:add
// 环绕开始
// 添加客户...
// 最终通知
// 环绕结束
// 后置通知,方法名称:add
我们的核心方法输出的是“添加客户...”,这里AOP给我们增加了前置通知、环绕通知、最终通知和后置通知,大家可以看一下调用顺序,下面测试一下抛出通知,我们修改CustomerDaoImpl内容如下:
@Component("customerDao")
public class CustomerDaoImpl {
public void add() throws Exception {
System.out.println("添加客户...");
throw new Exception("抛出异常测试");
}
// ...
}
还是通过上面的示例测试,输出结果如下:
前置通知,方法名称:add
环绕开始
添加客户...
最终通知
异常通知,出错了
可以看到抛出异常加强输出“异常通知,出错了”,但是后面的“环绕结束”和“后置通知”就没有了。
通过这个简单的示例,大家应该多AOP有一个初步的了解,这个示例其实是基于AspectJ的XML实现方式。其实JAVA中实现AOP的方式有很多种,下面我们对现有的实现方式,进行一个整体的介绍,让大家有一个宏观的认识。
AOP 采用了两种实现方式:静态织入(AspectJ 实现)和动态代理(Spring AOP实现)
所以准确来说,实现AOP其实有4种实现姿势。
Spring AOP 是通过动态代理技术实现的,而动态代理是基于反射设计的。Spring AOP 采用了两种混合的实现方式:JDK 动态代理和 CGLib 动态代理,分别来理解一下:
因为文章篇幅原因,AOP的4种实现姿势,还有3种未给出示例,我将会在下一篇文章中给出完整的示例描述。
通过这篇文章,你可以掌握AOP的基础知识,以及对AOP的使用有一个初步的认识,目前项目中用的最多的其实是AspectJ基于Annotation的声明,下一篇文章会给出完整的示例,然后对于AOP,我理解内部是通过代理和装饰器模式来实现的,我们也会在下一篇文章中和大家进行探讨。
欢迎大家多多点赞,更多文章,请关注微信公众号“楼仔进阶之路”,点关注,不迷路~~