Java 8的功能性编程模式

在有关编写更简单，更简洁的代码的教程中，了解有关函数式编程模式的更多信息。

1）在匿名Lambda上优先使用命名函数

为了进行热身，让我们从将一些用户的详细信息带到UI的简单任务开始。我们将从对实体列表的传统回顾开始，将每个实体列表转换User为UserDto：

public List<UserDto> getAllUsers() {
2
        List<User> users = userRepo.findAll();
3
        List<UserDto> dtos = new ArrayList<>();
4
        for (User user : users) {
5
                UserDto dto = new UserDto();
6
                dto.setUsername(user.getUsername());
7
                dto.setFullName(user.getFirstName() + " " + user.getLastName().toUpperCase());
8
                dto.setActive(user.getDeactivationDate() == null);
9
                dtos.add(dto);
10
        }
11
        return dtos;
12
}

但是，我对这个代码不是很骄傲，因为在很多情况下，我可能会重复编写类似的代码。因此，让我们使用Java 8削减样板：

public List<UserDto> getAllUsers() {
2
        return userRepo.findAll().stream()
3
                .map(user -> {
4
                        UserDto dto = new UserDto();
5
                        dto.setUsername(user.getUsername());
6
                        dto.setFullName(user.getFirstName() + " " + user.getLastName().toUpperCase());
7
                        dto.setActive(user.getDeactivationDate() == null);
8
                        return dto;
9
                })
10
                .collect(toList());
11
}

这样更好 但是，我仍然不满意。我写的这个lambda演示了“匿名函数”。作为一个干净的代码疯子，我对此有一个疑问–我想要表达性的名字。因此，我迅速将lambda内容提取到一个单独的方法中：

public List<UserDto> getAllUsers() {
2
        return userRepo.findAll().stream().map(this::toDto).collect(toList());
3
}
4
5
private UserDto toDto(User user) {
6
        UserDto dto = new UserDto();
7
        dto.setUsername(user.getUsername());
8
        dto.setFullName(user.getFirstName() + " " + user.getLastName().toUpperCase());
9
        dto.setActive(user.getDeactivationDate() == null);
10
        return dto;
11
}

真好 该代码在以前的版本中足够简单，但现在略胜一筹。使用IDE仅花了三秒钟。我总是建议我的学员掌握那些重构捷径！

有时，这种逻辑转换非常简单，如本例所示，我们可以将其直接放入DTO构造函数中。请注意，我将要求DTO依赖实体，而不是实体（依赖关系倒置原则）：

public class UserFacade {
2
        private UserRepo userRepo;        
3
4
        public List<UserDto> getAllUsers() {
5
                return userRepo.findAll().stream().map(UserDto::new).collect(toList());
6
        }
7
}
8
9
public class UserDto {
10
        private String username;
11
        private String fullName;
12
        private boolean active;
13
        public UserDto(User user) {
14
                username = user.getUsername();
15
                fullName = user.getFirstName() + " " + user.getLastName().toUpperCase();
16
                active = user.getDeactivationDate() == null;
17
        }
18
        ...
19
}

现在，让我们想象一下，这种转换需要其他一些组件的帮助，我们想使用Spring，Guice，CDI等注入这些组件。但是，将依赖注入到我们实例化的类中将需要非常复杂的代码。相反，我将回到以前的版本，但是如果这种转换确实变得太复杂了，我们应该将其移至一个单独的UserMapper类并从那里引用它：

@Service
2
public class UserFacade {
3
          @Autowired
4
          private UserRepo userRepo;
5
          @Autowired
6
          private UserMapper mapper;         
7
8
          public List<UserDto> getAllUsers() {
9
                   return userRepo.findAll().stream().map(mapper::toDto).collect(toList());
10
          }
11
}
12
13
@Component
14
public class UserMapper {
15
          @Autowired
16
          private OtherClass otherClass;
17
18
          public UserDto toDto(User user) {
19
                   UserDto dto = new UserDto();
20
                   dto.setUsername(user.getUsername());
21
                   ... // code using otherClass
22
                   return dto;
23
          }
24
}

关键点是：总是将复杂的lambda提取为具有表达性名称的函数，然后可以使用以下命令中的四点（::）进行引用：

同一班级（this::）;
另一堂课（mapper::）;
一些静态辅助方法（SomeClass::）;
流项目类型（Item::）；
即使足够简单，也可以使用一些构造函数（）；UserDto::new
简而言之：永不键入-> {。

2）流残骸

假设自从Lambda和Stream添加到语言以来，您就一直在使用它们。而且，您需要证明这一点，对吗？因此，您实现了一个用例：

public List<Product> getFrequentOrderedProducts(List<Order> orders) {
2
        return orders.stream()
3
                        .filter(o -> o.getCreationDate().isAfter(LocalDate.now().minusYears(1)))
4
                        .flatMap(o -> o.getOrderLines().stream())
5
                        .collect(groupingBy(OrderLine::getProduct, summingInt(OrderLine::getItemCount)))
6
                        .entrySet()
7
                        .stream()
8
                        .filter(e -> e.getValue() >= 10)
9
                        .map(Entry::getKey)
10
                        .filter(p -> !p.isDeleted())
11
                        .filter(p -> !productRepo.getHiddenProductIds().contains(p.getId()))
12
                        .collect(toList());
13
}

您可以计算上一年订购产品的次数。现在，如果没有按逻辑顺序删除或未从数据库中显式隐藏频繁订购的产品（> = 10），则返回它们。

你开心回家…

但是我们会找到你的！管理层无法解雇您-我同意-但是，谁能读懂这些东西？承认吧……谁会愿意与您合作？

此代码最糟糕的事情是每一行都返回不同的类型。除非您将鼠标悬停在IDE中（侦探工作），否则您将看不到这些类型。

干净代码最重要的规则之一是： 小方法。因此，通过查看.collect(…)紧随其后的代码，让我们将此长链分为两个方法.stream()。既然您还是将这些项目收集到一个集合中，为什么我们不通过提取一个名字很好的方法来解释那个集合是什么呢？此外，让我们替换!order.isDeleted()为order.isNotDeleted()，就可以使用了::。

public List<Product> getFrequentOrderedProducts(List<Order> orders) {
2
          return getProductCountsOverTheLastYear(orders).entrySet().stream()
3
                             .filter(e -> e.getValue() >= 10)
4
                             .map(Entry::getKey)
5
                             .filter(Product::isNotDeleted)
6
                             .filter(p -> !productRepo.getHiddenProductIds().contains(p.getId()))
7
                             .collect(toList());
8
}
9
10
private Map<Product, Integer> getProductCountsOverTheLastYear(List<Order> orders) {
11
          return orders.stream()
12
                             .filter(o -> o.getCreationDate().isAfter(LocalDate.now().minusYears(1)))
13
                             .flatMap(o -> o.getOrderLines().stream())
14
                             .collect(groupingBy(OrderLine::getProduct, summingInt(OrderLine::getItemCount)));
15
}

但是，只有到那时，我们才注意到在第6行，我们可能正在循环查询一个外部系统！我的天啊！那是您永远都不要做的事情。因此，让hiddenProductIds我们在开始流式传输之前获取该列表。我们甚至可以走得更远，提取检查产品是否隐藏在Predicate局部变量中。如果他愿意将函数保留在变量中，则可以为读者提供帮助：)。

public List<Product> getFrequentOrderedProducts(List<Order> orders) {
2
        List<Long> hiddenProductIds = productRepo.getHiddenProductIds();
3
        Predicate<Product> productIsNotHidden = p -> !hiddenProductIds.contains(p.getId());
4
        return getProductCountsOverTheLastYear(orders).entrySet().stream()
5
                        .filter(e -> e.getValue() >= 10)
6
                        .map(Entry::getKey)
7
                        .filter(Product::isNotDeleted)
8
                        .filter(productIsNotHidden)
9
                        .collect(toList());
10
}

我们还可以做一件事：我们可以命名常用产品流并将其设置为type变量Stream。如我们所知，Stream项目实际上并未在此时进行评估，而只是在最终评估时才进行评估.collect()。但是，Stream<>有时不鼓励使用变量，因为粗心的开发人员可能会尝试重用（重新遍历）变量，因此在执行变量之前，请确保您的团队充分了解这种常见情况。

public List<Product> getFrequentOrderedProducts(List<Order> orders) {
2
        List<Long> hiddenProductIds = productRepo.getHiddenProductIds();
3
        Predicate<Product> productIsNotHidden = p -> !hiddenProductIds.contains(p.getId());
4
        Stream<Product> frequentProducts = getProductCountsOverTheLastYear(orders).entrySet().stream()
5
                        .filter(e -> e.getValue() >= 10)
6
                        .map(Entry::getKey);
7
        return frequentProducts
8
                        .filter(Product::isNotDeleted)
9
                        .filter(productIsNotHidden)
10
                        .collect(toList());
11
}
12
[...]

这里的想法是通过引入解释变量来避免过多的方法链接。 这意味着 提取方法，甚至使用函数或Stream类型的变量，以使代码对读者来说尽可能清晰。

3）与所有人中最伟大的野兽战斗：空指针

是! 空指针并不总是在那里！实际上，实际上是最频繁出现的错误的原因！

现在让我们摆脱它吧？

练习很简单：我们需要返回一个格式正确的行，以便根据他收集的忠诚度点为客户打印适用的折扣：

public String getDiscountLine(Customer customer) {
2
        return "Discount%: " + getDiscountPercentage(customer.getMemberCard());
3
}
4
5
private Integer getDiscountPercentage(MemberCard card) {
6
        if (card.getFidelityPoints() >= 100) {
7
                return 5;
8
        }
9
        if (card.getFidelityPoints() >= 50) {
10
                return 3;
11
        }
12
        return null;
13
}

让我们看看它返回60分然后返回10分的结果：

System.out.println(discountService.getDiscountLine(new Customer(new MemberCard(60))));
2
System.out.println(discountService.getDiscountLine(new Customer(new MemberCard(10))));

Prints:

Discount%: 3
2
Discount%: null

但是，我想向您的用户显示“ null”并不是您每天都想做的事情。显然，问题在于我们连接了一个潜在的null整数。修复它很简单：

public String getDiscountLine(Customer customer) {
2
        Integer discount = getDiscountPercentage(customer.getMemberCard());
3
        if (discount != null) {
4
                return "Discount%: " + discount;
5
        } else {
6
                return "";
7
        }
8
}

Prints:

Discount%: 3

接下来，如果没有折扣，我们将返回一个空字符串。但是，为此，我们用空检查污染了我们的代码。而且，更糟糕的是，我们必须通过偷看该getDiscountPercentage()函数以查看何时可能返回a来找到问题null。但是，该技术无法在大型代码库中扩展。相反，您的API应该明确指出该函数可能不返回任何内容。

import java.util.Optional.*;
2
3
public String getDiscountLine(Customer customer) {
4
        Optional<Integer> discount = getDiscountPercentage(customer.getMemberCard());
5
        if (discount.isPresent()) {
6
                return "Discount%: " + discount.get();
7
        } else {
8
                return "";
9
        }
10
}
11
12
private Optional<Integer> getDiscountPercentage(MemberCard card) {
13
        if (card.getFidelityPoints() >= 100) {
14
                return of(5);
15
        }
16
        if (card.getFidelityPoints() >= 50) {
17
                return of(3);
18
        }
19
        return empty();
20
}

自然，我所做的就是用第Optional.isPresent()3行的调用替换了空检查。但是，有时候，第一个突然出现的想法并不总是最好的。与一起玩时Optional，您需要反过来考虑。每当您尝试更改魔术盒.map(中的内容时，请使用）将函数应用于该盒子，以便仅在其中有东西的情况下变换盒子的内容。

public String getDiscountLine(Customer customer) {
2
return getDiscountPercentage(customer.getMemberCard())
3
      .map(d -> "Discount%: " + d).orElse("");
4
}

不仅代码更简洁，而且一旦习惯了这种样式，它也更易于阅读。

！我们只需要再做一个测试：没有的客户MemberCard：

System.out.println(discountService.getDiscountLine(new Customer()));

Prints:

Exception in thread "main" java.lang.NullPointerException...

KABOOM！你去！我们经常惊恐地看到异常从何而来。在这里，它在getDiscountPercentage()函数的第一行。这是由于我们从未处理过null的MemberCard参数有一些边界值（）。让我们立即修复该问题-尽快隐藏该错误，并假装我们从未见过：

private Optional<Integer> getDiscountPercentage(MemberCard card) {
2
        if (card == null) {
3
                return empty();
4
        }
5
        if (card.getFidelityPoints() >= 100) {
6
                return of(5);
7
        }
8
        if (card.getFidelityPoints() >= 50) {
9
                return of(3);
10
        }
11
        return empty();
12
}

看，我们又冲了。而且，我们再次错过了一项设计见解（您看到模式了吗？）。我们在此处快速应用了防御性编程，并保护我们的代码免受所有其他无效数据的侵害。但是，据说最好的防御是进攻。如果，我们没有害怕担心地保护我们的代码，而是说：“等等。那么，客户可以不使用会员卡吗？然后，Customer.getMemberCard()应当返回一个Optional。”

public class Customer {
2
          ...
3
          public Optional<MemberCard> getMemberCard() {
4
                   returnofNullable(memberCard);
5
          }
6
}

是的，我在这里谈论神圣的事情。我敢于更改域实体！但是，我相信我之所以更具表现力，是因为客户与会员卡之间的链接实际上是可选的（注意：字段和设置者仍使用’raw’类型MemberCard）。然后，代替测试null，我们测试是否.isPresent():

private Optional<Integer> getDiscountPercentage(Optional<MemberCard> cardOpt) {
2
        if (!cardOpt.isPresent()) {
3
                returnempty();
4
        }
5
...// Wait a bit!

停！

我们一无所获！我会说这段代码更加丑陋！但是，这里有一条干净的代码规则：不要采用可为空的参数，因为您要做的第一件事就是检查null。在Java 8中，这表示不采用Optional参数。

让我们再次扭曲我们的心灵，看到我们应该运用getDiscountPercentage()到MemberCard，只要有一个会员卡。因此，让我们撤消更改以getDiscountPercentage()返回到getDiscountLine()并从开始Optional：

public String getDiscountLine(Customer customer) {
2
          return customer.getMemberCard()
3
                             .map(card -> getDiscountPercentage(card))
4
                             .map(d -> "Discount%: " + d)
5
                             .orElse("");
6
}

但是，输出可能使我们感到惊讶：

1
Discount%: Optional[3]
2
Discount%: Optional.empty

这是因为第4行的d不再是an Integer，而是an Optional。如果将鼠标悬停在第一个上，.map()然后查看返回类型：，您会自己看到它Optional<Optional>。在这里，您在另一个框内的框内有一个数字。这就像将您的孩子的圣诞节礼物包装成多层嵌套包装一样，只是为了增加发现的乐趣。在我们的例子中，我们将使用的一元性质Optional和使用.flatMap()，而不是.map()摆脱多余的包装的。（要在寒冷的大风夜晚做：请阅读有关Monads的更多信息）。使用Optionals还有很多，但是以我作为培训师的经验，最困难的思维步骤是此处所述。

public String getDiscountLine(Customer customer) {
2
            return customer.getMemberCard()
3
                                    .flatMap(this::getDiscountPercentage)
4
                                    .map(d -> "Discount%: " + d)
5
                                    .orElse("");
6
}

因此，每当null给Java 8带来问题时，请立即跳转至Optional 并将转换函数应用于可能为空的魔术盒。干净的代码规则变为：不要采用Optional参数；相反，只要您的函数希望向调用者发信号通知在某些情况下可能没有返回值，则返回Optional。

4）贷款模式/通过块

对于以下练习，让我们将订单导出到CSV文件：

public File exportFile(String fileName) throws Exception {
2
       File file = new File("export/" + fileName);
3
       try (Writer writer = new FileWriter(file)) {
4
              writer.write("OrderID;Date\n");
5
              repo.findByActiveTrue()
6
                     .map(o -> o.getId() + ";" + o.getCreationDate())
7
                     .forEach(writer::write);
8
              return file;
9
       } catch (Exception e) {
10
              // TODO send email notification
11
              log.debug("Gotcha!", e); // TERROR-Driven Development
12
              throw e;
13
       }
14
}

我将打开一个Writer，对所有订单进行流处理，将其转换，然后将它们写入文件。在这个例子的最后，隐隐的恐惧气味源于一种可能性，也许以后没有人会抓住我的例外。理想情况下，您应该相信您的团队具有这些异常，这样，如果将它们抛出在任何线程上，就可以正常捕获和记录它们。

完善！

但是，它无法编译！

这是因为Writer.write()方法声明了throws IOException，即使的Consumer期望值.forEach没有。如果抛出检查异常，您将遭受痛苦！但是，如何隐藏JDK类抛出的已检查异常？我们可以将第7行扩展为一个内联lambda，然后在其中执行以下操作：

try {...} catch(IOException) {throw new RuntimeException(e);}

但是，阅读本文会伤害我们的眼睛。我们可能应该立即以某种方法将其掩埋，否则我们可以让jOOL做到这一点。然后，第7行变成：

.forEach(Unchecked.consumer(writer::write));

我们很高兴回家…

.forEach(Unchecked.consumer(writer::write));

在执行此操作时，有很多方法可能会偏离正义之路，包括布尔值，枚举ExportType和@Overriding具体方法（我在演讲中提到了其中的一些，只是为了好玩），但在此我将概述的模板方法设计模式[GoF的]。

abstract class FileExporter {
2
          public File exportFile(String fileName) throws Exception {
3
                   File file = new File("export/" + fileName);
4
                   try (Writer writer = new FileWriter(file)) {
5
                             writeContent(writer);
6
                             return file;
7
                   } catch (Exception e) {
8
                             // TODO send email notification
9
                             throw e;
10
                   }
11
          }
12
          protected abstract void writeContent(Writer writer) throws IOException;
13
}
14
15
class OrderExporter extends FileExporter{
16
          private OrderRepo repo;
17
          @Override
18
          protected void writeContent(Writer writer) throws IOException {
19
                   writer.write("OrderID;Date\n");
20
                   repo.findByActiveTrue()
21
                             .map(o -> o.getId() + ";" + o.getCreationDate())
22
                             .forEach(Unchecked.consumer(writer::write));
23
          }
24
}
25
class UserExporter extends FileExporter {
26
          @Override
27
          protected void writeContent(Writer writer) throws IOException {
28
                   ...
29
          }
30
}

我想让你问自己：我们为什么在那使用那个危险的词？我们为什么玩火？extends代码中如此糟糕的借口是什么？为了强制我提供缺少的逻辑，f(Writer):void每当我将子类化时，都会有一个函数FileExporter。

但是，我们可以在Java 8中更轻松地做到这一点！我们只需要将aConsumer作为方法参数！

class FileExporter {
2
          public File exportFile(String fileName, Consumer<Writer> contentWriter) throws Exception {
3
                   File file = new File("export/" + fileName);
4
                   try (Writer writer = new FileWriter(file)) {
5
                             contentWriter.accept(writer);
6
                             return file;
7
                   } catch (Exception e) {
8
                             // TODO send email notification
9
                             throw e;
10
                   }
11
          }
12
}
13
14
class OrderExportWriter {
15
          private OrderRepo repo;
16
          public void writeOrders(Writer writer) throws IOException {
17
                   writer.write("OrderID;Date\n");
18
                   repo.findByActiveTrue()
19
                             .map(o -> o.getId() + ";" + o.getCreationDate())
20
                             .forEach(Unchecked.consumer(writer::write));
21
          }
22
}
23
class UserExportWriter {
24
          protected void writeUsers(Writer writer) throws IOException {
25
                   ...
26
          }
27
}

哇，这里发生了很多变化。该函数代替abstract和extends，exportFile()获得了一个新Consumer参数，调用该参数可写入实际的导出内容。为了获得整体情况，让我们草绘客户端代码：

fileExporter.exportFile("orders.csv", Unchecked.consumer(orderWriter::writeOrders));
2
fileExporter.exportFile("users.csv", Unchecked.consumer(userWriter::writeUsers));

在这里，我不得不Unchecked再次使用它来进行编译，因为writeOrders()声明它会引发异常！另外，如果您是Lombok的粉丝，则可以在@SneakyThrows上放一个writeOrders()，然后从其中删除throws子句。您可以自己尝试。我在这个专用的GitHub存储库上执行了所有步骤（包括这一步）。我不会争论这是否是一个好习惯，我只是在玩。另外，请注意，要进行尝试，您将必须在IDE上配置Lombok。

基本思想是，只要您具有一些“可变逻辑”，就可以考虑将其用作方法参数。在我的培训中，我将其称为“阻止传递”模式。但是，上面的示例略有变化，其中作为参数给出的函数与由主机函数管理的资源一起使用。在我们的示例中，OrderExportWriter.writeOrders接收一个Writer作为参数将内容写入其中。但是，writeOrders与创建，关闭或处理与相关的错误无关FileWriter。这就是为什么我们称之为THI š贷款模式。我们传入的这个函数本质上是借来的，因此Writer可以完成其工作。

贷款模式的一个主要好处是，它与基础结构代码（FileExporter）与实际的导出格式逻辑（OrderExportWriter）很好地分离了。通过抽象层，较好的分离，这种格局使得依赖在v版为，即你可以保持OrderWriter在一个更大的内部层。由于它很好地解耦了代码，因此设计和单元测试变得容易得多。您可以writeOrders()通过传递a进行测试StringWriter，然后查看写入其中的内容。要测试FileExporter，您可以仅传递一个Consumer只写“ dummy”的虚拟对象，然后验证基础代码是否能完成其工作。

而且，这一切都没有任何扩展。众所周知，扩展重用逻辑会对设计造成长期损害。因此，在Java 8中可以使用Passing-a-Block模式的优雅方式可能是见证模板方法设计模式的葬礼，因为它实现了几乎相同的目标，而无需强迫您扩展任何内容。

“通过块”模式的另一种变体是“执行环绕”模式。从语法上讲，代码非常相似：

measure(() -> stuff());
2
executeInTransaction(() -> stuff());

但是，目的略有不同。在这里，stuff()已经实现了，但是之后，我们想要围绕它执行一些任意代码（之前和之后）。使用Execute Around，我们在一些辅助函数中编写此代码之前/之后，然后将原始调用包装在对该辅助对象的调用中。如果我们仔细观察第二行，它闻起来像面向方面的编程（AOP），对吗？使用Spring，我们通常只是@Transactional使用一种方法来获取该方法的事务。为了使TransactionInterceptor发挥作用，您需要调用@TransactionalSpring所提供的对此类的（代理）引用上的方法（并非总是如此）。因此，以上两行均涉及需要临时编织的情况，即在任意实用工具函数中运行函数并在代码之前和/或之后运行函数。

免责声明：您可以在Internet上阅读的文章中模式名称可以互换使用。

本部分的主要内容是，您应该强迫自己思考如何处理逻辑位并将它们当作Java 8中的一等公民使用。

这将使您的代码更加优雅，简单和富有表现力。

5）实现特定类型逻辑的五种方法

任务很简单：有三种电影类型，每种都有自己的公式，用于根据借出的天数来计算价格。

class Movie {
2
        enum Type {
3
                REGULAR, NEW_RELEASE, CHILDREN
4
        }
5
6
        private final Type type;
7
8
        public Movie(Type type) {
9
                this.type = type;
10
        }
11
12
        public int computePrice(int days) {
13
                switch (type) {
14
                case REGULAR: return days + 1;
15
                case NEW_RELEASE: return days * 2;
16
                case CHILDREN: return 5;
17
                default: throw new IllegalArgumentException(); // Always have this here!
18
                }
19
        }
20
}

如果我们测试：

System.out.println(new Movie(Movie.Type.REGULAR).computePrice(2));
2
System.out.println(new Movie(Movie.Type.NEW_RELEASE).computePrice(2));
3
System.out.println(new Movie(Movie.Type.CHILDREN).computePrice(2));

我们得到：

3
4
5

该示例是Bob叔叔的经典视频商店代码Kata的提炼。上面代码中的问题可能是switch：每当您向枚举添加新值时，都需要查找所有开关并确保处理新的大小写。但这是脆弱的。该IllegalArgumentException会弹出，但只有当你走这条道路，从测试/ UI / API。简而言之，尽管任何人都可以阅读此代码，但这样做有些冒险。

一种避免风险的方法是OOP解决方案：

abstract class Movie {
2
        public abstract int computePrice(int days);
3
}
4
5
class RegularMovie extends Movie {
6
        public int computePrice(int days) {
7
                return days+1;
8
        }
9
}
10
11
class NewReleaseMovie extends Movie {
12
        public int computePrice(int days) {
13
                return days*2;
14
        }
15
}
16
17
class ChildrenMovie extends Movie {
18
        public int computePrice(int days) {
19
                return 5;
20
        }
21
}

如果您创建一种新型的电影，实际上是一个新的子类，那么除非您实现，否则代码不会编译computePrice()。但是，extends又来了！如果要按其他标准（例如发行年份）对电影进行分类怎么办？或者几个月后您将如何处理从“降级”Type.NEW_RELEASE到Type.REGULAR电影的操作？

让我们回到第一种形式，让我们寻找实现它的其他方式。在我的Devoxx演讲中，我还现场编码了如何使用枚举上的抽象方法来实现此逻辑。但是，在这里，我想直接提出更改请求：“新发行电影的价格公式中的因素（在我们的示例中为2）必须可以通过数据库进行更新。”

uch！这意味着我必须从某些注入的存储库中获取此因素。但是，由于我无法在Movie实体中注入存储库，因此将逻辑移到单独的类中：

public class PriceService {
2
3
        private final NewReleasePriceRepo repo;
4
5
        public PriceService(NewReleasePriceRepo repo) {
6
                this.repo = repo;
7
        }
8
9
        public int computeNewReleasePrice(int days) {
10
                return (int) (days * repo.getFactor());
11
        }
12
        public int computeRegularPrice(int days) {
13
                return days + 1;
14
        }
15
        public int computeChildrenPrice(int days) {
16
                return 5;
17
        }
18
19
        public int computePrice(Movie.Type type, int days) {
20
                switch (type) {
21
                case REGULAR: return computeRegularPrice(days);
22
                case NEW_RELEASE: return computeNewReleasePrice(days);
23
                case CHILDREN: return computeChildrenPrice(days);
24
                default: thrownew IllegalArgumentException();
25
                }
26
        }
27
}

但是，switch固有风险又回来了！有什么方法可以确保没有人忘记定义相关的价格公式？

现在，对于大结局：

public class Movie { 
2
3
       public enum Type {
4
              REGULAR(PriceService::computeRegularPrice),
5
              NEW_RELEASE(PriceService::computeNewReleasePrice),
6
              CHILDREN(PriceService::computeChildrenPrice);
7
8
              public final BiFunction<PriceService, Integer, Integer> priceAlgo;
9
10
              private Type(BiFunction<PriceService, Integer, Integer> priceAlgo) {
11
                     this.priceAlgo = priceAlgo;
12
              }
13
       }
14
       ...
15
16
}

？!!？！

我将每个方法的引用存储到每个枚举值中PriceService。由于我以静态方式（来自PriceService::）引用实例方法，因此我将需要PriceService在调用时将实例作为第一个参数提供。我给它this。这样，我可以从枚举值定义的静态上下文中的任何[Spring] bean中有效地引用方法。

在我所举办的各种Coding Dojos中，开发人员也提出了建议Map<Type,Function<>>，但与一门老派相比，switch, 它没有任何真正的好处-如果添加新的影片类型，编译仍然不会中断，但是代码变得更加神秘。

结论
简而言之：

始终将复杂的lambda提取到您使用引用的命名函数中::。你不应该写-> {。
避免过多的调用链接-使用解释性方法和变量将它们分开，尤其是当这些调用的返回类型有所不同时。
每当null让您感到烦恼时，请考虑使用Optional。改变主意-您必须将功能应用于魔术盒。
当变量事物是一个函数时，要意识到这一点，您可以显式地使用它，将一个函数传递给另一个函数。
贷款模式意味着将您提供的功能作为用于“主机”功能管理的资源的参数。从概念上讲，这使重量更轻，耦合松散并且易于测试设计。
有时，您可能需要一些任意代码来围绕另一个函数执行。如果是这种情况，请将该代码作为参数传递给函数。
您可以使用方法引用将类型特定的逻辑挂接到您的枚举，以确保每个枚举值都与逻辑的对应位相关联。
始终以尽可能简单的代码为目标，并积极提炼代码，直到它变得微不足道/“无聊”为止。

参考：《2020最新Java基础精讲视频教程和学习路线！》