提交 c898a3f9 编写于 作者: W wizardforcel

2020-06-04 16:23:23

上级 8cd6b772
......@@ -103,7 +103,7 @@ HQL 是一种类似于 SQL 的面向对象的查询语言,但是 HQL 不会对
* 插入操作
* 选择操作
2. `from`子句和别名
3. 选择子句和投影
3. `select`子句和投影
4. 使用命名参数
5. 分页结果集
6. 获得独特的结果
......
......@@ -4,9 +4,9 @@
在任何应用中,Hiberate 模式都以急切或惰性模式从数据库读取数据。 **Hiberate 延迟加载**是指按需延迟加载数据时的策略。
## 1\. Hiberate 延迟加载-我们为什么需要它?
## 1\. Hiberate 延迟加载 - 我们为什么需要它?
考虑一种常见的 Internet Web 应用:在线商店。 商店维护产品目录。 在最原始的级别上,可以将其建模为管理一系列产品实体的目录实体。 在一家大型商店中,可能有成千上万种产品归为各种重叠类别。
考虑一种常见的互联网 Web 应用:在线商店。 商店维护产品目录。 在最原始的级别上,可以将其建模为管理一系列产品实体的目录实体。 在一家大型商店中,可能有成千上万种产品归为各种重叠类别。
当客户端访问商店时,必须从数据库中加载目录。 我们可能不希望实现将代表成千上万种产品的每个实体中的每一个加载到内存中。 对于足够大的零售商,鉴于机器上可用的物理内存量,这甚至可能是不可能的。
......@@ -24,7 +24,7 @@ Category category = (Category)session.get(Category.class,new Integer(42));
```
但是,如果访问了该类别的所有产品,并且执行了延迟加载,则**,则会根据需要从数据库中拉出产品**。 例如,在以下代码段中,将加载关联的产品对象,因为在第二行中已明确引用了该产品。
但是,如果访问了该类别的所有产品,并且执行了延迟加载,则会根据需要从数据库中拉出产品。 例如,在以下代码段中,将加载关联的产品对象,因为在第二行中已明确引用了该产品。
```java
//Following code loads only a single category from the database
......@@ -41,11 +41,11 @@ Set<Product> products = category.getProducts();
在进一步进行操作之前,重要的是要重述延迟加载的默认行为,以防使用 Hiberate 映射和注释。
The default behavior is to load ‘property values eagerly’ and to load ‘collections lazily’. Contrary to what you might remember if you have used plain Hibernate 2 (mapping files) before, where all references (including collections) are loaded eagerly by default.
默认行为是紧急加载“属性值”和延迟加载“集合”。 如果您以前使用过普通的 Hibernate 2(映射文件),则默认情况下会急切加载所有引用(包括集合),这与您可能会记得的相反。
另请注意,[`@OneToMany`](https://howtodoinjava.com/hibernate/hibernate-one-to-many-mapping-using-annotations/)`@ManyToMany`关联默认为`LAZY`加载; [`@OneToOne`](https://howtodoinjava.com/hibernate/hibernate-one-to-one-mapping-using-annotations/)`@ManyToOne`默认为 EAGER 加载。 记住这一点很重要,以避免将来出现任何陷阱。
另请注意,[`@OneToMany`](https://howtodoinjava.com/hibernate/hibernate-one-to-many-mapping-using-annotations/)`@ManyToMany`关联默认为`LAZY`加载; [`@OneToOne`](https://howtodoinjava.com/hibernate/hibernate-one-to-one-mapping-using-annotations/)`@ManyToOne`默认为 EAGER 加载。 记住这一点很重要,以避免将来出现任何陷阱。
要显式启用延迟加载,必须在使用 Hiberate 注释时要延迟加载的关联上使用**“ fetch = FetchType.LAZY”**
要显式启用延迟加载,必须在使用 Hiberate 注释时要延迟加载的关联上使用`fetch = FetchType.LAZY`
一个 **hibernare 延迟加载示例**如下所示:
......@@ -55,21 +55,21 @@ private Set<ProductEntity> products;
```
`"FetchType.LAZY"`平行的另一个属性是`"FetchType.EAGER"`,它与 LAZY 正好相反,即,当首次获取所有者实体时,它也会加载关联实体。
`"FetchType.LAZY"`平行的另一个属性是`"FetchType.EAGER"`,它与`LAZY`正好相反,即,当首次获取所有者实体时,它也会加载关联实体。
## 4\. 延迟加载在 Hiberate 状态下如何工作
Hibernate 可以在实体和关联上应用延迟加载行为的最简单方法是**,方法是提供它们的代理实现**。 Hibernate 通过替换从实体类派生的代理来拦截对实体的调用。 如果缺少所需信息,将从控制权移交给上级实体的实现之前将其从数据库中加载。
Hibernate 可以在实体和关联上应用延迟加载行为的最简单方法是提供它们的代理实现。 Hibernate 通过替换从实体类派生的代理来拦截对实体的调用。 如果缺少所需信息,将从控制权移交给上级实体的实现之前将其从数据库中加载。
请注意,当关联表示为集合类时,将创建包器(本质上是集合的代理,而不是集合所包含的实体),并替换为原始集合。 当您访问该集合代理时,您在返回的代理集合中得到的不是代理实体;它是代理实体。 而是它们是实际的实体。 您无需在理解此概念上施加太大压力,因为在运行时几乎没有关系。
请注意,当关联表示为集合类时,将创建包器(本质上是集合的代理,而不是集合所包含的实体),并替换为原始集合。 当您访问该集合代理时,您在返回的代理集合中得到的不是代理实体;它是代理实体。 而是它们是实际的实体。 您无需在理解此概念上施加太大压力,因为在运行时几乎没有关系。
## 5\. 延迟加载对分离实体的影响
如我们所知,Hiberate 只能通过会话访问数据库,因此,如果实体与会话分离,并且当我们尝试访问尚未加载的关联(通过代理或集合包器)时, **Hibernate 抛出`LazyInitializationException`**
如我们所知,Hiberate 只能通过会话访问数据库,因此,如果实体与会话分离,并且当我们尝试访问尚未加载的关联(通过代理或集合包装器)时,**Hibernate 抛出`LazyInitializationException`**
解决方法是确保通过将实体附加到会话来使该实体再次成为持久化,或者确保在将实体从会话中分离之前,将访问所有需要的字段(将它们加载到实体中)。
这就是这个简单但非常重要的概念,即**如何在 Hiberate**中加载懒对象。 对于**Hiberate 获取策略[面试问题](https://howtodoinjava.com/java-interview-questions/)** 的初学者来说,这可能是一个问题。
这就是这个简单但非常重要的概念,即**如何在 Hiberate** 中加载惰性对象。 对于 **Hiberate 获取策略**[面试问题](https://howtodoinjava.com/java-interview-questions/)的初学者来说,这可能是一个问题。
如果不清楚或您想讨论任何事情,请发表评论。
......
此差异已折叠。
此差异已折叠。
# Hibernate @NamedQuery 教程
# Hibernate `@NamedQuery`教程
> 原文: [https://howtodoinjava.com/hibernate/hibernate-named-query-tutorial/](https://howtodoinjava.com/hibernate/hibernate-named-query-tutorial/)
Hiberate 中的命名查询是一种**技术,用于将 HQL 语句分组在单个位置**中,并在以后需要使用它们时以某种名称对其进行引用。 它**在很大程度上有助于代码清除**,因为这些 HQL 语句不再分散在整个代码中。
Hiberate 中的命名查询是一种技术,**用于将 HQL 语句分组在单个位置**中,并在以后需要使用它们时以某种名称对其进行引用。 **它在很大程度上有助于代码清除**,因为这些 HQL 语句不再分散在整个代码中。
除了上面的内容,以下是命名查询的一些次要**优势**
......@@ -18,14 +18,14 @@ Hiberate 中的命名查询是一种**技术,用于将 HQL 语句分组在单
在本教程中,我将提供一个使用注释配置的命名查询的示例。
我有一个 DepartmentEntity.java 类,它映射到数据库中的 Department 表。 我编写了两个命名查询,一个用于通过其 ID 更新部门名称,第二个用于通过其 ID 选择部门。
我有一个`DepartmentEntity.java`类,它映射到数据库中的`Department`表。 我编写了两个命名查询,一个用于通过其 ID 更新部门名称,第二个用于通过其 ID 选择部门。
命名查询定义具有两个重要属性:
* **name** :使用 Hiberate 会话定位名称查询的名称。
* **查询**:在这里,您将给出 HQL 语句以在数据库中执行。
* **`name`** :使用 Hiberate 会话定位名称查询的名称。
* **`query`**:在这里,您将给出 HQL 语句以在数据库中执行。
#### **DepartmentEntity.java**
#### `DepartmentEntity.java`
```java
@Entity
......@@ -78,7 +78,7 @@ public class DepartmentEntity implements Serializable {
为了测试,在上面的命名查询中,我编写了以下代码并执行了两个命名查询。
#### **TestHibernateNamedQuery.java**
#### **`TestHibernateNamedQuery.java`**
```java
public class TestHibernateNamedQuery
......@@ -123,7 +123,7 @@ Finance
## **要点:**
1. 使用 JPA 样式查询语言。 例如 代替表名,使用实体名。
1. 使用 JPA 样式查询语言。 例如,使用实体名代替表名。
2. 优选将命名查询仅用于基于复杂条件选择记录。 不要过多地使用它们,否则就不会在简单的 JDBC 上使用 ORM。
3. 请记住,命名查询的结果不会缓存在辅助缓存中,只有查询对象本身会被缓存。
4. 每当在代码中添加任何命名查询时,都要养成添加几个单元测试用例的习惯。 并立即运行那些单元测试用例。
......@@ -133,8 +133,7 @@ Finance
让我知道您的想法和建议。
```java
[源码下载](https://docs.google.com/file/d/0B7yo2HclmjI4T3ZHRldLY0pKc0U/edit?usp=sharing "Hibernate named query tutorial")
```
**祝您学习愉快!**
\ No newline at end of file
# Hibernate –如何定义实体之间的关联映射
# Hibernate – 如何定义实体之间的关联映射
> 原文: [https://howtodoinjava.com/hibernate/how-to-define-association-mappings-between-hibernate-entities/](https://howtodoinjava.com/hibernate/how-to-define-association-mappings-between-hibernate-entities/)
在上一教程中,我们了解了 [**Hiberate 实体**](//howtodoinjava.com/hibernate/hibernate-entity-persistence-lifecycle-states/ "Hibernate Entity / Persistence LifeCycle States") 的四种持久状态,并且我们注意到,只有在使用某些注解对 Java 对象进行注释时,hibernate 才能将其标识为持久对象。 否则,将它们视为与数据库没有直接关系的简单普通 Java 对象。 继续,当我们用 JPA 注释对 Java 类进行注释并使它们成为持久化实体时,我们可能会遇到两个实体可以关联并且必须相互引用的情况,无论是单向还是双向。 在实际在 Hiberate 实体之间创建引用之前,让我们了解一些基本知识。
在上一教程中,我们了解了 [**Hiberate 实体**](//howtodoinjava.com/hibernate/hibernate-entity-persistence-lifecycle-states/ "Hibernate Entity / Persistence LifeCycle States")的四种持久状态,并且我们注意到,只有在使用某些注解对 Java 对象进行注释时,hibernate 才能将其标识为持久对象。 否则,将它们视为与数据库没有直接关系的简单普通 Java 对象。 继续,当我们用 JPA 注释对 Java 类进行注释并使它们成为持久化实体时,我们可能会遇到两个实体可以关联并且必须相互引用的情况,无论是单向还是双向。 在实际在 Hiberate 实体之间创建引用之前,让我们了解一些基本知识。
## 了解实体及其关联
实体可以包含对其他实体的引用,可以直接作为嵌入式属性或字段,也可以通过某种集合(数组,集合,列表等)间接包含对其他实体的引用。 这些关联使用基础表中的外键关系表示**。 这些外键将依赖于参与表使用的标识符。**
实体可以包含对其他实体的引用,可以直接作为嵌入式属性或字段,也可以通过某种集合(数组,集合,列表等)间接包含对其他实体的引用。 这些关联使用基础表中的外键关系表示。 这些外键将依赖于参与表使用的标识符。
当一对实体中只有一个包含对另一个实体的引用时,关联为**单向**。 如果关联是相互的,则称为**双向**
A common mistake by beginners, when designing entity models, is to try to make all associations bidirectional. Remember that associations that are not a natural part of the object model should not be forced into it. Hibernate Query Language (HQL) often proves a more natural way to access the required information when needed.
初学者在设计实体模型时的一个常见错误是试图使所有关联都是双向的。 请记住,不是对象模型的自然组成部分的关联不应被强加到其中。 Hibernate 查询语言(HQL)通常被证明是在需要时访问所需信息的更自然的方法。
理想情况下,我们希望指示仅对关系一端的更改会导致外键的任何更新。 实际上,Hibernate 允许我们通过将关联的一端标记为由另一端管理来做到这一点。
**在 Hiberate 映射关联中,一个参与类(只有一个)被称为“管理关系”,而另一类则使用“ mappedBy”属性被“管理于”。 我们不应该使结社的两端都“管理关系”。 永远不要做。**
**在 Hiberate 映射关联中,一个参与类(只有一个)“管理关系”,而另一类则使用“`mappedBy`”属性“被管理”。 我们不应该使关联的两端都“管理关系”。 永远不要做。**
Note that “`mappedBy`” is purely about how the foreign key relationships between entities are saved. It has nothing to do with saving the entities themselves using cascade functionality.
注意,“`mappedBy`”纯粹是关于实体之间的外键关系如何保存的。 它与使用级联功能保存实体本身无关。
尽管 Hibernate 让我们指定对一个关联的更改将导致对数据库的更改,但是它不允许我们使对关联的一端的更改自动反映在 Java POJO 的另一端。 为此,我们必须使用级联功能。
## 通过示例了解关联
让我们快速构建示例,以了解我们上面已阅读的有关实体关联的内容以及应如何完成。 在此示例中,我使用两个简单实体`(AccountEntity``EmployeeEntity`),然后在它们之间创建 **[一对一关联](//howtodoinjava.com/hibernate/hibernate-one-to-one-mapping-using-annotations/ "Hibernate one-to-one mapping using annotations")** 。 然后,我们将看到各种关联选项如何改变运行时行为和复杂性。
让我们快速构建示例,以了解我们上面已阅读的有关实体关联的内容以及应如何完成。 在此示例中,我使用两个简单实体`(AccountEntity``EmployeeEntity`),然后在它们之间创建 [**一对一关联**](//howtodoinjava.com/hibernate/hibernate-one-to-one-mapping-using-annotations/ "Hibernate one-to-one mapping using annotations")。 然后,我们将看到各种关联选项如何改变运行时行为和复杂性。
**AccountEntity.java**
**`AccountEntity.java`**
```java
@Entity
......@@ -49,7 +49,7 @@ public class AccountEntity implements Serializable
```
**EmployeeEntity.java**
**`EmployeeEntity.java`**
```java
@Entity
......@@ -76,7 +76,7 @@ public class EmployeeEntity implements Serializable
#### 方案 1)由两个实体管理的关联
在这种类型的关联中,我们将使用@OneToOne 注释如下定义关联。
在这种类型的关联中,我们将使用`@OneToOne`注释如下定义关联。
```java
//Inside EmployeeEntity.java
......@@ -89,7 +89,7 @@ EmployeeEntity employee;
```
通过上述关联,两端都在管理关联,因此必须使用实体 java 文件中定义的 setter 方法使用彼此的信息来更新双方。 如果您未这样做,则将无法获取关联的实体信息,并且该信息将作为 null 返回。
通过上述关联,两端都在管理关联,因此必须使用实体 java 文件中定义的设置器方法使用彼此的信息来更新双方。 如果您未这样做,则将无法获取关联的实体信息,并且该信息将作为`null`返回。
```java
public class TestHibernate
......@@ -150,11 +150,11 @@ Exception in thread "main" java.lang.NullPointerException
```
您会看到我已经在客户实体中设置了帐户实体,所以我能够得到它。 但是我注释了“ `acc.setEmployee(emp);`”行,因此未在帐户实体内部设置雇员实体,因此我无法获取它。
您会看到我已经在客户实体中设置了帐户实体,所以我能够得到它。 但是我注释了“`acc.setEmployee(emp);`”行,因此未在帐户实体内部设置雇员实体,因此我无法获取它。
还要注意上面的插入查询。 这两个表都具有与列名 ***employee_ID*** 和 ***account_ID*** 对应的外键关联。 它是数据中**循环依赖项**的示例,可以随时轻松关闭您的应用。
还要注意上面的插入查询。 这两个表都具有与列名`employee_ID``account_ID`对应的外键关联。 它是数据中**循环依赖项**的示例,可以随时轻松关闭您的应用。
要正确存储上述关系,必须取消注释“ `acc.setEmployee(emp);`”行。 取消注释该行后,您将能够根据需要存储和检索关联,但是仍然存在循环依赖关系。
要正确存储上述关系,必须取消注释“`acc.setEmployee(emp);`”行。 取消注释该行后,您将能够根据需要存储和检索关联,但是仍然存在循环依赖关系。
取消注释该行后,输出将如下所示:
......@@ -178,7 +178,7 @@ DUMMY_ACCOUNT
#### 场景 2)由单个实体管理的关联
假设关联是由 EmployeeEntity 管理的,那么两个实体中的注释将如下所示。
假设关联是由`EmployeeEntity`管理的,那么两个实体中的注释将如下所示。
```java
//Inside EmployeeEntity.java
......@@ -191,7 +191,7 @@ EmployeeEntity employee;
```
现在告诉 Hiberate 状态,该关联是由`EmployeeEntity`管理的,我们将在`AccountEntity`中添加' **mappingBy** '属性以使其易于管理。 现在,要测试上述代码,我们将只需要使用“ `emp.setAccount(acc);`”设置一次关联,并且由员工实体来管理该关系。 `AccountEntity`不需要明确地知道任何事情。
现在告诉 Hiberate 状态,该关联是由`EmployeeEntity`管理的,我们将在`AccountEntity`中添加`mappingBy`属性以使其易于管理。 现在,要测试上述代码,我们将只需要使用“`emp.setAccount(acc);`”设置一次关联,并且由员工实体来管理该关系。 `AccountEntity`不需要明确地知道任何事情。
让我们看看下面的测试运行。
......@@ -247,17 +247,16 @@ DUMMY_ACCOUNT
```
您会看到您不需要告诉帐户实体任何内容(“ `acc.setEmployee(emp)`”已注释)。 员工实体通过两种方式管理关联。
您会看到您不需要告诉帐户实体任何内容(“`acc.setEmployee(emp)`”已注释)。 员工实体通过两种方式管理关联。
另一个观察结果是关于外键列,我们现在只有一个外键列,即 ***account_ID*** 是 Employee 表。 因此也没有循环依赖。 都好。
另一个观察结果是关于外键列,我们现在只有一个外键列,即`account_ID``Employee`表。 因此也没有循环依赖。 都好。
## 定义各种映射关联的指南
上面的示例显示了如何在一对一映射中管理实体之间的关联。 在上面的示例中,我们也可以选择由 **AccountEntity** 管理的关联,并且只需进行较小的代码更改即可完成所有工作。 但是,在其他映射的情况下(例如,一对多或多对一),您将无法随意定义关联。 您需要规则。
上面的示例显示了如何在一对一映射中管理实体之间的关联。 在上面的示例中,我们也可以选择由`AccountEntity`管理的关联,并且只需进行较小的代码更改即可完成所有工作。 但是,在其他映射的情况下(例如,一对多或多对一),您将无法随意定义关联。 您需要规则。
下表显示了如何选择关系的一方,该一方应成为双向关联的所有者。 **请记住,要使关联成为所有者,您必须将另一端标记为被另一**映射
下表显示了如何选择关系的一方,该一方应成为双向关联的所有者。 **请记住,要使关联成为所有者,您必须将另一端标记为被另一端映射**
[您的表]
| **关联类型** | **选项/用法** |
| --- | --- |
......@@ -266,9 +265,8 @@ DUMMY_ACCOUNT
| 多对一 | 这与从相反的角度看的一对多关系相同,因此适用相同的规则:必须使多头成为关联的所有者。 |
| 多对多 | 关联的任何一端都可以成为所有者。 |
[/ your_table]
如果这一切看起来都令人困惑,请记住**关联所有权仅与数据库**中外键的管理有关。 我建议您阅读之前的教程,讨论“ [**一对一映射**](//howtodoinjava.com/hibernate/hibernate-one-to-one-mapping-using-annotations/ "Hibernate one-to-one mapping using annotations") ”,“ [**一对多映射**](//howtodoinjava.com/hibernate/hibernate-one-to-many-mapping-using-annotations/ "Hibernate one-to-many mapping using annotations") ”和“ [**多对多映射**](//howtodoinjava.com/hibernate/hibernate-many-to-many-mapping-using-annotations/ "Hibernate many-to-many mapping using annotations") ”的详细信息。 他们将帮助您建立更强大的概念。
如果这一切看起来都令人困惑,请记住**关联所有权仅与数据库**中外键的管理有关。 我建议您阅读之前的教程,讨论“[**一对一映射**](//howtodoinjava.com/hibernate/hibernate-one-to-one-mapping-using-annotations/ "Hibernate one-to-one mapping using annotations")”,“[**一对多映射**](//howtodoinjava.com/hibernate/hibernate-one-to-many-mapping-using-annotations/ "Hibernate one-to-many mapping using annotations")”和“[**多对多映射**](//howtodoinjava.com/hibernate/hibernate-many-to-many-mapping-using-annotations/ "Hibernate many-to-many mapping using annotations")”的详细信息。 他们将帮助您建立更强大的概念。
如果您有任何问题,请在下面给我留言。
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/hibernate/hibernate-oscache-configuration-example-tutorial/](https://howtodoinjava.com/hibernate/hibernate-oscache-configuration-example-tutorial/)
[**OSCache**](//howtodoinjava.com/category/frameworks/oscache/ "oscache tutorials") 是 OpenSymphony 开发的 Java 框架,可轻松在 Web 应用中缓存内容。 使用 Hiberate 模式,可以将其配置为充当 **[二级缓存](//howtodoinjava.com/hibernate/how-hibernate-second-level-cache-works/ "How hibernate second level cache works?")**
[**OSCache**](//howtodoinjava.com/category/frameworks/oscache/ "oscache tutorials") 是 OpenSymphony 开发的 Java 框架,可轻松在 Web 应用中缓存内容。 使用 Hiberate 模式,可以将其配置为充当 [**二级缓存**](//howtodoinjava.com/hibernate/how-hibernate-second-level-cache-works/ "How hibernate second level cache works?")
在我的前一篇文章中,我们了解了 [**与 Hiberate**](//howtodoinjava.com/hibernate/hibernate-ehcache-configuration-tutorial/ "Hibernate EhCache configuration tutorial") 配置 EhCache 的过程,这是 Hiberate 中的默认二级缓存。 在本文中,我以使用 [**Hiberate**](//howtodoinjava.com/hibernate-tutorials/ "hibernate tutorials") 配置 OSCache 为例。
......@@ -113,7 +113,7 @@ Physical cache example
如果您要构建的缓存非常大,则最好在文件系统中构建它(例如 Windows 中的 C 驱动器)。 这将防止 Hiberate 状态在每次重新启动应用时建立高速缓存。 同样,[二级缓存提取规则](//howtodoinjava.com/hibernate/how-hibernate-second-level-cache-works/ "How hibernate second level cache works?")仍然适用。
要启用物理缓存,请下载 **[oscache.properties](https://svn.apache.org/repos/asf/db/ojb/trunk/src/config/oscache.properties "download oscache.properties")** 文件,并取消注释以下几行:
要启用物理缓存,请下载 [**oscache.properties**](https://svn.apache.org/repos/asf/db/ojb/trunk/src/config/oscache.properties "download oscache.properties") 文件,并取消注释以下几行:
```java
cache.memory=false
......
......@@ -269,7 +269,7 @@ private Integer employeeId;
尽管出于各种原因使用单列代理密钥是有利的,但有时您可能不得不使用业务密钥。 当它们包含在单个列中时,您可以使用`@Id`而无需指定生成策略,该策略强制用户在持久保存实体之前分配主键值。
但是,如果是多列主键,则必须创建一个代表该主键的类。 当然,它不需要自己的主键,但它必须是公共类,必须具有默认构造函数,必须可序列化,并且必须 **[实现 hashCode()和 equals()方法](//howtodoinjava.com/java/related-concepts/working-with-hashcode-and-equals-methods-in-java/ "Working with hashCode and equals methods in java")** ,以允许 Hibernate 代码测试主键冲突。
但是,如果是多列主键,则必须创建一个代表该主键的类。 当然,它不需要自己的主键,但它必须是公共类,必须具有默认构造函数,必须可序列化,并且必须 [**实现 hashCode()和 equals()方法**](//howtodoinjava.com/java/related-concepts/working-with-hashcode-and-equals-methods-in-java/ "Working with hashCode and equals methods in java") ,以允许 Hibernate 代码测试主键冲突。
一旦创建了此主键类,就可以使用以下三种策略:
......@@ -328,7 +328,7 @@ public class EmployeeEntity implements Serializable{
## 使用@Basic 保留基本类型
默认情况下,POJO 中的属性和实例变量是持久化的。 Hibernate 将为您存储它们的值。 因此,最简单的映射适用于“基本”类型。 这些包括原语,原语包器,原语或包器数组,枚举以及实现 Serializable 但本身不是映射实体的任何类型。
默认情况下,POJO 中的属性和实例变量是持久化的。 Hibernate 将为您存储它们的值。 因此,最简单的映射适用于“基本”类型。 这些包括原语,原语包装器,原语或包装器数组,枚举以及实现 Serializable 但本身不是映射实体的任何类型。
这些都隐式映射-无需注释。 默认情况下,此类字段被映射到单个列,并且热切获取用于检索它们(即,当从数据库中检索实体时,将检索所有基本字段和属性)。 同样,当字段或属性不是基元时,可以将其存储和检索为空值。
......@@ -383,7 +383,7 @@ private String firstName;
1. [**建模@OneToOne 关系**](//howtodoinjava.com/hibernate/hibernate-one-to-one-mapping-using-annotations/ "Hibernate one-to-one mapping using annotations")
2. [**建模@OneToMany 关系**](//howtodoinjava.com/hibernate/hibernate-one-to-many-mapping-using-annotations/ "Hibernate one-to-many mapping using annotations")
3. **[建模@ManyToMany 关系](//howtodoinjava.com/hibernate/hibernate-many-to-many-mapping-using-annotations "Hibernate one-to-many mapping using annotations")**
3. [**建模@ManyToMany 关系**](//howtodoinjava.com/hibernate/hibernate-many-to-many-mapping-using-annotations "Hibernate one-to-many mapping using annotations")
## 映射继承层次结构
......
......@@ -19,7 +19,7 @@ Various supported techniques for one to one mapping
## 各种支持的技术
在 Hiberate 状态下,有 3 种方法可在两个实体之间创建一对一关系。 无论哪种方式,我们都必须使用 **[@OneToOne](https://docs.oracle.com/javaee/5/api/javax/persistence/OneToOne.html "one to one annotation")** 注解。
在 Hiberate 状态下,有 3 种方法可在两个实体之间创建一对一关系。 无论哪种方式,我们都必须使用 [**@OneToOne**](https://docs.oracle.com/javaee/5/api/javax/persistence/OneToOne.html "one to one annotation") 注解。
1. 第一种技术使用最广泛,并且在其中一个表中使用**外键列。**
2. 第二种技术使用一种众所周知的解决方案,即具有**第三张表来存储前两个表之间的映射**
......@@ -43,7 +43,7 @@ private AccountEntity account;
```
连接列用 [**@JoinColumn**](https://docs.oracle.com/javaee/5/api/javax/persistence/JoinColumn.html "Join Column annotation") 注释声明,看起来像 **[@Column](https://docs.oracle.com/javaee/5/api/javax/persistence/Column.html "Column annotation")** 注释。 它还有一个名为`referencedColumnName`的参数。 此参数在目标实体中声明将用于连接的列。
连接列用 [**@JoinColumn**](https://docs.oracle.com/javaee/5/api/javax/persistence/JoinColumn.html "Join Column annotation") 注释声明,看起来像 [**@Column**](https://docs.oracle.com/javaee/5/api/javax/persistence/Column.html "Column annotation") 注释。 它还有一个名为`referencedColumnName`的参数。 此参数在目标实体中声明将用于连接的列。
如果在所有者方未声明`@JoinColumn`,则使用默认值。 将在所有者表中创建一个连接列,其名称将是所有者端关系名称 _(下划线)和所拥有的主键列名称的连接。 侧。
......@@ -136,7 +136,7 @@ Table structure will be like this:
![shared primary key one to one](img/5b3839ba6f2e7204541c4ae2f0f01705.png "shared primary key one to one")
在这种方法中, **[@PrimaryKeyJoinColumn](https://docs.oracle.com/javaee/5/api/javax/persistence/PrimaryKeyJoinColumn.html "PrimaryKeyJoinColumn annotation")** 是要使用的主要注释。 让我们看看如何使用它。
在这种方法中, [**@PrimaryKeyJoinColumn**](https://docs.oracle.com/javaee/5/api/javax/persistence/PrimaryKeyJoinColumn.html "PrimaryKeyJoinColumn annotation") 是要使用的主要注释。 让我们看看如何使用它。
```java
......
......@@ -2,7 +2,7 @@
> 原文: [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`注释不再使用可选参数,但它几乎没有变化。
在 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`注释不再使用可选参数,但它几乎没有变化。
## 之前和之后
......
......@@ -4,7 +4,7 @@
在任何以增量方式构建的应用中,通常希望只要引入新功能,我们就只能运行某些测试。 可以使用 JUnit 框架的`JUnitCore`类来实现。
**[JUnitCore](http://junit.sourceforge.net/javadoc/org/junit/runner/JUnitCore.html "JUnitCore")** 是 JUnit 包中的内置类,它基于**门面设计模式**`JUnitCore`类仅用于运行指定的测试类。
[**JUnitCore**](http://junit.sourceforge.net/javadoc/org/junit/runner/JUnitCore.html "JUnitCore") 是 JUnit 包中的内置类,它基于**门面设计模式**`JUnitCore`类仅用于运行指定的测试类。
> 阅读更多: [JUnit 5 测试套件](https://howtodoinjava.com/junit5/junit5-test-suites-examples/)
......
......@@ -2,9 +2,9 @@
> 原文: [https://howtodoinjava.com/junit/executing-junit-testcases-with-maven/](https://howtodoinjava.com/junit/executing-junit-testcases-with-maven/)
[**Maven**](//howtodoinjava.com/maven/ "Maven") 是用于项目依赖和构建管理的好工具。 它可以用于运行项目的 **[Junit](//howtodoinjava.com/junit/ "JUnit")** 测试用例。 在本文中,我将展示一些简单但有用的命令示例,以各种方式运行测试用例。
[**Maven**](//howtodoinjava.com/maven/ "Maven") 是用于项目依赖和构建管理的好工具。 它可以用于运行项目的 [**Junit**](//howtodoinjava.com/junit/ "JUnit") 测试用例。 在本文中,我将展示一些简单但有用的命令示例,以各种方式运行测试用例。
为了演示,我使用以下命令创建了一个 **[maven java 项目](//howtodoinjava.com/maven/create-a-simple-java-project-using-maven/ "Create a simple java project using maven")**
为了演示,我使用以下命令创建了一个 [**maven java 项目**](//howtodoinjava.com/maven/create-a-simple-java-project-using-maven/ "Create a simple java project using maven")
```java
mvn archetype:generate -DgroupId=com.howtodoinjava.junit -DartifactId=mavenJunitDemo
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/junit/assumption-based-testcases-in-junit-4/](https://howtodoinjava.com/junit/assumption-based-testcases-in-junit-4/)
**[Junit](//howtodoinjava.com/junit/ "junit tutorials")** 是 Java 编程语言的单元测试框架。 如果您想阅读有关 [**最佳做法**](//howtodoinjava.com/category/best-practices/ "best practices guides") 的信息,以进行 junit 测试,那么这里是一份出色的 [**指南**](//howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/ "Unit testing best practices : Junit Reference guide") 供您参考。
[**Junit**](//howtodoinjava.com/junit/ "junit tutorials") 是 Java 编程语言的单元测试框架。 如果您想阅读有关 [**最佳做法**](//howtodoinjava.com/category/best-practices/ "best practices guides") 的信息,以进行 junit 测试,那么这里是一份出色的 [**指南**](//howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/ "Unit testing best practices : Junit Reference guide") 供您参考。
在本文中,我正在写有关编写 junit 测试用例的信息,这些用例仅在运行时满足特定条件时才能运行。 例如,我只想在其他网络服务启动时才运行测试用例。 如果服务中断,我不想通过测试。
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/junit/junit-testcases-which-expects-exception-on-runtime/](https://howtodoinjava.com/junit/junit-testcases-which-expects-exception-on-runtime/)
**[Junit](//howtodoinjava.com/junit/ "junit tutorials")** 是 Java 编程语言的单元测试框架。 如果您想阅读有关 [**最佳做法**](//howtodoinjava.com/category/best-practices/ "best practices guides") 的信息,以进行 junit 测试,那么这里是一份出色的 [**指南**](//howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/ "Unit testing best practices : Junit Reference guide") 供您参考。
[**Junit**](//howtodoinjava.com/junit/ "junit tutorials") 是 Java 编程语言的单元测试框架。 如果您想阅读有关 [**最佳做法**](//howtodoinjava.com/category/best-practices/ "best practices guides") 的信息,以进行 junit 测试,那么这里是一份出色的 [**指南**](//howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/ "Unit testing best practices : Junit Reference guide") 供您参考。
在本文中,我正在编写一个示例测试用例,期望在运行时引发异常。 如果它获得预期的异常,则测试通过。 如果未检测到预期的异常,则测试用例失败。
......
......@@ -8,7 +8,7 @@
有时,我们必须编写 JUnit 测试,以访问网络上的某些外部系统。 绝对不能 100% 地确定在执行测试用例时这些外部系统将可用。 这就是为什么在编写具有外部依赖关系的测试用例时,建议使用 JUnit 框架的**超时**属性。
这也被认为是 **[JUnit 最佳实践](//howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/ "Unit testing best practices : Junit Reference guide")**
这也被认为是 [**JUnit 最佳实践**](//howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/ "Unit testing best practices : Junit Reference guide")
> 每个 JUnit 测试都在一个新线程中运行。 如果在测试完成之前经过了指定的超时,则将通过 **Thread.interrupt()**中断其执行。
......@@ -71,7 +71,7 @@ Please note that above timeout `@Rule` applies on `@Before` and `@After` methods
## 4\. 使用断言的 JUnit 5 超时
**[JUnit 5](https://howtodoinjava.com/junit-5-tutorial/)** 中,我们可以使用[断言](https://howtodoinjava.com/junit5/junit-5-assertions-examples/)强制测试超时。
[**JUnit 5**](https://howtodoinjava.com/junit-5-tutorial/) 中,我们可以使用[断言](https://howtodoinjava.com/junit5/junit-5-assertions-examples/)强制测试超时。
```java
import static java.time.Duration.ofMillis;
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/junit/junit-creating-temporary-filefolder-using-temporaryfolder-rule/](https://howtodoinjava.com/junit/junit-creating-temporary-filefolder-using-temporaryfolder-rule/)
很多时候,我们需要创建 **[junit](//howtodoinjava.com/junit/ "JUnit Tutorials")** 单元测试,我们需要**创建临时文件夹或临时文件**来执行测试用例。 很多时候,我们依赖于在特定位置有一个临时文件夹并在那里生成所有临时文件。 嗯,它有它自己的缺点。 主要缺点是您需要手动清理这些文件。
很多时候,我们需要创建 [**junit**](//howtodoinjava.com/junit/ "JUnit Tutorials") 单元测试,我们需要**创建临时文件夹或临时文件**来执行测试用例。 很多时候,我们依赖于在特定位置有一个临时文件夹并在那里生成所有临时文件。 嗯,它有它自己的缺点。 主要缺点是您需要手动清理这些文件。
Junit 带有[`TemporaryFolder`](https://junit-team.github.io/junit/javadoc/4.10/org/junit/rules/TemporaryFolder.html "TemporaryFolder")类,可用于生成临时文件夹。
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/maven/maven-bom-bill-of-materials-dependency/](https://howtodoinjava.com/maven/maven-bom-bill-of-materials-dependency/)
如果您在项目中为依赖项管理使用过 **[maven](//howtodoinjava.com/maven/ "Maven Tutorials")**,那么您必须至少遇到一个问题,或者可能更多。 问题是**版本不匹配**。 通常,当您获得一些依赖项并将其相关的依赖项与特定版本一起使用时,就会发生这种情况。 并且,如果您已经包含了具有不同版本号的那些依赖项,则它们可能在编译时以及运行时都面临不良结果。
如果您在项目中为依赖项管理使用过 [**maven**](//howtodoinjava.com/maven/ "Maven Tutorials"),那么您必须至少遇到一个问题,或者可能更多。 问题是**版本不匹配**。 通常,当您获得一些依赖项并将其相关的依赖项与特定版本一起使用时,就会发生这种情况。 并且,如果您已经包含了具有不同版本号的那些依赖项,则它们可能在编译时以及运行时都面临不良结果。
理想情况下,为避免上述问题,您需要明确排除相关的依赖关系,但您很有可能会忘记这样做。
......
......@@ -176,9 +176,9 @@ public class ParallelSuiteTest
```
Maven 可以与任何连续集成系统一起使用。 插件 **[maven-surefire-plugin](https://maven.apache.org/surefire/maven-surefire-plugin/ "maven surefire plugin")** 用于**配置和执行测试**。 这里,所述插件用于为 TestNG 测试配置`testng.xml``suites-test-testng.xml`并生成测试报告。
Maven 可以与任何连续集成系统一起使用。 插件 [**maven-surefire-plugin**](https://maven.apache.org/surefire/maven-surefire-plugin/ "maven surefire plugin") 用于**配置和执行测试**。 这里,所述插件用于为 TestNG 测试配置`testng.xml``suites-test-testng.xml`并生成测试报告。
插件 **[maven-compiler-plugin](//howtodoinjava.com/maven/solved-java-compiler-level-does-not-match-the-version-of-the-installed-java-project-facet/ "Solved: Java compiler level does not match the version of the installed Java project facet")** 用于帮助编译代码并使用特定的 JDK 版本进行编译。
插件 [**maven-compiler-plugin**](//howtodoinjava.com/maven/solved-java-compiler-level-does-not-match-the-version-of-the-installed-java-project-facet/ "Solved: Java compiler level does not match the version of the installed Java project facet") 用于帮助编译代码并使用特定的 JDK 版本进行编译。
## 4\. TestNG Maven 示例
......
......@@ -7,21 +7,21 @@ TestNG 使用注释来帮助开发人员编写测试。 下表是包含有关 Te
## TestNG 测试配置注释
| 注解 | 描述 |
| **[@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 套件中声明的每个测试节之后执行。 |
| **[@BeforeGroups](http://testng.org/javadoc/org/testng/annotations/BeforeGroups.html "BeforeGroups")** | 带注释的 BeforeGroups 方法将在执行指定组的任何测试方法之前运行。 |
| **[@AfterGroups](http://testng.org/javadoc/org/testng/annotations/AfterGroups.html "AfterGroups")** | AfterGroups 带注释的方法将在指定组的任何测试方法执行后运行。 |
| [**@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 套件中声明的每个测试节之后执行。 |
| [**@BeforeGroups**](http://testng.org/javadoc/org/testng/annotations/BeforeGroups.html "BeforeGroups") | 带注释的 BeforeGroups 方法将在执行指定组的任何测试方法之前运行。 |
| [**@AfterGroups**](http://testng.org/javadoc/org/testng/annotations/AfterGroups.html "AfterGroups") | AfterGroups 带注释的方法将在指定组的任何测试方法执行后运行。 |
| [@BeforeClass](http://testng.org/javadoc/org/testng/annotations/BeforeClass.html "BeforeClass") | 带注释的 BeforeClass 方法在测试类的任何测试方法之前执行。 |
| **[@AfterClass](http://testng.org/javadoc/org/testng/annotations/AfterClass.html "AfterClass")** | 在执行测试类的每个测试方法之后,将执行 AfterClass 带注释的方法。 |
| [**@AfterClass**](http://testng.org/javadoc/org/testng/annotations/AfterClass.html "AfterClass") | 在执行测试类的每个测试方法之后,将执行 AfterClass 带注释的方法。 |
| [@BeforeMethod](http://testng.org/javadoc/org/testng/annotations/BeforeMethod.html "BeforeMethod") | 这些带注释的方法在每个测试方法执行之前执行。 |
| **[@AfterMethod](http://testng.org/javadoc/org/testng/annotations/AfterMethod.html "AfterMethod")** | 这些带注释的方法在每个测试方法执行后执行。 |
| **[@DataProvider](http://testng.org/javadoc/org/testng/annotations/DataProvider.html "DataProvider")** | 将方法标记为测试方法的数据提供方法。 所述方法必须返回对象双精度数组(Object [] [])作为数据。 |
| **[@Factory](http://testng.org/javadoc/org/testng/annotations/Factory.html "Factory")** | 将带注释的方法标记为返回类对象数组(Object [])的工厂。 然后,这些类对象将被 TestNG 用作测试类。 这用于运行一组具有不同值的测试用例。 |
| **[@Listeners](http://testng.org/javadoc/org/testng/annotations/Listeners.html "Listeners")** | 应用于测试班。 定义一组扩展 org.testng.ITestNGListener 的测试侦听器类。 帮助跟踪执行状态和记录目的。 |
| **[@参数](http://testng.org/javadoc/org/testng/annotations/Parameters.html "Parameters")** | 此注解用于将参数传递给测试方法。 这些参数值在运行时使用 testng.xml 配置文件提供。 |
| **[@测试](https://static.javadoc.io/org.testng/testng/6.8.21/org/testng/annotations/Test.html "Test")** | 将类或方法标记为测试方法。 如果在类级别使用,则类的所有公共方法都将被视为测试方法。 |
| [**@AfterMethod**](http://testng.org/javadoc/org/testng/annotations/AfterMethod.html "AfterMethod") | 这些带注释的方法在每个测试方法执行后执行。 |
| [**@DataProvider**](http://testng.org/javadoc/org/testng/annotations/DataProvider.html "DataProvider") | 将方法标记为测试方法的数据提供方法。 所述方法必须返回对象双精度数组(Object [] [])作为数据。 |
| [**@Factory**](http://testng.org/javadoc/org/testng/annotations/Factory.html "Factory") | 将带注释的方法标记为返回类对象数组(Object [])的工厂。 然后,这些类对象将被 TestNG 用作测试类。 这用于运行一组具有不同值的测试用例。 |
| [**@Listeners**](http://testng.org/javadoc/org/testng/annotations/Listeners.html "Listeners") | 应用于测试班。 定义一组扩展 org.testng.ITestNGListener 的测试侦听器类。 帮助跟踪执行状态和记录目的。 |
| [**@参数**](http://testng.org/javadoc/org/testng/annotations/Parameters.html "Parameters") | 此注解用于将参数传递给测试方法。 这些参数值在运行时使用 testng.xml 配置文件提供。 |
| [**@测试**](https://static.javadoc.io/org.testng/testng/6.8.21/org/testng/annotations/Test.html "Test") | 将类或方法标记为测试方法。 如果在类级别使用,则类的所有公共方法都将被视为测试方法。 |
当您感到困惑时,请参考 **TestNG 注释**的表格。
**祝您学习愉快!**
\ No newline at end of file
......@@ -24,7 +24,7 @@ TestNG 提供了五种不同的`Before`和`After`注释选项,可以根据测
## 2\. TestNG 注释前后的示例
创建一个具有所有注释前后的新 TestNG 测试。 您可以根据此 **[TestNG 教程](//howtodoinjava.com/testng/testng-tutorial-with-eclipse/ "TestNG Tutorial (With Eclipse)")** 中给出的说明来创建此测试。 让我们看看如何选择所有注释之前和之后的注释。
创建一个具有所有注释前后的新 TestNG 测试。 您可以根据此 [**TestNG 教程**](//howtodoinjava.com/testng/testng-tutorial-with-eclipse/ "TestNG Tutorial (With Eclipse)") 中给出的说明来创建此测试。 让我们看看如何选择所有注释之前和之后的注释。
![Select all testng annotations](img/0b9218535b4d445357b6a3f938096beb.png)
......
......@@ -269,7 +269,7 @@ If a test method belongs to both included and excluded group, the excluded group
## 使用正则表达式
在将测试配置为包含或排除组时,TestNG 允许用户使用 **[正则表达式](//howtodoinjava.com/java-regular-expression-tutorials/ "Java Regular Expression Tutorial")** 。 这类似于包含和排除我们前面介绍的测试方法。 这可以帮助用户根据名称搜索包含和排除组。
在将测试配置为包含或排除组时,TestNG 允许用户使用 [**正则表达式**](//howtodoinjava.com/java-regular-expression-tutorials/ "Java Regular Expression Tutorial") 。 这类似于包含和排除我们前面介绍的测试方法。 这可以帮助用户根据名称搜索包含和排除组。
让我们学习如何排除基于基于正则表达式的名称匹配的测试。
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/spring-boot2/testing/spring-boot-mockito-junit-example/](https://howtodoinjava.com/spring-boot2/testing/spring-boot-mockito-junit-example/)
学习使用 **[JUnit](https://howtodoinjava.com/junit-4/)****Mockito** 测试框架为 Spring 应用的服务层编写 **[单元测试](https://howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/)。 本教程演示 *[弹簧启动](https://howtodoinjava.com/spring-boot-tutorials/)测试服务层示例*。**
学习使用 [**JUnit**](https://howtodoinjava.com/junit-4/)**Mockito** 测试框架为 Spring 应用的服务层编写 **[单元测试](https://howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/)。 本教程演示 *[弹簧启动](https://howtodoinjava.com/spring-boot-tutorials/)测试服务层示例*。**
## 1\. Maven 依赖
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/mockito/plugin-mockmaker-error/](https://howtodoinjava.com/mockito/plugin-mockmaker-error/)
如果您正在使用 **[Spring boot 2.x](https://howtodoinjava.com/spring-boot2/spring-boot-mockmvc-example/)** 应用,它们自动包含 **[Mockito](https://howtodoinjava.com/mockito/junit-mockito-example/) Core** 依赖项,那么您将遇到此错误,那么您 可以尝试建议的解决方案。
如果您正在使用 [**Spring boot 2.x**](https://howtodoinjava.com/spring-boot2/spring-boot-mockmvc-example/) 应用,它们自动包含 **[Mockito](https://howtodoinjava.com/mockito/junit-mockito-example/) Core** 依赖项,那么您将遇到此错误,那么您 可以尝试建议的解决方案。
## 1\. 问题
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/library/mock-testing-using-powermock-with-junit-and-mockito/](https://howtodoinjava.com/library/mock-testing-using-powermock-with-junit-and-mockito/)
**PowerMock** 是 Java 世界的开源模拟库。 它扩展了现有的模拟框架,例如 **[EasyMock](http://www.easymock.org/ "easymock")****[Mockito](https://code.google.com/p/mockito/ "mockito")** ,为它们添加了更强大的功能。 PowerMock 使我们能够为最不可测试的代码编写良好的单元测试。 Java 中的大多数模拟框架都不能模拟静态方法或最终类。 但是使用 PowerMock,我们可以模拟几乎任何类。
**PowerMock** 是 Java 世界的开源模拟库。 它扩展了现有的模拟框架,例如 [**EasyMock**](http://www.easymock.org/ "easymock")[**Mockito**](https://code.google.com/p/mockito/ "mockito") ,为它们添加了更强大的功能。 PowerMock 使我们能够为最不可测试的代码编写良好的单元测试。 Java 中的大多数模拟框架都不能模拟静态方法或最终类。 但是使用 PowerMock,我们可以模拟几乎任何类。
PowerMock currently extends the EasyMock and Mockito mocking frameworks. Depending on which extension is preferred, the syntax to write any unit test differs slightly. In this tutorial, I am using PowerMock with Mockito.
......
......@@ -41,7 +41,7 @@ module.controller('DemoController', function( $http ){
| `$xhrFactory` | 用于创建`XMLHttpRequest`对象的工厂函数。 |
| `$httpBackend` | 用于处理浏览器不兼容。 |
| `$interpolate` | 将带有标记的字符串编译为插值函数。 HTML `$compile`服务使用此服务进行数据绑定。 |
| `$interval` | Angular 的`window.setInterval`包器。 |
| `$interval` | Angular 的`window.setInterval`器。 |
| `$locale` | 提供各种 Angular 组件的本地化规则。 |
| `$location` | 它解析浏览器地址栏中的 URL,并使该 URL 可用于您的应用。 对地址栏中 URL 的更改将反映到`$location`服务中,对`$location`的更改将反映到浏览器地址栏中。 |
| `$log` | 控制台日志。 |
......@@ -52,7 +52,7 @@ module.controller('DemoController', function( $http ){
| `$sceDelegate` | 由后端`$sce`使用。 |
| `$sce` | 为 AngularJS 提供严格的上下文转义服务。 |
| `$templateRequest` | 它运行安全检查,然后使用`$http`下载提供的模板,并在成功后将内容存储在`$templateCache`中。 |
| `$timeout` | Angular 的`window.setTimeout()`包器 |
| `$timeout` | Angular 的`window.setTimeout()`器 |
| `$window` | 对浏览器的`window`对象的引用。 尽管`window`在 JavaScript 中全局可用,但由于它是全局变量,因此会引起可测试性问题。 在角度上,我们始终通过`$window`服务来引用它,因此可以对其进行覆盖,删除或模拟以进行测试。 |
*参考: [https://docs.angularjs.org/api/ng/service](https://docs.angularjs.org/api/ng/service)*
......
......@@ -98,7 +98,7 @@ angular http service example
## 3\. 示例中使用的 Spring REST API
现在让我们看一下本示例中使用的 RESTful API。 这些是使用 **[Spring REST JSON 示例](//howtodoinjava.com/spring/spring-restful/spring-rest-hello-world-json-example/)** 的源代码创建的。
现在让我们看一下本示例中使用的 RESTful API。 这些是使用 [**Spring REST JSON 示例**](//howtodoinjava.com/spring/spring-restful/spring-rest-hello-world-json-example/) 的源代码创建的。
```java
package com.howtodoinjava.demo.controller;
......
......@@ -336,7 +336,7 @@ function ajaxSyncRequest(reqURL)
#### 6.1 jQuery 查询
**[jQuery](https://jquery.com/ "jquery")** 可能在其替代品中很受欢迎。 它拥有自己的开发者社区,该社区也非常活跃。 使用 jquery 发送 ajax 请求的示例代码如下:
[**jQuery**](https://jquery.com/ "jquery") 可能在其替代品中很受欢迎。 它拥有自己的开发者社区,该社区也非常活跃。 使用 jquery 发送 ajax 请求的示例代码如下:
```java
//Current request reference; can be used else where
......@@ -377,7 +377,7 @@ $("#buttonId").submit(function(event) {
#### 6.2 原型
**[原型](http://prototypejs.org/ "prototype")** 是另一个用于相同目的的流行框架。 但是,请注意,已知原型与某些其他框架不兼容。 使用原型发送 ajax 请求的示例代码如下所示:
[**原型**](http://prototypejs.org/ "prototype") 是另一个用于相同目的的流行框架。 但是,请注意,已知原型与某些其他框架不兼容。 使用原型发送 ajax 请求的示例代码如下所示:
```java
new Ajax.Request('/some_url',
......@@ -399,6 +399,6 @@ new Ajax.Request('/some_url',
## Ajax 教程源代码下载
**[源码下载](https://docs.google.com/file/d/0B7yo2HclmjI4LUxndDZ1SUxjX3M/edit?usp=sharing "ajax demo source code")**
[**源码下载**](https://docs.google.com/file/d/0B7yo2HclmjI4LUxndDZ1SUxjX3M/edit?usp=sharing "ajax demo source code")
学习愉快!
\ No newline at end of file
......@@ -118,7 +118,7 @@ jQuery 1.8 在 jQuery 模式方面带来了重大变化。 此更改是`$.ajax()
* 它处理为请求设置的任何超时
* 它处理任何跨域调用(包括 jsonp)
The jqXHR objects returned by $.ajax() implement the Promise interface. The object has all the properties, methods, and behavior of a **[Promise](https://api.jquery.com/deferred.promise/)**.
The jqXHR objects returned by $.ajax() implement the Promise interface. The object has all the properties, methods, and behavior of a [**Promise**](https://api.jquery.com/deferred.promise/).
*jQuery 库作者已努力使其向后兼容,但不支持`onreadystatechange()`方法。*
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/jquery/jquery-deep-cloning-example/](https://howtodoinjava.com/jquery/jquery-deep-cloning-example/)
jQuery 深度克隆意味着独立更改原始对象或克隆对象不会对其他对象产生影响。 换句话说,两个对象(原始对象和克隆对象)都彼此完全独立。 您可以在对象克隆 的 **[指南中阅读有关克隆的更多信息。](//howtodoinjava.com/java/cloning/a-guide-to-object-cloning-in-java/ "A guide to object cloning in java")**
jQuery 深度克隆意味着独立更改原始对象或克隆对象不会对其他对象产生影响。 换句话说,两个对象(原始对象和克隆对象)都彼此完全独立。 您可以在对象克隆 的 [**指南中阅读有关克隆的更多信息。**](//howtodoinjava.com/java/cloning/a-guide-to-object-cloning-in-java/ "A guide to object cloning in java")
![jquery_logo](img/5ade7672922b927bd760e8a881839896.png)
......
......@@ -8,7 +8,7 @@ Please note that this will work always. No matter you generate these events with
![jquery_logo](img/5ade7672922b927bd760e8a881839896.png)
**阅读更多:[按键事件和击键事件之间的差异](//howtodoinjava.com/2013/12/20/jquery-keyup-function-demo/ "jQuery: difference between keypress and keydown events")****[检测 ENTER 键](//howtodoinjava.com/scripting/jquery-detect-if-enter-key-is-pressed/ "jQuery: Detect if ENTER key is pressed")**
**阅读更多:[按键事件和击键事件之间的差异](//howtodoinjava.com/2013/12/20/jquery-keyup-function-demo/ "jQuery: difference between keypress and keydown events")**[**检测 ENTER 键**](//howtodoinjava.com/scripting/jquery-detect-if-enter-key-is-pressed/ "jQuery: Detect if ENTER key is pressed")
**检测剪切复制或粘贴事件**
......
......@@ -2,9 +2,9 @@
> 原文: [https://howtodoinjava.com/javascript/implement-mvc-and-pubsub-in-javascript/](https://howtodoinjava.com/javascript/implement-mvc-and-pubsub-in-javascript/)
我们知道什么是 MVC? MVC 代表 **[模型-视图-控制器](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller "MVC")** 。 简而言之,MVC 是一种设计技术,其中将应用组件分为 3 组,以便可以独立开发它们而无需考虑它们将如何交互。 如果构建正确,则很少有配置代码可以绑定它们,并且可以立即使用。
我们知道什么是 MVC? MVC 代表 [**模型-视图-控制器**](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller "MVC") 。 简而言之,MVC 是一种设计技术,其中将应用组件分为 3 组,以便可以独立开发它们而无需考虑它们将如何交互。 如果构建正确,则很少有配置代码可以绑定它们,并且可以立即使用。
**[PubSub(发布者订阅者)](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern "pubsub")** 模型是设计范式,其中多个订阅者正在侦听源上的更改事件,并且一旦发生任何更改,便会立即通知侦听器。 在用户交互影响屏幕上多个部分的大型系统中,此模式消除了许多硬编码,并提供了设计灵活性。
[**PubSub(发布者订阅者)**](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern "pubsub") 模型是设计范式,其中多个订阅者正在侦听源上的更改事件,并且一旦发生任何更改,便会立即通知侦听器。 在用户交互影响屏幕上多个部分的大型系统中,此模式消除了许多硬编码,并提供了设计灵活性。
![PubSub + MVC in JavaScript](img/99dc384aba029061cae775869ac41f18.png)
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/hadoop/hadoop-mapreduce-tutorial-for-beginners/](https://howtodoinjava.com/hadoop/hadoop-mapreduce-tutorial-for-beginners/)
[**Hadoop**](//howtodoinjava.com/big-data/hadoop/hadoop-big-data-tutorial/) **MapReduce** 是一种软件框架,可轻松编写可在大型集群(数千个)上并行并行处理大量数据(多 TB 数据集)的应用 商品硬件的节点)以可靠,容错的方式。 与 **[HDFS](//howtodoinjava.com/big-data/hadoop/hdfs-hadoop-distributed-file-system-architecture-tutorial/)** 相似,Hadoop MapReduce 甚至可以在商用硬件中执行,并且假定节点可以随时发生故障并且仍在处理作业。 通过将一个任务划分为多个独立的子任务,MapReduce 可以并行处理大量数据。 与 HDFS 相似,MapReduce 也具有主从结构。
[**Hadoop**](//howtodoinjava.com/big-data/hadoop/hadoop-big-data-tutorial/) **MapReduce** 是一种软件框架,可轻松编写可在大型集群(数千个)上并行并行处理大量数据(多 TB 数据集)的应用 商品硬件的节点)以可靠,容错的方式。 与 [**HDFS**](//howtodoinjava.com/big-data/hadoop/hdfs-hadoop-distributed-file-system-architecture-tutorial/) 相似,Hadoop MapReduce 甚至可以在商用硬件中执行,并且假定节点可以随时发生故障并且仍在处理作业。 通过将一个任务划分为多个独立的子任务,MapReduce 可以并行处理大量数据。 与 HDFS 相似,MapReduce 也具有主从结构。
MapReduce 作业通常将输入数据集分成独立的块,这些块由**映射**任务以完全并行的方式处理。 框架对映射的输出进行排序,然后将其输入到**简化**任务中。 通常,作业的输入和输出都存储在文件系统中。
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/hadoop/hdfs-hadoop-distributed-file-system-architecture-tutorial/](https://howtodoinjava.com/hadoop/hdfs-hadoop-distributed-file-system-architecture-tutorial/)
**HDFS(Hadoop 分布式文件系统)****[大数据](//howtodoinjava.com/big-data/hadoop/hadoop-big-data-tutorial/)** 的存储位置。 HDFS 的主要目标是即使在存在名称节点故障,数据节点故障和/或网络分区( **[CAP 定理](//howtodoinjava.com/2015/07/13/brewers-cap-theorem-in-simple-words/)** 中的“ P”)等故障的情况下,也能可靠地存储数据。 本教程旨在研究将 HDFS 实现到分布式集群环境中涉及的不同组件。
**HDFS(Hadoop 分布式文件系统)**[**大数据**](//howtodoinjava.com/big-data/hadoop/hadoop-big-data-tutorial/) 的存储位置。 HDFS 的主要目标是即使在存在名称节点故障,数据节点故障和/或网络分区( [**CAP 定理**](//howtodoinjava.com/2015/07/13/brewers-cap-theorem-in-simple-words/) 中的“ P”)等故障的情况下,也能可靠地存储数据。 本教程旨在研究将 HDFS 实现到分布式集群环境中涉及的不同组件。
```java
Table of Contents
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/mongodb/introduction-to-mongodb-why-mongodb/](https://howtodoinjava.com/mongodb/introduction-to-mongodb-why-mongodb/)
在直接进入 **[MongoDB](https://www.mongodb.org/ "mongodb")** 的基础知识之前,我们应该尝试了解 **[No-SQL 数据库](https://en.wikipedia.org/wiki/NoSQL "NoSQL")** 本身的需要。 为什么传统的 **[关系数据库](https://en.wikipedia.org/wiki/Relational_database "Relational database")** 失去了与新竞争对手(如 MongoDB)的战斗。 为什么它们在当今如此受欢迎。 为什么?
在直接进入 [**MongoDB**](https://www.mongodb.org/ "mongodb") 的基础知识之前,我们应该尝试了解 [**No-SQL 数据库**](https://en.wikipedia.org/wiki/NoSQL "NoSQL") 本身的需要。 为什么传统的 [**关系数据库**](https://en.wikipedia.org/wiki/Relational_database "Relational database") 失去了与新竞争对手(如 MongoDB)的战斗。 为什么它们在当今如此受欢迎。 为什么?
## 为什么使用 NoSQL?
......@@ -16,7 +16,7 @@ MongoDB 是**开源文档数据库**,可在一组用作存储节点的可配
MongoDB shines because of its ease of use, whether a developer is using it in a large-scale application that spans hundreds or thousands of nodes, or in a single-server application that has no need for scale.
如果您还记得在 **[JSON](https://en.wikipedia.org/wiki/JSON "JSON")** 中,我们将信息存储在键值对中,如下所示:
如果您还记得在 [**JSON**](https://en.wikipedia.org/wiki/JSON "JSON") 中,我们将信息存储在键值对中,如下所示:
```java
{
......@@ -26,7 +26,7 @@ MongoDB shines because of its ease of use, whether a developer is using it in a
```
MongoDB 将所有数据存储在文档中,该文档是由字段和值对组成的 JSON 样式的数据结构。 MongoDB 以 BSON 序列化格式将文档存储在磁盘上。 **[BSON](http://bsonspec.org/ "bson")** 是 JSON 文档的二进制表示形式,尽管它包含比 JSON 更多的数据类型。 这些文档可以是上面的简单文档,也可以是下面的复杂文档:
MongoDB 将所有数据存储在文档中,该文档是由字段和值对组成的 JSON 样式的数据结构。 MongoDB 以 BSON 序列化格式将文档存储在磁盘上。 [**BSON**](http://bsonspec.org/ "bson") 是 JSON 文档的二进制表示形式,尽管它包含比 JSON 更多的数据类型。 这些文档可以是上面的简单文档,也可以是下面的复杂文档:
```java
{
......
......@@ -179,7 +179,7 @@ nt durability.
## 6\. 下载/使用 MongoDB Java 驱动
从此 **[下载链接](http://central.maven.org/maven2/org/mongodb/mongo-java-driver/2.9.3/mongo-java-driver-2.9.3.jar "mongodb java driver download")** 下载 MongoDB Java 驱动(mongo-java-driver-2.9.3.jar)。 这是一个 jar 文件,您需要在要使用 MongoDB 的项目的 libpath 文件夹中的 classpath /副本中包含该文件。
从此 [**下载链接**](http://central.maven.org/maven2/org/mongodb/mongo-java-driver/2.9.3/mongo-java-driver-2.9.3.jar "mongodb java driver download") 下载 MongoDB Java 驱动(mongo-java-driver-2.9.3.jar)。 这是一个 jar 文件,您需要在要使用 MongoDB 的项目的 libpath 文件夹中的 classpath /副本中包含该文件。
## 7\. 验证 MongoDB 安装
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/mongodb/java-mongodb-insert-documents-in-collection-examples/](https://howtodoinjava.com/mongodb/java-mongodb-insert-documents-in-collection-examples/)
**[MongoDB 学习系列](//howtodoinjava.com/category/nosql/mongodb/ "learn mongodb")** 中,我们已经介绍了 [MongoDB 基础知识](//howtodoinjava.com/nosql/introduction-to-mongodb-why-mongodb/ "Introduction to MongoDB: Why MongoDB?")**[MongoDB 在 Windows](//howtodoinjava.com/nosql/mongodb/how-to-install-mongodb-on-windows/ "How to Install MongoDB on Windows")**[ **[如何从集合](//howtodoinjava.com/nosql/mongodb/mongodb-selectqueryfind-documents-examples/ "MongoDB : Select/Query/Find Document(s) Examples")** 中查询/选择文档。 在本教程中,我列出了 4 种可用于在 MongoDB 中向集合中插入或添加文档的方法。
[**MongoDB 学习系列**](//howtodoinjava.com/category/nosql/mongodb/ "learn mongodb") 中,我们已经介绍了 [MongoDB 基础知识](//howtodoinjava.com/nosql/introduction-to-mongodb-why-mongodb/ "Introduction to MongoDB: Why MongoDB?")[**MongoDB 在 Windows**](//howtodoinjava.com/nosql/mongodb/how-to-install-mongodb-on-windows/ "How to Install MongoDB on Windows")[ [**如何从集合**](//howtodoinjava.com/nosql/mongodb/mongodb-selectqueryfind-documents-examples/ "MongoDB : Select/Query/Find Document(s) Examples") 中查询/选择文档。 在本教程中,我列出了 4 种可用于在 MongoDB 中向集合中插入或添加文档的方法。
```java
List of examples in this tutorial
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/kafka/spring-boot-jsonserializer-example/](https://howtodoinjava.com/kafka/spring-boot-jsonserializer-example/)
学习使用 **[JsonSerializer](https://docs.spring.io/spring-kafka/api/org/springframework/kafka/support/serializer/JsonSerializer.html)**[`JsonDeserializer`](https://docs.spring.io/spring-kafka/api/org/springframework/kafka/support/serializer/JsonDeserializer.html)类从 [Apache Kafka](https://howtodoinjava.com/kafka/tutorial-introduction/) 主题存储和检索 JSON,并返回 Java 模型对象。
学习使用 [**JsonSerializer**](https://docs.spring.io/spring-kafka/api/org/springframework/kafka/support/serializer/JsonSerializer.html)[`JsonDeserializer`](https://docs.spring.io/spring-kafka/api/org/springframework/kafka/support/serializer/JsonDeserializer.html)类从 [Apache Kafka](https://howtodoinjava.com/kafka/tutorial-introduction/) 主题存储和检索 JSON,并返回 Java 模型对象。
## 1\. 先决条件
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/resteasy/resteasy-jboss-7-hello-world-application/](https://howtodoinjava.com/resteasy/resteasy-jboss-7-hello-world-application/)
[**RESTEasy**](http://resteasy.jboss.org/ "resteasy") 是 JBOSS 提供的 JAX-RS 规范的实现,用于构建 **[RESTful Web 服务](//howtodoinjava.com/restful-web-service/ "RESTEasy tutorials")** 和 RESTful Java 应用。 尽管这不仅限于仅在 JBOSS 中使用,您还可以与其他服务器一起使用。 在本文中,我将在 JBOSS AS7 服务器中构建这样的 hello world 应用。
[**RESTEasy**](http://resteasy.jboss.org/ "resteasy") 是 JBOSS 提供的 JAX-RS 规范的实现,用于构建 [**RESTful Web 服务**](//howtodoinjava.com/restful-web-service/ "RESTEasy tutorials") 和 RESTful Java 应用。 尽管这不仅限于仅在 JBOSS 中使用,您还可以与其他服务器一起使用。 在本文中,我将在 JBOSS AS7 服务器中构建这样的 hello world 应用。
**使用的环境:**
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/resteasy/resteasy-tomcat-hello-world-application/](https://howtodoinjava.com/resteasy/resteasy-tomcat-hello-world-application/)
[**RESTEasy**](http://resteasy.jboss.org/ "resteasy") 是 JBOSS 提供的 JAX-RS 规范的实现,用于构建 **[REST API](//howtodoinjava.com/restful-web-service/ "RESTEasy tutorials")** 和 RESTful Java 应用。 尽管 RESTEasy 不限于仅在 JBOSS 中使用,我们也可以与其他服务器一起使用。 在此 **RESTEasy 示例**中,学习使用 eclipse 和 tomcat 在 Java 中创建静态的 Web 服务
[**RESTEasy**](http://resteasy.jboss.org/ "resteasy") 是 JBOSS 提供的 JAX-RS 规范的实现,用于构建 [**REST API**](//howtodoinjava.com/restful-web-service/ "RESTEasy tutorials") 和 RESTful Java 应用。 尽管 RESTEasy 不限于仅在 JBOSS 中使用,我们也可以与其他服务器一起使用。 在此 **RESTEasy 示例**中,学习使用 eclipse 和 tomcat 在 Java 中创建静态的 Web 服务
## 1\. 开发环境
......
......@@ -515,7 +515,7 @@ public class UserService {
因此,我们为一个简单的演示编写了许多代码。 现在,该测试我们的代码了。
我正在使用 **[RESTClient](https://addons.mozilla.org/en-US/firefox/addon/restclient/ "restclient firefox plugin")** 来验证 API 输出。 您可以选择自己的验证方式。
我正在使用 [**RESTClient**](https://addons.mozilla.org/en-US/firefox/addon/restclient/ "restclient firefox plugin") 来验证 API 输出。 您可以选择自己的验证方式。
我已经在 **eclipse juno** 上运行的 **JBOSS 7.1 服务器运行时环境**中部署了以上应用。 如果要部署在某些独立的 jboss 实例上,也可以尝试。
......
......@@ -4,7 +4,7 @@
[**RESTEasy**](http://resteasy.jboss.org/ "resteasy") 是 JBOSS 提供的 JAX-RS 规范的实现,用于构建 [**RESTful Web 服务**](//howtodoinjava.com/restful-web-service/ "RESTEasy tutorials")和 RESTful Java 应用。 尽管这不仅限于仅在 JBOSS 中使用,您还可以与其他服务器一起使用。
另一方面, **[JAXB](https://en.wikipedia.org/wiki/Java_Architecture_for_XML_Binding "jaxb")** 用于将 Java 类映射到等效的 xml 文档,反之亦然。 它是使用 JAXB 的编组和解组功能完成的。
另一方面, [**JAXB**](https://en.wikipedia.org/wiki/Java_Architecture_for_XML_Binding "jaxb") 用于将 Java 类映射到等效的 xml 文档,反之亦然。 它是使用 JAXB 的编组和解组功能完成的。
在本文中,我演示了将 JAXB 与 RESTEasy 一起使用的方式,以将 API 响应转换为 xml 格式。
......
......@@ -13,7 +13,7 @@
```
上面的代码特定于 JAX-RS 2.0,并使用 JAX-RS 类。 如果您正在使用最新的 **[RESTEasy](//howtodoinjava.com/restful-web-service/ "RESTful Web services Tutorials")** (版本 3)内部版本,则可以使用其客户端 API 提供的 RESTEasy 抽象的这些较低级别的 JAX-RS 2.0 API。
上面的代码特定于 JAX-RS 2.0,并使用 JAX-RS 类。 如果您正在使用最新的 [**RESTEasy**](//howtodoinjava.com/restful-web-service/ "RESTful Web services Tutorials") (版本 3)内部版本,则可以使用其客户端 API 提供的 RESTEasy 抽象的这些较低级别的 JAX-RS 2.0 API。
## JAX-RS RESTEasy API
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册