coding++：Spring 中的 AOP 原理

为什么使用 AOP 如下场景：

现在有一个情景：

我们要把大象放进冰箱，步骤为：打开冰箱->放入大象->关闭冰箱

如果再把大象拿出来，步骤为：打开冰箱->拿出大象->关闭冰箱

代码如下：

 public void put() {
        System.out.println("打开冰箱...");
        System.out.println("放入大象...");
        System.out.println("关闭冰箱...");
    }
 
    public void get() {
        System.out.println("打开冰箱...");
        System.out.println("拿出大象...");
        System.out.println("关闭冰箱...");
    }

我们需要在每一个拿进拿出操作前后都要进行打开冰箱和关闭冰箱的操作，造成了代码重复。

而如果要拿进拿出其他动物，那么每一个动物的操作都需要加入打开冰箱关闭冰箱的操作，十分繁琐混乱。

解决方法就是AOP，将这些打开冰箱和关闭冰箱的操作单独抽取出来，做成一个切面，之后调用任何方法，都插入到方法前后即可。

先来看一些基本概念再来解决这个问题。

基本概念：

AOP   即Aspect Oriented Program，面向切面编程。

使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。

从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事物管理，日志记录等等。

这些系统性的编程工作都可以独立编码实现，然后通过AOP技术切入进系统即可。从而达到了 将不同的关注点分离出来的效果。

切面（Aspect）：其实就是共有功能的实现。

　　　　　　　　  如日志切面、权限切面、事务切面等。

　　　　　　　　   在实际应用中通常是一个存放共有功能实现的普通Java类，之所以能被AOP容器识别成切面，是在配置中指定的。

通知/增强（Advice）：是切面的具体实现。以目标方法为参照点，根据放置的地方不同，可分为前置通知（Before）、后置通知（AfterReturning）、异常通知（AfterThrowing）、最终通知（After）与环绕通知（Around）5种。

　　　　　　　　　　  在实际应用中通常是切面类中的一个方法，具体属于哪类通知，同样是在配置中指定的。

连接点（Joinpoint）：就是程序在运行过程中能够插入切面的地点。

　　　　　　　　　　  例如，方法调用、异常抛出或字段修改等，但Spring只支持方法级的连接点。

切入点（Pointcut）：用于定义通知应该切入到哪些连接点上。

　　　　　　　　　　不同的通知通常需要切入到不同的连接点上，这种精准的匹配是由切入点的正则表达式来定义的。

目标对象（Target）：就是那些即将切入切面的对象，也就是那些被通知的对象。

　　　　　　              这些对象中已经只剩下干干净净的核心业务逻辑代码了，所有的共有功能代码等待AOP容器的切入。

代理对象（Proxy）：将通知应用到目标对象之后被动态创建的对象。

　　　　　　　　　　可以简单地理解为，代理对象的功能等于目标对象的核心业务逻辑功能加上共有功能。

　　　　　　　　　　 代理对象对于使用者而言是透明的，是程序运行过程中的产物。

织入（Weaving）：将切面应用到目标对象从而创建一个新的代理对象的过程。

　　　　　　　　　这个过程可以发生在编译期、类装载期及运行期，当然不同的发生点有着不同的前提条件。

　　　　　　　　　譬如发生在编译期的话，就要求有一个支持这种AOP实现的特殊编译器；发生在类装载期，就要求有一个支持AOP实现的特殊类装载器；只有发生在运行期，则可直接通过Java语言的反射机制与动态代理机制来动态实现。

AOP 原理：

AOP 代理可分为静态代理和动态代理两大类，

静态代理：使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；

动态代理：在运行时借助于 JDK 动态代理、CGLIB（code generate libary）字节码生成技术 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强

Spring AOP采用的是动态代理，在运行期间对业务方法进行增强，所以不会生成新类。

对于动态代理技术，Spring AOP提供了对JDK动态代理的支持以及CGLib的支持。

前者是基于反射技术的实现，后者是基于继承的机制实现。

如果目标对象有实现接口，使用jdk代理。

如果目标对象没有实现接口，则使用Cglib代理。

JDK：动态代理：

JDK动态代理需要获得被目标类的接口信息（应用Java的反射），生成一个实现了代理接口的动态代理类（字节码），再通过反射机制获得动态代理类的构造函数，利用构造函数生成动态代理类的实例对象，在调用具体方法前调用

invokeHandler方法来处理。

主要使用到 InvocationHandler 接口和 Proxy.newProxyInstance() 方法。

JDK动态代理要求被代理的类实现一个接口，只有接口中的方法才能够被代理 。

其方法是将被代理对象注入到一个中间对象，而中间对象实现InvocationHandler接口，在实现该接口时，可以在被代理对象调用它的方法时，在调用的前后插入一些代码。

而 Proxy.newProxyInstance() 能够利用中间对象来生产代理对象。

插入的代码就是切面代码。所以使用JDK动态代理可以实现AOP。

现在演示一下如何使用JDK动态代理实现开头的情景

JDK动态代理需要被代理类实现一个接口，先写一个接口。

public interface AnimalOperation {
    public void put();
    public void get();
}

再写一个类（要被代理的类），实现这个接口

public class ElephantOperation implements AnimalOperation{
 
    public void put() {
        System.out.println("放入大象...");
    }
 
    public void get() {
        System.out.println("拿出大象...");
    }
}

然后写一个类来实现InvocationHandler接口，在该类中对被代理类的方法做增强，并编写生成代理对象的方法

public class FridgeJDKProxy implements InvocationHandler{
    //被代理的对象,之后用反射调用被代理方法的时候需要被代理对象的引用
    private Object target;
 
    //InvocationHandler接口的方法,
    // proxy是代理对象，method是被代理的方法，args是被代理方法的参数，返回值是原方法的返回
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        openDoor();//调用被代理方法做一些操作
        Object result = method.invoke(target, args);//执行被代理对象的方法，如果方法有返回值则赋值给result
        closeDoor();//调用被代理方法后做一些操作
        return result;
    }
    private void openDoor(){
        System.out.println("打开冰箱...");
    }
    private void closeDoor(){
        System.out.println("关闭冰箱...");
    }
    public Object getProxy(Object target){
        this.target=target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
}

其中Proxy.newProxyInstance()方法需要的参数分别为，类加载器ClassLoader loader,接口数组Class<?>[] interfaces，与 InvocationHandler 

测试代码为：

  public static void main(String args[]) {
      AnimalOperation elephantOperation =(AnimalOperation) new FridgeJDKProxy().getProxy(new ElephantOperation());
      elephantOperation.put();
      elephantOperation.get();
  }

打印结果：

CGLIB 动态代理：

字节码生成技术实现AOP，其实就是继承被代理对象，然后Override需要被代理的方法，在覆盖该方法时，自然是可以插入我们自己的代码的。

CGLib动态代理需要依赖asm包，把被代理对象类的class文件加载进来，修改其字节码生成子类。

因为需要Override被代理对象的方法，所以自然CGLIB技术实现AOP时，就 必须要求需要被代理的方法不能是final方法，因为final方法不能被子类覆盖 。

现在演示一下如何使用CGLIB动态代理实现开头的情景

CGLIB动态代理不要求被代理类实现接口，先写一个被代理类。

public class MonkeyOperation {
    public void put() {
        System.out.println("放入猴子...");
    }
 
    public void get() {
        System.out.println("拿出猴子...");
    }
}

在写一个类实现MethodInterceptor接口，并在接口方法intercept（）里对被代理对象的方法做增强，并编写生成代理对象的方法

public class FridgeCGLibProxy implements MethodInterceptor {
 
    public String name="hahaha";
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        openDoor();//调用被代理方法做一些操作
        Object result = methodProxy.invokeSuper(proxy,args);//执行被代理对象的方法，如果方法有返回值则赋值给result
        closeDoor();//调用被代理方法后做一些操作
        return result;
    }
    private void openDoor(){
        System.out.println("打开冰箱...");
    }
    private void closeDoor(){
        System.out.println("关闭冰箱...");
    }
    public Object getProxy(Class cls){//参数为被代理的类对象
        Enhancer enhancer = new Enhancer();//创建增强器，用来创建动态代理类
        enhancer.setSuperclass(cls);//设置父类，即被代理的类对象
        enhancer.setCallback(this);//设置回调，指定为当前对象
        return enhancer.create();//返回生成的代理类
    }
}

测试代码：

  public static void main(String args[]) {
      MonkeyOperation monkeyOperation =(MonkeyOperation)new FridgeCGLibProxy().getProxy(MonkeyOperation.class);
      monkeyOperation.put();
      monkeyOperation.get();
  }

打印结果：

spring实现AOP，如果被代理对象实现了接口，那么就使用JDK的动态代理技术，反之则使用CGLIB来实现AOP，所以 Spring默认是使用JDK的动态代理技术实现AOP的 。