简介
代理模式是我们使用率比较高的一个模式。它的定义是为其他对象提供一种代理以控制对这个对象的访问。
如果只是从定义上来看，可能无法理解。为什么要用代理来对这个对象来访问，我直接访问不行吗？行，当然行了。但是我们使用代理自然是有代理的优势，我们举个简单例子来说明一下。
有一个房东，他有一座房子要出售。但是房子买卖呢，我们知道，需要让买房的人来看房，有意向之后还需要和顾客签订一系列的合同，实在复杂。我们的房东比较懒，他不想做那么多事情，他只想单纯卖房子。于是他找了一个中介，由中介来代替房东做这些事情。这个中介就可以说是我们的代理。如果觉得还是觉得抽象的话，下面我们会用实际开发代码来演示代理模式，深入理解。
代理模式的三个重要角色：
Subject抽象主题角色
- 抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。
RealSubject具体主题角色
- 被委托角色，被代理角色。也就是我们的房东
Proxy代理主题角色
- 也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。（我们的中介）
关于我们的代理模式大致可以分成两种，静态代理模式和动态代理模式。下面我们会用代码来分别演示一下两种代理的区别。
静态代理
静态代理呢，就是我们的每一个具体主题角色都有自己专门的代理角色。我们用代码来说吧，我们开发业务的时候，需要抽象service接口和具体实现。我们模拟一个增删改查。
package proxydemo;
public interface Service {
//比如我们的业务有这四个方法
void add();
void delete();
void update();
void query();
}
然后就是我们去实现这个接口
package proxydemo;
public class ServiceImpl implements Service {
@Override
public void add() {
System.out.println("增加操作");
}
@Override
public void delete() {
System.out.println("删除操作");
}
@Override
public void update() {
System.out.println("更新操作");
}
@Override
public void query() {
System.out.println("查询操作");
}
}
这个service接口就可以看作是我们的抽象主题角色，具体实现类就是我们的具体主题角色。我们可以在客户端使用
package proxydemo;
public class Client {
public static void main(String[] args) {
ServiceImpl service = new ServiceImpl();
service.add();
service.delete();
service.update();
service.query();
}
}
|----------控制台输出--------|
增加操作
删除操作
更新操作
查询操作
Process finished with exit code 0
但是如果这个时候来了一个需求，说要在我们使用方法后，日志能够记录下来是进行了什么操作。那我们容易想到的就是在我们的实现类去修改，在使用后方法后用日志记录下来。但是我们在开发中最忌讳就是修改原有的代码，因为我们是要符合开闭原则的。所有我们就可以用代理模式来
package proxydemo;
//我们的代理角色，在不修改原来的代码情况下，扩展了日志的功能
public class ProxyServiceImpl implements Service{
//使用组合模式代替继承
private ServiceImpl service;
public void setService(ServiceImpl service) {
this.service = service;
}
@Override
public void add() {
System.out.println("日志输出：使用add方法");
service.add();
}
@Override
public void delete() {
System.out.println("日志输出：使用delete方法");
service.delete();
}
@Override
public void update() {
System.out.println("日志输出：使用update方法");
service.update();
}
@Override
public void query() {
System.out.println("日志输出：使用query方法");
service.query();
}
}
然后在我们的客户端使用的时候，只需要给代理角色设置需要被代理的角色就行
package proxydemo;
public class Client {
public static void main(String[] args) {
//实例化我们原来的功能
ServiceImpl service = new ServiceImpl();
//实例我们的代理角色
ProxyServiceImpl proxyService = new ProxyServiceImpl();
//设置需要被代理的角色
proxyService.setService(service);
//使用有日志功能的代理方法
proxyService.add();
proxyService.delete();
proxyService.update();
proxyService.query();
}
}
|----------控制台输出--------|
日志输出：使用add方法
增加操作
日志输出：使用delete方法
删除操作
日志输出：使用update方法
更新操作
日志输出：使用query方法
查询操作
Process finished with exit code 0
静态代理总结
好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 一些非核心的功能交给了代理角色，实现了业务的分工
- 公共业务扩展的时候，方便集中管理
缺点：
- 上面也说了，每一个真实角色就会产生一个代理角色，代码量翻倍
动态代理
动态代理就是为了解决我们上面那个代码量大的解决问题，也是我们真正在开发中会去使用的代理模式。我们的动态代理有两种方式去实现，一个是JDK动态代理（面向接口），一个是CGlib动态代理（面向类）。我们这里主要是介绍概念，所以就用JDK动态代理来实现我们上面的例子，另一种的使用可以看这里（动态代理的两种方式以及区别）
(补充：现在也出了Javassit去实现了)
关于JDK的动态代理，我们在java.lang.reflect包下，有这么一个接口
Interface InvocationHandler ：
InvocationHandler是由代理实例的调用处理程序实现的接口 。
每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的
invoke方法。
还有一个Proxy类，它提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。
可以通过反射来创建代理
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
new Class<?>[] { Foo.class },
handler);
话不多说，我们用代码了实现一下更容易明白这些抽象的解释。
例子还是调用我们的上面的例子，只不过这个时候，我们的代理类不需要去实现了，我们实现InvocationHandler接口写调用程序就行了。
package proxydemo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
public Object target;
public void setTarget(Object object) {
this.target = object;
}
//通过反射生成得到代理类
public Object getProxy(){
//三个参数，当前的类加载器，被代理的接口，以及一个InvocationHandler，当前即可
return Proxy.newProxyInstance
(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
//处理代理实例，返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//通过反射来调用方法
Object result = method.invoke(target,args);
return result;
}
}
我们在我们的客户端使用的时候，需要去实例化一个InvocationHandler就行了。
package proxydemo;
public class Client {
public static void main(String[] args) {
//实例一个我们的需要被代理的角色
ServiceImpl service = new ServiceImpl();
//实例我们的代理调用处理
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//设计被代理的角色
pih.setTarget(service);
//通过反射了来实例我们的代理类
Service proxyService = (Service) pih.getProxy();
proxyService.add();
proxyService.delete();
proxyService.update();
proxyService.query();
}
}
|----------控制台输出--------|
增加操作
删除操作
更新操作
查询操作
Process finished with exit code 0
具体的调用过程就是
这个时候如果我们要增加一个日志输出功能的话，只需要在我们的ProxyInvocationHandler里面增加就行。
package proxydemo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Object target;
//设计被代理的接口
public void setTarget(Object object) {
this.target = object;
}
//通过反射生成得到代理类
public Object getProxy(){
//三个参数，当前的类加载器，被代理的接口，以及一个InvocationHandler，当前即可
return Proxy.newProxyInstance
(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
//处理代理实例，返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//通过反射来调用方法
log(method.getName()); //将方法名传给我们的输出方法
Object result = method.invoke(target,args);
return result;
}
//新增加的日志输出功能
public void log(String msg){
System.out.println("日志输出，调用了"+msg+"方法");
}
}
客户端输出：
日志输出，调用了add方法
增加操作
日志输出，调用了delete方法
删除操作
日志输出，调用了update方法
更新操作
日志输出，调用了query方法
查询操作
Process finished with exit code 0
看到这里可能还是会有小伙伴不是很懂， 上面我们的静态代理实现了一个代理类，这里不也是实现了一个调用处理吗？注意，这里我们的调用处理可是一个可以复用的，只要你是实现了基于接口实现的业务就可以调用。比如我们一个庞大的业务的层，有很多的servcie接口，都可以统一使用这个动态代理模板。我们不需要在实现阶段去关心代理谁，在使用的时候才指定代理谁！！！
总结
关于代理我们也了解，它主要的优点也很明显
- 职责清晰。真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件事务，附带的结果就是编程简洁清晰。
- 高扩展性。具体主题角色是随时都会发生变化的，只要它实现了接口，甭管它如何变化，都逃不脱如来佛的手掌（接口），那我们的代理类完全就可以在不做任何修改的情况下使用。
- 智能化。都不用自己实现代理，只需要在使用的时候去指定就行了。
使用场景
关于代理模式应用的场景，一个比较典型的动态代理就是Spring AOP了，我们用AOP来面向切面编程。在我们完成核心业务之后，然后可以横向扩展我们的周边业务，比如日志输出，监控等。具体的可以去了解AOP，了解之后对其他的场景，下次一见到就能看出来这用到了代理模式了。
参考资料
遇见狂神说：通俗易懂的23中设计模式教学（视频）
设计模式之禅（第二版）