慢啃设计模式：代理模式Proxy

代理模式也是生活中比较常见的一种模式，比如，现在火车站在城市中各处都会设置代售点，这就是一种代理模式。

代理模式的组成

代理模式由三种角色构成：

抽象角色。通过接口或抽象类声明真实角色实现的业务方法。所谓抽象角色，实际上就是定义真实中角色所能完成的动作，但不做具体实现。

真实角色。实现抽象角色，实现真实角色所要实现的业务逻辑，供代理角色调用。真实角色需要实现抽象角色中定义的动作。

代理角色。实现抽象角色，是真实角色的代理，通过调用真实角色的业务逻辑方法来实现抽象方法，并附加自己的操作。代理角色可以通过直接调用真实角色的方法实现业务逻辑，自然也可以在此前后添加自己的操作代码。

以火车票售票为例，抽象角色即为售票处，它有售卖火车票的功能；真是角色就是火车站的售票处，它可以完成售票功能；代售点则为代理角色，它最终通过火车站的售票处完成售票功能，但又可以有自己的操作，比如手续费。

代理模式的类图

模拟代售点火车售票

首先我们创建一个售票接口，其扮演抽象角色：

package com.proxy.ticket;

/**
* 售票处
*/
public interface TicketOffice {

/**
* 售票
* @param count 售票张数
*/
public void sale(int count);

}

接下来创建火车站售票处，这个是真实角色，真的可以买票的地方：

package com.proxy.ticket;

/**
* 火车站售票处
*/
public class StationTicketOffice implements TicketOffice{

/* (non-Javadoc)
* @see com.proxy.ticket.TicketOffice#sale(int)
*/
public void sale(int count) {
System.out.println("卖出" + count + "张票。");
}

}

最后，我们可以开设火车票代售点了：

package com.proxy.ticket;

/**
* 火车票代售点
*/
public class ProxyStationTicketOffice implements TicketOffice{

// 与真实角色的联系纽带
private TicketOffice office;

/**
* 构造代售点
* @param office
*/
public ProxyStationTicketOffice (TicketOffice office){
this.office = office;
}

/* (non-Javadoc)
* @see com.proxy.ticket.TicketOffice#sale(int)
*/
public void sale(int count) {
// 提示不受理退票
System.out.println("代售点不受理退票");
// 售票功能由真实角色完成
this.office.sale(count);
// 收取手续费
System.out.println("收取手续费5元");
}

}

至此，我们就可以选择去火车站买票或者到代售点买票了。现在模拟一下买票：

package com.proxy.ticket;

/**
* 代理模式测试类
*/
public class TestTicketOffice {
public static void main(String[] args) {
// 这里是火车站售票处
TicketOffice station = new StationTicketOffice();
// 这是一家代售点
TicketOffice proxy = new ProxyStationTicketOffice (station);

// 去火车站买一张票
station.sale(1);
// 去代售点买一张票
proxy.sale(1);
}
}

执行结果：

卖出1张票。
代售点不受理退票
卖出1张票。
收取手续费5元

静态代理模式的局限性

实际上，上面这种通过实现接口或者继承抽象类的方式实现的代理模式，被称作静态代理模式。静态代理模式的所有代理类都在编译期就已经确定，并生成对应的class文件，并且一个代理类只为一个接口服务。这里举的例子是代购火车票，那如果连付款我们也要代理呢？按照静态代理模式这种思路，首先我们要创建一个付款接口作为抽象角色，然后再建一个银行付款类充当真实角色，那么代理角色可能就是支付宝。

这样下去，我们需要创建多少个代理类呢？

动态代理模式

既然有静态代理模式，自然有与之对应的动态代理模式。动态代理模式不需要开发者手工写各种代理类，它的代理类是由Java反射机制在程序运行时动态创建的。

要实现动态代理，我们需要使用JDK中java.lang.reflect包下的Proxy类和InvocationHandler接口，它们提供了动态代理的功能。Proxy的newProxyInstance方法可以创建一个代理对象，它需要三个参数：

ClassLoader loader：第一个参数是类加载器，用于定义代理类。

Class<?>[] interfaces：第二个参数是接口数组，在动态定义代理类的同时，会让代理类实现这些接口。

InvocationHandler h：第三个参数为回调句柄。

InvocationHandler接口下只有一个方法invoke需要重写，代理对象在调用其业务代码时，实际上就是执行这个invoke方法。它也有三个参数：

Object proxy：代理对象。

Method method：需要代理的方法

Object[] args：方法执行传递的参数

仍以前面的火车售票为例，不修改TicketOffice和StationTicketOffice类，来看看动态代理的代理类如何实现：

package com.proxy.ticket;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
* 代理工厂
*/
public class ProxyFactory implements InvocationHandler{

/**
* 保存原始对象（真实角色）
*/
private Object target;

/**
* 获取代理对象（代理角色）
* @param o
* @return
*/
public Object getProxy(Object o){
this.target = o;
Class<?> clazz = o.getClass();

// 创建代理对象实例
return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}

/**
* 回调处理
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("开始代理");
// 业务仍由真实角色完成
Object result = method.invoke(target, args);
System.out.println("完成代理");

// 返回结果
return result;
}

}

当然，测试代码也会有一些改动：

package com.proxy.ticket;

/**
* 测试JDK动态代理
*/
public class TestJDKProxy {
public static void main(String[] args) {
// 创建代理工厂
ProxyFactory factory = new ProxyFactory();

// 这里是火车站售票处
TicketOffice ticket = new StationTicketOffice();
// 获取代理对象
TicketOffice t = (TicketOffice) factory.getProxy(ticket);
// 去买两张票
t.sale(2);
}
}

执行结果如下：

开始代理
卖出2张票。
完成代理

因为使用了动态代理，所以，我们也可以用这个代理类来处理付款代理了。

package com.proxy.ticket;

/**
* 付款
*/
public interface Payment {

/**
* 支付
*
* @param d
*/
public void pay(double d);

}

package com.proxy.ticket;

/**
* 银行付款
*/
public class BankPayment implements Payment{

public void pay(double d) {
System.out.println("本次支付" + d + "元");
}

}

无需对代理类做任何修改，更不需要添加新的代理类，测试代码如下：

package com.proxy.ticket;

/**
* 测试JDK动态代理
*/
public class TestJDKProxy {
public static void main(String[] args) {
// 创建代理工厂
ProxyFactory factory = new ProxyFactory();

// 这里是银行付款
Payment pay = new BankPayment();
// 付款代理
Payment payProxy = (Payment) factory.getProxy(pay);
// 支付15元
payProxy.pay(15.0);
}
}

执行结果：

开始代理
本次支付15.0元
完成代理

CGLIB实现动态代理

从前面的代码可以看出，无论是静态代理，还是动态代理，都需要先定义一个接口。这样就会造成普通的类无法对其生成代理类，对我们来说它也是有局限性的。不过好在我们可以使用cglib库来突破这个局限，对普通的java类动态的生成代理类。

cglib是针对类生成代理类的，它的原理是对指定对象的类生成一个子类，并覆盖其中的方法实现代理功能。由于采用的是继承机制，所以如果一个类是final的，cglib是无法对其进行代理的。下面是一个简单的cglib代理对象生成类：

package com.cglib.proxy;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
* cglib生成代理类
*
*/
public class CglibProxy implements MethodInterceptor{

// 原始对象
private Object target;

/**
* 生成代理对象
* @param o
* @return
*/
public Object getProxy(Object o){
this.target = o;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(o.getClass());
enhancer.setCallback(this);
return enhancer.create();
}

/**
* 代理回调
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {

System.out.println("代理开始");
// 三种方式调用被代理对象的方法
method.invoke(target, args);
proxy.invokeSuper(obj, args);
proxy.invoke(target, args);
System.out.println("代理完成");
return null;
}

}

上面是一个较为通用的代理对象生成类，现在我们创建一个类，它不实现任何接口：

package com.cglib.proxy;

/**
* 不实现任何借口的普通类
*
*/
public class Normal {

public void execute(){
System.out.println("我是一个普通类");
}

}

再来写一个测试类：

package com.cglib.proxy;

public class TestCglibProxy {
public static void main(String[] args) {
CglibProxy proxy = new CglibProxy();
Normal normal = new Normal();
Normal proxyNormal = (Normal) proxy.getProxy(normal);
proxyNormal.execute();
}
}

执行结果：

代理开始
我是一个普通类
我是一个普通类
我是一个普通类
代理完成

可以看到，Normal类的对象已经被代理了。当我们调用execute时，代理类进行了干预。当然，如果Normal类有多个方法，那么它的任何一个方法在执行时，都会被代理。那么问题来了，如果我恰恰有一个类不希望被代理类干预呢？

cglib还提供了回调过滤器，它的作用就是控制哪个方法被哪个回调干预。现在我们需要修改一下getProxy方法：

/**
* 生成代理对象
* @param o
* @return
*/
public Object getProxy(Object o){
this.target = o;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(o.getClass());
// 赋予多个回调，NoOp.INSTANCE是一个没有任何操作的回调
enhancer.setCallbacks(new Callback[]{this, NoOp.INSTANCE});
// 指定回调过滤器
enhancer.setCallbackFilter(new CallbackFilter() {

/**
* 根据方法名控制当前操作受哪个回调干预
*
* @param method 当前执行的方法
* @return 前面设置的回调数组的下标
*/
public int accept(Method method) {
if("execute".equals(method.getName())){
return 0;
}
return 1;
}
});
return enhancer.create();
}

给Normal类添加一些其它方法，然后再次在测试类中调用，就会发现，只有调用execute方法时，代理对象才会起作用。

总结

设计模式能够让我们写出更为优雅的代码，如果不使用代理模式，最原始的实现方式恐怕就是去修改真实角色的方法，追加一些操作。但因为代理模式的存在，我们可以不修改原来的类，通过一个代理类，来管理其他类。比如我们要实现日志功能，就可以添加一个日志代理类，将所有的类都代理起来，在这些类的方法执行时，记录下类名、方法名、参数等信息。实际上Spring框架中就使用了代理模式来管理事务，事务开启、回调、提交操作都是代理类完成的，我们只需要关心数据库操作即可。