Java 静态代理和动态代理（jdk、cglib）

梦里梦外; 2023-09-28 14:02 12阅读 0赞

**目录**

1 代理

1.1 被代理对象

2 静态代理

2.1 静态代理类

2.2 调试代码

3 动态代理

3.1 自定义增强类

3.2 自定义动态代理接口

3.3 JDK动态代理

3.3.1 实现代码

3.3.2 调试代码

3.4 Cglib动态代理

3.4.1 实现代码

3.4.2 调试代码

注：

--------------------

## 1 代理 ##

代理是一个抽象的概念，简单理解就可以理解为在一个java类上去给它增加一些新的功能，但是却不用动原来的代码，在Java中分为静态代理和动态代理，然而动态代理又分为 jdk 动态代理和 cglib 动态代理。

### 1.1 被代理对象 ###

package com.xudongbase.proxy.serivce;
    
    /**
     * AOP demo
     *
     * @author xudongmaster
     */
    public interface AopDemoService {
        /**
         * 打印 HelloWorld
         */
        void printHelloWorld();
    }

package com.xudongbase.proxy.serivce.impl;
    
    import com.xudongbase.proxy.serivce.AopDemoService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    
    /**
     * Aop Demo
     *
     * @author xudongmaster
     */
    @Slf4j
    @Component
    public class AopDemoServiceImpl implements AopDemoService {
        /**
         * 打印 HelloWorld
         */
        @Override
        public void printHelloWorld() {
            log.error("Hello World!");
        }
    }

## 2 静态代理 ##

静态代理相当于是多写了一个代理类，在调用的时候调用的是代理类，在代理类中的处理还是原生的处理逻辑，不过在前后添加上需要添加的代码。需要为每一个被代理的对象都创建一个代理类，并且不同类创建的代理类不能通用。

### 2.1 静态代理类 ###

package com.xudongbase.proxy;
    
    import com.xudongbase.proxy.serivce.AopDemoService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * 静态代理
     *
     * @author xudongmaster
     */
    @Slf4j
    @Component
    public class StaticProxy {
        @Autowired
        private AopDemoService aopDemoService;
    
        /**
         * 打印HelloWorld
         */
        public void printHelloWorld() {
            log.info("开始打印");
            aopDemoService.printHelloWorld();
            log.info("结束打印");
        }
    }

## 2.2 调试代码 ##

package com.xudongbase.proxy;
    
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    /**
     * 静态代理测试类
     *
     * @author xudongmaster
     */
    @SpringBootTest
    public class StaticProxyTest {
        @Autowired
        private StaticProxy staticProxy;
    
        /**
         * 测试静态代理
         */
        @Test
        public void testStaticProxy() {
            staticProxy.printHelloWorld();
        }
    }

## 3 动态代理 ##

### 3.1 自定义增强类 ###

package com.xudongbase.proxy.enhance;
    
    /**
     * 自定义增强类
     *
     * @author xudongmaster
     */
    public interface CustomEnhance {
        /**
         * 之前增强
         */
        void beforeEnhance();
    
        /**
         * 之后增强
         *
         */
        void afterEnhance();
    }

package com.xudongbase.proxy.enhance;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    
    /**
     * 打印Hello World增强类
     *
     * @author xudongmaster
     */
    @Slf4j
    @Component
    public class PrintHelloWorldEnhance implements CustomEnhance {
        /**
         * 之前增强
         *
         */
        @Override
        public void beforeEnhance() {
            log.info("开始打印");
        }
    
        /**
         * 之后增强
         *
         */
        @Override
        public void afterEnhance() {
            log.info("结束打印");
        }
    }

### 3.2 自定义动态代理接口 ###

package com.xudongbase.proxy.serivce;
    
    import com.xudongbase.proxy.enhance.CustomEnhance;
    
    /**
     * 自定义动态代理接口
     *
     * @author xudongmaster
     */
    public interface CustomDynamicProxy<T> {
        /**
         * 生成代理对象
         *
         * @param target  代理对象
         * @param enhance 增强类对象
         * @param args    传参
         * @return
         */
        T createProxyTarget(T target, CustomEnhance enhance, Object... args);
    }

### 3.3 JDK动态代理 ###

JDK动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

静态代理与动态代理的区别主要在：

*  静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
 *  动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

**特点：**  
动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

#### 3.3.1 实现代码 ####

package com.xudongbase.proxy;
    
    import com.xudongbase.proxy.enhance.CustomEnhance;
    import com.xudongbase.proxy.serivce.CustomDynamicProxy;
    import lombok.NoArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * JDK动态代理
     *
     * @author xudongmaster
     */
    @NoArgsConstructor
    @Component
    @Slf4j
    public class JdkDynamicProxy implements InvocationHandler, CustomDynamicProxy {
        /**
         * 需要代理的目标对象
         */
        private Object target;
        /**
         * 自定义增强类
         */
        private CustomEnhance enhance;
    
        /**
         * 反射调用
         *
         * @param proxy
         * @param method 方法对象
         * @param args   参数
         * @return
         * @throws Throwable
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            enhance.beforeEnhance();
            Object result = method.invoke(target, args);
            enhance.afterEnhance();
            return result;
        }
    
        /**
         * 生成代理对象
         *
         * @param target  代理对象
         * @param enhance 增强对象
         * @param args    传参
         * @return
         */
        @Override
        public Object createProxyTarget(Object target, CustomEnhance enhance, Object... args) {
            //代理对象
            this.target = target;
            //增强类对象
            this.enhance = enhance;
            //代理对象Class
            Class targetClass = (Class) args[0];
            //类加载器
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            //被代理的类
            Class[] classes = new Class[]{targetClass};
            //实例被动态代理的被代理类对象
            return Proxy.newProxyInstance(classLoader, classes, this);
        }
    }

#### 3.3.2 调试代码 ####

/**
         * 测试jdk动态代理
         */
        @Test
        public void testJdkDynamicProxy() {
            //实例被动态代理的被代理类对象
            AopDemoService aopProxyService = (AopDemoService) dynamicProxy.createProxyTarget(aopDemoService, printHelloWorldEnhance, AopDemoService.class);
            aopProxyService.printHelloWorld();
        }

### 3.4 Cglib动态代理 ###

cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib特点

*  JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。  
    如果想代理没有实现接口的类，就可以使用CGLIB实现。
 *  CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。  
    它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
 *  CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。

cglib与jdk动态代理最大的区别就是

*  使用jdk动态代理的对象必须实现一个或多个接口
 *  使用cglib代理的对象则无需实现接口，达到代理类无侵入。

使用cglib需要引入cglib的jar包，如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

#### 3.4.1 实现代码 ####

package com.xudongbase.proxy;
    
    import com.xudongbase.proxy.enhance.CustomEnhance;
    import com.xudongbase.proxy.serivce.CustomDynamicProxy;
    import lombok.NoArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    
    /**
     * Cglib动态代理
     *
     * @author xudongmaster
     */
    @Slf4j
    @Component
    @NoArgsConstructor
    public class CglibDynamicProxy implements MethodInterceptor, CustomDynamicProxy {
        /**
         * 需要代理的目标对象
         */
        private Object target;
    
        /**
         * 自定义增强类
         */
        private CustomEnhance enhance;
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            enhance.beforeEnhance();
            Object result = method.invoke(target, objects);
            enhance.afterEnhance();
            return result;
        }
    
        /**
         * 生成代理对象
         *
         * @param target  代理对象
         * @param enhance 增强类对象
         * @param args    传参
         * @return
         */
        @Override
        public Object createProxyTarget(Object target, CustomEnhance enhance, Object... args) {
            // 将传入进来的目标对象赋值给全局变量，在后续调用拦截方法时会用到
            this.target = target;
            //增强类对象
            this.enhance = enhance;
            //给被代理类搞一个屏障
            Enhancer enhancer = new Enhancer();
            //设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
            enhancer.setSuperclass(target.getClass());
            // 设置回调
            enhancer.setCallback(this);
            // 搞好这个代理类并返回
            Object result = enhancer.create();
            return result;
        }
    }

#### 3.4.2 调试代码 ####

/**
         * 测试cglib动态代理
         */
        @Test
        public void testCglibDynamicProxy() {
            //实例被动态代理的被代理类对象
            AopDemoService aopProxyService = (AopDemoService) cglibDynamicProxy.createProxyTarget(aopDemoService, printHelloWorldEnhance);
            aopProxyService.printHelloWorld();
        }

## 注： ##

觉得这篇博客写的不错的可以前往Gitee/GitCode点个Star，源码请查看Gitee/GitCode的xudongbase项目proxy分支。

[文件 · proxy · 旭东怪 / Xudongbase · GitCode][_ proxy _ _ _ Xudongbase _ GitCode][xudongbase: 主要是项目中可以用到的共通方法，现有easyexcel分支在持续更新中。欢迎大家Star和提交Issues。easyexcel分支：批量设置样式，批量添加批注，批量合并单元格，设置冻结行和列，设置行高列宽，隐藏行和列，绑定下拉框数据，设置水印，插入图片 - Gitee.com][xudongbase_ _easyexcel_Star_Issues_easyexcel_ - Gitee.com]

[_ proxy _ _ _ Xudongbase _ GitCode]: https://gitcode.net/qq_38974638/xudongbase/-/tree/proxy
[xudongbase_ _easyexcel_Star_Issues_easyexcel_ - Gitee.com]: https://gitee.com/xudong_master/xudongbase/tree/proxy/