代理模式

一、定义和分类

代理模式在设计模式中的定义就是：为其他对象提供一种代理以控制对这个对象的访问。说白了就是，在一些情况下客户不想或者不能直接引用一个对象，而代理对象可以在客户和目标对象之间起到中介作用，去掉客户不能看到的内容和服务或者增添客户需要的额外服务。 

　　那么什么时候要使用代理模式呢？在对已有的方法进行使用的时候出现需要对原有方法进行改进或者修改，这时候有两种改进选择：修改原有方法来适应现在的使用方式，或者使用一个“第三者”方法来调用原有的方法并且对方法产生的结果进行一定的控制。第一种方法是明显违背了“对扩展开放、对修改关闭”（开闭原则），而且在原来方法中作修改可能使得原来类的功能变得模糊和多元化（就像现在企业多元化一样），而使用第二种方式可以将功能划分的更加清晰，有助于后面的维护。所以在一定程度上第二种方式是一个比较好的选择！ 

　　当然，话又说回来了，如果是一个很小的系统，功能也不是很繁杂，那么使用代理模式可能就显得臃肿，不如第一种方式来的快捷。这就像一个三口之家，家务活全由家庭主妇或者一个保姆来完成是比较合理的，根本不需要雇上好几个保姆层层代理:) 

　　根据《Java与模式》书中对代理模式的分类，代理模式分为8种，这里将几种常见的、重要的列举如下： 

　　1. 远程（Remote）代理：为一个位于不同的地址空间的对象提供一个局域代表对象。比如：你可以将一个在世界某个角落一台机器通过代理假象成你局域网中的一部分。 

　　2. 虚拟（Virtual）代理：根据需要将一个资源消耗很大或者比较复杂的对象延迟的真正需要时才创建。比如：如果一个很大的图片，需要花费很长时间才能显示出来，那么当这个图片包含在文档中时，使用编辑器或浏览器打开这个文档，这个大图片可能就影响了文档的阅读，这时需要做个图片Proxy来代替真正的图片。 

　　3. 保护（Protect or Access）代理：控制对一个对象的访问权限。比如：在论坛中，不同的身份登陆，拥有的权限是不同的，使用代理模式可以控制权限（当然，使用别的方式也可以实现）。 

　　4. 智能引用（Smart Reference）代理：提供比对目标对象额外的服务。比如：纪录访问的流量（这是个再简单不过的例子），提供一些友情提示等等。 

　　代理模式是一种比较有用的模式，从几个类的“小结构”到庞大系统的“大结构”都可以看到它的影子。 

　　三、结构 

　　代理模式中的“代理商”要想实现代理任务，就必须和被代理的“厂商”使用共同的接口（你可以想象为产品）。所以自然而然你会想到在java中使用一个抽象类或者接口（推荐）来实现这个共同的接口。于是代理模式就有三个角色组成了： 

　　1．抽象主题角色：声明了真实主题和代理主题的共同接口。 

　　2．代理主题角色：内部包含对真实主题的引用，并且提供和真实主题角色相同的接口。 

　　3．真实主题角色：定义真实的对象。 

　　使用类图来表示下三者间的关系如下： 

　　当然，图上所示的是代理模式中的一个具体情况。而代理模式可以非常灵活的使用其他方式来实现，这样就与图上所示有很大的区别。 

 

但是我们一般都是使用java中动态代理模式：

JDK动态代理中包含一个类和一个接口： 
InvocationHandler接口： 
public interface InvocationHandler { 
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
} 
参数说明： 
Object proxy：指被代理的对象。 
Method method：要调用的方法 
Object[] args：方法调用时所需要的参数 

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。 

Proxy类： 
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法： 
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 
InvocationHandler h) 
                               throws IllegalArgumentException 
参数说明： 
ClassLoader loader：类加载器 
Class<?>[] interfaces：得到全部的接口 
InvocationHandler h：得到InvocationHandler接口的子类实例 

Ps:类加载器 
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器; 
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的； 
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类; 
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。 

动态代理 
与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

动态代理示例: 
1、BookFacade.java 

Java代码  

1 package net.battier.dao;  

2   

3 public interface BookFacade {  

4     public void addBook();  

5 }  

 

2、BookFacadeImpl.java 

Java代码  

6 package net.battier.dao.impl;  

7   

8 import net.battier.dao.BookFacade;  

9   

10 public class BookFacadeImpl implements BookFacade {  

11   

12     @Override  

13     public void addBook() {  

14         System.out.println("增加图书方法。。。");  

15     }  

16   

17 }  

18   

19 、BookFacadeProxy.java  

20   

21 package net.battier.proxy;  

22   

23 import java.lang.reflect.InvocationHandler;  

24 import java.lang.reflect.Method;  

25 import java.lang.reflect.Proxy;  

26   

27 /** 

28  * JDK动态代理代理类 

29  *  

30  * @author student 

31  *  

32  */  

33 public class BookFacadeProxy implements InvocationHandler {  

34     private Object target;  

35     /** 

36      * 绑定委托对象并返回一个代理类 

37      * @param target 

38      * @return 

39      */  

40     public Object bind(Object target) {  

41         this.target = target;  

42         //取得代理对象  

43         return Proxy.newProxyInstance(target.getClass().getClassLoader(),  

44                 target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  

45     }  

46   

47     @Override  

48     /** 

49      * 调用方法 

50      */  

51     public Object invoke(Object proxy, Method method, Object[] args)  

52             throws Throwable {  

53         Object result=null;  

54         System.out.println("事物开始");  

55         //执行方法  

56         result=method.invoke(target, args);  

57         System.out.println("事物结束");  

58         return result;  

59     }  

60   

61 }  

 

3、TestProxy.java 

Java代码  

62 package net.battier.test;  

63   

64 import net.battier.dao.BookFacade;  

65 import net.battier.dao.impl.BookFacadeImpl;  

66 import net.battier.proxy.BookFacadeProxy;  

67   

68 public class TestProxy {  

69   

70     public static void main(String[] args) {  

71         BookFacadeProxy proxy = new BookFacadeProxy();  

72         BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  

73         bookProxy.addBook();  

74     }  

75   

76 }  

 

但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。 

Cglib动态代理 
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 
示例 
1、BookFacadeCglib.java 

Java代码  

77 package net.battier.dao;  

78   

79 public interface BookFacade {  

80     public void addBook();  

81 }  

 

2、BookCadeImpl1.java 

Java代码  

82 package net.battier.dao.impl;  

83   

84 /** 

85  * 这个是没有实现接口的实现类 

86  *  

87  * @author student 

88  *  

89  */  

90 public class BookFacadeImpl1 {  

91     public void addBook() {  

92         System.out.println("增加图书的普通方法...");  

93     }  

94 }  

3、BookFacadeProxy.java 

Java代码  

95 package net.battier.proxy;  

96   

97 import java.lang.reflect.Method;  

98   

99 import net.sf.cglib.proxy.Enhancer;  

100 import net.sf.cglib.proxy.MethodInterceptor;  

101 import net.sf.cglib.proxy.MethodProxy;  

102   

103 /** 

104  * 使用cglib动态代理 

105  *  

106  * @author student 

107  *  

108  */  

109 public class BookFacadeCglib implements MethodInterceptor {  

110     private Object target;  

111   

112     /** 

113      * 创建代理对象 

114      *  

115      * @param target 

116      * @return 

117      */  

118     public Object getInstance(Object target) {  

119         this.target = target;  

120         Enhancer enhancer = new Enhancer();  

121         enhancer.setSuperclass(this.target.getClass());  

122         // 回调方法  

123         enhancer.setCallback(this);  

124         // 创建代理对象  

125         return enhancer.create();  

126     }  

127   

128     @Override  

129     // 回调方法  

130     public Object intercept(Object obj, Method method, Object[] args,  

131             MethodProxy proxy) throws Throwable {  

132         System.out.println("事物开始");  

133         proxy.invokeSuper(obj, args);  

134         System.out.println("事物结束");  

135         return null;  

136   

137   

138     }  

139   

140 }  

4、TestCglib.java 

Java代码  

141 package net.battier.test;  

142   

143 import net.battier.dao.impl.BookFacadeImpl1;  

144 import net.battier.proxy.BookFacadeCglib;  

145   

146 public class TestCglib {  

147       

148     public static void main(String[] args) {  

149         BookFacadeCglib cglib=new BookFacadeCglib();  

150         BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  

151         bookCglib.addBook();  

152     }  

153 }