Spring Aop 详解一

Aop 是一个编程思想，最初是一个理论，最后落地成了很多的技术实现。

我们写一个系统，都希望尽量少写点儿重复的东西。而很多时候呢，又不得不写一些重复的东西。比如访问某些方法的权限，执行某些方法性能的日志，数据库操作的方法进行事务控制。以上提到的，权限的控制，事务控制，性能监控的日志可以叫一个切面。像一个横切面穿过这一些列需要控制的方法。通过aop编程，实现了对切面业务的统一处理。

以上是我对aop的一个总体概括

aop的原始实现

通过动态代理和反射实现，又称之为JDK动态代理

MyInterceptor.java

package demo.aop.jdkproxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

/**

 * 拦截器

 *    1、目标类导入进来

 *    2、事务导入进来

 *    3、invoke完成

 *        1、开启事务

 *        2、调用目标对象的方法

 *        3、事务的提交

 * @author zd

 *

 */

public class MyInterceptor implements InvocationHandler{

    private Object target;//目标类

    private Transaction transaction;

    public MyInterceptor(Object target, Transaction transaction) {

        super();

        this.target = target;

        this.transaction = transaction;

    }

    public Object invoke(Object proxy, Method method, Object[] args)

            throws Throwable {

        String methodName = method.getName();

        if("savePerson".equals(methodName)||"updatePerson".equals(methodName)

                ||"deletePerson".equals(methodName)){

            this.transaction.beginTransaction();//开启事务

            method.invoke(target);//调用目标方法

            this.transaction.commit();//事务的提交

        }else{

            method.invoke(target);

        }

        return null;

    }

}

PersonDao.java

package demo.aop.jdkproxy;

public interface PersonDao {

    public void savePerson();

    public void updatePerson();

}

PersonDaoImpl.java

package demo.aop.jdkproxy;

public class PersonDaoImpl implements PersonDao{

    public void savePerson() {

        System.out.println("save person");

    }

    public void updatePerson() {

        // TODO Auto-generated method stub

        System.out.println("update person");

    }

}

Transaction.java

package demo.aop.jdkproxy;

public class Transaction {

    public void beginTransaction(){

        System.out.println("begin transaction");

    }

    public void commit(){

        System.out.println("commit");

    }

}

JDKProxyTest

package demo.aop.jdkproxy;

import org.junit.Test;

import java.lang.reflect.Proxy;

/**

 * 1、拦截器的invoke方法是在时候执行的？

 *     当在客户端，代理对象调用方法的时候，进入到了拦截器的invoke方法

 * 2、代理对象的方法体的内容是什么？

 *     拦截器的invoke方法的内容就是代理对象的方法的内容

 * 3、拦截器中的invoke方法中的参数method是谁在什么时候传递过来的？

 *     代理对象调用方法的时候，进入了拦截器中的invoke方法，所以invoke方法中的参数method就是

 *       代理对象调用的方法

 * @author zd

 *

 */

public class JDKProxyTest {

    @Test

    public void testJDKProxy(){

        /**

         * 1、创建一个目标对象

         * 2、创建一个事务

         * 3、创建一个拦截器

         * 4、动态产生一个代理对象

         */

        Object target = new PersonDaoImpl();

        Transaction transaction = new Transaction();

        MyInterceptor interceptor = new MyInterceptor(target, transaction);

        /**

         * 1、目标类的类加载器

         * 2、目标类实现的所有的接口

         * 3、拦截器

         */

        PersonDao personDao = (PersonDao) Proxy.newProxyInstance(target.getClass().getClassLoader(),

                target.getClass().getInterfaces(), interceptor);

        //personDao.savePerson();

        personDao.updatePerson();

    }

}

运行结果

begin transaction

update person

commit

原始实现部分，想必现在很少会有人再这么写了。但这个对于我们理解Aop的思想很有帮助。

我们可以看到代理对象 personDao调用的方法updatePerson中没有模拟事务的代码，但最终代理对象却输出了begin transaction和commit

Spring AOP概念核心词

切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用基于模式）或者基于@Aspect注解的方式来实现。
连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。
通知（Advice）：在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知（通知的类型将在后面部分进行讨论）。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。
切入点（Pointcut）：匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
引入（Introduction）：用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制。
目标对象（Target Object）：被一个或者多个切面所通知的对象。也被称做被通知（advised）对象。既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。
AOP代理（AOP Proxy）：AOP框架创建的对象，用来实现切面契约（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
织入（Weaving）：把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

上面为官方文档，有的地方还是很难读懂，毕竟是纯概念。下面我用自己的话来翻译一下，如果有不对的地方，请指正

切面统一处理的业务，比如上文提到的权限控制，事务处理
连接点 原本被执行的方法，一个执行的方法可能被多个切面横切
通知切面方法的执行，比如权限控制的具体执行过程（权限控制可以用前置通知@Before）
切入点 切入点的概念通常和连接点概念容易分不清，切入点其实是一个规则，也就是说什么样的情况下（满足什么规则)，

就会去执行链接点的那些方法,这个规则就是切入点，这种规则用切入点表达式去制定
引入（Introduction） 被代理的对象可以引入新接口，通过默认的实现类，让这个被代理的类增强
目标对象 就是被切面执行了的对象
AOP代理 代理包括jdk代理和cglib代理，是aop底层实现过程
织入就是切面中的方法完成加载执行的过程

这里有8个概念，但真正要完成aop的理解，还不得不再引入两个概念。

被代理对象 我们可以看到，上面说到目标对象永远是一个被代理的对象，也是被通知的对象。
代理对象 代理对象呢，就是最后通知后，生成的对象。

切入点表达式

execution

用于匹配指定类型内的方法执行，匹配的是方法，可以确切到方法

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern (param-pattern)

          throws-pattern?)

modifiers-pattern 修饰符表达式   :public protect private ，可以不写，表示不限制

ret-type-pattern    返回值表达式   如 String代表返回值为String ，*代表任意返回值都可以   必填字段

declaring-type-pattern  类型，可以由完整包名加类名组成   可以只写包名加.*限定包下的所有类   可以不写，表示不限制

name-pattern    方法名表达式，可以由*统配所有字符   必填字段

param-pattern   参数列表，可以用..来表示所有的方法  必填字段

execution(public * * (..))   //所有public的方法

execution(* set*(..))  //所有set开头的方法

execution( * com.xyz.service.AccountService.* (..) ) //AccountService的所有方法，如果AccountService是接口，指实现了这个接口的所有方法

execution(* com.xyz.service.*.*(..)) //com.xyz.service包下的所有类的所有方法

execution(* com.xyz.service..*.*(..)) //com.xyz.service包及子包下的所有类的所有方法

within

用于匹配指定类型内的方法执行，匹配的是类型内的方法，类型下的所有方法

within (com.xyz.service.*) // com.xyz.service包下面的所有类的所有方法

within (com.xyz.service..*) // com.xyz.service包或子包下面的所有类的所有方法

within (com.xyz.service.impl.UserServiceImpl) // UserServiceImpl类下面所有方法

this

用于匹配当前AOP代理对象类型的执行方法，在前文中引入（Introduction）的代理对象使用，可以注入代理对象
target

用于匹配当前目标对象类型的执行方法，可以注入目标对象，被代理的对象
args

用于匹配当前执行的方法传入的参数为指定类型的执行方法，可以注入连接点(方法)的参数列表
@target
@args
@within
@annotation
bean

代码实战

5种通知的案例

DemoAspect.java

定义切面，及通知，这里为了测试更多的案例，表达式切到AdviceKindTestController.java



package demo.aop.aspect;

import lombok.extern.slf4j.Slf4j;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.*;

import org.springframework.stereotype.Component;

@Aspect

@Slf4j

@Component //必须是个bean

public class DemoAspect {

    //前置通知

    @Before("execution (* demo.aop.controller.AdviceKindTestController.*(..))")

    public void auth() {

        log.info("前置通知，假装校验了个权限");

    }

    //后置通知

    @AfterReturning("execution (* demo.aop.controller.AdviceKindTestController.*(..))")

    public  Object  afterSomething(){

        log.info("后置通知，不太清楚运用场景");

        return "ok";

    }

    //环绕通知

    //如果环绕通知 不返回执行结果  方法不会返回任何结果，导致接口拿不到任何数据

    //所以一定把proceed 返回

    //ProceedingJoinPoint 是 JoinPoint的子类，仅当环绕通知的时候，可以注入ProceedingJoinPoint的连接点

    @Around("execution (* demo.aop.controller.AdviceKindTestController.*(..))")

    public  Object  getMethodTime(ProceedingJoinPoint point) throws Throwable {

        log.info("环绕通知，统计方法耗时，方法执行前");

        Long beforeMillis = System.currentTimeMillis();

        Object proceed = point.proceed();

        Long taketimes= System.currentTimeMillis()-beforeMillis;

        log.info(String.format("该方法用时%s毫秒",taketimes));

        return proceed;

    }

    //异常通知

    @AfterThrowing("execution (* demo.aop.controller.AdviceKindTestController.*(..))")

    public void throwSomething() {

        log.info("异常通知，只有异常了才会通知。具体场景，不是特别了解");

    }

    //最终通知

    @After("execution (* demo.aop.controller.AdviceKindTestController.*(..))")

    public void closeSomething() {

        log.info("最终通知，官网说，可以用来回收某些资源。无论发不发生异常，都会被执行");

    }

}

AdviceKindTestController.java

测试用的接口类

package demo.aop.controller;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController

public class AdviceKindTestController {

    @GetMapping("/advice") //http://localhost:8080/advice

    public String test() throws InterruptedException {

        Thread.sleep(4);

        return "ok";

    }

    @GetMapping("/advice/throwing") //http://localhost:8080/advice/throwing

    public String test2(){

        int i=1/0;

        return "ok";

    }

}

访问 http://localhost:8080/advice 后台输出为

2020-10-18 11:24:01.201                 : 环绕通知，统计方法耗时，方法执行前

2020-10-18 11:24:01.201                 : 前置通知，假装校验了个权限

2020-10-18 11:24:01.201                 : 该方法用时6毫秒

2020-10-18 11:24:01.202                 : 最终通知，官网说，可以用来回收某些资源。无论发不发生异常，都会被执行

2020-10-18 11:24:01.202                 : 后置通知，不太清楚运用场景

执行顺序

- 环绕通知的前面部分

- 前置通知

- 环绕通知的后面部分

- 最终通知

- 后置通知

访问 http://localhost:8080/advice/throwing 后台输出为

2020-10-18 11:30:34.935                 : 环绕通知，统计方法耗时，方法执行前

2020-10-18 11:30:34.935                 : 前置通知，假装校验了个权限

2020-10-18 11:30:34.936                 : 最终通知，官网说，可以用来回收某些资源。无论发不发生异常，都会被执行

2020-10-18 11:30:34.936                 : 异常通知，只有异常了才会通知。具体场景，不是特别了解

java.lang.ArithmeticException: / by zero    //test2()方法抛出了异常

执行顺序如下，我们可以看到因为接口出现了异常，所以后置通知并没执行，环绕通知的后面部分也没执行，但最终通知和异常通知被执行

- 环绕通知的前面部分

- 前置通知

- 最终通知

- 异常通知

下文预告

切入点表达式详解
通知优先级
通知中引用切点的参数，目标对象，代理对象、切点对象及其方法调用
@DeclareParents 实现引入
@ControllerAdvice 实现统一错误处理

本文完整代码参考 https://gitee.com/haimama/java-study/tree/master/spring-aop

spring aop翻译文档http://shouce.jb51.net/spring/aop.html

巴特西