静态代理和动态代理
所谓代理，可以认为是 客户无法直接与服务端交流，那么就需要一个媒介来处理他们之间的会面。思想比较简单，但是遇到真实情况下，静态代理比较容易理解，动态代理值得学习，想起以前别人的一些程序还是比较容易理解。
一）静态代理
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。这就是所谓的动态代理，表面做到了灵活性，但是我始终觉得比较耗资源。
