jdk动态代理和cglib动态代理详解

• • jdk动态代理
  • 如何实现一个hashmap的动态代理类？
  • cglib动态代理
  • jdk与cglib动态代理对比？
  • spring如何选择两种代理模式的？

如上图，代理模式可分为动态代理和静态代理，我们比较常用的有动态代理中的jdk动态代理和cglib代理，像spring框架、hibernate框架中都采用了jdk动态代理，下面将结合代码阐述两种代理模式的使用与区别。

静态代理

静态代理的代理对象和被代理对象在代理之前就已经确定，它们都实现相同的接口或继承相同的抽象类。静态代理模式一般由业务实现类和业务代理类组成，业务实现类里面实现主要的业务逻辑，业务代理类负责在业务方法调用的前后作一些你需要的处理，如日志记录、权限拦截等功能…实现业务逻辑与业务方法外的功能解耦，减少了对业务方法的入侵。静态代理又可细分为：基于继承的方式和基于聚合的方式实现。

场景：假设一个预减库存的操作，需要在预减的前后加日志记录（我这里是springboot项目）

基于继承的方式实现静态代理

/**
 * 业务实现类接口
 */
public interface orderservice {
    //减库存操作
    void reducestock();
}

/**
 * 业务实现类
 */
@slf4j
public class orderserviceimpl implements orderservice {
    @override
    public void reducestock() {
        try {
            log.info("预减库存中……");
            thread.sleep(1000);
        }catch (exception e){
            e.printstacktrace();
        }
    }
}

/**
 * 代理类
 */
@slf4j
public class orderservicelogproxy extends orderserviceimpl{
    @override
    public void reducestock() {
        log.info("预减库存开始……");
        super.reducestock();
        log.info("预减库存结束……");
    }
}

    /**
     * 测试继承方式实现的静态代理
     */
    @test
    public void testorderserviceproxy(){
        orderservicelogproxy proxy = new orderservicelogproxy();
        proxy.reducestock();
    }

输出结果

14:53:53.769 [main] info com.simons.cn.springbootdemo.proxy.orderservicelogproxy - 预减库存开始……
14:53:53.771 [main] info com.simons.cn.springbootdemo.proxy.orderserviceimpl - 预减库存中……
14:53:54.771 [main] info com.simons.cn.springbootdemo.proxy.orderservicelogproxy - 预减库存结束……

可以看到，orderservicelogproxy已经实现了为orderserviceimpl的代理，通过代理类的同名方法来增强了业务方法前后逻辑。

基于聚合的方式实现静态代理

聚合的意思就是把业务类引入到了代理类中，接口和业务实现类还是之前的orderservice、orderserviceimpl，代理类改为如下：

/**
 * 聚合方式实现静态代理：代理类中引入业务类
 */
@slf4j
public class orderservicelogproxy2 implements orderservice {
    private orderserviceimpl orderservice;
    public orderservicelogproxy2(orderserviceimpl orderservice) {
        this.orderservice = orderservice;
    }
    @override
    public void reducestock() {
        log.info("预减库存开始……");
        orderservice.reducestock();
        log.info("预减库存结束……");
    }
}

    /**
     * 测试聚合方式实现的静态代理
     */
    @test
    public void testorderserviceproxy2() {
        orderserviceimpl orderservice = new orderserviceimpl();
        orderservicelogproxy2 proxy2 = new orderservicelogproxy2(orderservice);
        proxy2.reducestock();
    }

测试输出结果和上面的结果是一致的。

继承与聚合方式实现的静态代理对比

结合上面的代码来看，如果此时需要叠加代理功能，我不仅要记录预减日志，还要增加权限拦截功能，这个时候如果采用继承的方式的话，就得新建一个代理类，里面包含日志和权限逻辑；那要是再增加一个代理功能，又要新增代理类；如果要改变下代理功能的执行顺序，还是得增加代理类，结合上面分析来看，这样做肯定是不妥的。但是如果使用聚合方式的方式呢？我们稍微改造下上面使用的聚合方式实现的静态代理代码：

首先是日志代理类代码

/**
 * 聚合方式实现静态代理--日志记录功能叠加改造
 */
@slf4j
public class orderservicelogproxy3 implements orderservice {
    //注意，这里换成了接口
    private orderservice orderservice;
    public orderservicelogproxy3(orderservice orderservice) {
        this.orderservice = orderservice;
    }
    @override
    public void reducestock() {
        log.info("预减库存开始……");
        orderservice.reducestock();
        log.info("预减库存结束……");
    }
}

然后是新增的权限验证代理类代码

/**
 * 聚合方式实现静态代理--日志记录功能叠加改造
 */
@slf4j
public class orderservicepermissionproxy implements orderservice {
    //注意，这里换成了接口
    private orderservice orderservice;
    public orderservicepermissionproxy(orderservice orderservice) {
        this.orderservice = orderservice;
    }
    @override
    public void reducestock() {
        log.info("权限验证开始……");
        orderservice.reducestock();
        log.info("权限验证结束……");
    }
}

测试用例

    /**
     * 测试聚合方式实现的静态代理-功能叠加
     */
    @test
    public void testorderserviceproxy3() {
        orderserviceimpl orderservice = new orderserviceimpl();
        orderservicelogproxy2 logproxy2 = new orderservicelogproxy2(orderservice);
        orderservicepermissionproxy permissionproxy = new orderservicepermissionproxy(logproxy2);
        permissionproxy.reducestock();
    }

测试结果

16:00:28.348 [main] info com.simons.cn.springbootdemo.proxy.orderservicepermissionproxy - 权限验证开始……
16:00:28.365 [main] info com.simons.cn.springbootdemo.proxy.orderservicelogproxy2 - 预减库存开始……
16:00:28.365 [main] info com.simons.cn.springbootdemo.proxy.orderserviceimpl - 预减库存中……
16:00:29.365 [main] info com.simons.cn.springbootdemo.proxy.orderservicelogproxy2 - 预减库存结束……
16:00:29.365 [main] info com.simons.cn.springbootdemo.proxy.orderservicepermissionproxy - 权限验证结束……

接下来，如果你需要调换一下代理类逻辑执行顺序问题，你只需要在使用（像测试一样）时调换一下实例化顺序即可实现日志功能和权限验证的先后执行顺序了，而不需要像继承方式一样去不断的新建代理类。

动态代理

看完上面的静态代理，我们发现，静态代理模式的代理类，只是实现了特定类的代理，比如上面orderservicelogproxy实现的orderserviceimpl的代理，如果我还有个userservice也许要日志记录、权限校验功能，又得写双份的userservicelogproxy、userservicepermissionproxy代理类，里面的逻辑很多都是相同的，也就是说你代理类对象的方法越多，你就得写越多的重复的代码，那么有了动态代理就可以比较好的解决这个问题，动态代理就可以动态的生成代理类，实现对不同类下的不同方法的代理。

jdk动态代理

jdk动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用业务方法前调用invocationhandler处理。代理类必须实现invocationhandler接口，并且，jdk动态代理只能代理实现了接口的类，没有实现接口的类是不能实现jdk动态代理。结合下面代码来看就比较清晰了。

import lombok.extern.slf4j.slf4j;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
/**
 * jdk动态代理实现，必须实现invocationhandler接口
 * invocationhandler可以理解为事务处理器，所有切面级别的逻辑都在此完成
 */
@slf4j
public class dynamiclogproxy implements invocationhandler {
    //需要代理的对象类
    private object target;

    public dynamiclogproxy(object target) {
        this.target = target;
    }
    /**
     * @param obj    代理对象
     * @param method 对象方法
     * @param args   方法参数
     * @return
     * @throws throwable
     */
    @override
    public object invoke(object obj, method method, object[] args) throws throwable {
        log.info("这里是日志记录切面，日志开始……");
        //使用方法的反射
        object invoke = method.invoke(target, args);
        log.info("这里是日志记录切面，日志结束……");
        return invoke;
    }
}

使用时代码

    /**
     * 测试jdk动态代理实现的日志代理类
     */
    @test
    public void testdynamiclogproxy() {
        orderserviceimpl orderservice = new orderserviceimpl();
        class<?> clazz = orderservice.getclass();
        dynamiclogproxy logproxyhandler = new dynamiclogproxy(orderservice);
        //通过proxy.newproxyinstance(类加载器, 接口s, 事务处理器handler) 加载动态代理
        orderservice os = (orderservice) proxy.newproxyinstance(clazz.getclassloader(), clazz.getinterfaces(), logproxyhandler);
        os.reducestock();
    }

输出结果

16:35:54.584 [main] info com.simons.cn.springbootdemo.proxy.dynamiclogproxy - 这里是日志记录切面，日志开始……
16:35:54.587 [main] info com.simons.cn.springbootdemo.proxy.orderserviceimpl - 预减库存中……
16:35:55.587 [main] info com.simons.cn.springbootdemo.proxy.dynamiclogproxy - 这里是日志记录切面，日志结束……

使用jdk动态代理类基本步骤：

1、编写需要被代理的类和接口（我这里就是orderserviceimpl、orderservice）；

2、编写代理类（例如我这里的dynamiclogproxy），需要实现invocationhandler接口，重写invoke方法；

3、使用proxy.newproxyinstance(classloader loader,class<?>[] interfaces,invocationhandler h)动态创建代理类对象，通过代理类对象调用业务方法。

那么这个时候，如果我需要在代理类中叠加功能，该如何是好？比如不仅要日志，还新增权限认证，思路还是上面的聚合方式实现静态代理里的那样，贴下代码，先新增权限认证代理类

import lombok.extern.slf4j.slf4j;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
/**
 * 基于jdk动态代理实现的权限认证代理类
 */
@slf4j
public class dynamicpermissionproxy implements invocationhandler{
    private object target;
    public dynamicpermissionproxy(object target) {
        this.target = target;
    }
    /**
     * @param obj    代理对象
     * @param method 对象方法
     * @param args   方法参数
     * @return
     * @throws throwable
     */
    @override
    public object invoke(object obj, method method, object[] args) throws throwable {
        log.info("这里是权限认证切面，开始验证……");
        object invoke = method.invoke(target,args);
        log.info("这里是权限认证切面，结束验证……");
        return invoke;
    }
}

然后使用时候，需要稍微改动下

    /**
     * 测试jdk动态代理实现的日志、权限功能代理类
     */
    @test
    public void testdynamiclogandpermissproxy() {
        orderserviceimpl orderservice = new orderserviceimpl();
        class<?> clazz = orderservice.getclass();
        dynamiclogproxy logproxyhandler = new dynamiclogproxy(orderservice);
        orderservice os = (orderservice) proxy.newproxyinstance(clazz.getclassloader(), clazz.getinterfaces(), logproxyhandler);
        //注：这里把日志代理类实例对象传入权限认证代理类中
        dynamicpermissionproxy dynamicpermissionproxy = new dynamicpermissionproxy(os);
        orderservice os2 = (orderservice)proxy.newproxyinstance(os.getclass().getclassloader(),os.getclass().getinterfaces(),dynamicpermissionproxy);
        os2.reducestock();
    }

如上即可，后面还需要叠加功能代理类的话，按照上面的思路依次传入代理对象实例即可。

如何实现一个hashmap的动态代理类？

public class hashmapproxytest {
    public static void main(string[] args) {
        final hashmap<string, object> hashmap = new hashmap<>();
        map<string, object> mapproxy = (map<string, object>) proxy.newproxyinstance(hashmap.class.getclassloader(), hashmap.class.getinterfaces(), new invocationhandler() {
            @override
            public object invoke(object proxy, method method, object[] args) throws throwable {
                return method.invoke(hashmap, args);
            }
        });
        mapproxy.put("key1", "value1");
        system.out.println(mapproxy);
    }
}

cglib动态代理

cglib是针对类来实现代理的，它会对目标类产生一个代理子类，通过方法拦截技术对过滤父类的方法调用。代理子类需要实现methodinterceptor接口。另外，如果你是基于spring配置文件形式开发，那你需要显示声明：

<aop:aspectj-autoproxy proxy-target-class="true"/>

如果你是基于springboot开发，则一般在启动类头部显示的添加注解 

@enableaspectjautoproxy(proxytargetclass = true)

import lombok.extern.slf4j.slf4j;
import org.springframework.cglib.proxy.enhancer;
import org.springframework.cglib.proxy.methodinterceptor;
import org.springframework.cglib.proxy.methodproxy;
import java.lang.reflect.method;
/**
 * 基于cglib方式实现动态代理-日志功能
 * 它是针对类实现代理的，类不用实现接口，cglib对目标类产生一个子类，通过方法拦截技术拦截所有的方法调用
 */
@slf4j
public class dynamiccgliblogproxy implements methodinterceptor {
    private enhancer enhancer = new enhancer();
    public object getproxyobj(class clazz) {
        //设置父类
        enhancer.setsuperclass(clazz);
        enhancer.setcallback(this);
        enhancer.setusecache(false);
        return enhancer.create();
    }
    /**
     * 拦截所有目标类的方法调用
     *
     * @param o           目标对象
     * @param method      目标方法
     * @param args        方法参数
     * @param methodproxy 代理类实例
     * @return
     * @throws throwable
     */
    @override
    public object intercept(object o, method method, object[] args, methodproxy methodproxy) throws throwable {
        log.info("这里是日志记录切面，日志开始……");
        //代理类对象实例调用父类方法
        object result = methodproxy.invokesuper(o, args);
        log.info("这里是日志记录切面，日志结束……");
        return result ;
    }
}

测试用例

    /**
     * 测试cglib实现的动态代理-日志功能
     */
    @test
    public void testgclibdynamiclogproxy(){
        dynamiccgliblogproxy dynamiccgliblogproxy = new dynamiccgliblogproxy();
        orderserviceimpl orderservice = (orderserviceimpl)dynamiccgliblogproxy.getproxyobj(orderserviceimpl.class);
        orderservice.reducestock();
    }

输出结果

17:41:07.007 [main] info com.simons.cn.springbootdemo.proxy.dynamiccgliblogproxy - 这里是日志记录切面，日志开始……
17:41:07.038 [main] info com.simons.cn.springbootdemo.proxy.orderserviceimpl - 预减库存中……
17:41:08.038 [main] info com.simons.cn.springbootdemo.proxy.dynamiccgliblogproxy - 这里是日志记录切面，日志结束……

jdk与cglib动态代理对比？

1、jdk动态代理只能代理实现了接口的类，没有实现接口的类不能实现jdk的动态代理；

2、cglib动态代理是针对类实现代理的，运行时动态生成被代理类的子类拦截父类方法调用，因此不能代理声明为final类型的类和方法；

动态代理和静态代理的区别？

1、静态代理在代理前就知道要代理的是哪个对象，而动态代理是运行时才知道；

2、静态代理一般只能代理一个类，而动态代理能代理实现了接口的多个类；

spring如何选择两种代理模式的？

1、如果目标对象实现了接口，则默认采用jdk动态代理；

2、如果目标对象没有实现接口，则使用cglib代理；

3、如果目标对象实现了接口，但强制使用了cglib，则使用cglib进行代理

我们可以结合源码来看下，上面的选择：

补充

cglib实现的methodinterceptor接口在spring-core包下，你可能需要要引入

<dependency>
    <groupid>org.springframework</groupid>
    <artifactid>spring-core</artifactid>
    <version>4.1.0.release</version>
</dependency>

@slf4j是lombok里提供的，而且如果你在intellij idea开发工具中使用还需要安装lombok插件

@test是junit包下的，你可能需要引入

<dependency>
     <groupid>junit</groupid>
     <artifactid>junit</artifactid>
     <version>4.11</version>
     <scope>test</scope>
</dependency>

总结

本篇文章就到这里了，希望可以给你带来一些帮助，也希望您能够多多关注的更多内容！