使用现代Java调整经典设计模式

深度学习与Python

发布于 2023-03-29 13:48:10

2400

发布于 2023-03-29 13:48:10

文章被收录于专栏：深度学习与python

作者｜ Olimpiu Pop

译者｜明知山

策划｜丁晓昀

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/

声明：本文为InfoQ翻译，未经许可禁止转载。

让小型企业提高 20 倍效率的统一技术栈

60 岁周星驰招聘 Web3.0 人才，要求“宅心仁厚”；马斯克计划裁掉推特 75% 的员工；Linus 致开发者：不要再熬夜了｜ Q 资讯

可能是最严重的云存储数据外泄事故之一：微软承认服务器错误配置导致全球客户数据泄露