Java动态代理与CGLIB动态代理实现原理

什么是代理模式

举个栗子，比如兰蔻想找安妮海瑟薇代言香水广告，假设兰蔻方代表为Jack，那么是不是Jack直接闯到Anne豪宅扯一嗓子“Anne 妹纸，我这有个私活你接不接”;实际情况肯定不是这样，且不说这个操作太鲁莽（搞不好还会被一枪崩掉），合作本身涉及的事项就很多，比如有木有档期，出场费怎么定价，要买哪些保险，税费怎么处理，违约责任等等，显然这里面财务、保险、法律相关的问题Anne一个人肯定搞不定，需要专业人士处理；而这所有的一切都可以交给Anne的经纪人（或者团队）Team来协办，作为一个艺人Anne只管拍广告就可以了。

在这个场景中，Jack是客户（代表兰蔻集团），Anne是艺人提供代言服务直接参与广告拍摄，Team是代理（帮Anne处理商务事宜），所有合作细节都是Jack找Team商谈完成，找Team谈合作一样能达成目标（拍代言广告），而且比直接找Anne本人效率更高，更稳妥。

静态代理

若代理类在程序运行前就已经存在，这种方式称为静态代理 ，这种情况下的代理类通常都是我们在Java代码中定义的（hard coding）。 通常情况下， 静态代理中的代理类和目标类（委托l类）会实现同一接口或是派生自相同的父类。

此例中，Atm是被代理的目标对象（委托对象），Crs持有Atm的引用，是代理对象，调用Crs的withdraw方法实际被转到Atm的withdraw

public interface Account {/*目标类与代理类都实现该接口*/
	String withdraw(double amount);
}

public class Atm implements Account{/*自动取款机,目标类(被代理)*/
	@Override
	public String withdraw(double amount) {
		return "取出"+ amount +"元";
	}
}

public class Crs implements Account {/*自动存取款机，此处为Atm的代理类*/

	private Account account = new Atm();/*持有被代理对象的引用,静态代理*/
	@Override
	public String withdraw(double amount) {
		return account.withdraw(amount);/*取款调用的是目标对象的方法*/
	}
	
	public String deposit() {/*代理类可以有自己的业务操作*/
		return "存款120元";
	}
}

public class Test {
	public static void main(String[] args) {
		Crs crs = new Crs();/*创建代理对象*/
		System.out.println(crs.withdraw(100));
	}
}

静态代理的不足

静态代理实现简单容易理解，但是静态代理不能使一个代理类反复作用于多个不同的目标对象，代理对象直接持有目标对象的引用，导致代理对象和目标对象的耦合。如果Account接口还有另一个实现类也需要进行事务控制，那么就要定义一个新的代理类，这样就会产生许多重复的模版代码，代码复用率不高。而动态代理就可以很好的解决这类问题。

JDK动态代理

静态代理的代理关系在编译时确定，而动态代理的代理关系在运行时确定，动态代理更灵活。

JDK动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的

目标与代理的共同接口

public interface Account {/*目标类与代理类都实现该接口，接口定义业务操作*/
	String withdraw(double amount);
}

目标对象

public class Atm implements Account{/*自动取款机,目标类*/
	@Override
	public String withdraw(double amount) {
		return "取出"+ amount +"元";
	}
}

handler

//InvocationHandler，对代理类方法的调用会被转到该类的invoke()方法。
public class AtmInvocationHandler implements InvocationHandler {
	private Object target;
	
	public AtmInvocationHandler(Object target) {/*绑定对象*/
		this.target = target;
	}

	public Object getProxy() {
		/* 获取代理对象
		
		参数说明：
		loader，指定代理对象的类加载器；
		interfaces，代理对象需要实现的接口数组；
		handler，方法调用的实际处理者

		newProxyInstance()会返回一个实现了指定接口的代理对象，对该对象的所有方法调用都会转发给InvocationHandler.invoke()方法。
		*/
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),
				target.getClass().getInterfaces(), this); // 需要绑定接口
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object result = null;
		System.out.println("取款操作");
		result = method.invoke(target, args);
		System.out.println(result);
		System.out.println("取款完成");
		return result;
	}

}

public class Test {
	public static void main(String[] args){
		AtmInvocationHandler handler = new AtmInvocationHandler(new Atm());
		Object atmProxy = handler.getProxy();
		Account accout = (Account)atmProxy;
		Object result = accout.withdraw(100.0);
	}
}

取款操作
取出100.0元
取款完成

JDK动态代理小结

代理类AtmInvocationHandler实现了InvocationHandler接口，与静态代理不同它持有的目标对象类型是Object，因此代理类AtmInvocationHandler能够代理任意的目标对象，给目标对象添加事务控制的逻辑。因此动态代理真正实现了将代码中横向切面逻辑的剥离，实现了代码复用。

JDK动态代理的缺点：
（一）通过反射类Proxy和InvocationHandler回调接口实现JDK动态代理，要求目标类必须实现一个接口，对于没有实现接口的类，无法通过这种方式实现动态代理。
（二）动态代理会为接口中的声明的所有方法添加上相同的代理逻辑，不够灵活

CGLIB动态代理

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB支持接口、继承方式实现代理。

$原理$：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势将横切逻辑织入（weave）目标对象

CGLIB代理实现步骤：

1、定义目标对象

public class Atm{/*自动取款机,目标类，不需要实现指定接口*/
	public String withdraw(double amount) {
		return "取出"+ amount +"元";
	}
	
	public String checkBalance() {
		return "当前余额:" + 1200 + "元";
	}
}

2、定义拦截器。在调用目标对象的方法时，CGLib会回调MethodInterceptor接口的intercept方法实施拦截，来切入代理逻辑，类似于JDK中的InvocationHandler接口

public class AtmInterceptor implements MethodInterceptor {
	/**
     * obj：cglib生成的代理对象
     * method：被代理对象方法
     * args：方法入参
     * methodProxy: 代理方法
    */	
	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		System.out.println("事务开始");
		Object result = proxy.invokeSuper(obj, args);
		System.out.println(result);
		System.out.println("事务结束");
		return result;
	}
}

3、在需要使用目标对象的时候，通过CGLIB动态代理获取代理对象。

public class Test {
	public static void main(String[] args) {
		//class 文件缓存目录，如果不研究动态类的源码可以不设置
		System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\cglib_classes");	
		//用于创建代理对象的增强器，可以对目标对象进行扩展
		Enhancer enhancer = new Enhancer();
		//将目标对象设置为父类
		enhancer.setSuperclass(Atm.class);
		//设置目标拦截器
		enhancer.setCallback(new AtmInterceptor());
		// 创建代理对象
		Atm atm = (Atm)enhancer.create();
		// 通过代理对象调用目标方法
		Object result = atm.withdraw(100);
		atm.checkBalance();
	}
}

目标对象的每个方法调用都会被拦截

CGLIB debugging enabled, writing to 'D:\cglib_classes'
事务开始
取出100.0元
事务结束
事务开始
当前余额:1200元
事务结束

以上代码通过CGLIB的Enhancer指定要代理的目标对象（即包含实际业务逻辑的对象），再通过调用create()方法得到代理对象，所有对代理对象的非final方法的调用都会指派给AtmInterceptor.intercept()方法，在intercept()方法中可以加入目标对象之外的业务逻辑，比如参数校验、日志审计、安全检查等功能；通过调用MethodProxy.invokeSuper()方法，将调用转发给原始对象，也就是本例的Atm 。CGLIG中MethodInterceptor的作用与JDK代理中的InvocationHandler类似，都是方法调用的中转派发。

两种动态代理方式的比较

JDK动态代理不需要任何外部依赖，但是只能基于接口进行代理；CGLIB通过继承的方式进行代理，无论目标对象有没有实现接口都可以代理，但是无法代理final对象与final方法。（final类型不能有子类，final方法不能被重载）

动态代理是 AOP(Aspect Orient Programming)编程思想，理解动态代理原理，对学习AOP框架至关重要。