本文由知名技术顾问Bruce Eckel撰写，深入探讨了函数对象模式的三个方面：命令模式、策略模式和职责链模式。通过实例展示了如何使用这些模式来封装行为、动态改变算法和创建行为链。文章还提到了Java8的lambda表达式如何简化了命令模式的实现。
Bruce Eckel
读完需要
10
分钟速读仅需 1 分钟
布鲁斯 • 埃克尔（Bruce Eckel），C++ 标准委员会的创始成员之一，知名技术顾问，专注于编程语言和软件系统设计方面的研究，常活跃于世界各大顶级技术研讨会。
他自 1986 年以来，累计出版 Thinking in C++、Thinking in Java、On Java 等十余部经典计算机著作，曾多次荣获 Jolt 最佳图书奖（被誉为“软件业界的奥斯卡”），其代表作 Thinking in Java 被译为中文、日文、俄文、意大利文、波兰文、韩文等十几种语言，在世界范围内产生了广泛影响。
7
函数对象模式
一个函数对象（Function Object）封装一个方法，其目的是将函数的选择和调用函数的位置解耦。
《设计模式》中对“函数对象”这个术语有所提及，但并未使用。不过函数对象的核心思想在该书的若干模式中反复出现过。
7.1
命令模式
这种模式是函数对象最纯粹的形式：一个身为对象的方法。将一个函数对象作为参数传递，它便会生成不同的行为。
命令（Command）模式在本书前面的若干地方描述过，主要包括以下几章：
基础卷第 11 章
基础卷第 19 章
进阶卷第 1 章
在下面这个示例中，show()的代码保持不变，改变的是传给 show()的 Comand 对象：
// patterns/CommandPattern.java
import java.util.*;
class Command {
public final String msg;
public Command(String msg) {
this.msg = msg;
}
}
public class CommandPattern {
public static void show(Command cmd) {
System.out.println(cmd.msg);
}
public static void main(String[] args) {
show(new Command("First Command"));
show(new Command("Second Command"));
}
}
/* 输出：
First Command
Second Command
*/下面是另一个示例，创建了一个命令对象的列表，形成了一个“宏指令”。在Java 8之前的版本中，如果要实现独立函数的效果，就需要额外的繁文缛节，显式地将方法包装到一个对象中。而Java 8的lambda表达式可以创建函数对象，因此命令模式就变得相当简单了：
// patterns/Macro.java
import java.util.*;
public class Macro {
public static void main(String[] args) {
List<Runnable> macro = new ArrayList<>(
Arrays.asList(
() -> System.out.print("Hello "),
() -> System.out.println("World! ")
));
macro.forEach(Runnable::run);
macro.add(
() -> System.out.print("I'm the command pattern!")
);
macro.forEach(Runnable::run);
}
}
/* 输出：
Hello World!
Hello World!
I'm the command pattern!
*/命令模式最主要的一点在于，可以让我们将想要的行为传给一个方法或对象。macro会将一组要集体执行的行为排成一队，这样就可以动态地创建行为了，而这本来一般都需要编写新的代码来实现。
Macro.java经过修改后，还可以用来解释脚本，参见解释器（Interpreter）模式。
《设计模式》中指出：“命令模式是回调的面向对象形式的替代品。”然而我认为“回”字是回调概念的核心本质。也就是说，回调实际上会指回到回调的创建者，命令模式则一般只将命令对象创建出来，然后传给某个方法或对象，而不会随着时间的推移（往回）连接到命令对象上。不过这只是我的个人看法。稍后我会将一组设计模式结合起来，放到本章8.10节中。
7.2
策略模式
策略模式（Strategy）看起来就像命令模式的同胞兄弟，都是从同一个基类继承出来的一组函数对象。区别在于这些对象的使用方式。命令模式用于解决一类特定的问题——例如，通过传入一个描述所需文件的命令对象，从文件列表中选择一个文件。所调用的方法体即“保持不变的事物”，而变化的部分则被隔离在命令对象中。
策略模式包含一段可作为代理类的“上下文”，该代理类用于控制文件的选择以及对特定策略对象的使用——和策略模式很像。它看起来就像下面这样：
// patterns/strategy/StrategyPattern.java
// {java patterns.strategy.StrategyPattern}
package patterns.strategy;
import java.util.function.*;
import java.util.*;
// 公共策略基类：
class FindMinima {
protected
Function<List<Double>, List<Double>> algorithm;
}
// 各种策略，每一个都会生成无意义的数据：
class LeastSquares extends FindMinima {
LeastSquares() {
// Line is a sequence of points:
// 直线是点的序列：
algorithm = (line) -> Arrays.asList(1.1, 2.2);
}
}
class Perturbation extends FindMinima {
Perturbation() {
algorithm = (line) -> Arrays.asList(3.3, 4.4);
}
}
class Bisection extends FindMinima {
Bisection() {
algorithm = (line) -> Arrays.asList(5.5, 6.6);
}
}
// “上下文”控制着策略：
class MinimaSolver {
private FindMinima strategy;
MinimaSolver(FindMinima strategy) {
this.strategy = strategy;
}
List<Double> minima(List<Double> line) {
return strategy.algorithm.apply(line);
}
void changeAlgorithm(FindMinima newAlgorithm) {
strategy = newAlgorithm;
}
}
public class StrategyPattern {
public static void main(String[] args) {
MinimaSolver solver =
new MinimaSolver(new LeastSquares());
List<Double> line = Arrays.asList(
1.0, 2.0, 1.0, 2.0, -1.0,
3.0, 4.0, 5.0, 4.0 );
System.out.println(solver.minima(line));
solver.changeAlgorithm(new Perturbation());
System.out.println(solver.minima(line));
solver.changeAlgorithm(new Bisection());
System.out.println(solver.minima(line));
}
}
/* 输出：
[1.1, 2.2]
[3.3, 4.4]
[5.5, 6.6]
*/MinimaSolver中的changeAlgorithm()将一个不同的策略插入strategy字段，然后minima()就会使用不同的算法了。
可以通过将上下文合并到FindMinima中来简化该方案：
// patterns/strategy/StrategyPattern2.java
// {java patterns.strategy.StrategyPattern2}
package patterns.strategy;
import java.util.function.*;
import java.util.*;
// “上下文”现在合并了：
class FindMinima2 {
private
Function<List<Double>, List<Double>> algorithm;
FindMinima2() { leastSquares(); } // 默认
// 各种策略：
void leastSquares() {
algorithm = (line) -> Arrays.asList(1.1, 2.2);
}
void perturbation() {
algorithm = (line) -> Arrays.asList(3.3, 4.4);
}
void bisection() {
algorithm = (line) -> Arrays.asList(5.5, 6.6);
}
List<Double> minima(List<Double> line) {
return algorithm.apply(line);
}
}
public class StrategyPattern2 {
public static void main(String[] args) {
FindMinima2 solver = new FindMinima2();
List<Double> line = Arrays.asList(
1.0, 2.0, 1.0, 2.0, -1.0,
3.0, 4.0, 5.0, 4.0 );
System.out.println(solver.minima(line));
solver.perturbation();
System.out.println(solver.minima(line));
solver.bisection();
System.out.println(solver.minima(line));
}
}
/* 输出：
[1.1, 2.2]
[3.3, 4.4]
[5.5, 6.6]
*/FindMinima2封装了各种不同的算法，现在还同时包含了上下文，因此可以在单个类中控制算法的选择了。
7.3
职责链模式
这种模式在本书第 1 章中介绍过。
职责链模式（Chain of Responsibility）大概可以被看作用策略对象实现的动态泛化版本的递归。先产生一个调用，然后一系列策略逐个尝试处理该调用。当某个策略处理成功，或者试过所有策略后（都不成功），整个过程结束。在递归过程中，一个方法不断重复调用自身，直到满足某个终结条件。而在职责链模式中，一个方法会调用相同基类的方法的不同实现，后者又会调用该基类方法的另一个实现，以此类推，直到满足终结条件。
不同于通过调用单个方法来处理请求，职责链中的多个方法都有机会处理该请求，因此职责链模式很适用于实现专家系统。职责链是高效的链表结构，因此可以动态地进行创建或修改。也可以将它看作一种更通用的、动态构建的 switch 语句。
你可能想让 StrategyPattern.java 自动尝试不同的算法，直到命中合适的那个。职责链模式提供了实现该功能的途径。Result 是包含一个 success 标签的信使，这样收件人就可以知道该算法是否成功，line 则用来承载实际的数据。如果某个算法失败，则返回 Result.fail：
// patterns/chain/Result.java
// 承载结果或表示失败
package patterns.chain;
import java.util.*;
public class Result {
public final boolean success;
public final List<Double> line;
public Result(List<Double> data) {
success = true;
line = data;
}
private Result() {
success = false;
line = Collections.<Double>emptyList();
}
public static final Result fail = new Result();
}由于失败是预期结果，因此在某个策略失败时，返回Result.fail比抛出异常更加合适。
// patterns/chain/ChainOfResponsibility.java
// {java patterns.chain.ChainOfResponsibility}
package patterns.chain;
import java.util.*;
import java.util.function.*;
interface Algorithm {
Result algorithm(List<Double> line);
}
class FindMinima {
public static Result test(
boolean success, String id, double d1, double d2) {
System.out.println(id);
if(success) // 实际的测试/计算：
return new Result(Arrays.asList(d1, d2));
else // 尝试职责链中的下一个：
return Result.fail;
}
public static Result leastSquares(List<Double> line) {
return test(false, "LeastSquares", 1.1, 2.2);
}
public static Result perturbation(List<Double> line) {
return test(false, "Perturbation", 3.3, 4.4);
}
public static Result bisection(List<Double> line) {
return test(true, "Bisection", 5.5, 6.6);
}
static List<Function<List<Double>, Result>>
algorithms = Arrays.asList(
FindMinima::leastSquares,
FindMinima::perturbation,
FindMinima::bisection
);
public static Result minima(List<Double> line) {
for(Function<List<Double>, Result> alg :
algorithms) {
Result result = alg.apply(line);
if(result.success)
return result;
}
return Result.fail;
}
}
public class ChainOfResponsibility {
public static void main(String[] args) {
FindMinima solver = new FindMinima();
List<Double> line = Arrays.asList(
1.0, 2.0, 1.0, 2.0, -1.0,
3.0, 4.0, 5.0, 4.0);
Result result = solver.minima(line);
if(result.success)
System.out.println(result.line);
else
System.out.println("No algorithm found");
}
}
/* 输出：
LeastSquares
Perturbation
Bisection
[5.5, 6.6]
*/每个Algorithm的实现针对algorithm()方法都有不同的方法。在FindMinima中，创建了一组algorithm的List（这便是职责链的那条“链”），而minima()方法会遍历该List，并找出执行成功的算法。
本书特色
查漏宝典：涵盖Java关键特性的设计原理和应用方法
避坑指南：以产业实践的得失为鉴，指明Java开发者不可不知的设计陷阱
经典普适：值得不同层次的Java开发者反复研读
专家领读：4位一线业务专家、知名作译者帮你拆解书中难点，总结Java开发精要
值得一提的是，为了帮助新手加深理解，出版方邀请了4位从业10年以上知名作译者（DDD 专家张逸、服务端专家梁桂钊、软件系统架构专家王前明、译者陈德伟）为本书录制【精讲视频】和【导读指南】，该视频已在B站和图灵社区发布，感兴趣的朋友可以去看看。
往期推荐
如何在 SpringBoot 项目中控制 RocketMQ消费线程数量
扫一扫
1810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
