动态代理实战：JDK与CGLIB在Java设计模式中的应用-优快云博客

本文链接：https://blog.youkuaiyun.com/libra_ts/article/details/115679352

本文详细介绍了Java中的动态代理，包括JDK动态代理通过匿名内部类实现和CGLIB库的运用，通过实例演示了如何利用它们创建代理对象以控制对象行为和实现解耦。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

设计模式系列文章，主要是把自己开发过程中用到的设计模式。温习一下，并且记录这个过程。

什么是代理模式?

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。
通俗的来讲代理模式就是我们生活中常见的中介。
为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

举个栗子： 我要买一套二手房，这时我的核心诉求就是买房，需要做的事情就是选房、付钱。可是现实情况是你需要讨价还价、验房、过户、缴纳各种契税等。这时候你就可以找到房屋中介，他来给你办这个事情，你只需要交钱就可以了。

静态代理和动态代理

代理模式根据代理类的生成时机，分为静态代理和动态代理

静态代理： 是在java文件编译前，已经写好代理类对象。这样只能代理一类对象，即一类接口的类型
优点：静态代理对调用者隐藏了被代理类接口的具体实现类，在一定程度上实现了解耦合，同时提高了安全性！
缺点：静态代理类需要实现目标类（被代理类）的接口，并实现其方法，造成了代码的大量冗余。而且只能为固定的接口提供代理，灵活性不强。

动态代理： 是通过反射原理，在程序运行的时候动态的生成的代理对象，所以可以代理任意的类对象。
优点：可以为实现了同一个接口的实现类提供代理，并且不需要像静态代理那样，在每个方法里面去增加操作，拓展性变强，冗余代码大大减少。
缺点：相比于静态代理来说。冒的缺点…

实现方式

静态代理真实使用场景较少，这里不做详细的描述。主要讲下项目中常用的动态代理
动态代理的实现方式，有JDK动态代理和CGLIB两种实现方式

JDK动态代理

利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

定义一个接口

package com.tansen.study.proxy;

/**
 * 定义一个计算器接口
 *
 * @author sam
 * @version 1.0.0
 * @date 2021/4/13
 */
public interface Calculator {
   int add(int i, int j);

   int subtract(int i, int j);

   int multiple(int i, int j);

   int divide(int i, int j);
}

定义一个计算器的实现类

package com.tansen.study.proxy;

/**
 * 计算器实现类
 *
 * @author sam
 * @version 1.0.0
 * @date 2021/4/13
 */
public class MyCalculator implements Calculator {

    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int subtract(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int multiple(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int divide(int i, int j) {
        int result = i / j;
        return result;
    }
}

定义一个代理类

/**
 * 获取代理
 * 要想代理类更加的通用，也可以将接口入参调整为Object
 * 这样的话传入什么，生成的就是什么
 *
 * @author sam
 * @version 1.0.0
 * @date 2021/4/13
 */
public class CalculatorProxy {

    public static Calculator getProxy(final Calculator calculator){
        //获取类加载器
        ClassLoader classLoader = calculator.getClass().getClassLoader();

        //获取需要实现的接口
        Class<?>[] interfaces = calculator.getClass().getInterfaces();

        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法名称：" + method.getName() + ",方法入参：" + args[0] + "," + args[1]);
                Object result = method.invoke(calculator, args);
                return result;
            }
        };

        Object o = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);

        return (Calculator)o;
    }
}

调用

/**
 * 调用
 *
 * @author sam
 * @version 1.0.0
 * @date 2021/4/13
 */
public class Test {
    public static void main(String[] args) {
        Calculator proxy = CalculatorProxy.getProxy(new MyCalculator());
        System.out.println(proxy.add(1, 1));
        System.out.println(proxy.subtract(1, 1));
        System.out.println(proxy.multiple(3, 6));
        System.out.println(proxy.divide(4, 2));
        System.out.println(proxy.getClass());

    }
}

代理处理的结果

在这里插入图片描述

JDK动态代理源码解析

jdk动态代理，生成代理对象的重点就在Proxy.class的567行apply()

 @Override
 public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
 
     Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
     
     for (Class<?> intf : interfaces) {
         Class<?> interfaceClass = null;
         try {
             interfaceClass = Class.forName(intf.getName(), false, loader);
         } catch (ClassNotFoundException e) {
         }
         if (interfaceClass != intf) {
             throw new IllegalArgumentException(
                 intf + " is not visible from class loader");
         }
         
         if (!interfaceClass.isInterface()) {
             throw new IllegalArgumentException(
                 interfaceClass.getName() + " is not an interface");
         }
         
         if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
             throw new IllegalArgumentException(
                 "repeated interface: " + interfaceClass.getName());
         }
     }
	//上面这部分都是校验
     String proxyPkg = null;     // package to define proxy class in
     int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
     
     for (Class<?> intf : interfaces) {
         int flags = intf.getModifiers();
         if (!Modifier.isPublic(flags)) {
             accessFlags = Modifier.FINAL;
             String name = intf.getName();
             int n = name.lastIndexOf('.');
             String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
             if (proxyPkg == null) {
                 proxyPkg = pkg;
             } else if (!pkg.equals(proxyPkg)) {
                 throw new IllegalArgumentException(
                     "non-public interfaces from different packages");
             }
         }
     }
	//拼接包名
     if (proxyPkg == null) {
         // if no non-public proxy interfaces, use com.sun.proxy package
         proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
     }

     //获取当前最新的代理数量，用于拼接代理对象名称，例如$Proxy0
     long num = nextUniqueNumber.getAndIncrement();
     //proxyClassNamePrefix是一个常量$Proxy
     String proxyName = proxyPkg + proxyClassNamePrefix + num;

     /*
      * Generate the specified proxy class.
      * 生成指定的代理类，将代理类加载到内存中
      */
     byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
         proxyName, interfaces, accessFlags);
     try {
     	//原生方法，生成代理的Class对象
         return defineClass0(loader, proxyName,
                             proxyClassFile, 0, proxyClassFile.length);
     } catch (ClassFormatError e) {
         /*
          * A ClassFormatError here means that (barring bugs in the
          * proxy class generation code) there was some other
          * invalid aspect of the arguments supplied to the proxy
          * class creation (such as virtual machine limitations
          * exceeded).
          */
         throw new IllegalArgumentException(e.toString());
     }
 }

CGLIB动态代理

“代理”的目的是构造一个和被代理的对象有同样行为的对象。
一个对象的行为是在类中定义的，对象只是类的实例。所以构造代理，不一定非得通过持有、包装对象这一种方式。
通过“继承”可以继承父类所有的公开方法，然后可以重写这些方法，在重写时对这些方法增强，这就是cglib的思想。

根据里氏代换原则（LSP），父类需要出现的地方，子类可以出现，所以cglib实现的代理也是可以被正常使用的。

CGLIB不同于JDK动态代理的地方在于，CGLIB不需要去实现接口。

CGLIB部分学习借鉴：https://blog.youkuaiyun.com/flyfeifei66/article/details/81481222

实现方式

package com.tansen.study.proxy.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * cglib代理类
 *
 * @author 谭森
 * @version 1.0.0
 * @date 2021/4/17
 */
public class MyCglib implements MethodInterceptor {
	/**
     * 根据给定的类型生成代理类
     * @param clazz
     * @return
     */
    public Object createProxyObj(Class<?> clazz) {
        //通过cglib动态代理获取代理对象的过程，创建调用的对象
        Enhancer enhancer = new Enhancer();
        //设置Enhancer的父类
        enhancer.setSuperclass(clazz);
        //设置enhancer的回调对象
        enhancer.setCallback(this);
        //创建代理对象
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    	//增强操作
        System.out.println("方法名称：" + method.getName() + ",方法入参：" + objects[0] + "," + objects[1]);
        return methodProxy.invokeSuper(o,objects);
    }
}