软件架构设计原则

一、开闭原则

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

示例：
首先创建一个课程类接口ICourse：

public interface ICourse {
    Integer getId();
    String getName();
    Double getPrice();
}

接下来创建一个Java架构课程的类JavaCourse：

public class JavaCourse implements ICourse {

    private Integer Id;
    private String name;
    private Double price;

    public JavaCourse(Integer id, String name, Double price) {
        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;
    }
}

当课程做活动时，需要对价格的修改，很显然对源代码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.61;
    }
}

---

二、依赖倒置原则

定义：依赖倒置原则是指设计代码结构时，高层模块不应该依赖底层模块，二者都因该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象。通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并且能够降低修改程序所造成的风险。
示例：以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学习上瘾时，还想学习其他课程时，则就要依次修改底层到高层（调用层）的代码，显然当系统发布之后这样是非常的不稳定的，也会带来意想不到的风险。
则我们优化一下代码，创建课程的抽象ICourse接口：

public interface ICourse {
    void study();
}

编写JavaCourse类：

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 NewTom {
    public void study(ICourse course){
        course.study();
    } 
}

接下来调用：

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

对注入的方式也有不同，也称依赖注入：
构造器注入与实现：

public class NewTom {
    private ICourse course;

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

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

    public static void main(String[] args) {
        NewTom newTom = new NewTom(new JavaCourse());
        NewTom newTom2 = new NewTom(new PythonCourse());
    }
}

Setter注入：（适用于当Tom是全局单例时）

public class NewTom {
    private ICourse course;

    public void setCourse(ICourse course) {
        this.course = course;
    }
    public void study(){
        course.study();
    }
    
    public static void main(String[] args) {
        NewTom newTom = new NewTom();
        newTom.setCourse(new JavaCourse());
        newTom.study();
        newTom.setCourse(new PythonCourse());
        newTom.study();
    }
}

三、单一职责原则

定义：不要存在多于一个导致类变更的原因。假设我们有一个类负责两个职责，一旦发生需求变更，修改其中一个职责的逻辑代码，可能导致另一个职责的功能发生故障。这样一来，这个类就存在两个导类变更的原因。
解决方案：将两个职责用两个类来实现，进行解耦。后期需求变更维护互不影响。
作用：降低类的复杂度，提高类的可读性，提高系统的可维护性，降低变更引起的风险。

---

四、接口隔离原则

定义：接口隔离原则是指用多个专门的接口，而不使用单一的总接口，客户不因该依赖他不需要的接口，则个原则指导我们在设计接口时应当注意：

• 一个累对另一个累的依赖应该建立在最小的接口之上。
• 建立单一接口，不要建立庞大臃肿的接口。
• 尽量细化接口，接口中的方法尽量少。

代码：
IAnimal代码如下：

public interface IAnimal {
    void eat();
    void fly();
    void swim();
}

Bird类代码如下：

public class Bird implements IAnimal {
    @Override
    public void eat() {}
    @Override
    public void fly() {}
    @Override
    public void swim() {}
}

Dog类代码如下：

public class Dog implements IAnimal {
    @Override
    public void eat() {}
    @Override
    public void fly() {}
    @Override
    public void swim() {}
}

在上面代码中，Bird的swin()方法可能只能空着，但Dog中的fiy()方法显然是不可能的。这时候就需要设计不同的接口：

IEatAnimal ：

public interface IEatAnimal {
    void eat();
}

IFlyAnimal ：

public interface IFlyAnimal {
    void fly();
}

ISwimAnimal ：

public interface ISwimAnimal {
    void swim();
}

Dog 类代码：

public class Dog implements ISwimAnimal,IEatAnimal {

    @Override
    public void eat() {
        
    }

    @Override
    public void swim() {

    }
}

---

五、迪米特原则

是指应该对象应该对其他对象保持最少的了解，又叫最少知道原则，尽量降低类与类之间的耦合度。迪米特原则主要强调：之和朋友交流，不和陌生人说话。
现在来设计一个权限系统，BOSS需要查看目前发布到线上的课程数量，这个时候，BOSS要找到TeamLeader 去进行统计，TeamLeader再把统计结果告诉BOSS。接下来我们还是来看代码。
Course：

public class Course {
}

TeamLeader：

public class TeamLeader {
    public void cheakNumberOfCourses(List<Course> courses){
        System.out.println("目前发布课程为："+ courses.size());
    }
}

Boss：

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader){
        List<Course> courseList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        teamLeader.cheakNumberOfCourses(courseList);
    }
}

测试代码：

public static void main(String[] args) {
        Boss boss = new Boss();
        TeamLeader teamLeader = new TeamLeader();
        boss.commandCheckNumber(teamLeader);
    }

在上面代码看来，Boss只想要知道结果，不需要跟Course直接交流，而TeamLeader统计需要引用Course对象。接下来代码改进：

public class TeamLeader {
    public void cheakNumberOfCourses(){
        List<Course> courseList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        System.out.println("目前发布课程为："+ courseList.size());
    }
}

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader) {

        teamLeader.cheakNumberOfCourses();
    }

}

六、里氏替换原则

是指如果对每一个类型为T1的对象O1，都有类型为T2的对象O2，使得以T1定义的所有程序P在所有的对象O1都替换成O2时，程序P的行为没有发生变换，那么类型T2是类型T1的子类型。
也就是说：

• 子类可以实现弗雷的抽象方法，但不能覆盖父类的非抽象方法。
• 子类可以增加自己特有的方法。
• 房子类的方法重载父类的方法时，方法的前置条件（既方法的输入/入参）要比父类方法的输入参数更宽松。
• 当子类的方法实现父类的方法时，（重写/重载或实现抽象方法），方法的后置条件（即方法的输出/放返回值）要比父类更严格或与父类一样。

优点：

1. 约束继承泛滥，是开闭原则的一种体现。
2. 加强程序的健壮性，同时变更时也可以做到非常好的兼容性，挺高程序的可维护性和扩展性，降低需求变更时引入的风险。

七、合成复用原则

是指尽量的使用对象组合/聚合而不是继承关系达到软件复用的目的，可以是系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。