java代理模式与反射机制(整理)

    代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

    代理模式一般涉及到的角色有： 
　　抽象角色：声明真实对象和代理对象的共同接口； 
　　代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。 
　　真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

        下面看一个例子:(仔细看注释)   注意: 本例中原始类:指真正干活的类   虚基类: 指最高层的那个抽象类   代理类:是指封装了原始类的那个类

package com.java.proxy;

interface Subject{
    abstract public void request();
}

class RealSubject implements Subject{
    @Override
    public void request() {
        System.out.println("real subject");
    }
}

class ProxySubject implements Subject{
    Subject subject;
    public ProxySubject() {
    }
    public ProxySubject(Subject subject){
        this.subject=subject;
    }
    @Override
    public void request() {
        System.out.println("预处理工作");
        subject.request();
        System.out.println("后续工作");
    }
}
public class ProxyModel {
     public static void main(String[] args) {
        Subject subject=new ProxySubject(new RealSubject());   //我认为, 代理的精髓就是, 本来需要让原始类干的事, 现在需要让代理来干. 这就是精髓.  对Java来说, 就存在一个调用的问题, 也就是说, 本来需要调用原始类的方法的时候, 现在需要调用代理类的同名方法. 注意这一行语句!: 原始类一定是要通过参赛来传进去给到代理类, 代理类一定会返回自己本身的对象给调用者使用.  调用者只需要搞个虚基类的指针用来指向代理类返回的对象即可.
这里就必须又要注意: 1) 原始类需要把自己通过参赛传给代理类, 那么代理类的构造函数里面一定是需要能够接受原始类, 它才能称之为原始类的代理  2)代理类能最终被虚基类的指针所调用, 所以必须实现了虚基类的同名方法. 3)原始类也必须要实现虚基类的同名方法才可以  4)代理类需要封装好原始类的方法, 同时即可以做预处理等工作.
这里: RealSubject就是原始类, ProxySubject就是代理类, subject就是虚基类
        subject.request();
    }
}

    由以上代码可以看出，客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理 RealSubject类，同样达到目的，同时还可以封装其他方法(可以做一些预处理，和后续工作)，可以处理一些其他问题。 
   
    另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须 对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。     
    看下面的例子:

package com.java.proxy;

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

interface Subject{   //虚基类
    abstract public void request();
}

class RealSubject implements Subject{   //原始类,真正干活的类
    public RealSubject() {
    }
    @Override
    public void request() {
        System.out.println("real subject");
    }
}

class ProxySubject implements InvocationHandler{   //代理类,注意:这里跟上面的例子就有点不同了. 上例中代理类是直接实现的虚基类那个接口, 但是这里直接是实现的Java中预定义的一个InvocationHandler类, 这个类中只有一个invoke的方法, 任何实现这个接口的类都必须重写这个方法. 实际上, 本例中可以看代码, 也实现了这个invoke接口的
    private Subject obj;
    public ProxySubject() {
    }
    public ProxySubject(Subject obj){
        this.obj=obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("预处理工作");
        method.invoke(obj, args);
        System.out.println("后续工作");
        return null;
    }
}
public class ProxyModel {
     public static void main(String[] args) {
         RealSubject realSubject=new RealSubject();
         Class cla=realSubject.getClass();  //前两行,先生成一个原始类的对象,然后得到原始类的Class类对象.(注意,Class本身也是一个java的类),这个类对象是后面要传递给newProxyInstance函数的.
         InvocationHandler handler=new ProxySubject(realSubject); //同样, 这个返回了一个handler, 一样是要传递给后面的newProxyInstance函数的.
         Subject subject=(Subject)Proxy.newProxyInstance(cla.getClassLoader(), cla.getInterfaces(), handler); //这里是通过Java预制的生成代理类的函数来生成一个代理类的对象, (注意生成对象还要强转一下)
         subject.request();  // 看这里也是在用代理类, 调用原始类里的同名request函数在干活!
     }
}

对比一下上例的主函数中的调用:
Subject subject=new ProxySubject(new RealSubject());  
subject.request();
其实本例和上例的区别就在于, 这个代理类, 是通过Proxy.newProxyInstance来动态生成的, 而不是直接继承的虚基类接口.  
好, 我们来仔细看下newProxyInstance( loader, [] interfaces,  h) throws  的玩法: 看官方文档:

• Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler. 
  Returns: a proxy instance with the specified invocation handler of a proxy class that is defined by the specified class loader and that implements the specified interfaces 

这句话的意思是说: 它会返回一个代理类, 第一个参赛就是指的原始类的loader, 第二个类是从原始类中获取到的interfaces接口, 也即实现了虚基类的接口, handler就是实现了InvocationHandler接口的那个handler.