设计模式-代理

Marlowe
设计模式

发布于：Nov 27, 2020
次浏览

1.3k words

5 min

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

介绍

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
20201127165600

主要解决的问题

在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

优缺点及注意

优点

  1. 职责清晰。
  2. 高扩展性。
  3. 智能化。

    缺点

  4. 由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。
  5. 实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

注意

  1. 和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。
  2. 和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

实现

静态代理

角色分析:

  • 抽象角色：一般会使用接口或者抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
  • 客户：访问代理对象的人！
  1. 接口
    1
    2
    3
    4
    5
    6
    7
    public interface Rent {

        /**
         * 出租房屋
         */
        public void rent();
    }
  2. 真实角色
    1
    2
    3
    4
    5
    6
    public class Landlord implements Rent {
        @Override
        public void rent() {
            System.out.println("房东要出租房子！");
        }
    }
  3. 代理角色
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    public class Proxy implements Rent {

        private Landlord landlord;

        public Proxy() {
        }

        public Proxy(Landlord landlord) {
            this.landlord = landlord;
        }

        @Override
        public void rent() {
            seeHouse();
            landlord.rent();
            signContract();
            fee();
        }

        public void seeHouse() {
            System.out.println("中介带你看房");
        }

        public void signContract() {
            System.out.println("签合同");
        }

        public void fee() {
            System.out.println("收中介费");
        }
    }
  4. 客户端访问代理角色
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Client {
        public static void main(String[] args) {
            // 房东要租房子
            Landlord landlord = new Landlord();
            // 代理,中介帮房东租房子，但是 代理一般会有一些附属操作
            Proxy proxy = new Proxy(landlord);
            // 你不用面对房东，直接找中介即可
            proxy.rent();
        }
    }

    1
    2
    3
    4
    5
    结果：
    中介带你看房
    房东要出租房子！
    签合同
    收中介费

    Spring AOP

    20201127183353

代理模式的好处：

  • 可以是真实角色的操作更加纯粹！不用去关注一些公共的业务
  • 公共也就交给代理角色！实现了业务的分工！
  • 公共业务发生扩展的时候，方便集中管理！

缺点：

  • 一个真实的角色就会产生一个代理角色；代码量会翻倍，开发效率会变低~

动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的，不是我们直接写好的！
  • 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
    • 基于接口 — JDK动态代理
    • 基于类：cglib
    • java字节码实现：javasist

需要两节两个类：Proxy，InvocationHandler：调用处理程序

动态代理的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
  • 公共也就交给代理角色！实现了业务的分工！
  • 公共业务发生扩展的时候，方便集中管理！
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可以代理多个类，只要实现了同一接口即可。
  1. 接口
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public interface UserService {
        public void add();

        public void delete();

        public void update();

        public void query();
    }
  2. 实现类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    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("查询了一个用户");
        }
    }
  3. 动态代理工具类（通用方法）
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    public class ProxyInvocationHandlerUtil implements InvocationHandler {

        /**
         * 被代理的接口
         */
        private Object target;
        
        public void setTarget(Object target) {
            this.target = target;
        }

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

        /**
         * 处理代理实例，并返回结果
         *
         * @param proxy
         * @param method
         * @param args
         * @return
         * @throws Throwable
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            log(method.getName());
            Object result = method.invoke(target, args);
            return result;
        }

        public void log(String msg) {
            System.out.println("[Debug] 使用了" + msg + "方法");
        }
    }
  4. 客户端访问代理角色
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Client2 {
        public static void main(String[] args) {
            // 真实角色
            UserServiceImpl userService = new UserServiceImpl();
            // 代理角色，不存在
            ProxyInvocationHandlerUtil pihu = new ProxyInvocationHandlerUtil();
            // 设置需要代理的对象
            pihu.setTarget(userService);
            // 动态生成代理类
            UserService proxy = (UserService) pihu.getProxy();
            proxy.add();
        }
    }
    1
    2
    3
    结果：
    [Debug] 使用了add方法
    增加了一个用户

博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议

本文永久链接是：https://xmmarlowe.github.io/2020/11/27/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E4%BB%A3%E7%90%86/

Marlowe

更新于：Mar 17, 2021

评论