提交 573b8f34 编写于 作者: W wizardforcel

2020-06-11 11:37:21

上级 f2de5ee0
......@@ -206,6 +206,6 @@ Show
希望您喜欢 **Java 原型模式示例**上的这篇文章。 如有任何疑问,请发表评论。
[**Download source code**](//howtodoinjava.com/wp-content/downloads/PrototypePatternDemo.zip "download source code for prototype design pattern in java")
[**下载源码**](//howtodoinjava.com/wp-content/downloads/PrototypePatternDemo.zip "下载源码 for prototype design pattern in java")
学习愉快!
\ No newline at end of file
......@@ -74,7 +74,7 @@ Support service system : class diagram
## 参与者的源代码
以下是使用责任链设计模式实支持服务的所有参与者的源代码:
以下是使用责任链设计模式实支持服务的所有参与者的源代码:
**ServiceLevel.java**
......
......@@ -63,7 +63,7 @@ else If(buttonName.equals(“Fan”))
* 最重要的是,如果家里有很多物品,代码的复杂性和可维护性将会增加。
* 最后,代码不干净且紧密耦合,我们未遵循将*编码为接口*等最佳实践。
## 命令模式实
## 命令模式实
让我们用命令设计模式解决上述家庭自动化问题,并一次设计一个组件。
......@@ -284,7 +284,7 @@ public class HomeAutomationRemote {
```
## 演示
## 演示
让我们编写代码并执行客户端代码,以查看命令的执行方式。
......@@ -362,7 +362,7 @@ Fan stopped..
## 何时使用命令模式
您可以使用命令模式来解决许多设计问题,例如
您可以使用命令模式来解决许多设计问题,例如
* 处理 Java 菜单项和按钮的动作。
* 提供对宏的支持(宏的记录和播放)。
......@@ -400,6 +400,6 @@ Fan stopped..
这就是*命令设计模式*的全部。 将我的问题放在评论部分。
[Download Source Code](//howtodoinjava.com/wp-content/downloads/Command-Design-Pattern.zip)
[下载源码](//howtodoinjava.com/wp-content/downloads/Command-Design-Pattern.zip)
学习愉快!
\ No newline at end of file
......@@ -2,15 +2,15 @@
> 原文: [https://howtodoinjava.com/design-patterns/behavioral/mediator-pattern/](https://howtodoinjava.com/design-patterns/behavioral/mediator-pattern/)
根据 GoF 定义,**中介器模式**定义了一个对象,[封装了](https://howtodoinjava.com/oops/encapsulation-in-java-and-its-relation-with-abstraction/)一组对象如何交互。 介体通过防止对象之间显式地相互引用来促进松散耦合,并且它使我们可以独立地更改其交互。
根据 GoF 定义,**中介器模式**定义了一个对象,[封装了](https://howtodoinjava.com/oops/encapsulation-in-java-and-its-relation-with-abstraction/)一组对象如何交互。 中介者通过防止对象之间显式地相互引用来促进松散耦合,并且它使我们可以独立地更改其交互。
中介者是**行为设计模式**,也是 GoF 讨论的[其他 23 个模式](https://howtodoinjava.com/gang-of-four-java-design-patterns/)之一。
## 1.何时使用调解器设计模式
介体有助于在对象之间建立**松耦合通信**,并有助于减少彼此之间的直接引用。 这有助于最大程度地减少依赖管理和参与对象之间的通信的复杂性。
中介者有助于在对象之间建立**松耦合通信**,并有助于减少彼此之间的直接引用。 这有助于最大程度地减少依赖管理和参与对象之间的通信的复杂性。
介体**对象不知道其他对象**存在的方式帮助促进对象之间的交互。 对象仅依赖于单个调解器类,而不耦合到许多其他对象。
中介者**对象不知道其他对象**存在的方式帮助促进对象之间的交互。 对象仅依赖于单个调解器类,而不耦合到许多其他对象。
在设计问题的解决方案期间,如果遇到多个对象需要相互交互以处理请求,但直接通信可能会创建复杂系统的情况,则可以考虑使用中介者模式。
......@@ -20,7 +20,7 @@
* A great real world example of mediator pattern is **traffic control room** at airports. If all flights will have to interact with each other for finding which flight is going to land next, it will create a big mess.
相反,航班只会将其状态发送给塔楼。 这些塔依次发送信号,以确认哪架飞机可以起飞或着陆。 我们必须注意,这些塔无法控制整个飞行。 它们仅在终端区域实约束。
相反,航班只会将其状态发送给塔楼。 这些塔依次发送信号,以确认哪架飞机可以起飞或着陆。 我们必须注意,这些塔无法控制整个飞行。 它们仅在终端区域实约束。
* 中介模式的另一个很好的例子是**聊天应用**。 在聊天应用中,我们可以有多个参与者。 将每个参与者连接到所有其他参与者不是一个好主意,因为连接数量确实很高。 最好的解决方案是建立一个所有参与者都可以连接的集线器。 该中心只是调解器类。
* 在 Java 编程中,[`java.util.concurrent.Executor`](https://howtodoinjava.com/java/multi-threading/executor-framework-tutorial/)接口内部的`execute()`方法遵循此模式。 `java.util.Timer`类的各种`schedule()`方法的不同重载版本也可以视为遵循此模式。
......@@ -41,7 +41,7 @@ Mediator design pattern
#### 3.2 设计参加者
* **介体** – 定义`Colleague`对象之间的通信接口
* **中介者** – 定义`Colleague`对象之间的通信接口
* **ConcreteMediator** – 实现`Mediator`接口并协调`Colleague`对象之间的通信。 **它了解所有同事及其在互通方面的目的**
* **同事** – 定义了通过`Mediator`与其他同事进行交流的接口
* **ConcreteColleague** – 实现`Colleague`接口并通过其`Mediator`与其他同事进行通信
......@@ -50,7 +50,7 @@ Mediator design pattern
在此 **Java 中介器模式示例**中,我们模拟了聊天应用,用户可以在其中以一对一的方式向其他用户发送消息。 必须向所有聊天应用注册所有用户才能发送或接收消息。
**介体接口**
**中介者接口**
```java
public interface IChatRoom
......@@ -62,7 +62,7 @@ public interface IChatRoom
```
**混凝土介体**
**混凝土中介者**
```java
import java.util.HashMap;
......@@ -145,7 +145,7 @@ public class ChatUser extends User {
```
测试介体模式。
测试中介者模式。
```java
public class Main
......
# 纪念品设计模式
# 备忘录设计模式
> 原文: [https://howtodoinjava.com/design-patterns/behavioral/memento-design-pattern/](https://howtodoinjava.com/design-patterns/behavioral/memento-design-pattern/)
Memento 设计模式是行为模式,是 Gang of Four 讨论的 23 种[设计模式](https://howtodoinjava.com/gang-of-four-java-design-patterns/)之一。 **纪念图案**用于将对象的状态恢复到先前的状态。 也称为**快照模式**
纪念品就像对象生命周期中的还原点,客户端应用可使用该还原点将对象状态还原为其状态。 从概念上讲,这很像我们为操作系统创建还原点,并在发生故障或系统崩溃时用于还原系统。
备忘录就像对象生命周期中的还原点,客户端应用可使用该还原点将对象状态还原为其状态。 从概念上讲,这很像我们为操作系统创建还原点,并在发生故障或系统崩溃时用于还原系统。
> 记忆模式的目的是在不破坏封装的情况下捕获对象的内部状态,从而提供一种在需要时将对象恢复为初始状态的手段。
......@@ -12,7 +12,7 @@ Memento 设计模式是行为模式,是 Gang of Four 讨论的 23 种[设计
在对象状态不断变化的任何应用中都应使用 Memento 模式,并且该应用的用户可以在任何时候决定**回滚或撤消**所做的更改。
纪念品也可用于必须从其上一个已知工作状态或**草稿**重新启动的应用中。 这样的一个示例可以是 IDE,它可以在关闭 IDE 之前由用户更改后重新启动。
备忘录也可用于必须从其上一个已知工作状态或**草稿**重新启动的应用中。 这样的一个示例可以是 IDE,它可以在关闭 IDE 之前由用户更改后重新启动。
## 2.备忘录模式的真实示例
......@@ -20,7 +20,7 @@ Memento 设计模式是行为模式,是 Gang of Four 讨论的 23 种[设计
* 在代码编辑器中,我们可以使用简单的命令将**撤消和重做**还原或应用任何代码更改。
* 在计算器应用中,我们只需按一下按钮就可以重新访问内存中的所有计算。
* 在编程中,可以使用 memento 在数据库事务期间创建检查点。 如果任何操作失败,我们只需将所有内容回滚到最后一个已知的稳定数据库状态。
* `javax.swing.text.JTextComponent`类提供了撤消支持机制。 `javax.swing.undo.UndoManager`可以充当看守,`javax.swing.undo.UndoableEdit`的实现可以像纪念品,而`javax.swing.text.Document`的实现可以像发起者。
* `javax.swing.text.JTextComponent`类提供了撤消支持机制。 `javax.swing.undo.UndoManager`可以充当看守,`javax.swing.undo.UndoableEdit`的实现可以像备忘录,而`javax.swing.text.Document`的实现可以像发起者。
## 3.备忘录设计模式
......@@ -36,15 +36,15 @@ Memento 设计模式是行为模式,是 Gang of Four 讨论的 23 种[设计
#### 3.2 设计参加者
纪念品模式有三个参与者。
备忘录模式有三个参与者。
1. **发起者** – 是知道如何创建和保存其状态以备将来使用的对象。 它提供了方法`createMemento()``restore(memento)`
2. **看守者** – 在发起者上执行操作,同时可能回滚。 它跟踪多种纪念品。 看守者类是指发起者类,用于保存(HTG0)和恢复(HTG1)发起者的内部状态。
3. **Memento** – 由发起者编写和读取,并由看守者管理的锁盒。 原则上,纪念品必须在[不可变的](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/)对象中,这样一旦创建便没有人可以更改其状态。
2. **看守者** – 在发起者上执行操作,同时可能回滚。 它跟踪多种备忘录。 看守者类是指发起者类,用于保存(HTG0)和恢复(HTG1)发起者的内部状态。
3. **Memento** – 由发起者编写和读取,并由看守者管理的锁盒。 原则上,备忘录必须在[不可变的](https://howtodoinjava.com/java/basics/how-to-make-a-java-class-immutable/)对象中,这样一旦创建便没有人可以更改其状态。
## 4\. Memento 设计模式示例
在此示例中,我们为`Article`对象创建纪念品,该对象具有三个基本属性 – id,title 和 content。 `ArticleMemento`类用作`Article`对象的纪念品
在此示例中,我们为`Article`对象创建备忘录,该对象具有三个基本属性 – id,title 和 content。 `ArticleMemento`类用作`Article`对象的备忘录
```java
public class Article
......@@ -144,20 +144,20 @@ Article [id=1, title=My Article, content=ABC]
## 5.常见问题
#### 5.1 纪念品是内部阶级吗?
#### 5.1 备忘录是内部阶级吗?
可以用许多不同的方式来实现 memento 设计模式,例如内部类,程序包专用可见性或[序列化](https://howtodoinjava.com/java/serialization/a-mini-guide-for-implementing-serializable-interface-in-java/)等。实现 memento 模式没有固定的准则。
#### 5.2 纪念品模式的好处
#### 5.2 备忘录模式的好处
* 最大的优点是,您始终可以丢弃不需要的更改,并将其还原到预期或稳定的状态。
* 您不会破坏与参与此模型的关键对象关联的[封装](https://howtodoinjava.com/oops/encapsulation-in-java-and-its-relation-with-abstraction/)
* 保持高凝聚力。
* 提供一种简单的恢复技术。
#### 5.3 纪念品模式的挑战
#### 5.3 备忘录模式的挑战
* 大量纪念品需要更多存储空间。 同时,他们给看守人增加了负担。
* 大量备忘录需要更多存储空间。 同时,他们给看守人增加了负担。
* 同时还增加了维护成本,因为还需要付出代码努力来管理 memento 类。
* 保存状态的额外时间降低了系统的整体性能。
......
......@@ -57,7 +57,7 @@ Strategy Pattern Participants
在上述问题中,我们有一个可以以多种方式(连接到朋友)完成的操作,用户可以在运行时选择所需的方式。 因此,它非常适合用于策略设计模式。
为了实该解决方案,让我们一次设计一个参与者。
为了实该解决方案,让我们一次设计一个参与者。
* **ISocialMediaStrategy** - 抽象操作的接口。
* **SocialMediaContext** – 确定实现的上下文。
......@@ -71,7 +71,7 @@ Strategy Pattern Class Diagram
## 代码实
## 代码实
现在,让我们在设计参与者之上进行编码。
......@@ -177,7 +177,7 @@ public class OrkutStrategy implements ISocialMediaStrategy {
```
## 演示
## 演示
现在看看如何在运行时中使用这些策略。
......@@ -251,6 +251,6 @@ Connecting with Lokesh through Orkut [not possible though :)]
这就是有关策略设计模式的全部内容。 将我的问题放在评论部分。
[Download Source Code](//howtodoinjava.com/wp-content/downloads/strategyDesignPattern.zip)
[下载源码](//howtodoinjava.com/wp-content/downloads/strategyDesignPattern.zip)
学习愉快!
\ No newline at end of file
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/design-patterns/behavioral/template-method-pattern/](https://howtodoinjava.com/design-patterns/behavioral/template-method-pattern/)
**模板方法设计模式**是广泛接受的行为设计模式,用于在编程的上下文中实某种[算法](//howtodoinjava.com/java-algorithms-implementations/)(固定的步骤集)。
**模板方法设计模式**是广泛接受的行为设计模式,用于在编程的上下文中实某种[算法](//howtodoinjava.com/java-algorithms-implementations/)(固定的步骤集)。
它定义了执行多步算法的顺序步骤,并且还可以选择提供默认实现(根据要求)。
......@@ -63,7 +63,7 @@ Class Diagram using Template Method Design pattern
## 代码实
## 代码实
首先,我们需要创建一个名为`House`的抽象类,它将定义名为`buildHouse()`的模板方法。
......@@ -189,7 +189,7 @@ public class GlassWallHouse extends House {
```
## 演示
## 演示
让我们尝试建造两种房屋。
......@@ -260,10 +260,10 @@ Glass Wall House constructed successfully
## 总结
**模板模式**是一种非常简单的设计模式,用于定义和实编程示例中的某些顺序算法步骤。 它有助于定义算法的框架,该框架不得在子类中被覆盖。
**模板模式**是一种非常简单的设计模式,用于定义和实编程示例中的某些顺序算法步骤。 它有助于定义算法的框架,该框架不得在子类中被覆盖。
因此,展望未来,当您需要实现上述业务场景时,请考虑一下模板模式 – 它非常易于实现并且也非常易于维护。
学习愉快!
[Download Source Code](//howtodoinjava.com/wp-content/downloads/TemplateDesignPattern.zip)
\ No newline at end of file
[下载源码](//howtodoinjava.com/wp-content/downloads/TemplateDesignPattern.zip)
\ No newline at end of file
......@@ -72,7 +72,7 @@ Solution using visitor pattern
在上面的类图中,我们为 Mac 和 Linux 操作系统配置了路由器。 如果我们还需要添加 Windows 功能,那么我不需要更改任何类,只需定义一个新的访问者 WindowsConfigurator 并实现 RouterVisitor 接口中定义的 visit()方法。 它将提供所需的功能,而无需任何进一步的修改。
## 实代码
## 实代码
让我们看一下上面讨论的问题和解决方案所涉及的不同文件的源代码。
......
......@@ -32,13 +32,13 @@ Bridge pattern participants
1. #### 抽象(抽象类)
它定义了抽象接口,即行为部分。 它还维护实者参考。
它定义了抽象接口,即行为部分。 它还维护实者参考。
2. #### RefinedAbstraction(普通类)
它扩展了 Abstraction 定义的接口。
3. #### 实者(接口)
3. #### 实者(接口)
它定义了实现类的接口。 该接口不需要直接对应于抽象接口,并且可以有很大的不同。 抽象 imp 提供了一个由 Implementer 接口提供的操作的实现。
......@@ -208,7 +208,7 @@ File downloaded successfully in LINUX !!
#### 抽象的更改不会影响实现
现在,假设您要在抽象层添加另一项功能(即删除)。 它也不能强迫现有的实者和客户进行改变。
现在,假设您要在抽象层添加另一项功能(即删除)。 它也不能强迫现有的实者和客户进行改变。
**FileDownloaderAbstraction.java**
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/design-patterns/structural/composite-design-pattern/](https://howtodoinjava.com/design-patterns/structural/composite-design-pattern/)
**复合设计图案**是修改对象结构的**结构图案**。 此模式最适合需要使用**对象的情况,这些对象形成树状结构**。 在该树中,每个节点/对象(根节点除外)都是复合节点或叶节点。 实施复合模式可使客户统一对待单个对象和构图。
**复合设计模式**是修改对象结构的**结构图案**。 此模式最适合需要使用**对象的情况,这些对象形成树状结构**。 在该树中,每个节点/对象(根节点除外)都是复合节点或叶节点。 实现复合模式可使客户统一对待单个对象和构图。
```java
Table of Contents
......
......@@ -190,7 +190,7 @@ Support data - support link - - support popup -
**A)如何确定何时使用装饰器模式?**
如果我们深入了解该概念,则会发现 Decorator Design Pattern 具有多个需求指标以表明这是潜在的解决方案,例如
如果我们深入了解该概念,则会发现 Decorator Design Pattern 具有多个需求指标以表明这是潜在的解决方案,例如
* 我们有一个需要扩展名 e 的对象。 一个需要其他“可选”功能(例如滚动条,标题栏和状态栏)的窗口控件。
* 几个通过“装饰”支持扩展的对象。 通常,这些对象共享一个公共接口,特征或超类,有时还具有其他中间超类。
......@@ -208,7 +208,7 @@ DecoratorPattern 和子类之间的区别在于,在子类中,您可以“使
1)Java iO 库类,例如 BufferedInputStream bs = new BufferedInputStream(new FileInputStream(new File(“ File1.txt”))));
2)在显示标签 jsp 库中的装饰器列中,例如
2)在显示标签 jsp 库中的装饰器列中,例如
```java
<display:table name="reportsViewResultTable" class="demoClass" id="reportsQueryViewResultTable">
......
......@@ -6,7 +6,7 @@
## 1.何时使用外墙图案
立面图案是**结构设计图案**中的一种,另外还有四个[设计图案](https://howtodoinjava.com/gang-of-four-java-design-patterns/)。 当我们有一个复杂的系统要以简化的方式向客户公开时,外观模式是合适的。 其目的是将内部复杂性隐藏在从外部看起来很简单的单个界面后面。
立面图案是**结构设计模式**中的一种,另外还有四个[设计模式](https://howtodoinjava.com/gang-of-four-java-design-patterns/)。 当我们有一个复杂的系统要以简化的方式向客户公开时,外观模式是合适的。 其目的是将内部复杂性隐藏在从外部看起来很简单的单个界面后面。
Facade 还可以将使用系统的代码与子系统的细节分离开来,从而使以后修改系统变得更加容易。
......@@ -184,7 +184,7 @@ Pdf Report written
它为客户提供了一个简单的界面,即,我们没有为客户展示一个复杂的子系统,而是为客户提供了一个简化的界面。 它还可以帮助我们减少客户端需要处理的对象数量。
#### 4.2 外立面不限制对子系统的访问
#### 4.2 外不限制对子系统的访问
Facade 不封装子系统类或接口。 它只是提供了一个简单的界面(或图层),使我们的生活更轻松。 我们可以自由公开子系统或整个子系统本身的任何功能。
......@@ -196,7 +196,7 @@ Facade 不封装子系统类或接口。 它只是提供了一个简单的界面
外墙图案简化了界面。 它为客户端提供了一个与之交互的简单界面(而不是复杂的子系统)。
#### 4.4 外立面模式与中介模式
#### 4.4 外模式与中介模式
在调解器模式实现中,子系统知道调解器。 他们互相交谈。
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/design-patterns/structural/flyweight-design-pattern/](https://howtodoinjava.com/design-patterns/structural/flyweight-design-pattern/)
根据 GoF 定义,**轻量级设计模式**可以使用对象共享来有效地支持大量细粒度对象。 权重是**共享对象**,可以同时在多个上下文中使用。 飞重在每种情况下都充当独立对象。
根据 GoF 定义,**轻量级设计模式**可以使用对象共享来有效地支持大量细粒度对象。 权重是**共享对象**,可以同时在多个上下文中使用。 享元在每种情况下都充当独立对象。
## 1.何时使用轻量化设计模式
......
......@@ -152,7 +152,7 @@ public class IsbnEditor extends PropertyEditorSupport {
这是我最喜欢的原则。 它适用于接口,因为单一职责原则适用于类。 ISP 说:
> “不应强迫客户实不必要的不​​必要的方法”
> “不应强迫客户实不必要的不​​必要的方法”
举个例子。 开发人员 Alex 创建了一个接口`Reportable`并添加了两种方法`generateExcel()``generatedPdf()`。 现在,客户“ A”希望使用此界面,但他打算仅使用 PDF 格式的报告,而不使用 excel。 他将能够轻松使用该功能吗?
......
......@@ -247,7 +247,7 @@ public class Multiplication implements IOperation
通过确保代码可以扩展但不能修改,可以有效地禁止将来对现有类和程序集进行更改,这迫使程序员创建可以插入扩展点的新类。
建议的方法是确定需求中可能更改的部分或难以实的部分,并将这些部分排除在扩展点之后。
建议的方法是确定需求中可能更改的部分或难以实的部分,并将这些部分排除在扩展点之后。
学习愉快!
......
......@@ -167,7 +167,7 @@ Summary
毫无疑问,单元测试可以显着提高项目质量。 我们这个行业中的许多学者声称,任何单元测试总比没有好,但是我不同意:测试套件可以成为一项重要资产,但是不良套件可以成为负担不起的同样巨大的负担。 这取决于这些测试的质量,这似乎取决于其开发人员对单元测试的目标和原理的理解程度。
如果您理解上述准则,并尝试在下一组测试用例中实其中的大多数准则,那么您一定会感到与众不同。
如果您理解上述准则,并尝试在下一组测试用例中实其中的大多数准则,那么您一定会感到与众不同。
请让我知道您的想法。
......
......@@ -4,7 +4,7 @@
## 1.什么是多重字典>
在 python 中,“ **multidict** ”一词用于指代字典,在其中可以将**单键映射到多个值**。 例如
在 python 中,“ **multidict** ”一词用于指代字典,在其中可以将**单键映射到多个值**。 例如
```java
multidictWithList = {
......
......@@ -98,7 +98,7 @@ observable.map(w -> w.toUpperCase()).subscribe(consumer);
在上面的示例中,我们在订阅可观察对象之前添加了一种中间方法`map()`。 因此,每个单词都首先通过`map()`方法,然后再传递给订阅者以进行进一步处理。 这称为转换。
如前所述,您还可以在转换过程中更改事件的数据类型。 例如
如前所述,您还可以在转换过程中更改事件的数据类型。 例如
```java
Observable<String> observable = Observable.just("how", "to", "do", "in", "java");
......
......@@ -396,7 +396,7 @@ protected void doGet(HttpServletRequest request,
2)在 web.xml 应用部署描述符中注册监听器。
3)使用在`ServletContext`上定义的`addListener()`方法。
请注意,`ServletContextListener`不是 servlet API 中的唯一列表器。 还有更多例如
请注意,`ServletContextListener`不是 servlet API 中的唯一列表器。 还有更多例如
* javax.servlet.ServletRequestListener
* javax.servlet.ServletRequestAttrbiteListener
......
......@@ -845,7 +845,7 @@ Directory structure for spring struts hibernate integration
下载以上示例的源代码或获取.war 文件。
[Download Source Code](https://drive.google.com/file/d/0B7yo2HclmjI4S2c5YldiNk44aVE/edit?usp=sharing "spring + struts + hibernate tutorial source code link")
[下载源码](https://drive.google.com/file/d/0B7yo2HclmjI4S2c5YldiNk44aVE/edit?usp=sharing "spring + struts + hibernate tutorial source code link")
[Download .war File](https://drive.google.com/file/d/0B7yo2HclmjI4T2NrS19iRU5Hb3c/edit?usp=sharing "spring + struts + hibernate tutorial .war file link")
......
......@@ -34,7 +34,7 @@ Random exceptions
1) Use of `@ParentPackage` annotation
2) Define <constant name=”struts.convention.default.parent.package” value=”default”/ > in struts.xml
例如
例如
```java
<struts>
......
......@@ -95,7 +95,7 @@ struts.convention.result.path=/
```
好吧,你的路径不正确。 将其更正为 JSP 文件所在的任何有效位置。 例如
好吧,你的路径不正确。 将其更正为 JSP 文件所在的任何有效位置。 例如
```java
<constant name="struts.convention.result.path" value="/WEB-INF/jsp/" />
......
......@@ -56,7 +56,7 @@ public class IdentifyProblemsInCode {
> **引用 Java 语言规范 –**
>
> “我们的想法是,从包含该语句的构造函数,方法,实例初始化程序或静态初始化程序的开始,必须有一些可能的执行路径。 分析考虑了语句的结构。
> “我们的想法是,从包含该语句的构造函数,方法,实例初始化器或静态初始化器的开始,必须有一些可能的执行路径。 分析考虑了语句的结构。
>
> 除了对条件表达式具有恒定值 **true** 的`while`,`do`和`for`语句进行特殊处理外,在流量分析中不考虑其他表达式的值。
......
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/puzzles/puzzle-check-if-string-is-complete-contains-all-alphabets/](https://howtodoinjava.com/puzzles/puzzle-check-if-string-is-complete-contains-all-alphabets/)
如果字符串包含从 a 到 z 的所有字符,则认为该字符串是完整的。 给定一个字符串,检查它是否完成。 例如
如果字符串包含从 a 到 z 的所有字符,则认为该字符串是完整的。 给定一个字符串,检查它是否完成。 例如
**样本输入**
......
......@@ -129,7 +129,7 @@ HashMap 不是线程安全的。 我们可以在并发应用中使用 **HashTabl
#### 1.14 [Java 对象克隆](//howtodoinjava.com/java/cloning/a-guide-to-object-cloning-in-java/ "A guide to object cloning in java")
Java 中的对象**克隆**并非易事。 我自己花了很长时间了解 Java 的克隆。 看起来真的很简单; 使用`Cloneable`界面并覆盖`clone()`方法。 可是等等; 在面试中还有很多要说的和要问的。 例如
Java 中的对象**克隆**并非易事。 我自己花了很长时间了解 Java 的克隆。 看起来真的很简单; 使用`Cloneable`界面并覆盖`clone()`方法。 可是等等; 在面试中还有很多要说的和要问的。 例如
* clone()方法如何工作?
* Java 中的浅表复制是什么?
......@@ -159,7 +159,7 @@ Java 中的对象**克隆**并非易事。 我自己花了很长时间了解 Jav
定义**线程安全性**非常棘手。 线程安全性的任何合理定义的核心是正确性的概念。 因此,在了解线程安全性之前,我们应该首先了解这种“正确性”。
在这个必读的 Java 教程中,清除您的疑问并准备回答一些流行的面试问题。 例如
在这个必读的 Java 教程中,清除您的疑问并准备回答一些流行的面试问题。 例如
* 线程安全的正确性是什么?
* 举个线程安全类的例子吗?
......@@ -242,7 +242,7 @@ ThreadPoolExecutor 将任务创建和执行分开。 使用 ThreadPoolExecutor
#### 4.1 [Spring核心面试问题](https://howtodoinjava.com/interview-questions/top-spring-core-interview-questions-with-answers/)
我已经尝试收集一些Spring热门核心面试问题,您将在下次技术面试中面对这些问题,例如
我已经尝试收集一些Spring热门核心面试问题,您将在下次技术面试中面对这些问题,例如
* 什么是控制反转(IoC)和依赖注入(DI)?
* BeanFactory 和 ApplicationContext 之间的区别?
......
......@@ -96,7 +96,7 @@ Wrapping data and methods within classes in combination with implementation hidi
因此,它们可以像下面这样关联:
– 抽象更多是关于“类可以做什么”。 [想法]
– 封装更多地是关于“如何”实现该功能。 [实]
– 封装更多地是关于“如何”实现该功能。 [实]
## 接口和抽象类之间的区别?
......@@ -176,7 +176,7 @@ Java 基于 [Hoare](https://en.wikipedia.org/wiki/Tony_Hoare) 的监视器概念
3. 随时添加新值。
4. 在这一点上设置一个新值。
例如
例如
```java
List<String> names = new ArrayList<String>();
......
......@@ -143,7 +143,7 @@ List wordList = Arrays.asList(words);
```
请注意,此函数并非特定于 String 类,它将返回数组属于任何类型的元素的 List。 例如
请注意,此函数并非特定于 String 类,它将返回数组属于任何类型的元素的 List。 例如
```java
//String array
......
......@@ -136,7 +136,7 @@ public class Employee
* 创建`com.fasterxml.jackson.databind.ObjectMapper`的实例
* 使用`objectMapper.readValue()`方法将 JSON 转换为 POJO
例如
例如
```java
//JSON input
......
......@@ -274,6 +274,6 @@ Output:
```
[**下载这篇文章的源码**](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 "下载源码 for sax parser")
学习愉快!
\ No newline at end of file
......@@ -267,6 +267,6 @@ Received message: How to do in java dot com
```
[**下载源代码**](https://docs.google.com/file/d/0B7yo2HclmjI4b21RNVZFZm55dEU/edit?usp=sharing "download source code")
[**下载源代码**](https://docs.google.com/file/d/0B7yo2HclmjI4b21RNVZFZm55dEU/edit?usp=sharing "下载源码")
**祝您学习愉快!**
\ No newline at end of file
......@@ -129,7 +129,7 @@ Tomcat 的默认配置包括名为 **localhost** 的主机。 可以通过在文
阀门是类似于拦截器的元素,当插入到容器(上下文,主机或引擎)中时,**会在所有传入的 HTTP 请求到达应用**之前拦截它们。 这使您能够预处理针对特定应用的请求。 虚拟主机中运行的应用或引擎中运行的所有应用。
阀门可以有多种用途,例如
阀门可以有多种用途,例如
通过`RemoteAddrValve`阀,您可以根据源 IP 地址有选择地允许或阻止请求。 它支持两个属性 – `allow``block`
......
......@@ -8,13 +8,13 @@
获得线程转储所需的第一条信息是 Java 进程的 PID。
Java JDK 附带 **jps** 命令,该命令列出了所有 Java 进程 ID。 您可以这样运行此命令:
Java JDK 附带`jps`命令,该命令列出了所有 Java 进程 ID。 您可以这样运行此命令:
```java
$ jps -l
```
***记住*** – 您可能必须以 **$ sudo -u jps -l** 运行此命令,其中“ user”是 Java 进程用户的用户名 正在运行
***记住*** – 您可能必须以`$ sudo -u jps -l`运行此命令,其中“`user`”是正在运行的 Java 进程用户的用户名
即使现在,如果您仍无法找到进程 ID,请使用以下命令:
......@@ -26,13 +26,13 @@ $ ps -aef | grep java
如果已安装/可用,我们建议使用 [**jstack**](https://docs.oracle.com/javase/1.5.0/docs/tooldocs/share/jstack.html "jstack") 工具。 它将线程转储打印到命令行控制台。
要使用 jstack 获得**的线程转储,请运行以下命令:**
要使用 jstack 获得**线程转储**,请运行以下命令:
```java
$ jstack
```
您可以使用控制台输出 ***redirect / append*** 伪指令将连续的线程转储输出到文件中:
您可以使用控制台输出`redirect/append`伪指令将连续的线程转储输出到文件中:
```java
$ jstack >> threaddumps.log
......@@ -41,13 +41,12 @@ $ jstack >> threaddumps.log
**要点**
1. 从 JDK 1.5 开始,可以使用 jstack 工具。
2. 即使启用了 -Xrs jvm 参数,jstack 也可以工作。
2. 即使启用了`-Xrs jvm`参数,jstack 也可以工作。
3. 无法使用 JDK 1.6 中的 jstack 工具从运行在 JDK 1.5 上的进程中进行线程转储。
## 3.使用 jstack 脚本以固定的时间间隔进行线程转储采样
这个简单的 Shell 脚本以固定的时间间隔拍摄了几个 jstack 快照:[[参考文档](https://wiki.eclipse.org/How_to_report_a_deadlock#jstackSeries_--_jstack_sampling_in_fixed_time_intervals_.28tested_on_Linux.29 "jstack refernce")]
这个简单的 Shell 脚本以固定的时间间隔拍摄了几个 jstack 快照([参考文档](https://wiki.eclipse.org/How_to_report_a_deadlock#jstackSeries_--_jstack_sampling_in_fixed_time_intervals_.28tested_on_Linux.29 "jstack refernce")):
```java
#!/bin/bash
......@@ -79,13 +78,13 @@ $ jstackSeries 10 5
## 4.如何比较两个 JStack 线程转储
**比较线程转储**,您可以使用交互式差异查看器,例如
**比较线程转储**,您可以使用交互式差异查看器,例如
```java
$ vimdiff file1 file2 file3 file4 # up to 4 files
```
查看 jstack 跟踪的哪些部分随时间变化的另一种方法是使用 *$ context diff(-c 选项)*比较相邻的 jstack 跟踪:
查看 jstack 跟踪的哪些部分随时间变化的另一种方法是使用`$ context diff`(-c 选项)比较相邻的 jstack 跟踪:
```java
d_old=""
......
......@@ -11,7 +11,7 @@
* 确定方法
* 编写 bash 脚本
* 编写脚本执行器
* 添加食流者
* 添加`StreamEater`
* 查看全部
## 确定方法
......@@ -65,13 +65,13 @@ exit 0
```
在上面的脚本中,DIR_PATH,NUM_OF_DAYS 和 DIR_SIZE 是命令行参数。 而 SIZE 是用于计算目的的常数。 在上面的脚本中,**行号 16** 将删除 n 天之前的日志文件。
在上面的脚本中,`DIR_PATH``NUM_OF_DAYS``DIR_SIZE`是命令行参数。 而`SIZE`是用于计算目的的常数。 在上面的脚本中,**行号 16** 将删除 n 天之前的日志文件。
**行号 22** 中,脚本使用 *[du 命令](http://linux.about.com/library/cmd/blcmdl1_du.htm "Linux du command")* 检查目录的当前大小。 如果大小超过 DIR_SIZE(以 GB 为单位),脚本将开始使用' **ls -1tra | head -1**命令并开始将它们一个一个地删除。 它将继续直到目录大小未达到所需的限制。
**行号 22** 中,脚本使用[`du`命令](http://linux.about.com/library/cmd/blcmdl1_du.htm "Linux du command")检查目录的当前大小。 如果大小超过`DIR_SIZE`(以 GB 为单位),脚本将开始使用`ls -1tra | head -1`命令并开始将它们一个一个地删除。 它将继续直到目录大小未达到所需的限制。
## 编写脚本执行器
至于本文,核心组件将保留在 bash 脚本之上,但仍然需要一种从应用运行 *.sh 文件*的方法。 最好的方法是使用线程(如果需要,可以使用[执行器](https://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/ExecutorService.html "Executor Service"))。 该线程将以可配置的速率定期执行以上 bash 脚本。 我不会写那部分代码。 如果执行代码时遇到任何问题,请写下注释。
至于本文,核心组件将保留在 bash 脚本之上,但仍然需要一种从应用运行`*.sh`文件的方法。 最好的方法是使用线程(如果需要,可以使用[执行器](https://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/ExecutorService.html "Executor Service"))。 该线程将以可配置的速率定期执行以上 bash 脚本。 我不会写那部分代码。 如果执行代码时遇到任何问题,请写下注释。
让我给你一个示例代码::
......@@ -152,19 +152,19 @@ public final class DiskFileManager
```
上面的代码将在类路径中找到脚本文件,并传递所需的参数。 在我们的例子中,“ / logs 1 1”是 3 个参数,这意味着
上面的代码将在类路径中找到脚本文件,并传递所需的参数。 在我们的例子中,“`/logs 1 1`”是 3 个参数,这意味着
* 要监视的目录是/ logs
* 要监视的目录是`/logs`
* 删除一天的日志文件,然后
* 请勿在任何时候存储超过 1 GB 的日志文件。
## 添加食流者
## 添加`StreamEater`
因此,我们已经添加了一个 bash 脚本和一个用于运行脚本的执行程序代码。 您必须编写自己的线程才能在执行程序上方定期运行。
现在,我们将研究 StreamEater,它实际上收集命令输出并提供给您的应用代码,因此应用可以记录它或执行所需的任何操作。
现在,我们将研究`StreamEater`,它实际上收集命令输出并提供给您的应用代码,因此应用可以记录它或执行所需的任何操作。
我们已经在上面的执行器中使用过 StreamEater,现在我给出其代码:
我们已经在上面的执行器中使用过`StreamEater`,现在我给出其代码:
```java
package corejava.dischandler;
......
......@@ -4,7 +4,7 @@
如今, [REST](http://restfulapi.net)[微服务](//howtodoinjava.com/microservices/microservices-definition-principles-benefits/)势头强劲。 同时,实际的 REST 规范并未建议任何标准方法来记录我们将要公开的 REST API(例如 WSDL for SOAP)。 结果,每个人都以自己的方式记录自己的 API,从而导致通用结构中的空白,所有这些都可以轻松地遵循,理解和使用。 我们需要一个通用的模式和工具。
[Swagger](https://swagger.io/) (得到了 Google,IBM,Microsoft 等公司的支持)完成了相同工作,以填补常见文档样式的空白。 在本教程中,我们将学习**使用 Swagger 来使用 **swagger 2 注释**来生成 REST API 文档**
[Swagger](https://swagger.io/)(得到了 Google,IBM,Microsoft 等公司的支持)完成了相同工作,以填补常见文档样式的空白。 在本教程中,我们将学习**使用 Swagger 来使用 **swagger2 注释**来生成 REST API 文档**
```java
Table of Contents
......@@ -19,7 +19,7 @@ Demo
## 昂首阔步
Swagger(现为“ Open API Initiative”)是一种规范和框架,用于使用所有人都可以理解的通用语言来描述 REST API。 还有其他一些流行的框架,例如 RAML,Summation 等。但是,考虑到它的功能和在开发者社区中的接受程度,Swagger 在这一点上最受欢迎。
Swagger(现为“Open API Initiative”)是一种规范和框架,用于使用所有人都可以理解的通用语言来描述 REST API。 还有其他一些流行的框架,例如 RAML,Summation 等。但是,考虑到它的功能和在开发者社区中的接受程度,Swagger 在这一点上最受欢迎。
它提供了人类可读和机器可读的文档格式。 它同时提供 JSON 和 UI 支持。 JSON 可以用作机器可读格式,`Swagger-UI`用于可视化显示,人类只需浏览 api 文档即可轻松理解。
......@@ -29,7 +29,7 @@ Swagger(现为“ Open API Initiative”)是一种规范和框架,用于
![Swagger2 Project Structure](img/e5fb83172c356c894cde300dfc0d9933.png)
Swagger2 Project Structure
Swagger2 项目结构
......@@ -46,15 +46,15 @@ Swagger2 Project Structure
我们将首先创建一些 REST API,这些 API 将用于展示 Swagger 文档功能。 我们将使用 Spring 引导样式公开剩余的 API,以缩短开发时间。
1. Create a Spring boot project from [Spring Boot initializer](https://start.spring.io/) portal with `Web`, `Rest Repositories`, `Actuator` dependencies. Give other maven GAV coordinates and download the project. This screen will look like:
1. 从具有 Web,Rest Repositories,Actuator 依赖项的 [Spring Boot 初始化器](https://start.spring.io/)门户创建一个 Spring Boot 项目。 给出其他 Maven GAV 坐标并下载项目。 该屏幕如下所示:
[![](img/dc6046216d8449cef133f2c6e41291ec.png)](//howtodoinjava.com/wp-content/uploads/2017/07/Project_Generation.jpg)
Spring Boot REST Project Generation
Spring Boot REST 项目生成
将项目解压缩并将其作为现有的 maven 项目导入 Eclipse。 在此步骤中,将从 maven 仓库下载所有必需的依赖项。 在此步骤中执行全新的`mvn clean install`,以便正确下载所有与Spring启动相关的工件。
将项目解压缩并将其作为现有的 maven 项目导入 Eclipse。 在此步骤中,将从 maven 仓库下载所有必需的依赖项。 在此步骤中执行全新的`mvn clean install`,以便正确下载所有与 Spring Boot相关的工件。
2. 打开`application.properties`并添加以下属性。 这将在`/swagger2-demo`上下文路径中启动应用。
......@@ -62,9 +62,9 @@ Swagger2 Project Structure
server.contextPath=/swagger2-demo
```
3. Add one REST controller `Swagger2DemoRestController` which will provide basic REST based functionalities on `Student` entity.
3. 添加一个 REST 控制器“`Swagger2DemoRestController`”,该控制器将在“`Student`”实体上提供基于 REST 的基本功能。
**Swagger2DemoRestController.java**
**`Swagger2DemoRestController.java`**
```java
package com.example.springbootswagger2.controller;
......@@ -115,7 +115,7 @@ Swagger2 Project Structure
```
**Student.java**
**`Student.java`**
```java
......@@ -154,19 +154,19 @@ Swagger2 Project Structure
```
4. 作为 Spring 启动应用启动该应用。 测试几个 REST 端点,以检查它们是否工作正常:
* http:// localhost:8080 / swagger2-demo / getStudents
* http:// localhost:8080 / swagger2-demo / getStudent / sajal
* http:// localhost:8080 / swagger2-demo / getStudentByCountry / india
* http:// localhost:8080 / swagger2-demo / getStudentByClass / v
4. 作为 Spring Boot 应用启动该应用。 测试几个 REST 端点,以检查它们是否工作正常:
* `http://localhost:8080/swagger2-demo/getStudents`
* `http://localhost:8080/swagger2-demo/getStudent/sajal`
* `http://localhost:8080/swagger2-demo/getStudentByCountry/india`
* `http://localhost:8080/swagger2-demo/getStudentByClass/v`
## Swagger2 配置
我们的 REST API 已准备就绪。 现在将 swagger 2 支持添加到 project.ff
我们的 REST API 已准备就绪。 现在将 swagger2 支持添加到`project.ff`
#### 添加 Swagger2 Maven 依赖项
打开`spring-boot-swagger2`项目的 pom.xml 文件,并在下面添加两个与 swagger 相关的依赖项,即`springfox-swagger2``springfox-swagger-ui`
打开`spring-boot-swagger2`项目的`pom.xml`文件,并在下面添加两个与 swagger 相关的依赖项,即`springfox-swagger2``springfox-swagger-ui`
```java
<dependency>
......@@ -183,7 +183,7 @@ Swagger2 Project Structure
```
Actually `swagger` API has couple of varieties and maintained in different artifacts. Today we will use the `springfox` because this version adapts well with any spring based configurations. We can try other configurations also easily and that should give same functionality – with no/little change in configuration.
实际上,`swagger` API 具有多种变体,并且维护在不同的工件中。 今天,我们将使用`springfox`,因为该版本可以很好地适应任何基于 spring 的配置。 我们还可以轻松地尝试其他配置,并且应该提供相同的功能-无需更改/只需稍作更改即可。
#### 添加 Swagger2 配置
......@@ -233,17 +233,17 @@ public class Swagger2UiConfiguration extends WebMvcConfigurerAdapter
#### 验证 Swagger2 JSON 格式文档
执行 maven 并启动服务器。 打开链接 [http:// localhost:8080 / swagger2-demo / v2 / api-docs](http://localhost:8080/swagger2-demo/v2/api-docs) ,它应该以`JSON`格式提供整个文档。 这并不是那么容易阅读和理解,实际上 Swagger 已经提供了将其用于其他系统中的功能,例如如今流行的 API 管理工具,它提供了 API 网关,API 缓存,API 文档等功能。
执行 maven 并启动服务器。 打开链接`http://localhost:8080/swagger2-demo/v2/api-docs`,它应该以`JSON`格式提供整个文档。 这并不是那么容易阅读和理解,实际上 Swagger 已经提供了将其用于其他系统中的功能,例如如今流行的 API 管理工具,它提供了 API 网关,API 缓存,API 文档等功能。
[![](img/4e9fbf864b8b2663ee66dfc5c3fc5c8c.png)](//howtodoinjava.com/wp-content/uploads/2017/07/JSON_documenatation.jpg)
JSON documentation
JSON 文档
#### 验证 Swagger2 UI 文档
打开 [http:// localhost:8080 / swagger2-demo / swagger-ui.html](http://localhost:8080/swagger2-demo/swagger-ui.html) 在浏览器中查看 Swagger UI 文档。
打开`http://localhost:8080/swagger2-demo/swagger-ui.html`在浏览器中查看 Swagger UI 文档。
![Swagger2 UI Docs without Annotations](img/de00227979aa13b38e66dc6d767ad0be.png)
......@@ -253,7 +253,7 @@ Swagger2 UI 文档(无注释)
## Swagger2 注释
默认生成的 API 文档很好,但是缺少详细的 API 级别信息。 Swagger 提供了一些注释,可以将这些详细信息添加到 API。 例如
默认生成的 API 文档很好,但是缺少详细的 API 级别信息。 Swagger 提供了一些注释,可以将这些详细信息添加到 API。 例如
1. `@Api` – 我们可以将此注释添加到控制器,以添加有关控制器的基本信息。
......@@ -265,7 +265,7 @@ Swagger2 UI 文档(无注释)
}
```
2. `@ApiOperation and @ApiResponses` – We can add these annotations to any rest method in the controller to add basic information related to that method. e.g.
2. `@ApiOperation``@ApiResponses` – 我们可以将这些注释添加到控制器中的任何 rest 方法,以添加与该方法有关的基本信息。 例如:
```java
@ApiOperation(value = "Get list of Students in the System ", response = Iterable.class, tags = "getStudents")
......@@ -284,16 +284,16 @@ Swagger2 UI 文档(无注释)
在这里,我们可以将`tags`添加到方法中,以在`swagger-ui`中添加一些分组。
3. `@ApiModelProperty` – 在 Model 属性中使用此注释可为该 Model 属性的 Swagger 输出添加一些描述。 例如
3. `@ApiModelProperty` – 在 Model 属性中使用此注释可为该 Model 属性的 Swagger 输出添加一些描述。 例如
```java
@ApiModelProperty(notes = "Name of the Student",name="name",required=true,value="test name")
private String name;
```
添加 swagger2 注释后的 Controller 和 Model 类代码。
添加 swagger2 注释后的控制器和模型类代码。
**Swagger2DemoRestController.java**
**`Swagger2DemoRestController.java`**
```java
package com.example.springbootswagger2.controller;
......@@ -359,7 +359,7 @@ public class Swagger2DemoRestController {
```
**Student.java**
**`Student.java`**
```java
package com.example.springbootswagger2.model;
......@@ -404,18 +404,18 @@ public class Student
```
## 演示
## 演示
现在,在正确注释我们的 REST API 之后,我们来看一下最终输出。 打开 [http:// localhost:8080 / swagger2-demo / swagger-ui.html](http://localhost:8080/swagger2-demo/swagger-ui.html) 在浏览器中查看 Swagger ui 文档。
现在,在正确注释我们的 REST API 之后,我们来看一下最终输出。 打开`http://localhost:8080/swagger2-demo/swagger-ui.html`在浏览器中查看 Swagger ui 文档。
![Final Swagger2 REST API Output](img/1f62370e64802188fb3551506abb9860.png)
Final Swagger2 REST API Output
Swagger2 REST API 最终输出
这一切都将通过 Spring 启动应用[swagger2] **创建 REST API 文档。 将我的问题放在评论部分。**
这一切都将通过 Spring Boot应用 swagger2 **创建 REST API 文档**。 将我的问题放在评论部分。
[Download Source code](//howtodoinjava.com/wp-content/uploads/2017/07/spring-boot-swagger2.zip)
[下载源码](//howtodoinjava.com/wp-content/uploads/2017/07/spring-boot-swagger2.zip)
学习愉快!
\ No newline at end of file
......@@ -2,7 +2,7 @@
> 原文: [https://howtodoinjava.com/gang-of-four-java-design-patterns/](https://howtodoinjava.com/gang-of-four-java-design-patterns/)
顾名思义,设计模式是设计软件时最常见(和最常见)的问题的解决方案。 这些模式大多是“进化的”而不是“发现的”。 这些设计模式总结了许多专业人士的大量学习成果。 这些模式都没有强迫您执行任何东西。 它们只是在特定情况下以特定方式解决特定问题的指南。 代码实是您的责任。
顾名思义,设计模式是设计软件时最常见(和最常见)的问题的解决方案。 这些模式大多是“进化的”而不是“发现的”。 这些设计模式总结了许多专业人士的大量学习成果。 这些模式都没有强迫您执行任何东西。 它们只是在特定情况下以特定方式解决特定问题的指南。 代码实是您的责任。
非常重要,让我们更详细地学习这些设计模式(在 Java 上下文中)。
......@@ -10,37 +10,40 @@
创建模式通常用于代替构造函数的直接实例化。 它们使创建过程更具适应性和动态性。 特别是,它们可以为创建哪些对象,如何创建这些对象以及如何对其进行初始化提供很大的灵活性。
| 设计图案名称 | 目的 |
| 设计模式名称 | 目的 |
| --- | --- |
| [构建器](//howtodoinjava.com/design-patterns/creational/builder-pattern-in-java/) | 构建器设计模式是构建复杂对象的另一种方法,仅当我们希望使用相同的对象构建过程构建不同类型的不可变对象时,才应使用构建器设计模式。 |
| [原型](//howtodoinjava.com/design-patterns/creational/prototype-design-pattern-in-java/) | 原型设计模式用于应用需要创建大量类的实例的情况,这些实例的状态几乎相同或相差很小。 |
| [工厂](//howtodoinjava.com/design-patterns/creational/implementing-factory-design-pattern-in-java/) | 当涉及复杂的对象创建步骤时,工厂设计模式最合适。 为了确保这些步骤是集中的,并且不暴露于组成类。 |
| [抽象工厂](//howtodoinjava.com/design-patterns/creational/abstract-factory-pattern-in-java/) | 每当我们需要对使用工厂模式创建的一组工厂进行另一个抽象级别时,就会使用抽象工厂模式。 |
| [单例](//howtodoinjava.com/design-patterns/singleton-design-pattern-in-java/) | Singleton 使应用每个 JVM 具有一个类的一个实例。 |
| [单例](//howtodoinjava.com/design-patterns/singleton-design-pattern-in-java/) | 单例使应用每个 JVM 具有一个类的一个实例。 |
## 2.结构设计模式
结构设计模式向我们展示了如何以灵活和可扩展的方式将系统的不同部分粘合在一起。 这些模式帮助我们确保当其中一部分发生更改时,整个应用结构都不需要更改。
| Design Pattern Name | Purpose |
| 设计模式名称 | 目的 |
| --- | --- |
| [适配器](//howtodoinjava.com/2014/05/10/adapter-design-pattern-in-java/) | 适配器将类的接口转换为客户端期望的另一个接口。 它可以让类因接口不兼容而无法一起工作。 |
| [](//howtodoinjava.com/design-patterns/structural/bridge-design-pattern/) | 桥接器设计模式用于将一个类分解为两部分 -*抽象**实现* – 以便将来可以相互进化而不会相互影响。 它增加了类抽象与其实现之间的松散耦合。 |
| [复合](//howtodoinjava.com/design-patterns/structural/composite-design-pattern/) | 组合设计模式有助于将对象组合成树形结构,以表示整个部分的层次结构。 复合可以使客户统一对待单个对象和对象组成。 |
| [](//howtodoinjava.com/design-patterns/structural/bridge-design-pattern/) | 桥接器设计模式用于将一个类分解为两部分 - *抽象**实现* – 以便将来可以相互进化而不会相互影响。 它增加了类抽象与其实现之间的松散耦合。 |
| [组合](//howtodoinjava.com/design-patterns/structural/composite-design-pattern/) | 组合设计模式有助于将对象组合成树形结构,以表示整个部分的层次结构。 组合可以使客户统一对待单个对象和对象组成。 |
| [装饰器](//howtodoinjava.com/design-patterns/structural/decorator-design-pattern/) | 装饰器设计模式用于向类的特定实例添加其他功能或行为,而不会修改同一类的其他实例。 |
| [立面](https://howtodoinjava.com/design-patterns/structural/facade-design-pattern/) | 外观设计模式为子系统中的一组接口提供了统一的接口。 Facade 定义了一个更高级别的界面,使子系统更易于使用。 |
| [Flyweight](https://howtodoinjava.com/design-patterns/structural/flyweight-design-pattern/) | Flyweight 设计模式允许使用对象共享,以有效支持大量细粒度的对象。 flyweight 是一个共享对象,可以同时在多个上下文中使用。 飞重在每种情况下都充当独立对象。 |
| [](https://howtodoinjava.com/design-patterns/structural/facade-design-pattern/) | 外观设计模式为子系统中的一组接口提供了统一的接口。 外观定义了一个更高级别的界面,使子系统更易于使用。 |
| [享元](https://howtodoinjava.com/design-patterns/structural/flyweight-design-pattern/) | 享元设计模式允许使用对象共享,以有效支持大量细粒度的对象。 享元是一个共享对象,可以同时在多个上下文中使用。 享元在每种情况下都充当独立对象。 |
| [代理](https://howtodoinjava.com/design-patterns/structural/proxy-design-pattern/) | 在代理设计模式中,代理对象为另一个对象提供代理或占位符,以控制对其的访问。 代理大量用于实现与延迟加载相关的用例,在这种情况下,我们直到真正需要时才创建完整的对象。 |
## 3.行为设计模式
行为模式抽象了我们要对采取该操作的对象或类采取的操作。 通过更改对象或类,我们可以更改所使用的算法,受影响的对象或行为,同时仍为客户端类保留相同的基本接口。
| Design Pattern Name | Purpose |
| 设计模式名称 | 目的 |
| --- | --- |
| [责任链](//howtodoinjava.com/design-patterns/behavioral/chain-of-responsibility-design-pattern/) | 责任链设计模式通过以链的形式将接收对象链接在一起,为多个对象提供了处理请求的机会。 |
| [命令](//howtodoinjava.com/design-patterns/behavioral/command-pattern/) | 命令设计模式对于将业务逻辑抽象为离散的动作(我们称为命令)很有用。 这些命令对象有助于两个类之间的松散耦合,其中一个类(调用者)应调用另一类(接收者)上的方法来执行业务操作。 |
| 口译员 | 解释器模式指定如何以编程方式求值一种语言的句子。 它有助于为一种简单的语言建立语法,以便可以解释该语言中的句子。 |
| 解释器 | 解释器模式指定如何以编程方式求值一种语言的句子。 它有助于为一种简单的语言建立语法,以便可以解释该语言中的句子。 |
| [迭代器](https://howtodoinjava.com/design-patterns/behavioral/iterator-design-pattern/) | 迭代器模式提供了一种在不暴露其基础表示的情况下顺序访问聚合对象的元素的方法。 |
| [介体](https://howtodoinjava.com/design-patterns/behavioral/mediator-pattern/) | 介体模式定义了一个对象,该对象封装了一组对象之间的交互方式。 介体通过防止对象之间显式地相互引用来促进松散耦合,并且它使我们可以独立地更改其交互。 |
| [纪念品](https://howtodoinjava.com/design-patterns/behavioral/memento-design-pattern/) | 记忆模式用于将对象的状态恢复到先前的状态。 也称为快照模式。 |
| [中介者](https://howtodoinjava.com/design-patterns/behavioral/mediator-pattern/) | 中介者模式定义了一个对象,该对象封装了一组对象之间的交互方式。 中介者通过防止对象之间显式地相互引用来促进松散耦合,并且它使我们可以独立地更改其交互。 |
| [备忘录](https://howtodoinjava.com/design-patterns/behavioral/memento-design-pattern/) | 记忆模式用于将对象的状态恢复到先前的状态。 也称为快照模式。 |
| [观察者](https://howtodoinjava.com/design-patterns/behavioral/observer-design-pattern/) | 观察者模式定义了对象之间的一对多依赖关系,因此当一个对象改变状态时,其所有依赖关系都会得到通知并自动更新。 它也称为发布 - 订阅模式。 |
| [状态](https://howtodoinjava.com/design-patterns/behavioral/state-design-pattern/) | 在状态模式下,对象可以在其内部状态更改时更改其行为。 该对象似乎将更改其类。 每个对象的可能状态应有一个单独的具体类。 |
| [策略](//howtodoinjava.com/design-patterns/behavioral/strategy-design-pattern/) | 当我们在运行时从算法的多个其他实现中选择特定的算法或任务实现时,将使用策略模式。 |
......
......@@ -282,7 +282,7 @@ public class DemoSingleton implements Serializable {
## 7.将 serialVersionUId 添加到单例对象
到目前为止,一切都很好。 到目前为止,我们已经解决了同步和序列化这两个问题。 现在,我们距正确而完整的实仅一步之遥。 唯一缺少的部分是序列号。
到目前为止,一切都很好。 到目前为止,我们已经解决了同步和序列化这两个问题。 现在,我们距正确而完整的实仅一步之遥。 唯一缺少的部分是序列号。
在您的类结构在序列化和反序列化之间更改的情况下,这是必需的。 更改的类结构将导致 JVM 在反序列化过程中给出异常。
......
......@@ -202,7 +202,7 @@ User: Super, Man, 0, null, null
## JDK 中的现有实现
[java.lang.Appendable](https://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html "Appendable") 的所有实现实际上都是在 Java 中使用 Builder 模式的良好示例。 例如
[java.lang.Appendable](https://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html "Appendable") 的所有实现实际上都是在 Java 中使用 Builder 模式的良好示例。 例如
[java.lang.StringBuilder#append()](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html#append%28java.lang.CharSequence%29 "StringBuilder") [未同步的类]
......
......@@ -25,7 +25,7 @@ Table of Contents
工厂模式引入了**类之间的松散耦合**,这是在设计应用架构时应考虑并应用的最重要的原理。 通过针对抽象实体(而不是具体的实现)进行编程,可以在应用架构中引入松耦合。 这不仅使我们的架构更加灵活,而且不那么脆弱。
一张图片胜过千言万语。 让我们看看工厂实的样子。
一张图片胜过千言万语。 让我们看看工厂实的样子。
[![](img/27cfb71b99daa98627b530eabd77c766.png "class_diagram_of_factory_pattern_in_java")](https://howtodoinjava.files.wordpress.com/2012/10/class_diagram_of_factory_pattern_in_java1.png)
......@@ -221,7 +221,7 @@ designPatterns.creational.factory.LuxuryCar@e9bfee2
## 4.最后的笔记
**工厂模式最适合涉及一些复杂的对象创建步骤的地方**。 为确保这些步骤集中进行,并且不暴露于编写类中,应使用工厂模式。 我们可以在 JDK 本身中看到许多实时的工厂模式示例,例如
**工厂模式最适合涉及一些复杂的对象创建步骤的地方**。 为确保这些步骤集中进行,并且不暴露于编写类中,应使用工厂模式。 我们可以在 JDK 本身中看到许多实时的工厂模式示例,例如
* [java.sql.DriverManager#getConnection()](https://docs.oracle.com/javase/10/docs/api/java/sql/DriverManager.html#getConnection%28java.lang.String%29 "driver manager get connection")
* [java.net.URL#openConnection()](https://docs.oracle.com/javase/10/docs/api/java/net/URL.html#openConnection%28%29 "url open connection")
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册