2022-12-23 14:04:41 226阅读
模块间的依赖通过抽象产生,实现类之间不发生直接依赖,其依赖关系是通过接口或抽象类产生的。依赖倒置原则的目的是通过面向接口的编程来降低类间的耦合性,所以我们在实际编程中只要遵循以下4点,基本就能在项目中满足这个原则。
1.每个类尽量提供接口或抽象类,或者两者都具备。
2.参数类型、引用对象尽量使用接口或抽象类,而不是实现类。
3.任何类都不应该从实现类派生。
业务需求:在云数据库服务部署的过程中,对于公有云环境和私有云环境可能存在施工方式不一样的场景,因此在我们实际的工程项目中,需要用一套代码来兼容两种施工方式并存的场景。
public class DeployPublicCloudService {
public void preCheck() {
System.out.println("公有云-环境预检查");
}
public void deploy() {
System.out.println("公有云-施工部署");
}
}
public class DeployPrivateCloudService {
public void preCheck() {
System.out.println("私有云-环境预检查");
}
public void deploy() {
System.out.println("私有云-施工部署");
}
}
public class NotifyService {
public void callback(String msg) {
System.out.println(String.format("回调通知%s", msg));
}
}
public class Client {
public static void main(String[] args) {
// 公有云环境施工部署
constructInPublicCloud(new DeployPublicCloudService());
// 分割线
System.out.println("=========================");
// 私有云环境施工部署
constructInPrivateCloud(new DeployPrivateCloudService());
}
private static void constructInPublicCloud(DeployPublicCloudService deployService) {
deployService.preCheck();
deployService.deploy();
NotifyService notifyService = new NotifyService();
notifyService.callback("施工结果");
}
private static void constructInPrivateCloud(DeployPrivateCloudService deployService) {
deployService.preCheck();
deployService.deploy();
NotifyService notifyService = new NotifyService();
notifyService.callback("施工结果");
}
}
公有云-环境预检查
公有云-施工部署
回调通知施工结果
=========================
私有云-环境预检查
私有云-施工部署
回调通知施工结果
顺着以上代码的实现思路,假设现在又需要开发一套混合云的兼容施工方案,那我们的直接想法就是再新增一个部署混合云的服务(DeployMixedCloudService),然后再新增一个constructInMixedCloud方法,也就是说每次来一种新的施工方式,都要新增一个施工方法,而我们发现施工方法里的代码几乎一样,这不仅增加了代码冗余影响阅读,还不利于后期代码的可扩展性维护,比如某天需要修改预检查和部署方法的依赖关系,那么所有的施工方法都得改一遍,风险大大提高了,这显然是不可取的。那有没有一种方式,既能满足业务需求又不需要每次都新增施工方法呢,答案是有的,只要我们遵循依赖倒置原则的四点要求就能做到。下面进行代码演进。
public interface IDeployService {
/**
* 环境预检查
*/
void preCheck();
/**
* 施工部署
*/
void deploy();
}
public class DeployPublicCloudService implements IDeployService {
@Override
public void preCheck() {
System.out.println("公有云-环境预检查");
}
@Override
public void deploy() {
System.out.println("公有云-施工部署");
}
}
public class DeployPrivateCloudService implements IDeployService {
@Override
public void preCheck() {
System.out.println("私有云-环境预检查");
}
@Override
public void deploy() {
System.out.println("私有云-施工部署");
}
}
public class NotifyService {
public void callback(String msg) {
System.out.println(String.format("回调通知%s", msg));
}
}
public class Client {
public static void main(String[] args) {
// 公有云环境施工部署
construct(new DeployPublicCloudService());
// 分割线
System.out.println("=========================");
// 私有云环境施工部署
construct(new DeployPrivateCloudService());
}
private static void construct(IDeployService deployService) {
deployService.preCheck();
deployService.deploy();
NotifyService notifyService = new NotifyService();
notifyService.callback("施工结果");
}
}
公有云-环境预检查
公有云-施工部署
回调通知施工结果
=========================
私有云-环境预检查
私有云-施工部署
回调通知施工结果
2022-12-23 14:04:41 226阅读
模块间的依赖通过抽象产生,实现类之间不发生直接依赖,其依赖关系是通过接口或抽象类产生的。依赖倒置原则的目的是通过面向接口的编程来降低类间的耦合性,所以我们在实际编程中只要遵循以下4点,基本就能在项目中满足这个原则。
1.每个类尽量提供接口或抽象类,或者两者都具备。
2.参数类型、引用对象尽量使用接口或抽象类,而不是实现类。
3.任何类都不应该从实现类派生。
业务需求:在云数据库服务部署的过程中,对于公有云环境和私有云环境可能存在施工方式不一样的场景,因此在我们实际的工程项目中,需要用一套代码来兼容两种施工方式并存的场景。
public class DeployPublicCloudService {
public void preCheck() {
System.out.println("公有云-环境预检查");
}
public void deploy() {
System.out.println("公有云-施工部署");
}
}
public class DeployPrivateCloudService {
public void preCheck() {
System.out.println("私有云-环境预检查");
}
public void deploy() {
System.out.println("私有云-施工部署");
}
}
public class NotifyService {
public void callback(String msg) {
System.out.println(String.format("回调通知%s", msg));
}
}
public class Client {
public static void main(String[] args) {
// 公有云环境施工部署
constructInPublicCloud(new DeployPublicCloudService());
// 分割线
System.out.println("=========================");
// 私有云环境施工部署
constructInPrivateCloud(new DeployPrivateCloudService());
}
private static void constructInPublicCloud(DeployPublicCloudService deployService) {
deployService.preCheck();
deployService.deploy();
NotifyService notifyService = new NotifyService();
notifyService.callback("施工结果");
}
private static void constructInPrivateCloud(DeployPrivateCloudService deployService) {
deployService.preCheck();
deployService.deploy();
NotifyService notifyService = new NotifyService();
notifyService.callback("施工结果");
}
}
公有云-环境预检查
公有云-施工部署
回调通知施工结果
=========================
私有云-环境预检查
私有云-施工部署
回调通知施工结果
顺着以上代码的实现思路,假设现在又需要开发一套混合云的兼容施工方案,那我们的直接想法就是再新增一个部署混合云的服务(DeployMixedCloudService),然后再新增一个constructInMixedCloud方法,也就是说每次来一种新的施工方式,都要新增一个施工方法,而我们发现施工方法里的代码几乎一样,这不仅增加了代码冗余影响阅读,还不利于后期代码的可扩展性维护,比如某天需要修改预检查和部署方法的依赖关系,那么所有的施工方法都得改一遍,风险大大提高了,这显然是不可取的。那有没有一种方式,既能满足业务需求又不需要每次都新增施工方法呢,答案是有的,只要我们遵循依赖倒置原则的四点要求就能做到。下面进行代码演进。
public interface IDeployService {
/**
* 环境预检查
*/
void preCheck();
/**
* 施工部署
*/
void deploy();
}
public class DeployPublicCloudService implements IDeployService {
@Override
public void preCheck() {
System.out.println("公有云-环境预检查");
}
@Override
public void deploy() {
System.out.println("公有云-施工部署");
}
}
public class DeployPrivateCloudService implements IDeployService {
@Override
public void preCheck() {
System.out.println("私有云-环境预检查");
}
@Override
public void deploy() {
System.out.println("私有云-施工部署");
}
}
public class NotifyService {
public void callback(String msg) {
System.out.println(String.format("回调通知%s", msg));
}
}
public class Client {
public static void main(String[] args) {
// 公有云环境施工部署
construct(new DeployPublicCloudService());
// 分割线
System.out.println("=========================");
// 私有云环境施工部署
construct(new DeployPrivateCloudService());
}
private static void construct(IDeployService deployService) {
deployService.preCheck();
deployService.deploy();
NotifyService notifyService = new NotifyService();
notifyService.callback("施工结果");
}
}
公有云-环境预检查
公有云-施工部署
回调通知施工结果
=========================
私有云-环境预检查
私有云-施工部署
回调通知施工结果