Spring AOP动态代理的两种实现方式

Spring AOP动态代理的两种实现方式

Aspect Oriented Programming 面向切面编程

通过预处理和运行期动态代理的方式, 实现功能的统一维护

作用: 在运行期间, 不修改源码的情况下, 增加方法的功能

优势: 减少重复代码, 也便于维护

底层实现: 动态代理技术

两种动态代理方式

• jdk代理 : 基于接口的动态代理技术
• cglib代理: 基于父类的动态代理技术

示例: 基于JDK的动态代理

// TargetInterface.java
public interface TargetInterface {
    
     void save();}

// Target.java
public class Target implements TargetInterface{
    
    
    @Override
    public void save() {
    
     System.out.println("[Target] saving"); }
}

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

// ProxyTest.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyTest {
    
    
    public static void main(String[] args) {
    
    
        final Target target = new Target();
        Advice advice = new Advice();

        // 返回值 就是动态生产的代理对象 用抽象接收而非具体!
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 1. 目标对象的类加载器
                target.getClass().getInterfaces(),  // 2. 目标对象的相同的接口字节码数组
                new InvocationHandler() {
    
    
                    // 3. 调用代理对象的任何方法, 实质执行的都是该 invoke()方法
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    
                        advice.before(); // 前置增强
                        method.invoke(target, args);   // 执行目标方法
                        advice.after();  // 后置增强
                        return null;
                    }
                }
        );
        proxy.save();
    }
}

输出:
前置增强
[Target] saving
后置增强

示例: 基于cglib的动态代理

// Target.java
public class Target  {
    
    
    public void save() {
    
     System.out.println("[Target] saving"); } 
}

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

// ProxyTest.java
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class ProxyTest {
    
    
    public static void main(String[] args) {
    
    
        final Target target = new Target();  // 目标对象
        Advice advice = new Advice();  // 用于增强的对象

        // 返回值就是动态代理生成的对象, 基于cglib
        Enhancer enhancer = new Enhancer();  // 1. 创建增强器
        enhancer.setSuperclass(Target.class);  // 2. 创建父类(目标)
        // 3. 创建回调
        enhancer.setCallback(new MethodInterceptor() {
    
    
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    
    
                advice.before();  // 前置
                Object invoke = method.invoke(target, objects);  // 执行目标
                advice.after();  // 后置
                return null;
            }
        });

        // 创建代理对象
        Target target1 = (Target) enhancer.create();
        target1.save();
    }
}

输出:
前置增强
[Target] saving
后置增强