代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。
代理模式结构图
image.png
举例
假如你要租房子，上班没有时间自己找，只有把找房子的事委托给房屋中介去做，而你只需要把房子的位置，户型，大小，价格，交通等需求告知房屋中介，委托中介帮你帮找房子，中介会按照你的需求去帮你匹配。然后找到房子后中介就会通知你。这就是代理思想在现实中的一个例子。
image.png
静态代理
所谓的静态代理就是在代码运行之前，代理类就已经存在，通常情况下， 静态代理中的代理类和委托类会实现同一接口或是派生自相同的父类
静态代理简单实现
1.抽象角色
基于面向对象的思想，首先定义一个码农接口,它有一个实现用户需求的方法。
public interface ICoder {
public void implDemands(String demandName);
}
2.真实角色
假设小张是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!");
}
}
3.代理角色
委屈一下产品经理，将其命名为码农代理类，同时让他实现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 class Test {
public static void main(String[] args){
//定义一个java码农
ICoder coder = new JavaCoder("Zhang");
//定义一个产品经理
ICoder proxy = new CoderProxy(coder);
//让产品经理实现一个需求
proxy.implDemands("Add user manageMent");
}
}
运行程序，结果如下：
Zhang implemented demand:Add user manageMent in JAVA!
产品经理充当了程序员的代理，客户把需求告诉产品经理，并不需要和程序员接触。产品经理就把客户的需求转达了一下。
产品经理当然不只是转达用户需求，他还有很多事情可以做。比如，该项目决定不接受新增功能的需求了，对修CoderProxy类做一些修改：
public class CoderProxy implements ICoder {
private ICoder coder;
public CoderProxy(ICoder coder){
this.coder = coder;
}
@Override
public void implDemands(String demandName) {
if(demandName.startsWith("Add")){
System.out.println("No longer receive 'Add' demand");
return;
}
coder.implDemands(demandName);
}
}
这样，当客户再有增加功能的需求时，产品经理就直接回绝了，程序员无需再对这部分需求做过滤。
总结
代理模式最主要的就是有一个公共接口（ICoder），一个具体的类（JavaCoder），一个代理类（CoderProxy）。
我们对上面的事例做一个简单的抽象：
image
代理模式包含如下角色：
- Subject:抽象主题角色。可以是接口，也可以是抽象类。
- RealSubject:真实主题角色。业务逻辑的具体执行者。
- ProxySubject:代理主题角色。内部含有RealSubject的引用,负责对真实角色的调用，并在真实主题角色处理前后做预处理和善后工作。
代理模式优点：
- 职责清晰 真实角色只需关注业务逻辑的实现，非业务逻辑部分，后期通过代理类完成即可。
- 高扩展性 不管真实角色如何变化，由于接口是固定的，代理类无需做任何改动。
动态代理
前面讲的主要是静态代理。那么什么是动态代理呢？
代理类在程序运行时创建的代理方式被称为动态代理。也就是说，这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指令”动态生成的
假设有这么一个需求，在方法执行前和执行完成后，打印系统时间。这很简单嘛，非业务逻辑，只要在代理类调用真实角色的方法前、后输出时间就可以了。像上例，只有一个implDemands方法，这样实现没有问题。但如果真实角色有10个方法，那么我们要写10遍完全相同的代码。有点追求的码农，肯定会对这种方法感到非常不爽。有些机智的小伙伴可能想到了用AOP解决这个问题。非常正确。莫非AOP和动态代理有什么关系？没错！AOP用的恰恰是动态代理。
代理类在程序运行时创建的代理方式被称为动态代理。也就是说，代理类并不需要在Java代码中定义，而是在运行时动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。对于上例打印时间的需求，通过使用动态代理，我们可以做一个“统一指示”，对所有代理类的方法进行统一处理，而不用逐一修改每个方法。下面我们来具体介绍下如何使用动态代理方式实现我们的需求。
与静态代理相比，抽象角色、真实角色都没有变化。变化的只有代理类。因此，抽象角色、真实角色，参考ICoder和JavaCodr。
在使用动态代理时，我们需要定义一个位于代理类与委托类之间的中介类，也叫动态代理类，这个类被要求实现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 InvocationTargetException, IllegalAccessException {
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance();
System.out.println(dateFormat.format(date));
Object result = method.invoke(coder,args);
System.out.println(dateFormat.format(date));
return result;
}
}
我们调用代理类对象的方法时，这个“调用”会转送到中介类的invoke方法中，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。
我们通过一个场景类，模拟用户找产品经理更改需求。
public class Test {
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");
}
}
运行结果如下
2019-1-11 16:28:55
Zhang implemented demand:Modify user management in JAVA!
2019-1-11 16:28:55
通过上述代码，就实现了，在执行委托类的所有方法前、后打印时间。还是那个熟悉的小张，但我们并没有创建代理类，也没有时间ICoder接口。这就是动态代理。
总结
总结一下，一个典型的动态代理可分为以下四个步骤：
- 创建抽象角色
- 创建真实角色
- 通过实现InvocationHandler接口创建中介类
- 通过场景类，动态生成代理类
网友评论