【设计模式】Java设计模式 - 动态代理

😄 不断学习才是王道
🔥 继续踏上学习之路,学之分享笔记
👊 总有一天我也能像各位大佬一样
🏆 一个有梦有戏的人 @怒放吧德德
🌝最近工作比较忙,没啥时间学习

1、简介

动态代理是指客户通过代理类来调用其它对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象。动态代理就需要建立真实对象和代理对象关系,再去实现代理逻辑方法。
Java中实现动态代理有许多方法,JDK、CGLIB、Javassist、ASM,常用的是JDKCGLIB,在spring中就是使用了这两种,然而mybatis还是用了Javassist

2、JDK动态代理

提供简单的接口类以及其实现类,在通过建立真是对象与代理对象的关系,并且实现代理逻辑。

(1)、准备接口类

先提供接口类:
HelloWorldService:

1
2
3
4
5
6
7
8
9
10
package com.lyd.demo.service;

/**
* @Author: lyd
* @Description: 普通的接口
* @Date: 2022-08-17
*/
public interface HelloWorldService {
public void sayHelloWorld();
}

HelloWorldServiceImpl:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.lyd.demo.service.impl;

import com.lyd.demo.service.HelloWorldService;

/**
* @Author: lyd
* @Description: 接口实现类
* @Date: 2022-08-17
*/
public class HelloWorldServiceImpl implements HelloWorldService {
@Override
public void sayHelloWorld() {
System.out.println("Hello World!");
}
}

(2)、jdk动态代理

在JDK动态代理中,通过bind将真实对象和代理对象绑定起来,实现代理逻辑就要去实现java.lang.reflect.InvocationHandler接口,并且去实现invoke方法

①、首先需要声明 bind 方法去建立真实对象与代理对象的关系,把本类中的target保存真实对象。在通过Proxy的newProxyInstance方法来建立并生成对象,target.getClass().getClassLoader():target本身的类加载器,target.getClass().getInterfaces():把生成的动态代理对象下挂在接口中,this:当前对象,是定义实现方法逻辑的代理类。
②、实现InvocationHandler类中的invoke方法,可以实现代理逻辑,当我们使用了代理对象调度方法后就会进入到invoke方法中。

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.lyd.demo.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
* @Author: lyd
* @Description: 动态代理绑定和代理逻辑实现
* @Date: 2022-08-17
*/
public class JdkProxyExample implements InvocationHandler {

// 真实对象
private Object target = null;

/**
* 建立代理对象和真实对象的代理关系,并且返回代理逻辑实现
* @param target 真实对象
* @return 代理对象
*/
public Object bind(Object target) {
this.target = target; // 绑定对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}

/**
* 代理方法逻辑
* @param proxy 代理对象
* @param method 当前调度方法
* @param args 当前方法的参数
* @return 代理结果返回
* @throws Throwable 异常
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("进入代理逻辑方法");
System.out.println("在调度真实对象之前的服务");
Object obj = method.invoke(target, args); // 相当于调用了sayHelloWorld的方法
System.out.println("在调度真实对象之后的服务");
return obj;
}
}

(3)、实例

测试jdk动态代理
通过 HelloWorldService proxy = (HelloWorldService) jdkProxyExample.bind(new HelloWorldServiceImpl()); 去代理对象,然后就是使用proxy去点接口里面的方法了。
代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.lyd.demo.test;

import com.lyd.demo.jdk.JdkProxyExample;
import com.lyd.demo.service.HelloWorldService;
import com.lyd.demo.service.impl.HelloWorldServiceImpl;

/**
* @Author: lyd
* @Description: 测试jdk动态代理
* @Date: 2022-08-17
*/
public class jdkProxyText {
public static void main(String[] args) {
JdkProxyExample jdkProxyExample = new JdkProxyExample();
// 绑定关系,因为挂载带接口下,因此声明一个代理对象
HelloWorldService proxy = (HelloWorldService) jdkProxyExample.bind(new HelloWorldServiceImpl()); // 对象是new 实现类
// 调用方法
proxy.sayHelloWorld();
}
}

实验结果
在这里插入图片描述
可以带入参数:以下是带入参数的例子

在接口中的方法添加参数

1
public void sayHelloWorld(String name);

在实现类的实现方法中打印出来

1
System.out.println("Hello World! " + name);

调用方法的时候添加参数

1
2
// 调用方法
proxy.sayHelloWorld("lyd");

代理模式十分重要,要理解里面的逻辑,可以通过debug打断点去一步一步查看。

3、CGLIB 动态代理

JDK动态代理需要接口才能完成,而如果不提供接口,只有实现的方法类,可以使用三方插件CGLIB来动态代理,采用这个动态代理技术,需要引入三方jar包,可以搭建maven项目,引入CGLIB jar包 ,通过maven官网搜索添加,亦可以直接下载jar文件。

(1)、加入CGLIB依赖

maven引入依赖:

1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>

(2)、准备实现类

准备一个实现类,cglib不需要接口,只要实现就可以:

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.lyd.demo.impl;

/**
* @Author: lyd
* @Description: 实现类
* @Date: 2022-08-17
*/
public class HelloWorldServiceImpl {
public void sayHelloWorld(String name) {
System.out.println("Hello World! " + name);
}
}

(3)、代理类

代理类需要MethodInterceptor去实现方法

这里使用了增强者enhancer,通过设置超类和使用setCallback方法设置代理类,CGLIB是通过invokeSuper方法代理逻辑的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.lyd.demo.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
* @Author: lyd
* @Description:
* @Date: 2022-08-17
*/
public class CglibProxyExample implements MethodInterceptor {

/**
* 生成CGLIB对象
* @param cls -----对象类
* @return Class的CGLIB代理对象
*/
public Object getProxy(Class cls) {
//CGLIB的增强类对象
Enhancer enhancer = new Enhancer();
//设置增强对象
enhancer.setSuperclass(cls);
//定义代理逻辑对象为当前对象,要求对象实现MethodInterceptor方法
enhancer.setCallback(this);
//生成返回代理对象
return enhancer.create();
}

/**
* 代理逻辑方法
* @param proxy 代理对象
* @param method 方法
* @param args 参数
* @param methodProxy 方法代理
* @return 代理逻辑返回
* @throws Throwable 异常处理
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("调用对象之前");
//使用CGLIB反射真实对象的方法
Object result = methodProxy.invokeSuper(proxy, args);
System.out.println("调用对象之后");
return result;
}
}

(4)、实例

测试:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.lyd.demo.test;

import com.lyd.demo.cglib.CglibProxyExample;
import com.lyd.demo.impl.HelloWorldServiceImpl;

/**
* @Author: lyd
* @Description: 测试CGLIB
* @Date: 2022-08-17
*/
public class CGLIBProxyTest {
public static void main(String[] args) {
CglibProxyExample cglibProxyExample = new CglibProxyExample();
HelloWorldServiceImpl proxy = (HelloWorldServiceImpl) cglibProxyExample.getProxy(HelloWorldServiceImpl.class); // 获取对象,可以不需要接口类
proxy.sayHelloWorld("lyd");
}
}

结果
在这里插入图片描述