研磨设计模式 之 代理模式（Proxy）3——跟着cc学设计系列
（1）代理模式的功能
代理模式是通过创建一个代理对象，用这个代理对象去代表真实的对象，客户端得到这个代理对象过后，对客户端没有什么影响，就跟得到了真实对象一样来使用。
?????? 当客户端操作这个代理对象的时候，实际上功能最终还是会由真实的对象来完成，只不过是通过代理操作的，也就是客户端操作代理，代理操作真正的对象。
?????? 正是因为有代理对象夹在客户端和被代理的真实对象中间，相当于一个中转，那么在中转的时候就有很多花招可以玩，比如：判断一下权限，如果没有足够的权限那就不给你中转了，等等。
（2）代理的分类
事实上代理又被分成多种，大致有如下一些：
?????? 在这些代理类型中，最常见的是：虚代理、保护代理、远程代理和智能指引这几种。本书主要讨论和示例了虚代理和保护代理，这是实际开发中使用频率最高的。
对于远程代理，没有去讨论，因为在Java中，远程代理的典型体现是RMI技术，要把远程代理讲述清楚，就需要把RMI讲述清楚，这不在本书讨论范围之内。
对于智能指引，基本的实现方式和保护代理的实现类似，只是实现的具体功能有所不同，因此也没有具体去讨论和示例。
（3）虚代理的示例
?????? 前面的例子就是一个典型的虚代理的实现。
起初每个代理对象只有用户编号和姓名的数据，直到需要的时候，才会把整个用户的数据装载到内存中来。
也就是说，要根据需要来装载整个UserModel的数据，虽然用户数据对象是前面已经创建好了的，但是只有用户编号和姓名的数据，可以看成是一个“虚”的对象，直到通过代理把所有的数据都设置好，才算是一个完整的用户数据对象。
（4）copy-on-write
?????? 拷贝一个大的对象是很消耗资源的，如果这个被拷贝的对象从上次操作以来，根本就没有被修改过，那么再拷贝这个对象是没有必要的，白白消耗资源而已。那么就可以使用代理来延迟拷贝的过程，可以等到对象被修改的时候才真的对它进行拷贝。
?????? copy-on-write可以大大降低拷贝大对象的开销，因此它算是一种优化方式，可以根据需要来拷贝或者克隆对象。
（5）具体目标和代理的关系
?????? 从代理模式的结构图来看，好像是有一个具体目标类就有一个代理类，其实不是这样的。如果代理类能完全通过接口来操作它所代理的目标对象，那么代理对象就不需要知道具体的目标对象，这样就无须为每一个具体目标类都创建一个代理类了。
?????? 但是，如果代理类必须要实例化它代理的目标对象，那么代理类就必须知道具体被代理的对象，这种情况下，一个具体目标类通常会有一个代理类。这种情况多出现在虚代理的实现里面。
（6）代理模式调用顺序示意图
代理模式调用顺序如图11.4所示：
?
图11.4? 代理模式调用顺序示意图
?????? 保护代理是一种控制对原始对象访问的代理，多用于对象应该有不同的访问权限的时候。保护代理会检查调用者是否具有请求所必需的访问权限，如果没有相应的权限，那么就不会调用目标对象，从而实现对目标对象的保护。
?????? 还是通过一个示例来说明。
1：示例需求
现在有一个订单系统，要求是：一旦订单被创建，只有订单的创建人才可以修改订单中的数据，其他人不能修改。
相当于现在如果有了一个订单对象实例，那么就需要控制外部对它的访问，满足条件的可以访问，而不满足条件的就不能访问了。
2：示例实现
（1）订单对象的接口定义
要实现这个功能需要，先来定义订单对象的接口，很简单，主要是对订单对象的属性的getter/setter方法，示例代码如下：
/**
?* 订单对象的接口定义
?*/
public interface OrderApi {
??? /**
??? ?* 获取订单订购的产品名称
??? ?* @return 订单订购的产品名称
??? ?*/
??? public String getProductName();
??? /**
??? ?* 设置订单订购的产品名称
??? ?* @param productName 订单订购的产品名称
??? ?* @param user 操作人员
??? ?*/
??? public void setProductName(String productName,String user);
??? /**
??? ?* 获取订单订购的数量
??? ?* @return 订单订购的数量
??? ?*/
??? public int getOrderNum();
??? /**
??? ?* 设置订单订购的数量
??? ?* @param orderNum 订单订购的数量
??? ?* @param user 操作人员
??? ?*/
??? public void setOrderNum(int orderNum,String user);
??? /**
??? ?* 获取创建订单的人员
??? ?* @return 创建订单的人员
??? ?*/
??? public String getOrderUser();
??? /**
??? ?* 设置创建订单的人员
??? ?* @param orderUser 创建订单的人员
??? ?* @param user 操作人员
??? ?*/
??? public void setOrderUser(String orderUser,String user);
}
（2）订单对象
接下来定义订单对象，原本订单对象需要描述的属性很多，为了简单，只描述三个就好了，示例代码如下：
/**
?* 订单对象
?*/
public class Order implements OrderApi{
??? /**
??? ?* 订单订购的产品名称
??? ?*/
??? private String productName;
??? /**
??? ?* 订单订购的数量
??? ?*/
??? private int orderNum;
??? /**
??? ?* 创建订单的人员
??? ?*/
??? private String orderUser;
?
??? /**
??? ?* 构造方法，传入构建需要的数据
??? ?* @param productName 订单订购的产品名称
??? ?* @param orderNum 订单订购的数量
??? ?* @param orderUser 创建订单的人员
??? ?*/
??? public Order(String productName,int orderNum,String orderUser){
?????? this.productName = productName;
?????? this.orderNum = orderNum;
?????? this.orderUser = orderUser;
??? }
?
??? public String getProductName() {
?????? return productName;
??? }
??? public void setProductName(String productName,String user) {
?????? this.productName = productName;
??? }
??? public int getOrderNum() {
?????? return orderNum;
??? }
??? public void setOrderNum(int orderNum,String user) {
?????? this.orderNum = orderNum;
??? }
??? public String getOrderUser() {
?????? return orderUser;
??? }
??? public void setOrderUser(String orderUser,String user) {
?????? this.orderUser = orderUser;
??? }
}
（3）订单对象的代理
创建好了订单对象，需要创建对它的代理对象了。既然订单代理就相当于一个订单，那么最自然的方式就是让订单代理跟订单对象实现一样的接口；要控制对订单setter方法的访问，那么就需要在代理的方法里面进行权限判断，有权限就调用订单对象的方法，没有权限就提示错误并返回。示例代码如下：
/**
?* 订单的代理对象
?*/
public class OrderProxy implements OrderApi{
??? /**
??? ?* 持有被代理的具体的目标对象
??? ?*/
??? private Order order=null;
??? /**
??? ?* 构造方法，传入被代理的具体的目标对象
??? ?* @param realSubject 被代理的具体的目标对象
??? ?*/
??? public OrderProxy(Order realSubject){
?????? this.order = realSubject;
??? }
?
????public?void setProductName(String productName,String user) {
?????? //控制访问权限，只有创建订单的人员才能够修改
?????? if(user!=null && user.equals(this.getOrderUser())){
?????????? order.setProductName(productName, user);
?????? }else{
?????????? System.out.println("对不起"+user
+"，您无权修改订单中的产品名称。");
?????? }
??? }
??? public void setOrderNum(int orderNum,String user) {
?????? //控制访问权限，只有创建订单的人员才能够修改
?????? if(user!=null && user.equals(this.getOrderUser())){
?????????? order.setOrderNum(orderNum, user);
?????? }else{
?????????? System.out.println("对不起"+user
+"，您无权修改订单中的订购数量。");
?????? }
??? }
??? public void setOrderUser(String orderUser,String user) {
?????? //控制访问权限，只有创建订单的人员才能够修改
?????? if(user!=null && user.equals(this.getOrderUser())){
?????????? order.setOrderUser(orderUser, user);
?????? }else{
?????????? System.out.println("对不起"+user
+"，您无权修改订单中的订购人。");
?????? }
??? }
?
??? public int getOrderNum() {
?????? return this.order.getOrderNum();
??? }
??? public String getOrderUser() {
?????? return this.order.getOrderUser();
??? }
??? public String getProductName() {
?????? return this.order.getProductName();
??? }
??? public String toString(){
?????? return "productName="+this.getProductName()+",orderNum="
+this.getOrderNum()+",orderUser="+this.getOrderUser();
??? }
}
（4）测试代码
一起来看看如何使用刚刚完成的订单代理，示例代码如下：
public class Client {
??? public static void main(String[] args) {
?????? //张三先登录系统创建了一个订单
?????? OrderApi order = new OrderProxy(
new Order("设计模式",100,"张三"));
?????? //李四想要来修改，那就会报错
?????? order.setOrderNum(123, "李四");
?????? //输出order
?????? System.out.println("李四修改后订单记录没有变化："+order);
?????? //张三修改就不会有问题
?????? order.setOrderNum(123, "张三");
?????? //再次输出order
?????? System.out.println("张三修改后，订单记录："+order);
??? }
}
?????? 运行结果如下：
对不起李四，您无权修改订单中的订购数量。
李四修改后订单记录没有变化：
productName=设计模式,orderNum=100,orderUser=张三
张三修改后，订单记录：productName=设计模式,orderNum=123,orderUser=张三
?????? 从上面的运行结果就可以看出，在通过代理转调目标对象的时候，在代理对象里面，对访问的用户进行了权限判断，如果不满足要求，就不会转调目标对象的方法，从而保护了目标对象的方法，只让有权限的人操作。
?????? Java对代理模式提供了内建的支持，在java.lang.reflect包下面，提供了一个Proxy的类和一个InvocationHandler的接口。
?????? 通常把前面自己实现的代理模式，称为Java的静态代理。这种实现方式有一个较大的缺点，就是如果Subject接口发生变化，那么代理类和具体的目标实现都要变化，不是很灵活，而使用Java内建的对代理模式支持的功能来实现则没有这个问题。
?????? 通常把使用Java内建的对代理模式支持的功能来实现的代理称为Java的动态代理。动态代理跟静态代理相比，明显的变化是：静态代理实现的时候，在Subject接口上定义很多的方法，代理类里面自然也要实现很多方法；而动态代理实现的时候，虽然Subject接口上定义了很多方法，但是动态代理类始终只有一个invoke方法。这样当Subject接口发生变化的时候，动态代理的接口就不需要跟着变化了。
?????? Java的动态代理目前只能代理接口，基本的实现是依靠Java的反射机制和动态生成class的技术，来动态生成被代理的接口的实现对象。具体的内部实现细节这里不去讨论。如果要实现类的代理，可以使用cglib（一个开源的Code Generation Library）。
?????? 还是来看看示例，那就修改上面保护代理的示例，看看如何使用Java的动态代理来实现同样的功能。
（1）订单接口的定义是完全一样的，就不去赘述了。
（2）订单对象的实现，只是添加了一个toString，以方便测试输出，这里也不去示例了。在前面的示例中，toString是实现在代理类里面了。
（3）直接看看代理类的实现，大致有如下变化：
示例代码如下：
/**
?* 使用Java中的动态代理
?*/
public class DynamicProxy implements InvocationHandler{
??? /**
??? ?* 被代理的对象
??? ?*/
??? private OrderApi order = null;
??? /**
??? ?* 获取绑定好代理和具体目标对象后的目标对象的接口
??? ?* @param order 具体的订单对象，相当于具体目标对象
??? ?* @return 绑定好代理和具体目标对象后的目标对象的接口
??? ?*/
??? public OrderApi getProxyInterface(Order order){
?????? //设置被代理的对象，好方便invoke里面的操作
?????? this.order = order;
?????? //把真正的订单对象和动态代理关联起来
?????? OrderApi orderApi = (OrderApi) Proxy.newProxyInstance(
????????????? order.getClass().getClassLoader(),
????????????? order.getClass().getInterfaces(),
????????????? this);
?????? return orderApi;
??? }
?
??? public Object invoke(Object proxy, Method method, Object[] args)
?????????? throws Throwable {
?????? //如果是调用setter方法就需要检查权限
?????? if(method.getName().startsWith("set")){
?????????? //如果不是创建人，那就不能修改
?????????? if(order.getOrderUser()!=null
&& order.getOrderUser().equals(args[1])){
????????????? //可以操作
????????????? return method.invoke(order, args);
?????????? }else{
????????????? System.out.println("对不起，"+args[1]
+"，您无权修改本订单中的数据");
?????????? }
?????? }else{
?????????? //不是调用的setter方法就继续运行
?????????? return method.invoke(order, args);
?????? }
?????? return null;
??? }
}
要看明白上面的实现，需要熟悉Java反射的知识，这里就不去展开了。
（4）看看现在的客户端如何使用这个动态代理，示例代码如下：
public class Client {
??? public static void main(String[] args) {
?????? //张三先登录系统创建了一个订单
?????? Order order = new Order("设计模式",100,"张三");
?
?????? //创建一个动态代理
?????? DynamicProxy dynamicProxy = new DynamicProxy();?????
?????? //然后把订单和动态代理关联起来
?????? OrderApi orderApi = dynamicProxy.getProxyInterface(order);
?
?????? //以下就需要使用被代理过的接口来操作了
?????? //李四想要来修改，那就会报错
?????? orderApi.setOrderNum(123, "李四");
?????? //输出order
?????? System.out.println("李四修改后订单记录没有变化："+orderApi);
?????? //张三修改就不会有问题
?????? orderApi.setOrderNum(123, "张三");
?????? //再次输出order
?????? System.out.println("张三修改后，订单记录："+orderApi);
??? }
}
运行结果如下：
对不起，李四，您无权修改本订单中的数据
李四修改后订单记录没有变化：
productName=设计模式,orderNum=100,orderUser=张三
张三修改后，订单记录：productName=设计模式,orderNum=123,orderUser=张三
?????? 运行的结果跟前面完全由自己实现的代理模式是一样的。
?????? 事实上，Java的动态代理还是实现AOP（面向方面编程）的一个重要手段，AOP的知识这里暂时不去讲述，大家先了解这一点就可以了。
?????? 代理模式在客户和被客户访问的对象之间，引入了一定程度的间接性，客户是直接使用代理，让代理来与被访问的对象进行交互。不同的代理类型，这种附加的间接性有不同的用途，也就是有不同的特点：
1：代理模式的本质
?????? 代理模式的本质：控制对象访问。
?????? 代理模式通过代理目标对象，把代理对象插入到客户和目标对象之间，从而为客户和目标对象引入一定的间接性，正是这个间接性，给了代理对象很多的活动空间，代理对象可以在调用具体的目标对象前后，附加很多操作，从而实现新的功能或是扩展目标对象的功能，更狠的是，代理对象还可以不去创建和调用目标对象，也就是说，目标对象被完全代理掉了，或是被替换掉了。
?????? 从实现上看，代理模式主要是使用对象的组合和委托，尤其是在静态代理的实现里面，会看得更清楚。但是也可以采用对象继承的方式来实现代理，这种实现方式在某些情况下，比使用对象组合还要来得简单。
举个例子来说明一下，改造11.3.2保护代理的例子来说明。
（1）首先就是去掉OrderApi，现在改成继承的方式实现代理，不再需要公共的接口了
（2）Order对象变化不大，只是去掉实现的OrderApi接口就好了，示例代码如下：
public class Order?implements OrderApi?{
??? //其它的代码没有任何变化，就不去赘述了
}
（3）再看看代理的实现，变化较多，大致有如下的变化：
示例代码如下：
/**
?* 订单的代理对象
?*/
public class OrderProxy?extends?Order{
????public?OrderProxy(String productName
,int orderNum,String orderUser){
?????? super(productName,orderNum,orderUser);
??? }??
??? public void setProductName(String productName,String user) {
???????//控制访问权限，只有创建订单的人员才能够修改
?????? if(user!=null && user.equals(this.getOrderUser())){
?????????? super.setProductName(productName, user);
?????? }else{
?????????? System.out.println("对不起"+user
+"，您无权修改订单中的产品名称。");
?????? }
??? }
??? public void setOrderNum(int orderNum,String user) {
???????//控制访问权限，只有创建订单的人员才能够修改
?????? if(user!=null && user.equals(this.getOrderUser())){
?????????? super.setOrderNum(orderNum, user);
?????? }else{
?????????? System.out.println("对不起"+user
+"，您无权修改订单中的订购数量。");
?????? }
??? }
??? public void setOrderUser(String orderUser,String user) {
???????//控制访问权限，只有创建订单的人员才能够修改
?????? if(user!=null && user.equals(this.getOrderUser())){
?????????? super.setOrderUser(orderUser, user);
?????? }else{
?????????? System.out.println("对不起"+user
+"，您无权修改订单中的订购人。");
?????? }
??? }
??? public String toString(){
?????? return "productName="+this.getProductName()+",orderNum="
+this.getOrderNum()+",orderUser="+this.getOrderUser();
??? }
}
（4）客户端的变化不大，主要是不再直接面向OrderApi接口，而是使用Order对象了，另外创建代理的构造方法也发生了变化，示例代码如下：
public class Client {
??? public static void main(String[] args) {
?????? //张三先登录系统创建了一个订单
?????? Order order = new OrderProxy("设计模式",100,"张三");
?
?????? //李四想要来修改，那就会报错
?????? order.setOrderNum(123, "李四");
?????? //输出order
?????? System.out.println("李四修改后订单记录没有变化："+order);
?
?????? //张三修改就不会有问题
?????? order.setOrderNum(123, "张三");
?????? //再次输出order
?????? System.out.println("张三修改后，订单记录："+order);
??? }
}
?????? 去运行一下，测试看看，体会一下这种实现方式。
2：何时选用代理模式
建议在如下情况中，选用代理模式：
l????????? 代理模式和适配器模式
??? 这两个模式有一定的相似性，但也有差异。
??? 这两个模式有相似性，它们都为另一个对象提供间接性的访问，而且都是从自身以外的一个接口向这个对象转发请求。
??? 但是从功能上，两个模式是不一样的。适配器模式主要用来解决接口之间不匹配的问题，它通常是为所适配的对象提供一个不同的接口；而代理模式会实现和目标对象相同的接口。
l????????? 代理模式和装饰模式
??? 这两个模式从实现上相似，但是功能上是不同的。
??? 装饰模式的实现和保护代理的实现上是类似的，都是在转调其它对象的前后执行一定的功能。但是它们的目的和功能都是不同的。
??? 装饰模式的目的是为了让你不生成子类就可以给对象添加职责，也就是为了动态的增加功能；而代理模式的主要目的是控制对对象的访问。
?
---------------------------------------
私塾在线学习网原创内容 ?跟着cc学设计系列 之?研磨设计模式
研磨设计讨论群【252780326】
原创内容，转载请注明出处【http://sishuok.com/forum/blogPost/list/0/5263.html】
---------------------------------------
1 楼 hyj1254 2012-08-14 排版整理下，不然对不起这内容。