# Design-Patterns

**Repository Path**: leeJax/design-patterns

## Basic Information

- **Project Name**: Design-Patterns
- **Description**: 二十三种设计模式学习仓库
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-08-17
- **Last Updated**: 2024-08-29

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# design-patterns 设计模式使用案例
# 一、设计模式介绍

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。



## 二、设计模式的分类

| 创建型模式<br />Creating pattern | 共五种                                     | 案例                                                         |
| -------------------------------- | :----------------------------------------- | ------------------------------------------------------------ |
|                                  | 工厂方法模式<br />Factory Method Pattern   | Spring使用工厂模式通过Bean Factory、Application Context创建Bean对象 |
|                                  | 抽象工厂模式<br />Abstract Factory Pattern |                                                              |
|                                  | 单例模式<br />Singleton Pattern            | Spring种的Bean对象默认是单例模式                             |
|                                  | 建造者模式<br />Builder Pattern            | String Buffer中使用了建造者模式                              |
|                                  | 原型模式<br />Prototype Pattern            |                                                              |

| 结构型模式<br />Structural pattern | 共七种                            | 案例                                                                                                                    |
| ---------------------------------- | --------------------------------- |-----------------------------------------------------------------------------------------------------------------------|
|                                    | 适配器模式<br />Adapter Pattern   | Spring AOP中的增强或通知使用了适配器模式。<br />Spring中MVC中也是用到了适配器Handler Adapter适配Controller                                        |
|                                    | 装饰器模式<br />Decorator Pattern | Spring 中配置 DataSource 的时候，DataSource 可能是不同的数据库和数据源，项目需要连接多个数据库，这种模式让我们可以根据客户需求切换不同的数据源。Java中字符字节缓冲的输入输出流也是基于装饰器模式实现的。 |
|                                    | 代理模式<br />Proxy Pattern       | Spring AOP（面向切面编程）广泛使用代理模式来实现横切关注点，如事务管理、日志记录等。这可以是通过动态代理实现的，Spring AOP可以使用JDK动态代理（基于接口）或CGLIB代理（基于类）。                |
|                                    | 外观模式<br />Facade Pattern      |                                                                                                                       |
|                                    | 桥接模式<br />Bridge Pattern      |                                                                                                                       |
|                                    | 组合模式<br />Composite Pattern   |                                                                                                                       |
|                                    | 享元模式<br />Flyweight Pattern   |                                                                                                                       |

| 行为型模式<br />Behavioral patterns | 共十一种                                        | 案例                                                         |
| ----------------------------------- | ----------------------------------------------- | ------------------------------------------------------------ |
|                                     | 模板方法模式<br />Template Method Pattern       | Spring中的许多模板，如`JdbcTemplate`、`RestTemplate`、`RabbitTemplate`等，都使用了模板方法模式。这些模板抽象了一些常用的操作，允许用户通过回调函数自定义这些操作的特定部分，而常规的执行流程则被模板方法所管理。 |
|                                     | 观察者模式<br />Observer Pattern                | Spring事件驱动模型就是观察者模式很经典的一个应用。           |
|                                     | 策略模式<br />Strategy Pattern                  | Spring允许通过配置来选择具体的策略类。例如，在Spring Security中，可以通过配置来选择不同的认证策略。这种模式提高了灵活性，使得组件可以在不同的策略实现间切换。 |
|                                     | 迭代器模式<br />Iterator Pattern                |                                                              |
|                                     | 命令模式<br />Command Pattern                   |                                                              |
|                                     | 备忘录模式<br />Memento Pattern                 |                                                              |
|                                     | 状态模式<br />State Pattern                     |                                                              |
|                                     | 访问者模式<br />Visitor Pattern                 |                                                              |
|                                     | 中介者模式<br />Mediator Pattern                |                                                              |
|                                     | 解释器模式<br />Interpreter Pattern             |                                                              |
|                                     | 责任链模式<br />Chain of Responsibility Pattern |                                                              |



# 三、设计模式的六大原则
* 单一职责原则（Single Responsibility Principle，SRP）：
  类应该只有一个单一的职责，即一个类应该有且只有一个改变的理由。
这意味着一个类应该只负责一个特定的功能或任务，而不是多个不相关的功能。这样做可以提高类的内聚性，并使得类更容易理解、修改和测试。

* 开放-封闭原则（Open/Closed Principle，OCP）：
  软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。
这意味着在不修改现有代码的情况下，应该能够通过添加新的代码来扩展系统的功能。这样做可以使得系统更加稳定，减少修改现有代码可能带来的风险。

* 里氏替换原则（Liskov Substitution Principle，LSP）：
  子类型必须能够替换其基类型。换句话说，任何可以接受基类型的地方都可以接受子类型，而且不会引发意外的行为。
这样做可以保持系统的一致性和可靠性，并且确保使用继承时不会破坏代码的正确性。

* 接口隔离原则（Interface Segregation Principle，ISP）：
  客户端不应该被迫依赖于其不使用的接口。这意味着应该将接口设计成小而专注的接口，而不是大而臃肿的接口。
这样做可以降低耦合性，并且使得系统更加灵活和易于维护。

* 依赖倒置原则（Dependency Inversion Principle，DIP）：
  高层模块不应该依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。
这样做可以降低模块之间的耦合度，并且使得系统更易于扩展和修改。

* 迪米特法则（Law Of Demter，LOD）
  不该有直接依赖关系的类之间，不要有依赖；有依赖关系的类之间，尽量只依赖必要的接口。

这些原则是由罗伯特·马丁（Robert C. Martin）等人在面向对象设计中提出的，它们提供了一套指导原则，帮助设计出高质量、可维护和可扩展的面向对象系统。


# 四、设计模式详解

### 1. 创建型模式详解

#### 1.1 单例模式

描述：确保某个类只有一个实例对象，而且自行实例化并向整个系统提供这个实例

​	<img src=".\assets\SingletonClass.jpg"  />

分类：懒汉式、饿汉式、枚举式；

关键代码：

- 构造函数应该是私有的

使用场景：

- 要求生产唯一序列号。
- WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
- 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

优缺点：

优点：

- 节约内存；
- 减少性能开销；
- 避免对资源的多重占用；
- 优化和共享资源访问。

缺点：

- 一般无接口，扩展性差；
- 不易于测试；
- 和职责单一原则有冲突。

#### 1.2 工厂模式

分类：简单工厂、抽象工厂、工厂方法模式



# 五、文章参考

[设计模式之——单例 Singleton_instance 空指针吗-CSDN博客](https://blog.csdn.net/qq_40041259/article/details/118570086)

[23种设计模式图例详解 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/581346498)

[jalenFish/design-patterns: 设计模式使用案例 (github.com)](https://github.com/jalenFish/design-patterns)