JDK动态代理与CGLib动态代理相关问题

JDK动态代理与CGLib动态代理相关问题

欢迎关注公众号:程序员面试经验分享(jobbible)

原文:mp.weixin.qq.com/s/YeNX

导读:
1、JDK动态代理原理是什么?为什么不支持类的代理?
2、JDK动态代理实例
3、CGLib代理原理是什么?
4、CGLib代理实例
5、JDK动态代理与CGLib代理的区别是什么?
6、总结

注:阅读本文之前可以先阅读:什么是代理模式?

JDK动态代理原理是什么?为什么不支持类的代理?

利用拦截器(拦截器必须实现InvocationHanlder)加上反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。是在程序运行的过程中,根据被代理的接口来动态生成代理类的class文件,并加载运行的过程。

之所以只支持实现了接口的类的代理。从原理上讲是因为JVM动态生成的代理类有如下特性:

继承了Proxy类,实现了代理的接口,最终形式如下(HelloInterface为被代理类实现的接口):

public final class $Proxy0 extends Proxy implements HelloInterface{

.......

}

然而由于java不能多继承,这里已经继承了Proxy类了,不能再继承其他的类,所以JDK的动态代理不支持对实现类的代理,只支持接口的代理。

从使用上讲,创建代理类时必须传入被代理类实现的接口。

详细介绍:

在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的。

1、InvocationHandler

每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

InvocationHandler这个接口的唯一一个方法 invoke 方法:

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

这个方法一共接受三个参数,那么这三个参数分别代表如下:

proxy:  指代JDK动态生成的最终代理对象

method: 指代的是我们所要调用真实对象的某个方法的Method对象

args:   指代的是调用真实对象某个方法时接受的参数

2、Proxy

Proxy这个类的作用就是用来动态创建一个代理对象的类,它提供了许多的方法,但是我们用的最多的就是 newProxyInstance 这个方法:

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws IllegalArgumentException

这个方法的作用就是得到一个动态的代理对象,其接收三个参数,我们来看看这三个参数所代表的含义:

loader: ClassLoader对象,定义了由哪个ClassLoader来对生成的代理对象进行加载。

interfaces: Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了。

Handler:InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上。

所以我们所说的DynamicProxy(动态代理类)是这样一种class:它是在运行时生成的class,在生成它时你必须提供一组interface给它,然后该class就宣称它实现了这些 interface。这个DynamicProxy其实就是一个Proxy,它不会做实质性的工作,在生成它的实例时你必须提供一个handler,由它接管实际的工作。

JDK动态代理实例

1、创建接口类

public interface HelloInterface {

void sayHello();

}

2、创建被代理类,实现接口

/**

* 被代理类

*/

public class HelloImpl implements HelloInterface{

@Override

public void sayHello() {

System.out.println("hello");

}

}

3、创建InvocationHandler实现类

/**

* 每次生成动态代理类对象时都需要指定一个实现了InvocationHandler接口的调用处理器对象

*/

public class ProxyHandler implements InvocationHandler{

private Object subject; // 这个就是我们要代理的真实对象,也就是真正执行业务逻辑的类

public ProxyHandler(Object subject) {// 通过构造方法传入这个被代理对象

this.subject = subject;

}

/**

*当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用

*/

@Override

public Object invoke(Object obj, Method method, Object[] objs)

throws Throwable {

Object result = null;

System.out.println("可以在调用实际方法前做一些事情");

System.out.println("当前调用的方法是" + method.getName());

result = method.invoke(subject, objs);// 需要指定被代理对象和传入参数

System.out.println(method.getName() + "方法的返回值是" + result);

System.out.println("可以在调用实际方法后做一些事情");

System.out.println("------------------------");

return result;// 返回method方法执行后的返回值

}

}

4、测试

public class Mytest {

public static void main(String[] args) {

//第一步:创建被代理对象

HelloImpl hello = new HelloImpl();

//第二步:创建handler,传入真实对象

ProxyHandler handler = new ProxyHandler(hello);

//第三步:创建代理对象,传入类加载器、接口、handler

HelloInterface helloProxy = (HelloInterface) Proxy.newProxyInstance(

HelloInterface.class.getClassLoader(),

new Class[]{HelloInterface.class}, handler);

//第四步:调用方法

helloProxy.sayHello();

}

}

5、结果

可以在调用实际方法前做一些事情

当前调用的方法是sayHello

hello

sayHello方法的返回值是null

可以在调用实际方法后做一些事情

------------------------

CGLib代理原理是什么?

CGLib采用了非常底层的字节码技术,其原理是通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。(利用ASM开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理)

CGLib核心类:

1、net.sf.cglib.proxy.Enhancer:主要增强类,通过字节码技术动态创建委托类的子类实例;

Enhancer可能是CGLIB中最常用的一个类,和Java1.3动态代理中引入的Proxy类差不多。和Proxy不同的是,Enhancer既能够代理普通的class,也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用(包括从Object中继承的toString和hashCode方法)。Enhancer不能够拦截final方法,例如Object.getClass()方法,这是由于Java final方法语义决定的。基于同样的道理,Enhancer也不能对fianl类进行代理操作。这也是Hibernate为什么不能持久化final class的原因。

2、net.sf.cglib.proxy.MethodInterceptor:常用的方法拦截器接口,需要实现intercept方法,实现具体拦截处理;

public java.lang.Object intercept(java.lang.Object obj,

java.lang.reflect.Method method,

java.lang.Object[] args,

MethodProxy proxy)

throws java.lang.Throwable{}

obj:动态生成的代理对象

method : 实际调用的方法

args:调用方法入参

proxy:

net.sf.cglib.proxy.MethodProxy:java Method类的代理类,可以实现委托类对象的方法的调用;常用方法:methodProxy.invokeSuper(proxy, args);在拦截方法内可以调用多次

CGLib代理实例

1、创建被代理类

public class SayHello {

public void say(){

System.out.println("hello");

}

}

2、创建代理类

/**

*代理类

*/

public class ProxyCglib implements MethodInterceptor{

private Enhancer enhancer = new Enhancer();

public Object getProxy(Class clazz){

//设置需要创建子类的类

enhancer.setSuperclass(clazz);

enhancer.setCallback(this);

//通过字节码技术动态创建子类实例

return enhancer.create();

}

//实现MethodInterceptor接口方法

public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {

System.out.println("可以在调用实际方法前做一些事情");

//通过代理类调用父类中的方法

Object result = proxy.invokeSuper(obj, args);

System.out.println("可以在调用实际方法后做一些事情");

return result;

}

}

3、测试

public class Mytest {

public static void main(String[] args) {

ProxyCglib proxy = new ProxyCglib();

//通过生成子类的方式创建代理类

SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class);

proxyImp.say();

}

}

4、结果

可以在调用实际方法前做一些事情

hello

可以在调用实际方法后做一些事情

JDK动态代理与CGLib代理的区别是什么?

原理区别:

java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。核心是实现InvocationHandler接口,使用invoke()方法进行面向切面的处理,调用相应的通知。

而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。核心是实现MethodInterceptor接口,使用intercept()方法进行面向切面的处理,调用相应的通知。

1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口,可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换

性能区别:

1、CGLib底层采用ASM字节码生成框架,使用字节码技术生成代理类,在jdk6之前比使用Java反射效率要高。唯一需要注意的是,CGLib不能对声明为final的方法进行代理,因为CGLib原理是动态生成被代理类的子类。

2、在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后,在调用次数较少的情况下,JDK代理效率高于CGLIB代理效率,只有当进行大量调用的时候,jdk6和jdk7比CGLIB代理效率低一点,但是到jdk8的时候,jdk代理效率高于CGLIB代理。

各自局限:

1、JDK的动态代理机制只能代理实现了接口的类,而不能实现接口的类就不能实现JDK的动态代理。

2、cglib是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类进行代理。

总结

发布于 2018-11-06

文章被以下专栏收录