【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>&#xA0;
</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> &#xA0;
<!--设置为CGLib子类代理，可以使用接口和实现类接，记住:使用接口来接，永远不出错-->
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy> &#xA0;

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(){}
}

Original: https://www.cnblogs.com/Burning-youth/p/16310931.html
Author: 猿头猿脑的王狗蛋
Title: 【SSM框架】Spring笔记 – AOP详解；AspectJ中四种通知的使用