解析动态代理jdk的Proxy与spring的CGlib(包括区别介绍)

1. 为什么要使用动态代理？

动态代理：在不改变原有代码的情况下上进行对象功能增强 使用代理对象代替原来的对象完成功能 进而达到拓展功能的目的

2.jdk proxy 动态代理面向接口的动态代理

特点：

• 一定要有接口和实现类的存在 代理对象增强的是实现类 在实现接口的方法重写的方法
• 生成的代理对象只能转换成 接口的不能转换成 被代理类
• 代理对象只能增强接口中定义的方法 实现类中其他和接口无关的方法是无法增强的
• 代理对象只能读取到接口中方法上的注解 不能读取到实现类方法上的注解
• 使用方法：

public class test1 {
    public static void main(string[] args) {
        dinner dinner=new person("张三");
        // 通过porxy动态代理获得一个代理对象,在代理对象中,对某个方法进行增强
//        classloader loader,被代理的对象的类加载器
        classloader classloader = dinner.getclass().getclassloader();
//        class<?>[] interfaces,被代理对象所实现的所有接口
        class[] interaces= dinner.getclass().getinterfaces();
//        invocationhandler h,执行处理器对象,专门用于定义增强的规则
        invocationhandler handler = new invocationhandler(){
            // invoke 当我们让代理对象调用任何方法时,都会触发invoke方法的执行
            public object invoke(object proxy, method method, object[] args) throws throwable {
//                object proxy, 代理对象
//                method method,被代理的方法
//                object[] args,被代理方法运行时的实参
                object res=null;
               if(method.getname().equals("eat")){
                   system.out.println("饭前洗手");
                   // 让原有的eat的方法去运行
                   res =method.invoke(dinner, args);
                   system.out.println("饭后刷碗");
               }else{
                   // 如果是其他方法,那么正常执行就可以了
                   res =method.invoke(dinner, args);
               }
                return res;
            }
        };
        dinner dinnerproxy =(dinner) proxy.newproxyinstance(classloader,interaces,handler);
        //dinnerproxy.eat("包子");
        dinnerproxy.drink();
    }
}
interface dinner{
    void eat(string foodname);
    void drink();
}
class person implements dinner{
    private string name;
    public person(string name) {
        this.name = name;
    }
    @override
    public void eat(string foodname) {
        system.out.println(name+"正在吃"+foodname);
    }
    @override
    public void drink( ) {
        system.out.println(name+"正在喝茶");
    }
}
class student implements dinner{
    private string name;
    public student(string name) {
        this.name = name;
    }
    @override
    public void eat(string foodname) {
        system.out.println(name+"正在食堂吃"+foodname);
    }
    @override
    public void drink( ) {
        system.out.println(name+"正在喝可乐");
    }
}

3.cglib动态代理

cglib动态代理模式是面向父类

特点：

面向父类的和接口没有直接关系
2.不仅可以增强接口中定义的方法还可以增强其他方法
3.可以读取父类中方法上的所有注解

使用实例

public class test1 {
    @test
    public void testcglib(){
        person person =new person();
        // 获取一个person的代理对象
        // 1 获得一个enhancer对象
        enhancer enhancer=new enhancer();
        // 2 设置父类字节码
        enhancer.setsuperclass(person.getclass());
        // 3 获取methodintercepter对象 用于定义增强规则
        methodinterceptor methodinterceptor=new methodinterceptor() {
            @override
            public object intercept(object o, method method, object[] objects, methodproxy methodproxy) throws throwable {
                /*object o,  生成之后的代理对象 personproxy
                method method,  父类中原本要执行的方法  person>>> eat()
                object[] objects, 方法在调用时传入的实参数组
                methodproxy methodproxy  子类中重写父类的方法 personproxy >>> eat()
                */
                object res =null;
                if(method.getname().equals("eat")){
                    // 如果是eat方法 则增强并运行
                    system.out.println("饭前洗手");
                    res=methodproxy.invokesuper(o,objects);
                    system.out.println("饭后刷碗");
                }else{
                    // 如果是其他方法 不增强运行
                    res=methodproxy.invokesuper(o,objects); // 子类对象方法在执行,默认会调用父类对应被重写的方法
                }
                return res;
            }
        };
        // 4 设置methodinterceptor
        enhancer.setcallback(methodinterceptor);
        // 5 获得代理对象
        person personproxy = (person)enhancer.create();
        // 6 使用代理对象完成功能
        personproxy.eat("包子");
    }
}
class person  {
    public person( ) {
    }
    public void eat(string foodname) {
        system.out.println("张三正在吃"+foodname);
    }
}

原理区别：

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

而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口，默认情况下会采用jdk的动态代理实现aop 
2、如果目标对象实现了接口，可以强制使用cglib实现aop 

3、如果目标对象没有实现了接口，必须采用cglib库，spring会自动在jdk动态代理和cglib之间转换

如何强制使用cglib实现aop？
 （1）添加cglib库，spring_home/cglib/*.jar
 （2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>

jdk动态代理和cglib字节码生成的区别？
 （1）jdk动态代理只能对实现了接口的类生成代理，而不能针对类
 （2）cglib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
   因为是继承，所以该类或方法最好不要声明成final 

两个动态代理的区别

• jdk动态代理是面向接口的，只能增强实现类中接口中存在的方法。cglib是面向父类的，可以增强父类的所有方法
• jdk得到的对象是jdk代理对象实例，而cglib得到的对象是被代理对象的子类 生活虽然苦闷，但跑起来总是带风！

到此这篇关于解析动态代理jdk的proxy与spring的cglib的文章就介绍到这了,更多相关动态代理jdk的proxy与spring的cglib内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！