设计模式-委托模式

>>强大,10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程!

模式定义

温馨提示:内容较多建议收藏阅读,大约需要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)角色)
*/

public interface MemberStrategy {

/**
* 计算图书的价格
* @param booksPrice 原书价格
* @return 打折后的价格
*/

double calcPrice(double booksPrice);
}

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

/**
* 具体策略(ConcreteStrategy)角色
* 初级会员折扣具体策略
*/

public class PrimaryMemberStrategy implements MemberStrategy {

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

/**
* 中级会员折扣策略
*/

public class IntermediteMemberStrategy implements MemberStrategy {

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


/**
* 高级会员折扣策略
*/

public class AdvanceMemberStrategy implements MemberStrategy {

@Override
public double calcPrice(double booksPrice) {
return booksPrice * 0.8;
}
}

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

/**
* 环境(Context)角色:持有一个Strategy的引用。
* Created by unique on 2017/6/1.
*/

public class 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;
}
}

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

public class 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);
}

}

打印结果如下所示:

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

委派模式

主要角色

  • DispatcherServlet:持有所有策略的引用,当收到请求时委派给对应合适的策略处理并返回结果。

  • 抽象策略(Strategy)角色:这是一个抽象角色,通常由一个接口或抽象类实现。

  • 具体策略(ConcreteStrategy)角色:包装了相关的算法或行为。

现在我们回到委派模式,其实跟策略模式很像,区别就是委派模式的 DispatcherServlet 持有所有的委托类引用。

场景使用

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

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

代码实现如下

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

/**
* 执行的接口
*/

public interface IExcuter {
void execute(String command);
}

/**
* 程序猿A执行的工作
*/

public class ExcuterA implements IExcuter {

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

/**
* 程序猿B执行的任务
*/

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

接着定义我们的 产品经理

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

public class 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);
}
}

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

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

最后我们查看打印结果

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

总结

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

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

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

关注、转发、点赞收藏,我的两小时编写换你一秒的随手关注、转发、点赞收藏


原文始发于微信公众号(JavaStorm):设计模式-委托模式