[color=red][align=center][size=large]commons-proxy的使用[/size][/align][/color]
代理可以分为两种。
[list]
[*]静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。
[*]动态代理:在程序运行时,运用反射机制动态创建而成。
[/list]
代理主要用途有懒加载,安全,事务,日志,行为监控等对个方面。commons-proxy中提供了代理的多种生成工具,比如用JDK动态代理,CGLIB和Javassist。首先,先介绍工具的实现原理,然后再介绍对应的commons-proxy中对工具的运用[list]
[*]JDK 动态代理
JDK动态代理主要涉及两个类 Proxy,InvocationHandler.Proxy 提供用于创建动态代理类和实例的静态方法,它还是由这些方法创建的所有动态代理类的超类.
InvocationHandler接口中只有一个方法,一般我们会实现这个类,重写这个唯一的方法invoke(),当用Proxy创建代理对象(代理类的名字是不可知的,这也是动态代理与静态代理的区别)时,传入了一个InvocationHandler参数。当调用代理对象的任何方法放入时候,会自动跳转到调用InvocationHandler中的invoke方法(你可以在invoke()方法内设置断点跟踪)
使用JDK动态代理步骤:
[*]首先,必须有一个实现了接口的对象(即要代理的对象)
[*]其次,先实现InvocationHandler接口,并且在此实现中得到代理的真正对象(一般通过构造函数或setter方法注入,由成员变量接受);然后调用Proxy的newProxyInstance,创建代理对象。
接口Animal,实现类Dog,InvocationHandler的实现MyHandler(如无特别说明,下面举例以此为据)
Proxy.newProxyInstance()方法内部运行机制:
代理类名:把接口类加载到JVM,放到内部Set里保存,把接口的完整名字保存,带包名的接口名字,并以把这组接口名称数组转换成List作为key,用于下面生成代理类后保存到内部Map的key.也就是相当于这一组的接口名称对应的一个生成的代理类.主要是从内存里找是否之前已经生成好了这同一组接口的代理类,如果有就直接拿出。这里第一次是需要新建立的,所以开始创建代理,首先检查代理目标接口的访问控制符是否是默认包级别的,如果是就需要给生成的代理类设置目标接口同样的包名,才能默认访问这种级别下的接口。如果这种有默认访问控制标识符的目标接口,又有不同包名的目标接口,则会报出错误。否则其它情况,是给的无包名的代理类,生成的代理类的默认名称是$Proxy开头加Proxy里标识唯一类名的数字,是静态long型变量,每次生成一次代理类会累加
字节码类: 动态生成class字节码类,该类相当于是Proxy的子类,实现了需要代理的接口方法,并在每个方法里调用了InvocationHandler的invoke方法,而我们自己实现的InvocationHandler接口类里完成了以反射方式最终对目标业务类的接口方法进行调用。所以此种方式实现的动态代理只能代理接口方法,对具体类的代理不能实现。
commons-proxy中有一个类叫ProxyFactory,它底层用JDK中Proxy.newProxyInstance来创建代理对象的.在以下创建方法中,只看形参,主要有两点区别 [color=darkred]1.有无ClassLoader,意思是可以自己指定;如果没有指定,默认是当前线程的ClassLoader(通过Thread.currentThread().getContextClassLoader()获取),传入的ClassLoader就是传入到Proxy.newProxyInstance的ClassLoader形参中。2. 有三种不同类型ObjectProvider,Interceptor ,Invoker [/color]
ProxyFactory创建代理的方法如下
[color=red]ObjectProvider作为参数构造了DelegatorInvocationHandler ,这个类实现了InvocationHandler,所以,当目标对象被调用的时候,该类的invoke()方法中就通过ObjectProvider拿到被代理的目标对象,然后调用目标对象上的方法。很显然,由于DelegatorInvocationHandler 在内部构造,invoke()方法根本不可能被重写,所以假如你想在方法前后打印日志,是根本不可能实现的。故ObjectProvider只被简单的作为一个代理实现。同样DelegatorInvocationHandler传入到Proxy.newProxyInstance方法的形参中。[/color]
举例
[color=red]Interceptor和Target(目标对象)作为形参传入InterceptorInvocationHandler,
同样,InterceptorInvocationHandler实现了InvocationHandler.当调用代理对象方法时,会调用invoke(),其中ReflectionInvocation实现了Invocation[/color]
[color=red]看以上代码methodInterceptor.intercept( invocation )可知只需要重写 intercept( invocation ),在方法中只需要调用invocation.proceed()即可实现目标对象的方法调用,你可以在invocation.proceed()前后打印日志.ReflectionInvocation的proceed()方法实现(仍然用反射)[/color]
举例
结果
Invoker传入InvokerInvocationHandler,可见你只需要重写invoke()。
[code]
private static class InvokerInvocationHandler implements InvocationHandler
{
private final Invoker invoker;
public InvokerInvocationHandler( Invoker invoker )
{
this.invoker = invoker;
}
public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
{
return invoker.invoke( proxy, method, args );
}
}[/code]
举例
结果
总结:ProxyFactory创建代理有三种方式(不考虑ClassLoader):ObjectProvider,
Interceptor,Invoker.
[list]
[color=darkred][*]ObjectProvider接口只有一个Object getObject(),只是提供目标对象ProxyFactory创建代理对象,不能够手动控制方法调用;
[*]Interceptor接口只有一个 Object intercept(Invocation invocation)Invocation类中封装了一些信息,比如代理对象,方法,方法参数,方法调用(前面讲的Invocation.process()),可以在intercept中做打印日志,控制方法是否调用等操作;
[*]Invoker接口只有一个Object invoke(Object proxy, Method method, Object[] arguments),与intercept不同的是它并没有把proxy,method,arguments和method.invoke()封装为
Invocation.process()。[/color]
[/list]
[*]CGLIB
[*]Javassist
[list]
代理可以分为两种。
[list]
[*]静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。
[*]动态代理:在程序运行时,运用反射机制动态创建而成。
[/list]
代理主要用途有懒加载,安全,事务,日志,行为监控等对个方面。commons-proxy中提供了代理的多种生成工具,比如用JDK动态代理,CGLIB和Javassist。首先,先介绍工具的实现原理,然后再介绍对应的commons-proxy中对工具的运用[list]
[*]JDK 动态代理
JDK动态代理主要涉及两个类 Proxy,InvocationHandler.Proxy 提供用于创建动态代理类和实例的静态方法,它还是由这些方法创建的所有动态代理类的超类.
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
InvocationHandler接口中只有一个方法,一般我们会实现这个类,重写这个唯一的方法invoke(),当用Proxy创建代理对象(代理类的名字是不可知的,这也是动态代理与静态代理的区别)时,传入了一个InvocationHandler参数。当调用代理对象的任何方法放入时候,会自动跳转到调用InvocationHandler中的invoke方法(你可以在invoke()方法内设置断点跟踪)
Object invoke(Object proxy, Method method, Object[] args)
使用JDK动态代理步骤:
[*]首先,必须有一个实现了接口的对象(即要代理的对象)
[*]其次,先实现InvocationHandler接口,并且在此实现中得到代理的真正对象(一般通过构造函数或setter方法注入,由成员变量接受);然后调用Proxy的newProxyInstance,创建代理对象。
接口Animal,实现类Dog,InvocationHandler的实现MyHandler(如无特别说明,下面举例以此为据)
package com.bstek.dylan;
public interface Animal {
public void eat();
}
package com.bstek.dylan;
public class Dog implements Animal {
public void eat() {
System.out.println("I am eating ");
}
}
package com.bstek.dylan;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyHandler implements InvocationHandler {
private Object target ;
public Object bind(Object target) {
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("--------ok---------");
return method.invoke(target, args);
}
public static void main(String[] args) {
Animal dog = new Dog();
dog = (Animal) new MyHandler().bind(dog);
dog.eat();
}
}
结果
--------ok---------
I am eating
Proxy.newProxyInstance()方法内部运行机制:
代理类名:把接口类加载到JVM,放到内部Set里保存,把接口的完整名字保存,带包名的接口名字,并以把这组接口名称数组转换成List作为key,用于下面生成代理类后保存到内部Map的key.也就是相当于这一组的接口名称对应的一个生成的代理类.主要是从内存里找是否之前已经生成好了这同一组接口的代理类,如果有就直接拿出。这里第一次是需要新建立的,所以开始创建代理,首先检查代理目标接口的访问控制符是否是默认包级别的,如果是就需要给生成的代理类设置目标接口同样的包名,才能默认访问这种级别下的接口。如果这种有默认访问控制标识符的目标接口,又有不同包名的目标接口,则会报出错误。否则其它情况,是给的无包名的代理类,生成的代理类的默认名称是$Proxy开头加Proxy里标识唯一类名的数字,是静态long型变量,每次生成一次代理类会累加
字节码类: 动态生成class字节码类,该类相当于是Proxy的子类,实现了需要代理的接口方法,并在每个方法里调用了InvocationHandler的invoke方法,而我们自己实现的InvocationHandler接口类里完成了以反射方式最终对目标业务类的接口方法进行调用。所以此种方式实现的动态代理只能代理接口方法,对具体类的代理不能实现。
ProxyGenerator.generateProxyClass(proxyName, interfaces)
根据指定接口和代理类名生成class字节数据,再用这代码生成最终类
proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
commons-proxy中有一个类叫ProxyFactory,它底层用JDK中Proxy.newProxyInstance来创建代理对象的.在以下创建方法中,只看形参,主要有两点区别 [color=darkred]1.有无ClassLoader,意思是可以自己指定;如果没有指定,默认是当前线程的ClassLoader(通过Thread.currentThread().getContextClassLoader()获取),传入的ClassLoader就是传入到Proxy.newProxyInstance的ClassLoader形参中。2. 有三种不同类型ObjectProvider,Interceptor ,Invoker [/color]
ProxyFactory创建代理的方法如下
Object createDelegatorProxy(ClassLoader classLoader, ObjectProvider delegateProvider, Class[] proxyClasses)
Object createDelegatorProxy(ObjectProvider delegateProvider, Class[] proxyClasses)
Object createInterceptorProxy(ClassLoader classLoader, Object target, Interceptor interceptor, Class[] proxyClasses)
Object createInterceptorProxy(Object target, Interceptor interceptor, Class[] proxyClasses)
Object createInvokerProxy(ClassLoader classLoader, Invoker invoker, Class[] proxyClasses)
Object createInvokerProxy(Invoker invoker, Class[] proxyClasses)
[color=red]ObjectProvider作为参数构造了DelegatorInvocationHandler ,这个类实现了InvocationHandler,所以,当目标对象被调用的时候,该类的invoke()方法中就通过ObjectProvider拿到被代理的目标对象,然后调用目标对象上的方法。很显然,由于DelegatorInvocationHandler 在内部构造,invoke()方法根本不可能被重写,所以假如你想在方法前后打印日志,是根本不可能实现的。故ObjectProvider只被简单的作为一个代理实现。同样DelegatorInvocationHandler传入到Proxy.newProxyInstance方法的形参中。[/color]
private static class DelegatorInvocationHandler implements InvocationHandler
{
private final ObjectProvider delegateProvider;
protected DelegatorInvocationHandler( ObjectProvider delegateProvider )
{
this.delegateProvider = delegateProvider;
}
public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
{
try
{
return method.invoke( delegateProvider.getObject(), args );
}
catch( InvocationTargetException e )
{
throw e.getTargetException();
}
}
}
举例
BeanProvider provider = new BeanProvider();
provider.setBeanClass(Dog.class);
ProxyFactory factory = new ProxyFactory();
Animal proxy = (Animal)factory.createDelegatorProxy(provider, provider.getObject().getClass().getInterfaces());
proxy.eat();
结果
I am eating
[color=red]Interceptor和Target(目标对象)作为形参传入InterceptorInvocationHandler,
同样,InterceptorInvocationHandler实现了InvocationHandler.当调用代理对象方法时,会调用invoke(),其中ReflectionInvocation实现了Invocation[/color]
private static class InterceptorInvocationHandler implements InvocationHandler
{
private final Object target;
private final Interceptor methodInterceptor;
public InterceptorInvocationHandler( Object target, Interceptor methodInterceptor )
{
this.target = target;
this.methodInterceptor = methodInterceptor;
}
public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
{
final ReflectionInvocation invocation = new ReflectionInvocation( target, method, args );
return methodInterceptor.intercept( invocation );
}
}
[color=red]看以上代码methodInterceptor.intercept( invocation )可知只需要重写 intercept( invocation ),在方法中只需要调用invocation.proceed()即可实现目标对象的方法调用,你可以在invocation.proceed()前后打印日志.ReflectionInvocation的proceed()方法实现(仍然用反射)[/color]
public Object proceed() throws Throwable
{
try
{
return method.invoke( target, arguments );
}
catch( InvocationTargetException e )
{
throw e.getTargetException();
}
}
举例
public class MyInterceptor implements Interceptor {
public Object intercept(Invocation invocation) throws Throwable {
String method = invocation.getMethod().getName();
if(method.equals("eat")) {
System.out.println("吃饭");
}
return invocation.proceed();
}
}
Interceptor interceptor = new MyInterceptor();
ProxyFactory factory = new ProxyFactory();
Animal animal = new Dog();
Animal proxy = (Animal)factory.createInterceptorProxy(animal, interceptor, animal.getClass().getInterfaces());
proxy.eat();
结果
吃饭
I am eating
Invoker传入InvokerInvocationHandler,可见你只需要重写invoke()。
[code]
private static class InvokerInvocationHandler implements InvocationHandler
{
private final Invoker invoker;
public InvokerInvocationHandler( Invoker invoker )
{
this.invoker = invoker;
}
public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
{
return invoker.invoke( proxy, method, args );
}
}[/code]
举例
public class MyInvoker implements Invoker {
private Object target;
public MyInvoker(Object target){
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] arguments)
throws Throwable {
String methodName = method.getName();
if(methodName.equals("eat")) {
System.out.println("吃饭");
}else if(methodName.equals("defecate")) {
System.out.println("排便");
}
return method.invoke(target, arguments);
}
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
}
Animal animal = new Dog();
Invoker invoker = new MyInvoker(animal);
ProxyFactory factory = new ProxyFactory();
Animal proxy = (Animal)factory.createInvokerProxy(invoker, animal.getClass().getInterfaces());
proxy.eat();
结果
吃饭
I am eating
总结:ProxyFactory创建代理有三种方式(不考虑ClassLoader):ObjectProvider,
Interceptor,Invoker.
[list]
[color=darkred][*]ObjectProvider接口只有一个Object getObject(),只是提供目标对象ProxyFactory创建代理对象,不能够手动控制方法调用;
[*]Interceptor接口只有一个 Object intercept(Invocation invocation)Invocation类中封装了一些信息,比如代理对象,方法,方法参数,方法调用(前面讲的Invocation.process()),可以在intercept中做打印日志,控制方法是否调用等操作;
[*]Invoker接口只有一个Object invoke(Object proxy, Method method, Object[] arguments),与intercept不同的是它并没有把proxy,method,arguments和method.invoke()封装为
Invocation.process()。[/color]
[/list]
[*]CGLIB
[*]Javassist
[list]