Java 结合实例学会使用 静态代理、JDK动态代理、CGLIB动态代理

• @CreateTime : 2020/4/21

• @Description :

**/

public class OrderServiceLogProxy implements OrderService {

private OrderServiceImpl orderService;

public OrderServiceLogProxy(OrderServiceImpl orderService) {

this.orderService = orderService;

}

@Override

public Map executeFoodOrder(String userName, Map<String, Integer> foodMap) {

System.out.println(“+静态代理LogProxy”);

System.out.println(“+下单前我们做点什么.”);

System.out.println(“+正在获取用户：”+userName+“用户信息…”);

System.out.println(“+正在记录用户：”+userName+“选择的菜品：”+foodMap.toString());

System.out.println(“+准备执行主业务”);

Map map = orderService.executeFoodOrder(userName, foodMap);

System.out.println(“+下单后我们做点什么.”);

System.out.println(“+记录用户”+userName+“下单后的详情信息:”+map.toString());

return map;

}

}

简单分析下，我们新创建了一个实现下单点餐接口的类，在这类里面，重写下单方法executeFoodOrder，在调用下单方法时加上一些日志记录等等的代码：

OK，有可能这样写，你还是不能看出所为的代理结构，那么如果说我 写成这样呢？

是不是这样看起来就有感觉了。（该篇文章后面的JDK动态代理、CGLIB动态代理，我就不一一抽出来写成 before和 after了）

调用方式：

public static void main(String[] args) {

//静态代理调用方式

OrderServiceImpl orderService=new OrderServiceImpl();

OrderServiceLogProxy orderServiceLogProxy=new OrderServiceLogProxy(orderService);

String userName=“JCccc”;

Map<String,Integer> orderMap=new HashMap<>();

orderMap.put(“白米饭”,2);

orderMap.put(“红烧肉”,1);

orderMap.put(“水煮鱼”,1);

orderMap.put(“番茄炒蛋”,1);

Map resultMap = orderServiceLogProxy.executeFoodOrder(userName, orderMap);

System.out.println(“静态代理方法执行完毕,结果：”+resultMap);

}

可以看下控制台的输出情况：

蓝色：静态代理类做的事情 （可以看到在主业务执行的前后）

红色：原本主业务做的事情

静态代理使用感觉：

实现代理的代码都是提前设计好，而且还是一一对应起来，OrderService 的代理是 OrderServiceLogProxy；

而且实现代理的方法也是一一对应。

那么如果 需要记录日志 的不止是OrderService ，再来一个 UserService呢？ 再来一个 GameService呢？

这样一来，需要我们写死的代码就非常非常多。

这就是所谓的 静态 的不好之处，于是乎有了 动态代理（能够根据我们传入的 需要被代理类，实现代理）。

2.动态代理

---

动态代理有两种：

JDK动态代理

CGLIB动态代理

2.1 JDK动态代理

基于前面创建好的 OrderService 和 OrderServiceImpl ，我们接下来采取 JDK动态代理的方式去实现我们的日志添加。

（已经有种解耦的意味了吧，我们根本不需要动原本的业务接口和业务实现类，代理模式的作用无形中已经慢慢崭露出来了）

创建咱们的日志动态代理类，DynamicsLogProxy.java ：

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Arrays;

/**

• @Author : JCccc

• @CreateTime : 2020/4/21

• @Description :

**/

public class DynamicsLogProxy implements InvocationHandler {

Object obj;

//绑定委托对象，并返回代理类

public Object bind(Object obj)

{

this.obj = obj;

//绑定该类实现的所有接口，取得代理类

return Proxy.newProxyInstance(obj.getClass().getClassLoader(),

obj.getClass().getInterfaces(),

this);

}

@Override

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

System.out.println(“+静态代理LogProxy”);

System.out.println(“+下单前我们做点什么.”);

System.out.println(“+正在获取目前传入的参数：”+Arrays.toString(args));

System.out.println(“+正在记录…”);

System.out.println(“+准备执行主业务”);

Object res = method.invoke(obj, args);

System.out.println(“+下单后我们做点什么.”);

System.out.println(“+可得到业务方法执行后结果”+res.toString());

System.out.println(“+记录…”);

return res;

}

}

JDK动态代理的一些代码剖析：

1. JDK动态代理类 必须 实现 InvocationHandler 接口：

2.被代理的类 必须 存在 类 和实现的接口 （OrderService  和  OrderServiceImpl）

3.需要把 被代理对象传过去，因为动态生成代理类时要使用到：

3.使用jdk的api 中的 java.lang.reflect.Proxy 帮我们即时创建 代理实例对象：

前面两个参数，可以理解为把需要被代理的类相关信息传过去，最后一个参数  InvocationHandler h，

这玩意讲究。

咱们的DynamicsLogProxy 实现了这玩意，那么Proxy帮我们创建出来的一个代理实例对象，自然是不清楚咱们要代理的具体方法。

而invoke就是帮我们根据传入的参数：

proxy表示动态代理类实例，method表示调用的方法，args表示调用方法的参数

实现 调用 目标对象（被代理的类）的 目标方法。

简单点理解：

Proxy会帮我们 动态创建一个代理类，  这个代理类 代理的谁， 是我们传入的。

而InvocationHandler 的invoke方法，随时待命从代理类中去调用 被代理类的对应方法。

调用方式：

public static void main(String[] args) {

//动态代理调用方式

OrderService dynamicsOrderProxy = (OrderService)new DynamicsLogProxy().bind(new OrderServiceImpl());

String userName=“JCccc”;

Map<String,Integer> orderMap=new HashMap<>();

orderMap.put(“白米饭”,2);

orderMap.put(“红烧肉”,1);

orderMap.put(“水煮鱼”,1);

orderMap.put(“番茄炒蛋”,1);

//通过动态代理类去调用不同方法

Map resultMap = dynamicsOrderProxy.executeFoodOrder(userName, orderMap);

System.out.println(“动态代理方法执行完毕,结果：”+resultMap);

}

可以看下控制台的输出情况：

JDK的动态代理使用感觉：

挺好，我们只需要编写一个日志代理类之后；

想这个日志代理类与哪个 需要被代理的类绑定， 我们就动态传入；

想要在被代理的类哪个方法前后 去嵌入 一些东西， 我们就动态调用方法；

很灵活，不像静态代理那样死死的。

但是，显然我们在使用JDK动态代理的时候，我们发现了，Proxy在帮我们动态即时创建 代理类的时候，要求我们传入

Class<?>[] interfaces

那就是意味着，我们的需要被代理的类，必须实现接口：

因为JDK动态代理其实也是悄咪咪帮我们创建一份代理类代码，也帮我们实现同样的接口。

也就是说， 如果你的 被代理类， 没有实现接口，那么就没办法使用 JDK动态代理。

那怎么办？  CGLIB动态代理出来了，它说 我不关心你是否实现接口，只需要告诉我 哪个类需要被代理。

2.2 CGLIB动态代理

上面咱们已经说了，CGLIB动态代理只关心 哪个类需要被代理。

因为这个家伙其实是悄咪咪地帮我们 针对需要被代理的类 创建一个 代理子类。根据调用的方法，拦截调用到父类的方法。

看CGLIB动态代理实现，CglibLogProxy.java：

import org.springframework.cglib.proxy.Enhancer;

import org.springframework.cglib.proxy.MethodInterceptor;

import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**

• @Author : JCccc

• @CreateTime : 2020/4/21

• @Description :

**/

public class CglibLogProxy implements MethodInterceptor {

/**

• 自定义方法：利用Enhancer类生成代理类

• @param clazz

• @param

• @return

*/

public T getObjByEnhancer(Class clazz) {

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(clazz);

enhancer.setCallback(this);

T res = (T) enhancer.create();

return res;

}

@Override

public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

System.out.println(" +CGLIB日志代理CglibLogProxy");

System.out.println(“+CGLIB日志代理获取到执行的方法名” + method.getName());

System.out.println(“+做一些日志记录…”);

System.out.println(“+做一些日志记录…”);

Object res = methodProxy.invokeSuper(o, objects);

System.out.println(“+主业务方法执行后我们做点什么.”);

System.out.println(“+可得到业务方法执行后结果”+res.toString());

System.out.println(“+记录…”);

return res;

}

}

实现代码简单剖析：

1. implements MethodInterceptor    cglib动态代理类实现了这个方法拦截

2. intercept 方法，这个也就是 提供地方给咱们 添加 日志记录、权限判断等等的地方

3. Enhancer

Enhancer  这个玩意是CGLIB动态代理类的核心。

它的职责是，创建出一个子类（代理类）， 然后将我们传入的 被代理类  设置成 SuperClass 父类 。

这个子类（代理类） ’继承‘ 了父类（ 被代理类）的 所有 可以公开的方法 ，然后设置拦截回调的类（父类），子类中拦截父类方法并织入方法增强逻辑。

ps：cglib动态代理不能代理声明为final类型的类和方法

事不宜迟，我们贴出CGLIB动态代理调用方式：

public static void main(String[] args) {

CglibLogProxy cglibLogProxy=new CglibLogProxy();

OrderServiceImpl orderProxy= cglibLogProxy.getObjByEnhancer(OrderServiceImpl.class);

String userName=“JCccc”;

Map<String,Integer> orderMap=new HashMap();

orderMap.put(“白米饭”,2);

orderMap.put(“红烧肉”,1);

orderMap.put(“水煮鱼”,1);

orderMap.put(“番茄炒蛋”,1);

Map map = orderProxy.executeFoodOrder(userName, orderMap);

System.out.println(map.toString());

}

注意看， 调用方法的时候，用的是什么？

orderProxy.executeFoodOrder(userName, orderMap);

没错，跟JDK动态代理看似一样直接调用 我们执行的业务方法，

但是接下来就不一样了，再看看cglib动态代理类的实现代码：

没错，orderProxy是我们通过Enhancer去生成的，特意设置了回调拦截方法。从拦截的这个意思去看，就更有AOP的意味，更有代理的感觉了。

调用父类方法（被代理类）前，拦住， 先调用咱们自己写的 拦截方法， 啥时候完事了，再通过 methodProxy.invokeSuper 切回到主业务方法去。

可以看到控制台输出：

简单的介绍就到这里吧。

---

总结

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

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

最后

做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。
当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。

更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务

自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**
[外链图片转存中…(img-VMs9qEWe-1711136203354)]
[外链图片转存中…(img-wHmSd2kg-1711136203356)]
[外链图片转存中…(img-mv7JCnug-1711136203356)]

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

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-6GiMYQnV-1711136203357)]

最后

做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。
当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。

更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务

[外链图片转存中…(img-XioKsyYa-1711136203357)]

[外链图片转存中…(img-8lxnKW3i-1711136203358)]

[外链图片转存中…(img-0MHqvb1F-1711136203358)]

[外链图片转存中…(img-xAF3tHer-1711136203359)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录