用Java 11实现清洁架构Clean Architecture

栏目: 后端 · 发布时间: 6年前

内容简介：在软件工程方面，软件架构是过去几年中最重要的主题之一。但是当涉及到具体实施时，事情变得困难并且出现了许多问题。我该从哪里开始？我如何构建我的项目？如何将Bob叔叔的原则应用于我想要使用的技术？这里我将尝试从Java Web开发人员的角度回答这些问题，他们希望使用Java 9中的Java 11和Jigsaw模块。这将为您提供更加具体的视图，了解Uncle Bob的干净架构。

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

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

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

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

用Java 11实现清洁架构Clean Architecture

实体：这些是应用程序的业务对象。这些不应受到外部任何更改的影响，这些应该是应用程序中最稳定的代码。这些可以是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 上找到它们：

将所有东西放在一起

现在我们已经有了实现细节，我们需要将它们组合在一起。为此，我们需要创建一个包含应用程序配置的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上：

https://github.com/carlphilipp/clean-architecture-example

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，也希望大家多多支持码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。

码农书籍

How to Think About Algorithms

Jeff Edmonds / Cambridge University Press / 2008-05-19 / USD 38.99

HOW TO THINK ABOUT ALGORITHMS There are many algorithm texts that provide lots of well-polished code and proofs of correctness. Instead, this one presents insights, notations, and analogies t......一起来看看《How to Think About Algorithms》这本书的介绍吧!

码农工具

用Java 11实现清洁架构Clean Architecture

How to Think About Algorithms

MD5 加密

XML、JSON 在线转换

RGB HSV 转换