定义
代理模式为另一个对象提供一个替身或占位符以控制对这个对象的访问。
举个例子
码农不直接和客户沟通,而是通过产品经理来传达客户的需求,这时,产品经理就相当于一个代理了,让我们通过代码来看看。
静态代理
基于面向对象的思想,首先定义一个码农接口,它有一个实现用户需求的方法。
public interface ICoder {
public void implDemands(String demandName);
}
我们假设小张是JAVA程序员,定义一个JAVA
码农类,他通过JAVA
语言实现需求。
public class JavaCoder implements ICoder{
private String name;
public JavaCoder(String name){
this.name = name;
}
@Override
public void implDemands(String demandName) {
System.out.println(name + " implemented demand:" + demandName + " in JAVA!");
}
}
产品经理,将其命名为码农代理类,同时让他实现ICoder
接口。
public class CoderProxy implements ICoder{
private ICoder coder;
public CoderProxy(ICoder coder){
this.coder = coder;
}
@Override
public void implDemands(String demandName) {
coder.implDemands(demandName);
}
}
上面一个接口,两个类,就实现了代理模式。
我们通过一个场景类,模拟用户找产品经理增加需求。
public static void main(String args[]){
//定义一个java码农
ICoder coder = new JavaCoder("Zhang");
//定义一个产品经理
ICoder proxy = new CoderProxy(coder);
//让产品经理实现一个需求
proxy.implDemands();
}
}
运行程序,结果如下:
Zhang implemented demand:Add user manageMent in JAVA!
总结
我们对上面的事例做一个简单的抽象:
代理模式包含如下角色:
- Subject:抽象主题角色。可以是接口,也可以是抽象类。
- RealSubject:真实主题角色。业务逻辑的具体执行者。
- ProxySubject:代理主题角色。内部含有RealSubject的引用,负责对真实角色的调用,并在真实主题角色处理前后做预处理和善后工作。
代理模式优点:
- 职责清晰 真实角色只需关注业务逻辑的实现,非业务逻辑部分,后期通过代理类完成即可。
- 高扩展性 不管真实角色如何变化,由于接口是固定的,代理类无需做任何改动。
动态代理
动态代理需要使用到反射的知识,可以在这篇博文中学习到。
前面讲的主要是静态代理。那么什么是动态代理呢?
假设有这么一个需求,在方法执行前和执行完成后,打印系统时间。这很简单嘛,非业务逻辑,只要在代理类调用真实角色的方法前、后输出时间就可以了。像上例,只有一个implDemands
方法,这样实现没有问题。但如果真实角色有10个方法,那么我们要写10遍完全相同的代码。有点追求的码农,肯定会对这种方法感到非常不爽。有些机智的小伙伴可能想到了用AOP
解决这个问题。非常正确。莫非AOP
和动态代理有什么关系?没错!AOP
用的恰恰是动态代理。
代理类在程序运行时创建的代理方式被称为动态代理。也就是说,代理类并不需要在Java
代码中定义,而是在运行时动态生成的。相比于静态代理, 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理,而不用修改每个代理类的函数。对于上例打印时间的需求,通过使用动态代理,我们可以做一个“统一指示”,对所有代理类的方法进行统一处理,而不用逐一修改每个方法。下面我们来具体介绍下如何使用动态代理方式实现我们的需求。
与静态代理相比,抽象角色、真实角色都没有变化。变化的只有代理类。因此,抽象角色、真实角色,参考ICoder
和JavaCoder
。
在使用动态代理时,我们需要定义一个位于代理类与委托类之间的中介类,也叫动态代理类,这个类被要求实现InvocationHandler
接口:
public class CoderDynamicProxy implements InvocationHandler{
//被代理的实例
private ICoder coder;
public CoderDynamicProxy(ICoder _coder){
this.coder = _coder;
}
//调用被代理的方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(System.currentTimeMillis());
Object result = method.invoke(coder, args);
System.out.println(System.currentTimeMillis());
return result;
}
}
当我们调用代理类对象的方法时,这个“调用”会转送到中介类的invoke
方法中,参数method
标识了我们具体调用的是代理类的哪个方法,args
为这个方法的参数。
我们通过一个场景类,模拟用户找产品经理更改需求。
public class DynamicClient {
public static void main(String args[]){
//要代理的真实对象
ICoder coder = new JavaCoder("Zhang");
//创建中介类实例
InvocationHandler handler = new CoderDynamicProxy(coder);
//获取类加载器(这里使用了反射的知识)
ClassLoader cl = coder.getClass().getClassLoader();
//动态产生一个代理类
ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);
//通过代理类,执行doSomething方法;
proxy.implDemands("Modify user management");
}
}
执行结果如下:
1501728574978
Zhang implemented demand:Modify user management in JAVA!
1501728574979
通过上述代码,就实现了,在执行委托类的所有方法前、后打印时间。
还是那个熟悉的小张,但我们并没有创建代理类,也没有时间ICoder
接口。
这就是动态代理。
总结
总结一下,一个典型的动态代理可分为以下四个步骤:
- 创建抽象角色
- 创建真实角色
- 通过实现
InvocationHandler
接口创建中介类 - 通过场景类,动态生成代理类