三、spring——动态代理模式（AOP）

大神：https://blog.csdn.net/jiankunking/article/details/52143504?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase#%E5%9B%9B%E3%80%81%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86%E6%80%8E%E4%B9%88%E5%AE%9E%E7%8E%B0%E7%9A%84%EF%BC%9F

大神：https://www.cnblogs.com/gonjan-blog/p/6685611.html

参考：https://blog.csdn.net/lz1170063911/article/details/79835248

一、JDK动态代理

租房为例

1、定义接口：

//定义我们需要完成租房的事情
public interface LetRoom {
    void zf();
}

2、定义2个房东，继承租房

public class FD implements LetRoom{
    @Override
    public void zf() {
        System.out.println("--出租1号楼4层拐角厕所男--");
    }
}

public class FD2 implements LetRoom{
    @Override
    public void zf() {
        System.out.println("--出租2号楼2层拐角厕所男--");
    }
}

3、定义代理类（中介）

public class MyInv implements InvocationHandler {
    private LetRoom letRoom;

    public LetRoom getLetRoom() {
        return letRoom;
    }

    public void setLetRoom(LetRoom letRoom) {
        this.letRoom = letRoom;
    }

    //执行改方法就会动态产生代理对象
    public Object getProxy(){
        /**
         *
         *  参数一：保证类型是ClassLoader
         *
         *  参数二：接口的class数组
         *
         *  参数三：参数类型是InvocationHandler即可
         *
         * */
        Object obj = Proxy.newProxyInstance(MyInv.class.getClassLoader(), new Class[]{LetRoom.class}, this);
        return obj;
    }


    //这个方法就类似于书写中介中的zf()
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /**
         * proxy:代理对象--中介
         *
         * method:代理对象中的方法
         *
         * args：参数--null；
         *
         * */
        System.out.println("---收取推荐费100元--");

        Object invoke = method.invoke(letRoom, args);

        System.out.println("---收取管理费费500元--");
        return invoke;
    }
}

4、测试（我要租房子了）

public class Test {
    public static void main(String[] args) {
        MyInv my = new MyInv();
        //设置具体的房东
        my.setLetRoom(new FD2());
        //产生了中介代理对象，动态产生
        LetRoom letroom =(LetRoom) my.getProxy();
        letroom.zf();
        Util.writeProxyClassToHardDisk("E:/$Proxy11.class",new FD2().getClass().getInterfaces() );  //生成class文件，通过反编译查看编译思路
    }
}

 二、cglib动态代理

1、定义房东

public class FD {
    public    void   zf(){
        System.out.println("--出租4号楼1层--");
    }
}

2、定义代理类

public class MethodInv implements MethodInterceptor {
    //产生代理类对象
    public Object getProxy(){

        Enhancer en = new Enhancer();
        //类似于之前的接口
        en.setSuperclass(FD.class);
        en.setCallback(this);
        //使整个设置的内容生效
        Object o = en.create();
        return o;
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        /**
         * o:被代理对象
         *
         * method:被代理对象的方法
         *
         * objects：参数
         *
         * methodProxy：代理对象中方法
         * */
        System.out.println(method+"---"+objects+"---"+methodProxy);
        System.out.println("--收取管理费100元--");
        //调用真正房东的zf()
        Object o1 = methodProxy.invokeSuper(o, objects);
        System.out.println("--收取管理费500元--");

        return o1;

    }
}

3、测试（我要租房）

public class Test {
    public static void main(String[] args) {
        MethodInv me = new MethodInv();
        FD fd = (FD) me.getProxy();
        fd.zf();
    }
}