理解springAop的正确姿势

Spring有两大核心，IOC和AOP。IOC在spring项目中基本无处不在，而AOP则用的基本比较少。 AOP（Aspect Oriented Programming），即面向切面编程。

AOP有一些复杂的概念：

• 切面(aspect)：用来切插业务方法的类。
• 连接点(joinpoint)：是切面类和业务类的连接点，其实就是封装了业务方法的一些基本属性，作为通知的参数来解析。
• 通知(advice)：在切面类中，声明对业务方法做额外处理的方法。
• 切入点(pointcut)：业务类中指定的方法，作为切面切入的点。其实就是指定某个方法作为切面切的地方。
• 目标对象(target object)：被代理对象。
• AOP代理(aop proxy)：代理对象。
  通知：
• 前置通知(before advice)：在切入点之前执行。
• 后置通知(after returning advice)：在切入点执行完成后，执行通知。
• 环绕通知(around advice)：包围切入点，调用方法前后完成自定义行为。
• 异常通知(after throwing advice)：在切入点抛出异常后，执行通知。

初学的时候这些概念很难理解，可以先把它理解成一个高级的代理模式：

那么我们首先看一下什么是代理模式

代理模式即它可以在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。

代理模式常用在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到>代理类统一处理，让程序员只需要关注业务方面的开发。除此之外，代理模式还可以用在 RPC、缓存等应用场景中。

比如有一个类，我们想不改变这个类代码的情况下统计这个类下面的所有方法执行时间。

public class UserController {

    public String login(String username, String password) {
        //do something
        try {
            Thread.sleep(50);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("执行用户密码登录");
        return "登录成功";
    }

    public String register(String username, String password) {
        //do something
        try {
            Thread.sleep(50);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("执行用户密码注册");
        return "注册成功";
    }
}

先看一下静态代理实现

很简单，就是创建一个代理类来继承原始类(还有一种方法：可以通过实现相同的接口来创建代理类)

public class UserControllerProxy extends UserController {


    public String login(String username, String password) {
        long startTimestamp = System.currentTimeMillis();
        //执行原始方法
        String res = super.login(username, password);
        long endTimeStamp = System.currentTimeMillis();
        long executeTime = endTimeStamp - startTimestamp;
        System.out.println("登录方法执行时间:" + executeTime);
        return res;
    }


    public String register(String username, String password) {
        long startTimestamp = System.currentTimeMillis();
        //执行原始方法
        String res = super.register(username, password);
        long endTimeStamp = System.currentTimeMillis();
        long executeTime = endTimeStamp - startTimestamp;
        System.out.println("注册方法执行时间:" + executeTime);
        return res;
    }

}

执行直接用代理类来执行

    @Test
    public void test(){
        UserController userControllerProxy = new UserControllerProxy();
        userControllerProxy.login("hello","123456");
    }
//输出：
//执行用户密码登录
//登录方法执行时间:50

这样的代码有点问题。一方面，我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑。另一方面，如果要添加的附加功能的类有不止一个，我们需要针对每个类都创建一个代理类。

动态代理实现

动态代理不需要给每一类创建代理类，只需要一个拦截方法类就可以。java有两种常用的代理实现，一种是基于反射的JDK动态代理实现，一种是基于字节码的CGLIB实现。这点主要介绍一些CGLIB的实现。
先引入cglib包

     <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
       </dependency>
       <dependency>
            <groupId>org.ow2.asm</groupId>
            <artifactId>asm</artifactId>
            <version>9.1</version>
       </dependency>

创建CGLIB代理类

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;


public class CGLibProxy implements MethodInterceptor {


    public <T> T getProxy(Class<T> cls) {
        return (T) Enhancer.create(cls, this);

    }

    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        long startTimestamp = System.currentTimeMillis();
        //代理类中的所有方法
        Object result = proxy.invokeSuper(obj, args);
        long endTimeStamp = System.currentTimeMillis();
        long executeTime = endTimeStamp - startTimestamp;
        System.out.println("方法执行时间是:" + executeTime);
        return result;
    }
}

    @Test
    public void test1(){
        CGLibProxy cgLibProxy = new CGLibProxy();
        UserController userControllerProxy = cgLibProxy.getProxy(UserController.class);
        userControllerProxy.login("hello","123456");
      //输出：
      //执行用户密码登录
      //方法执行时间是:62
    }

再回头看一下springAOP

aop其实就像代理模式一样可以帮助我们增强方法，但它比动态代理方法更为细致。可以拦截到方法执行之前，方法执行过程，以及方法执行之后，通过这一些面对方法进行增强。
首先我们可以先定义一个注解，用于标识那些方法需要增强
假如我们要做一个业务监控的功能，这个功能需要和业务代码解耦，用AOP来做就非常适合了。

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Monitor {

    String value();

}

首先我们先定义一个AOP的切面
切面的作用就是拦截方法的，通过切面可以对方法进行增强。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
@Aspect
public class AopAspect {
    
    
    //定义切入点，指定那些方法可以被切面到，这里定义的是 被@Monitor注解定义的方法会被切面
    @Pointcut("@annotation(com.dofun.aopdemo.aop.Monitor)")
    public void pointcut() {
        System.out.println("定义 pointcut");
    }

    
    //定义方法前置拦截，方法在执行之前可以做一些事情
    @Before("pointcut()")
    public void before(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        //获取方法上的注解
        Monitor monitor = method.getDeclaredAnnotation(Monitor.class);
        if (monitor != null) {
            Object[] paramValues = joinPoint.getArgs();
            String[] paramNames = methodSignature.getParameterNames();
            System.out.print(monitor.value()+"参数：");
            for (int i = 0; i < paramNames.length; i++) {
                System.out.print(paramNames[i] + ":" + paramValues[i]+";");
            }
            System.out.println("");
        }
    }
    //定义方法后置拦截，方法在执行之后可以做一些什么事情
    @After("pointcut()")
    public void after(JoinPoint joinPoint) {
        System.out.println(""+joinPoint.getSignature().getName()+"方法结束。。。发送事件");
    }

    //定义方法环绕拦截，可以在方法执行过程中做一些什么事情
    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint) {
        long startTimestamp = System.currentTimeMillis();
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        long endTimeStamp = System.currentTimeMillis();
        long executeTime = endTimeStamp - startTimestamp;
        System.out.println("方法执行时间是:" + executeTime);
    }
}

添加一个测试方法

@SpringBootTest
public class ProxyTest {

    @Autowired
    private AdminService adminService;

    @Test
    public void test2(){
        adminService.updatePassword("1","张三");
    }

  //修改管理员密码参数：adminId:1;adminName:张三;
  //执行方法本身，do something
  //updatePassword方法结束。。。发送事件
  //方法执行时间是:13
}

整个AOP实现就完成了。然后我们可以打个断点看一下，adminService其实已经不是我们当初定义那个AdminService类型了，而是一个代理类的对象。

image.png

这其实就是spring AOP的原理了，spring容器在扫描这个类的过程中发现这个类有被切面“切入”到，就会往容器里面放入代理类而不是原始类。