动态代理的两种实现方式

在java web中，很多的技术底层都用到了java的动态代理技术。比如拦截器，比如Spring中的AOP编程等。

在java中，动态代理技术有：原生JDK，CGLIB，Javassist，ASM。其中，Spring常用JDK和CGLIB，而Mybatis中还使用了Javassist。本文只讲原生JDK，CGLIB这两种最常用的方式。

1.原生JDK

必须借助接口才能产生代理对象，必须有接口

接口：

public interface Worker {
	void doWork();

}

实现类：

public class Programmer implements Worker {

	@Override
	public void doWork() {
		System.out.println("工作就是写代码");
	}
}

动态代理绑定和代理逻辑实现：

public class JdkProxyTest implements InvocationHandler {
	
	//真实对象
	private Object target =null;
	
	/**
	 * 将真实对象和代理对象建立联系，通过真实对象来返回一个代理对象（猜测该代理对象可能为真实对象的子类）
	 * @param target 真实对象
	 * @return 代理对象
	 */
	public Object bind(Object target){
		this.target=target;
		
		/**
		 * 参数1：类加载器，采用target本身的类加载器
		 * 参数2：生成的动态代理对象挂在那个接口下，采用target实现的接口下，即Woker接口。
		 * 参数3：定义实现方法逻辑的代理类，this表示当前对象，，它必须实现InvocationHandler的invoke方法。
		 */
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
	target.getClass().getInterfaces(), this);
	}


	/**代理方法逻辑
	 * @param proxy 代理对象
	 * @param method 当前调度方法
	 * @param args 当前方法参数
	 * @return  代理结果返回
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("进入代理逻辑方法");
		System.out.println("调度真实对象之前的服务");
		Object obj=method.invoke(target, args);//相当于调用doWork()方法

		System.out.println("调度真实对象之后的服务");
		
		return obj;
	}

}

主程序：

public class MainClass {

	public static void main(String[] args) {
		JdkProxyTest proxyTest=new JdkProxyTest();
		//绑定关系
		Worker workerProxy=(Worker)proxyTest.bind(new Programmer());
		//注意：此时的workerProxy已经是一个代理对象，而不仅仅是一个单纯的Worker对象，所以它会执行代理逻辑方法invoke中得到代码。
		//调用workerProxy.doWork()不会去执行Programmer中的doWork()方法，而是去执行代理方法。因为它现在是一个代理对象
		workerProxy.doWork();
	}
}

程序运行后控制台：

进入代理逻辑方法
调度真实对象之前的服务
工作就是写代码
调度真实对象之后的服务

注意：Worker workerProxy=(Worker)proxyTest.bind(new Programmer());该代码返回的对象并不是单纯的Programmer对象，而是代理对象。所以workerProxy.doWork()会去执行invoke（）方法，而不是doWork（）方法。

2.CGLIB

CGLIB实现动态代理，不需要接口！！！

下面的代码需要导入cloud-cglib.jar。

CGLIB动态代理实现逻辑：
 

public class CglibTest implements MethodInterceptor {

	/**
	 * 生成Cglib代理对象
	 * @param cla 真实对象的class对象
	 * @return Cglib代理对象
	 */
	public Object getProxy(Class cla){
		//CGLIB的增强类对象
		Enhancer enhancer=new Enhancer();
		//设置增强类型，增强真实对象
		enhancer.setSuperclass(cla);
		//定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor中的抽象方法。
		enhancer.setCallback(this);
		return enhancer.create();
		
	}
	@Override
	public Object intercept(Object object, Method method, Object[] arg2, MethodProxy methodProxy) throws Throwable {
		
		System.out.println("调用真实对象前");
		Object result= methodProxy.invokeSuper(object, arg2);
		System.out.println("调用真实对象后");
		
		return result;
	}

}

需要增强的类：

public class StudentService {
	
	void study(){
		System.out.println("学生在教室中静悄悄地在学习...");
	}

}

主程序：

public class MainClass {

	public static void main(String[] args) {
		CglibTest cglibTest=new CglibTest();
		//绑定关系，返回的是StudentService的代理对象
		StudentService studentService=(StudentService)cglibTest.getProxy(StudentService.class);
		//执行代理对象的intercept（）方法，而不是StudentService中的study（）方法。
		//CGLIB的具体实现没看，猜测可能使用了多态，enhancer.create() 返回的真实对象的子类，增强的逻辑在子类中。
		studentService.study();
	}

}

控制台：

调用真实对象前
学生在教室中静悄悄地在学习...
调用真实对象后

3.总结

动态代理实质，就是使用字节码技术，重新生成了一个新类，来达到增强的效果。

关于动态代理对象的本质，可以参考下面的文章。

参考文章：https://blog.csdn.net/weixin_34127717/article/details/91454332

               https://blog.csdn.net/zhaobo19911119/article/details/103057560