【设计模式】Java设计模式 - 动态代理
😄 不断学习才是王道
🔥 继续踏上学习之路，学之分享笔记
👊 总有一天我也能像各位大佬一样
🏆 关注我的CSDN： 一个有梦有戏的人
👊 打算连载Java设计模式，记录自己的学习心得，分享学习经验。
1、简介
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。动态代理就需要建立真实对象和代理对象关系，再去实现代理逻辑方法。
Java中实现动态代理有许多方法，JDK、CGLIB、Javassist、ASM，常用的是JDK和CGLIB，在spring中就是使用了这两种，然而mybatis还是用了Javassist。
2、JDK动态代理
提供简单的接口类以及其实现类，在通过建立真是对象与代理对象的关系，并且实现代理逻辑。
(1)、准备接口类
先提供接口类：
HelloWorldService：
package com.lyd.demo.service;
/**
* @Author: lyd
* @Description: 普通的接口
* @Date: 2022-08-17
*/
public interface HelloWorldService {
public void sayHelloWorld();
}HelloWorldServiceImpl：
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方法中。
代码如下：
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去点接口里面的方法了。
代码如下：
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();
}
}实验结果
可以带入参数：以下是带入参数的例子
在接口中的方法添加参数
public void sayHelloWorld(String name);在实现类的实现方法中打印出来
System.out.println("Hello World! " + name);调用方法的时候添加参数
// 调用方法
proxy.sayHelloWorld("lyd");代理模式十分重要，要理解里面的逻辑，可以通过debug打断点去一步一步查看。
3、CGLIB 动态代理
JDK动态代理需要接口才能完成，而如果不提供接口，只有实现的方法类，可以使用三方插件CGLIB来动态代理，采用这个动态代理技术，需要引入三方jar包，可以搭建maven项目，引入CGLIB jar包 ，通过maven官网搜索添加，亦可以直接下载jar文件。
(1)、加入CGLIB依赖
maven引入依赖：
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>(2)、准备实现类
准备一个实现类，cglib不需要接口，只要实现就可以：
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方法代理逻辑的。
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)、实例
测试：
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");
}
}结果
