代理模式

导语
学习代理模式的目的主要是打算学习RPC（远程过程调用）的原理，其中RPC的原理在Hadoop的HDFS文件系统中使用。看了《大话设计模式》和网上的一些博客资料，故自写一篇博客以总结。

---

静态代理
代理模式（Proxy），为其他对象提供一种代理以控制对这个对象的访问。《大话设计模式》中提及的是静态代理模式，写得非常形象，通俗易懂。

代码示例：账户查询更新，事物机制
AccountDao.java

package cn.edu.scut;

public interface AccountDao {
    //查看账户
    public void queryAccount();
    //修改账户
    public void updateAccount();
}

AccountDaoImpl.java

package cn.edu.scut;

public class AccountDaoImpl implements AccountDao{

    @Override
    public void queryAccount() {
        // TODO Auto-generated method stub
        System.out.println("query account ...");
    }

    @Override
    public void updateAccount() {
        // TODO Auto-generated method stub
        System.out.println("update account ...");
    }

}

Transaction.java

package cn.edu.scut;

public class Transaction {
    //开启事物
    public void beginTransaction(){
        System.out.println("begin transaction ...");
    }
    //结束事物
    public void endTransaction(){
        System.out.println("end transaction ...");
    }
}

AccountDaoProxy.java

package cn.edu.scut;

public class AccountDaoProxy implements AccountDao{
    private AccountDao accountDao;
    private Transaction transaction;

    public AccountDaoProxy() {
        super();
        // TODO Auto-generated constructor stub
    }

    public AccountDaoProxy(AccountDao accountDao, Transaction transaction) {
        super();
        this.accountDao = accountDao;
        this.transaction = transaction;
    }



    @Override
    public void queryAccount() {
        // TODO Auto-generated method stub
        transaction.beginTransaction();
        accountDao.queryAccount();
        transaction.endTransaction();
    }

    @Override
    public void updateAccount() {
        // TODO Auto-generated method stub
        transaction.beginTransaction();
        accountDao.updateAccount();
        transaction.endTransaction();
    }

}

Client.java

package cn.edu.scut;

public class Client {
    public static void main(String[] args) {
        AccountDao accountDao = new AccountDaoImpl();
        Transaction transaction = new Transaction();
        AccountDaoProxy accountDaoProxy = new AccountDaoProxy(accountDao, transaction);
        accountDaoProxy.updateAccount();
        System.out.println("-----------------");
        accountDaoProxy.queryAccount();
    }
}

总结而言，代理类和目标类实现同一个接口，然后再代理类中增加一些目标类并不需要关注的其他操作。和装饰者模式有些类似。可以看到，在查询账户等时自动增加了事物。但是存在以下缺点：

• 如果接口中有很多方法，故在代理类中也需要重写很多方法。

JDK动态代理
主要是使用一个Proxy类和一个InvocationHandler接口，借用博客介绍。
InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数
可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 
InvocationHandler h) throws IllegalArgumentException
参数说明： 
ClassLoader loader：类加载器 
Class<?>[] interfaces：得到全部的接口 
InvocationHandler h：得到InvocationHandler接口的子类实例

Ps:类加载器
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类;
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

AcccountDaoProxy.java

package cn.edu.scut.jdkproxy;

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

public class AccountDaoProxy implements InvocationHandler{

    private Object target;
    private Transaction transaction;

    public Object bind(Object target, Transaction transaction){
        this.transaction = transaction;
        this.target = target;
        //取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);//要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)
    }

    /*
    public AccountDaoProxy(Object object, Transaction transaction) {
        super();
        this.target = object;
        this.transaction = transaction;
    }*/


    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        this.transaction.beginTransaction();
        method.invoke(target, args);
        this.transaction.endTransaction();
        return null;
    }

}

client.java

package cn.edu.scut.jdkproxy;

import cn.edu.scut.jdkproxy.AccountDaoProxy;

public class Client {
    public static void main(String[] args) {
        Transaction transaction = new Transaction();
        Object target = new AccountDaoImpl();
//      AccountDaoProxy accountDaoProxy = new AccountDaoProxy(target, transaction);
//      AccountDao accountDao = (AccountDao)Proxy.newProxyInstance(target.getClass().getClassLoader(), 
//              target.getClass().getInterfaces(), accountDaoProxy);
        AccountDaoProxy proxy = new AccountDaoProxy();
        AccountDao accountDao = (AccountDao)proxy.bind(target, transaction);
        accountDao.queryAccount();
        System.out.println(" ------------------------ ");
        accountDao.updateAccount();
    }
}

代理对象具有和目标类一样的接口方法。
缺点：JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

Cglib动态代理
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

AccountDaoImpl.java：不用再继承接口

package cn.edu.scut.cglib.proxy;

public class AccountDaoImpl{

    public void queryAccount() {
        // TODO Auto-generated method stub
        System.out.println("query account ...");
    }

    public void updateAccount() {
        // TODO Auto-generated method stub
        System.out.println("update account ...");
    }   
}

AccountDaoProxy.java

package cn.edu.scut.cglib.proxy;

import java.lang.reflect.Method;

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

public class AccountDaoProxy implements MethodInterceptor{
    private Object target;
    private Transaction transaction;

    /**
     * 创建代理对象
     */
    public Object getInstance(Object target, Transaction transaction){
        this.target = target;
        this.transaction = transaction;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        //回调方法
        enhancer.setCallback(this);
        //创建代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object object, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {
        // TODO Auto-generated method stub
        transaction.beginTransaction();
        proxy.invoke(target, args);
        transaction.endTransaction();
        return null;
    }
}

Client.java

package cn.edu.scut.cglib.proxy;

public class Client {
    public static void main(String[] args) {
        AccountDaoProxy proxy = new AccountDaoProxy();
        Transaction transaction = new Transaction();
        AccountDaoImpl accountDaoImpl = (AccountDaoImpl)proxy.getInstance(
                new AccountDaoImpl(), transaction);
        accountDaoImpl.queryAccount();
        System.out.println(" --------------------  ");
        accountDaoImpl.updateAccount();
    }
}

代理模式应用
1. 远程代理，也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实。如客户端程序调用代理可以解决远程访问的问题。
2.虚拟代理，是根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真实对象。 可以达到性能的，如浏览器用代理模式优化下载。
3.安全代理，用来控制真实对象访问时的权限。
4.智能指引，是指当调用真实的对象是，代理处理另外一些事。

参考以下知识：