1998 年出版的《设计模式——可复用面向对象软件的基础》有资格成为计算机科学的经典著作，大学仍然将它作为教材，并被奉为业界的最佳实践。在 Devoxx 的一场深度讨论中，Venkat Subramaniam使用现代 Java 实现了迭代器、策略、装饰器或工厂方法模式，对原有的设计模式进行了一番调整。
在讨论的引言部分，Subramaniam 表示这本书的作者是软件开发的祖父，他们的设计模式是祖母的食谱——但即使你有了这些食谱，也不一定能做出这些菜。因此，他认为将设计模式作为一种沟通工具是有意义的，但将其作为一种软件设计工具却是一场灾难。
以下是我们在日常编程中可能遇到的常见模式，Subramaniam 通过充满活力和快乐的方式让这些模式变得更加流式。
由于 Java 加入了函数式编程，迭代器模式发生了很大的变化。最大的一个变化是从外部迭代器到内部迭代器的转变，这是 Java 函数式 API 带来的。这个变化可以让你从使用冗长的命令式迭代
int count = 0;for(var name: names) { if(name.length() == 4) { System.out.println(name.toUpperCase()); count++;
if(count == 2) { break; } } }}
复制代码
演变成使用流式的函数式迭代
names.stream() .filter(name -> name.length() == 4) .map(String::toUpperCase) .limit(2) .forEach(System.out::println);
复制代码
limit(long)和takeWhile(Predicate<? super T>)（在 Java 9 中添加的）是continue和break语句的等效函数，第一个只接受数值限制参数，而第二个可以接受表达式。
尽管 Java 的函数式 API 作为 JDK 的一部分已经有近十年的时间了，但在代码库中仍然存在一些常见的错误。当函数管道“不”纯粹（修改或依赖外部可见的状态）时，可能会导致迭代操作的结果不可预测（特别是在进行并行执行时）。
策略模式——我们希望改变算法的一小部分，同时保持算法的其余部分不变。从历史上看，这个模式是通过一个方法来实现的，这个方法采用一个方法接口作为参数，作为参数的方法接口可以有多个策略实现，一个策略通常就是一个方法或函数。因此，函数式接口和 lambda 表达式在这里很适用。
虽然匿名类可以作为一种实现机制，但函数接口（Predicate<? super T>是一个很好的选择）或 lambda 表达式让代码变得更加流式，更容易理解。在现代 Java 中，策略模式更多的是一种特性，而不是需要付出大量努力才能实现的模式。
public class Sample { public static int totalValues(List<Integer> numbers) { int total = 0;
for(var number: numbers) { total += number; }
return total; }
public static int totalEvenValues(List<Integer> numbers) { int total = 0;
for(var number: numbers) { if(number % 2 == 0) { total += number; } }
return total; }
public static int totalOddValues(List<Integer> numbers) { int total = 0;
for(var number: numbers) { if(number % 2 != 0) { total += number; } }
return total; }
public static void main(String[] args) { var numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(totalValues(numbers)); System.out.println(totalEvenValues(numbers)); System.out.println(totalOddValues(numbers)); }}
复制代码
现代的做法是使用 lambda 表达式来表示策略。
import java.util.function.Predicate;
public class Sample { public static int totalValues(List<Integer> numbers, Predicate<Integer> selector) { int total = 0;
for(var number: numbers) { if(selector.test(number)) { total += number; } }
return total; }
public static boolean isOdd(int number) { return number % 2 != 0; }
public static void main(String[] args) { var numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(totalValues(numbers, ignore -> true)); System.out.println(totalValues(numbers, number -> number % 2 == 0));
System.out.println(totalValues(numbers, Sample::isOdd)); }}
复制代码
在介绍工厂方法实现时，Venkat 陈述了以下内容。
从多态的角度来看，Java 中最糟糕的关键字是什么？尽管 final、instanceof 和 static 都可能算是最糟糕的关键字，但它们都只是小兵，new才是它们当中的黑手党。多模式（创建模式）、框架（Spring、Guice）是为了解决 new 的“弊端”——缺乏多态性支持和紧密耦合。受Ruby基于上下文创建不同对象的多态能力的启发，Venkat 使用 Java 的default关键字实现工厂方法模式。这种方法使用了接口和非常小的实现类，让代码变得更容易理解。
import java.util.*;
interface Pet {}class Dog implements Pet {}class Cat implements Pet {}
interface Person { Pet getPet();
default void play() { System.out.println("playing with " + getPet()); }}
class DogPerson implements Person { private Dog dog = new Dog();
public Pet getPet() { return dog; }}
class CatLover implements Person { private Cat cat = new Cat(); public Pet getPet() { return cat; }}
public class Sample { public static void call(Person person) { person.play(); }
public static void main(String[] args) { call(new DogPerson()); call(new CatLover()); }}
复制代码
即使装饰器模式在理论上为许多程序员所熟知，但实际上很少有人使用它。它的实现最臭名昭著的例子可能是 io 包。Venkat 基于函数的可组合性提出了一种不同的方法——使用identity函数和andThen(Function<? super R,? extends V>)构建简单、流式的机制来增强对象的能力。
class Camera { private Function<Color, Color> filter;
public Camera(Function<Color, Color>... filters) { filter = Stream.of(filters) .reduce(Function.identity(), Function::andThen); }
public Color snap(Color input) { return filter.apply(input); }}
public class Sample { public static void print(Camera camera) { System.out.println(camera.snap(new Color(125, 125, 125))); }
public static void main(String[] args) { print(new Camera());
print(new Camera(Color::brighter)); print(new Camera(Color::darker));
print(new Camera(Color::brighter, Color::darker)); }}
复制代码
即使模式看起来会一直存在，就像 Subramaniam在讨论中提到的：“设计模式经常被用来填补编程语言的空白。一门语言越强大，我们就越少谈论设计模式，因为设计模式自然会成为语言的特性。”
随着编程语言的演进和我们经验的积累，模式也会随着时间的推移而演变。其中一些模式被吸收为语言的特性，另一些则被认为已过时，而另一些变得更加容易实现。不管你最喜欢的是哪一类，Venkat 建议把它们作为交流的手段，并让代码朝着这些模式的方向演变。此外，他建议尝试使用多种编程语言，让代码变得更加流式。
原文链接：
https://www.infoq.com/news/2022/10/modern-java-design-patterns/
评论