jdk代理和cglib代理（实例推导）

jdk代理和cglib代理（实例推导）

更深层的探究jdk和cglib动态代理的原理

jdk动态代理

jdk动态代理（简单实现）

定义一个House的房源类型接口

public interface House {
    //销售房屋
    void saleHouse();
    //出租房屋
    void rentHouse();
}

定义一个房东Landlord实现上面定义的房源接口

public class Landlord implements House{
    @Override
    public void saleHouse() {
        System.out.println("可供出售房源！");
    }

    @Override
    public void rentHouse() {
        System.out.println("可供出租房源！");
    }
}

问题：

• 房东没有人际关系找不到要租房或买房的人，于是找到了中介 =》代理对象
• 中介需要获取房东的房源给客户 =》实现接口
• 虽然房东只想要把房源出售和出租很简单的流程，但是中介为了保证双方的理由，在租房或售房之前需要签订合同，保证双方的合法利用 =》前置通知（功能增强）

public class HouseProxy implements House{
    @Override
    public void saleHouse() {
      	//业务增强
        System.out.println("before:签订售房合同");
      	//调用目标
        new Landlord().saleHouse();
    }

    @Override
    public void rentHouse() {
      	//业务增强
        System.out.println("before:签订租房合同");
      	//调用目标
        new Landlord().rentHouse();
    }
}

代理对象执行结果

jdk动态代理（优化一）

上面的代码把功能增强 的代码和调用目标 的代码都固定在了代理类的内部，不太灵活

新增一个自定义接口:MyHandler

/*
* 注意作用：实现动态代理的代码解耦
* */
public interface MyHandler {
    void myInvoke();
}

修改代理类，注入上述接口

package top.jacktgq.proxy.jdk.mock.test;

import top.jacktgq.proxy.jdk.mock.test01.MyHandler;

public class HouseProxy implements House{
    //注入新增接口
    private MyHandler myHandler;

    //添加有参构造来创建代理类
    public HouseProxy(MyHandler myHandler) {
        this.myHandler = myHandler;
    }

    @Override
    public void saleHouse() {
//        System.out.println("before:签订售房合同");
//        new Landlord().saleHouse();
        
        //调用新增接口定义的方法
        myHandler.myInvoke();
    }

    @Override
    public void rentHouse() {
        System.out.println("before:签订租房合同");
        new Landlord().rentHouse();
    }
}

代理对象执行结果

jdk动态代理（优化二）

第2个版本的代码虽然将功能增强的代码和调用目标的代码通过接口的方式独立出来了，但还是有问题，如果此时House接口中新增了一个rentHouse()方法，要想使用代理对象调用执行rentHouse()方法，就需要将该方法在接口实现类Landlord和代理类中进行重写，并生成代理对象时进行调用和执行，也不太灵活

修改MyHandler接口

/*
* 注意作用：实现动态代理的代码解耦
* */
public interface MyHandler {
    //优化前
//    void myInvoke();

    //优化后，可以接收参数
    /*
    * 将想要执行的方法作为匿名内部类执行体，然后匿名内部类作为参数传递给代理对象，最后执行
    * */
    void myInvoke(Method method,Object[] args) throws InvocationTargetException, IllegalAccessException;
}

修改Landlord的代理类

public class HouseProxyPlus implements House {
    static Method method1;
    static Method method2;
    static {
        try {
            method1 = Landlord.class.getDeclaredMethod("saleHouse");
            method2 = Landlord.class.getDeclaredMethod("rentHouse");
        } catch (NoSuchMethodException e) {
            throw new NoSuchFieldError(e.getMessage());
        }
    }

    private MyHandler myHandler;

    public HouseProxyPlus(MyHandler myHandler) {
        this.myHandler = myHandler;
    }

    @Override
    public void saleHouse() {
        try {
            myHandler.myInvoke(method1,null);
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void rentHouse() {
        try {
            myHandler.myInvoke(method2,null);
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

代理对象执行结果

总结：

​ 以上几个版本就是大致jdk动态代理的实例推导，上述优化的版本的代码其实已经离jdk动态代理生成的代码很相近了，再更改一下MyHandler 接口的myInvoke 方法的返回值类型即可

Cglib动态代理

//接口
public interface House {
    //销售房屋
    void saleHouse();
    //出租房屋
    void rentHouse();
}

//实现类（即将要被代理的类）
public class Landlord implements House{
    @Override
    public void saleHouse() {
        System.out.println("可供出售房源！");
    }

    @Override
    public void rentHouse() {
        System.out.println("可供出租房源！");
    }
}

//cglib代理类
public class HouseCglibProxy extends Landlord {
    private MethodInterceptor methodInterceptor;

    public HouseCglibProxy(MethodInterceptor methodInterceptor) {
        this.methodInterceptor = methodInterceptor;
    }

    static Method method;
    static {
        try {
            method = Landlord.class.getDeclaredMethod("saleHouse");
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }

    @Override
    public void saleHouse() {
        /*
        * 参数一：代理对象
        * 参数二：要调研的目标方法
        * 参数三：方法参数
        * */
        try {
            methodInterceptor.intercept(this,method,new Object[0],null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
//        super.saleHouse();
    }

    @Override
    public void rentHouse() {
        super.rentHouse();
    }
}

执行结果

总结

jdk动态代理和cglib动态代理的区别

• 使用jdk动态代理生成的代理类与目标类（也就是被代理的原对象）之间是兄弟关系；使用cglib动态代理生成的代理类与目标类之间是父子关系
• 总结上一句话，其本质jdk动态代理是基于接口实现的（目标类实现的接口）；cglib动态代理是基于类实现的（目标类）