代理模式

本篇博客参考于https://www.cnblogs.com/daniels/p/8242592.html

代理模式：
概念：为一个对象提供一个代理对象，由代理对象控制原对象的调用

实际操作图：

具体的实例：就是购买房子
购房者相当于客户类
购房者只需提供购房接口
代理类相当于中介
房屋出售相当于委托类
房屋出售看是否符合购房接口要求
下面主要是通过静态代理来对上面的流程做一个简单的代码展示

/**
 * @Author: Jason
 * @Create: 2019/12/20  8:56
 * @Description 静态代理-购房接口
 * 相当于购房者提出的购房接口
 */

public interface BuyHouse {

    public void buyHouse();
}


/**
 * @Author: Jason
 * @Create: 2019/12/20  8:58
 * @Description 卖房
 * 相当于卖房者-需要实现购房接口
 */
public class SeilHouse implements  BuyHouse{

    @Override
    public void buyHouse() {
        System.out.println("买房");
    }
}


/**
 * @Author: Jason
 * @Create: 2019/12/20  9:00
 * @Description 房产中介方
 * 同样需要实现购房接口
 */
public class HouseProxe implements BuyHouse{

    //注入房屋出售方
    public  SeilHouse seilHouse;

    //有参构造
    public HouseProxe(SeilHouse seilHouse){
        this.seilHouse = seilHouse;
    }
    @Override
    public void buyHouse() {
        System.out.println("购房押金");
        seilHouse.buyHouse();
        System.out.println("房子装修");
    }
}

其实也就是三个步骤
 提供接口------代理类实现接口，委托类实现接口 ------委托类注入到代理类中去

在上面我们谈及到静态代理也就有动态代理机制
静态代理是指：在程序运行之前时，代理类已经创建，这个代理类其实就是指程序员自己手写的一个代理类
动态代理：是指程序在运行时，才去创建代理类，代理类不是程序员自己手写去创建的

/**
 * @Author: Jason
 * @Create: 2019/12/20  10:05
 * @Description 动态处理器
 * 动态处理器编写
 */
public class ProxeHandler implements InvocationHandler {

    //所有的委托类用Object来表示
    private Object object;

    //有参构造方法
    public  ProxeHandler(Object object){
        this.object = object;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("购房前押金");
        Object invoke = method.invoke(object, args);
        System.out.println("装修房子");
        return invoke;
    }
}


/**
 * @Author: Jason
 * @Create: 2019/12/20  10:12
 * @Description 动态代理测试类
 */
public class ProxyTest {
    public static void main(String[] args) {
        BuyHouse  buyHouse = new SeilHouse();
        BuyHouse o = (BuyHouse)Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), new Class[]{BuyHouse.class}, new ProxeHandler(buyHouse));
        o.buyHouse();
    }
}

CGLIB代理其实也是动态代理，只是两者的最大区别在是否实现接口，通过接口来定义业务方法
以及两者的底层技术，jdk是通过反射技术，cglib是通过字节码技术这一点在代理类的代码编写上可以体现出来
cglib：其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。

/**
 * @Author: Jason
 * @Create: 2019/12/20  10:35
 * @Description cglib实现动态代理
 * 这个类就是创建一个子类，并且在子类对父类方法调用进行拦截
 */
public class CglibProxy implements MethodInterceptor {

    private  Object object;

    //获取实例
    public  Object  getInstance(Object object){
        this.object = object;
        Enhancer  enhancer = new Enhancer();
        //设置它的父类类型
        enhancer.setSuperclass(object.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
    

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        method.invoke(object, objects);
        return null;
    }

/**
 * @Author: Jason
 * @Create: 2019/12/20  10:46
 * @Description
 */
public class CglibTest{
    public static void main(String[] args) {
        SeilHouse seilHouse = new SeilHouse();
        CglibProxy  cglibProxy = new  CglibProxy();
        SeilHouse instance = (SeilHouse)cglibProxy.getInstance(seilHouse);
        instance.buyHouse();
    }