浅析23种软件设计模式

眼睛是心灵的窗户，是人体中最宝贵 的感觉 器官， 可很多 孩子对 眼睛的 重要性 不重视 。在每 学期的 视力测 查中情 况都不 容乐观
设计模式分类
Creational patterns 帮助我们更好地组织创建 对象的代码。增强弹性，以应付在不同情况下 创建和初始化对象的代码变更。 Structural patterns 增强代码重用，优化对象结 构，使其职责分明、粒度合适，以松耦合的体 系结构来减低代码的rippling效应。 Behavioral patterns 更好地定义对象间的协作 关系，使复杂的程序流程变得清晰。
由上述我们不难引出Abstract Factory的定义，就是 用于创建Factory的Factory。其设计思想和Factory的完 全一致，不过是一种特殊的Factory而已。
眼睛是心灵的窗户，是人体中最宝贵 的感觉 器官， 可很多 孩子对 眼睛的 重要性 不重视 。在每 学期的 视力测 查中情 况都不 容乐观
实际上，EJB容器将所有资源（JMS Factory、EJB Home等）的Factory全绑定到了目录服务中，使用这 些Factory的时候都是由目录服务获取，因此目录服务 是所有资源Factory的Abstract Factory。
眼睛是心灵的窗户，是人体中最宝贵 的感觉 器官， 可很多 孩子对 眼睛的 重要性 不重视 。在每 学期的 视力测 查中情 况都不 容乐观
其核心思想是将可重用的解决方案总 结出来，并分门别类。从而指导设计，减 少代码重复和优化体系结构。
眼睛是心灵的窗户，是人体中最宝贵 的感觉 器官， 可很多 孩子对 眼睛的 重要性 不重视 。在每 学期的 视力测 查中情 况都不 容乐观
采用设计模式的益处
重用，避免代码重复冗余 优化体系结构 提升系统的可维护性和弹性 代码更加容易测试，利于测试驱动 为性能优化提供便利 使软件质量更加有保证 增强代码可读性，便于团队交流 有助于整体提升团队水平

详解23种设计模式设计模式（Design Patterns） ⾸先说⼀下我对设计模式的理解，设计模式是⼀种在软件内部优化代码的技巧。

注意，是代码的内部，也就是在⼀个局部范围内优化设计。

这⼀点和软件的架构是完全不同的，软件架构是全局的优化，讲的是怎么对软件进⾏切分以及对切开之后的内容进⾏重组的⼀个过程。

软件的设计模式强调的是代码，软件架构强调的是结构。

在⾯向对象的编程思想中，这就体现在怎么解决类与类之间的关系。

能处理好类与类之间的关系，优化设计就搞好了。

下⾯这段话是软件设计模式的定义： 设计模式（Design pattern）是⼀套被反复使⽤、多数⼈知晓的、经过分类编⽬的、代码设计经验的总结。

使⽤设计模式是为了可重⽤代码、让代码更容易被他⼈理解、保证代码可靠性。

毫⽆疑问，设计模式于⼰于他⼈于系统都是多赢的，设计模式使代码编制真正⼯程化，设计模式是软件⼯程的基⽯，如同⼤厦的⼀块块砖⽯⼀样。

项⽬中合理的运⽤设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每⼀个模式描述了⼀个在我们周围不断重复发⽣的问题，以及该问题的核⼼解决⽅案，这也是它能被⼴泛应⽤的原因。

设计模式是⼀代⼜⼀代的编程⼤师总结出来的，我们应该重视，不能束之⾼阁，应当合理利⽤。

关键是要搞清楚哪种情况⽤哪种设计模式。

⼀、设计模式的分类总体来说设计模式分为三⼤类：创建型模式，共五种：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。

（还有⼀种叫简单⼯⼚模式，是⼯⼚模式的变形，不满⾜单⼀职责，设计不太合理，所以就没列出来）结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

⾏为型模式，共⼗⼀种：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

⼆、设计模式的七⼤原则设计模式的七⼤原则堪称经典，这七条原则是我们在设计软件的过程中必须准守的，当然不遵守的话，你的⽼板可能就会“嘿嘿”你，你懂得！这七条原则指导了23种设计模式，可以这么说，23种设计模式就是在这七条原则在不同场景之下的应⽤。

23种设计模式及应用设计模式是指在软件设计过程中，针对常见问题的解决方案的经验总结。

它们提供了解决特定或常见问题的可重用方案，使得软件设计更加灵活、可扩展和可维护。

1. 创建型模式：- 单例模式：确保一个类只有一个实例，并提供全局访问点。

- 简单工厂模式：通过一个共同的接口创建不同的对象实例。

- 工厂方法模式：定义一个创建对象的接口，由子类决定具体创建哪个对象。

- 抽象工厂模式：提供一个创建一系列相关或互相依赖对象的接口。

- 建造者模式：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

2. 结构型模式：- 适配器模式：将一个类的接口转换为客户端所期待的另一种接口。

- 桥接模式：将抽象部分与它的实现部分分离，使它们可以独立变化。

- 组合模式：将对象组合成树形结构以表示"整体-部分"的层次结构。

- 装饰器模式：动态地给对象添加额外的功能，避免继承带来的类膨胀问题。

- 外观模式：为子系统中一组接口提供一个一致的界面。

3. 行为型模式：- 策略模式：定义一系列算法，将它们封装起来，并使它们可以相互替换。

- 观察者模式：定义对象之间的依赖关系，当对象状态改变时自动通知依赖方。

- 模板方法模式：定义一个操作中的算法骨架，将一些步骤延迟到子类中实现。

- 命令模式：将一个请求封装成一个对象，从而使您可以用不同的请求参数化客户端对象。

- 状态模式：允许对象在其内部状态改变时改变其行为。

4. J2EE模式：- MVC模式：将应用程序划分为三个核心组件：模型、视图和控制器。

- 业务代表模式：将对业务对象的访问和业务逻辑从表示层分离出来。

- 数据访问对象模式：用于将业务逻辑和数据访问逻辑分离。

- 前端控制器模式：通过一个单一的入口点来处理应用程序的所有请求。

- 传输对象模式：用于在客户端和服务器之间传输数据。

5. 并发模式：- 线程池模式：创建一组预先初始化的线程对象来处理任务。

11、享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是 区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互 独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象，而应当使用一个 工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。
14、命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模 式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是 怎么被执行的。系统支持命令的撤消。
浅析23种软件设计模式
1、工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。
2、建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。
9、装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。
10、门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。

面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。

在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。

本文将对23种常见的设计模式进行详解。

一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。

在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。

简单工厂模式适合于对象创建过程较为简单的情况。

2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。

工厂方法模式适合于对象创建过程较为复杂的情况。

它可以为工厂类添加新的产品类型，而不会影响原有的代码。

3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。

在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。

4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。

在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。

5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。

在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。

原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。

二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。

在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。

7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。

23种设计模式代码设计模式是软件工程中常用的解决问题的方法论，它们提供了一套通用的解决方案，帮助开发人员设计出可复用、可维护和可扩展的代码。

本文将介绍23种常见的设计模式，分别是：1. 单例模式：确保一个类只有一个实例，并提供全局访问点。

2. 简单工厂模式：通过一个工厂类创建不同类型的对象，而无需直接实例化对象。

3. 工厂方法模式：定义一个创建对象的接口，由子类决定实例化哪个类。

4. 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体类。

5. 建造者模式：将一个复杂对象的构建与其表示分离，使同样的构建过程可以创建不同的表示。

6. 原型模式：通过复制现有对象来创建新对象，而无需知道具体的创建过程。

7. 适配器模式：将一个类的接口转换为客户端所期望的另一个接口。

8. 桥接模式：将抽象部分与实现部分分离，使它们可以独立变化。

9. 组合模式：将对象组合成树形结构以表示“整体-部分”的层次结构，使客户端对单个对象和组合对象的使用具有一致性。

10. 装饰器模式：动态地给一个对象添加额外的职责，同时又不改变其结构。

11. 外观模式：为子系统中的一组接口提供一个统一的接口，用来简化客户端的使用。

12. 享元模式：通过共享对象来减少内存使用，提高性能。

13. 代理模式：为其他对象提供一种代理以控制对这个对象的访问。

14. 责任链模式：将多个对象组成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

15. 命令模式：将一个请求封装成一个对象，从而使你可以用不同的请求对客户端进行参数化。

16. 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

17. 迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

18. 中介者模式：用一个中介对象来封装一系列对象之间的交互，使得各对象之间不需要显式地相互引用。

Java开发中的23种设计模式通常，一个设计模式描述了一个被证实可行的方案。

这些方案非常普遍，是具有完整定义的最常用的模式。

一般模式有4个基本要素：模式名称(pattern name)、问题(problem)、解决方案(solution)、效果(consequences)。

常见的Java设计模式有以下23种：1、抽象工厂模式(Abstract Factory)：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

2、适配器模式(Adapter)：将一个类的接口转换成客户希望的另外一个接口。

适配器模式使得原本由于接口不兼容而不能一起工作的类可以一起工作。

3、桥梁模式(Bridge)：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

4、建造模式(Builder)：将一个复杂对象的构建与它的表示分离，使同样的构建过程可以创建不同的表示。

5、责任链模式(Chain of Responsibility)：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。

将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。

6、命令模式(Command)：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化;对请求排队或记录请求日志，以及支持可取消的操作。

7、合成模式(Composite)：将对象组合成树形结构以表示“部分-整体”的层次结构。

它使得客户对单个对象和复合对象的使用具有一致性。

8、装饰模式(Decorator)：动态地给一个对象添加一些额外的职责。

就扩展功能而言，它能生成子类的方式更为灵活。

9、门面模式(Facade)：为子系统中的一组接口提供一个一致的界面，门面模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

10、工厂方法(Factory Method)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。

Factory Method 使一个类的实例化延迟到其子类。

23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。

这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。

目前，常用的设计模式有23种。

下面，我们来详细介绍一下这23种设计模式。

1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。

在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。

2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。

它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。

3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。

它可以生成一系列相关或相互依赖的对象实例。

具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。

4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。

它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。

5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。

一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。

6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。

具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。

7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。

具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。

8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。

23种设计模式的经典运用介绍设计模式是解决软件设计中常见问题的可重复使用的解决方案。

本文将介绍23种经典的设计模式，并给出它们在实际开发中的应用示例。

通过学习这些设计模式，您将增加对软件设计的理解，并能够更好地解决问题。

创建型设计模式1.工厂方法模式（F a c t o r y M e t h o d）工厂方法模式通过定义一个创建对象的接口，但由子类决定实例化具体类。

这种方法可以延迟实例化过程，具有更高的灵活性和可扩展性。

应用场景：-在一个系统中，希望客户端与具体类的实例化解耦。

-希望通过增加具体类的扩展来增加系统的灵活性。

2.抽象工厂模式（A b s t r a c t F a c t o r y）抽象工厂模式提供一个接口，用于创建相关或依赖对象组。

这种模式将对象的实例化推迟到子类中，从而实现了解耦。

应用场景：-当一个系统独立于其产品的创建、组合和表示时。

-当需要一个系列的相互依赖的对象而无需指定其具体类时。

3.单例模式（S i n gl e t o n）单例模式确保一个类只有一个实例，并提供一个全局访问点。

这种模式常用于控制对资源的访问，例如数据库连接或日志文件。

应用场景：-当需要一个类的唯一实例，并且该实例需要被多个客户端共享时。

-当需要限制系统中特定类的实例数量时。

4.原型模式（P r o to t y p e）原型模式通过复制现有对象来创建新对象。

这种模式对于创建需要消耗大量资源的对象非常有用，可以通过克隆现有对象来提高性能。

应用场景：-当一个系统的某些对象的创建比较昂贵时。

-当需要避免构造函数调用，而直接通过复制现有对象来创建新对象时。

5.建造者模式（B ui l d e r）建造者模式将一个复杂对象的构建过程与其表现分离，使得相同的构建过程可以创建不同的表现。

应用场景：-当想要构建一些复杂对象时，如生成器。

-当需要创建对象的过程具有多个步骤，并且每个步骤都可以按需选择或省略时。

结构型设计模式6.适配器模式（A da p t e r）适配器模式将一个类的接口转换为客户端所期望的另一个接口。

六大设计原则和23种设计模式
设计原则是设计模式的基础，六大设计原则是SOLID原则和DRY原则。

SOLID是单一职责原则（Single Responsibility Principle，SRP）、开闭原则（Open Closed Principle，OCP）、里氏替换原则（Liskov Substitution Principle，LSP）、接口隔离原则（Interface Segregation Principle，ISP）和依赖反转原则（Dependency Inversion Principle，DIP）。

DRY原则是不要重复自己（Don't Repeat Yourself）。

设计模式是软件设计中常用的解决问题的模式，常见的23种设计模式包括：
1. 创建型模式，工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式。

2. 结构型模式，适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式。

3. 行为型模式，责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模
式、模板方法模式、访问者模式。

这些设计原则和设计模式在软件开发中起着重要的作用。

设计原则有助于编写具有良好结构和可维护性的代码，而设计模式则提供了解决特定问题的经过验证的解决方案。

通过遵循这些原则和模式，开发人员可以编写出高质量、可扩展和易于维护的软件系统。

同时，这些原则和模式也有助于促进团队之间的沟通和协作，使得软件开发过程更加高效和可靠。

软件开发的23种设计模式 ⼆⼗三种设计模式1.单例模式（Singleton Pattern）定义：Ensure a class has only one instance, and provide a global point of access to it.（确保某⼀个类只有⼀个实例，⽽且⾃⾏实例化并向整个系统提供这个实例。

）通⽤代码：（是线程安全的）public class Singleton {private static final Singleton singleton = new Singleton();//限制产⽣多个对象private Singleton(){}//通过该⽅法获得实例对象public static Singleton getSingleton(){return singleton;}//类中其他⽅法，尽量是staticpublic static void doSomething(){}}使⽤场景：●要求⽣成唯⼀序列号的环境；●在整个项⽬中需要⼀个共享访问点或共享数据，例如⼀个Web页⾯上的计数器，可以不⽤把每次刷新都记录到数据库中，使⽤单例模式保持计数器的值，并确保是线程安全的；●创建⼀个对象需要消耗的资源过多，如要访问IO和数据库等资源；●需要定义⼤量的静态常量和静态⽅法（如⼯具类）的环境，可以采⽤单例模式（当然，也可以直接声明为static的⽅式）。

线程不安全实例：public class Singleton {private static Singleton singleton = null;//限制产⽣多个对象private Singleton(){}//通过该⽅法获得实例对象public static Singleton getSingleton(){if(singleton == null){singleton = new Singleton();}return singleton;}}解决办法：在getSingleton⽅法前加synchronized关键字，也可以在getSingleton⽅法内增加synchronized来实现。

合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
9、装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，
是继承关系的一个替代方案，提供比继承更多的灵活性。
动态给一个对象增加功能，这些功能可以再动态的撤消。
增加由一些基本功能的排列组合而产生的非常大量的功能。
享元模式以共享的方式高效的支持大量的细粒度对象。
享元模式能做到共享的关键是区分内蕴状态和外蕴状态。
内蕴状态存储在享元内部，不会随环境的改变而有所不同。
外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。
将可以共享的状态和不可以共享的状态从常规类中区分开来，
将不可以共享的状态从类里剔除出去。
当使用访问者模式时，要将尽可能多的对象浏览逻辑放在访问者类中，而不是放到它的子类中。
访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。
每一个命令对象都有一个解释方法，代表对命令对象的解释。
命令对象的等级结构中的对象的任何排列组合都是一个语言。
16、迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。
多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。
迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。
1、工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。
2、建造模式：将产品的内部表象和产品的生成过程分割开来，
从而使一个建造过程生成具有不同的内部表象的产品对象。

1.对设计模式了解少？项目中是否有运用到？对于23种设计模式都有学习过最少超过两三次吧，主要是学习到了一些设计思想，当通过对一些框架低层的了解，比如spring 中的AOP就用到了很多代理模式，通过代理一个对像，来对我们的方法进行控制，代理后，用到了装饰器模式（项目中操作记录日志，封装对像），装饰我们的目标对象，对我们的方法前后进后不同的操作，比如开启事务，日志处理、提交、回滚、结果返回等操作。

（1）比如java的io体系，可以一层包装一层，外面的一层，都会对里面的一层进行功能的增强。

（2）还有就是spring的aop，aop这块可以基于动态代理的理念，装饰我们的目标对象，然后加入事务控制，日志打印之类的功能。

当然这一串的操作不可能在一个方法中处理，就用到了责任连模式，通过链式调用，按不同的顺执行。

在我们项目中，比如导出功能，用到了模板设计模式，以及价格计算用到了策略模式加工厂模式，计算以责任连模式进行对不同价格的计算或项目中对8种税的计算流程，根据不同的类型计算得到不同的对像，执行不同的计算逻辑，也用到了模板设计模式加工厂模式，不管你算什么价，最终这个价都不能低于地板价都需要对地板价进行校验，这样，地板价校验都是公共的抽成模板处理方式，每个特殊的算价走对应的抽像方法执行算价。

项目中的采购入库及退货入库，都会进行库存数据的修改，一些公用的比如对商品的更新、数量加减这一顺序基本一样，可以抽成模板设计、然后不同的逻辑对应的类去执行这就是命令模式，在把这些逻辑封装在一个工厂里面，就成了工厂模式。

策略模式跟命令模式的区别？看起来一样的，但是用处不一样。

命令是可以发送出去，然后可以经过一些队列的流转，比如先把命令发送到MQ，接着再处理。

策略是说选择了一组策略，立即就要执行的，不会经过其他别的什么处理。

而且策略逻辑基本就是用在复杂的if else代码中的命令模式，可以用在更多别的场景中思想是不一样的，也许实现上，接口、实现类、工厂来做的，适合的场景是不一样的状态模式状态模式里，非常重要的一点就是将状态之间流转的逻辑，封装在Context类里面。

浅析23种软件设计模式软件设计模式是解决特定问题的一种经过验证的解决方案。

它们是开发者在软件设计过程中基于经验总结出来的最佳实践。

《设计模式》一书中总结了23种常见的软件设计模式，本文将对这23种模式进行浅析。

一、创建型模式1. 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。

常用于线程池、数据库连接等需要全局唯一实例的场景。

2. 工厂模式（Factory Pattern）：通过工厂类创建对象，将对象的创建与使用分离，提供了一种统一的接口来创建各种不同类型的对象。

3. 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

4. 建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

5. 原型模式（Prototype Pattern）：通过克隆对象来创建新的对象，避免了通过new关键字创建对象的开销。

二、结构型模式6. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户端所期望的另一个接口，使得原本因接口不兼容而不能在一起工作的类可以一起工作。

7. 桥接模式（Bridge Pattern）：将抽象与实现分离，使它们可以独立变化。

通过组合的方式来实现类之间的关系。

9. 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，同时不改变其原有的结构。

10. 外观模式（Facade Pattern）：为一组复杂的子系统提供一个更高级别的接口，简化对子系统的访问。

11. 享元模式（Flyweight Pattern）：运用共享技术来有效支持大量细粒度对象的复用。

12. 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。

三、行为型模式13. 模板方法模式（Template Method Pattern）：定义一个操作中的算法框架，将一些步骤延迟到子类中实现。

二十三种设计模式1 引言谈到设计模式，绝对应该一起来说说重构。

重构给我们带来了什么？除了作为对遗留代码的改进的方法，另一大意义在于，可以让我们在写程序的时候可以不需事先考虑太多的代码组织问题，当然这其中也包括了应用模式的问题。

尽管大多数开发者都已经养成了写代码前先从设计开始的习惯，但是，这种程度的设计，涉及到到大局、到总体架构、到主要的模块划分我觉得就够了。

换句话说，这时就能写代码了。

这就得益于重构的思想了。

如果没有重构的思想，有希望获得非常高质量的代码，我们就不得不在开始写代码前考虑更多其实并非非常稳定的代码组织及设计模式的应用问题，那开发效率当然就大打折扣了。

在重构和设计模式的合理应用之下，我们可以相对较早的开始写代码，并在功能尽早实现的同时，不断地通过重构和模式来改善我们的代码质量。

所以，下面的章节中，在谈模式的同时，我也会谈谈关于常用的这些模式的重构成本的理解。

重构成本越高意味着，在遇到类似的问题情形的时候，我们更应该提前考虑应用对应的设计模式，而重构成本比较低则说明，类似的情形下，完全可以先怎么方便，怎么快怎么写，哪怕代码不是很优雅也没关系，回头再重构也很容易。

1 创建型1.1 Factory Method思想：Factory Method的主要思想是使一个类的实例化延迟到其子类。

场景：典型的应用场景如：在某个系统开发的较早阶段，有某些类的实例化过程，实例化方式可能还不是很确定，或者实际实例化的对象（可能是需要对象的某个子类中的一个）不确定，或者比较容易变化。

此时，如果直接将实例化过程写在某个函数中，那么一般就是if-else或select-case代码。

如果，候选项的数目较少、类型基本确定，那么这样的if-else还是可以接受的，一旦情形变得复杂、不确定性增加，更甚至包含这个构造过程的函数所在的类包含几个甚至更多类似的函数时，这样的if-else代码就会变得比较不那么容易维护了。

此时，应用本模式，可以将这种复杂情形隔离开，即将这类不确定的对象的实例化过程延迟到子类。

设计模式分为三⼤类23种（单例模式）1) 创建型模式：单例模式、抽象⼯⼚模式、原型模式、建造者模式、⼯⼚模式。

2) 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

3) ⾏为型模式：模版⽅法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)。

单例模式:定义: 所谓类的单例设计模式，就是采取⼀定的⽅法保证在整个的软件系统中，对某个类只能存在⼀个对象实例，并且该类只提供⼀个取得其对象实例的⽅法(静态⽅法)单例模式有⼋种⽅式：1) 饿汉式(静态常量)2) 饿汉式（静态代码块）3) 懒汉式(线程不安全)4) 懒汉式(线程安全，同步⽅法)5) 懒汉式(线程安全，同步代码块)6) 双重检查7) 静态内部类8) 枚举1. 饿汉式（静态常量)步骤如下：1) 构造器私有化 (防⽌new )2) 类的内部创建对象3) 向外暴露⼀个静态的公共⽅法。

getInstance4) 代码实现优缺点说明：1) 优点：这种写法⽐较简单，就是在类装载的时候就完成实例化。

避免了线程同步问题。

2) 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。

如果从始⾄终从未使⽤过这个实例，则会造成内存的浪费3) 这种⽅式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中⼤多数都是调⽤getInstance⽅法，但是导致类装载的原因有很多种，因此不能确定有其他的⽅式（或者其他的静态⽅法）导致类装载，这时候初始化instance就没有达到lazy loading的效果4) 结论：这种单例模式可⽤，可能造成内存浪费 2 饿汉式（静态代码块）应⽤实例优缺点说明：1) 这种⽅式和上⾯的⽅式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执⾏静态代码块中的代码，初始化类的实例。

23种设计模式详解原⽂链接:/zhangerqing⼀、设计模式的分类总体来说设计模式分为三⼤类：创建型模式，共五种：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

⾏为型模式，共⼗⼀种：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类：并发型模式和线程池模式。

⽤⼀个图⽚来整体描述⼀下：⼆、设计模式的六⼤原则总原则：开闭原则（Open Close Principle）开闭原则就是说对扩展开放，对修改关闭。

在程序需要进⾏拓展的时候，不能去修改原有的代码，⽽是要扩展原有代码，实现⼀个热插拔的效果。

所以⼀句话概括就是：为了使程序的扩展性好，易于维护和升级。

想要达到这样的效果，我们需要使⽤接⼝和抽象类等，后⾯的具体设计中我们会提到这点。

1、单⼀职责原则不要存在多于⼀个导致类变更的原因，也就是说每个类应该实现单⼀的职责，如若不然，就应该把类拆分。

2、⾥⽒替换原则（Liskov Substitution Principle）⾥⽒替换原则中，⼦类对⽗类的⽅法尽量不要重写和重载。

因为⽗类代表了定义好的结构，通过这个规范的接⼝与外界交互，⼦类不应该随便破坏它。

3、依赖倒置原则（Dependence Inversion Principle）这个是开闭原则的基础，具体内容：⾯向接⼝编程，依赖于抽象⽽不依赖于具体。

写代码时⽤到具体类时，不与具体类交互，⽽与具体类的上层接⼝交互。

4、接⼝隔离原则（Interface Segregation Principle）这个原则的意思是：每个接⼝中不存在⼦类⽤不到却必须实现的⽅法，如果不然，就要将接⼝拆分。

使⽤多个隔离的接⼝，⽐使⽤单个接⼝（多个接⼝⽅法集合到⼀个的接⼝）要好。

5、迪⽶特法则（最少知道原则）（Demeter Principle）就是说：⼀个类对⾃⼰依赖的类知道的越少越好。