动态代理实战

代理机制及特点

通过实现 InvocationHandler 接口创建自己的调用处理器；

通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；

通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；

通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

先看一个简单易懂的例子：(来自百度百科)

抽象角色：

public interface Subject {
	public void request();
}

具体角色：

public class RealSubject implements Subject{

	@Override
	public void request() {
		System.out.println("REQUEST");
	}

}

代理角色：

public class DynamicSubject implements InvocationHandler {
	private Object sub;

	public DynamicSubject() {
	}

	public DynamicSubject(Object obj) {
		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("after calling " + method);
		return null;
	}
}

该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj）对其赋值；此外，在该类还实现了invoke方法，该方法中的
method.invoke(sub, args);

其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些相关操作。

客户端：

public class Client {
	public static void main(String[] args) throws Throwable {
		RealSubject rs = new RealSubject(); // 在这里指定被代理类
		InvocationHandler ds = new DynamicSubject(rs); // 初始化代理类
		Class<?> cls = rs.getClass();
		// 以下是分解步骤
		/*
		 * Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces()) ;
		 * Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class}); 
                 * Subject subject =(Subject) ct.newInstance(new Object[]{ds});
		 */
		// 以下是一次性生成
		Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), ds);
		subject.request();
	}
}

输出：

before calling public abstract void com.test.Subject.request()
REQUEST
after calling public abstract void com.test.Subject.request()

通过这种方式，被代理的对象（RealSubject）可以在运行时动态改变，需要控制的接口（Subject接口）可以在运行时改变，控制的方式（DynamicSubject类）也可以动态改变，从而实现了非常灵活的动态代理关系。

再看一个项目中用到过的例子：

先写一个工具类：

public class DynProxyUtil {
	public static Object newProxy(Object targetObject, InvocationHandler aopHandler) {
		ClassLoader cl = targetObject.getClass().getClassLoader();
		Class<?>[] interfaces = targetObject.getClass().getInterfaces();
		MyInvocationHandler myHandler = new MyInvocationHandler(targetObject, aopHandler);
		return Proxy.newProxyInstance(cl, interfaces, myHandler);
	}


	private static class MyInvocationHandler implements InvocationHandler {
		private Object tartetObj;
		private InvocationHandler aopHandler;


		public MyInvocationHandler(Object targetObj, InvocationHandler aopHandler) {// 非必须，但是为了给invoke传目的接口实现对象，需要它
			this.tartetObj = targetObj;
			this.aopHandler = aopHandler;
		}


		@Override
		public Object invoke(Object proxy, Method method, Object[] args) { // 由代理类调用
			Object ret = null;
			try {
				if (aopHandler != null) {
					ret = aopHandler.invoke(tartetObj, method, args);
				}
			} catch (Throwable e) {
				e.printStackTrace();
			}
			return ret;
		}
	}
}

实际项目中的一个具体应用：

/**
	 * 该对象会自动对所有的实现方法进行登录验证。<br/>
	 * 如果登录过期，会自动尝试登录一次，然后执行相同的方法。<br/>
	 * @return
	 */
	public static IHttpManager get() {
		if (sInstance == null) {
			sInstance = new InnerHttpManagerImpl();
			sInstance = (IHttpManager) DynProxyUtil.newProxy(sInstance, new InvocationHandler() {

				@Override
				public Object invoke(Object tgtObj, Method method, Object[] args) throws Throwable {
					try {
						Object obj = method.invoke(tgtObj, args);
						return obj;
					} catch (XException e) {
						if (e.getCode() == XException.ERR_NOT_LOGIN) {
							User user = AccManager.getCurUser();
							if (user == null) {
								throw e;
							}
							IHttpManager httpMgr = (IHttpManager) tgtObj;
							httpMgr.login(user);
							try {
								return method.invoke(tgtObj, args);
							} catch (Throwable e1) {
								throw new XException(e1);
							}
						}
						throw e;
					}
				}
			});
		}
		return sInstance;
	}