java设计模式：代理模式

package com.selfStudy;

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

/*本文来学习代理设计模式：
 * 代理模式：它是你为了提供额外的或不同的操作，而插入的用来代替“实际”对象的对象；充当着中间人
 *          的角色；(就想公司里老板和秘书的关系)；
 * 组成元素：
 * 1.抽象角色：声明真实对象和代理对象的共同接口；
 * 2.真实角色：代理角色所代表的真实对象，是我们最终要引用的对象；
 * 3.代理角色：其内部通过构造器拿到实际对象的引用，同时代理对象与真实的对象实现相同的接口，以便
 *             在任何是否都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作；
 *            相当于对真实对象进行了封装；
 * 
 * 
 * */
//1.抽象角色
interface Subject{
    void doSomething(String args);

    void doSomething();
}
//2.真实对象
class RealSubject implements Subject{
    public void doSomething(){
        System.out.println(" RealSubject dosothming");
    }
    public void doSomething(String args) {
        System.out.println("i will sumbit this "+args+" to our Web service");       
    }   
}

//3.代理角色
class ProxySubject implements Subject{
    private Subject real=null;
    ProxySubject(Subject real){
        this.real = real;
    }
    @Override
    public void doSomething(String args) {
        System.out.println("frist , examine the network");
        real.doSomething(args);
    }
    @Override
    public void doSomething() {
        System.out.println("proxySubject dosomething");
        real.doSomething();
    }

}

/*
 * 上述代码客服端实际上是想调用的是RealSubject 的doSomething方法，可以看到通过代理模式，其不但执行了RealSubject的doSomething
 * 方法，还执行了一些额外的操作；
 * 上面模式的缺点：
 *      首先：真实角色必须事先已经存在，并且其作为代理角色的内部属性；
 *      其次：一个真实的角色必须对应一个代理角色，那么就会存在这样的问题，如果存在大量的真实角色，那岂不会存在大量的代理角色
 *           从而使类数量急剧膨胀；
 * 因此引入动态代理模式：
 *  此时就会用到了java反射包中的 InvocationHandler接口和Proxy类；
 * */

class DynamicProxy implements InvocationHandler{
    private Object proxied;
    public DynamicProxy(Object proxied){
        this.proxied = proxied;
    }
    /**
     * Object proxy:在其上调用方法的代理实例
     * Method method:对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口
     *                ，该接口可以是代理类赖以继承方法的代理接口的超接口。
     * Object[] args:包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数
     *                被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        if(args!=null)
          return method.invoke(proxied, args);
        return method.invoke(proxied);
    }

}
/**
 * ClassLoader: loader - 定义代理类的类加载器
 * Class[] :interfaces - 代理类要实现的接口列表
 * InvocationHandler:h - 指派方法调用的调用处理程序 
 */

public class ProxyModel {

    public static void main(String[] args) {


        ProxySubject ps = new ProxySubject(new RealSubject());
        ps.doSomething();
        ps.doSomething("seek people");


        RealSubject real = new RealSubject();
        Subject proxy = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(), 
                new Class[]{Subject.class},new DynamicProxy(real));
        proxy.doSomething("hahahah");

    }

}