举个栗子,比如兰蔻想找安妮海瑟薇代言香水广告,假设兰蔻方代表为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动态代理是通过反射类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元
取款完成
代理类AtmInvocationHandler实现了InvocationHandler接口,与静态代理不同它持有的目标对象类型是Object,因此代理类AtmInvocationHandler能够代理任意的目标对象,给目标对象添加事务控制的逻辑。因此动态代理真正实现了将代码中横向切面逻辑的剥离,实现了代码复用。
JDK动态代理的缺点:
(一)通过反射类Proxy和InvocationHandler回调接口实现JDK动态代理,要求目标类必须实现一个接口,对于没有实现接口的类,无法通过这种方式实现动态代理。
(二)动态代理会为接口中的声明的所有方法添加上相同的代理逻辑,不够灵活
CGLIB(Code Generation Library)是一个基于ASM的字节码生成库,它允许我们在运行时对字节码进行修改和动态生成。CGLIB支持接口、继承方式实现代理。
原 理 \color{blue}{原理} 原理:动态生成一个要代理类的子类,子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势将横切逻辑织入(weave)目标对象
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框架至关重要。