转载

用Java 11实现清洁架构Clean Architecture

在软件工程方面，软件架构是过去几年中最重要的主题之一。罗伯特·C·马丁（又名鲍勃大叔）在他的书中深刻地提出了他对清洁架构的看法，我强烈推荐！

但是当涉及到具体实施时，事情变得困难并且出现了许多问题。我该从哪里开始？我如何构建我的项目？如何将Bob叔叔的原则应用于我想要使用的技术？

这里我将尝试从Java Web开发人员的角度回答这些问题，他们希望使用Java 9中的Java 11和Jigsaw模块。这将为您提供更加具体的视图，了解Uncle Bob的干净架构。

在深入实现之前，让我们来看看架构：

实体：这些是应用程序的业务对象。这些不应受到外部任何更改的影响，这些应该是应用程序中最稳定的代码。这些可以是POJO，具有方法的对象，甚至是数据结构。
用例：实现并封装所有业务规则。
接口适配器：将数据转换并呈现给用例和实体层。
框架和驱动程序：包含运行应用程序所需的任何框架或工具。

这里的关键概念是：

任何层都只能引用它下面的层，而不知道上面发生了什么。
用例和实体是应用程序的核心，应该具有最小的外部库依赖项集。

实施项目

我们将使用Gradle多项目和 Java Jigsaw 模块来强制执行不同层之间的依赖关系。

我们要构建的应用程序非常简单，对于这样的项目来说，架构可能看起来有点过分，但这是了解这一切是如何工作的最佳方式。

该应用程序的功能将是：

创建用户。
找一个用户。
列出所有用户。
使用密码登录用户。

为此，我们将从内层（实体/用例）开始，然后是接口适配器层，我们将完成外层。我们还将通过更改实现细节和在框架之间切换来演示架构的灵活性。

以下是该项目的视图：

用Java 11实现清洁架构Clean Architecture

内层

我们的实体和用例分为两个子项目：“领域domain”和“用例usecase”：

用Java 11实现清洁架构Clean Architecture

这两个子项目代表了我们应用的核心。

架构必须非常明确。通过快速查看上面的示例，我们立即知道存在什么样的操作以及在哪里。如果您要创建单个UserService而不是很难分辨该服务中存在哪种操作，那么您需要深入了解实现以了解服务的作用。在我们干净的架构中，我们只需要快速查看usecase包，就可以了解支持哪种操作。

domain实体包中包含的所有实体。在我们的例子中，我们将只有一 User：

<b>package</b> com.slalom.example.domain.entity;

<b>public</b> <b>class</b> User {

  <b>private</b> String id;
    <b>private</b> String email;
    <b>private</b> String password;
    <b>private</b> String lastName;
    <b>private</b> String firstName;
        <font><i>// Builder pattern & Getters</i></font><font>
        </font><font><i>// ...</i></font><font>
}
</font>

用例usecase子模块包含我们的业务逻辑。我们将从一个简单的用例开始FindUser：

<b>package</b> com.slalom.example.usecase;

<b>import</b> com.slalom.example.domain.entity.User;
<b>import</b> com.slalom.example.domain.port.UserRepository;
<b>import</b> java.util.List;
<b>import</b> java.util.Optional;

<b>public</b> <b>final</b> <b>class</b> FindUser {

    <b>private</b> <b>final</b> UserRepository repository;

    <font><i>// All args constructor</i></font><font>

    <b>public</b> Optional<User> findById(<b>final</b> String id) {
        <b>return</b> repository.findById(id);
    }

    <b>public</b> List<User> findAllUsers() {
        <b>return</b> repository.findAllUsers();
    }
</font>

我们有两个操作，这两个操作需要从存储库中检索用户。这在面向服务的体系结构SOA中看起来很标准。UserRepository是一个未在我们当前子项目中实现的接口。这被认为是我们架构中的细节，细节在外层实现。当实例化用例时（例如通过依赖注入），将提供它的实现。这提供了一些优点：

无论实现是什么，业务逻辑都保持不变。
实现中的任何更改都不会影响业务逻辑。
完全更改实现非常容易，因为它对业务逻辑没有影响。

请注意，该接口也称为端口，因为它构成了业务逻辑和外部世界之间的桥梁。

现在让我们构建CreateUser用例的第一次迭代：

<b>package</b> com.slalom.example.usecase;

<b>import</b> com.slalom.example.domain.entity.User;
<b>import</b> com.slalom.example.domain.port.IdGenerator;
<b>import</b> com.slalom.example.domain.port.PasswordEncoder;
<b>import</b> com.slalom.example.domain.port.UserRepository;

<b>public</b> <b>final</b> <b>class</b> CreateUser {

    <b>private</b> <b>final</b> UserRepository repository;
    <b>private</b> <b>final</b> PasswordEncoder passwordEncoder;
    <b>private</b> <b>final</b> IdGenerator idGenerator;
  
    <font><i>// All args constructor</i></font><font>
  
    <b>public</b> User create(<b>final</b> User user) {
        <b>var</b> userToSave = User.builder()
            .id(idGenerator.generate())
            .email(user.getEmail())
            .password(passwordEncoder.encode(user.getEmail() + user.getPassword()))
            .lastName(user.getLastName())
            .firstName(user.getFirstName())
            .build();
        <b>return</b> repository.create(userToSave);
    }
}
</font>

与FindUser用例一样，我们需要一个存储库，一种生成ID的方法，以及一种对密码进行编码的方法。这些也是细节，而不是业务规则，稍后将在外层实现。

我们还想验证提供的用户是否有效（包含正确的数据），并且它已经不存在。这导致了我们对用例的最后一次迭代：

<b>public</b> <b>final</b> <b>class</b> CreateUser {

    <b>private</b> <b>final</b> UserRepository repository;
    <b>private</b> <b>final</b> PasswordEncoder passwordEncoder;
    <b>private</b> <b>final</b> IdGenerator idGenerator;
  
      <font><i>// All args constructor</i></font><font>
    
    <b>public</b> User create(<b>final</b> User user) {
            UserValidator.validateCreateUser(user);
        <b>if</b> (repository.findByEmail(user.getEmail()).isPresent()) {
            <b>throw</b> <b>new</b> UserAlreadyExistsException(user.getEmail());
        }
        <b>var</b> userToSave = User.builder()
            .id(idGenerator.generate())
            .email(user.getEmail())
            .password(passwordEncoder.encode(user.getEmail() + user.getPassword()))
            .lastName(user.getLastName())
            .firstName(user.getFirstName())
            .build();
        <b>return</b> repository.create(userToSave);
    }
}
</font>

如果用户无效或已存在，则抛出自定义运行时异常。这些自定义异常应由其他层处理。

我们的最后一个用例LoginUser非常简单，可以在 GitHub 中找到。

最后，为了强制执行边界，两个子项目都使用 Jigsaw 模块。Jigsaw模块允许我们仅向外界公开需要暴露的内容，因此不会泄露任何实现细节。例如，没有理由公开UserValidator该类：

<font><i>// Domain module-info</i></font><font>
module slalom.example.domain {
    exports com.slalom.example.domain.entity;
    exports com.slalom.example.domain.port;
    exports com.slalom.example.domain.exception;
}

</font><font><i>// Use case module-info</i></font><font>
module slalom.example.usecase {
    exports com.slalom.example.usecase;
    requires slalom.example.domain;
    requires org.apache.commons.lang3;
}
</font>

总结内层的作用：

内层包含域对象和业务规则。这应该是应用程序中最稳定和最受测试的部分。
内部层中没有实现与外部世界的任何交互（如数据库或外部服务）。我们使用端口（接口）来表示它们。
没有使用框架和最小的依赖关系。
Jigsaw模块允许我们隐藏实现细节。

外层

1. 适配器

现在我们有了实体和用例，我们可以实现细节。为了能够证明该体系结构非常灵活，我们将创建多个实现并在不同的上下文中使用它们。

用Java 11实现清洁架构Clean Architecture

让我们从存储库开始。UserRepository实现简单HashMap：

<b>package</b> com.slalom.example.db;

<b>import</b> com.slalom.example.domain.entity.User;
<b>import</b> com.slalom.example.domain.port.UserRepository;
<b>import</b> java.util.ArrayList;
<b>import</b> java.util.HashMap;
<b>import</b> java.util.List;
<b>import</b> java.util.Map;
<b>import</b> java.util.Optional;

<b>public</b> <b>class</b> InMemoryUserRepository implements UserRepository {
    
    <b>private</b> <b>final</b> Map<String, User> inMemoryDb = <b>new</b> HashMap<>();
    
      @Override
    <b>public</b> User create(<b>final</b> User user) {
        inMemoryDb.put(user.getId(), user);
        <b>return</b> user;
    }
  
    @Override
    <b>public</b> Optional<User> findById(<b>final</b> String id) {
        <b>return</b> Optional.ofNullable(inMemoryDb.get(id));
    }
  
    @Override
    <b>public</b> Optional<User> findByEmail(<b>final</b> String email) {
        <b>return</b> inMemoryDb.values().stream()
            .filter(user -> user.getEmail().equals(email))
            .findAny();
    }
  
    @Override
    <b>public</b> List<User> findAllUsers() {
        <b>return</b> <b>new</b> ArrayList<>(inMemoryDb.values());
    }
}

可以在 GitHub上找到Hazelcast的另一个实现。

其他适配器：其他适配器仅通过实现域中声明的接口以相同的方式实现。你可以在 GitGub 上找到它们：

Password encoder
Jug Id Generator
Uuid Generator

将所有东西放在一起

现在我们已经有了实现细节，我们需要将它们组合在一起。为此，我们需要创建一个包含应用程序配置的config文件夹和一个包含运行应用程序代码的应用程序文件夹。

这是其中一个配置：

<b>public</b> <b>class</b> ManualConfig {

    <b>private</b> <b>final</b> UserRepository userRepository = <b>new</b> InMemoryUserRepository();
    <b>private</b> <b>final</b> IdGenerator idGenerator = <b>new</b> JugIdGenerator();
    <b>private</b> <b>final</b> PasswordEncoder passwordEncoder = <b>new</b> Sha256PasswordEncoder();

    <b>public</b> CreateUser createUser() {
        <b>return</b> <b>new</b> CreateUser(userRepository, passwordEncoder, idGenerator);
    }
    
      <b>public</b> FindUser findUser() {
        <b>return</b> <b>new</b> FindUser(userRepository);
    }
    
    <b>public</b> LoginUser loginUser() {
        <b>return</b> <b>new</b> LoginUser(userRepository, passwordEncoder);
    }
}

此配置使用相关适配器初始化用例。如果您想要更改实现，您可以轻松地从一个适配器实现切换到另一个，而无需修改用例代码。

以下是运行应用程序的主类：

<b>public</b> <b>class</b> Main {
    <b>public</b> <b>static</b> <b>void</b> main(String[] args) {
        <font><i>// Setup</i></font><font>
        <b>var</b> config = <b>new</b> ManualConfig();
        <b>var</b> createUser = config.createUser();
        <b>var</b> findUser = config.findUser();
        <b>var</b> loginUser = config.loginUser();
        <b>var</b> user = User.builder()
            .email(</font><font>"john.doe@gmail.com"</font><font>)
            .password(</font><font>"mypassword"</font><font>)
            .lastName(</font><font>"doe"</font><font>)
            .firstName(</font><font>"john"</font><font>)
            .build();
                        
        </font><font><i>// Create a user</i></font><font>
        <b>var</b> actualCreateUser = createUser.create(user);
        System.out.println(</font><font>"User created with id "</font><font> + actualCreateUser.getId());
                
        </font><font><i>// Find a user by id</i></font><font>
        <b>var</b> actualFindUser = findUser.findById(actualCreateUser.getId());
        System.out.println(</font><font>"Found user with id "</font><font> + actualFindUser.get().getId());
                
        </font><font><i>// List all users</i></font><font>
        <b>var</b> users = findUser.findAllUsers();
        System.out.println(</font><font>"List all users: "</font><font> + users);
                
        </font><font><i>// Login</i></font><font>
        loginUser.login(</font><font>"john.doe@gmail.com"</font><font>, </font><font>"mypassword"</font><font>);
        System.out.println(</font><font>"Allowed to login with email 'john.doe@gmail.com' and password 'mypassword'"</font><font>);
    }
}
</font>

Web框架

如果您想使用Spring Boot或Vert.x等Web框架，该怎么办？这很简单 - 我们只需要：

为Web应用程序创建新配置。
创建一个新的应用程序运行
在适配器文件夹中添加控制器。控制器将负责与内层通信。

这是Spring控制器的样子：

<b>package</b> com.slalom.example.spring.controller;

@RestController
<b>public</b> <b>class</b> UserController {
    <b>private</b> <b>final</b> CreateUser createUser;
    <b>private</b> <b>final</b> FindUser findUser;
    <b>private</b> <b>final</b> LoginUser loginUser;
  
    <font><i>// All args constructor with @Autowired</i></font><font>
  
    @RequestMapping(value = </font><font>"/users"</font><font>, method = RequestMethod.POST)
    <b>public</b> UserWeb createUser(@RequestBody <b>final</b> UserWeb userWeb) {
        <b>var</b> user = userWeb.toUser();
        <b>return</b> UserWeb.toUserWeb(createUser.create(user));
    }
    
    @RequestMapping(value = </font><font>"/login"</font><font>, method = RequestMethod.GET)
    <b>public</b> UserWeb login(@RequestParam(</font><font>"email"</font><font>) <b>final</b> String email, @RequestParam(</font><font>"password"</font><font>) <b>final</b> String password) {
        <b>return</b> UserWeb.toUserWeb(loginUser.login(email, password));
    }
    
     @RequestMapping(value = </font><font>"/users/{userId}"</font><font>, method = RequestMethod.GET)
    <b>public</b> UserWeb getUser(@PathVariable(</font><font>"userId"</font><font>) <b>final</b> String userId) {
        <b>return</b> UserWeb.toUserWeb(findUser.findById(userId).orElseThrow(() -> <b>new</b> RuntimeException(</font><font>"user not found"</font><font>)));
    }
    
     @RequestMapping(value = </font><font>"/users"</font><font>, method = RequestMethod.GET)
    <b>public</b> List<UserWeb> allUsers() {
        <b>return</b> findUser.findAllUsers()
            .stream()
            .map(UserWeb::toUserWeb)
            .collect(Collectors.toList());
    }
}
</font>

您可以使用Spring Boot和Vert.x 在 GitHub中找到此应用程序的完整示例。

结论

我们在本文中试图展示Uncle Bob的干净架构是多么强大。希望你有点清楚。

优点：

强大：您的业务逻辑受到保护，外部没有任何东西可以使其失败。您的代码不依赖于其他人“控制”的任何外部框架。
灵活性：任何适配器都可以随时由您选择的任何其他实现替换。从Spring启动切换到Vert.x或Dropwizard可以非常快速地完成。
推迟决定：我需要什么样的数据库？我需要什么样的Web框架？您可以在不了解这些细节的情况下构建业务逻辑。
高可维护性：很容易识别哪个组件出现故障。
更快地实施：由于架构将问题分开，您可以一次专注于一项任务并更快地发展。这也应该减少技术债务的数额。
测试：单元测试更容易，因为依赖项是明确定义的，它很容易模拟或存根。
集成测试：您可以在集成测试期间创建要访问的任何外部服务的特定实现。例如，如果您不希望因为按请求付费而访问云中托管的数据库，只需使用适配器的内存实现即可。

缺点：

学习曲线：一开始，架构可能会非常庞大，尤其是初级开发人员。
更多课程，更多包，更多子项目。据我所知，没有什么可以做的。作为一名polygot开发人员，我鼓励Java开发人员探索其他语言，如Kotlin。在这种情况下，Kotlin可以帮助减少创建的文件数量。
项目的复杂性更高。
对于小型项目，这可能只是过度设计。

GitHub上的项目提供了有关如何处理Web框架的更多详细信息。如果您有兴趣，我会鼓励您查看代码并使用它。

Github上：