软件架构设计原则

本文通过实例来讲解

开闭原则
依赖导致原则

开闭原则

开闭原则（Open-Close Principle，OCP）是指一个软件实体（如类、模块和函数）应该对扩展开放，对修改关闭。所谓的开闭，也正是对扩展和修改两个行为的一个原则。它强调的是用抽象构建框架，用实现扩展细节，可以提高软件系统的可复用性及可维护性。开闭原则是面向对象设计中最基础的设计原则，它指导我们如何简历稳定、灵活的系统。例如版本更新，我们尽可能不修改源代码，但是可以增加新功能。

比如说：弹性作息时间，只规定每天工作8个小时，但是你什么时候来，什么时候走是开放的，早来早走，晚来晚走。

开闭原则的核心思想就是面向抽象编程，接下来我们来看一段代码。
以课程体系位例，首先创建一个课程接口ICourse:

public interface ICourse {
    //获取课程Id
    Integer getId();
    //获取课程名称
    String getName();
    //获取课程价格
    Double getPrice();
}

整个课程生态有Java、大数据、等，我们创建一个Java课程的类JavaCourse：

public class JavaCourse implements ICourse {
    private Integer id;
    private String name;
    private Double price;
	//构造器
    public JavaCourse(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public Integer getId() {
        return this.id;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Double getPrice() {
        return this.price;
    }
}

现在我们要给Java课程做活动，价格优惠，如果修改JavaCourse中的getPrice()方法，则存在一定的风险，可能影响其他地方的调用结果。我们如何在不修改源代码的前提下，实现价格优惠这个功能呢？我们可以在写一个处理优惠逻辑的类JavaDiscountCourse

public class JavaDiscountCourse extends JavaCourse {
    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    //初始价格
    public Double getOriginPrice(){
        return super.getPrice();
    }
    
    //获取优惠价格价格
    public Double getPrice(){
        return super.getPrice()*0.6;
    }
}

简单来看一下类结构图
在这里插入图片描述
所谓的开闭原则就是不修改，多扩展。

依赖倒置原则

依赖倒置原则（Dependence Inversion Princip，DIP）是指设计代码结构时，高层模块不应该依赖底层模块，二者都应该依赖其抽象。抽象不应该依赖细节，细节应该依赖抽象。通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并且能够降低修改程序所造成的风险。

看一个案例，还是以Course为例，先来创建一个类Tom：

public class Tom {
    public void studyJavaCourse(){
        System.out.println("Tom在学习Java课程");
    }
    
    public void studyPythonCourse(){
        System.out.println("Tom在学习Python课程");
    }
}

来调用一下：

public static void main(String[] args) {
        Tom tom = new Tom();
        tom.studyJavaCourse();
        tom.studyPythonCourse();
    }

Tom非常热爱学习，现在他想在学一门新的技术AI，这时候，因为业务扩展，要从低层到高层（调用层）一次修改代码。在Tom类中增加StudyAICouese()方法，在高层也要追加调用。如此依赖，系统发布以后，实际上是非常不稳定的，在修改代码的同时也会带来意想不到的风险。接下来我们优化代码，创建一个课程的抽象接口ICouese接口：

public interface ICourse {
    void study();
}

然后编写JvaCourse类：

public class JavaCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("tom正在学习Java");
    }
}

在编写pythonCourse类：

public class PythonCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("tom正在学习Python");
    }
}

修改Tom类：

public class Tom {
    
    public  void study(ICourse course){
        course.study();
    }
}

看调用代码：

 public static void main(String[] args) {
        Tom tom = new Tom();
        tom.study(new JavaCourse());
        tom.study(new PythonCourse());
    }

此时无论Tom还想学习几门课程，对于新的课程，只需要创建一个类，通过传参的方式告诉Tom，而不需要修改底层代码。实际上这是一种依赖注入方式，注入的方式还有构造器方法和Setter方法。

构造器注入方式：

public class Tom {

    private ICourse course;

    public Tom(ICourse course) {
        this.course = course;
    }

    public  void study(){
        course.study();
    }

   
}

调用代码：

public static void main(String[] args) {
        Tom tom = new Tom(new JavaCourse());
        tom.study();
    }

根据构造器方式注入，在调用时，每次都要创建实例。如果Tom是全局单例，则我们只能选择用Setter方式来注入：

public class Tom {

    private ICourse course;

    public void setCourse(ICourse course) {
        this.course = course;
    }

    public  void study(){
        course.study();
    }
}

调用代码：

public static void main(String[] args) {
        Tom tom = new Tom();
        tom.setCourse(new JavaCourse());
        tom.study();
        
        tom.setCourse(new PythonCourse());
        tom.study();
    }