2020-06-10 15:20:19

docs/misc2/103.md

@@ -10,7 +10,7 @@
 
 责任链允许许多类尝试处理请求，而与链上的任何其他对象无关。 处理完请求后，它就完成了整个流程。
 
-可以在链中添加或删除额外的处理程序，而无需修改任何具体处理程序内部的逻辑。
+可以在链中添加或删除额外的处理器，而无需修改任何具体处理器内部的逻辑。
 
 ```java
 Sections in this post:
@@ -28,19 +28,19 @@ Reference implementations in JDK
 
 ## **建议用法**
 
-当多个对象可以处理一个请求并且处理程序不必是特定的对象时，建议使用此模式。 另外，处理程序是在运行时确定的。 请注意，任何处理程序都不处理的请求是有效的用例。
+当多个对象可以处理一个请求并且处理器不必是特定的对象时，建议使用此模式。 另外，处理器是在运行时确定的。 请注意，任何处理器都不处理的请求是有效的用例。
 
-例如，Windows OS 中的事件处理机制，可以从鼠标，键盘或某些自动生成的事件生成事件。 所有这些事件都可以由多个处理程序处理，并且在运行时可以找到正确的处理程序。
+例如，Windows OS 中的事件处理机制，可以从鼠标，键盘或某些自动生成的事件生成事件。 所有这些事件都可以由多个处理器处理，并且在运行时可以找到正确的处理器。
 
-更一般的例子可以是对呼叫中心的服务请求。 可以在前台，主管或任何更高级别处理此请求。 仅当在各个级别上遍历请求时，才在运行时知道正确的请求处理程序。 我们将在这篇文章中解决这种情况。
+更一般的例子可以是对呼叫中心的服务请求。 可以在前台，主管或任何更高级别处理此请求。 仅当在各个级别上遍历请求时，才在运行时知道正确的请求处理器。 我们将在这篇文章中解决这种情况。
 
 ## **解决方案**中的参与者
 
-**1）处理程序**：这可以是一个主要接收请求并将请求分派到处理程序链的接口。 它仅引用链中的第一个处理程序，而对其余处理程序一无所知。
+**1）处理器**：这可以是一个主要接收请求并将请求分派到处理器链的接口。 它仅引用链中的第一个处理器，而对其余处理器一无所知。
 
-**2）具体处理程序**：这些是按某些顺序链接的请求的实际处理程序。
+**2）具体处理器**：这些是按某些顺序链接的请求的实际处理器。
 
-**3）客户端**：请求的始发者，它将访问处理程序来处理它。
+**3）客户端**：请求的始发者，它将访问处理器来处理它。
 
 ![Participants in chain of responsibility](img/2d4b87b6740e026b5215c34cf1862ac9.png)
 
@@ -54,7 +54,7 @@ Participants in chain of responsibility
 
 ## **建议的解决方案**
 
-以上问题是使用责任链模式的良好人选。 我们可以在每个级别上定义处理程序，即支持台，主管，经理和主管。 然后，我们可以定义一条链来处理支持请求。 该链必须遵循以下顺序：
+以上问题是使用责任链模式的良好人选。 我们可以在每个级别上定义处理器，即支持台，主管，经理和主管。 然后，我们可以定义一条链来处理支持请求。 该链必须遵循以下顺序：
 
 ```java
 Support desk > supervisor > manager > director

docs/misc2/104.md

@@ -23,7 +23,7 @@ Summary
 
 在面向对象的编程中，命令模式是一种行为设计模式，其中一个对象用于[封装](//howtodoinjava.com/object-oriented/encapsulation-in-java-and-its-relation-with-abstraction/)执行动作，业务操作或触发事件所需的所有信息。 方法名称，接收方对象引用和方法参数值（如果有）。 该对象称为*命令*。
 
-类似的方法也适用于[责任链](//howtodoinjava.com/design-patterns/behavioral/chain-of-responsibility-design-pattern/)模式。 唯一的区别是命令中只有一个请求处理程序，而在责任链中单个请求对象可以有许多处理程序。
+类似的方法也适用于[责任链](//howtodoinjava.com/design-patterns/behavioral/chain-of-responsibility-design-pattern/)模式。 唯一的区别是命令中只有一个请求处理器，而在责任链中单个请求对象可以有许多处理器。
 
 ## 设计参加者
 

docs/misc2/108.md

@@ -213,9 +213,9 @@ MessageSubscriberThree :: Second Message
 
 *   **Difference between observer pattern and chain of responsibility pattern?**
 
-    在观察者模式中，所有已注册的处理程序对象都同时获得通知，并且它们同时处理更新。
+    在观察者模式中，所有已注册的处理器对象都同时获得通知，并且它们同时处理更新。
 
-    但是在责任链模式中，链中的处理程序对象是一个接一个地通知的，此过程一直持续到一个对象完全处理了通知为止。
+    但是在责任链模式中，链中的处理器对象是一个接一个地通知的，此过程一直持续到一个对象完全处理了通知为止。
 
 *   **Benefits of the observer pattern?**
 

docs/misc2/122.md

@@ -162,7 +162,7 @@ public class IsbnEditor extends PropertyEditorSupport {
 
 #### 4.1 接口隔离原理示例
 
-查找 IPS 示例的最佳地方是 Java AWT 事件处理程序，用于处理从键盘和鼠标触发的 GUI 事件。 对于每种事件，它都有不同的监听器类。 我们只需要编写希望处理的事件处理程序即可。 没有什么是强制性的。
+查找 IPS 示例的最佳地方是 Java AWT 事件处理器，用于处理从键盘和鼠标触发的 GUI 事件。 对于每种事件，它都有不同的监听器类。 我们只需要编写希望处理的事件处理器即可。 没有什么是强制性的。
 
 一些听众是：
 

docs/misc2/176.md

@@ -78,7 +78,7 @@ Struts 2 jar files
 
 ## **知道 struts.xml 配置文件**
 
-因此，StrutsPrepareAndExecuteFilter 有一个要处理的请求。 怎么办？ 它将使用该配置来知道如何处理特定请求。 此配置在 struts.xml 文件中定义。 该文件将具有特定于应用工作流及其操作处理程序的 url 映射。 它还定义了输入/成功/错误视图。
+因此，StrutsPrepareAndExecuteFilter 有一个要处理的请求。 怎么办？ 它将使用该配置来知道如何处理特定请求。 此配置在 struts.xml 文件中定义。 该文件将具有特定于应用工作流及其操作处理器的 url 映射。 它还定义了输入/成功/错误视图。
 
 ```java
 <?xml version="1.0" encoding="UTF-8"?>

docs/misc2/23.md

@@ -6,7 +6,7 @@
 
 ## 1\. `JsonReader`
 
-*   `JsonReader`是流 JSON 解析器，并且是**拉式解析器**的示例。 推送解析器解析 JSON 令牌并将其推送到事件处理程序中。
+*   `JsonReader`是流 JSON 解析器，并且是**拉式解析器**的示例。 推送解析器解析 JSON 令牌并将其推送到事件处理器中。
 *   它有助于读取 JSON（[RFC 7159](https://www.ietf.org/rfc/rfc7159.txt)）编码的值作为令牌流。
 *   它读取字面值（字符串，数字，布尔值和`null`）以及对象和数组的开始和结束定界符。
 *   令牌以**深度优先顺序**遍历，与 JSON 文档中出现的顺序相同。

docs/misc2/3.md

@@ -200,7 +200,7 @@ MessageConsumer consumer = session.createConsumer(topic);
 
 #### 5.8 JMS 消息监听器
 
-消息监听器是一个对象，充当消息的异步事件处理程序。 消息监听器实现[`MessageListener`](https://docs.oracle.com/javaee/7/api/javax/jms/MessageListener.html)接口，其中包含一个方法`onMessage()`。 在这种方法中，我们定义了消息到达时要执行的动作。 通过使用`setMessageListener()`，我们使用特定的`MessageConsumer`定义消息监听器。
+消息监听器是一个对象，充当消息的异步事件处理器。 消息监听器实现[`MessageListener`](https://docs.oracle.com/javaee/7/api/javax/jms/MessageListener.html)接口，其中包含一个方法`onMessage()`。 在这种方法中，我们定义了消息到达时要执行的动作。 通过使用`setMessageListener()`，我们使用特定的`MessageConsumer`定义消息监听器。
 
 ```java
 Listener myListener = new Listener();

docs/misc2/51.md

-# Java SAX 解析器 – 阅读 XML 示例
+# Java SAX 解析器 – 读取 XML 示例
 
 > 原文： [https://howtodoinjava.com/xml/sax-parser-read-xml-example/](https://howtodoinjava.com/xml/sax-parser-read-xml-example/)
 
-**SAX 解析器**或 [**XML**](//howtodoinjava.com/category/xml/ "xml tag") 的简单 API 已经存在很多年了，最初由 [David Megginson](http://www.megginson.com/) 领导开发。 千年。 那时，您不得不从 David 的个人网站下载 Java 版本的 SAX。 在最终添加到 Java Standard Edition 1.4 中之前，它已发展为 [**SAX 项目**](http://www.saxproject.org/) 。
+**SAX 解析器**或 [**XML**](//howtodoinjava.com/category/xml/ "xml tag") 的简单 API 已经存在很多年了，最初由 [David Megginson](http://www.megginson.com/) 领导开发。 那时，您不得不从 David 的个人网站下载 Java 版本的 SAX。 在最终添加到 Java 标准版 1.4 中之前，它已发展为 [**SAX 项目**](http://www.saxproject.org/) 。
 
-SAX 是 XML 的流接口，这意味着使用 SAX 的应用从文档的顶部开始，以顺序的时间接收到有关正在处理的 XML 文档的事件通知的元素和属性，并以关闭文档的结尾结束。 根元素。 这意味着它在线性时间内处理 XML 的效率非常高，而不会对系统内存提出过多要求。
+SAX 是 XML 的流接口，这意味着使用 SAX 的应用从文档的顶部开始，以顺序的时间接收到有关 XML 文档正在处理元素和属性的事件通知，并以根元素的关闭而结束。 这意味着它在线性时间内处理 XML 的效率非常高，而不会对系统内存提出过多要求。
 
 让我们创建一个演示程序，以便**使用 SAX 解析器**读取 xml 文件以全面理解。
 
@@ -74,9 +74,9 @@ public class User
 
 ```
 
-## 3.通过扩展 DefaultParser 构建处理程序
+## 3.通过扩展`DefaultParser`构建处理器
 
-下面的代码为解析处理程序。 我在代码注释中添加了其他信息。 不过，您有任何疑问吗，请给我留言。
+下面的代码为解析处理器。 我在代码注释中添加了其他信息。 不过，您有任何疑问吗，请给我留言。
 
 ```java
 package com.howtodoinjava.xml.sax;
@@ -241,7 +241,7 @@ public class UsersXmlParser
 
 ## 5）测试 SAX 解析器
 
-让我们编写一些代码来测试我们的处理程序是否真正起作用。
+让我们编写一些代码来测试我们的处理器是否真正起作用。
 
 ```java
 package com.howtodoinjava.xml.sax;
@@ -274,6 +274,6 @@ Output:
 
 ```
 
-[**下载源码 for this post**](https://drive.google.com/file/d/0B7yo2HclmjI4Y1REbUt1aV9lZlk/view?usp=drive_web "download source code for sax parser")
+[**下载这篇文章的源码**](https://drive.google.com/file/d/0B7yo2HclmjI4Y1REbUt1aV9lZlk/view?usp=drive_web "download source code for sax parser")
 
 学习愉快！
\ No newline at end of file

docs/misc2/52.md

@@ -20,11 +20,11 @@ Sourcecode Download
 
 ## 项目结构
 
-请创建此文件夹结构以执行示例。 这是在 Eclipse 中创建的[简单 Maven 项目。](//howtodoinjava.com/maven/create-a-simple-java-project-using-maven/)
+请创建此文件夹结构以执行示例。 这是在 Eclipse 中创建的[简单 Maven 项目](//howtodoinjava.com/maven/create-a-simple-java-project-using-maven/)。
 
 ![JDOM2 XML Parser](img/ed0b32780669a3c5c383c47c1e14ed4b.png)
 
-Project Structure
+项目结构
 
 
 
@@ -173,7 +173,7 @@ Root Element :: employees
 
 #### 读取属性值
 
-使用 Element.getAttributeValue()方法。
+使用`Element.getAttributeValue()`方法。
 
 ```java
 public static void main(String[] args) 
@@ -194,7 +194,7 @@ private static void readEmployeeNode(Element employeeNode)
 
 ```
 
-Output:
+输出：
 
 ```java
 Id : 101
@@ -289,7 +289,7 @@ for (Element element : xPathN.evaluate(document))
 
 ```
 
-Output:
+输出：
 
 ```java
 Employee Ids :: 101
@@ -299,9 +299,9 @@ Employee First Name :: Lokesh
 Employee First Name :: Brian
 ```
 
-## 完整的 JDOM2 Read XML 示例
+## 完整的 JDOM2 XML 读取示例
 
-这是在 Java 中使用 JDOM2 **读取 xml 的完整代码。**
+这是在 Java 中使用 JDOM2 **读取 xml 的完整代码**。
 
 ```java
 package com.howtodoinjava.demo.jdom2;
@@ -465,7 +465,7 @@ public class ReadXMLDemo
 
 ```
 
-Output:
+输出：
 
 ```java
 Root Element :: employees
@@ -502,4 +502,5 @@ Employee First Name :: Brian
 参考文献：
 
 [JDOM 网站](http://www.jdom.org/)
+
 [JDOM2 入门](https://github.com/hunterhacker/jdom/wiki/JDOM2-A-Primer)
\ No newline at end of file

docs/misc2/53.md

-# 使用 StAX Parser 的 Java 读取 XML – 游标&迭代器 API
+# 使用 StAX Parser 的 Java 读取 XML – 游标和迭代器 API
 
 > 原文： [https://howtodoinjava.com/xml/read-xml-stax-parser-cursor-iterator/](https://howtodoinjava.com/xml/read-xml-stax-parser-cursor-iterator/)
 
-学习使用 Java StAX 解析器解析和**读取 XML 文件。 StAX（用于 XML 的流 API）提供了两种解析 XML 的方法，即**基于光标的 API** 和**迭代器基于 API** 。**
+学习使用 Java StAX 解析器解析和**读取 XML 文件**。 StAX（用于 XML 的流 API）提供了两种解析 XML 的方法，即**基于游标的 API** 和**基于迭代器的 API** 。
 
 ## 1）StAX 解析器
 
@@ -11,7 +11,7 @@
 1.  StAX 是“ `pull`” API。 SAX 是“ `push`” API。
 2.  StAX 可以进行 XML 读取和写入。 SAX 只能读取 XML。
 
-**StAX 是拉样式 API** 。 这意味着您必须自己将 StAX 解析器从 XML 文件中的一个项目移动到另一个项目，就像使用标准[`Iterator`](https://howtodoinjava.com/java/collections/how-iterator-works-in-java/)或 JDBC [`ResultSet`](https://howtodoinjava.com/java/jdbc/jdbc-select-query-example/)一样。 然后，您可以通过 StAX 解析器访问 XML 文件中遇到的每个此类“项目”的 XML 信息。
+**StAX 是拉取样式 API** 。 这意味着您必须自己将 StAX 解析器从 XML 文件中的一个项目移动到另一个项目，就像使用标准[`Iterator`](https://howtodoinjava.com/java/collections/how-iterator-works-in-java/)或 JDBC [`ResultSet`](https://howtodoinjava.com/java/jdbc/jdbc-select-query-example/)一样。 然后，您可以通过 StAX 解析器访问 XML 文件中遇到的每个此类“项目”的 XML 信息。
 
 #### 游标与迭代器
 
@@ -31,7 +31,7 @@
 
     ```
 
-2.  与 Iterator 不同，游标的工作方式类似于 JDBC 中的`Resultset`。 如果将光标移动到 XML 文档中的下一个元素。 然后，您可以直接在光标上调用方法以获得有关当前事件的更多信息。
+2.  与迭代器不同，游标的工作方式类似于 JDBC 中的`Resultset`。 如果将游标移动到 XML 文档中的下一个元素。 然后，您可以直接在游标上调用方法以获得有关当前事件的更多信息。
 
     ```java
     XMLStreamReader streamReader = ...;
@@ -48,9 +48,9 @@
 
     ```
 
-## 2）StAX Iterator API 示例
+## 2）StAX 迭代器 API 示例
 
-下面给出的演示**如何使用基于 StAX 迭代器的 API 读取对象**的 XML 文档。
+下面给出的 XML 文档演示**如何使用基于 StAX 迭代器的 API 读取对象**。
 
 #### XML 文件
 
@@ -68,12 +68,12 @@
 
 ```
 
-#### 使用 StAX Iterator 读取 XML
+#### 使用 StAX 迭代器读取 XML
 
 要读取文件，我已按照以下步骤编写了程序：
 
 1.  创建迭代器并开始接收事件。
-2.  一旦获得`open 'employee' tag`，请创建一个新的`Employee`对象。
+2.  一旦获得打开的`'employee'`标签，请创建一个新的`Employee`对象。
 3.  从员工标签读取`id`属性，并将其设置为当前的`Employee`对象。
 4.  循环到下一个开始标签事件。 这些是`employee`标记内的 XML 元素。 读取这些标签内的数据。 将读取的数据设置为当前的`Employee`对象。
 5.  继续迭代事件。 当找到`'employee'`标签的结束元素事件时，可以说您已经读取了当前`employee`的数据，因此将当前`employee`对象添加到`employeeList`集合中。
@@ -185,7 +185,7 @@ public class ReadXMLExample
 
 ```
 
-## 3）StAX 光标 API 示例
+## 3）StAX 游标 API 示例
 
 我将使用基于游标的 API 读取相同的`employees.xml`文件。
 
@@ -276,7 +276,7 @@ public class ReadXMLExample
 1.  **什么是基于 XML 流 API 的 StAX 解析器**。
 2.  **StAX 与 SAX** 解析器之间的差异。
 3.  如何通过示例使用 StAX 迭代器 API 来**读取 XML。**
-4.  如何通过示例使用 StAX 光标 API 来**读取 XML。**
+4.  如何通过示例使用 StAX 游标 API 来**读取 XML。**
 
 两种 API 都能够解析任何类型的 XML 文档，但是**游标 API 比迭代器 API** 具有更高的内存效率。 因此，如果您的应用需要更好的性能，请考虑使用基于游标的 API。
 

docs/misc2/54.md

@@ -2,21 +2,21 @@
 
 > 原文： [https://howtodoinjava.com/xml/dom-vs-sax-parser-in-java/](https://howtodoinjava.com/xml/dom-vs-sax-parser-in-java/)
 
-**DOM 与 SAX 解析器之间的区别**非常流行 [**Java 面试问题**](//howtodoinjava.com/java-interview-questions/ "Java Interview Questions") ，当在 Java 和 XML 上进行面试时经常被问到。 DOM 和 SAX 解析器都广泛用于在 Java 应用中读取和解析 XML 文件，它们都有各自的优缺点。 在这篇文章中，我列出了两个解析器之间的一些明显的差异。
+**DOM 与 SAX 解析器之间的区别**是非常流行 [**Java 面试问题**](//howtodoinjava.com/java-interview-questions/ "Java Interview Questions") ，当在 Java 和 XML 上进行面试时经常被问到。 DOM 和 SAX 解析器都广泛用于在 Java 应用中读取和解析 XML 文件，它们都有各自的优缺点。 在这篇文章中，我列出了两个解析器之间的一些明显的差异。
 
 ## 1\. Java 中的 DOM XML 解析器
 
-**DOM 解析器是基于树的 API** 。 基于树的 API 以树结构为中心，因此在树的组件（是 DOM 文档）上提供接口，例如**文档**接口，**节点**接口， **NodeList 的**接口，**元素**接口，**属性**接口等等。
+**DOM 解析器是基于树的 API** 。 基于树的 API 以树结构为中心，因此在树的组件（是 DOM 文档）上提供接口，例如`Document`接口，`Node`接口， `NodeList`接口，`Element`接口，`Attrubute`接口等等。
 
 DOM 解析器根据输入文档在内存中创建树结构，然后等待来自客户端的请求。 DOM 解析器始终将**整个文档提供给客户端应用，无论客户端实际需要多少**。 使用 DOM 解析器，客户端应用中的方法调用必须是显式的，并形成一种链式方法调用。
 
 ## 2\. Java 中的 SAX XML 解析器
 
-**SAX 解析器是基于事件的 API** 。 通常，基于事件的 API 在处理程序上提供接口。 有四个处理程序接口， **ContentHandler** 接口， **DTDHandler** 接口， **EntityResolver** 接口和 **ErrorHandler** 接口。
+**SAX 解析器是基于事件的 API** 。 通常，基于事件的 API 在处理器上提供接口。 有四个处理器接口，`ContentHandler`接口， `DTDHandler`接口，`EntityResolver`接口和`ErrorHandler`接口。
 
-SAX 解析器**不会创建任何内部结构**。 取而代之的是，它将输入文档中组件的出现视为事件，并告诉客户端在读取输入文档时所读取的内容。 SAX 解析器始终在任何给定时间始终仅将文档的片段提供给客户端应用**。 使用 SAX 解析器，当在 xml 文档上解析期间发生某些特定事件时，某些自定义方法称为[[**回调**”方法]。 尽管我们可以显式调用它们，但客户端不必显式调用这些方法。**
+SAX 解析器**不会创建任何内部结构**。 取而代之的是，它将输入文档中组件的出现视为事件，并告诉客户端在读取输入文档时所读取的内容。 SAX 解析器始终在任何给定时间始终仅将文档的片段提供给客户端应用。 使用 SAX 解析器，当在 xml 文档上解析期间发生某些特定事件时，某些自定义方法称为“**回调**”方法。 尽管我们可以显式调用它们，但客户端不必显式调用这些方法。
 
-## 3\. DOM 和 Java 中的 SAX XML Parser 之间的区别
+## 3\. Java 中的 DOM 和 SAX XML 解析器之间的区别
 
 让我们列出一个容易记住的差异简短列表。
 
@@ -31,10 +31,10 @@ SAX 解析器**不会创建任何内部结构**。 取而代之的是，它将
 **SAX**
 
 *   解析直到您告诉它停止
-*   为每个事件触发事件处理程序：
-    1.  开始日
-    2.  标签体
-    3.  结束日
+*   为每个事件触发事件处理器：
+    1.  开始标签
+    2.  标签正文
+    3.  结束标签
 *   低级 API
 *   适用于非常大的文档，特别是如果您只关心文档的一小部分。
 
@@ -42,7 +42,7 @@ SAX 解析器**不会创建任何内部结构**。 取而代之的是，它将
 
 理想情况下，一个好的解析器应该是快速的（省时的），节省空间的，功能丰富的并且易于使用的。 但是实际上，没有一个主要的解析器同时具有所有这些功能。 例如，DOM 解析器功能丰富（因为它在内存中创建了 DOM 树，并允许您重复访问文档的任何部分，并允许您修改 DOM 树），但是当文档很大时，空间效率低下 ，并且需要花费一些时间来学习如何使用它。
 
-但是，在输入文档较大的情况下，SAX Parser 的空间效率要高得多（因为它不创建内部结构）。 而且，由于它的 API 非常简单，因此与 DOM 分析器相比，它运行更快且更易于学习。 但是从功能的角度来看，它提供的功能较少，这意味着用户自己必须承担更多的责任，例如创建自己的数据结构。
+但是，在输入文档较大的情况下，SAX 解析器的空间效率要高得多（因为它不创建内部结构）。 而且，由于它的 API 非常简单，因此与 DOM 分析器相比，它运行更快且更易于学习。 但是从功能的角度来看，它提供的功能较少，这意味着用户自己必须承担更多的责任，例如创建自己的数据结构。
 
 我认为答案确实**取决于您的应用的特性和当前的要求**。
 

docs/misc2/92.md

@@ -16,7 +16,7 @@
 
 ## 确定方法
 
-我相信，要把工作做好，我们肯定需要一个 bash 脚本。 Linux 具有一些非常有用的内置命令，这些命令在通过命令窗口执行时可以立即执行此工作。 bash 脚本的优势包括将实际应用的文件处理程序代码解耦，如果需要任何特定于平台的更改，可以对其进行修改。
+我相信，要把工作做好，我们肯定需要一个 bash 脚本。 Linux 具有一些非常有用的内置命令，这些命令在通过命令窗口执行时可以立即执行此工作。 bash 脚本的优势包括将实际应用的文件处理器代码解耦，如果需要任何特定于平台的更改，可以对其进行修改。
 
 ## 编写 bash 脚本