贯穿设计模式第三话--依赖倒转原则
Posted 最爱吃鱼罐头
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了贯穿设计模式第三话--依赖倒转原则相关的知识，希望对你有一定的参考价值。
🥳🥳🥳 茫茫人海千千万万，感谢这一刻你看到了我的文章，感谢观赏，大家好呀，我是最爱吃鱼罐头，大家可以叫鱼罐头呦~🥳🥳🥳
从今天开始，将开启一个专栏，
【贯穿设计模式】，设计模式是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。为了能更好的设计出优雅的代码，为了能更好的提升自己的编程水准，为了能够更好的理解诸多技术的底层源码， 设计模式就是基石，万丈高楼平地起,一砖一瓦皆根基。 ✨✨欢迎订阅本专栏✨✨
🥺 本人不才，如果文章知识点有缺漏、错误的地方 🧐，也欢迎各位人才们评论批评指正！和大家一起学习，一起进步! 👀
❤️ 愿自己还有你在未来的日子，保持学习，保持进步，保持热爱，奔赴山海！ ❤️
💬 最后，希望我的这篇文章能对你的有所帮助！ 🍊 点赞 👍 收藏 ⭐留言 📝 都是我最大的动力！
📃前言回顾
在第二篇文章中，我们了解设计模式的七大原则中第二个原则：开闭原则；
我们来回顾下，它的定义：扩展开放，对修改关闭，强调的是用抽象构建框架，用实现扩展细节，可以提高软件系统的可复用性及可维护性。
并且我们通过习题集价格不同的例子讲解并认识到当价格需求不同时代码所遇到的问题，值得注意的是：开闭原则是对扩展开放，对修改关闭，但这并不意味着不做任何修改，低层模块的变更，必然要有高层模块进行耦合，否则就是一个孤立无意义的代码片段。
🍒依赖倒转原则
今天我们要学习的是依赖倒转原则，高层模块不应该依赖低层模块，两者都应该依赖其抽象。
🍓概述
- 该原则是指高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象；依赖倒转的中心思想是面向接口编程；
- 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或者抽象类，细节就是具体的实现类。使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成；
- 依赖倒转原则要求我们在程序代码中传递参数时或在关联关系中，尽量引用层次高的抽象层类;
- 简单理解就是针对接口编程，而不是针对实现编程，在程序中尽量使用抽象层进行编程；
- 比如有三个类A类、B类和C类（B类和C类的功能类似），现在A类需要B类的相关功能，所以A类直接依赖类B，但是后面不需要B类的功能，需要C类的功能了，此时又需要要将A类改为依赖类C，然后必须通过修改A类的代码来完成这一需求，此时我们应该将A类修改为依赖接口D，B类和C类各自实现接口D，A类通过接口D间接与B类或者C类发生联系，则会大大降低修改A类的几率。
🍚特点
依赖倒置原则是开闭原则的基础，指的是针对接口编程，依赖于抽象而不依赖于具体，通过依赖倒置可以使系统有以下优点 ：
- 可以降低类与类之间的耦合性；
- 提高系统的稳定性；
- 提高代码的可读性和可维护性；
- 并降低修改程序带来的风险。
🍜问题引出
在大学上学期间，每位同学都是需要上各种不同的必修课程，如语文、数学、英语等，但是还需要上一些额外的选修课程，如思想政治、心里健康、计算机编程等。那接下来就以学生学习课程为例来讲解下依赖倒转原则吧。
1. 建立一个Java课程类JavaCourse：
package com.ygt.principle.dip;
/**
* 一个学习Java的课程
*/
public class JavaCourse
// 返回当前课程名，表示学习的是Java课程
public String getCourse()
return "Java课程";
2. 建议学生类Ygt学习课程：
package com.ygt.principle.dip;
/**
* 建立一个学生类，叫做鱼罐头ygt
*/
public class Ygt
// 他有个特点就是特别爱学习（哈哈）,上学期间热衷上各种课程
public void study(JavaCourse course)
System.out.println("当前学习了" + course.getCourse());
3. 建一个测试类DependenceInversion测试下学生上课：
package com.ygt.principle.dip;
// 测试依赖倒转
public class DependenceInversion
public static void main(String[] args)
// 这里测试下ygt学习上课。
Ygt ygt = new Ygt();
ygt.study(new JavaCourse());
得到的结果：
当前学习了Java课程
ygt非常热爱学习，因为学习不是人生的全部，但学习都征服不了，那你还能做什么？所以除了学习，我别无选择哈哈。现在ygt除了学习Java课程后，还想学习另一门语言Sql课程，这个时候，业务代码要如何修改呢？按照现在的代码逻辑的话，业务要拓展，代码从课程类到调用类，都是需要修改代码的，如此一来，不仅违反了开闭原则，也违反了依赖倒转原则的了，并且在修改代码的同时，可能会带来意想不到的风险，先来看看粗鲁的修改代码吧！
4. 新增一个Sql课程SqlCourse：
package com.ygt.principle.dip;
/**
* 增加一个Sql教程
*/
public class SqlCourse
// 返回当前课程名，表示学习的是SQL课程
public String getCourse()
return "SQL课程";
5. 修改ygt类中的学习方法：
package com.ygt.principle.dip;
/**
* 建立一个学生类，叫做鱼罐头ygt
*/
public class Ygt
// 他有个特点就是特别爱学习（哈哈）,上学期间热衷上各种课程
// public void study(JavaCourse course)
// System.out.println("当前学习了" + course.getCourse());
//
/**
* 学习方法修改如下，将传参修改为SqlCourse
*/
public void study(SqlCourse course)
System.out.println("当前学习了" + course.getCourse());
6. 修改测试类的调用：
package com.ygt.principle.dip;
// 测试依赖倒转
public class DependenceInversion
public static void main(String[] args)
// 这里测试下ygt学习上课。
Ygt ygt = new Ygt();
// ygt.study(new JavaCourse());
// 修改为Sql课程
ygt.study(new SqlCourse());
得到的结果：
当前学习了SQL课程
以上可以看出，如果后续ygt想再学习一门新课程的话，就又得重新修改代码，从上到下的修改代码，非常的繁杂，而且出错风险极大，下面就一起来探讨下解决方法吧。
🫖解决方案
在依赖倒转的核心中，高层模块不应该依赖低层模块，两者都应该依赖其抽象，所以我们可以将课程类提取出来，进行抽象接口化，这样ygt就不是直接依赖于Java课程和Sql课程啦，而是依赖于课程接口，使他们之间的关系进行倒转。
1. 新增一个课程接口ICourse：
package com.ygt.principle.dip;
/**
* 新增课程接口，每个课程都会一个方法，展示课程名字
*/
public interface ICourse
// 返回当前课程名
String getCourse();
2. 修改Java课程和Sql课程，通过实现ICourse接口：
// Java课程
package com.ygt.principle.dip;
/**
* 一个学习Java的课程
* 实现ICourse接口
*/
public class JavaCourse implements ICourse
// 返回当前课程名，表示学习的是Java课程
public String getCourse()
return "Java课程";
// Sql课程
package com.ygt.principle.dip;
/**
* 增加一个Sql教程
* 实现ICourse接口
*/
public class SqlCourse implements ICourse
// 返回当前课程名，表示学习的是SQL课程
public String getCourse()
return "SQL课程";
3. 修改ygt中的学习方法：
package com.ygt.principle.dip;
/**
* 建立一个学生类，叫做鱼罐头ygt
*/
public class Ygt
// 他有个特点就是特别爱学习（哈哈）,上学期间热衷上各种课程
// public void study(JavaCourse course)
// System.out.println("当前学习了" + course.getCourse());
//
// /**
// * 学习方法修改如下，将传参修改为SqlCourse
// */
// public void study(SqlCourse course)
// System.out.println("当前学习了" + course.getCourse());
//
/**
* 学习方法修改如下，将传参修改为ICourse
* 这样只要是实现ICourse接口的，都能学习啦！
*/
public void study(ICourse course)
System.out.println("当前学习了" + course.getCourse());
4. 最后修改下测试类：
package com.ygt.principle.dip;
// 测试依赖倒转
public class DependenceInversion
public static void main(String[] args)
// 这里测试下ygt学习上课。
Ygt ygt = new Ygt();
ygt.study(new JavaCourse());
// 修改为Sql课程
ygt.study(new SqlCourse());
得到的结果：
当前学习了Java课程
当前学习了SQL课程
可以看到，这样修改之后，就遵循了依赖倒转原则了，并且如果再新增一个课程的话，只需要新增一个类实现ICourse接口即可，就可以实现调用啦，无需修改ygt等代码了。
在实现依赖倒转原则时，需要针对抽象层编程，而将具体类的对象通过依赖注入的方式注入其他对象中。依赖注入是指当一个对象要与其他对象发生依赖关系时，通过抽象来注入所依赖的对象。而常用的注入方式有3种：接口注入、构造注入和Setter注入，接口注入在上面已经实现了，下面来看看如何实现其他两种注入吧：
构造注入：
通过构造函数来传入具体类的对象，
新建个类来测试构造注入：
package com.ygt.principle.dip;
/**
* 测试构造注入
*/
public class Ygt2
private ICourse course;
public Ygt2(ICourse course)
this.course = course;
public void study()
System.out.println("当前学习了" + course.getCourse());
调用方需要将JavaCourse对象作用ygt2对象的构造函数注入。
package com.ygt.principle.dip;
// 测试依赖倒转
public class DependenceInversion
public static void main(String[] args)
// // 这里测试下ygt学习上课。
// Ygt ygt = new Ygt();
// ygt.study(new JavaCourse());
// // 修改为Sql课程
// ygt.study(new SqlCourse());
// 测试构造注入
Ygt2 ygt2 = new Ygt2(new JavaCourse());
ygt2.study();
Setter注入：
通过Setter方法来传入具体类的对象，
新建个类来测试Setter注入：
package com.ygt.principle.dip;
/**
* 测试Setter注入
*/
public class Ygt3
private ICourse course;
public void setCourse(ICourse course)
this.course = course;
public void study()
System.out.println("当前学习了" + course.getCourse());
调用方需要将JavaCourse对象作用ygt2对象的构造函数注入。
package com.ygt.principle.dip;
// 测试依赖倒转
public class DependenceInversion
public static void main(String[] args)
// // 这里测试下ygt学习上课。
// Ygt ygt = new Ygt();
// ygt.study(new JavaCourse());
// // 修改为Sql课程
// ygt.study(new SqlCourse());
// // 测试构造注入
// Ygt2 ygt2 = new Ygt2(new JavaCourse());
// ygt2.study();
// 测试Setter注入
Ygt3 ygt3 = new Ygt3();
ygt3.setCourse(new JavaCourse());
ygt3.study();
🌸 完结
相信各位看官看到这里大致都对设计模式中的其中一个原则有了了解吧，依赖倒转原则实际上的定义就是高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象；它的核心思想是面向接口编程。
学好设计模式，让你感受一些机械化代码之外的程序设计魅力，也可以让你理解各个框架底层的实现原理。最后，祝大家跟自己能在程序员这条越走越远呀，祝大家人均架构师，我也在努力。 接下来期待第四话：里氏替换原则。 💪💪💪
文章的最后来个小小的思维导图：
🧐 本人不才，如有什么缺漏、错误的地方，也欢迎各位人才们评论批评指正！🤞🤞🤞
🤩 当然如果这篇文章确定对你有点小小帮助的话，也请亲切可爱的人才们给个点赞、收藏下吧，非常感谢！🤗🤗🤗
🥂 虽然这篇文章完结了，但是我还在，永不完结。我会努力保持写文章。来日方长，何惧车遥马慢！✨✨✨
💟 感谢各位看到这里！愿你韶华不负，青春无悔！让我们一起加油吧！ 🌼🌼🌼
💖 学到这里，今天的世界打烊了，晚安！🌙🌙🌙
设计模式之刘伟老师文章学习记录-------------依赖倒转原则
如果说开闭原则是面向对象设计的目标的话，那么依赖倒转原则就是面向对象设计的主要实现机制之一，它是系统抽象化的具体实现。依赖倒转原则是Robert C. Martin在1996年为“C++Reporter”所写的专栏Engineering Notebook的第三篇，后来加入到他在2002年出版的经典著作“Agile Software Development, Principles, Patterns, and Practices”一书中。依赖倒转原则定义如下：
|
依赖倒转原则(Dependency Inversion Principle, DIP)：抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程。 |
依赖倒转原则要求我们在程序代码中传递参数时或在关联关系中，尽量引用层次高的抽象层类，即使用接口和抽象类进行变量类型声明、参数类型声明、方法返回类型声明，以及数据类型的转换等，而不要用具体类来做这些事情。为了确保该原则的应用，一个具体类应当只实现接口或抽象类中声明过的方法，而不要给出多余的方法，否则将无法调用到在子类中增加的新方法。
在引入抽象层后，系统将具有很好的灵活性，在程序中尽量使用抽象层进行编程，而将具体类写在配置文件中，这样一来，如果系统行为发生变化，只需要对抽象层进行扩展，并修改配置文件，而无须修改原有系统的源代码，在不修改的情况下来扩展系统的功能，满足开闭原则的要求。
在实现依赖倒转原则时，我们需要针对抽象层编程，而将具体类的对象通过依赖注入(DependencyInjection, DI)的方式注入到其他对象中，依赖注入是指当一个对象要与其他对象发生依赖关系时，通过抽象来注入所依赖的对象。常用的注入方式有三种，分别是：构造注入，设值注入（Setter注入）和接口注入。构造注入是指通过构造函数来传入具体类的对象，设值注入是指通过Setter方法来传入具体类的对象，而接口注入是指通过在接口中声明的业务方法来传入具体类的对象。这些方法在定义时使用的是抽象类型，在运行时再传入具体类型的对象，由子类对象来覆盖父类对象。
|
下面通过一个简单实例来加深对依赖倒转原则的理解：
|
Sunny软件公司开发人员在开发某CRM系统时发现：该系统经常需要将存储在TXT或Excel文件中的客户信息转存到数据库中，因此需要进行数据格式转换。在客户数据操作类中将调用数据格式转换类的方法实现格式转换和数据库插入操作，初始设计方案结构如图1所示：
图1 初始设计方案结构图 在编码实现图1所示结构时，Sunny软件公司开发人员发现该设计方案存在一个非常严重的问题，由于每次转换数据时数据来源不一定相同，因此需要更换数据转换类，如有时候需要将TXTDataConvertor改为ExcelDataConvertor，此时，需要修改CustomerDAO的源代码，而且在引入并使用新的数据转换类时也不得不修改CustomerDAO的源代码，系统扩展性较差，违反了开闭原则，现需要对该方案进行重构。 |
在本实例中，由于CustomerDAO针对具体数据转换类编程，因此在增加新的数据转换类或者更换数据转换类时都不得不修改CustomerDAO的源代码。我们可以通过引入抽象数据转换类解决该问题，在引入抽象数据转换类DataConvertor之后，CustomerDAO针对抽象类DataConvertor编程，而将具体数据转换类名存储在配置文件中，符合依赖倒转原则。根据里氏代换原则，程序运行时，具体数据转换类对象将替换DataConvertor类型的对象，程序不会出现任何问题。更换具体数据转换类时无须修改源代码，只需要修改配置文件；如果需要增加新的具体数据转换类，只要将新增数据转换类作为DataConvertor的子类并修改配置文件即可，原有代码无须做任何修改，满足开闭原则。重构后的结构如图2所示：
图2重构后的结构图
在上述重构过程中，我们使用了开闭原则、里氏代换原则和依赖倒转原则，在大多数情况下，这三个设计原则会同时出现，开闭原则是目标，里氏代换原则是基础，依赖倒转原则是手段，它们相辅相成，相互补充，目标一致，只是分析问题时所站角度不同而已。
以上是关于贯穿设计模式第三话--依赖倒转原则的主要内容，如果未能解决你的问题，请参考以下文章