Spring AOP 前篇（一）：Java代理之JDK静态代理、JDK动态代理、CGLIB动态代理

Spring AOP 前篇：Java代理之JDK静态代理、JDK动态代理、CGLIB动态代理

该文章参考多篇文章的基础上进行了简化并做少许修改，方便理解。原文章地址如下：

Java之代理（jdk静态代理，jdk动态代理，cglib动态代理，aop，aspectj）

AOP的底层实现-CGLIB动态代理和JDK动态代理

静态代理、JDK动态代理和CGLIB动态代理之间的区别?

java 静态代理，jdk动态代理，CGLIB动态代理详解

一、代理是Java常用的设计模式，代理类通过调用被代理类的相关方法，并对相关方法进行增强。加入一些非业务性代码，如事务、日志、报警发邮件等操作。

AOP是Spring框架中的核心之一，在应用中具有非常重要的作用，也是Spring其他组件的基础。AOP的核心功能的底层实现机制：如何用动态代理来实现切面拦截。

AOP的拦截功能是由java中的动态代理来实现的。

JDK动态代理：由java内部的反射机制来实现的；
CGLIB动态代理：底层则是借助asm来实现的；

总的来说，反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过asm生成的类进行缓存，这样解决asm生成类过程低效问题）。

并且：JDK动态代理的应用前提必须是目标类基于统一的接口；如果没有上述前提，JDK动态代理不能应用。由此可以看出，JDK动态代理有一定的局限性。CGLIB动态代理这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。

Spring在给某个类提供动态代理时，会自动在JDK动态代理和CGLIB动态代理中动态的选择。

二、JDK静态代理（设计模式中的简单代理模式）

代理类与被代理类实现相同的方法。（图文来自《图解设计模式》）

在这里插入图片描述

代理类：（只在必要时生成实例）
在这里插入图片描述

在这里插入图片描述

三、JDK动态代理

JDK动态代理要求目标对象必须实现接口，因为它创建代理对象的时候是根据接口创建的。如果不实现接口，JDK无法给目标对象创建代理对象。被代理对象可以实现多个接口，创建代理时指定创建某个接口的代理对象就可以调用该接口定义的方法了。

JDK动态代理只能代理实现接口的类，没有实现接口的类无法代理。

在java动态代理机制中，有两个重要的类或接口，一个是InvocationHandler（Interface）、另一个则是Proxy（Class），这个类和接口是实现我们动态代理所必须用到的。

为目标类（target）定义统一的接口类Service，这个是JDK动态代理必须的前提。

Service接口，及该接口实现类AService（需要被代理的类）。

public class AService implements Service {
	public void add() {
		System.out.println("AService add>>>>>>>>>>>>>>>>>>");
	}
 
	public void update() {
		System.out.println("AService update>>>>>>>>>>>>>>>");
	}
}

实现动态代理类MyInvocationHandler：实现InvocationHandler接口，并且实现接口中的invoke方法。每个动态代理类都必须要实现InvocationHandler这个接口，并且每个dialing类的实例都关联到了一个handler：当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke方法来进行调用。Invocationhandler接口中的唯一一个方法------invoke（）方法：
```
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
```
- proxy：我们所代理的那个真实对象；
- method：所要调用真实对象的某个方法的Method对象；
- args：调用真实对象某个方法时接受的参数；
Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但我们用的最多的就是 newProxyInstance这个方法：

public class MyInvocationHandler implements InvocationHandler {
	private Object target;
 
	MyInvocationHandler() {
		super();
	}
 
	MyInvocationHandler(Object target) {
		super();
		this.target = target;
	}
 
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// 程序执行前加入逻辑，MethodBeforeAdviceInterceptor
		System.out.println("before-----------------------------");
		// 程序执行
		Object result = method.invoke(target, args);
		// 程序执行后加入逻辑，MethodAfterAdviceInterceptor
		System.out.println("after------------------------------");
		return result;
	}
 
}

测试类：

public class Test {
	public static void main(String[] args) {
        // 被代理的对象
		Service aService = new AService();
        //动态代理类
		MyInvocationHandler handler = new MyInvocationHandler(aService);
		// Proxy为InvocationHandler实现类动态创建一个符合某一接口的代理实例
        // 即创建代理对象
		Service aServiceProxy = 
            (Service) Proxy.newProxyInstance(
            	aService.getClass().getClassLoader(),	// proxy 对象
            	aService.getClass().getInterfaces(), 	// method 对象
            	handler);							  // args 参数
		// 由动态生成的代理对象来aServiceProxy 代理执行程序，其中aServiceProxy 符合Service接口
		aServiceProxy.add();
		System.out.println();
		aServiceProxy.update();
	}
}

打印结果如下；在目标类AService的add和update方法前后已经加入了自定义的切面逻辑，AOP拦截机制生效了。

before-----------------------------
AService add>>>>>>>>>>>>>>>>>>
after------------------------------
before-----------------------------
AService update>>>>>>>>>>>>>>>

after------------------------------

四、CGLIB动态代理

CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。CGLIB是针对类来实现代理的，原理是对指定的目标生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

需要注意的是：JDK动态代理只可以为接口去完成操作；而CGLIB动态dialing可以为没有实现接口的类去做代理，也可以为实现接口的类去做代理。

CGLIB动态代理通过 Enhancer类生成代理类。

//CGLIB动态代理类实现MethodInterceptor接口，实现intercept()方法。
public class CglibProxyFactory implements MethodInterceptor {
    //得到目标对象
    private Object target;
 
    //使用构造方法传递目标对象
    public CglibProxyFactory(Object target) {
        super();
        this.target = target;
    }
 
    //创建代理对象
    public Object createProxy(){
        //1.创建Enhancer
        Enhancer enhancer = new Enhancer();
        //2.传递目标对象的class
        enhancer.setSuperclass(target.getClass());
        //3.设置回调操作
        enhancer.setCallback(this);
 		// 返回dialing类对象
        return enhancer.create();
    }
 
    @Override
    //参数一:代理对象;参数二:需要增强的方法;参数三:需要增强方法的参数;参数四:需要增强的方法的代理
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 增强前
        //添加切面逻辑（advise），此处是在目标类代码执行之前，即为MethodBeforeAdviceInterceptor。
        System.out.println("这是增强方法前......");
        Object invoke = methodProxy.invoke(target, args);
        // 增强后
        //添加切面逻辑（advise），此处是在目标类代码执行之后，即为MethodAfterAdviceInterceptor。
        System.out.println("这是增强方法后......");
        return invoke;
    }
 
    public static void main(String[] args) {
        // 1.创建对象
        UserServiceImpl userService = new UserServiceImpl();
        // 2.创建代理对象
        CglibProxyFactory proxy = new CglibProxyFactory(userService);
        // 3.调用代理对象的增强方法,得到增强后的对象
        IUserService createProxy = (IUserService) proxy.createProxy();
        createProxy.regist();
    }
}