自己理解的动态代理,包含四种角色;
1:被代理人(Target.java)
2:代理机构(MyProxy.java)
3:处理机构(MyHandler.java)
4:处理机构用到的武器,对应于struts2中的拦截器(Interceptor.java)
代码如下:
1:被代理人(Target.java)
由于动态代理是建立在接口基础之上的,所以我们应该面向接口编程(不知道有没这个说法,自己理解的)。
Interceptor接口,和它的实现类
2:代理机构(MyProxy.java)
3:处理机构(MyHandler.java)
4:处理机构用到的武器,对应于struts2中的拦截器(Interceptor.java)
最后是我们的验证类:
处理流程梳理:
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)
以上是肤浅的分析,今后会慢慢完善。
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)
以上是肤浅的分析,今后会慢慢完善。