知乎盐选 | 6.2 开闭原则的庐山真面目
6.2 开闭原则的庐山真面目
开闭原则的定义已经非常明确地告诉我们：软件实体应该对扩展开放，对修改关闭，其含义是说一个软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化。那什么又是软件实体呢？软件实体包括以下几个部分：
- 项目或软件产品中按照一定的逻辑规则划分的模块。
- 抽象和类。
- 方法。
一个软件产品只要在生命期内，都会发生变化，既然变化是一个既定的事实，我们就应该在设计时尽量适应这些变化，以提高项目的稳定性和灵活性，真正实现「拥抱变化」。开闭原则告诉我们应尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来完成变化，它是为软件实体的未来事件而制定的对现行开发设计进行约束的一个原则。我们举例说明什么是开闭原则，以书店销售书籍为例，其类图如图 6-1 所示。
加载中...
图 6-1 书店售书类图
IBook 定义了数据的三个属性：名称、价格和作者。小说类 NovelBook 是一个具体的实现类，是所有小说书籍的总称，BookStore 指的是书店，IBook 接口如代码清单 6-1 所示。
代码清单 6-1 书籍接口
public interface IBook {
//书籍有名称
public String getName()；
//书籍有售价
public int getPrice()；
//书籍有作者
public String getAuthor()；}
目前书店只出售小说类书籍，小说类如代码清单 6-2 所示。
代码清单 6-2 小说类
public class NovelBook implements IBook {
//书籍名称
private String name；
//书籍的价格
private int price；
//书籍的作者
private String author；
//通过构造函数传递书籍数据
public NovelBook（String \_name,int \_price,String _author）{
this.name = _name；
this.price = _price；
this.author = _author；
}
//获得作者是谁
public String getAuthor() {
return this.author；
}
//书籍叫什么名字
public String getName() {
return this.name；
}
//获得书籍的价格
public int getPrice() {
return this.price；
}}
注意 我们把价格定义为 int 类型并不是错误，在非金融类项目中对货币处理时，一般取 2 位精度，通常的设计方法是在运算过程中扩大 100 倍，在需要展示时再缩小 100 倍，减少精度带来的误差。
书店售书的过程如代码清单 6-3 所示。
代码清单 6-3 书店售书类
public class BookStore {
private final static ArrayList<IBook> bookList = new ArrayList<IBook>()；
//static 静态模块初始化数据，实际项目中一般是由持久层完成
static{
bookList.add(new NovelBook（「天龙八部」，3200，「金庸」）)；
bookList.add(new NovelBook（「巴黎圣母院」，5600，「雨果」）)；
bookList.add(new NovelBook（「悲惨世界」，3500，「雨果」）)；
bookList.add(new NovelBook（「金瓶梅」，4300，「兰陵笑笑生」）)；
}
//模拟书店买书
public static void main（String\[\] args） {
NumberFormat formatter = NumberFormat.getCurrencyInstance()；
formatter.setMaximumFractionDigits(2)；
System.out.println（「-----------书店卖出去的书籍记录如下：-----------」）；
for（IBook book:bookList）{
System.out.println(「书籍名称：」 + book.getName()+「\\t 书籍作者：」 +
book.getAuthor()+「\\t 书籍价格：」+ formatter.format (book.getPrice()/
100.0)+「元」)；
}
}}
在 BookStore 中声明了一个静态模块，实现了数据的初始化，这部分应该是从持久层产生的，由持久层框架进行管理，运行结果如下：
-----------------书店卖出去的书籍记录如下：--------------
书籍名称：天龙八部 书籍作者：金庸 书籍价格：￥25.60 元
书籍名称：巴黎圣母院 书籍作者：雨果 书籍价格：￥50.40 元
书籍名称：悲惨世界 书籍作者：雨果 书籍价格：￥28.00 元
书籍名称：金瓶梅 书籍作者：兰陵笑笑生 书籍价格：￥38.70 元
项目投产了，书籍正常销售出去，书店也赢利了。从 2008 年开始，全球经济开始下滑，对零售业影响比较大，书店为了生存开始打折销售：所有 40 元以上的书籍 9 折销售，其他的 8 折销售。对已经投产的项目来说，这就是一个变化，我们应该如何应对这样一个需求变化？有如下三种方法可以解决这个问题：
● 修改接口
在 IBook 上新增加一个方法 getOffPrice()，专门用于进行打折处理，所有的实现类实现该方法。但是这样修改的后果就是，实现类 NovelBook 要修改，BookStore 中的 main 方法也修改，同时 IBook 作为接口应该是稳定且可靠的，不应该经常发生变化，否则接口作为契约的作用就失去了效能。因此，该方案否定。
● 修改实现类
修改 NovelBook 类中的方法，直接在 getPrice()中实现打折处理，好办法，我相信大家在项目中经常使用的就是这样的办法，通过 class 文件替换的方式可以完成部分业务变化（或是缺陷修复）。该方法在项目有明确的章程（团队内约束）或优良的架构设计时，是一个非常优秀的方法，但是该方法还是有缺陷的。例如采购书籍人员也是要看价格的，由于该方法已经实现了打折处理价格，因此采购人员看到的也是打折后的价格，会因信息不对称而出现决策失误的情况。因此，该方案也不是一个最优的方案。
● 通过扩展实现变化
增加一个子类 OffNovelBook，覆写 getPrice 方法，高层次的模块（也就是 static 静态模块区）通过 OffNovelBook 类产生新的对象，完成业务变化对系统的最小化开发。好办法，修改也少，风险也小，修改后的类图如图 6-2 所示。
加载中...
图 6-2 扩展后的书店售书类图
OffNovelBook 类继承了 NovelBook，并覆写了 getPrice 方法，不修改原有的代码。新增加的子类 OffNovelBook 如代码清单 6-4 所示。
代码清单 6-4 打折销售的小说类
public class OffNovelBook extends NovelBook {
public OffNovelBook（String \_name,int \_price,String _author）{
super（\_name,\_price,_author）；
}
//覆写销售价格
@Override
public int getPrice(){
//原价
int selfPrice = super.getPrice()；
int offPrice=0；
if（selfPrice>4000）{ //原价大于 40 元，则打 9 折
offPrice = selfPrice * 90 /100；
}else{
offPrice = selfPrice * 80 /100；
}
return offPrice；
}}
很简单，仅仅覆写了 getPrice 方法，通过扩展完成了新增加的业务。书店类 BookStore 需要依赖子类，代码稍作修改，如代码清单 6-5 所示。
代码清单 6-5 书店打折销售类
public class BookStore {
private final static ArrayList<IBook> bookList = new ArrayList<IBook>()；
//static 静态模块初始化数据，实际项目中一般是由持久层完成
static{
bookList.add(new OffNovelBook（「天龙八部」，3200，「金庸」）)；
bookList.add(new OffNovelBook（「巴黎圣母院」，5600，「雨果」）)；
bookList.add(new OffNovelBook（「悲惨世界」，3500，「雨果」）)；
bookList.add(new OffNovelBook（「金瓶梅」，4300，「兰陵笑笑生」）)；
}
//模拟书店买书
public static void main（String\[\] args） {
NumberFormat formatter = NumberFormat.getCurrencyInstance()；
formatter.setMaximumFractionDigits(2)；
System.out.println（「-----------书店卖出去的书籍记录如下：-----------」）；
for（IBook book:bookList）{
System.out.println(「书籍名称：」 + book.getName()+「\\t 书籍作者：」 + book.getAuthor()+ 「\\t 书籍价格：」 + formatter.format (book.getPrice()/100.0)+「元」)；
}
}}
我们只修改了粗体部分，其他的部分没有任何改动，运行结果如下所示。
----------------------书店卖出去的书籍记录如下：---------------------
书籍名称：天龙八部 书籍作者：金庸 书籍价格：￥25.60 元
书籍名称：巴黎圣母院 书籍作者：雨果 书籍价格：￥50.40 元
书籍名称：悲惨世界 书籍作者：雨果 书籍价格：￥28.00 元
书籍名称：金瓶梅 书籍作者：兰陵笑笑生 书籍价格：￥38.70 元
OK，打折销售开发完成了。看到这里，各位可能有想法了：增加了一个 OffNoveBook 类后，你的业务逻辑还是修改了，你修改了 static 静态模块区域。这部分确实修改了，该部分属于高层次的模块，是由持久层产生的，在业务规则改变的情况下高层模块必须有部分改变以适应新业务，改变要尽量地少，防止变化风险的扩散。
注意 开闭原则对扩展开放，对修改关闭，并不意味着不做任何修改，低层模块的变更，必然要有高层模块进行耦合，否则就是一个孤立无意义的代码片段。
我们可以把变化归纳为以下三种类型：
● 逻辑变化
只变化一个逻辑，而不涉及其他模块，比如原有的一个算法是 a*b+c，现在需要修改为 a*b*c，可以通过修改原有类中的方法的方式来完成，前提条件是所有依赖或关联类都按照相同的逻辑处理。
● 子模块变化
一个模块变化，会对其他的模块产生影响，特别是一个低层次的模块变化必然引起高层模块的变化，因此在通过扩展完成变化时，高层次的模块修改是必然的，刚刚的书籍打折处理就是类似的处理模块，该部分的变化甚至会引起界面的变化。
● 可见视图变化
可见视图是提供给客户使用的界面，如 JSP 程序、Swing 界面等，该部分的变化一般会引起连锁反应（特别是在国内做项目，做欧美的外包项目一般不会影响太大）。如果仅仅是界面上按钮、文字的重新排布倒是简单，最司空见惯的是业务耦合变化，什么意思呢？一个展示数据的列表，按照原有的需求是 6 列，突然有一天要增加 1 列，而且这一列要跨 N 张表，处理 M 个逻辑才能展现出来，这样的变化是比较恐怖的，但还是可以通过扩展来完成变化，这就要看我们原有的设计是否灵活。
我们再来回顾一下书店销售书籍的程序，首先是我们有一个还算灵活的设计（不灵活是什么样子？BookStore 中所有使用到 IBook 的地方全部修改为实现类，然后再扩展一个 ComputerBook 书籍，你就知道什么是不灵活了）；然后有一个需求变化，我们通过扩展一个子类拥抱了变化；最后把子类投入运行环境中，新逻辑正式投产。通过分析，我们发现并没有修改原有的模块代码，IBook 接口没有改变，NovelBook 类没有改变，这属于已有的业务代码，我们保持了历史的纯洁性。放弃修改历史的想法吧，一个项目的基本路径应该是这样的：项目开发、重构、测试、投产、运维，其中的重构可以对原有的设计和代码进行修改，运维尽量减少对原有代码的修改，保持历史代码的纯洁性，提高系统的稳定性。
原网址: 访问
创建于: 2023-06-12 10:41:58
目录: default
标签: 无
未标明原创文章均为采集，版权归作者所有，转载无需和我联系，请注明原出处，南摩阿彌陀佛，知识，不只知道，要得到
最新评论