代理模式

　　java 的代理模式可以有静态代理模式和动态代理模式。下面的内容，大体的流程如下：

　　

　　所谓代理模式，就是代理处理其他类的操作。具体点就是，类似于北京的中介公司一样，自己没有实际的房屋和出租权，而是通过跟真正的房东商谈，代理出租房屋，从中谋取利益。这种模式的好处是，隐藏了真正的处理类，可以使代理类的操作简单化，而代理的操作可以复杂和有更多的操作。就如中介公司如果把房东透漏给你了，你就不会再经过中介去租房屋了，中介也不能再中介抽取钱了。

　　（I）静态代理模式

　　首先，看一下简单的静态代理模式。静态代理模式的类图如下：

其中，我定义了接口 PersonDao，实现类 PersonDaoImpl，代理类 PersonProxy,另外两个 After、Before 是我设置的后置方法类和前置方法的封装类。具体的代码如下：

（1）Dao 接口：

/**
 * 0.0.0.1
 */
package com.gaoqing.common.mode;

/**
 * Person 到 接口
 * @author gaoqing
 * 2014-6-17
 */
public interface PersonDao {

    public void info();

}

上述 Dao 接口，只是定义了一个简单的 info() 方法，打印出用户信息的操作。

（2）DaoImpl 实现类：

/**
 * 0.0.0.1
 */
package com.gaoqing.common.mode;

/**
 * Person dao 的实现类
 * @author gaoqing
 * 2014-6-17
 */
public class PersonDaoImpl implements PersonDao {

    private String name;
    private String address;
    /**
     * 构造方法
     */
    public PersonDaoImpl() {
        
    }

    /**
     * 构造方法
     */
    public PersonDaoImpl(String name, String address) {
        super();
        this.name = name;
        this.address = address;
    }

    /**
     * @see com.gaoqing.common.mode.PersonDao#info()
     */
    @Override
    public void info() {
        
        System.out.println("姓名：" + name + "," + "地址：" + address);

    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the address
     */
    public String getAddress() {
        return address;
    }

    /**
     * @param address the address to set
     */
    public void setAddress(String address) {
        this.address = address;
    }
}

（3）代理类如下：

/**
 * 0.0.0.1
 */
package com.gaoqing.common.mode;

/**
 * 静态代理方法
 * @author gaoqing
 * 2014-6-21
 */
public class StaticProxyTest implements PersonDao{
    
    /** PersonDao 方法 */
    private PersonDao personDao;
    /** 前置方法对象 */
    private Before before;
    /** 后置方法对象 */
    private After after;

    /**
     * 构造方法
     */
    public StaticProxyTest() {
        
    }
    
    /**
     * 构造方法
     * @param personDao PersonDao 对象
     * @param before 前置方法对象
     * @param after 后置方法对象
     */
    public StaticProxyTest(PersonDao personDao, Before before, After after) {
        super();
        this.personDao = personDao;
        this.before = before;
        this.after = after;
    }

    /**
    * @see com.gaoqing.common.mode.PersonDao#info()
    */
    @Override
    public void info() {
        //执行前置方法
        before.execute();
        
        //执行具体的请求方法
        personDao.info();
        
        //执行后置方法
        after.execute();
    }

    /**
     * @return the personDao
     */
    public PersonDao getPersonDao() {
        return personDao;
    }

    /**
     * @param personDao the personDao to set
     */
    public void setPersonDao(PersonDao personDao) {
        this.personDao = personDao;
    }

    /**
     * @return the before
     */
    public Before getBefore() {
        return before;
    }

    /**
     * @param before the before to set
     */
    public void setBefore(Before before) {
        this.before = before;
    }

    /**
     * @return the after
     */
    public After getAfter() {
        return after;
    }

    /**
     * @param after the after to set
     */
    public void setAfter(After after) {
        this.after = after;
    }
}

上面的代理类的特点是：和 DaoImpl 的实现类一样，都实现了 PersonDao 接口，只是在自己的 info() 方法，调用实现类的具体方法，而在自己的操作中，添加了更多别的附加的操作。

　　

　　（II）动态代理模式

　　如果只是仅仅使用简单的静态代理也可以实现某些面向切面的编程，比如插入日志什么的，可以将插入的内容放到 Before 和 After 类中。但是，如果我需要很多的代理类的时候，就需要像上面一样，写很多的类似的 PersonProxy 类，这样就很类了。随之产生的一种处理方式就出现了--动态代理。这样就可以只编写一个代理类，去代理所有自己想要代理类，更可以把那些相同的代码，分离到某些类中，集中进行管理，方便而且优雅。

　　（II.1）JDK 实现

　　我依旧使用上面的 PersonDao 和 PersonDaoImpl，具体的类图如下：

正如，在类图中的注释，这种动态代理的方式，是在 JDK 中，动态的生成一个类，该类和代理类一样，实现了相同的接口，拥有和代理类同样的方法。

（4）动态代理类如下：

/**
 * 0.0.0.1
 */
package com.gaoqing.common.mode;

import java.lang.reflect.Proxy;

/**
 * 代理类
 * @author gaoqing
 * 2014-6-17
 */
public class ProxyPerson {

    /** 被代理对象 */
    private Object obj;
    
    /** 调用处理类对象 */
    private MyInvocationHandler handler;
    
    /**
     * 构造方法
     */
    public ProxyPerson() {
        
    }
    
    /**
     * 构造方法
     * @param obj 被代理的对象
     * @param handler 具体的调用处理类
     */
    public ProxyPerson(Object obj, MyInvocationHandler handler) {
        super();
        this.obj = obj;
        this.handler = handler;
    }

    /**
     * 生成代理类
     * @author 高青
     * 2014-6-17
     * @return obj 代理类
     */
    public Object getProxyPerson(){
        
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }

    /**
     * @return the obj
     */
    public Object getObj() {
        return obj;
    }

    /**
     * @param obj the obj to set
     */
    public void setObj(Object obj) {
        this.obj = obj;
    }

    /**
     * @return the handler
     */
    public MyInvocationHandler getHandler() {
        return handler;
    }

    /**
     * @param handler the handler to set
     */
    public void setHandler(MyInvocationHandler handler) {
        this.handler = handler;
    }
}

（4）具体的调用处理类如下：

/**
 * 0.0.0.1
 */
package com.gaoqing.common.mode;

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

/**
 * 自定义的调用处理器
 * @author gaoqing
 * 2014-6-17
 */
public class MyInvocationHandler implements InvocationHandler {
    
    /** 被代理的类 */
    private Object obj;
    
    /** 方法前对象 */
    private Before before;
    
    /** 方法后对象 */
    private After after;

    /**
     * 构造方法
     */
    public MyInvocationHandler() {
        
    }

    /**
     * 构造方法
     */
    public MyInvocationHandler(Object obj) {
        super();
        this.obj = obj;
    }

    /**
     * 构造方法
     */
    public MyInvocationHandler(Object obj, Before before, After after) {
        super();
        this.obj = obj;
        this.before = before;
        this.after = after;
    }

    /**
     * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        /*
         * 代理的具体处理方式
         */
        
        //方法前操作
        before.execute();
        
        Object invokeValue  = method.invoke(obj, args);
        
        //方法后操作
        after.execute();
        
        return invokeValue;
    }

    /**
     * @return the obj
     */
    public Object getObj() {
        return obj;
    }

    /**
     * @param obj the obj to set
     */
    public void setObj(Object obj) {
        this.obj = obj;
    }

    /**
     * @return the before
     */
    public Before getBefore() {
        return before;
    }

    /**
     * @param before the before to set
     */
    public void setBefore(Before before) {
        this.before = before;
    }

    /**
     * @return the after
     */
    public After getAfter() {
        return after;
    }

    /**
     * @param after the after to set
     */
    public void setAfter(After after) {
        this.after = after;
    }
}

　　（II.2）Cglib 实现

　　从上面可以看到，使用 JDK 自带的接口实现动态代理的话，需要被代理的对象必须实现一个接口。这样，就存在了一种限制，如果我需要代理那些普通的类那该怎么办呢？这个时候可以使用 cglib 类库，它可以实现代理那些没有实现接口的类。Cglib 是一个优秀的动态代理框架，它的底层使用 ASM 在内存中动态的生成被代理类的一个子类。具体的 ASM 的使用，目前还没用过啊，现在只是简单的使用以下 cglib 。

　　使用 cglib 框架实现动态代理时，需要导入两个包，一个是其依赖的 asm.jar，一个是 cglib.jar。注意：需要导入合适的包，如果包的版本不对，是会报错的，如果报错了，可以试着换下 cglib 的 jar 包。在这个代理的过程中，主要用到了 cglib 的：

（1）Enhancer – 主要的增强类，类似于 JDK 的 Proxy 类，产生具体的代理类

（2）MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现，就是将代理类请求的方法，进行拦截到被代理类对象进行处理，类似于 JDK 的 InvocationHandler 接口的 invoke()方法

（3）MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用

具体的实现如下：

/**
 * 0.0.0.1
 */
package com.gaoqing.common.mode;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * 使用 Cglib 框架实现的代理类
 * @author gaoqing
 * 2014-6-19
 */
public class DynamicProxyByCGLIBTest {

    /**
     * 构造方法
     */
    public DynamicProxyByCGLIBTest() {
        
    }

    /**
     * 主线程方法
     * @author 高青
     * 2014-6-19
     * @param args 参数字符串集
     * @return void 空
     */
    public static void main(String[] args) {
        
        //代理类
        final PersonDaoImpl personDaoImpl = new PersonDaoImpl("gaoqing", "beijing");
        
        //得到增强类
        Enhancer enhancer = new Enhancer();
        
        //设置增强类的父类
        enhancer.setSuperclass(PersonDaoImpl.class);
        
        enhancer.setCallback(new MethodInterceptor() {
            
            @Override
            public Object intercept(Object target, Method method, Object[] args,
                    MethodProxy proxy) throws Throwable {
                
                Object invoke = method.invoke(personDaoImpl, args);      //也可以使用 proxy 的 invokeSupre(target, args)
                
                return invoke;
            }
        });
        PersonDaoImpl personDaoImplProxy =  (PersonDaoImpl) enhancer.create();
        
        personDaoImplProxy.info();

    }
}

　　（III）代理模式的使用场景

　　上述就是简单的代理模式的实现。动态代理的方式，可以实现面向 AOP 的编程，具体的使用是大家知道的动态的插入日志，添加事物，记录用户的操作记录等。具体的框架应用就是 Spring 的 AOP 实现，为它们提供为方法的Interception（拦截）,在 hibernate 中，使用 Cglib 来代理单端single-ended(多对一和一对一)关联等等。