【设计模式】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();
    }
}

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

在接口中的方法添加参数

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引入依赖：

<!-- 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");
    }
}