JAVA结构型模式-- 你必须要会的代理模式

一、引言

    前段时间，天天在家练车，考驾照，马上考试科目二了~

    没有学习的这段时间真的很焦虑，也没工作，钱包里的RMB已经满足不了我的生活了~

    我觉得有句话说得很对， “ 行动力强可以抗焦虑 ” ~

    好了！不扯淡了，进入今天的主题...... 

二、 什么是代理模式 ？

   为了一个对象提供了一个替身，已控制对这个对象的访问。即通过代理对象访问目标对象，这样做的好处就是：可以在原有对象目标的基础上增加额外的功能（比如：校验信息、日志记录），而不改变现有的代码，符合开闭原则。

 

三、思路图

 

角色分析：

• 抽象角色：一般使用接口或者抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户: 访问代理对象的人 ~

四、静态代理

案例一： 上面租房的案例，可以参照上面的思路图

注意点：代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的

方法。

步骤一：定义租房的接口（或抽象类）

/**
 * @Author WangYan
 * @Date 2022/9/5 14:54
 * @Version 1.0
 * 租房
 */
public interface Rent {

    void rent();
}

步骤二：被代理的角色 （真实角色）

/**
 * @Author WangYan
 * @Date 2022/9/5 14:56
 * @Version 1.0
 * 真实角色 : 被代理的角色
 */
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东需要出租房屋!");
    }
}

步骤三：代理类，也要实现相同接口，并且聚合目标类。( 在原本 " 中介带你看房子 " 的方法上，添加了新功能，实现了开闭原则 )

/**
 * @Author WangYan
 * @Date 2022/9/5 14:57
 * @Version 1.0
 * 代理角色 : 代理真实角色
 */
public class Proxy implements Rent {

    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        System.out.println("中介带你看房子~");
        host.rent();
        System.out.println("中介赚取费用！");
    }
}

步骤四： Test测试

/**
 * @Author WangYan
 * @Date 2022/9/5 14:59
 * @Version 1.0
 * 客户端 : Test测试
 */
public class Test {
    public static void main(String[] args) {
        // 房东
        Host host = new Host();

        // 代理角色
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

案例二： 在增删改查中，添加个记录日志的方法

步骤一：CRUD接口

/**
 * @Author WangYan
 * @Date 2022/9/5 18:41
 * @Version 1.0
 * CRUD接口
 */
public interface UserService {

    void add();

    void delete();

    void update();

    void query();
}

步骤二：真实角色

/**
 * @Author WangYan
 * @Date 2022/9/5 18:41
 * @Version 1.0
 * 真实角色
 */
public class UserServiceImpl implements UserService {

    @Override
    public void add() {
        System.out.println("添加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}

步骤三：静态代理，继承接口类

/**
 * @Author WangYan
 * @Date 2022/9/5 18:42
 * @Version 1.0
 * 静态代理
 */
public class UserServiceProxy implements UserService {

    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }


    @Override
    public void add() {
        userService.add();
        log("添加");
    }

    @Override
    public void delete() {
        userService.delete();
        log("删除");
    }

    @Override
    public void update() {
        userService.update();
        log("修改");
    }

    @Override
    public void query() {
        userService.query();
        log("查询");
    }

    public void log(String msg){
        System.out.println("【DEBUG】" + msg + "用户");
    }
}

步骤四：Test测试

/**
 * @Author WangYan
 * @Date 2022/9/5 18:48
 * @Version 1.0
 * Test 测试
 */
public class Test {
    public static void main(String[] args) {
        // 真实角色
        UserServiceImpl userService = new UserServiceImpl();

        // 代理
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);
        userServiceProxy.delete();
    }
}

五、动态代理

动态代理和静态代理角色一样

动态代理的代理类是动态生成的，不是我们直接写好的 ！

动态代理分为两大类 ： 基于接口的动态代理 、 基于类的动态代理

比如 ：基础接口 ： jdk动态代理 、基于类 ： cglib

静态代理和动态代理最大的区别 ： 动态代理类不需要实现相同的接口或继承相同的父类。

这里就只展示代理类，其他的代码和静态代理一样 ~

/**
 * @Author WangYan
 * @Date 2022/9/5 22:29
 * @Version 1.0
 * 动态代理
 */
public class ProxyInvocationHandler implements InvocationHandler {

    // 目标对象
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    // 生成得到的代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    // 处理代理实例,并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String name = method.getName();
        System.out.println("执行的方法名称:" + name);
        Object invoke = method.invoke(target, args);
        return invoke;
    }
}

六、总结

       不管是静态代理、动态代理。他们都是为一个对象提供一个替身，来控制这个对象的访问。就是通过代理类来访问目标类，这样做的好处就是可以在目标基础之上，增加额外的功能操作，不改变现有的代码。实现了开闭原则。

静态代理：实现比较简单，目标类和代理类都需要实现相同的方法或者父类，维护比较麻烦。

动态代理：代理对象需要实现InvocationHandler接口，动态代理将目标对象和代理对象进行了解耦。（来自我廖哥的总结：https://jiannan.blog.csdn.net/article/details/103386878）

拜拜~

有任何问题欢迎大家指出~

Thank You !