2020-06-08 16:00:44

8bbdede2 · wizardforcel · 3a197ac3 · 8bbdede2 · 8bbdede2 · 8bbdede2
44 changed file
--- a/docs/misc1/151.md
+++ b/docs/misc1/151.md
-# Hibernate / JPA 2 持久化注解教程
+# Hibernate / JPA2 持久化注解教程

 > 原文： [https://howtodoinjava.com/hibernate/hibernate-jpa-2-persistence-annotations-tutorial/](https://howtodoinjava.com/hibernate/hibernate-jpa-2-persistence-annotations-tutorial/)

-此 [**Hibernate**](//howtodoinjava.com/hibernate-tutorials/ "Hibernate Tutorials")（或 JPA 2）持久化注解教程包含对 Java POJO 进行注解以使其充当持久化 JPA 实体时可能需要的所有重要注解的概述。 本教程首先定义一个 POJO “`EmployeeEntity`”，在其中定义一些属性，并具有各自的获取器和设置器方法。 在学习新注解时，我们将这些注解应用于`EmployeeEntity`，然后我们将了解该特定注解的含义。
+此 [**Hibernate**](//howtodoinjava.com/hibernate-tutorials/ "Hibernate Tutorials")（或 JPA2）持久化注解教程包含对 Java POJO 进行注解以使其充当持久化 JPA 实体时可能需要的所有重要注解的概述。 本教程首先定义一个 POJO “`EmployeeEntity`”，在其中定义一些属性，并具有各自的获取器和设置器方法。 在学习新注解时，我们将这些注解应用于`EmployeeEntity`，然后我们将了解该特定注解的含义。

 让我们快速列出注解，我们将在本教程中进行讨论。

@@ -24,7 +24,7 @@ Table of Contents
 	Single Table
 	Joined Table
 	Table per Concrete Class
-**Other JPA 2 Persistence Annotations**
+**Other JPA2 Persistence Annotations**
 	Temporal Data with `@Temporal`
 	Element Collections with `@ElementCollection`
 	Large Objects with `@Lob`
@@ -86,7 +86,7 @@ public class EmployeeEntity implements Serializable

 ## 最常用的 JPA 注解

-## Hibernate / JPA 2 `@Entity`注解教程
+## Hibernate / JPA2 `@Entity`注解教程

 这是将 POJO 标记为 JPA 实体的第一步。 为此，我们需要应用`@Entity`注解，如下所示：

@@ -104,7 +104,7 @@ public class EmployeeEntity implements Serializable

 ```

-JPA 2 标准注解包含在`javax.persistence`包中，因此我们从此包中导入了注解。 `@Entity`注解将该类标记为实体 Bean，因此它**必须具有无参数构造器**，该构造器至少在受保护的范围（特定于 JPA）下可见。 Hibernate 至少支持包作用域，但是您会失去对其他 JPA 实现的可移植性，因为它们可能只允许受保护级别作用域。 理想情况下，您应该将此构造器公开，这也使其与其他规范高度兼容。 还有更多规则，例如 POJO 类的欲望不是最终的。 而且也不能是抽象的。
+JPA2 标准注解包含在`javax.persistence`包中，因此我们从此包中导入了注解。 `@Entity`注解将该类标记为实体 Bean，因此它**必须具有无参数构造器**，该构造器至少在受保护的范围（特定于 JPA）下可见。 Hibernate 至少支持包作用域，但是您会失去对其他 JPA 实现的可移植性，因为它们可能只允许受保护级别作用域。 理想情况下，您应该将此构造器公开，这也使其与其他规范高度兼容。 还有更多规则，例如 POJO 类的欲望不是最终的。 而且也不能是抽象的。

 现在，让我们快速浏览一下“`@org.hibernate.annotations.Entity`”注解（特定于 Hiberate）。 使用它，您可以为特定于 Hiberate 的实体定义一些额外的行为。

@@ -159,7 +159,7 @@ public class EmployeeEntity implements Serializable

 继续，如果需要，在代码中使用这些注解。

-## 具有`@Id`和`@GeneratedValue`的主键
+## 使用`@Id`和`@GeneratedValue`的主键

 每个实体 bean 必须具有一个主键，您可以在主类上使用`@Id`注解对其进行注解。 通常，主键将是单个字段，尽管它也可以是多个字段的组合，我们将在后面的部分中看到。

@@ -265,7 +265,7 @@ private Integer employeeId;

 因为该表可用于包含各种条目的主键值，所以使用该表的每个实体可能只有一行。 因此，它需要自己的主键（`pkColumnName`），以及包含从中获取主键的任何实体要使用的下一个主键值（`pkColumnValue`）的列。

-## 具有`@Id`，`@IdClass`或`@EmbeddedId`的复合主键
+## 使用`@Id`，`@IdClass`或`@EmbeddedId`的复合主键

 尽管出于各种原因使用单列代理密钥是有利的，但有时您可能不得不使用业务密钥。 当它们包含在单个列中时，您可以使用`@Id`而无需指定生成策略，该策略强制用户在持久保存实体之前分配主键值。

@@ -360,7 +360,7 @@ private Integer age;

 ## 使用`@Column`映射属性和字段

-`@Column`注解用于指定字段或属性将映射到的列的详细信息。 其中一些细节与架构相关，因此仅在从注解文件生成架构时才适用。 其他应用则由 Hibernate（或 JPA 2 持久化引擎）在运行时应用并强制执行。 它是可选的，具有一组适当的默认行为，但是在覆盖默认行为或需要将对象模型适合到预先存在的架构中时通常很有用。
+`@Column`注解用于指定字段或属性将映射到的列的详细信息。 其中一些细节与架构相关，因此仅在从注解文件生成架构时才适用。 其他应用则由 Hibernate（或 JPA2 持久化引擎）在运行时应用并强制执行。 它是可选的，具有一组适当的默认行为，但是在覆盖默认行为或需要将对象模型适合到预先存在的架构中时通常很有用。

 以下属性通常被覆盖：

@@ -389,7 +389,7 @@ private String  firstName;

 实体并不总是与其他实体关联为属性； 有时，它们使用常规的 OOP 继承规则进行关联。 Hibernate 允许您使用`@Inheritance`注解来履行此类关系。

-JPA 2 标准和 Hibernate 都支持将继承层次结构映射到数据库中的三种方法。 这些如下：
+JPA2 标准和 Hibernate 都支持将继承层次结构映射到数据库中的三种方法。 这些如下：

 1.  **单个表（`SINGLE_TABLE`）**：每个类层次结构都有一个表
 2.  **已连接（`JOINED`）**：每个子类一个表（包括接口和抽象类）
@@ -459,9 +459,9 @@ public class Book {

 ```

-## 其他 JPA 2 持久化注解
+## 其他 JPA2 持久化注解

-尽管我们现在涵盖了大多数核心 JPA 2 持久化注解，但是您还会经常遇到其他一些注解。 我们将在以下各节中介绍其中一些内容。
+尽管我们现在涵盖了大多数核心 JPA2 持久化注解，但是您还会经常遇到其他一些注解。 我们将在以下各节中介绍其中一些内容。

 ## `@Temporal`的时间数据

@@ -477,7 +477,7 @@ java.util.Date startingTime;

 ## `@ElementCollection`的元素集合

-除了使用一对多映射来映射集合之外，JPA 2 还引入了`@ElementCollection`注解，用于映射基本或可嵌入类的集合。 您可以使用`@ElementCollection`注解来简化映射。
+除了使用一对多映射来映射集合之外，JPA2 还引入了`@ElementCollection`注解，用于映射基本或可嵌入类的集合。 您可以使用`@ElementCollection`注解来简化映射。

 ```java
 @ElementCollection
@@ -511,7 +511,7 @@ String content; // a very long article

 ## 使用`@OrderColumn`排序集合

-尽管`@OrderBy`允许从数据库中检索数据后进行排序，但 JPA 2 还提供了一个注解，该注解允许在数据库中维护适当集合类型（例如`List`）的排序； 它通过维护代表该顺序的有序列来实现。 这是一个例子：
+尽管`@OrderBy`允许从数据库中检索数据后进行排序，但 JPA2 还提供了一个注解，该注解允许在数据库中维护适当集合类型（例如`List`）的排序； 它通过维护代表该顺序的有序列来实现。 这是一个例子：

 ```java
 @OneToMany
@@ -575,6 +575,6 @@ public class Author {

 ```

-简而言之，这就是本篇有限的教程，涵盖了**最重要的 JPA 2 持久化注解**。 我将在以后的教程中详细介绍它们。
+简而言之，这就是本篇有限的教程，涵盖了**最重要的 JPA2 持久化注解**。 我将在以后的教程中详细介绍它们。

 **祝您学习愉快！**
\ No newline at end of file
--- a/docs/misc1/152.md
+++ b/docs/misc1/152.md
@@ -55,7 +55,7 @@

    后者的一些冗长是 XML 本身的本质（标记名和样板文档类型声明），而某些是由于注解与源代码的紧密集成所致。

-*   另一个主要的好处是 Hiberate 使用并支持 JPA 2 持久化注解。 如果选择不在代码和注解中使用特定于 Hibernate 的功能，则可以使用支持 JPA 2 的其他 ORM 工具将实体部署到环境中。
+*   另一个主要的好处是 Hiberate 使用并支持 JPA2 持久化注解。 如果选择不在代码和注解中使用特定于 Hibernate 的功能，则可以使用支持 JPA2 的其他 ORM 工具将实体部署到环境中。
 *   最后，也许是次要的一点，因为注解被直接编译到适当的类文件中，因此丢失或陈旧的映射文件在部署时引起问题的风险较小。

 ## 选择使用哪个

--- a/docs/misc1/153.md
+++ b/docs/misc1/153.md
@@ -2,9 +2,9 @@

 > 原文： [https://howtodoinjava.com/hibernate/immutable-and-naturalid-hibernate-specific-annotations/](https://howtodoinjava.com/hibernate/immutable-and-naturalid-hibernate-specific-annotations/)

-在上一篇文章中，我们了解了[Hiberate](//howtodoinjava.com/hibernate-tutorials/ "Hibernate Tutorials")中最常用的 [JPA 注解](//howtodoinjava.com/hibernate/hibernate-jpa-2-persistence-annotations-tutorial/ "Hibernate / JPA 2 Persistence Annotations Tutorial")，还了解了与这些 JPA 注解互补的 Hiberate 注解。 使用 JPA 注解使您的应用代码可移植到其他 JPA 实现中，这是一件好事。 除了 JPA 注解之外，Hiberate 还具有一些自己的注解，您可以使用它们在应用代码中具有某些功能。 但是您必须记住，将来的日期可能很难使您的代码可移植。
+在上一篇文章中，我们了解了[Hiberate](//howtodoinjava.com/hibernate-tutorials/ "Hibernate Tutorials")中最常用的 [JPA 注解](//howtodoinjava.com/hibernate/hibernate-jpa-2-persistence-annotations-tutorial/ "Hibernate / JPA2 Persistence Annotations Tutorial")，还了解了与这些 JPA 注解互补的 Hiberate 注解。 使用 JPA 注解使您的应用代码可移植到其他 JPA 实现中，这是一件好事。 除了 JPA 注解之外，Hiberate 还具有一些自己的注解，您可以使用它们在应用代码中具有某些功能。 但是您必须记住，将来的日期可能很难使您的代码可移植。

-> **阅读更多： [JPA 2 持久化注解教程](//howtodoinjava.com/hibernate/hibernate-jpa-2-persistence-annotations-tutorial/ "Hibernate / JPA 2 Persistence Annotations Tutorial")**
+> **阅读更多： [JPA2 持久化注解教程](//howtodoinjava.com/hibernate/hibernate-jpa-2-persistence-annotations-tutorial/ "Hibernate / JPA2 Persistence Annotations Tutorial")**

 在本文中，我们将学习两个特定于 Hibernate 的此类注解。


--- a/docs/misc1/157.md
+++ b/docs/misc1/157.md
@@ -25,7 +25,7 @@ Various supported techniques for one to one mapping
 2.  第二种技术使用一种众所周知的解决方案，即具有**第三张表来存储前两个表之间的映射**。
 3.  第三种技术是新技术，它在两个表中都使用了**公共主键值。**

-## 1\. 使用外键关联 Hiberate 一对一映射
+## 1\. 使用外键关联的 Hiberate 一对一映射

 在这种关联中，在**所有者实体**中创建了一个外键列。 例如，如果我们使为`EmployeeEntity`为所有者，则将在`Employee`表中创建一个额外的列`"ACCOUNT_ID"`。 此列将存储`Account`表的外键。

@@ -101,7 +101,7 @@ Hibernate: insert into Employee (ACCOUNT_ID, EMAIL, FIRST_NAME, LAST_NAME) value

 当您运行上述程序时，可以在两个表中验证数据和映射。

-## 2\. 使用公共连接表 Hiberate 一对一映射
+## 2\. 使用公共连接表的 Hiberate 一对一映射

 这种方法对我们所有人都不陌生。 让我们从这种技术的目标 DB 结构开始。

@@ -128,7 +128,7 @@ Hibernate: insert into EMPLOYEE_ACCCOUNT (ACCOUNT_ID, EMPLOYEE_ID) values (?, ?)

 ```

-## 3\. 使用共享主键 Hiberate 一对一映射
+## 3\. 使用共享主键的 Hiberate 一对一映射

 在这种技术中，Hiberate 将确保在两个表中都使用一个公共的主键值。 这样，`EmployeeEntity`的主键也可以安全地假定为`AccountEntity`的主键。


--- a/docs/misc1/158.md
+++ b/docs/misc1/158.md
-# JUnit 5 教程
\ No newline at end of file
+# JUnit5 教程
\ No newline at end of file
--- a/docs/misc1/159.md
+++ b/docs/misc1/159.md
-# JUnit 5 教程
+# JUnit5 教程

 > 原文： [https://howtodoinjava.com/junit-5-tutorial/](https://howtodoinjava.com/junit-5-tutorial/)

-这个 **JUnit 5 教程**讨论了它如何适应 Java 8 编码风格以及其他一些功能。 了解它与 JUnit 3 或 4 的区别。
+这个 **JUnit5 教程**讨论了它如何适应 Java8 编码风格以及其他一些功能。 了解它与 JUnit 3 或 4 的区别。

-JUnit 5 是 Java 应用使用最广泛的测试框架。 长期以来，JUnit 一直在完美地完成其工作。 在这两者之间，JDK 8 带来了 Java 中非常令人兴奋的功能，最著名的是 [lambda 表达式](//howtodoinjava.com/java8/complete-lambda-expressions-tutorial-in-java/)。 JUnit 5 旨在适应 Java 8 的编码风格以及其他一些功能，这就是为什么需要 Java 8 在 JUnit 5 中创建和执行测试（尽管可以执行用 JUnit 3 或 JUnit 4 编写的测试以实现向后兼容） 。
+JUnit5 是 Java 应用使用最广泛的测试框架。 长期以来，JUnit 一直在完美地完成其工作。 在这两者之间，JDK 8 带来了 Java 中非常令人兴奋的功能，最著名的是 [lambda 表达式](//howtodoinjava.com/java8/complete-lambda-expressions-tutorial-in-java/)。 JUnit5 旨在适应 Java8 的编码风格以及其他一些功能，这就是为什么需要 Java8 在 JUnit5 中创建和执行测试（尽管可以执行用 JUnit 3 或 JUnit4 编写的测试以实现向后兼容） 。

 ```java
 Table of Contents
@@ -20,12 +20,12 @@ Backward Compatibility
 Conclusion
 ```

-## JUnit 5 架构
+## JUnit5 架构

-由于[与 JUnit 4](//howtodoinjava.com/junit-5/junit-5-vs-junit-4/) 相比，JUnit 5 由来自三个不同子项目的几个不同模块组成：
+由于[与 JUnit4](//howtodoinjava.com/junit-5/junit-5-vs-junit-4/) 相比，JUnit5 由来自三个不同子项目的几个不同模块组成：

 ```java
-JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage
+JUnit5 = JUnit Platform + JUnit Jupiter + JUnit Vintage
 ```

 1.  #### JUnit 平台
@@ -39,11 +39,11 @@ JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

 3.  #### JUnit Vintage

-    其主要目的是支持在 JUnit 5 平台上运行 JUnit 3 和 JUnit 4 书面测试。 它具有向后兼容性。
+    其主要目的是支持在 JUnit5 平台上运行 JUnit 3 和 JUnit4 书面测试。 它具有向后兼容性。

 ## 安装

-您可以在 Maven 或 Gradle 项目中使用 JUnit 5，方法是至少包含两个依赖项，即 Jupiter 引擎依赖项和平台运行期依赖项。
+您可以在 Maven 或 Gradle 项目中使用 JUnit5，方法是至少包含两个依赖项，即 Jupiter 引擎依赖项和平台运行期依赖项。

 ```java
 //pom.xml
@@ -79,9 +79,9 @@ testRuntime("org.junit.platform:junit-platform-runner:1.5.2")

 > 阅读更多： [Maven 示例](//howtodoinjava.com/junit-5/junit-5-maven-dependency-pom-xml-example/) | [Gradle 示例](//howtodoinjava.com/junit-5/junit-5-gradle-dependency-build-gradle-example/)

-## JUnit 5 注解
+## JUnit5 注解

-JUnit 5 提供了以下注解来编写测试。
+JUnit5 提供了以下注解来编写测试。

 | 注解 | 描述 |
 | --- | --- |
@@ -96,9 +96,9 @@ JUnit 5 提供了以下注解来编写测试。
 | `@Tag` | 用标签标记测试方法或测试类，以进行测试发现和过滤 |
 | `@TestFactory` | 标记方法为动态测试的测试工厂 |

-## 在 JUnit 5 中编写测试
+## 在 JUnit5 中编写测试

-在 JUnit 4 和 JUnit 5 之间，测试书写样式没有太大变化。 这是使用[生命周期](//howtodoinjava.com/junit-5/junit-5-test-lifecycle/)方法的示例测试。
+在 JUnit4 和 JUnit5 之间，测试书写样式没有太大变化。 这是使用[生命周期](//howtodoinjava.com/junit-5/junit-5-test-lifecycle/)方法的示例测试。

 ```java
 import org.junit.jupiter.api.AfterAll;
@@ -156,7 +156,7 @@ public class AppTest {

 ## 测试套件

-使用 **JUnit 5 测试套件**，您可以运行分散到多个测试类和不同包中的测试。 JUnit 5 提供了两个注解：[`@SelectPackages`](http://junit.org/junit5/docs/current/api/index.html?org/junit/platform/runner/SelectPackages.html)和[`@SelectClasses`](http://junit.org/junit5/docs/current/api/index.html?org/junit/platform/runner/SelectClasses.html)以创建测试套件。
+使用 **JUnit5 测试套件**，您可以运行分散到多个测试类和不同包中的测试。 JUnit5 提供了两个注解：[`@SelectPackages`](http://junit.org/junit5/docs/current/api/index.html?org/junit/platform/runner/SelectPackages.html)和[`@SelectClasses`](http://junit.org/junit5/docs/current/api/index.html?org/junit/platform/runner/SelectClasses.html)以创建测试套件。

 要执行套件，您将使用`@RunWith(JUnitPlatform.class)`。

@@ -186,7 +186,7 @@ public class JUnit5TestSuiteExample

 ```

-> 阅读更多： [JUnit 5 测试套件](//howtodoinjava.com/junit-5/junit5-test-suites-examples/)
+> 阅读更多： [JUnit5 测试套件](//howtodoinjava.com/junit-5/junit5-test-suites-examples/)

 ## 断言

@@ -208,7 +208,7 @@ void testCase()

 ```

-> 阅读更多： [JUnit 5 断言](//howtodoinjava.com/junit-5/junit-5-assertions-examples/)
+> 阅读更多： [JUnit5 断言](//howtodoinjava.com/junit-5/junit-5-assertions-examples/)

 ## 假设

@@ -239,21 +239,21 @@ public class AppTest {

 ```

-> 阅读更多： [JUnit 5 假设](//howtodoinjava.com/junit-5/junit-5-assumptions-examples/)
+> 阅读更多： [JUnit5 假设](//howtodoinjava.com/junit-5/junit-5-assumptions-examples/)

-## JUnit 3 或 JUnit 4 的向后兼容性
+## JUnit 3 或 JUnit4 的向后兼容性

-JUnit 4 已经存在了很长时间，并且用 junit 4 编写了许多测试。JUnitJupiter 也需要支持这些测试。 为此，开发了 *JUnit Vintage* 子项目。
+JUnit4 已经存在了很长时间，并且用 JUnit4 编写了许多测试。JUnitJupiter 也需要支持这些测试。 为此，开发了 *JUnit Vintage* 子项目。

-JUnit Vintage 提供了`TestEngine`实现，用于在 JUnit 5 平台上运行基于 JUnit 3 和 JUnit 4 的测试。
+JUnit Vintage 提供了`TestEngine`实现，用于在 JUnit5 平台上运行基于 JUnit 3 和 JUnit4 的测试。

 ## 总结

-JUnit 5 仍在开发中。 看起来如此令人兴奋且功能丰富。 现在，它可以通过第三方工具和 API 进行扩展。 作为一名测试作者，您可能不会有太大的不同，但是当您尝试扩展它或尝试开发任何 IDE 插件时，您会称赞它。
+JUnit5 仍在开发中。 看起来如此令人兴奋且功能丰富。 现在，它可以通过第三方工具和 API 进行扩展。 作为一名测试作者，您可能不会有太大的不同，但是当您尝试扩展它或尝试开发任何 IDE 插件时，您会称赞它。

 作为开发人员，您还可以考虑[将测试模板添加到 Eclipse](//howtodoinjava.com/junit-5/code-test-templates-eclipse/) IDE 中以提高开发速度。

-在评论中写下您对此 JUnit 5 教程的想法。
+在评论中写下您对此 JUnit5 教程的想法。

 学习愉快！


--- a/docs/misc1/160.md
+++ b/docs/misc1/160.md
-# JUnit 5 测试生命周期
+# JUnit5 测试生命周期

 > 原文： [https://howtodoinjava.com/junit5/junit-5-test-lifecycle/](https://howtodoinjava.com/junit5/junit-5-test-lifecycle/)

-在 JUnit 5 中，测试生命周期由 4 个主要注解驱动，即[**`@BeforeAll`**](//howtodoinjava.com/junit-5/before-all-annotation-example/)， [`@BeforeEach`](//howtodoinjava.com/junit-5/before-each-annotation-example/)， [`@AfterEach`](//howtodoinjava.com/junit-5/after-each-annotation-example/)和[`@AfterAll`](//howtodoinjava.com/junit-5/after-all-annotation-example/)。 同时，每个测试方法都必须标有`@Test`注解。 尽管`@Test`注解不再使用可选参数，但它几乎没有变化。
+在 JUnit5 中，测试生命周期由 4 个主要注解驱动，即[**`@BeforeAll`**](//howtodoinjava.com/junit-5/before-all-annotation-example/)， [`@BeforeEach`](//howtodoinjava.com/junit-5/before-each-annotation-example/)， [`@AfterEach`](//howtodoinjava.com/junit-5/after-each-annotation-example/)和[`@AfterAll`](//howtodoinjava.com/junit-5/after-all-annotation-example/)。 同时，每个测试方法都必须标有`@Test`注解。 尽管`@Test`注解不再使用可选参数，但它几乎没有变化。

 ## 之前和之后

@@ -72,7 +72,7 @@ public class AppTest {

 ## 禁用测试

-要在 JUnit 5 中禁用测试，您将需要使用[`@Disabled`](//howtodoinjava.com/junit-5/junit-5-disabled-test-example/)注解。 它等效于 JUnit 4 的`@Ignored`注解。
+要在 JUnit5 中禁用测试，您将需要使用[`@Disabled`](//howtodoinjava.com/junit-5/junit-5-disabled-test-example/)注解。 它等效于 JUnit4 的`@Ignored`注解。

 `@Disabled`注解可以应用于测试类（禁用该类中的所有测试方法）或单个测试方法。


--- a/docs/misc1/161.md
+++ b/docs/misc1/161.md
-# JUnit 5 `@BeforeAll`注解示例
+# JUnit5 `@BeforeAll`注解示例

 > 原文： [https://howtodoinjava.com/junit5/before-all-annotation-example/](https://howtodoinjava.com/junit5/before-all-annotation-example/)

-JUnit 5 [`@BeforeAll`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/BeforeAll.html) 注解替换了 [JUnit 4](//howtodoinjava.com/junit-4/) 中的`@BeforeClass`注解。 它用于表示应在当前测试类中的所有测试之前执行**注解方法**。
+JUnit5 [`@BeforeAll`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/BeforeAll.html) 注解替换了 [JUnit4](//howtodoinjava.com/junit-4/) 中的`@BeforeClass`注解。 它用于表示应在当前测试类中的所有测试之前执行**注解方法**。

 ## `@BeforeAll`注解用法


--- a/docs/misc1/162.md
+++ b/docs/misc1/162.md
-# JUnit 5 `@BeforeEach`注解示例
+# JUnit5 `@BeforeEach`注解示例

 > 原文： [https://howtodoinjava.com/junit5/before-each-annotation-example/](https://howtodoinjava.com/junit5/before-each-annotation-example/)

-JUnit 5 [`@BeforeEach`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/BeforeEach.html)注解替换了 JUnit 4 中的`@Before`注解。它用于表示应在当前类中的每个`@Test`方法之前执行**注解方法**。
+JUnit5 [`@BeforeEach`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/BeforeEach.html)注解替换了 JUnit4 中的`@Before`注解。它用于表示应在当前类中的每个`@Test`方法之前执行**注解方法**。

 ## `@BeforeEach`注解用法


--- a/docs/misc1/163.md
+++ b/docs/misc1/163.md
-# JUnit 5 `@AfterEach`注解示例
+# JUnit5 `@AfterEach`注解示例

 > 原文： [https://howtodoinjava.com/junit5/after-each-annotation-example/](https://howtodoinjava.com/junit5/after-each-annotation-example/)

-JUnit 5 [`@AfterEach`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/AfterEach.html) 注解替换了 JUnit 4 中的`@After`注解。它用于表示应在当前类中的每个`@Test`方法之后执行**注解方法**。
+JUnit5 [`@AfterEach`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/AfterEach.html) 注解替换了 JUnit4 中的`@After`注解。它用于表示应在当前类中的每个`@Test`方法之后执行**注解方法**。

 ## `@AfterEach`注解用法


--- a/docs/misc1/164.md
+++ b/docs/misc1/164.md
-# JUnit 5 `@AfterAll`注解示例
+# JUnit5 `@AfterAll`注解示例

 > 原文： [https://howtodoinjava.com/junit5/after-all-annotation-example/](https://howtodoinjava.com/junit5/after-all-annotation-example/)

-JUnit 5 [`@AfterAll`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/AfterAll.html) 注解替换了 JUnit 4 中的`@AfterClass`注解。它用于表示应在当前测试类中的所有测试之后执行**注解方法**。
+JUnit5 [`@AfterAll`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/AfterAll.html) 注解替换了 JUnit4 中的`@AfterClass`注解。它用于表示应在当前测试类中的所有测试之后执行**注解方法**。

 ## `@AfterAll`注解用法

@@ -28,7 +28,7 @@ org.junit.platform.commons.JUnitException: @AfterAll method 'public void com.how

 ```

-## @AfterAll 注解示例
+## `@AfterAll`注解示例

 让我们举个例子。 我使用了一个`Calculator`类并添加了一个`add`方法。 我将使用`@RepeatedTest`注解对其进行 5 次测试。 此注解将导致`add`测试运行 5 次。 但是`@AfterAll`带注解的方法只能调用一次。


--- a/docs/misc1/165.md
+++ b/docs/misc1/165.md
-# JUnit 5 `@RepeatedTest`注解示例
+# JUnit5 `@RepeatedTest`注解示例

 > 原文： [https://howtodoinjava.com/junit5/repeated-test-annotation-example/](https://howtodoinjava.com/junit5/repeated-test-annotation-example/)

-通过 JUnit 5 [`@RepeatedTest`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/RepeatedTest.html)注解，可以编写可以多次运行的**可重复测试模板**。 频率可以配置为`@RepeatedTest`注解的参数。
+通过 JUnit5 [`@RepeatedTest`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/RepeatedTest.html)注解，可以编写可以多次运行的**可重复测试模板**。 频率可以配置为`@RepeatedTest`注解的参数。

 ## 1\. `@RepeatedTest`注解用法

@@ -127,9 +127,9 @@ public class JUnit5AnnotationsExample

 运行以上测试将在下面输出：

-![JUnit 5 Repeated Test Display Names](img/b46da3713bac1ef2f67c614c4f1a4bd0.png)
+![JUnit5 Repeated Test Display Names](img/b46da3713bac1ef2f67c614c4f1a4bd0.png)

-JUnit 5 重复测试的显示名称
+JUnit5 重复测试的显示名称




--- a/docs/misc1/166.md
+++ b/docs/misc1/166.md
-# JUnit 5 `@Disabled`测试示例
+# JUnit5 `@Disabled`测试示例

 > 原文： [https://howtodoinjava.com/junit5/junit-5-disabled-test-example/](https://howtodoinjava.com/junit5/junit-5-disabled-test-example/)

@@ -35,15 +35,15 @@ public class AppTest {

 ```

-![JUnit 5 Disabled Annotation Over Class](img/f89d2d61b89111d2a3f783c12bf6ddb4.png)
+![JUnit5 Disabled Annotation Over Class](img/f89d2d61b89111d2a3f783c12bf6ddb4.png)

-JUnit 5 类上的`@Disabled`注解
+JUnit5 类上的`@Disabled`注解



 请注意运行次数：2/2（跳过 2 个）。 显然，两个测试都被禁用，因此不执行。

-## JUnit 5 `@Disabled`测试方法
+## JUnit5 `@Disabled`测试方法

 `@Disabled`用于表示当前已禁用带注解的**测试方法，因此不应执行**。

@@ -72,9 +72,9 @@ public class AppTest {

 ```

-![JUnit 5 Disabled Annotation Over Method](img/ca156a5524c6e5b84062a6eadb029648.png)
+![JUnit5 Disabled Annotation Over Method](img/ca156a5524c6e5b84062a6eadb029648.png)

-JUnit 5 方法上的`@Disabled`注解
+JUnit5 方法上的`@Disabled`注解




--- a/docs/misc1/167.md
+++ b/docs/misc1/167.md
-# JUnit 5 `@Tag` 注解示例
+# JUnit5 `@Tag`注解示例

 > 原文： [https://howtodoinjava.com/junit5/junit-5-tag-annotation-example/](https://howtodoinjava.com/junit5/junit-5-tag-annotation-example/)

-JUnit 5 [`@Tag`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Tag.html) 可用于从测试计划中过滤测试用例。 它可以帮助针对不同的环境，不同的用例或任何特定要求创建多个不同的测试计划。 您可以通过仅在测试计划中包括那些标记的测试或通过从测试计划中排除其他测试来执行测试集。
+JUnit5 [`@Tag`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Tag.html) 可用于从测试计划中过滤测试用例。 它可以帮助针对不同的环境，不同的用例或任何特定要求创建多个不同的测试计划。 您可以通过仅在测试计划中包括那些标记的测试或通过从测试计划中排除其他测试来执行测试集。

 ## 1\. `@Tag`注解用法

@@ -73,7 +73,7 @@ public class MultipleTagsExample

 我们不能在单个测试计划中同时包含`@IncludeTags`和`@ExcludeTags 注`解。

-## 3\. JUnit 5 `@Tag`示例
+## 3\. JUnit5 `@Tag`示例

 假设我们有 3 个测试，并且我们想在开发环境中运行全部 3 个测试； 但只想在生产中运行一个。 因此，我们将标记测试如下：

@@ -119,9 +119,9 @@ public class ProductionTests

 ```

-![JUnit 5 @Tag Example - Production Tests](img/b9653a407e8fca6e0439e9b25f72b3c3.png)
+![JUnit5 @Tag Example - Production Tests](img/b9653a407e8fca6e0439e9b25f72b3c3.png)

-JUnit 5 `@Tag`示例 – 生产测试
+JUnit5 `@Tag`示例 – 生产测试



@@ -137,9 +137,9 @@ public class DevelopmentTests

 ```

-![JUnit 5 @Tag Example - Development Tests](img/da0d6710958d1a488cf312e55059eaff.png)
+![JUnit5 @Tag Example - Development Tests](img/da0d6710958d1a488cf312e55059eaff.png)

-JUnit 5 `@Tag`示例 – 开发测试
+JUnit5 `@Tag`示例 – 开发测试




--- a/docs/misc1/168.md
+++ b/docs/misc1/168.md
-# JUnit 5 预期的异常 – `assertThrows()`示例
+# JUnit5 预期的异常 – `assertThrows()`示例

 > 原文： [https://howtodoinjava.com/junit5/expected-exception-example/](https://howtodoinjava.com/junit5/expected-exception-example/)

-在 JUnit 5 中，要*测试异常情况*，则应使用[`org.junit.jupiter.api.Assertions.assertThrows()`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assertions.html#assertThrows-java.lang.Class-org.junit.jupiter.api.function.Executable-)方法。 *junit 5 异常测试*还有其他方法，但我建议避免使用它们。
+在 JUnit5 中，要*测试异常情况*，则应使用[`org.junit.jupiter.api.Assertions.assertThrows()`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assertions.html#assertThrows-java.lang.Class-org.junit.jupiter.api.function.Executable-)方法。 *JUnit5 异常测试*还有其他方法，但我建议避免使用它们。

-## 1\. Junit 5 `assertThrows()`的语法
+## 1\. JUnit5 `assertThrows()`的语法

 它断言所提供的`executable`的执行将引发`expectedType`的异常并返回该异常。

@@ -16,7 +16,7 @@ public static <T extends Throwable> T assertThrows(Class<T> expectedType, Execut

 请注意，允许使用相同类型的异常。 例如，如果您期望`NumberFormatException`并且抛出`IllegalArgumentException`，那么该测试也会通过，因为`NumberFormatException`扩展了`IllegalArgumentException`类。

-## 2\. JUnit 5 预期异常示例
+## 2\. JUnit5 预期异常示例

 一个非常简单的示例可以是：

@@ -72,7 +72,7 @@ void testExpectedExceptionFail() {

 ## 5\. 完整的例子

-这是 *junit 5 断言异常消息*的完整代码。
+这是 *JUnit5 断言异常消息*的完整代码。

 ```java
 package com.howtodoinjava.junit5.examples.module;
@@ -129,13 +129,13 @@ public class JUnit5Example

 Eclipse 测试结果如下图所示：

-![JUnit 5 Expected Exception Tests](img/d4f22108b773fc944929b8a82ae7eb7f.png)
+![JUnit5 Expected Exception Tests](img/d4f22108b773fc944929b8a82ae7eb7f.png)

-JUnit 5 预期异常测试
+JUnit5 预期异常测试



-这就是 **JUnit 5 异常测试**的全部。 将我的问题放在评论部分。
+这就是 **JUnit5 异常测试**的全部。 将我的问题放在评论部分。

 学习愉快！


--- a/docs/misc1/169.md
+++ b/docs/misc1/169.md
-# JUnit 5 断言示例
+# JUnit5 断言示例

 > 原文： [https://howtodoinjava.com/junit5/junit-5-assertions-examples/](https://howtodoinjava.com/junit5/junit-5-assertions-examples/)

-**JUnit 5 断言**帮助用测试用例的实际输出来验证期望的输出。 为简单起见，所有 **JUnit Jupiter 断言**是[`org.junit.jupiter.Assertions`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assertions.html)类中的静态方法。
+**JUnit5 断言**帮助用测试用例的实际输出来验证期望的输出。 为简单起见，所有 **JUnit Jupiter 断言**是[`org.junit.jupiter.Assertions`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assertions.html)类中的静态方法。

 ```java
 Table of Contents
@@ -182,7 +182,7 @@ void testCase()

 ```

-## `Assertions.assertNotSame()`和 `Assertions.assertSame()`示例
+## `Assertions.assertNotSame()`和`Assertions.assertSame()`示例

 `assertNotSame()`断言**预期和实际不引用同一对象**。 同样，`assertSame()`方法断言，**预期和实际引用完全相同的对象**。 两者都有三种重载方法。

@@ -219,7 +219,7 @@ void testCase()

 ```

-## `Assertions.assertTimeout()`和 `Assertions.assertTimeoutPreemptively()`示例
+## `Assertions.assertTimeout()`和`Assertions.assertTimeoutPreemptively()`示例

 `assertTimeout()`和`assertTimeoutPreemptively()`均用于测试长时间运行的任务。 如果测试用例中的给定任务花费的时间超过指定的持续时间，则测试将失败。


--- a/docs/misc1/170.md
+++ b/docs/misc1/170.md
-# JUnit 5 假设示例
+# JUnit5 假设示例

 > 原文： [https://howtodoinjava.com/junit5/junit-5-assumptions-examples/](https://howtodoinjava.com/junit5/junit-5-assumptions-examples/)

-JUnit 5 `Assumptions`类提供静态方法来支持基于假设的条件测试执行。 假设失败会导致测试中止。 [假设](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assumptions.html)通常在继续执行给定测试方法没有意义的情况下使用。 在测试报告中，这些测试将被标记为通过。
+JUnit5 `Assumptions`类提供静态方法来支持基于假设的条件测试执行。 假设失败会导致测试中止。 [假设](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assumptions.html)通常在继续执行给定测试方法没有意义的情况下使用。 在测试报告中，这些测试将被标记为通过。

 JUnit jupiter `Assumptions`类具有两个这样的方法：`assumeFalse()`和`assumeTrue()`。

@@ -15,7 +15,7 @@ Assumptions.assumeTrue()
 Assumptions.assumeFalse()
 ```

-## JUnit 5 的`Assumptions.assumeTrue()`
+## JUnit5 的`Assumptions.assumeTrue()`

 `assumeTrue()`验证给定的假设为`true`，如果假设为`true`，则进行测试，否则测试执行将中止。

@@ -56,7 +56,7 @@ public class AppTest {

 ```

-## JUnit 5 的`Assumptions.assumeFalse()`
+## JUnit5 的`Assumptions.assumeFalse()`

 `assumeFalse()`会验证给定的假设是否为假，如果假设为假，则执行测试，否则测试执行将中止。 它的工作与`assumeTrue()`相反。


--- a/docs/misc1/171.md
+++ b/docs/misc1/171.md
-# JUnit 5 测试套件示例
+# JUnit5 测试套件示例

 > 原文： [https://howtodoinjava.com/junit5/junit5-test-suites-examples/](https://howtodoinjava.com/junit5/junit5-test-suites-examples/)

-使用 **JUnit 5 测试套件**，您可以运行分散到多个测试类和不同包中的测试。 JUnit 5 提供了两个注解：[`@SelectPackages`](http://junit.org/junit5/docs/current/api/index.html?org/junit/platform/runner/SelectPackages.html)和[`@SelectClasses`](http://junit.org/junit5/docs/current/api/index.html?org/junit/platform/runner/SelectClasses.html)以创建测试套件。 此外，您可以使用其他注解来过滤测试包，类甚至测试方法。
+使用 **JUnit5 测试套件**，您可以运行分散到多个测试类和不同包中的测试。 JUnit5 提供了两个注解：[`@SelectPackages`](http://junit.org/junit5/docs/current/api/index.html?org/junit/platform/runner/SelectPackages.html)和[`@SelectClasses`](http://junit.org/junit5/docs/current/api/index.html?org/junit/platform/runner/SelectClasses.html)以创建测试套件。 此外，您可以使用其他注解来过滤测试包，类甚至测试方法。

 ```java
 Table of Contents

 Project Structure for Test classes and Suite
-Create Test Suite with JUnit 5 @SelectPackages
-Create Test Suite with JUnit 5 @SelectClasses
+Create Test Suite with JUnit5 @SelectPackages
+Create Test Suite with JUnit5 @SelectClasses
 Filtering Packages with @IncludePackages and @ExcludePackages
 Filtering Test Classes with @IncludeClassNamePatterns and @ExcludeClassNamePatterns
 Filtering Tests with @IncludeTags and @ExcludeTags
@@ -21,9 +21,9 @@ Filtering Tests with @IncludeTags and @ExcludeTags

 对于此示例，我使用以下项目结构。

-![JUnit 5 Test Suite Project Structure](img/afb801e2a7677f26c4c2fa69d2902a04.png)
+![JUnit5 Test Suite Project Structure](img/afb801e2a7677f26c4c2fa69d2902a04.png)

-JUnit 5 测试套件项目结构
+JUnit5 测试套件项目结构



@@ -213,7 +213,7 @@ public class JUnit5TestSuiteExample

 ```

-显然，有多种方法**在 JUnit 5** 中创建测试套件，并且它强烈支持**过滤测试套件**中的测试。
+显然，有多种方法**在 JUnit5** 中创建测试套件，并且它强烈支持**过滤测试套件**中的测试。

 将我的问题放在评论部分。


--- a/docs/misc1/172.md
+++ b/docs/misc1/172.md
-# JUnit 5 和 Gradle 
+# JUnit5 和 Gradle 

 > 原文： [https://howtodoinjava.com/junit5/junit-5-gradle-dependency-build-gradle-example/](https://howtodoinjava.com/junit5/junit-5-gradle-dependency-build-gradle-example/)

 了解**使用 gradle** 配置它的不同模块，以及如何使用它们来创建和执行测试。

-请注意，JUnit 5 在运行时需要 Java 8。
+请注意，JUnit5 在运行时需要 Java8。

-## 1\. JUnit 5 Gradle 依赖项
+## 1\. JUnit5 Gradle 依赖项

-要通过 gradle 运行 JUnit 5 测试，您将至少需要两个依赖项。
+要通过 gradle 运行 JUnit5 测试，您将至少需要两个依赖项。

 1.  #### JUnit Jupiter 引擎依赖项

@@ -31,7 +31,7 @@

 2.  #### JUnit 平台运行程序依赖项

-    我们需要`junit-platform-runner`用于**在 JUnit 4 环境**中的 JUnit 平台上执行测试和测试套件。
+    我们需要`junit-platform-runner`用于**在 JUnit4 环境**中的 JUnit 平台上执行测试和测试套件。

    在内部，`junit-platform-runner`依赖于`junit-platform-suite-api`和`junit-platform-launcher`，因此添加`junit-jupiter-engine`仅将所有三个依赖项引入类路径中。

@@ -39,24 +39,24 @@
    testRuntime("org.junit.platform:junit-platform-runner:1.5.2")
    ```

-## 2\. 使用 JUnit 5 执行 JUnit 4 测试
+## 2\. 使用 JUnit5 执行 JUnit4 测试

-要在 junit 5 环境中执行 **junit 4 测试**，您将需要包括`junit-vintage-engine`依赖项。 JUnit Vintage 提供了`TestEngine`，用于在平台上运行基于 JUnit 3 和 JUnit 4 的测试。
+要在 JUnit5 环境中执行 **JUnit4 测试**，您将需要包括`junit-vintage-engine`依赖项。 JUnit Vintage 提供了`TestEngine`，用于在平台上运行基于 JUnit 3 和 JUnit4 的测试。

 ```java
 dependencies {
-    //To run JUnit 3 and junit 4 tests
+    //To run JUnit 3 and JUnit4 tests
    testCompile("junit:junit:4.12")
    testRuntime("org.junit.vintage:junit-vintage-engine:4.12.0-M4")
 }

 ```

-通过在`build.gradle`中进行上述配置，现在您可以使用 junit 5 运行旧的 junit 3 或 junit 4 测试。
+通过在`build.gradle`中进行上述配置，现在您可以使用 JUnit5 运行旧的 junit 3 或 JUnit4 测试。

-## 3\. JUnit 5 Gradle 示例
+## 3\. JUnit5 Gradle 示例

-用于运行用 junit 5 构建的测试的示例`build.gradle`文件如下：
+用于运行用 JUnit5 构建的测试的示例`build.gradle`文件如下：

 ```java
 buildscript {
@@ -118,7 +118,7 @@ dependencies {
 	testCompile("org.junit.jupiter:junit-jupiter-api:${junitJupiterVersion}")
 	testRuntime("org.junit.jupiter:junit-jupiter-engine:${junitJupiterVersion}")

-	// If you also want to support JUnit 3 and JUnit 4 tests
+	// If you also want to support JUnit 3 and JUnit4 tests
 	testCompile("junit:junit:${junit4Version}")
 	testRuntime("org.junit.vintage:junit-vintage-engine:${junitVintageVersion}")


--- a/docs/misc1/173.md
+++ b/docs/misc1/173.md
-# JUnit 5 Maven 依赖项
+# JUnit5 Maven 依赖项

 > 原文： [https://howtodoinjava.com/junit5/junit5-maven-dependency/](https://howtodoinjava.com/junit5/junit5-maven-dependency/)

-了解**使用 Maven** 配置其 junit 5 的不同模块，以及如何使用它们创建和执行测试。
+了解**使用 Maven** 配置其 JUnit5 的不同模块，以及如何使用它们创建和执行测试。

-请注意，JUnit 5 在运行时需要 Java 8。
+请注意，JUnit5 在运行时需要 Java8。

-## 1\. JUnit 5 Maven 依赖项
+## 1\. JUnit5 Maven 依赖项

-要通过 [maven](https://howtodoinjava.com/maven/) 运行 [JUnit 5](https://howtodoinjava.com/junit-5-tutorial/) 测试，您将至少需要两个依赖项。
+要通过 [maven](https://howtodoinjava.com/maven/) 运行 [JUnit5](https://howtodoinjava.com/junit-5-tutorial/) 测试，您将至少需要两个依赖项。

 1.  #### JUnit Jupiter 引擎依赖项

@@ -29,15 +29,15 @@

    我们来看看依赖树：

-    ![Junit 5 jupiter engine dependency tree](img/976f54abf0d14f443b77bc3341eabde6.png)
+    ![JUnit5 jupiter engine dependency tree](img/976f54abf0d14f443b77bc3341eabde6.png)

-    Junit 5 jupiter 引擎依赖树
+    JUnit5 jupiter 引擎依赖树



 2.  #### JUnit 平台运行程序依赖项

-    在 JUnit 4 环境中，需要`junit-platform-runner`用于**在 JUnit 平台上执行测试和测试套件**。
+    在 JUnit4 环境中，需要`junit-platform-runner`用于**在 JUnit 平台上执行测试和测试套件**。

    在内部，`junit-platform-runner`依赖于`junit-platform-suite-api`和`junit-platform-launcher`，因此添加`junit-jupiter-engine`仅将所有三个依赖项引入类路径中。

@@ -53,15 +53,15 @@

    我们来看看依赖树：

-    ![Junit 5 platform runner dependency tree](img/faa877bf63e2929061a4bbe5890b2597.png)
+    ![JUnit5 platform runner dependency tree](img/faa877bf63e2929061a4bbe5890b2597.png)

-    Junit 5 平台运行程序依赖树
+    JUnit5 平台运行程序依赖树



-## 2\. 使用 JUnit 5 执行 JUnit 4 测试
+## 2\. 使用 JUnit5 执行 JUnit4 测试

-要在 junit 5 环境中执行 **junit 4 测试**，您将需要`JUnit Platform Surefire Provider`插件。 只要您在 JUnit 4 上配置`test`依赖项并将 JUnit Vintage TestEngine 实现添加到`maven-surefire-plugin`的依赖项中，它就可以运行基于 JUnit 4 的测试，如下所示。
+要在 JUnit5 环境中执行 **JUnit4 测试**，您将需要`JUnit Platform Surefire Provider`插件。 只要您在 JUnit4 上配置`test`依赖项并将 JUnit Vintage TestEngine 实现添加到`maven-surefire-plugin`的依赖项中，它就可以运行基于 JUnit4 的测试，如下所示。

 ```java
 <build>
@@ -95,11 +95,11 @@

 ```

-通过在`pom.xml`中进行上述配置，现在您可以使用 junit 5 运行旧的测试。
+通过在`pom.xml`中进行上述配置，现在您可以使用 JUnit5 运行旧的测试。

-## 3\. JUnit 5 Maven 示例
+## 3\. JUnit5 Maven 示例

-用于运行用 junit 5 构建的测试的示例`pom.xml`文件如下：
+用于运行用 JUnit5 构建的测试的示例`pom.xml`文件如下：

 ```java
 <project xmlns="http://maven.apache.org/POM/4.0.0"

--- a/docs/misc1/174.md
+++ b/docs/misc1/174.md
-# JUnit 5 – 在 Eclipse 中执行测试
+# JUnit5 – 在 Eclipse 中执行测试

 > 原文： [https://howtodoinjava.com/junit5/execute-testcase-eclipse/](https://howtodoinjava.com/junit5/execute-testcase-eclipse/)

-学习在 Eclipse IDE 中执行 [junit 5](http://junit.org/junit5/) 测试。 在这个 junit 5 示例中，已使用 Maven 导入依赖项。
+学习在 Eclipse IDE 中执行 [JUnit5](http://junit.org/junit5/) 测试。 在这个 JUnit5 示例中，已使用 Maven 导入依赖项。

-## 1\. Junit 5 Maven 依赖项
+## 1\. JUnit5 Maven 依赖项

-为了能够在 Eclipse 中执行 junit 5 测试，我们需要以下依赖项。
+为了能够在 Eclipse 中执行 JUnit5 测试，我们需要以下依赖项。

 *   `test`范围中的`junit-platform-runner`：`JUnitPlatform`运行程序的位置
 *   `test`范围中的`junit-jupiter-api`：用于编写测试的 API，包括`@Test`等。当包含`junit-jupiter-engine`时，将其包括在内。
@@ -60,7 +60,7 @@

 ## 2\. `@RunWith(JUnitPlatform.class)`

-`JUnitPlatform`允许测试与 IDE 一起运行并构建支持 JUnit 4 但尚不直接支持 JUnit 平台的系统。
+`JUnitPlatform`允许测试与 IDE 一起运行并构建支持 JUnit4 但尚不直接支持 JUnit 平台的系统。

 ```java
 package net.restfulapi.demo;
@@ -105,9 +105,9 @@ public class NumericCalculator {

 您将获得以下输出。

-![Junit 5 eclipse example](img/3dcd8476fb49ca2363469c470de5d60d.png)
+![JUnit5 eclipse example](img/3dcd8476fb49ca2363469c470de5d60d.png)

-Junit 5 eclipse 示例
+JUnit5 eclipse 示例




--- a/docs/misc1/175.md
+++ b/docs/misc1/175.md
-# Eclipse 的 JUnit 5 测试模板
+# Eclipse 的 JUnit5 测试模板

 > 原文： [https://howtodoinjava.com/junit5/code-test-templates-eclipse/](https://howtodoinjava.com/junit5/code-test-templates-eclipse/)

-Eclipse 对 JUnit 测试用例提供了强大的工具支持。 在 Eclipse 中配置用于 JUnit 测试用例的[代码模板](//howtodoinjava.com/best-practices/create-eclipse-templates-for-faster-java-coding/)是加快测试开发速度的重要功能。 在 Eclipse 中学习**创建和导入 JUnit 5 测试模板。**
+Eclipse 对 JUnit 测试用例提供了强大的工具支持。 在 Eclipse 中配置用于 JUnit 测试用例的[代码模板](//howtodoinjava.com/best-practices/create-eclipse-templates-for-faster-java-coding/)是加快测试开发速度的重要功能。 在 Eclipse 中学习**创建和导入 JUnit5 测试模板。**

-## JUnit 5 测试模板
+## JUnit5 测试模板

-在以下模板文件中给出的配置三个 JUnit 5 模板方法，即
+在以下模板文件中给出的配置三个 JUnit5 模板方法，即

 1.  [`@BeforeEach`](//howtodoinjava.com/junit-5/before-each-annotation-example/)注解的`setUp()`
 2.  [`@AfterEach`](//howtodoinjava.com/junit-5/after-each-annotation-example/)注解的`tearDown()`
@@ -46,11 +46,11 @@ public void test${name}() {
 2.  Java -> 编辑器 -> 模板
 3.  导入…
 4.  选择文件
-5.  验证特定于 JUnit 5 的模板名称“`setup(JUnit5)`”，“`teardown(JUnit5)`”和“`test(JUnit5)`”
+5.  验证特定于 JUnit5 的模板名称“`setup(JUnit5)`”，“`teardown(JUnit5)`”和“`test(JUnit5)`”

-![JUnit 5 Test Templates for Eclipse](img/db1556fd280a5e72b747832500923434.png)
+![JUnit5 Test Templates for Eclipse](img/db1556fd280a5e72b747832500923434.png)

-JUnit 5 Eclipse 的测试模板
+JUnit5 Eclipse 的测试模板



@@ -58,9 +58,9 @@ JUnit 5 Eclipse 的测试模板

 要使用模板，请将光标放在新行中，然后输入 2-3 个模板方法的缩写。 现在点击`CTRL+ENTER`。 它将以下面的方式打开一个弹出窗口。

-![Use JUnit 5 Test Templates in Eclipse](img/893100246cadeae5914fc05dc90370ed.png)
+![Use JUnit5 Test Templates in Eclipse](img/893100246cadeae5914fc05dc90370ed.png)

-使用 JUnit 5 Eclipse 的测试模板
+使用 JUnit5 Eclipse 的测试模板




--- a/docs/misc1/176.md
+++ b/docs/misc1/176.md
-# JUnit 5 与 JUnit 4
+# JUnit5 与 JUnit4

 > 原文： [https://howtodoinjava.com/junit5/junit-5-vs-junit-4/](https://howtodoinjava.com/junit5/junit-5-vs-junit-4/)

-JUnit 5 旨在适应 Java 8 编码风格，并且比 JUnit 4 更加健壮和灵活。在本篇文章 **JUnit 5 vs JUnit 4** 中，我们将重点介绍 junit 4 和 junit 5 之间的一些主要区别。
+JUnit5 旨在适应 Java8 编码风格，并且比 JUnit4 更加健壮和灵活。在本篇文章 **JUnit5 vs JUnit4** 中，我们将重点介绍 JUnit4 和 JUnit5 之间的一些主要区别。

-## 1\. JUnit 5 与 JUnit 4 – 注解
+## 1\. JUnit5 与 JUnit4 – 注解

 两个版本中的大多数注解都相同，但几乎没有区别。 这是一个快速比较。

-| 特性 | JUnit 4 | Junit 5 |
+| 特性 | JUnit4 | JUnit5 |
 | --- | --- | --- |
 | 声明测试方法 | `@Test` | `@Test` |
 | 在当前类中的所有测试方法之前执行 | `@BeforeClass` | `@BeforeAll` |
@@ -21,13 +21,13 @@ JUnit 5 旨在适应 Java 8 编码风格，并且比 JUnit 4 更加健壮和灵
 | 标记和过滤 | `@Category` | `@Tag` |
 | 注册自定义扩展 | NA | `@ExtendWith` |

-## 2\. JUnit 5 和 JUnit 4 之间的其他区别
+## 2\. JUnit5 和 JUnit4 之间的其他区别

 #### 2.1 架构

-JUnit 4 将所有内容捆绑到单个 jar 文件中。
+JUnit4 将所有内容捆绑到单个 jar 文件中。

-Junit 5 由 3 个子项目组成，即 JUnit Platform，JUnit Jupiter 和 JUnit Vintage。
+JUnit5 由 3 个子项目组成，即 JUnit Platform，JUnit Jupiter 和 JUnit Vintage。

 1.  ##### JUnit 平台

@@ -39,17 +39,17 @@ Junit 5 由 3 个子项目组成，即 JUnit Platform，JUnit Jupiter 和 JUnit

 3.  ##### JUnit Vintage

-    为了支持在 JUnit 5 平台上运行 JUnit 3 和 JUnit 4 书面测试。
+    为了支持在 JUnit5 平台上运行 JUnit 3 和 JUnit4 书面测试。

 #### 2.2 所需的 JDK 版本

-Junit 4 需要 Java 5 或更高版本。
+JUnit4 需要 Java 5 或更高版本。

-Junit 5 需要 Java 8 或更高版本。
+JUnit5 需要 Java8 或更高版本。

 #### 2.3 断言

-在 Junit 4 中，[`org.junit.Assert`](http://junit.org/junit4/javadoc/4.12/org/junit/Assert.html)具有所有肯定的方法来验证预期结果和结果。
+在 JUnit4 中，[`org.junit.Assert`](http://junit.org/junit4/javadoc/4.12/org/junit/Assert.html)具有所有肯定的方法来验证预期结果和结果。
 他们接受错误消息的额外参数作为方法签名中的第一个参数。 例如：

 ```java
@@ -58,9 +58,9 @@ public static void assertEquals(String message, long expected, long actual)

 ```

-在 JUnit 5 中，[`org.junit.jupiter.Assertions`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assertions.html)包含大多数断言方法，包括其他`assertThrows()`和`assertAll()`方法。 到目前为止，`assertAll()`处于实验状态，用于分组断言。
+在 JUnit5 中，[`org.junit.jupiter.Assertions`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assertions.html)包含大多数断言方法，包括其他`assertThrows()`和`assertAll()`方法。 到目前为止，`assertAll()`处于实验状态，用于分组断言。

-JUnit 5 断言方法还具有重载方法，以在测试失败（例如测试失败）时支持传递要打印的错误消息。
+JUnit5 断言方法还具有重载方法，以在测试失败（例如测试失败）时支持传递要打印的错误消息。

 ```java
 public static void assertEquals(long expected, long actual)
@@ -71,7 +71,7 @@ public static void assertEquals(long expected, long actual, Supplier messageSupp

 #### 2.4 假设

-在 Junit 4 中，[`org.junit.Assume`](http://junit.org/junit4/javadoc/4.12/org/junit/Assume.html)包含一些方法，用于陈述有关测试有意义的条件的假设。 它具有以下五种方法：
+在 JUnit4 中，[`org.junit.Assume`](http://junit.org/junit4/javadoc/4.12/org/junit/Assume.html)包含一些方法，用于陈述有关测试有意义的条件的假设。 它具有以下五种方法：

 1.  `assumeFalse()`
 2.  `assumeNoException()`
@@ -79,7 +79,7 @@ public static void assertEquals(long expected, long actual, Supplier messageSupp
 4.  `assumeThat()`
 5.  `assumeTrue()`

-在 Junit 5 中，[`org.junit.jupiter.api.Assumptions`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assumptions.html) 包含一些方法，用于陈述有关测试有意义的条件的假设。 它具有以下三种方法：
+在 JUnit5 中，[`org.junit.jupiter.api.Assumptions`](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assumptions.html) 包含一些方法，用于陈述有关测试有意义的条件的假设。 它具有以下三种方法：

 1.  `assumeFalse()`
 2.  `assumingThat()`
@@ -87,13 +87,13 @@ public static void assertEquals(long expected, long actual, Supplier messageSupp

 #### 2.5 标记和过滤

-在 Junit 4 中，使用`@category`注解。
+在 JUnit4 中，使用`@category`注解。

-在 Junit 5 中，使用`@tag`注解。
+在 JUnit5 中，使用`@tag`注解。

 #### 2.6 测试套件

-在 Junit 4 中，`@RunWith`和`@Suite`注解。 例如：
+在 JUnit4 中，`@RunWith`和`@Suite`注解。 例如：

 ```java
 import org.junit.runner.RunWith;
@@ -110,7 +110,7 @@ public class JUnit4Example

 ```

-在 Junit 5 中，`@RunWith`，`@SelectPackages`和`@SelectClasses`例如：
+在 JUnit5 中，`@RunWith`，`@SelectPackages`和`@SelectClasses`例如：

 ```java
 import org.junit.platform.runner.JUnitPlatform;
@@ -127,10 +127,10 @@ public class JUnit5Example

 #### 2.7 第三方整合

-在 Junit 4 中，不支持对第三方插件和 IDE 的集成。 他们必须依靠[反射](//howtodoinjava.com/java/related-concepts/real-usage-examples-of-reflection-in-java/)。
+在 JUnit4 中，不支持对第三方插件和 IDE 的集成。 他们必须依靠[反射](//howtodoinjava.com/java/related-concepts/real-usage-examples-of-reflection-in-java/)。

-JUnit 5 为此有专门的子项目，即 JUnit Platform。 它定义了`TestEngine` API，用于开发在平台上运行的测试框架。
+JUnit5 为此有专门的子项目，即 JUnit Platform。 它定义了`TestEngine` API，用于开发在平台上运行的测试框架。

-请在评论部分中对 junit 5 和 junit 4 之间的**比较发表您的看法。**
+请在评论部分中对 JUnit5 和 JUnit4 之间的**比较发表您的看法。**

 学习愉快！
\ No newline at end of file
--- a/docs/misc1/177.md
+++ b/docs/misc1/177.md
-# JUnit 4 教程
\ No newline at end of file
+# JUnit4 教程
\ No newline at end of file
--- a/docs/misc1/178.md
+++ b/docs/misc1/178.md
@@ -30,7 +30,7 @@ dependencies {

 *   #### JUnit Jar 文件

-    单击链接以下载 [JUnit 4.12 jar 文件](http://central.maven.org/maven2/junit/junit/4.12/junit-4.12.jar)。
+    单击链接以下载 [JUnit4.12 jar 文件](http://central.maven.org/maven2/junit/junit/4.12/junit-4.12.jar)。

 ## JUnit 注解


--- a/docs/misc1/179.md
+++ b/docs/misc1/179.md
@@ -9,7 +9,7 @@
 1.  **`@RunWith`**
 2.  **`@SuiteClasses`**

-> 阅读更多： [JUnit 5 测试套件](https://howtodoinjava.com/junit5/junit5-test-suites-examples/)
+> 阅读更多： [JUnit5 测试套件](https://howtodoinjava.com/junit5/junit5-test-suites-examples/)

 ## 1\. JUnit 测试套件示例


--- a/docs/misc1/180.md
+++ b/docs/misc1/180.md
@@ -6,7 +6,7 @@

 [**`JUnitCore`**](http://junit.sourceforge.net/javadoc/org/junit/runner/JUnitCore.html "JUnitCore")是 JUnit 包中的内置类，它基于**外观设计模式**。 `JUnitCore`类仅用于运行指定的测试类。

-> 阅读更多： [JUnit 5 测试套件](https://howtodoinjava.com/junit5/junit5-test-suites-examples/)
+> 阅读更多： [JUnit5 测试套件](https://howtodoinjava.com/junit5/junit5-test-suites-examples/)

 ## 1\. `JUnitCore`示例


--- a/docs/misc1/182.md
+++ b/docs/misc1/182.md
-# JUnit 4 – 基于假设的测试用例
+# JUnit4 – 基于假设的测试用例

 > 原文： [https://howtodoinjava.com/junit/assumption-based-testcases-in-junit-4/](https://howtodoinjava.com/junit/assumption-based-testcases-in-junit-4/)


--- a/docs/misc1/185.md
+++ b/docs/misc1/185.md
-# JUnit 测试超时– JUnit 5 超时示例
+# JUnit 测试超时 – JUnit5 超时示例

 > 原文： [https://howtodoinjava.com/junit/how-to-force-timeout-in-jnuit-testcase-execution/](https://howtodoinjava.com/junit/how-to-force-timeout-in-jnuit-testcase-execution/)

-学习编写具有超时行为的 JUnit 测试。 如果任何测试未在给定的时限内完成执行，则 JUnit 将停止执行。 还学习使用断言使用 **JUnit 5 测试超时**。
+学习编写具有超时行为的 JUnit 测试。 如果任何测试未在给定的时限内完成执行，则 JUnit 将停止执行。 还学习使用断言使用 **JUnit5 测试超时**。

 ## 1\. 为什么要编写 JUnit 超时测试？

@@ -69,9 +69,9 @@ public void testInfiniteTametakingLoop2() throws InterruptedException

 请注意，以上超时时间`@Rule`同样适用于`@Before`和`@After`方法。 因此，请小心使用。

-## 4\. 使用断言的 JUnit 5 超时
+## 4\. 使用断言的 JUnit5 超时

-在 [**JUnit 5**](https://howtodoinjava.com/junit-5-tutorial/) 中，我们可以使用[断言](https://howtodoinjava.com/junit5/junit-5-assertions-examples/)强制测试超时。
+在 [**JUnit5**](https://howtodoinjava.com/junit-5-tutorial/) 中，我们可以使用[断言](https://howtodoinjava.com/junit5/junit-5-assertions-examples/)强制测试超时。

 ```java
 import static java.time.Duration.ofMillis;

--- a/docs/misc1/186.md
+++ b/docs/misc1/186.md
@@ -6,7 +6,7 @@

 ## 1\. JUnit 方法排序器

-从 JUnit 4.11 版本开始引入`MethodSorters`。 此类声明了三种执行顺序，可以在测试用例中使用它们。
+从 JUnit4.11 版本开始引入`MethodSorters`。 此类声明了三种执行顺序，可以在测试用例中使用它们。

 1.  **`MethodSorters.DEFAULT`** – 以确定但不可预测的顺序对测试方法进行排序。
 2.  **`MethodSorters.JVM`** - 按照 JVM 返回的顺序保留测试方法。
@@ -52,7 +52,7 @@ Executing third test

 ```

-## 2\. JUnit 有序测试示例– JVM
+## 2\. JUnit 有序测试示例 – JVM

 现在使用`JVM`选项执行相同的测试。


--- a/docs/misc1/187.md
+++ b/docs/misc1/187.md
@@ -105,7 +105,7 @@ public class JunitTestsWithParameters {

 现在检查程序输出。

-![junit 4 test execution](img/234b893e7bbf4fc4ff939748e24d137a.png "junit 4 test execution")
+![JUnit4 test execution](img/234b893e7bbf4fc4ff939748e24d137a.png "JUnit4 test execution")

 测试执行结果


--- a/docs/misc1/191.md
+++ b/docs/misc1/191.md
@@ -6,7 +6,7 @@ TestNG 是一个受 JUnit 和 NUnit 启发的测试框架，但引入了一些

 此页面列出了此博客中有关 TestNG 的所有可用教程。 在 TestNG 上发布新教程后，将立即更新此页面。

-## 安装与安装
+## 安装与配置

 #### [将 TestNG 安装到 Eclipse 上并执行第一个测试](//howtodoinjava.com/testng/testng-tutorial-with-eclipse/ "TestNG Tutorial (With Eclipse)")

@@ -19,7 +19,7 @@ TestNG 是一个受 JUnit 和 NUnit 启发的测试框架，但引入了一些
 *   创建您的第一个 TestNG 类
 *   运行 TestNG 测试

-## 开始于 TestNG
+## 启用 TestNG

 #### [注解教程](//howtodoinjava.com/testng/testng-annotations-tutorial/ "TestNG Annotations Tutorial")

@@ -45,7 +45,7 @@ TestNG 使用注解来帮助开发人员编写测试。 了解 TestNG 提供的

 TestNG 的重要功能之一是参数化。 此功能允许用户将参数值作为参数传递给测试方法。 通过使用`@Parameters`注解支持此功能。

-## 先进概念
+## 高级概念

 #### [通过`@DataProvider`传递参数](//howtodoinjava.com/testng/testng-test-parameters-through-dataprovider/ "TestNG – Test Parameters through @DataProvider") 


--- a/docs/misc1/192.md
+++ b/docs/misc1/192.md
@@ -22,7 +22,7 @@ Running TestNG test

 [TestNG](http://testng.org/doc/index.html "testng")，其中 **NG 代表“下一代”**，是受 [JUnit](//howtodoinjava.com/junit/ "JUnit Tutorials") （Java）和 NUnit（C#）启发的测试自动化框架。 它可以用于单元，功能，集成和端到端测试。 TestNG 在短时间内获得了很大的普及，并且是 Java 开发人员中使用最广泛的测试框架之一。 它主要使用 Java 注解来配置和编写测试方法。

-TestNG 在 JUnit 4 上具有的一些功能是：
+TestNG 在 JUnit4 上具有的一些功能是：

 *   额外的之前和之后注解，例如“之前/之后”套件和“之前/之后”组
 *   依赖项测试

--- a/docs/misc1/194.md
+++ b/docs/misc1/194.md
@@ -10,8 +10,8 @@ TestNG 使用注解来帮助开发人员编写测试。 下表是包含有关 Te
 | --- | --- |
 | [**`@BeforeSuite`**](https://static.javadoc.io/org.testng/testng/6.8.21/org/testng/annotations/BeforeSuite.html "BeforeSuite") | 带注解的方法将在 TestNG 套件内声明的任何测试之前执行。 |
 | [**`@AfterSuite`**](http://testng.org/javadoc/org/testng/annotations/AfterSuite.html "AfterSuite") | 带注解的方法将在 TestNG 套件内声明的任何测试之后执行。 |
-| [**`@BeforeTest`**](http://testng.org/javadoc/org/testng/annotations/BeforeTest.html "BeforeTest") | 带注解的方法将在 TestNG 套件中声明的每个测试节之前执行。 |
-| [**@AfterTest**](http://testng.org/javadoc/org/testng/annotations/AfterTest.html "AfterTest") | 带注解的方法将在 TestNG 套件中声明的每个测试节之后执行。 |
+| [**`@BeforeTest`**](http://testng.org/javadoc/org/testng/annotations/BeforeTest.html "BeforeTest") | 带注解的方法将在 TestNG 套件中声明的每个测试部分之前执行。 |
+| [**@AfterTest**](http://testng.org/javadoc/org/testng/annotations/AfterTest.html "AfterTest") | 带注解的方法将在 TestNG 套件中声明的每个测试部分之后执行。 |
 | [**`@BeforeGroups`**](http://testng.org/javadoc/org/testng/annotations/BeforeGroups.html "BeforeGroups") | 带注解的方法将在执行指定组的任何测试方法之前运行。 |
 | [**`@AfterGroups`**](http://testng.org/javadoc/org/testng/annotations/AfterGroups.html "AfterGroups") | 带注解的方法将在指定组的任何测试方法执行后运行。 |
 | [`@BeforeClass`](http://testng.org/javadoc/org/testng/annotations/BeforeClass.html "BeforeClass") | 带注解的方法在测试类的任何测试方法之前执行。 |

--- a/docs/misc1/195.md
+++ b/docs/misc1/195.md
-# TestNG –预期异常和预期消息教程
+# TestNG – 预期异常和预期消息教程

 > 原文： [https://howtodoinjava.com/testng/testng-expected-exception-and-expected-message-tutorial/](https://howtodoinjava.com/testng/testng-expected-exception-and-expected-message-tutorial/)


--- a/docs/misc1/197.md
+++ b/docs/misc1/197.md
@@ -27,7 +27,7 @@ Table Of Contents

 在 TestNG 中可以使用多种不同的方式配置并行功能。

-## 2\. 运行并行的 testng 测试用例
+## 2\. 并行运行 testng 测试用例

 TestNG 提供了多种方法**在多线程条件**中执行测试，其中一种方法是在单个线程中执行每种测试方法。 此模式显着减少了执行时间，因为可以并行执行更多测试，从而减少了总执行时间。

@@ -196,7 +196,7 @@ After test-class. Thread id is: 9

 先前的测试结果清楚地表明，每个测试类及其各自的`beforeClass`和`afterClass`方法都是在不同的线程中执行的。 这由控制台上打印的线程的 ID 标识。

-## 4\. TestNG 运行并行套件
+## 4\. 并行运行 TestNG 套件

 让我们学习一下**在套件**中并行执行每个测试，也就是说，作为测试套件执行一部分的每个测试都将在各自独立的线程中执行。


--- a/docs/misc1/291.md
+++ b/docs/misc1/291.md
@@ -6,7 +6,7 @@

 ## 1\. 先决条件

-*   **需要 Java 8** 才能从 Kafka 网站运行最新下载。
+*   **需要 Java8** 才能从 Kafka 网站运行最新下载。
 *   **Zookeeper** （用于存储有关 Kafka 群集的元数据）也是必需的。 Kafka 首先内置了 Zookeeper。 但是建议在生产环境中单独安装 Zookeeper。 从其[官方网站](https://zookeeper.apache.org/releases.html)下载它。
 *   Kafka 可以在任何操作系统上运行。 推荐使用 linux 操作系统。 使用 Windows，Kafka 有一些已知的错误。


--- a/docs/misc1/292.md
+++ b/docs/misc1/292.md
@@ -14,7 +14,7 @@
 ## 1\. 先决条件

 *   请按照本指南在您的机器上设置 [Kafka](https://howtodoinjava.com/kafka/getting-started-windows-10/) 。
-*   我们正在创建一个基于 Maven 的 Spring 引导应用，因此您的计算机应至少安装 [Java 8](https://howtodoinjava.com/java/basics/jdk-jre-jvm/#downloads) 和 [Maven](https://howtodoinjava.com/maven/how-to-install-maven-on-windows/) 。
+*   我们正在创建一个基于 Maven 的 Spring 引导应用，因此您的计算机应至少安装 [Java8](https://howtodoinjava.com/java/basics/jdk-jre-jvm/#downloads) 和 [Maven](https://howtodoinjava.com/maven/how-to-install-maven-on-windows/) 。

 ## 2\. Spring Boot 应用


--- a/docs/misc1/293.md
+++ b/docs/misc1/293.md
@@ -8,7 +8,7 @@

 *   请按照本指南在您的机器上设置 [Kafka](https://howtodoinjava.com/kafka/getting-started-windows-10/) 。
 *   我们正在修改 [Spring boot 和 Kafka hello world 应用](https://howtodoinjava.com/kafka/spring-boot-with-kafka/)。
-*   还要确保您的计算机上至少安装了 [Java 8](https://howtodoinjava.com/java/basics/jdk-jre-jvm/#downloads) 和 [Maven](https://howtodoinjava.com/maven/how-to-install-maven-on-windows/) 。
+*   还要确保您的计算机上至少安装了 [Java8](https://howtodoinjava.com/java/basics/jdk-jre-jvm/#downloads) 和 [Maven](https://howtodoinjava.com/maven/how-to-install-maven-on-windows/) 。

 ## 2\. 应用配置


--- a/docs/misc1/33.md
+++ b/docs/misc1/33.md
@@ -2,7 +2,7 @@

 > 原文： [https://howtodoinjava.com/log4j2/log4j-2-json-configuration-example/](https://howtodoinjava.com/log4j2/log4j-2-json-configuration-example/)

-[Apache Log4j2](https://logging.apache.org/log4j/2.x/) 是对 Log4j 1.x 的升级，在性能上进行了重大改进，改进了配置文件的自动重装，java 8 lambda 支持和自定义日志级别，从而大大改进了 Log4j1.x。 除了 [XML](//howtodoinjava.com/log4j2/log4j-2-xml-configuration-example/) 和[属性](//howtodoinjava.com/log4j2/log4j-2-properties-file-configuration-example)文件外，还可以使用 **JSON** 配置 Log4j。
+[Apache Log4j2](https://logging.apache.org/log4j/2.x/) 是对 Log4j 1.x 的升级，在性能上进行了重大改进，改进了配置文件的自动重装，Java8 lambda 支持和自定义日志级别，从而大大改进了 Log4j1.x。 除了 [XML](//howtodoinjava.com/log4j2/log4j-2-xml-configuration-example/) 和[属性](//howtodoinjava.com/log4j2/log4j-2-properties-file-configuration-example)文件外，还可以使用 **JSON** 配置 Log4j。

 ## Log4j2 依赖项


--- a/docs/misc1/34.md
+++ b/docs/misc1/34.md
@@ -4,7 +4,7 @@

 学习配置`log4j2.properties`文件，以将日志语句输出到控制台，滚动文件等。学习配置 **log4j2** 附加器，级别和模式。

-Apache [Log4j2](https://logging.apache.org/log4j/2.x/) 是 Log4j 1.x 的升级版，对它的前身进行了重大改进，例如性能提高，自动重新加载已修改的配置文件， [Java 8 lambda](https://howtodoinjava.com/java8/complete-lambda-expressions-tutorial-in-java/) 支持和自定义 [日志级别](https://howtodoinjava.com/log4j/logging-levels-in-log4j/)。
+Apache [Log4j2](https://logging.apache.org/log4j/2.x/) 是 Log4j 1.x 的升级版，对它的前身进行了重大改进，例如性能提高，自动重新加载已修改的配置文件， [Java8 lambda](https://howtodoinjava.com/java8/complete-lambda-expressions-tutorial-in-java/) 支持和自定义 [日志级别](https://howtodoinjava.com/log4j/logging-levels-in-log4j/)。

 ## 1\. Log4j2 Maven 依赖项


--- a/docs/misc1/35.md
+++ b/docs/misc1/35.md
@@ -2,7 +2,7 @@

 > 原文： [https://howtodoinjava.com/log4j2/log4j-2-xml-configuration-example/](https://howtodoinjava.com/log4j2/log4j-2-xml-configuration-example/)

-[Apache Log4j2](https://logging.apache.org/log4j/2.x/) 是对 Log4j 1.x 的升级，与以前的版本相比有了显着改进，例如性能提高，自动重新加载已修改的配置文件， [Java 8 lambda](https://howtodoinjava.com/java-8-tutorial/) 支持和自定义日志级别。
+[Apache Log4j2](https://logging.apache.org/log4j/2.x/) 是对 Log4j 1.x 的升级，与以前的版本相比有了显着改进，例如性能提高，自动重新加载已修改的配置文件， [Java8 lambda](https://howtodoinjava.com/java-8-tutorial/) 支持和自定义日志级别。

 Log4j2.4 及更高版本需要 Java 7。 版本 2.0-alpha1 至 2.3 需要 Java 6。


--- a/docs/misc1/5.md
+++ b/docs/misc1/5.md
@@ -117,7 +117,7 @@ $ mvn dependency:tree

 为了解决此类版本不匹配的问题，maven 提供了`<exclusion>`标记，以打破传递依赖项。

-例如，当您在类路径中具有 JUnit 4.12 并包括 DBUnit 依赖项时，则需要删除 JUnit 3.8.2 依赖项。 可以使用`exclusion`标签完成。
+例如，当您在类路径中具有 JUnit4.12 并包括 DBUnit 依赖项时，则需要删除 JUnit 3.8.2 依赖项。 可以使用`exclusion`标签完成。

 ```java
 <dependency>

--- a/docs/misc1/60.md
+++ b/docs/misc1/60.md
@@ -16,7 +16,7 @@ Request Validation
 Verify REST APIs
 ```

-您将需要 **Java 8** 来运行此代码中给出的示例，这些示例是使用 dropwizard 1.0.0 版开发的。
+您将需要 **Java8** 来运行此代码中给出的示例，这些示例是使用 dropwizard 1.0.0 版开发的。

 ## dropwizard 中包含的库