Spring系列第30篇：jdk动态代理和cglib代理

2401_84010326

于 2024-04-03 11:14:41 发布

阅读量981

点赞数 27

分类专栏：程序员文章标签： java spring 开发语言

本文链接：https://blog.csdn.net/2401_84010326/article/details/137337250

版权

程序员专栏收录该内容

237 篇文章 0 订阅

订阅专栏

方法：m2

class com.javacode2018.aop.demo2.CglibTest1 $I S er v i ce 1$ $E nhan cer B y CG L I B$ $1d32a82

创建代理类实现的接口如下：

interface com.javacode2018.aop.demo2.CglibTest1$IService1

interface com.javacode2018.aop.demo2.CglibTest1$IService2

interface org.springframework.cglib.proxy.Factory

上面创建的代理类相当于下面代码

public class CglibTest1 $I S er v i ce 1$ $E nhan cer B y CG L I B$ $1d32a82 implements IService1, IService2 {

@Override

public void m1() {

System.out.println(“方法：m1”);

}

@Override

public void m2() {

System.out.println(“方法：m2”);

}

案例2：为类和接口同时创建代理

下面定义了2个接口：IService1和IService2，2个接口有个实现类：Service，然后通过cglib创建了个代理类，实现了这2个接口，并且将Service类作为代理类的父类。

public class CglibTest2 {

interface IService1 {

void m1();

}

interface IService2 {

void m2();

}

public static class Service implements IService1, IService2 {

@Override

public void m1() {

System.out.println(“m1”);

}

@Override

public void m2() {

System.out.println(“m2”);

}

public static void main(String[] args) {

Enhancer enhancer = new Enhancer();

//设置代理类的父类

enhancer.setSuperclass(Service.class);

//设置代理对象需要实现的接口

enhancer.setInterfaces(new Class[]{IService1.class, IService2.class});

//通过Callback来对被代理方法进行增强

enhancer.setCallback(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); //调用父类中的方法

System.out.println(method + “，耗时(纳秒):” + (System.nanoTime() - startime));

return result;

}

});

//创建代理对象

Object proxy = enhancer.create();

//判断代理对象是否是Service类型的

System.out.println(“proxy instanceof Service” + (proxy instanceof Service));

if (proxy instanceof Service) {

Service service = (Service) proxy;

service.m1();

service.m2();

}

//看一下代理对象的类型

System.out.println(proxy.getClass());

//输出代理对象的父类

System.out.println(“代理类的父类：” + proxy.getClass().getSuperclass());

//看一下代理类实现的接口

System.out.println(“创建代理类实现的接口如下：”);

for (Class<?> cs : proxy.getClass().getInterfaces()) {

System.out.println(cs);

}

运行输出

proxy instanceof Servicetrue

public void com.javacode2018.aop.demo2.CglibTest2$Service.m1()，耗时(纳秒):14219700

public void com.javacode2018.aop.demo2.CglibTest2$Service.m2()，耗时(纳秒):62800

class com.javacode2018.aop.demo2.CglibTest2 $S er v i ce$ $E nhan cer B y CG L I B$ $80494536

代理类的父类：class com.javacode2018.aop.demo2.CglibTest2$Service

创建代理类实现的接口如下：

interface com.javacode2018.aop.demo2.CglibTest2$IService1

interface com.javacode2018.aop.demo2.CglibTest2$IService2

interface org.springframework.cglib.proxy.Factory

输出中可以代理对象的类型是：

class com.javacode2018.aop.demo2.CglibTest2 $S er v i ce$ $E nhan cer B y CG L I B$ $80494536

带有$$EnhancerByCGLIB$$字样的，在调试spring的过程中，发现有这样字样的，基本上都是cglib创建的代理对象。

上面创建的代理类相当于下面代码

public class CglibTest2 $S er v i ce$ $E nhan cer B y CG L I B$ $80494536 extends Service implements IService1, IService2 {

@Override

public void m1() {

long starttime = System.nanoTime();

super.m1();

System.out.println(“方法m1，耗时(纳秒):” + (System.nanoTime() - starttime));

}

@Override

public void m2() {

long starttime = System.nanoTime();

super.m1();

System.out.println(“方法m1，耗时(纳秒):” + (System.nanoTime() - starttime));

}

案例3：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(“第1次调用say方法”);

userModel.say();

}

运行输出

第1次调用say方法

调用LazyLoader.loadObject()方法

你好：路人甲java

第1次调用say方法

你好：路人甲java

当第1次调用say方法的时候，会被cglib拦截，进入lazyLoader的loadObject内部，将这个方法的返回值作为say方法的调用者，loadObject中返回了一个路人甲Java的UserModel，cglib内部会将loadObject方法的返回值和say方法关联起来，然后缓存起来，而第2次调用say方法的时候，通过方法名去缓存中找，会直接拿到第1次返回的UserModel，所以第2次不会进入到loadObject方法中了。

将下代码拆分开来

System.out.println(“第1次调用say方法”);

userModel.say();

System.out.println(“第1次调用say方法”);

userModel.say();

相当于下面的代码

System.out.println(“第1次调用say方法”);

System.out.println(“调用LazyLoader.loadObject()方法”);

userModel = new UserModel(“路人甲java”);

userModel.say();

System.out.println(“第1次调用say方法”);

userModel.say();

下面通过LazyLoader实现延迟加载的效果。

案例4：LazyLoader实现延迟加载

博客的内容一般比较多，需要用到内容的时候，我们再去加载，下面来模拟博客内容延迟加载的效果。

public class LazyLoaderTest2 {

//博客信息

public static class BlogModel {

private String title;

//博客内容信息比较多，需要的时候再去获取

private BlogContentModel blogContentModel;

public BlogModel() {

this.title = “spring aop详解!”;

this.blogContentModel = this.getBlogContentModel();

}

private BlogContentModel getBlogContentModel() {

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(BlogContentModel.class);

enhancer.setCallback(new LazyLoader() {

@Override

public Object loadObject() throws Exception {

//此处模拟从数据库中获取博客内容

System.out.println(“开始从数据库中获取博客内容…”);

BlogContentModel result = new BlogContentModel();

result.setContent(“欢迎大家和我一起学些spring，我们一起成为spring高手！”);

return result;

}

});

return (BlogContentModel) enhancer.create();

}

//表示博客内容信息

public static class BlogContentModel {

//博客内容

private String content;

public String getContent() {

return content;

}

public void setContent(String content) {

this.content = content;

}

public static void main(String[] args) {

//创建博客对象

BlogModel blogModel = new BlogModel();

System.out.println(blogModel.title);

System.out.println(“博客内容”);

System.out.println(blogModel.blogContentModel.getContent()); //@1

}

@1：调用blogContentModel.getContent()方法的时候，才会通过LazyLoader#loadObject方法从db中获取到博客内容信息

运行输出

spring aop详解!

博客内容

开始从数据库中获取博客内容…

欢迎大家和我一起学些spring，我们一起成为spring高手！

案例5：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 LazyLoaderTest1.UserModel(“路人甲java,” + UUID.randomUUID().toString());

}

};

enhancer.setCallback(dispatcher);

Object proxy = enhancer.create();

LazyLoaderTest1.UserModel userModel = (LazyLoaderTest1.UserModel) proxy;

System.out.println(“第1次调用say方法”);

userModel.say();

System.out.println(“第1次调用say方法”);

userModel.say();

}

运行输出

第1次调用say方法

调用Dispatcher.loadObject()方法

你好：路人甲java,514f911e-06ac-4e3b-aee4-595f82c16a5f

第1次调用say方法

调用Dispatcher.loadObject()方法

你好：路人甲java,bc062990-bc16-4226-97e3-b1b321a03468

案例6：通过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 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 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());

}

运行输出

新增用户

[add, update]

案例7：cglib中的NamingPolicy接口

接口NamingPolicy表示生成代理类的名字的策略，通过Enhancer.setNamingPolicy方法设置命名策略。

默认的实现类：DefaultNamingPolicy，具体cglib动态生成类的命名控制。

DefaultNamingPolicy中有个getTag方法。

DefaultNamingPolicy生成的代理类的类名命名规则：

被代理class name + “ $" + 使用 c g l ib 处理的 c l a ss nam e + " B y CG L I B " + "$ ” + key的hashcode

如：

com.javacode2018.aop.demo2.DispatcherTest2 $U ser S er v i ce$ $E nhan cer B y CG L I B$ $e7ec0be5@17d10166

自定义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 com.javacode2018.aop.demo2.NamingPolicyTest $E nhan cer - t es t -$ 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);

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

结语

小编也是很有感触，如果一直都是在中小公司，没有接触过大型的互联网架构设计的话，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。

我们选择的这个行业就一直要持续的学习，又很吃青春饭。

虽然大家可能经常见到说程序员年薪几十万，但这样的人毕竟不是大部份，要么是有名校光环，要么是在阿里华为这样的大企业。年龄一大，更有可能被裁。

送给每一位想学习Java小伙伴，用来提升自己。

在这里插入图片描述

本文到这里就结束了，喜欢的朋友可以帮忙点赞和评论一下，感谢支持！
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
objenesis.newInstance(User.class);

System.out.println(user);

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-4IxPO1IV-1712114041247)]

[外链图片转存中…(img-vh8luVmX-1712114041248)]

[外链图片转存中…(img-PpBC4FXf-1712114041248)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

结语

我们选择的这个行业就一直要持续的学习，又很吃青春饭。

送给每一位想学习Java小伙伴，用来提升自己。

[外链图片转存中…(img-VYtc26wi-1712114041248)]

本文到这里就结束了，喜欢的朋友可以帮忙点赞和评论一下，感谢支持！
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

2401_84010326

关注

27
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
Spring系列第30篇：jdk动态代理和cglib代理

小编也是很有感触，如果一直都是在中小公司，没有接触过大型的互联网架构设计的话，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。我们选择的这个行业就一直要持续的学习，又很吃青春饭。虽然大家可能经常见到说程序员年薪几十万，但这样的人毕竟不是大部份，要么是有名校光环，要么是在阿里华为这样的大企业。年龄一大，更有可能被裁。送给每一位想学习Java小伙伴，用来提升自己。
复制链接

扫一扫