作者：yangwq
博客：https://yangwq.cn
# 前言
软件设计是一门关注长期变化的学问，日常开发中需求不断变化，那我们该怎么编写出可以支撑长期变化的代码呢？大多数人都认同的解决方案是利用设计模式，这里就有一个问题：怎么融汇贯通的将设计模式应用到实际项目中呢？这就是我们本篇文章的主题：设计原则。
个人认为设计原则是软件设计的基石之一，所有语言都可以利用设计原则开发出可扩展性、可维护性、可读性高的项目，学好设计原则，就等于我们拥有了指南针，不会迷失在各个设计模式的场景中。
郑晔老师的《软件设计之美》指出：设计模式是在特定问题上应用设计原则的解决方案。我们可以类比设计原则是心法，设计模式是招式，两者相辅相成，虽然脱离对方都能使用，但是不能融会贯通。
本章主要涉及的设计原则有：
1. SOLID原则
2. KISS原则、YAGNI原则、DRY原则
接下来对各个原则进行详细说明，有错误或语义不明确的地方欢迎大家指正。
## 一、SOLID原则
1. S(Single Responsibility Principle，SRP)：单一职责原则；
2. O(Open–closed principle，OCP)：开放-关闭原则；
3. L(Liskov Substitution Principle，LSP)：里氏替换原则；
4. I(Interface segregation principle，LSP)：接口隔离原则；
5. D(Dependency inversion principle, DIP)：依赖倒置原则。
### 1、单一职责原则（Single Responsibility Principle，SRP）
本原则的定义经历过一些变化。以前的定义是：**一个模块（模块、类、接口）仅有一个引起变化的原因**，后面升级为： **一个模块（模块、类、接口）对一类且仅对一类行为者负责**。
#### 怎么理解一个模块（模块、类、接口）仅有一个引起变化的原因？
我们重点关注的是“变化”一词。下面我们用代码来进行示例：
背景：设计一个订单接口，能做到创建、编辑订单和会员的赠送及过期。
```
public interface OrderService {
int createOrder();
int updateOrder();
// 下单完成后分配vip给用户
int distributionVIP();
// vip过期
int expireVIP();
}
```
OrderService包含对订单、VIP的操作，不管是订单业务或VIP业务的改变，我们都需要改变这个类。这样有什么问题？有多个引起OrderService变化的原因导致这个类不能稳定下来，对VIP代码的改动有可能导致原本运行正常的订单功能发生故障，没有做到高内聚、低耦合。
**一个模块最理想的状态是不改变，其次是少改变。**我们可以将对VIP的处理单独放到一个类：
```
public interface OrderService {
int createOrder();
int updateOrder();
}
public interface VIPService{
// 下单完成后分配vip给用户
int distributionVIP();
// vip过期
int expireVIP();
}
```
这样我们对订单或VIP的改动都不会影响到对方正常的功能，极大程度上减少了问题发生的概率。
#### 该怎么理解一个模块（模块、类、接口）对一类且仅对一类行为者负责？
这个定义比上面的定义多加了一个内容：变化的来源。
上面的例子可能区分不出来变化的来源，像vip这类功能一般都是订单系统体系内的。从下面这个例子说明:
背景：在上面例子的背景下，增加对地址信息的维护。
```java
public interface OrderService {
int createOrder();
int updateOrder();
// 订单地址的修改
int updateOrderAddress();
}
```
OrderService中对订单地址的修改，可能是订单负责人提出的需求，也可能是物流部门提出来：需要共用订单地址。
这里就需要区分两种业务场景。
如果是订单负责人提出的，那上面这个设计就是合理的，因为我们维护的是订单附属内容，而且变化的来源只有订单系统。
但如果是物流部门提出共用订单地址，那就需要将更改地址的接口抽离出来，因为这个需求变化的来源有两拨人：可能是订单，也可能是物流部门。改动如下：
```
public interface OrderService {
int createOrder();
int editOrder();
}
public interface AddressService {
// 订单修改地址
int updateAddressByOrder();
// 物流修改地址
int updateAddressByLogistics();
}
```
为了职责明确我们有对接口的命名进行重构，这样更容易被使用者接受，通过将地址的变化隔离在AddressService，后续维护地址只用修改这个类，提升了代码的可读性和可维护性。
### 2、开放-关闭原则（Open–closed principle，OCP)
定义：**对扩展开放，对修改关闭。**简而言之: 不修改已有代码（尽可能不更改已有代码的情况下），新需求用新代码实现。
如何做到？**分离关注点，找出共性构建模型/抽象，设计扩展点。**
代码示例：
背景：设计一套通用的文件上传下载功能，需要支持本地盘和阿里云OSS。一开始的设计可能是这样的：
```
public void FileUtil {
void upload(UploadParam uploadParam) {
if(type == 1){
// 上传文件到本地盘
}else if (type == 2){
// 上传文件到阿里云OSS
}
}
void download(DownloadParam downloadParam){
if(type == 1){
// 从本地盘下载文件
}else if (type == 2){
// 从阿里云OSS下载文件
}
}
}
```
上面的设计有什么问题？首先第一点UploadParam 和 DownloadParam 参数职责过重，不同方式的上传、下载参数混合在一个类，可读性不高，而且加入其他存储方式的时候可能只加了上传，漏掉了下载的改动，容易产生问题。
那我们先通过分离关注点：不同存储方式都需要提供对应的上传、下载操作。于是我们可以将动作拆分成上传、下载，参数需要按不同场景选用不同的对象。改动后如下：
```java
// 所有参数的父类接口
public interface BaseFileParam{
}
// 统一的上传下载接口类
public interface FileService<U,D>{
/**
* 上传
*/
void upload();
/**
* 下载
*/
void download();
}
// 抽象实现，将参数作为属性放到类中，子类可以使用
public abstract class AbstractFileService<U,D> implements FileService<U,D>{
protected U uploadParam;
protected D downloadParam;
public AbstractFileService() {
}
protected FileService<U, D> buildUploadParam(U uploadParam){
this.uploadParam = uploadParam;
return this;
}
protected FileService<U, D> buildDownloadParam(D downloadParam){
this.downloadParam = downloadParam;
return this;
}
protected U getUploadParam() {
return uploadParam;
}
protected D getDownloadParam() {
return downloadParam;
}
}
// OSS实现
public class OssFileServe extends AbstractFileService<OssFileServe.OssUpload, OssFileServe.OssDownload> {
/**
* 上传到阿里云
*/
@Override
public void upload() {
}
/**
* 从阿里云下载文件
*/
@Override
public void download() {
}
public class OssUpload implements BaseFileParam{
}
public class OssDownload implements BaseFileParam{
}
}
// 本地盘实现
public class LocalFileService extends AbstractFileService<LocalFileService.LocalFileUploadParams, LocalFileService.LocalFileDownloadParams> {
/**
* 上传到本地磁盘
*/
@Override
public void upload() {
}
@Override
public void download() {
}
public static class LocalFileUploadParams implements BaseFileParam {
}
public static class LocalFileDownloadParams implements BaseFileParam {
}
}
// 使用入口
public class FileServiceDelegate {
public FileService<? extends BaseFileParam,? extends BaseFileParam> getFileService(String type, BaseFileParam upload, BaseFileParam download){
if("local".equals(type)){
return new LocalFileService().buildUploadParam(upload != null ? (LocalFileService.LocalFileUploadParams) upload : null)
.buildDownloadParam(download != null ? (LocalFileService.LocalFileDownloadParams) download : null);
}else if ("oss".equals(type)) {
return new OssFileServe().buildUploadParam(upload != null ? (OssFileServe.OssUpload) upload : null)
.buildDownloadParam(download != null ? (OssFileServe.OssDownload) download : null);
}else {
throw new RuntimeException("未知的上传类型");
}
}
public void upload(String type, BaseFileParam baseFileParam){
getFileService(type,baseFileParam, null).upload();
}
public void download(String type, BaseFileParam baseFileParam){
getFileService(type,null, baseFileParam).download();
}
}
```
以上是比较粗糙的方案，只做案例演示。后续如果需要加入亚马逊S3存储，我们需要改动的点：
```java
// 加入S3实现
public class S3FileService extends AbstractFileService<S3FileService.S3UploadParams, S3FileService.S3DownloadParams> {
/**
* 上传到S3
*/
@Override
public void upload() {
}
/**
* 从S3下载文件
*/
@Override
public void download() {
}
public class S3UploadParams implements BaseFileParam {
}
public class S3DownloadParams implements BaseFileParam {
}
}
// 修改入口类
public class FileServiceDelegate {
public FileService<? extends BaseFileParam,? extends BaseFileParam> getFileService(String type, BaseFileParam upload, BaseFileParam download){
if("local".equals(type)){
return new LocalFileService().buildUploadParam(upload != null ? (LocalFileService.LocalFileUploadParams) upload : null)
.buildDownloadParam(download != null ? (LocalFileService.LocalFileDownloadParams) download : null);
}else if ("oss".equals(type)) {
return new OssFileServe().buildUploadParam(upload != null ? (OssFileServe.OssUpload) upload : null)
.buildDownloadParam(download != null ? (OssFileServe.OssDownload) download : null);
}
// 加入S3处理
else if("s3".equals(type)){
return new S3FileService().buildDownloadParam(upload != null ? (S3FileService.S3DownloadParams) upload : null)
.buildDownloadParam(download != null ? (S3FileService.S3DownloadParams) download : null);
}else {
throw new RuntimeException("未知的上传类型");
}
}
public void upload(String type, BaseFileParam baseFileParam){
getFileService(type,baseFileParam, null).upload();
}
public void download(String type, BaseFileParam baseFileParam){
getFileService(type,null, baseFileParam).download();
}
}
```
上面我们修改了两个地方，一个是加入了S3的实现类，另一个是更改入口类加入了S3的处理，这就符合新功能用新代码实现，但可能有人说改动了入口类，其实只要改动的代码没有影响到原有的功能，小幅度的修改是可以接受的。
### 3、里氏替换原则(Liskov Substitution Principle，LSP)
定义：**子类必须能够替换其父类，并保证原来程序的逻辑行为不变及正确性不被破坏。**
如何实现？**站在父类的角度设计接口，子类需要满足基于行为的IS-A关系**，更具体的来讲：**子类遵守父类的行为约定**，约定包含：功能主旨，异常，输入，输出，注释等。
违背功能主旨：
```java
public interface OrderService {
Order updateById(Order order);
}
public class OrderServiceImpl {
public Order findById(Order order) {
// 实际上是通过订单编号进行更新的
return orderMapper.updateBySn(order);
}
}
```
父类的定义原本是按订单ID更新，在子类实现中却变成了按订单编号更新，这个方法就违背了功能主旨。会出现什么问题？使用者会发现执行结果与自己期望的不一致，而且有隐藏BUG：一开始传了订单编号，后面订单编号没了，这个方法就报错了，更严重一点，如果是使用mybatis的xml判断了编号不为空进行条件拼接，此时由于编号为空就没有了条件过滤然后更改了整个表的数据。
异常：父类规定接口不能抛出异常，而子类抛出了异常。
输入：父类输入整数类型就行，子类要求正整数才能执行。
输出：父类执行方法要求有异常时返回null,子类重写后直接将异常抛出来了。
关于里氏替换原则，我们就只要记住一点：**从父类角度设计行为一致的子类**。
### 4、接口隔离原则（Interface segregation principle，LSP）
定义：**不应强迫使用者依赖于它们不用的方法。** 通俗的理解：**对接口设计应用单一职责，根据调用者设计不同的接口。**
示例：
```java
public class UserController{
int addUser(User user);
int updateUser(User user);
int deleteUser(int id);
// 锁定用户
int lockUser(User user);
}
```
上面是一个对订单crud的接口，现在有其他项目组的同事需要锁定用户的功能，然后你可能一拍脑袋直接把上面整个接口UserController扔给他（或者直接扔一个swagger文档），这样同事会很懵逼：我只要锁定用户就行，为什么还要这么多接口？
这样做暴露的问题:
1. 调用者关注了不需要的接口；
2. 多余的接口暴露出来容易问题，每次更改接口你也不知道会不会影响其他模块的功能。
所以我们尽量要最小化暴露接口，根据不同的调用者仅提供他们当前需要的接口，提供的公共接口越多越难以维护。
接口隔离原则与单一职责的区别：
1、单一职责要求的的是模块、类、接口的职责单一，
2、接口隔离原则要求的是暴露给使用者的接口尽可能少。
可以这么理解：一个类某个职责有10个接口都暴露给其他模块使用，按单一原则来讲是合理的，但是按接口隔离来讲是不允许的。
### 5、依赖倒置原则(Dependency inversion principle, DIP)
定义：**高层模块不直接依赖底层模块，依赖于抽象，底层模块不依赖于细节，细节依赖于抽象。**
这一点如果我们是使用spring开发的项目就已经用到了。spring的依赖注入就是依赖倒置原则的体现。
```java
// 以前没有使用spring的时候，我们是这样初始化service的
// 存在的问题：1、如果需要替换成一个新的实现类，改动点太多，简单点说就是高耦合；
// 2、使用者不需要关注具体的实现类，只关注有哪些接口能用就行；
// 3、对象实例不能共享，每个使用的地方都是新建的实例，实际上用同一个实例就行了。
UserService userService = new UserServiceImpl();
```
通过spring的IOC容器，我们只要定义好依赖关系，IOC容器就可以帮我们管理对应的实例，起到了松耦合的作用。
还有其他的使用场景吗？
有，举例：
```java
public class UserServiceImpl {
private KafkaProducer producer;
public int addUser(User user){
// 创建用户
// 发送消息到消息队列，由感兴趣的系统订阅并消费。
producer.send(msg);
}
}
```
这里初看没有什么问题，但如果后续我们更换了kafka为rabbitmq，那上面使用到kafka的类都需要重新调整。
我们利用"高层模块不直接依赖底层模块，依赖于抽象"对上面代码进行调整，让我们的实现类UserServiceImpl不直接依赖KafkaProducer，而是依赖接口类MessageSender。
```java
public class UserServiceImpl {
private MessageSender sender;
public int addUser(User user){
// 创建用户
// 发送消息到消息队列，由感兴趣的系统订阅并消费。
sender.send(msg);
}
}
public interface MessageSender {
void send(Map<String,String> params);
}
// kafka 实现
public class KafkaProducer implements MessageSender{
public void send(Map<String,String> params) {
}
}
```
这样一来，就算我们切换成RabbitMq，改动的点无非是对MessageSender实现的更改，而有了spring的IOC容器，我们很容易就可以更改实例实现。
```java
// rabbitmq 实现
public class RabbitmqProducer implements MessageSender{
public void send(Map<String,String> params) {
}
}
```
控制反转：控制反转是一个比较笼统的设计思想，并不是一种具体的实现方法，一般用来指导框架层面的设计。这里的控制指的是程序执行流程的控制，反转是从程序员变为框架控制。
依赖注入：一种具体的编码技巧，不直接使用new创建对象，而是在外部将对象创建好后通过构造函数、方法、方法参数传递给类使用。
## 二、KISS原则、YAGNI原则、DRY原则
这三个原则是偏理论性的概念，主要目的是指导我们学习设计原则后不要过度设计。
## KISS（Keep it simple, stupid）原则
定义： **尽量保持简单**。保持简单可以让我们的代码可读性更高，维护起来也更容易。但这是一个比较抽象的概念：对于“简单”的定义没有统一规范，每个人的理解都不一致，这个时候就需要code review，同事有很多疑问的代码就要考虑是不是代码不够“简单”。
实践过程中怎么编写满足KISS原则的代码？以下几点供大家参考：
1. 不要重复造轮子，复用已有的工具；
2. 方法写得越小越好；
3. 不要使用同事可能不懂的技术来实现代码。
## YAGNI（You aren’t gonna need it）原则
定义： **你不会需要它。**我们可以这样理解：**如非必要，勿增功能。**
这一个原则我们可以用在两个方面：需求和代码实现。
对于产品人员提出的需求，按照二八原则，80%的功能是用不上的，所以我们可以不做对用户没有价值的需求。
对于开发人员的代码实现，除非编写的模块以后会频繁变化，这种情况我们可以提前构建扩展点，但如果模块变化很少，我们就不需要做过多的扩展点，保持功能正常运行就行。
KISS原则和YAGNI原则区别：
KISS原则关注的怎么做，YAGNI原则关注的是需不需要做。
## DRY（Don’t repeat yourself）原则：
定义：**不要重复自己**。广泛的认知是不写重复代码，更深入一点的理解是**不要对你的知识和意图进行复制**。
在我看来：解决重复代码是每个程序员都会做的事情，但是重复的代码一定要解决吗？首先要明白解决重复代码的重点是建立抽象，那这个抽象有没有存在的意义？我们应该根据实际的业务场景，如果发现引起该抽象改变的原因超过一个，这说明该抽象没有存在的意义。
例如，我们开发crud接口中常见的VO和Entity：
```java
public class UserEntity {
private String username;
private String name;
private Integer age;
private String password;
}
public class UserVO {
private String username;
private String name;
private Integer age;
// 用户拥有的菜单
private List menuList;
}
```
我们如果按DRY原则将重复的代码合并到一个类：
```java
public class BaseUser{
private String username;
private String name;
private Integer age;
private String phone;
}
public class UserEntity extends BaseUser{
private String password;
}
public class UserVO {
// 用户拥有的菜单
private List menuList;
}
```
改成这样会有什么问题？如果后续UserVO不允许暴露age属性或者需要对手机号加密，这个时候就需要改动BaseUser和UserEntity，对UserVO的维护就会改动到BaseUser和UserEntity，一方面违反了单一职责，另一方面需要对发现所有使用BaseUser、UserEntity、UserVO的地方进行测试，增加了维护成本。
基于以上考虑，我们需要将对UserVO的改动隔离起来：还原成刚开始重复代码的场景。
实行DRY原则的方式:
**三次法则(Rule of Three)**：
1. 第一次先写了一段代码，不考虑复用性；
2. 第二次在另一个地方写了一段相同的代码，可以标记为需清除重复代码，但是暂不处理；
3. 再次在另一个地方写了同样的代码，现在可以考虑解决重复代码了。
# 总结
本篇的宗旨是给大家树立一个观点：设计原则是设计模式的基础，而不是设计模式的附属物。设计模式是在特定问题应用设计原则的解决方案。但是只用设计原则开发软件离目标是有偏差的，所以我们也要借鉴设计模式：熟悉不同场景下设计原则的使用方式，这样才能开发出可扩展性、可维护性、可读性高的软件。
本篇文章如有错误或语义不明确的地方欢迎大家指正。
