设计模式之禅笔记7--代理模式

代理模式

定义：为其他对象提供一种代理以控制对这个对象的访问。
角色如下：
1. Subject抽象主题角色
2. RealSubject具体主题角色。也叫做被委托角色。
3. Proxy代理主题角色。也叫做代理类，委托类。

public interface Subject {

    //定义一个方法
    public void  request();
}
public class RealSubject implemnts Subject{
    //实现方法
    public void request(){
        //业务处理
    }
}
public class Proxy implements Subject{
    //要代理哪个实现类
    private Subejct subejct = null;
    //默认被代理者
    public Proxy(){
        this.subject = new proxy();
    }
    //通过构造函数传递代理者
    public Proxy(Object...objects){

    }
    public proxy(Subject subject){
        this.subejct = subject;
    }
    //实现接口中定义的方法
    public void request(){
        this.before();
        this.subject.request();
        this.after();
    }
    public void before(){do Something}
    public void after(){do Something}
}

优点：
1. 职责清晰
2. 高扩展性
3. 智能化

普通代理：客户端只能访问代理角色，而不能访问真实角色。
强制代理：一般的思维是要通过代理找到真实的角色。但是强制代理是通过真实角色找到代理角色。否则你不能访问。即先new出一个真实角色，再通过真实角色的getProsy()方法得到代理角色。客户端再调用代理角色的方法。

代理是有个性的：代理类不仅仅可以实现主题接口，也可以实现其他接口完成不同的任务。代理的目的就是在目标对象方法的基础上增强，其本质是对目标对象方法进行拦截和过滤。

动态代理

在实现阶段不用关心代理谁，而在运行阶段才指定代理哪一个对象。相对来说，自己写代理类就是静态代理。以打游戏为例。其中InvocationHandler是JDK提供的动态代理接口，对被代理类的方法进行处理。

//动态代理类
public class GamePlayIH implements InvocationHandler{
    //被代理者
    Class cls = null;
    //被代理的实例
    Object obj = null;
    //我要代理谁
    public GamePlayIH(Object _obj){
        this.obj = _obj;
    }
    //调用被代理类的方法
    public Object invoke(Object proxy,Method method,Object[] args){
        Object result = mehtod.invoke(this.obj,args);
        return result;
    }
}

invoke方法是接口InvocationHandler定义必须实现的。他完成对真实方法的调用。

public class Client{
    public static void main(String[] args) throws Throwable{
        //定义一个痴迷的玩家
        IGamePlayer player = new GamePlayer("张三");
        //定义个Handler
        InvocationHandler handler = new GamePlayIH(player);
        //开始打游戏
        System.out.println("开始时间是：2009-8-25 10:45");
        //获得类的Class loader
        ClassLoader cl = player.getClass().getClassLoader();
        //动态产生一个代理者
        IGamePalyer proxy = (IGamePalyer )Proxy.newProxyInstance(cl,new Class[]{IGamePalyer.class},handler);
        //登录
        proxy.login("zhngshan","password");
        proxy.killBoss();
        proxy.upgrade();
        System.out.println("游戏时间结束");
    }
}

动态代理的通用源码：

public interface Subject {
    public void doSomething(String abc);
}
public class RealSubject implements Subject {

    //业务操作
    public void doSomething(String str) {
        System.out.println("do something!---->" + str);
    }

}
public class MyInvocationHandler implements InvocationHandler {
    private Object target = null;
    public MyInvocationHandler(Object _obj){
        this.target = _obj;
    }
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        return method.invoke(this.target, args);
    }
}
public class DynamicProxy<T> {

    public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
        if(true){
            (new BeforeAdvice()).exec();
        }
        return (T)Proxy.newProxyInstance(loader,interfaces, h);     
    }
}
public interface IAdvice {
    public void exec();
}
public class BeforeAdvice implements IAdvice{

    public void exec(){
        System.out.println("我是前置通知，我被执行了");
    }
}
public class AfterAdvice implements IAdvice {

    public void exec() {
        System.out.println("我是后置通知，我被执行了");
    }

}
public class Client {

    public static void main(String[] args) {
        Subject subject = new RealSubject();

        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);

        proxy.doSomething("Finish");
    }
}

一个类的动态代理是这样的，由InvocationHandler的实现类实现所有的方法，由其invoke方法接管所有方法的实现，其调用过程如下图：

以上的Dynamicproxy类不具有业务意义，是一个通用类。可以增加一个具有业务的动态代理：

public class SubejctDynamicProxy extends DynamicProxy{
    public static <T> T newProxyInstance(Subject subject){
        ClassLoader loader = subject.getClass().getClassLoader();
        Class<?> calsses = subejct.getClass().geInterfaces();
        InvocationHandler handler = new MyInvocationHandler(subject);
        return newProxyInstance(loader,classes,handller);
    }
}

注：要实现动态代理的首要条件：被代理类必须实现一个接口。