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());
    }
}