java设计模式之代理模式

首先介绍一下，什么是代理：

 

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

    代理类和委托类，存在着关联关系。代理类的对象本身并不真正实现服务（借助实现类），只是通过调用委托类的对象的相关方法，委托类（可能是activity）委托代理类来实现一个接口。

    代理类可以分为两种：静态代理和动态代理。 

 

静态代理：

    代理类是由程序员创建，或由工具生成的代码 编译成的。在程序运行前，代理类的 *.class文件已经存在了。直接就可以运行 。

 

动态代理：

    动态代理的代理类。没有直接由源代码生成。动态代理类的对象是在程序运行时由JAVA反射机制动态生成，不需要手工编写源代码。从而提高了软件的可扩展性。JAVA反射机制可以生成任意类型的动态代理类。

 

 

静态代理的实现：

接口：

 package test.static.pattern;

 public interface UserManager {

     public void addUser(String userId,String userName);

     public void delUser(String userId);

     public String findUser(String userId);

     public void modifyUser(String userId,String userNameString);
 }

 

实现类：

 package test.static.pattern;

 public class UserManagerImpl implements UserManager {

     @Override
     public void addUser(String userId, String userName) {
         System.out.println("UserManagerImpl.addUser()  userId-->>" + userId);
     }

     @Override
     public void delUser(String userId) {
         System.out.println("UserManagerImpl.delUser() userId-->>" + userId);
     }

     @Override
     public String findUser(String userId) {
         System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
         return null;
     }

     @Override
     public void modifyUser(String userId, String userNameString) {
         System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);
     }

 }

 

静态代理类：（只持有对象的引用）

 package test.static.pattern;

 public class UserManagerImplProxy implements UserManager {

     private UserManager userManager;

     public UserManagerImplProxy (UserManager userManager){
         this.userManager=userManager;
     }

     @Override
     public void addUser(String userId, String userName) {
         userManager.addUser(userId, userName);
     }

     @Override
     public void delUser(String userId) {
         userManager.delUser(userId);
     }

     @Override
     public String findUser(String userId) {

         return userManager.findUser(userId);
     }

     @Override
     public void modifyUser(String userId, String userNameString) {
         userManager.modifyUser(userId, userNameString);
     }

 }

 

客户端：

 package test.static.pattern;

 public class Client {
     /**
      * @param args
      */
     public static void main(String[] args) {
         //正常思路：客户端直接实例化出 子类的对象
         UserManager userManager=new UserManagerImpl();
         //静态代理：客户端实例化代理，通过代理取 子类的引用
         UserManager userManager=new UserManagerImplProxy(new UserManagerImpl());
         userManager.addUser("0001", "张三");
     }
 }

 

执行结果：

静态代理，因为代理类持有对象的引用，所以可以对其进行控制。

    现象1：对于各个功能模块来说，都要建立对应的代理类。造成大量的代理类

    现象2：但是如果对各个实现相同的控制，则需要重复写大量的代码。

 

为了避免重复代码出现多次，我们接着看什么是动态代理。

 

动态代理的实现：

接口：

 package test.dynamic.pattern;

 public interface UserManager {

     public void addUser(String userId,String userName);

     public void delUser(String userId);

     public String findUser(String userId);

     public void modifyUser(String userId,String userNameString);
 }

实现类：

 package test.dynamic.pattern;

 public class UserManagerImpl implements UserManager {

     @Override
     public void addUser(String userId, String userName) {
         System.out.println("UserManagerImpl.addUser()  userId-->>" + userId);
     }

     @Override
     public void delUser(String userId) {
         System.out.println("UserManagerImpl.delUser() userId-->>" + userId);
     }

     @Override
     public String findUser(String userId) {
         System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
         return null;
     }

     @Override
     public void modifyUser(String userId, String userNameString) {
         System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);
     }

 }

动态代理生成类：

 package test.dynamic.pattern;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;

 import org.omg.CORBA.SystemException;
 import org.omg.CORBA.portable.InputStream;
 import org.omg.CORBA.portable.InvokeHandler;
 import org.omg.CORBA.portable.OutputStream;
 import org.omg.CORBA.portable.ResponseHandler;

 public class LogHandler implements InvocationHandler {

     /**
      * 调用引用对象类的方法抽象
      */
     @Override
     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {

         Object ret=null;
         try {
             //调用目标方法
             ret=method.invoke(targetObject, args);
         } catch (Exception e) {
             throw e;
         }
         return null;
     }

     //目标实现的引用
     private Object targetObject;

     /**
      * 代理类生成方法
      * @param targetObject
      * @return
      */
     public Object newProxyInstance(Object targetObject){
         this.targetObject=targetObject;
         return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
     }
 }

 

客户端：

 package test.dynamic.pattern;

 public class Client {

     /**
      * @param args
      */
     public static void main(String[] args) {
         //动态代理
         LogHandler logHandler=new LogHandler();
         UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());
         //userManager.addUser("0001", "张三");
         userManager.delUser("111");
     }
 }

 

执行结果：

 

   动态代理类，在程序中没有体现。只有在程序运行的时候采用创建相应的代理类。这样就可以少些大量的代理类。对于现象2，相同控制代码是如何减少的。请看下一篇博客。