《大话设计模式》之代理模式

1.定义

为其他对象提供一种代理以控制对这个对象的访问。
主要解决：
在直接访问对象时带来的问题
当客户端无法直接操作实际对象：
一种情况是你需要调用的对象在另外一台机器上，你需要跨越网络才能访问，如果让你直接coding去调用，你需要处理网络连接、处理打包、解包等等非常复杂的步骤，所以为了简化客户端的处理，我们使用代理模式，在客户端建立一个远程对象的代理，客户端就象调用本地对象一样调用该代理，再由代理去跟实际对象联系，对于客户端来说可能根本没有感觉到调用的东西在网络另外一端，这实际上就是Web Service的工作原理。
另一种情况虽然你所要调用的对象就在本地，但是由于调用非常耗时，你怕影响你正常的操作，所以特意找个代理来处理这种耗时情况，如打开网页加载大资源时，可以为这个大资源设置一个代理，让代理慢慢打开这个大资源而不影响网页本来的打开。
扩展目标对象的功能
可以在目标对象实现的基础上,增强额外的功能操作,
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法.
也可以被用来区别一个对象实例的请求和实际的访问，例如：在程序初始化过程中可能建立多个对象，但并不都是马上使用，代理模式可以载入需要的真正的对象。这是一个需要载入和显示一幅很大的图像的程序，当程序启动时，就必须确定要显示的图像，但是实际的图像只能在完全载入后才可以显示！这时我们就可以使用代理模式。

2.实现

2.1静态代理

public interface Subject {

    public void Request();
}

public class RealSubject implements Subject {

    @Override
    public void Request() {
        System.out.println("真实的请求");
    }

}

public class Proxy implements Subject {
    RealSubject realSubject;
    @Override
    public void Request() {
        if(realSubject==null) {
            realSubject=new RealSubject();
        }
        realSubject.Request();
    }

}

public class Client {

    public static void main(String[] args) {
        Proxy proxy=new Proxy();
        proxy.Request();
    }
}

优点：可以做到在不修改目标对象的功能前提下,对目标功能扩展.
缺点：1.因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.
2.一旦接口增加方法,目标对象与代理对象都要维护.

2.2动态代理
分为JDK代理和Cglib代理

2.2.1JDK代理
利用JDK的API,动态的在内存中构建代理对象，使用java.lang.reflect.Proxy这个包，实现代理只需要使用newProxyInstance方法：

static Object newProxyInstance(ClassLoader loader, Class

public interface Subject {

    public void Request();
}

//目标对象
public class RealSubject implements Subject {

    @Override
    public void Request() {
        System.out.println("真实的请求");
    }

}

//创建动态代理对象
public class ProxyFactory{
    //维护一个目标对象
    private Object object;

    public ProxyFactory(Object  object) {
        this.object=object;
    }
    //给目标对象生成代理对象
    public  Object getInstance() {
        return Proxy.newProxyInstance(
                object.getClass().getClassLoader(), 
                object.getClass().getInterfaces(),
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("执行目标对象方法前操作");
                      //执行目标对象方法
                        Object returnValue = method.invoke(object, args);
                        System.out.println("执行目标对象方法后操作");
                        return returnValue;
                    }
                });
    }
}

public class Client {

    public static void main(String[] args) {
        Subject realSubject=(Subject) new ProxyFactory(new RealSubject()).getInstance();
        realSubject.Request();      
    }
}

2.2.2Cglib代理
静态代理和JDK代理模式都是要求目标对象是实现一个接口的目标对象，而Cglib代理则不需要。
代理的类不能为final,目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

public class RealSubject {

    public void Request() {
        System.out.println("真实的请求");
    }

}

public class ProxyCglibFactory implements MethodInterceptor{
    //目标对象
    private Object object;
    public ProxyCglibFactory(Object object) {
        this.object=object;
    }
    @Override
    public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
        System.out.println("可以在执行目标对象方法前进行操作");
        //执行目标对象方法
        Object returnValue = method.invoke(object, args);
        System.out.println("可以在执行目标对象方法后进行操作");
        return returnValue;
    }
    public Object getProxyInstance() {
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(object.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

}

public class Client {

    public static void main(String[] args) {

        RealSubject real=(RealSubject) new ProxyCglibFactory(new RealSubject()).getProxyInstance();
        real.Request();
    }
}