【SSM框架】Spring笔记 --- AOP详解；AspectJ中四种通知的使用
1、面向切面编程AOP
AOP（Aspect Orient Programming），面向切面编程。
切面:公共的，通用的，重复的功能称为切面，面向切面编程就是将切面提取出来，单独开发，在需要调用的方法中通过动态代理的方式进行织入。
2、AOP框架的"进化"
1)第一个版本:业务和切面紧耦合在一起，没有拆分.
2)第二个版本:使用子类代理的方式拆分业务和切面.
3)第三个版本:使用静态代理拆分业务和切面.业务和业务接口已拆分.此时切面紧耦合在业务中
4)第四个版本:使用静态代理拆分业务和业务接口，切面和切面接口.
5)第五个版本:使用动态代理完成第四个版本的优化.
3、Spring支持的AOP的实现
Spring支持AOP的编程，常用的有以下几种：
1)Before通知：在目标方法被调用前调用，涉及接口为 org.springframework.aop.MethodBeforeAdvice
2)After通知：在目标方法被调用后调用，涉及接口为 org.springframework.aop.AfterReturningAdvice
3)Throws通知：在目标方法抛出异常时调用，涉及接口为 org.springframework.aop.ThrowsAdvice
4)Around通知：拦截对目标对象方法调用，涉及接口为 org.aopalliance.intercept.MethodInterceptor
4、AOP常用的术语
1)切面:就是那些重复的，公共的，通用的功能称为切面，例如:日志，事务，权限.
2)连接点:就是目标方法.因为在目标方法中要实现目标方法的功能和切面功能.
3)切入点(Pointcut):指定切入的位置，多个连接点构成切入点，切入点可以是一个目标方法，可以是一个类中的所有方法，可以是某个包下的所有类中的方法.
4)目标对象:操作谁，谁就是目标对象.
5)通知(Advice):来指定切入的时机，是在目标方法执行前还是执行后还是出错时，还是环绕目标方法切入切面功能.
5、AspectJ框架
- AspectJ 是一个优秀的面向切面的框架，它扩展了 Java 语言，提供了强大的切面实现。它因为是基于java语言开发的，所以无缝扩展
AspectJ 中常用的通知有四种类型：
1)前置通知@Before
2)后置通知@AfterReturning
3)环绕通知@Around
4)最终通知@After
5)定义切入点@Pointcut(了解)
6、AspectJ 的切入点表达式(掌握)
规范的公式:
- execution(访问权限 方法返回值 方法声明(参数) 异常类型)
可简化为：
- execution( 方法返回值 方法声明(参数) )
用到的符号:
* 代表任意(通配符)
.. 如果出现在方法的参数中，则代表任意参数；如果出现在路径中，则代表本路径及其所有的子路径（其实就相当于路径中的省略号呗）
示例:
//任意的公共方法：
execution(public * *(..))
//任何一个以“set”开始的方法
execution(* set*(..))
//任意的返回值类型，在com.xyz.service.impl包下的任意类的任意方法
execution(* com.xyz.service.impl.*.*(..))
//任意的返回值类型 ，在com.xyz.service及其子包下的任意类的任意方法
execution(* com.xyz.service..*.*(..))
//service之前可以有任意的子包
execution(* *..service.*.*(..))
//service之前只有一个包
execution(* *.service.*.*(..))
7、AspectJ的前置通知@Before：
- 在目标方法执行前切入切面功能，在切面方法中不可以获得目标方法的返回值，只能得到目标方法的签名。
实现的步骤:
1)添加依赖：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
2)创建业务接口
3)创建业务实现
4)创建切面类，实现切面方法
5)在applicationContext.xml文件中进行切面绑定
栗子:
@Aspect //交给AspectJ的框架去识别切面类
@Component
public class MyAspect {
/**
* 所有切面的功能都是由切面方法来实现的
* 可以将各种切面都在此类中进行开发
*
* 前置通知的切面方法的规范
* 1)访问权限是public
* 2)方法的返回值是void
* 3)方法名称自定义
* 4)方法没有参数，如果有也只能是JoinPoint类型
* 5)必须使用@Before注解来声明切入的时机是前切功能和切入点
* 参数:value 指定切入点表达式
*
* 业务方法
* public String doSome(String name， int age)
*/
@Before(value = "execution(public String com.bjpowernode.s01.SomeServiceImpl.*(String，int))")
public void myBefore(){
System.out.println("切面方法中的前置通知功能实现............");
}
@Before(value = "execution(public * com.bjpowernode.s01.SomeServiceImpl.*(..))")
public void myBefore(){
System.out.println("切面方法中的前置通知功能实现............");
}
@Before(value = "execution( * com.bjpowernode.s01.*.*(..))")
public void myBefore(JoinPoint jp){
System.out.println("切面方法中的前置通知功能实现............");
System.out.println("目标方法的签名:"+jp.getSignature());
System.out.println("目标方法的参数:"+ Arrays.toString(jp.getArgs()));
}
@Before(value = "execution( * com.bjpowernode.s01..*(..))")
public void myBefore(){
System.out.println("切面方法中的前置通知功能实现............");
}
@Before(value = "execution( * *(..))")
public void myBefore(){
System.out.println("切面方法中的前置通知功能实现............");
}
}
AspectJ框架切换JDK动态代理和CGLib动态代理：
<!--默认是JDK动态代理，取时必须使用接口类型-->
<aop:aspectj-autoproxy ></aop:aspectj-autoproxy>
<!--设置为CGLib子类代理，可以使用接口和实现类接，记住:使用接口来接，永远不出错-->
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
8、@AfterReturning后置通知：
- 后置通知是在目标方法执行后切入切面功能，可以得到目标方法的返回值.如果目标方法的返回值是简单类型(8种基本类型+String)则不可改变.如果目标方法的返回值是引用类型则可以改变.
@Aspect
@Component
public class MyAspect {
/**
* 后置通知的方法的规范
* 1)访问权限是public
* 2)方法没有返回值void
* 3)方法名称自定义
* 4)方法有参数(也可以没有参数，如果目标方法没有返回值，则可以写无参的方法，但一般会写有参，这样可以处理无参可以处理有参)，这个切面方法的参数就是目标方法的返回值
* 5)使用@AfterReturning注解表明是后置通知
* 参数:
* value:指定切入点表达式
* returning:指定目标方法的返回值的名称，则名称必须与切面方法的参数名称一致.
*/
@AfterReturning(value = "execution(* com.bjpowernode.s02.*.*(..))"，returning = "obj")
public void myAfterReturning(Object obj){
System.out.println("后置通知功能实现..............");
if(obj != null){
if(obj instanceof String){
obj = obj.toString().toUpperCase();
System.out.println("在切面方法中目标方法的返回值:"+obj);
}
if(obj instanceof Student){
Student stu = (Student) obj;
stu.setName("李四");
System.out.println("在切面方法中目标方法的返回值:"+stu);
}
}
}
}
9、环绕通知@Around：
- 它是通过拦截目标方法的方式 ，在目标方法前后增强功能的通知，它是功能最强大的通知，一般事务使用此通知.它可以轻易的改变目标方法的返回值.
@Aspect
@Component
public class MyAspect {
/**
* 环绕通知方法的规范
* 1)访问权限是public
* 2)切面方法有返回值，此返回值就是目标方法的返回值
* 3)方法名称自定义
* 4)方法有参数，此参数就是目标方法
* 5)回避异常Throwable
* 6)使用@Around注解声明是环绕通知
* 参数:
* value:指定切入点表达式
*/
@Around(value = "execution(* com.bjpowernode.s03.*.*(..))")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
//前切功能实现
System.out.println("环绕通知中的前置功能实现............");
//目标方法调用
Object obj = pjp.proceed(pjp.getArgs());
//后切功能实现
System.out.println("环绕通知中的后置功能实现............");
return obj.toString().toUpperCase(); //改变了目标方法的返回值
}
}
10、最终通知@After
无论目标方法是否正常执行，最终通知的代码都会被执行.
@Aspect
@Component
public class MyAspect {
/**
* 最终方法的规范
* 1)访问权限是public
* 2)切面方法没有返回值void
* 3)方法名称自定义
* 4)方法可以没有参数,也可以有,则JoinPoint.
* 5)使用@After注解
* 6)参数:value:指定切入点表达式
*/
@After(value = "execution(* com.bjpowernode.s04.SomeServiceImpl.*(..))")
public void myAfter(){
System.out.println("最终通知被执行.............");
}
}
11、给切入点表达式起别名@Pointcut
如果多个切面切入到同一个切入点，可以使用别名简化开发。使用@Pointcut注解，创建一个空方法，此方法的名称就是别名。
@Aspect
@Component
public class MyAspect {
/**
* 最终通知方法的规范
* 1)访问权限是public
* 2)方法没有返回值
* 3)方法名称自定义
* 4)方法没有参数，如果有也只能是JoinPoint
* 5)使用@After注解表明是最终通知
* 参数:
* value:指定切入点表达式
*/
@After(value = "mycut()")
public void myAfter(){
System.out.println("最终通知的功能........");
}
@Before(value = "mycut()")
public void myBefore(){
System.out.println("前置通知的功能........");
}
@AfterReturning(value = "mycut()"，returning = "obj")
public void myAfterReturning(Object obj){
System.out.println("后置通知的功能........");
}
@Around(value = "mycut()")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("环绕通知中的前置通知的功能........");
Object obj = pjp.proceed(pjp.getArgs());
System.out.println("环绕通知中的后置通知的功能........");
return obj;
}
@Pointcut(value = "execution(* com.bjpowernode.s04.*.*(..))")
public void mycut(){}
}
