java的动态代理机制

自己理解的动态代理，包含四种角色；
1：被代理人（Target.java）
2：代理机构（MyProxy.java）
3：处理机构（MyHandler.java）
4：处理机构用到的武器，对应于struts2中的拦截器（Interceptor.java）

代码如下：
1：被代理人（Target.java）
由于动态代理是建立在接口基础之上的，所以我们应该面向接口编程（不知道有没这个说法，自己理解的）。

Interceptor接口，和它的实现类

package com.interceptor;

public interface TargetInterface {
	public void doSomething();
}

package com.interceptor;

public class Target implements TargetInterface {

	public void doSomething() {
		System.out.println("do something");
	}
	
}

2：代理机构（MyProxy.java）

package com.interceptor;
import java.lang.reflect.Proxy;

public class MyProxy {
	public Object getProxy(Object object){
		MyHandler myHandler = new MyHandler();
		myHandler.setObject(object);
		return Proxy.newProxyInstance(object.getClass().getClassLoader(),
					object.getClass().getInterfaces(),myHandler);
		
	}
}

3：处理机构（MyHandler.java）

package com.interceptor;

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

public class MyHandler implements InvocationHandler {

	private Object object;
	private Interceptor interceptor = new Interceptor();
	public void setObject(Object object){
		this.object = object;
	}
	public Object invoke(Object arg0, Method arg1, Object[] arg2)
			throws Throwable {
		Object result = null;
		interceptor.before();
		
		result = arg1.invoke(object,arg2);
		
		interceptor.after();
		return result;
	}

}

4：处理机构用到的武器，对应于struts2中的拦截器（Interceptor.java）

package com.interceptor;

public class Interceptor {
	public void before(){
		System.out.println("before");
	}
	
	public void after(){
		System.out.println("after");
	}
}

最后是我们的验证类：

package com.interceptor;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		TargetInterface  target = new Target();
		
		//以下生成target的一个代理
		
		MyProxy myProxy = new MyProxy();
		TargetInterface proxy =(TargetInterface)myProxy.getProxy(target);
		proxy.doSomething();
	}

}

处理流程梳理：
1：由测试类Client运行开始，这里先生成的是被代理类所继承的接口的一个引用。（我理解的动态代理和面向接口编程有关，就是这里体现的，定义接口引用）

2：接下来是定义一个代理对象（MyProxy myProxy = new MyProxy();），我们的代理对象在调用getProxy方法，并传入被代理引用后(TargetInterface)myProxy.getProxy(target)，会被强制转换为被代理类所实现的接口类型。

3：深入到（myProxy.getProxy(target)）这里面去。也就是MyProxy类中。
我们看到，被代理的那个引用，也就是这个（myProxy.getProxy(target)）里面的target参数
被（myHandler.setObject(object);），又传给了处理类MyHandler，接下来第四点会分析到M因H按了人中进行的动作，先说说这个（Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),myHandler);）代理类的一个newProxyInstance方法，这个方法用来做什么的，它会在你创建MyProxy对象的时候调用这个方法实例化。注意里面的第三个参数myHandler。这个参数说明我们创建MyProxy对象时传递了处理类的对象。

4：既然第三步创建MyProxy时，传递了myHandler对象参数给实例化方法。那么我们进入MyHandler方法中，看它做了些什么。

你可以看到这个类MyHandler是我们的主战场。
它做了些什么？
首先它实现了这个接口（InvocationHandler），这个接口里面的方法（invoke(Object arg0, Method arg1, Object[] arg2)）就是我们的处理核心。
invoke方法里面的内容（Object result = null;
interceptor.before();

result = arg1.invoke(object,arg2);

interceptor.after();
return result;）
做了在运行object实例，也就是累Client里面的引用proxy调用方法doSomething()的时候，在运行方法doSometing之前调用了拦截器Interceptor的before方法，运行之后又调用了after方法。



总结：处理线路：Client用到MyProxy，MyProx用到MyHandler，MyHandler用到Interceptor，最后我们的被代理类Target就这么处理完了。

用上面的四种角色来分析，就是被代理人（Target），由代理机构代理（MyProxy），代理机构聘请处理机构来处理（MyHandler），处理机构用到了武器（Interceptor）


以上是肤浅的分析，今后会慢慢完善。