静态代理模式

    以前学习设计模式时，基本一直接触的是静态的设计模式，静态代理模式虽然简单易用，但是存在诸多问题。

代理模式

    说一下我对代理模式的理解：因为需要对一些函数进行二次处理，或是某些函数不让外界知道时，可以使用代理模式，通过访问第三方，简介访问原函数的方式，达到以上目的，来看一下代理模式的类图：

    

   总的来说，就是通过ProxySubject代理类，对原RealSubject的访问提供控制。

静态代理

    接口UserManager

[java] view plaincopyprint?
  1. /*** 
  2.  * 用户控制接口 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public interface UserManager {  
  7.   
  8.     public void addUser(String userId,String userName);  
  9.     public void modifyUser(String userId,String userName);  
  10.     public void delUser(String userId);  
  11.     public String findUser(String userId);  
  12. }  

    实现类UserManagerImpl

[java] view plaincopyprint?
  1. /**** 
  2.  * 用户管理真正的实现类 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public class UserManagerImpl implements UserManager {  
  7.   
  8.     /***** 
  9.      * 添加用户 
  10.      */  
  11.     public void addUser(String userId, String userName) {  
  12.             System.out.println("正在添加用户,用户为："+userId+userName+"……");  
  13.     }  
  14.     /***** 
  15.      * 删除用户 
  16.      */  
  17.     public void delUser(String userId) {  
  18.         System.out.println("delUser,userId="+userId);  
  19.     }  
  20.     /*** 
  21.      * 查找用户 
  22.      */  
  23.     public String findUser(String userId) {  
  24.         System.out.println("findUser,userId="+userId);  
  25.         return userId;  
  26.     }  
  27.   
  28.     public void modifyUser(String userId, String userName) {  
  29.         System.out.println("modifyUser,userId="+userId);  
  30.     }  
  31. }  

    代理类Proxy

[java] view plaincopyprint?
  1. /*** 
  2.  * 代理类，提供用户实现类的访问控制 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public class Proxy implements UserManager{  
  7.     private UserManager userManager;  
  8.     public Proxy(UserManagerImpl ul)  
  9.     {  
  10.         userManager=ul;  
  11.     }  
  12.     public void addUser(String userId, String userName) {  
  13.         System.out.println("正在进行添加用户前的准备工作,用户id为："+userId+"……");  
  14.         try {  
  15.             userManager.addUser(userId, userName);  
  16.             System.out.println("成功添加用户"+userId+"，正在进行确认处理……");  
  17.         } catch (Exception e) {  
  18.             System.out.println("添加,userId="+userId+"失败！");  
  19.         }  
  20.           
  21.           
  22.     }  
  23.   
  24.     public void delUser(String userId) {  
  25.         // TODO Auto-generated method stub  
  26.           
  27.     }  
  28.   
  29.     public String findUser(String userId) {  
  30.         // TODO Auto-generated method stub  
  31.         return null;  
  32.     }  
  33.   
  34.     public void modifyUser(String userId, String userName) {  
  35.         // TODO Auto-generated method stub  
  36.     }  
  37. }  

    客户端Client

[java] view plaincopyprint?
  1. /**** 
  2.  * 客户端 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public class client {  
  7.   
  8.         public static void main(String []args)  
  9.         {  
  10.             UserManager userManager=new Proxy( new UserManagerImpl());  
  11.             userManager.addUser("0001", "张三");  
  12.         }  
  13. }  

    运行结果

    

    时序图

    

静态代理的弊端

    如果我们为每个方法都使用“正在进行添加用户前的准备工作”、“成功添加用户，正在进行确认处理”等处理，很显然每个代理方法中都要重复这些代码；并且如果要想为多个类进行代理，则需要建立多个代理类，维护难度加大。

    仔细想想，为什么静态代理会有这些问题，是因为代理在编译期就已经决定，如果代理哪个发生在运行期，这些问题解决起来就比较简单，所以动态代理的存在就很有必要了，详见博客《》。


    更多博客，其访问《项目总结》。
posted @ 2016-01-14 11:56  宝贝企鹅  阅读(196)  评论(0)  编辑  收藏  举报