Spring AOP底层实现原理-动态代理

AOP是什么？

spring框架的核心之一AOP，面向切面编程是一种编程思想。我对于面向切面编程的理解是：可以让我们动态的控制程序的执行流程及执行结果。spring框架对AOP的实现是为了使业务逻辑之间实现分离，分离主业务逻辑及次要业务逻辑，进而降低系统间的耦合度。

spring框架对于这种编程思想的实现基于两种动态代理模式，分别是 JDK动态代理 及 CGLIB的动态代理，这两种动态代理的区别是 JDK动态代理需要目标对象实现接口，而 CGLIB的动态代理则不需要。

特征：

• JDK代理：基于接口的代理，一定是基于接口，会生成目标对象的接口类型的子对象。

• Cglib代理：基于类的代理，不需要基于接口，会生成目标对象类型的子对象。

下面我们来简单实现动态代理，进而帮助我们理解面向切面编程。

JDK动态代理

接口：

public interface UserService {
    void save();
    int select();
}

接口实现类：

public class UserServiceImpl implements UserService {
 
    @Override
    public void save() {
        System.out.println("保存用户信息成功");
    }
 
    @Override
    public int select() {
        System.out.println("查询用户信息成功");
        return 10;
    }
}

JDK动态代理工厂类：

public class JdkProxyFactory implements InvocationHandler {
 
    private Object target;
 
    public JdkProxyFactory(Object target) {
        this.target = target;
    }
 
    /**
     * 获取代理对象，当前类继承InvocationHandler
     *
     * @return
     */
    public Object getProxyObject() {
        return Proxy.newProxyInstance(
        			target.getClass().getClassLoader(),
        			target.getClass().getInterfaces(),
        			this
        		);
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //添加功能
        System.out.println("增强代码，添加日志功能");
        //执行原有方法
        return method.invoke(target, args);
    }
}

测试代码：

@Test
public void JdkProxyTest() {
    //创建目标对象
    UserService userService = new UserServiceImpl();
    //创建工厂对象
    JdkProxyFactory jdkProxyFactory = new JdkProxyFactory(userService);
    UserService proxy = (UserService) jdkProxyFactory.getProxyObject();
    proxy.save();
    System.out.println("=========================");
    proxy.select();
}

CGLIB动态代理

需生成代理对象的类:

public class OrderService {
 
    public void save() {
        System.out.println("保存订单成功");
    }
 
    public int select() {
        System.out.println("查询订单成功");
        return 10;
    }
}

CGLIB动态代理工厂类:

public class CglibProxyFactory implements MethodInterceptor {
 
    private Object target;
 
    public CglibProxyFactory(Object target) {
        this.target = target;
    }
 
    /**
     * 获取代理对象
     *
     * @return
     */
    public Object getProxyObject() {
        Enhancer enhancer = new Enhancer();
        //设置两个参数
        //设置生成代理类的目标对象（代理类对象是目标对象的子类）
        enhancer.setSuperclass(target.getClass());
        //设置回调方法
        enhancer.setCallback(this);
        //生成代理对象
        return enhancer.create();
    }
 
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //添加功能
        System.out.println("增强代码，添加日志功能");
        //执行原有方法
        return method.invoke(target, objects);
    }
}

测试代码：

@Test
public void CglibProxyTest() {
    //创建目标对象
    OrderService orderService = new OrderService();
    //创建工厂对象
    CglibProxyFactory cglibProxyFactory = new CglibProxyFactory(orderService);
    OrderService proxy = (OrderService) cglibProxyFactory.getProxyObject();
    proxy.save();
    System.out.println("=========================");
    proxy.select();
}