静态代理模式

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

代理模式

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

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

静态代理

 

    接口UserManager

[java] view plaincopyprint?

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

    实现类UserManagerImpl

[java] view plaincopyprint?

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

    代理类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.     public void delUser(String userId) {
  22.         // TODO Auto-generated method stub
  23.     }
  24.     public String findUser(String userId) {
  25.         // TODO Auto-generated method stub
  26.         return null;
  27.     }
  28.     public void modifyUser(String userId, String userName) {
  29.         // TODO Auto-generated method stub
  30.     }
  31. }

    客户端Client

[java] view plaincopyprint?

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

    运行结果

 

    时序图

静态代理的弊端

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

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

标签