设计模式-委托模式

大家好我是佩奇

发布于 2022-8-5 17:43

浏览

0收藏

模式定义

温馨提示：内容较多建议收藏阅读，大约需要5分钟。

代码可在GitHub中阅读：欢迎star。https://github.com/UniqueDong/zero-design-patterns

在常用的23种设计模式中其实面没有委派模式（delegate）的影子，但是在 Spring 中委派模式确实用的比较多的一种模式，Spring MVC 框架中的DispatcherServlet其实就用到了委派模式

其实我个人的理解就是一个特殊的静态代理模式，只不过加入了策略模式，我们看下面的图。

策略模式的环境上下文角色只有一个策略抽象的引用，然后根据条件设置对应的策略调用。而委托持有所有的策略，根据条件去将请求委托到对应的实现类中执行。

设计模式-委托模式-鸿蒙开发者社区

委派模式

策略模式
我们通过一个简单例子来看看策略模式：它只只有一个策略的引用，根据不同场景切换策略。

● 环境(Context)角色：持有一个Strategy的引用。
● 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。
● 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

使用场景
假设现在要设计一个贩卖各类书籍的电子商务网站的购物车系统。

一个最简单的情况就是把所有货品的单价乘上数量，但是实际情况肯定比这要复杂。

比如，本网站可能对所有的高级会员提供每本20%的促销折扣；对中级会员提供每本10%的促销折扣；对初级会员没有折扣。

根据描述，折扣是根据以下的几个算法中的一个进行的：

● 算法一：对初级会员没有折扣。
● 算法二：对中级会员提供10%的促销折扣。
● 算法三：对高级会员提供20%的促销折扣。
代码实现如下：定义抽象策略角色

/**
 * 抽象折扣类(抽象策略(Strategy)角色)
 */
publicinterface MemberStrategy {

    /**
     * 计算图书的价格
     * @param booksPrice 原书价格
     * @return 打折后的价格
     */
    double calcPrice(double booksPrice);
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

然后定义我们针对不同会员的折扣算法实现

/**
 * 具体策略(ConcreteStrategy)角色
 * 初级会员折扣具体策略
 */
publicclass PrimaryMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        System.out.println("对初级会员没有打折");
        return booksPrice;
    }
}

/**
 * 中级会员折扣策略
 */
publicclass IntermediteMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        System.out.println("对于中级会员的折扣为10%");
        return booksPrice * 0.9;
    }
}


/**
 * 高级会员折扣策略
 */
publicclass AdvanceMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        return booksPrice * 0.8;
    }
}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.

最后我们还需定义个策略上下文角色，它只有一个抽象策略的引用。

/**
 * 环境(Context)角色:持有一个Strategy的引用。
 * Created by unique on 2017/6/1.
 */
publicclass PriceContext {
    /**
     * 持有一个具体的策略对象
     */
    private MemberStrategy memberStrategy;

    /**
     * 构造方法，传入一个具体策略
     * @param memberStrategy
     */
    public PriceContext(MemberStrategy memberStrategy) {
        this.memberStrategy = memberStrategy;
    }

    /**
     * 计算图书的价格
     * @param booksPrice
     * @return
     */
    public double calcPrice(double booksPrice) {
        return memberStrategy.calcPrice(booksPrice);
    }

    public void setMemberStrategy(MemberStrategy memberStrategy) {
        this.memberStrategy = memberStrategy;
    }
}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.

最后我们编写客户端来模拟

publicclass Clinet {
    public static void main(String[] args) {
        //选择并创建所要的策略
        MemberStrategy strategy = new AdvanceMemberStrategy();

        //创建环境
        PriceContext context = new PriceContext(strategy);
        double booksPrice = 500.98;
        double price = context.calcPrice(booksPrice);
        System.out.println("图书的原价:" + booksPrice + "打折后的最终价格：" + price);

        System.out.println("----切换会员----");
        strategy = new PrimaryMemberStrategy();
        context.setMemberStrategy(strategy);

        price = context.calcPrice(booksPrice);
        System.out.println("图书的原价:" + booksPrice + "打折后的最终价格：" + price);
    }

}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

打印结果如下所示：

书的原价:500.98打折后的最终价格：400.78400000000005
----切换会员----
对初级会员没有打折
图书的原价:500.98打折后的最终价格：500.981.
2.
3.
4.

委派模式
主要角色
● DispatcherServlet：持有所有策略的引用，当收到请求时委派给对应合适的策略处理并返回结果。
● 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。
● 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。
现在我们回到委派模式，其实跟策略模式很像，区别就是委派模式的 DispatcherServlet 持有所有的委托类引用。

场景使用
假设现在 Boss 点子来了想做一个根据手机外壳来改变 app 主题样式功能。这个时候就把任务交给了产品经理，产品经理就找来程序猿委托开发小哥哥去分工实现。这样Boss就是一个请求，而产品经理就是一个 dispatcherSevlet 。

boss把任务给 leader, 而 leader 做了一个任务的分配和调度的工作，自己没有做工作，而是把具体工作交给具体的执行者去做。

代码实现如下

首先定义我们的任务执行角色,以及各自分工任务的程序猿

/**
 * 执行的接口
 */
publicinterface IExcuter {
    void execute(String command);
}

/**
 * 程序猿A执行的工作
 */
publicclass ExcuterA implements IExcuter {

    @Override
    public void execute(String command) {
        System.out.println("员工A 开始做" + command + "的工作");
    }
}

/**
 * 程序猿B执行的任务
 */
publicclass ExcuterB implements IExcuter {
    @Override
    public void execute(String command) {
        System.out.println("员工B 开始做" + command + "的工作");
    }
}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.

接着定义我们的产品经理

/**
 * @description: leader 委派者   任务分发的作用
 * @ModificationHistory who      when       What
 **/
publicclass LeaderDispatch {

    private Map<String, IExcuter> targets = new HashMap<String, IExcuter>();

    public Leader() {
        targets.put("识别颜色", new ExcuterA());
        targets.put("切换主题", new ExcuterB());
    }

    
    public void dispatch (String command) {
        //根据指令委托到对应的执行者
        targets.get(command).execute(command);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

最后我们模拟boss发送指令实现功能

publicclass Boss {
    public static void main(String[] args) {
        LeaderDispatch leader = new LeaderDispatch();
        //看上去好像是我们的项目经理在干活
        //但实际干活的人是普通员工
        //这就是典型，干活是我的，功劳是你的
        leader.execute("识别颜色");
        leader.execute("切换主题");
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

最后我们查看打印结果

员工B 开始做登录的工作
员工A 开始做加密的工作1.
2.

总结
通过此文我们重新复习了策略模式，通过策略模式演化出委托模式。

Spring MVC框架中的DispatcherServlet其实就是用到的委派模式，针对之前的MVC执行流程无法理解的HandlerMapping其实就是这里的项目经理维护的各个员工的信息。

上述实例中，为了简单，直接在构造函数中维护了相关实例的引用，但是在具体的HandlerMapping 中，这一步显然要复杂的多。

文章转载自公众号：码哥字节

分类

标签

已于2022-8-5 17:43:39修改

51CTO

51CTO博客

51CTO学堂

设计模式-委托模式

订阅鸿蒙技术特刊，精选内容抢先看