代理模式简介

一、静态代理

/**
 * @description: 父类
 * @author:mrzhang
 * @createTime:2021/4/26 8:19
 * @version:1.0
 */
public interface ParentInterface {
    void money();
}

/**
 * @description: 房东
 * @author:mrzhang
 * @createTime:2021/4/26 8:19
 * @version:1.0
 */
public class Owner implements ParentInterface{
    public void money(){
        System.out.println("躺着挣钱");
    }
}

/**
 * @description: 中介(静态代理)
 * @author:mrzhang
 * @createTime:2021/4/26 8:21
 * @version:1.0
 */
public class Medium implements ParentInterface{
    private Owner owner;


    public Medium(Owner owner) {
        this.owner = owner;
    }

    @Override
    public void money() {
        System.out.println("约谈客户");
        System.out.println("签合同");
        owner.money();
    }
}

public class PoxyTest {
    public static void main(String[] args) {
        //静态代理
        Owner owner=new Owner();
        Medium medium=new Medium(owner);
        medium.money();

    }
}

二、动态代理

2.1、 jdk动态代理

1、InvocationHandler：
invoke方法:调用目标方法；功能增强；
参数：proxy：jdk创建的代理对象、method：目标类中的方法（反射机制获取对象方法并执行）、args：方法参数数组；
2、Proxy类：
newProxyInstance方法： 返回代理类一个实例（代理对象）。
参数：ClassLoader:类加载器，负责向内存中加载对象(目标对象)，使用反射获取对象的ClassLoader；interfaces:目标对象实现的接口，也是反射获取的。InvocationHandler：代理类要完成的功能。

/**
 * @description: 中介（jdk动态代理）
 * @author:mrzhang
 * @createTime:2021/4/26 8:27
 * @version:1.0
 */
public class Medium01 {
    //引用委托类，与代理类联系在一起
    private Object object;
    public Medium01(Object object) {
        this.object=object;
    }
    public Object getProxyInstance(){
        ClassLoader classLoader=object.getClass().getClassLoader();
        return Proxy.newProxyInstance(classLoader, object.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("约谈客户");
                        System.out.println("签合同");
                        Object invoke=method.invoke(object,args);
                        return invoke;
                    }
                });
    }
}

public class PoxyTest {
    public static void main(String[] args) {
        //静态代理
        //        Owner owner=new Owner();
        //        Medium medium=new Medium(owner);
        //        medium.money();
        //jdk动态代理
        Owner owner=new Owner();
        ParentInterface parentInterface=(ParentInterface) new Medium01(owner).getProxyInstance();
        parentInterface.money();
    }
}

2.2、 cglib动态代理

原理：继承，通过继承目标类，创建它的子类，在子类中重写父类同名的方法，实现功能的修改。

/**
 * @description: 中介（cglib）
 * @author:mrzhang
 * @createTime:2021/4/26 9:24
 * @version:1.0
 */
public class Medium03 implements MethodInterceptor {
    private Object object;

    public Medium03(Object object) {
        this.object = object;
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("约谈客户");
        System.out.println("签合同");
        Object invoke=method.invoke(object,objects);
        return invoke;
    }

    /**
     * 创建代理类
     */
    public Object getProxyInstance(){
        Enhancer en=new Enhancer();
        //设置委托类的字节码
        en.setSuperclass(object.getClass());
        //设置回调函数
        en.setCallback(this);
        //创建代理类
        return en.create();
    }
}

public class PoxyTest {
    public static void main(String[] args) {
        //静态代理
        //        Owner owner=new Owner();
        //        Medium medium=new Medium(owner);
        //        medium.money();
        //jdk动态代理
        //        Owner owner=new Owner();
        //        ParentInterface parentInterface=(ParentInterface) new Medium01(owner).getProxyInstance();
        //        parentInterface.money();
        //cglib动态
        Owner owner=new Owner();
        Owner proxyInstance=(Owner) new Medium03(owner).getProxyInstance();
        proxyInstance.money();
    }

}

2.3、 两者的区别

jdk:
1.只能代理实现类接口的类；
2.没有实现接口的类不能实现jdk的动态代理;
3.目标对象和代理对象同时实现类的接口。

cglib:
1.针对类实现代理；
2.对指定目标产生一个子类，通过方法拦截技术拦截所有父类方法调用；
3.代理对象继承目标对象。

三、反射机制

/**
 * @description: 反射机制
 * @author:mrzhang
 * @createTime:2021/4/26 10:39
 * @version:1.0
 */
public class InvokeTest {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Invoke invoke=new InvokeImpl();
        Method method=Invoke.class.getMethod("say",String.class);
        Object ret=method.invoke(invoke,"zhangsan");
    }
}