静态代理和动态代理

所谓代理，可以认为是 客户无法直接与服务端交流，那么就需要一个媒介来处理他们之间的会面。思想比较简单，但是遇到真实情况下，静态代理比较容易理解，动态代理值得学习，想起以前别人的一些程序还是比较容易理解。

一）静态代理

1：

public abstract class Subject
{
    public abstract void request();
}

2：

public class RealSubject extends Subject
{
    public void request()
    {
        System.out.println("From real subject.");
    }
}:

3：

public class ProxySubject extends Subject
{
    private RealSubject realSubject; //代理角色内部引用了真实角色
    
    public void request()
    {
        this.preRequest(); //在真实角色操作之前所附加的操作
        
        if(null == realSubject)
        {
            realSubject = new RealSubject();
        }
        
        realSubject.request(); //真实角色所完成的事情
        
        this.postRequest(); //在真实角色操作之后所附加的操作
    }
    private void preRequest()
    {
        System.out.println("pre request");
    }
    
    private void postRequest()
    {
        System.out.println("post request");
    }
}

4：

public class Client
{
    public static void main(String[] args)
    {
        Subject subject = new ProxySubject();
        
        subject.request();
    }
}
二）动态代理

1：

public interface Subject
{
    public void request();
}

2：

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

}

3：

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

/**
 * 该代理类的内部属性是Object类型，实际使用的时候通过该类的构造方法传递进来一个对象
 * 此外，该类还实现了invoke方法，该方法中的method.invoke其实就是调用被代理对象的将要
 * 执行的方法，方法参数是sub，表示该方法从属于sub，通过动态代理类，我们可以在执行真实对象的方法前后
 * 加入自己的一些额外方法。
 *
 */

public class DynamicSubject implements InvocationHandler
{
    private Object sub;
    
    public DynamicSubject(Object obj)
    {
        this.sub = obj;
    }
    
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable
    {
        System.out.println("before calling: " + method);
        
        method.invoke(sub, args);
        
        System.out.println(args == null);
        
        System.out.println("after calling: " + method);
        
        return null;
    }
    

}

4：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;
import java.util.Vector;

public class VectorProxy implements InvocationHandler
{
    private Object proxyObj;

    public VectorProxy(Object obj)
    {
        this.proxyObj = obj;
    }

    public static Object factory(Object obj)
    {
        Class<?> classType = obj.getClass();

        return Proxy.newProxyInstance(classType.getClassLoader(),
                classType.getInterfaces(), new VectorProxy(obj));
    }
    
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable
    {
        System.out.println("before calling: " + method);
        
        if(null != args)
        {
            for(Object obj : args)
            {
                System.out.println(obj);
            }
        }
        
        Object object = method.invoke(proxyObj, args);
        
        System.out.println("after calling: " + method);
        
        return object;
    }
    
    public static void main(String[] args)
    {
        List v = (List)factory(new Vector());
        
        System.out.println(v.getClass().getName());
        
        v.add("New");
        v.add("York");
        
        System.out.println(v);
        
        v.remove(0);
        System.out.println(v);
        
    }

}

5：

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

public class Client
{
    public static void main(String[] args)
    {
        RealSubject realSubject = new RealSubject();

        InvocationHandler handler = new DynamicSubject(realSubject);

        Class<?> classType = handler.getClass();

        // 下面的代码一次性生成代理

        Subject subject = (Subject) Proxy.newProxyInstance(classType
                .getClassLoader(), realSubject.getClass().getInterfaces(),
                handler);

        subject.request();

        System.out.println(subject.getClass());

    }

}

Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。

其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。可以这样想象：编译期间我们不知道有多少类，只有在运行期间利用反射机制动态的生成一些class。这就是所谓的动态代理，表面做到了灵活性，但是我始终觉得比较耗资源。