SpringAOP底层代码实现

AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
简单来说：AOP有助于我们将不同但是有必要的重复性代码集中管理起来复用，而不是每次都要重复写一遍。
AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

springAOP的代理模式

springAop中基于两种代理模式：

• 一种是基于接口的动态代理技术，也就是jdk提供的代理技术。
• 一种是基于父类的动态代理技术，是cglib的代理技术。

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

jdk代理

基于接口的动态代理技术

目标类接口

public interface TargetInterface {
   public void save();
}

目标类

public class Target implements TargetInterface {
   @Override
   public void save() {
       System.out.println("save running....");
  }
}

增强类

public class Advice {
​
   public void before(){
       System.out.println("前置增强....");
  }
​
   public void afterReturning(){
       System.out.println("后置增强....");
  }
​
}

动态代理代码

public static void main(String[] args) {
​
       //目标对象
       final Target target = new Target();
​
       //增强对象
       final Advice advice = new Advice();
​
       //返回值 就是动态生成的代理对象
       TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
               target.getClass().getClassLoader(), //目标对象类加载器
          //目标对象相同的接口字节码对象（数组，因为一个实现类可以实现多个接口）
               target.getClass().getInterfaces(),
               new InvocationHandler() {
                   //调用代理对象的任何方法 实质执行的都是invoke方法
                   //参数1:就是代理对象,一般不使用
                   //参数2:要调用的方法的Method对象,被代理对象的方法
                   //参数3:要调用的方法的参数
                   public Object invoke(Object proxy,
                                        Method method, Object[] args) throws Throwable {
                       advice.before(); //前置增强
                       Object invoke = method.invoke(target, args);//执行目标方法
                       advice.afterReturning(); //后置增强
                       return invoke;
                  }
              }
      );
​       //调用代理对象的方法
       proxy.save();​
}

cglib代理

基于父类的动态代理技术

所需依赖

<dependencies>
​
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>5.0.5.RELEASE</version>
       </dependency>
       
</dependencies>

spring-context中会依赖spring-core，spring-core中有封装cglib。

目标类

public class Target {
   public void save() {
       System.out.println("save running....");
  }
}

增强类

public class Advice {
​
   public void before(){
       System.out.println("前置增强....");
  }
​
   public void afterReturning(){
       System.out.println("后置增强....");
  }
​
}

动态代理代码

public static void main(String[] args) {
​
       //目标对象
       final Target target = new Target();
​
       //增强对象
       final Advice advice = new Advice();
​
       //返回值 就是动态生成的代理对象 基于cglib
       //1、创建增强器
       Enhancer enhancer = new Enhancer();
       //2、设置父类（目标）
       enhancer.setSuperclass(Target.class);
       //3、设置回调
       enhancer.setCallback(new MethodInterceptor() {
           //参数1:就是代理对象,一般不使用
           //参数2:要调用的方法的Method对象,被代理对象的方法
           //参数3:要调用的方法的参数
           //参数4:要调用的方法的代理对象
           public Object intercept(
               Object proxy,
               Method method,
               Object[] args,
               MethodProxy methodProxy) throws Throwable {               
               advice.before(); //执行前置
               Object invoke = method.invoke(target, args);//执行目标
               advice.afterReturning(); //执行后置
               return invoke;             
          }
      });
       //4、创建代理对象
       Target proxy = (Target) enhancer.create();
​​
       proxy.save();
​  }
​