代理模式

代理模式

为其他对象提供一种代理以控制对这个对象的访问

1. UML类图

2. 通用代码

聚合式的代理，产生该代理的实例，然后把被代理者的通过构造函数传递进来

//抽象主题类
public interface Subject{
    //定义了一个方法
    public void request();
}

//真实主题类
public class RealSubject implements Subject{
    //实现方法
    public void request(){
        //业务逻辑处理
    }
}

//代理类
public class Proxy implements Subject{
    //要代理哪个实现类
    private Subject subject = null;
    //默认被代理者
    public Proxy(){
        this.subject = new Proxy();
    }
    //通过构造函数传递代理者
    public Proxy(Object...object){
    }
    //代理的构造函数
    public Proxy(Subject _subject){
        this.subject = _subject;
    }
    //实现接口中定义的方法
    public void request(){
        this.before();
        this.subject.request();
        this.after();
    } 
    //预处理
    private void before(){
        //do something
    }
    //善后处理
    private void after(){
        //do something
    }
}

3. 优点

• 职责清晰：真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件事务，附带的结果就是变成简洁清晰
• 高扩展性：具体主题角色是随时都会发生变化的，只要它实现了接口，甭管它如何变化，都离不开接口，所以代理类完全可以在不做任何修改的情况下使用

4. 普通代理和强制代理

4.1 普通代理

只能访问代理角色，不能访问真实角色，即在场景类中不能直接new真实角色

场景类无须再调用真实角色，只需调用代理类就可以了

//真实主题类
public class RealSubject implements Subject{
    private String args = "";
    public RealSubject (Subject subject,String args) throws Exception{
        if(subject == null){
            throws new Exception("不能创建真实角色");
        }else{
            this.args = args;
        }
    }

    //实现方法
    public void request(){
        //业务逻辑处理
    }
}

//代理类
public class Proxy implements Subject{
    //要代理哪个实现类
    private Subject subject = null;
    //默认被代理者
    public Proxy(String args){
        try{
            subject = new RealSubject(this,args);
        }catch(Exception e){
            //TODO异常处理
        }
    }
    //实现接口中定义的方法
    public void request(){
        this.before();
        this.subject.request();
        this.after();
    } 
    //预处理
    private void before(){
        //do something
    }
    //善后处理
    private void after(){
        //do something
    }
}

4.2 强制代理

通过真实角色找到代理角色

//抽象主题类
public interface Subject{
    //定义了一个方法
    public void request();
    //找到自己的代理
    public Subject getProxy();
}

//强制代理的真实角色
public class RealSubject implements Subject{

    private Subject proxy = null;
    //找到自己的代理
    public Subject getProxy(){
        this.proxy = new Proxy(this);
        return this.proxy;
    }
    //实现方法
    public void request(){
        if(this.isProxy()){
            //业务逻辑处理    
        }else{
            System.out.println("请使用指定的代理访问");
        }           
    }
    private boolean isProxy(){
        if(this.proxy == null){
            return false;
        }else{
            return true;
        }
    }
}

//代理类
public class Proxy implements Subject{
    //要代理哪个实现类
    private Subject subject = null;
    //构造函数传递
    public Proxy(Subject subject){
        this.subject = subject;
    }
    //实现接口中定义的方法
    public void request(){
        this.before();
        this.subject.request();
        this.after();
    } 
    public Subject getProxy(){
        return this;
    }

    //预处理
    private void before(){
        //do something
    }
    //善后处理
    private void after(){
        //do something
    }
}

5. 动态代理

//抽象主题
public interface Subject{
    //业务操作
    public void doSomething(String str);
}
//真实主题
public class RealSubject implements Subject{
    //业务操作
    public void doSomething(String str){
        System.out.println("do something");
    } 
}

//动态代理的Handler类
public class MyInvacationHandler implements InvocationHandler {

    private Object target;

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }

    /*
     * 参数：
     * proxy  被代理对象
     * method  被代理对象的方法
     * args 方法的参数
     * 
     * 返回值：
     * Object  方法的返回值
     * */
    @Override
    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,InvacationHandler h){
        //寻找joinpoint连接点，AOP框架使用元数据定义
        if(true){
            //执行一个前置通知
        }
        return (T)Proxy.newProxyInstance(loader,interfaces,h);
    }
}

//进一步封装具体业务的动态代理
public class SubjectDynamicProxy extends DynamicProxy{
    public static <T> T newProxyInstance(Subject subject){
        //获得ClassLoader
        ClassLoader loader = subject.getClass().getClassLoader();
        //获得接口数组
        Class<?>[] classes = subject.getClass().getInterfaces();
        //获得handler
        InvacationHandler handler = new MyInvacationHandler(subject);
        return newProxyInstance(loader,classes,handler);
    }

}

//场景类
public class Client{
    public static void main(String[] args){
        //定义一个主题
        Subject subject = new RealSubject();
        //定义主题的代理
        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
        //代理的业务
        proxy.doSomething("");
    }

}