Java中的代理模式

代理模式在Java Web的框架中经常使用到。比如说在对数据库的访问中，核心功能是对数据库的增删改查，而连接数据库、处理事务等功能我们在开发中也要考虑到。所以我们将数据库的CRUD抽象到接口中，然后实现该接口。 而将数据库连接、事务处理等功能交给代理类去完成。

上图描述了代理模式的基本框架。代理模式的核心是以下几点:

1. 代理实现类和真实的实现类都实现了接口

2. 代理实现类必须持有一个真实实现类的引用

3. 代理实现类完成非核心功能，而核心功能有其持有的真是实现类完成

现在以对数据库访问为例。加入数据库中有Dept表（只有表示部门名称和地点的dname、loc字段），Java类如下:

 package other;

 import java.io.Serializable;
 import java.util.Date;

 @SuppressWarnings("serial")
 public  class Dept implements Serializable
 {
     private String dname;
     private String loc;
     public String getDname()
     {
         return dname;
     }
     public void setDname(String dname)
     {
         this.dname = dname;
     }
     public String getLoc()
     {
         return loc;
     }
     public void setLoc(String loc)
     {
         this.loc = loc;
     }
 }

对数据库的访问有一个IDAO<K,V>接口，为了演示方便，只包含了数据增加和数据修改功能：

 package other;

 public interface IDAO<K,V>
 {
     public boolean doCreate(V vo) throws Exception ;
     public boolean doUpdate(V vo) throws Exception ;
 }

下面是对IDAO<K,V>的实现，该类用伪代码实现：

package other;

public class DAOImpl implements IDAO<Integer, Dept>
{

    @Override
    public boolean doCreate(Dept vo) throws Exception
    {
        System.out.println("===成功创建Dept记录===");
        return true;
    }

    @Override
    public boolean doUpdate(Dept vo) throws Exception
    {
        System.out.println("===成功更新Dept记录===");
        return true;
    }
}

下面定义的是代理类，代理类持有一个对DAOImpl的引用。代理类要完成数据库自动提交设置，同时还要调用真实类完成对数据库的访问:

 package other;

 public class DAOImplProxy implements IDAO<Integer, Dept>
 {
     private IDAO<Integer, Dept> realObject = null;
     public DAOImplProxy(IDAO<Integer, Dept> realObject)
     {
         this.realObject = realObject;
     }

     private void updatePre()
     {
         System.out.println("===取消自动提交===");
     }

     private void updateAfter()
     {
         System.out.println("===设置自动提交===");
     }

     private void roolBack()
     {
         System.out.println("===事务出现异常，回滚===");
     }

     @Override
     public boolean doCreate(Dept vo) throws Exception
     {
         try
         {
             this.updatePre();
             boolean retVal = this.realObject.doCreate(vo);
             this.updateAfter();
             return retVal;
         }catch(Exception e)
         {
             this.roolBack();
             e.printStackTrace();
             throw e;
         }
     }
     @Override
     public boolean doUpdate(Dept vo) throws Exception
     {
         try
         {
             this.updatePre();
             boolean retVal = this.realObject.doUpdate(vo);
             this.updateAfter();
             return retVal;
         }catch(Exception e)
         {
             this.roolBack();
             e.printStackTrace();
             throw e;
         }
     }

 }

可以看到，代理类也实现了IDAO<K,V>接口，而对Dept表的插入和更新之前和之后，都进行了一定的处理，如果出现数据库访问异常，还进行了回滚。而对数据库的插入和更新，则是调用的真实主题类的实现。也就是说，代理类只帮我们完成一些辅助功能，核心功能有我们用户自己定义，并传进去。

下面是测试代码：

 package org.lyk.main;

 import other.*;

 public class Main
 {
     public static void main(String[] args) throws Exception
     {
         DAOImplProxy proxy = new DAOImplProxy(new DAOImpl());
         IDAO<Integer,Dept> dao = (IDAO<Integer, Dept>)proxy;
         dao.doCreate(new Dept());
     }
 }

从上面的解释可以看出，我们每个代理类都和固定的真实实现类绑定在了一起，因为该代理类只能完成DAOImpl类的这些功能。如果我们有另外一个对IDAO<K,V>的实现，我们又不得不再写一个代理类，悲剧的事我们的数据库往往有几十甚至几百张表。而且这种紧耦合方式在软件设计/开发中应该是尽量回避的。

上面是我们自己实现的代理模式设计，其实JAVA对代理模式已经有对应的支持。利用Proxy类和InvocationHandler接口可以实现动态代理模式设计。

动态代理模式中的代理类不再继承某一个特定的接口，而是实现InvocationHandler接口。同样，持有一个对真实对象的引用（该引用由我们在运行时动态传入）。在invoke中实现对数据库的访问调用。

 package other;

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

 public class DAOImplProxy implements InvocationHandler
 {
     private Object realObject = null;

     public DAOImplProxy(Object realObject)
     {
         this.realObject = realObject;
     }

     private void updatePre()
     {
         System.out.println("===取消自动提交===");
     }

     private void updateAfter()
     {
         System.out.println("===设置自动提交===");
     }

     private void roolBack()
     {
         System.out.println("===事务出现异常，回滚===");
     }

     @Override
     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable
     {
         try
         {
             this.updatePre();
             Object retVal = method.invoke(this.realObject, args);
             this.updateAfter();
             return retVal;
         }
         catch(Exception e)
         {
             this.roolBack();
             e.printStackTrace();
             throw e;

         }
     }
 }

上面使用了JAVA中反射功能实现对DAOImpl中方法的调用。

测试代码:

package org.lyk.main;

import java.lang.reflect.Proxy;

import other.*;

public class Main
{
    public static void main(String[] args) throws Exception
    {
        //真实的对数据库的访问功能
        DAOImpl di = new DAOImpl();
        //将真实功能实例传入代理类中
        DAOImplProxy proxy = new DAOImplProxy(di);
        //通过Proxy获取代理主题的实例
        Object proxyInstance = Proxy.newProxyInstance(di.getClass().getClassLoader(),di.getClass().getInterfaces(), proxy);
        //强转成IDAO接口
        IDAO<Integer,Dept> dao = (IDAO<Integer, Dept>)proxyInstance;
        //实现对数据库的访问
        dao.doCreate(new Dept());
    }
}