《深入浅出Spring》JDK动态代理和CGLIB
静态代理
有一个接口IService，如下：
package com.yuan11.proxy;
/**
* @title: IService
* @Author yuan11
* @Date: 2022/6/13 22:58
* @Version 1.0
*/
public interface IService {
void m1();
void m2();
void m3();
}
以及实现类：
package com.yuan11.proxy;
/**
* @title: ServiceA
* @Author yuan11
* @Date: 2022/6/13 22:58
* @Version 1.0
*/
public class ServiceA implements IService {
@Override
public void m1() {
System.out.println("我是ServiceA中的m1方法!");
}
@Override
public void m2() {
System.out.println("我是ServiceA中的m2方法!");
}
@Override
public void m3() {
System.out.println("我是ServiceA中的m3方法!");
}
}
package com.yuan11.proxy;
/**
* @title: ServiceB
* @Author yuan11
* @Date: 2022/6/13 22:58
* @Version 1.0
*/
public class ServiceB implements IService {
@Override
public void m1() {
System.out.println("我是ServiceB中的m1方法!");
}
@Override
public void m2() {
System.out.println("我是ServiceB中的m2方法!");
}
@Override
public void m3() {
System.out.println("我是ServiceB中的m3方法!");
}
}
调用测试：
package com.yuan11.proxy;
/**
* @title: ProxyTest
* @Author yuan11
* @Date: 2022/6/13 22:59
* @Version 1.0
*/
public class ProxyTest {
public static void main(String[] args) {
m1();
}
public static void m1() {
IService serviceA = new ServiceA();
IService serviceB = new ServiceB();
serviceA.m1();
serviceA.m2();
serviceA.m3();
serviceB.m1();
serviceB.m2();
serviceB.m3();
}
}
上面是我们原本的程序，突然领导有个需求：调用IService接口中的任何方法的时候，需要记录方法的耗时。
此时你会怎么做呢？
IService接口有2个实现类ServiceA和ServiceB，我们可以在这两个类的所有方法中加上统计耗时的代码，如果IService接口有几十个实现，是不是要修改很多代码，所有被修改的方法需重新测试？是不是非常痛苦，不过上面这种修改代码的方式倒是可以解决问题，只是增加了很多工作量（编码 & 测试）。
突然有一天，领导又说，要将这些耗时统计发送到监控系统用来做监控报警使用。
此时是不是又要去一个修改上面的代码？又要去测试？此时的系统是难以维护。
还有假如上面这些类都是第三方以jar包的方式提供给我们的，此时这些类都是class文件，此时我们无法去修改源码。
比较好的方式：可以为IService接口创建一个代理类，通过这个代理类来间接访问IService接口的实现类，在这个代理类中去做耗时及发送至监控的代码，代码如下：
package com.yuan11.proxy;
/**
* @title: ServiceProxy
* @Author yuan11
* @Date: 2022/6/13 23:03
* @Version 1.0
*/
// IService的代理类
public class ServiceProxy implements IService {
//目标对象，被代理的对象
private IService target;
public ServiceProxy(IService target) {
this.target = target;
}
@Override
public void m1() {
long starTime = System.nanoTime();
this.target.m1();
long endTime = System.nanoTime();
System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
}
@Override
public void m2() {
long starTime = System.nanoTime();
this.target.m1();
long endTime = System.nanoTime();
System.out.println(this.target.getClass() + ".m2()方法耗时(纳秒):" + (endTime - starTime));
}
@Override
public void m3() {
long starTime = System.nanoTime();
this.target.m1();
long endTime = System.nanoTime();
System.out.println(this.target.getClass() + ".m3()方法耗时(纳秒):" + (endTime - starTime));
}
}
erviceProxy是IService接口的代理类，target为被代理的对象，即实际需要访问的对象，也实现了IService接口，上面的3个方法中加了统计耗时的代码，当我们需要访问IService的其他实现类的时候，可以通过ServiceProxy来间接的进行访问，用法如下：
public static void serviceProxy() {
IService serviceA = new ServiceProxy(new ServiceA());//@1
IService serviceB = new ServiceProxy(new ServiceB()); //@2
serviceA.m1();
serviceA.m2();
serviceA.m3();
serviceB.m1();
serviceB.m2();
serviceB.m3();
}
上面实现中我们没有去修改ServiceA和ServiceB中的方法，只是给IService接口创建了一个代理类，通过代理类去访问目标对象，需要添加的一些共有的功能都放在代理中，当领导有其他需求的时候，我们只需修改ServiceProxy的代码，方便系统的扩展和测试。
假如现在我们需要给系统中所有接口都加上统计耗时的功能，若按照上面的方式，我们需要给每个接口创建一个代理类，此时代码量和测试的工作量也是巨大的，那么我们能不能写一个通用的代理类，来满足上面的功能呢？
`
通用代理的2种实现：
- jdk动态代理
- cglib代理``
JDK 动态代理
jdk中为实现代理提供了支持，主要用到2个类：
java.lang.reflect.Proxy
java.lang.reflect.InvocationHandler
jdk自带的代理使用上面有个限制，只能为接口创建代理类，如果需要给具体的类创建代理类，需要用后面要说的cglib
java.lang.reflect.Proxy
这是jdk动态代理中主要的一个类，里面有一些静态方法会经常用到，我们来熟悉一下：
- getProxyClass方法
为指定的接口创建代理类，返回代理类的Class对象
public static Class<?> getProxyClass(ClassLoader loader,
Class<?>... interfaces)
参数说明：
loader：定义代理类的类加载器
interfaces：指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口
- newProxyInstance方法
创建代理类的实例对象
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
这个方法先为指定的接口创建代理类，然后会生成代理类的一个实例，最后一个参数比较特殊，是InvocationHandler类型的，这个是个借口如下：
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
上面方法会返回一个代理对象，当调用代理对象的任何方法的时候，会就被InvocationHandler接口的invoke方法处理，所以主要代码需要写在invoke方法中，稍后会有案例细说。
- isProxy方法
判断指定的类是否是一个代理类
public static boolean isProxyClass(Class<?> cl)
- getInvocationHandler方法
获取代理对象的InvocationHandler对象
public static InvocationHandler getInvocationHandler(Object proxy)
throws IllegalArgumentException
上面几个方法大家熟悉一下，下面我们来看创建代理具体的2种方式。
创建代理：方式一
步骤
1.调用Proxy.getProxyClass方法获取代理类的Class对象
2.使用InvocationHandler接口创建代理类的处理器
3.通过代理类和InvocationHandler创建代理对象
4.上面已经创建好代理对象了，接着我们就可以使用代理对象了
JDK代理创建IService的代理对象
public void m1() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// 1. 获取接口对应的代理类
Class<IService> proxyClass = (Class<IService>) Proxy.getProxyClass(IService.class.getClassLoader(), IService.class);
// 2. 创建代理类的处理器
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
return null;
}
};
// 3. 创建代理实例
IService proxyService = proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);
// 4. 调用代理的方法
proxyService.m1();
proxyService.m2();
proxyService.m3();
}
运行结果如下：
创建代理：方式二
创建代理对象有更简单的方式。
步骤
1.使用InvocationHandler接口创建代理类的处理器
2.使用Proxy类的静态方法newProxyInstance直接创建代理对象
3.使用代理对象
public void m2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// 1. 创建代理类的处理器
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
return null;
}
};
// 2. 创建代理实例
IService proxyService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(), new Class[]{IService.class}, invocationHandler);
// 3. 调用代理的方法
proxyService.m1();
proxyService.m2();
proxyService.m3();
}
运行结果和上例子一样、
栗子：任意接口中的方法耗时统计
下面我们通过jdk动态代理实现一个通用的代理，解决统计所有接口方法耗时的问题。
主要的代码在代理处理器InvocationHandler实现上面，如下：
package com.yuan11.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class CostTimeInvocationHandler implements InvocationHandler {
private Object target;
public CostTimeInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long starTime = System.nanoTime();
Object result = method.invoke(this.target, args);//@1
long endTime = System.nanoTime();
System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
return result;
}
/**
* 用来创建targetInterface接口的代理对象
*
* @param target 需要被代理的对象
* @param targetInterface 被代理的接口
* @param
* @return
*/
public static <T> T createProxy(Object target, Class<T> targetInterface) {
if (!targetInterface.isInterface()) {
throw new IllegalStateException("targetInterface必须是接口类型!");
} else if (!targetInterface.isAssignableFrom(target.getClass())) {
throw new IllegalStateException("target必须是targetInterface接口的实现类!");
}
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));
}
}
上面主要是createProxy方法用来创建代理对象，2个参数：
target：目标对象，需要实现targetInterface接口
targetInterface：需要创建代理的接口
invoke方法中通过method.invoke(this.target, args)调用目标方法，然后统计方法的耗时。
**上面当我们创建一个新的接口的时候，不需要再去新建一个代理类了，只需要使用CostTimeInvocationHandler.createProxy创建一个新的代理对象就可以了，方便了很多。
Proxy使用注意：
jdk中的Proxy只能为接口生成代理类，如果你想给某个类创建代理类，那么Proxy是无能为力的，此时需要我们用到下面要说的cglib了。
Proxy类中提供的几个常用的静态方法大家需要掌握
通过Proxy创建代理对象，当调用代理对象任意方法时候，会被InvocationHandler接口中的invoke方法进行处理，这个接口内容是关键**
CGLIB代理
什么是cglib
jdk动态代理只能为接口创建代理，使用上有局限性。实际的场景中我们的类不一定有接口，此时如果我们想为普通的类也实现代理功能，我们就需要用到cglib来实现了。
cglib是一个强大、高性能的字节码生成库，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。基于同样的道理，Enhancer也不能对final类进行代理操作。
CGLIB作为一个开源项目，其代码托管在github，地址为：
https://github.com/cglib/cglib
cglib组成结构
CGLIB底层使用了ASM（一个短小精悍的字节码操作框架）来操作字节码生成新的类。除了CGLIB库外，脚本语言（如Groovy和BeanShell）也使用ASM生成字节码。ASM使用类似SAX的解析器来实现高性能。我们不鼓励直接使用ASM，因为它需要对Java字节码的格式足够的了解。
spring已将第三方cglib jar包中所有的类集成到spring自己的jar包中，本系列内容都是和spring相关的，为了方便，我们直接使用spring内部已集成的来讲解
举例说明cglib 的常用方法
- 案例1：拦截所有方法（MethodInterceptor）
创建一个具体的类，如下：
package com.yuan11.proxyCglib;
/**
* @title: Service1
* @Author yuan11
* @Date: 2022/6/13 23:29
* @Version 1.0
*/
public class Service1 {
public void m1() {
System.out.println("我是m1方法");
}
public void m2() {
System.out.println("我是m2方法");
}
}
下面我们为这个类创建一个代理，代理中实现打印每个方法的调用日志。
package com.yuan11.proxyCglib;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @title: ProxyTest
* @Author yuan11
* @Date: 2022/6/13 23:29
* @Version 1.0
*/
public class ProxyTest {
public static void main(String[] args) {
test1();
}
public static void test1() {
//使用Enhancer来给某个类创建代理类，步骤
//1.创建Enhancer对象
Enhancer enhancer = new Enhancer();
//2.通过setSuperclass来设置父类型，即需要给哪个类创建代理类
enhancer.setSuperclass(Service1.class);
/*3.设置回调，需实现org.springframework.cglib.proxy.Callback接口，
此处我们使用的是org.springframework.cglib.proxy.MethodInterceptor，也是一个接口，实现了Callback接口，
当调用代理对象的任何方法的时候，都会被MethodInterceptor接口的invoke方法处理*/
enhancer.setCallback(new MethodInterceptor() {
/**
* 代理对象方法拦截器
* @param o 代理对象
* @param method 被代理的类的方法，即Service1中的方法
* @param objects 调用方法传递的参数
* @param methodProxy 方法代理对象
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用方法:" + method);
//可以调用MethodProxy的invokeSuper调用被代理类的方法
Object result = methodProxy.invokeSuper(o, objects);
return result;
}
});
//4.获取代理对象,调用enhancer.create方法获取代理对象，这个方法返回的是Object类型的，所以需要强转一下
Service1 proxy = (Service1) enhancer.create();
//5.调用代理对象的方法
proxy.m1();
proxy.m2();
}
}
上面代码中的注释很详细，列出了给指定的类创建代理的具体步骤，整个过程中主要用到了Enhancer类和MethodInterceptor接口。
enhancer.setSuperclass用来设置代理类的父类，即需要给哪个类创建代理类，此处是Service1
enhancer.setCallback传递的是MethodInterceptor接口类型的参数，MethodInterceptor接口有个intercept方法，这个方法会拦截代理对象所有的方法调用。
还有一个重点是Object result = methodProxy.invokeSuper(o,
objects);可以调用被代理类，也就是Service1类中的具体的方法，从方法名称的意思可以看出是调用父类，实际对某个类创建代理，cglib底层通过修改字节码的方式为Service1类创建了一个子类。
运行结果如下：
- 案例2：拦截所有方法（MethodInterceptor）
创建一个类，如下：
package com.yuan11.proxyCglib;
/**
* @title: Service1
* @Author yuan11
* @Date: 2022/6/13 23:29
* @Version 1.0
*/
public class Service2 {
public void m1() {
System.out.println("我是m1方法");
this.m2(); //@1
}
public void m2() {
System.out.println("我是m2方法");
}
}
这个类和上面的Service1类似，有点不同是@1，在m1方法中调用了m2方法。
下面来采用案例1中同样的方式来给Service2创建代理，如下：
public void test2() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Service2.class);
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用方法:" + method);
Object result = methodProxy.invokeSuper(o, objects);
return result;
}
});
Service2 proxy = (Service2) enhancer.create();
proxy.m1(); //@1
}
运行结果如下
从输出中可以看出m1和m2方法都被拦截器处理了，而m2方法是在Service1的m1方法中调用的，也被拦截处理了。
spring中的@configuration注解就是采用这种方式实现的
- 案例3：拦截所有方法并返回固定值（FixedValue）
当调用某个类的任何方法的时候，都希望返回一个固定的值，此时可以使用FixedValue接口，如下：
enhancer.setCallback(new FixedValue() {
@Override
public Object loadObject() throws Exception {
return "猿一一";
}
});
上面创建的代理对象，调用其任意方法返回的都是”猿一一”。
创建一个类Service3，如下：
public void test3() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Service3.class);
enhancer.setCallback(new FixedValue() {
@Override
public Object loadObject() throws Exception {
return "猿一一";
}
});
Service3 proxy = (Service3) enhancer.create();
System.out.println(proxy.m1());//@1
System.out.println(proxy.m2()); //@2
System.out.println(proxy.toString());//@3
}
@1、@2、@3调用了代理对象的3个方法，运行输出：
可以看出输出的都是一个值。
- 案例4：直接放行，不做任何操作（NoOp.INSTANCE）
Callback接口下面有个子接口org.springframework.cglib.proxy.NoOp，将这个作为Callback的时候，被调用的方法会直接放行，像没有任何代理一样，感受一下效果：
public void test6() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Service3.class);
enhancer.setCallback(NoOp.INSTANCE);
Service3 proxy = (Service3) enhancer.create();
System.out.println(proxy.m1());
System.out.println(proxy.m2());
}
运行输出：
我是m1方法 hello:m1 我是m2方法 hello:m2
- 案例5：不同的方法使用不同的拦截器（CallbackFilter）
需求，给这个类创建一个代理需要实现下面的功能：
以insert开头的方法需要统计方法耗时
以get开头的的方法直接返回 猿一一
下来看代码：
public static void test4() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Service4.class);
//创建2个Callback
Callback[] callbacks = {
//这个用来拦截所有insert开头的方法
new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
long starTime = System.nanoTime();
Object result = methodProxy.invokeSuper(o, objects);
long endTime = System.nanoTime();
System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));
return result;
}
},
//下面这个用来拦截所有get开头的方法，返回固定值的
new FixedValue() {
@Override
public Object loadObject() throws Exception {
return "猿一一";
}
}
};
//调用enhancer的setCallbacks传递Callback数组
enhancer.setCallbacks(callbacks);
/**
* 设置过滤器CallbackFilter
* CallbackFilter用来判断调用方法的时候使用callbacks数组中的哪个Callback来处理当前方法
* 返回的是callbacks数组的下标
*/
enhancer.setCallbackFilter(new CallbackFilter() {
@Override
public int accept(Method method) {
//获取当前调用的方法的名称
String methodName = method.getName();
/**
* 方法名称以insert开头，
* 返回callbacks中的第1个Callback对象来处理当前方法，
* 否则使用第二个Callback处理被调用的方法
*/
return methodName.startsWith("insert") ? 0 : 1;
}
});
Service4 proxy = (Service4) enhancer.create();
System.out.println("---------------");
proxy.insert1();
System.out.println("---------------");
proxy.insert2();
System.out.println("---------------");
System.out.println(proxy.get1());
System.out.println("---------------");
System.out.println(proxy.get2());
}
运行结果
输出效果和案例4一模一样的，上面重点在于CallbackHelper，里面做了一些封装，有兴趣的可以去看一下源码，比较简单。
- 案例6：实现通用的统计任意类方法耗时代理类
public class CostTimeProxy implements MethodInterceptor {
//目标对象
private Object target;
public CostTimeProxy(Object target) {
this.target = target;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
long starTime = System.nanoTime();
//调用被代理对象（即target）的方法，获取结果
Object result = method.invoke(target, objects); //@1
long endTime = System.nanoTime();
System.out.println(method + "，耗时(纳秒)：" + (endTime - starTime));
return result;
}
/**
* 创建任意类的代理对象
*
* @param target
* @param
* @return
*/
public static <T> T createProxy(T target) {
CostTimeProxy costTimeProxy = new CostTimeProxy(target);
Enhancer enhancer = new Enhancer();
enhancer.setCallback(costTimeProxy);
enhancer.setSuperclass(target.getClass());
return (T) enhancer.create();
}
}
CGLIB和Java动态代理的区别
1、Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类的父类为java.lang.reflect.Proxy，Java类继承机制不允许多重继承）；
2、CGLIB能够代理普通类；
3、Java动态代理使用Java原生的反射API进行操作，在生成类上比较高效；CGLIB使用ASM框架直接对字节码进行操作，在类的执行过程中比较高效
cglib的特点
1、cglib弥补了jdk动态代理的不足，jdk动态代理只能为接口创建代理，而cglib非常强大，不管是接口还是类，都可以使用cglib来创建代理
2、cglib创建代理的过程，相当于创建了一个新的类，可以通过cglib来配置这个新的类需要实现的接口，以及需要继承的父类
3、cglib可以为类创建代理，但是这个类不能是final类型的，cglib为类创建代理的过程，实际上为通过继承来实现的，相当于给需要被代理的类创建了一个子类，然后会重写父类中的方法，来进行增强，继承的特性大家应该都知道，final修饰的类是不能被继承的，final修饰的方法不能被重写，static修饰的方法也不能被重写，private修饰的方法也不能被子类重写，而其他类型的方法都可以被子类重写，被重写的这些方法可以通过cglib进行拦截增强
cglib整个过程
1、Cglib根据父类,Callback, Filter 及一些相关信息生成key
2、然后根据key 生成对应的子类的二进制表现形式
3、使用ClassLoader装载对应的二进制,生成Class对象,并缓存
4、最后实例化Class对象,并缓存
LazyLoader的使用
LazyLoader是cglib用于实现懒加载的callback。当被增强bean的方法初次被调用时，会触发回调，之后每次再进行方法调用都是对LazyLoader第一次返回的bean调用，hibernate延迟加载有用到过这个。
public class LazyLoaderTest1 {
public static class UserModel {
private String name;
public UserModel() {
}
public UserModel(String name) {
this.name = name;
}
public void say() {
System.out.println("你好：" + name);
}
}
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserModel.class);
//创建一个LazyLoader对象
LazyLoader lazyLoader = new LazyLoader() {
@Override
public Object loadObject() throws Exception {
System.out.println("调用LazyLoader.loadObject()方法");
return new UserModel("java");
}
};
enhancer.setCallback(lazyLoader);
Object proxy = enhancer.create();
UserModel userModel = (UserModel) proxy;
System.out.println("第1次调用say方法");
userModel.say();
System.out.println("第2次调用say方法");
userModel.say();
}
}
第1次调用say方法
调用LazyLoader.loadObject()方法
你好：java
第2次调用say方法
你好：java
当第1次调用say方法的时候，会被cglib拦截，进入lazyLoader的loadObject内部，将这个方法的返回值作为say方法的调用者，loadObject中返回了一个Java的UserModel，cglib内部会将loadObject方法的返回值和say方法关联起来，然后缓存起来，而第2次调用say方法的时候，通过方法名去缓存中找，会直接拿到第1次返回的UserModel，所以第2次不会进入到loadObject方法中了。
Dispatcher
Dispatcher和LazyLoader作用很相似，区别是用Dispatcher的话每次对增强bean进行方法调用都会触发回调。
public class DispatcherTest1 {
public static class UserModel {
private String name;
public UserModel() {
}
public UserModel(String name) {
this.name = name;
}
public void say() {
System.out.println("你好：" + name);
}
}
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(LazyLoaderTest1.UserModel.class);
//创建一个Dispatcher对象
Dispatcher dispatcher = new Dispatcher() {
@Override
public Object loadObject() throws Exception {
System.out.println("调用Dispatcher.loadObject()方法");
return new DispatcherTest1.UserModel("java," + UUID.randomUUID().toString());
}
};
enhancer.setCallback(dispatcher);
Object proxy = enhancer.create();
DispatcherTest1.UserModel userModel = (DispatcherTest1.UserModel) proxy;
System.out.println("第1次调用say方法");
userModel.say();
System.out.println("第2次调用say方法");
userModel.say();
}
}
第1次调用say方法
调用Dispatcher.loadObject()方法
你好：java,514f911e-06ac-4e3b-aee4-595f82c16a5f
第2次调用say方法
调用Dispatcher.loadObject()方法
你好：java,bc062990-bc16-4226-97e3-b1b321a03468
通过Dispathcer对类扩展一些接口
下面有个UserService类，我们需要对这个类创建一个代理。
代码中还定义了一个接口：IMethodInfo，用来统计被代理类的一些方法信息，有个实现类：DefaultMethodInfo。
通过cglib创建一个代理类，父类为UserService，并且实现IMethodInfo接口，将接口IMethodInfo所有方法的转发给DefaultMethodInfo处理，代理类中的其他方法，转发给其父类UserService处理。
这个代码相当于对UserService这个类进行了增强，使其具有了IMethodInfo接口中的功能。
public class DispatcherTest2 {
public static class UserService {
public void add() {
System.out.println("新增用户");
}
public void update() {
System.out.println("更新用户信息");
}
}
//用来获取方法信息的接口
public interface IMethodInfo {
//获取方法数量
int methodCount();
//获取被代理的对象中方法名称列表
List<String> methodNames();
}
//IMethodInfo的默认实现
public static class DefaultMethodInfo implements IMethodInfo {
private Class<?> targetClass;
public DefaultMethodInfo(Class<?> targetClass) {
this.targetClass = targetClass;
}
@Override
public int methodCount() {
return targetClass.getDeclaredMethods().length;
}
@Override
public List<String> methodNames() {
return Arrays.stream(targetClass.getDeclaredMethods()).
map(Method::getName).
collect(Collectors.toList());
}
}
public static void main(String[] args) {
Class<?> targetClass = UserService.class;
Enhancer enhancer = new Enhancer();
//设置代理的父类
enhancer.setSuperclass(targetClass);
//设置代理需要实现的接口列表
enhancer.setInterfaces(new Class[]{IMethodInfo.class});
//创建一个方法统计器
IMethodInfo methodInfo = new DefaultMethodInfo(targetClass);
//创建会调用器列表，此处定义了2个，第1个用于处理UserService中所有的方法，第2个用来处理IMethodInfo接口中的方法
Callback[] callbacks = {
new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
return methodProxy.invokeSuper(o, objects);
}
},
new Dispatcher() {
@Override
public Object loadObject() throws Exception {
/**
* 用来处理代理对象中IMethodInfo接口中的所有方法
* 所以此处返回的为IMethodInfo类型的对象，
* 将由这个对象来处理代理对象中IMethodInfo接口中的所有方法
*/
return methodInfo;
}
}
};
enhancer.setCallbacks(callbacks);
enhancer.setCallbackFilter(new CallbackFilter() {
@Override
public int accept(Method method) {
//当方法在IMethodInfo中定义的时候，返回callbacks中的第二个元素
return method.getDeclaringClass() == IMethodInfo.class ? 1 : 0;
}
});
Object proxy = enhancer.create();
//代理的父类是UserService
UserService userService = (UserService) proxy;
userService.add();
//代理实现了IMethodInfo接口
IMethodInfo mf = (IMethodInfo) proxy;
System.out.println(mf.methodCount());
System.out.println(mf.methodNames());
}
}
新增用户
2
[add, update]
cglib中的NamingPolicy接口
接口NamingPolicy表示生成代理类的名字的策略，通过Enhancer.setNamingPolicy方法设置命名策略。
默认的实现类：DefaultNamingPolicy， 具体cglib动态生成类的命名控制。
DefaultNamingPolicy中有个getTag方法。
DefaultNamingPolicy生成的代理类的类名命名规则：
被代理class name + “ " + 使 用 c g l i b 处 理 的 c l a s s n a m e + " B y C G L I B " + " " + 使用cglib处理的class name + "ByCGLIB" + " "+使用cglib处理的classname+"ByCGLIB"+"” + key的hashcode
自定义NamingPolicy，通常会继承DefaultNamingPolicy来实现，spring中默认就提供了一个，如下
public class SpringNamingPolicy extends DefaultNamingPolicy {
public static final SpringNamingPolicy INSTANCE = new SpringNamingPolicy();
@Override
protected String getTag() {
return “BySpringCGLIB”;
}
}
public class NamingPolicyTest {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(NamingPolicyTest.class);
enhancer.setCallback(NoOp.INSTANCE);
//通过Enhancer.setNamingPolicy来设置代理类的命名策略
enhancer.setNamingPolicy(new DefaultNamingPolicy() {
@Override
protected String getTag() {
return "-test-";
}
});
Object proxy = enhancer.create();
System.out.println(proxy.getClass());
}
}
输出
class.NamingPolicyTest$$Enhancer-test-$$5946713
Objenesis：实例化对象的一种方式
先来看一段代码，有一个有参构造函数：
public static class User {
private String name;
public User(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
大家来思考一个问题：如果不使用这个有参构造函数的情况下，如何创建这个对象？
通过反射？大家可以试试，如果不使用有参构造函数，是无法创建对象的。
cglib中提供了一个接口：Objenesis，通过这个接口可以解决上面这种问题，它专门用来创建对象，即使你没有空的构造函数，都木有问题，它不使用构造方法创建Java对象，所以即使你有空的构造方法，也是不会执行的。
用法比较简单：
@Test
public void test1() {
Objenesis objenesis = new ObjenesisStd();
User user = objenesis.newInstance(User.class);
System.out.println(user);
}
输出
User{name='null'}
大家可以在User类中加一个默认构造函数，来验证一下上面的代码会不会调用默认构造函数？
public User() {
System.out.println("默认构造函数");
}
再次运行会发现，并不会调用默认构造函数。
如果需要多次创建User对象，可以写成下面方式重复利用
@Test
public void test2() {
Objenesis objenesis = new ObjenesisStd();
ObjectInstantiator<User> userObjectInstantiator = objenesis.getInstantiatorOf(User.class);
User user1 = userObjectInstantiator.newInstance();
System.out.println(user1);
User user2 = userObjectInstantiator.newInstance();
System.out.println(user2);
System.out.println(user1 == user2);
}
运行输出
User{name='null'}
User{name='null'}
false
动态代理在Spring中的应用
Spring AOP 应用
以下是Spring AOP创建代理的方法
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
//如果
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理
2、如果目标对象实现了接口，也可以强制使用CGLIB
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
如果需要强制使用CGLIB来实现AOP，需要配置spring.aop.proxy-target-class=true或@EnableAspectJAutoProxy(proxyTargetClass = true