一、代理模式

代理模式是常用的java设计模式，特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 

 

按照代理的创建时期，代理类可以分为两种：

静态代理：由程序员创建或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。 

动态代理：在程序运行时运用反射机制动态创建而成。

 

 

二、单个静态代理

 

1. public interface CountDao  
2. {  
3.     // 查看账户方法  
4.     public void queryCount();  
5. }  
6.  
7. public class CountDaoImpl implements CountDao  
8. {  
9.     public void queryCount()  
10.     {  
11.         System.out.println("查看账户方法...");  
12.     }  
13. }  
14.  
15. public class CountTrancProxy implements CountDao  
16. {  
17.     private CountDao countDao;  
18.  
19.     public CountProxy(CountDao countDao)  
20.     {  
21.         this.countDao = countDao;  
22.     }  
23.  
24.     @Override 
25.     public void queryCount()  
26.     {  
27.         System.out.println("tranc start");  
28.         countDao.queryCount();  
29.         System.out.println("tranc end");  
30.     }  
31. }  
32.  
33. public class TestCount  
34. {  
35.     public static void main(String[] args)  
36.     {  
37.         CountTrancProxy countProxy = new CountTrancProxy(new CountDaoImpl());  
38.         countProxy.updateCount();  
39.     }  
40. } 

tranc start

查看账户方法... tranc end

 

三、多个静态代理

在上面代码的基础上新增了

 

1. public class CountLogProxy implements CountDao  
2. {  
3.     private CountDao countDao;  
4.  
5.     public CountLogProxy(CountDao countDao)  
6.     {  
7.         this.countDao = countDao;  
8.     }  
9.  
10.     @Override 
11.     public void queryCount()  
12.     {  
13.         System.out.println("Log start");  
14.         countDao.queryCount();  
15.         System.out.println("Log end");  
16.     }  
17. } 

调用代码就变成了

 

1. //  体现了聚合的思想，代理之间的组合  
2. public static void main(String[] args)  
3. {  
4.     CountTrancProxy trancProxy = new CountTrancProxy(new CountDaoImpl());  
5.     CountLogProxy logPro = new CountLogProxy(trancProxy);  
6.     logPro.queryCount();  
7. } 

Log start

事务处理之前 查看账户方法... 事务处理之后 Log end

 

四、总结

其实可以用代理类可以用继承或实现接口两种方式达到代理的效果，但是当多个代理类需要相互组合的时候，继承就不灵活了，需要不断重写代理类，而实现接口的方式就十分容易通过的聚合实现代理类之间的组合。