软件架构设计原则

1 软件架构设计原则

1.1 开闭原则

开闭原则（Open-Closed Principle，OCP）是指一个软件实体（如类、模块和函数）应该对扩展开放，对修改关闭。

课程接口ICourser：

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) {
        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;
    }
}

处理优惠逻辑的类JavaDiscountCurse：

public class JavaDiscountCourse extends JavaCourse {

    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }
    public Double getOriginPrice() {
        return super.getPrice();
    }
    @Override
    public Double getPrice() {
        return super.getPrice()*0.61;
    }
}

测试类OpenCloseTest：

public class OpenCloseTest {
    public static void main(String[] args) {
        ICourse iCourse = new JavaDiscountCourse(233,"学院专属课", 8888D);
        JavaDiscountCourse javaCourse = (JavaDiscountCourse) iCourse;
        System.out.println("课程ID:" + javaCourse.getId() +
                "\n课程名称：《" + javaCourse.getName() + "》" +
                "\n原价：" + javaCourse.getOriginPrice() + "元" +
                "\n折后价：" + javaCourse.getPrice() + "元");
    }
}

输出：

课程ID:233
课程名称：《学院专属课》
原价：8888.0元
折后价：5421.68元

1.2 依赖倒置原则

Dependence Inversion Principle，DIP。是指设计代码结构时，高层模块不应该依赖低层模块，二者都应该依赖其抽象。抽象不应该依赖细节，细节应该依赖抽象。

创建一个Jack类：

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

测试类：

public class DependencyInversionTest {
    public static void main(String[] args) {
        Jack jack = new Jack();
        jack.studyJavaCourse();
        jack.studyPythonCourse();
    }
}

如果Jack还想学习AI的课程，则随着业务的扩展，要从低层到高层依次修改代码。在Jack类中增加studyAICourse()方法，在高层也要追加调用，实际上是很不稳定的，在修改代码的同时也会带来意想不到的风险。接下来优化代码，创建一个课程的抽象ICourse接口：

public interface ICourse {
    void study();
}

然后编写JavaCourse类：

public class JavaCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("Jack在学习Java的课程");
    }
}

再实现PythonCourse类：

public class PythonCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("Jack在学习Python的课程");
    }
}

修改Jack类：

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

调用代码：

public class DependencyInversionTest {
    public static void main(String[] args) {
        Jack jack = new Jack();
        jack.study(new JavaCourse());
        jack.study(new PythonCourse());
    }
}

输出：

Jack在学习Java的课程
Jack在学习Python的课程

如此，无论Jack的兴趣如何暴涨，对于新的课程，只需要新建一个类，通过传参的方式告诉Jack，而不需要修改底层代码。这种方式就叫依赖注入。

注入的方式还有构造器方式和Setter方式。构造器注入方式：

public class Jack {
    private ICourse course;
    public Jack(ICourse course) {
        this.course = course;
    }
    public void study() {
        course.study();
    }
}

调用代码：

public class DependencyInversionTest {
    public static void main(String[] args) {
        Jack jack = new Jack(new JavaCourse());
        jack.study();
    }
}

Jack在学习Java的课程

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

public class Jack {
    private ICourse course;
    public void setCourse(ICourse course) {
        this.course = course;
    }
    public void study() {
        course.study();
    }
}

调用代码：

public class DependencyInversionTest {
    public static void main(String[] args) {
        Jack jack = new Jack();
        jack.setCourse(new JavaCourse());
        jack.study();
        jack.setCourse(new PythonCourse());
        jack.study();
    }
}

Jack在学习Java的课程
Jack在学习Python的课程

1.3 单一职责原则

Simple Responsibility Principe，SRP：是指不要存在多于一个导致类变更的原因。一个类、接口或方法只负责一项职责。

以直播课和录播课为例子，创建一个Course类：

public class Course {
    public void study(String courseName) {
        if ("直播课".equals(courseName)) {
            System.out.println(courseName + "不能快进");
        } else {
            System.out.println(courseName + "可以反复回看");
        }
    }
}

调用代码：

public class SingleResponsibilityTest {
    public static void main(String[] args) {
        Course course = new Course();
        course.study("直播课");
        course.study("录播课");
    }
}

直播课不能快进
录播课可以反复回看

从代码来看，Course类承担了两种处理逻辑。如果现在需要对课程进行加密，直播课程和录播课程的加密逻辑不一样，必须修改代码。而修改代码的逻辑势必会一你会相互影响，容易带来不可控的风险。

需要对职责进行解耦，分别创建两个类：LiveCourse和ReplayCourse。

public class LiveCourse {
    public void study(String courseName) {
        System.out.println(courseName + "不能快进看");
    }
}

public class ReplayCourse {
    public void study(String courseName) {
        System.out.println(courseName + "可以反复回看");
    }
}

调用代码：

public class SingleResponsibilityTest {
    public static void main(String[] args) {
        LiveCourse liveCourse = new LiveCourse();
        liveCourse.study("直播课");

        ReplayCourse replayCourse = new ReplayCourse();
        replayCourse.study("录播课");
    }
}

直播课不能快进看
录播课可以反复回看

如果业务继续发展，课程要做权限。未付费学员可以获取基本信息，已付费学员可以获得学习权限。那么在控制课程层面至少有两个职责。我们可以将展示职责和管理职责分离开来，都实现同一个抽象依赖。设计一个顶层接口，创建ICourse接口：

public interface ICourse {
    // 获得基本信息
    String getCourseName();

    // 获得视频流
    byte[] getCourseVideo();

    // 学习课程
    void studyCourse();
    // 退款
    void refundCourse();
}

也可以将这个接口拆成两个接口：ICourseInfo和ICourseManager

public interface ICourseInfo {
    String getCourseName();
    byte[] getCourseVideo();
}

public interface ICourseManager {
    void studyCourse();
    void refundCourse();
}

1.4 接口隔离原则

Interface Segregation Principle，ISP：是指用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口。

对一个动物行为进行抽象描述：

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的swim()方法只能空着，Dog的fly()方法显然也是不可能的。这时需要对不同动物行为来设计不同的接口，分别设计IEatAnimal、IFlyAnimal和ISwimAnimal接口。代码如下：

public interface IEatAnimal {
    void eat();
}

public interface IFlyAnimal {
    void fly();
}

public interface ISwimAnimal {
    void swim();
}

Dog只实现了IEatAnimal和ISwimAnimal接口，代码如下：

public class Dog implements IEatAnimal, ISwimAnimal {
    @Override
    public void eat() {}

    @Override
    public void swim() {}
}

1.5 迪米特原则

Law of Demeter，LoD：是指一个对象应该对其他对象保持最小的了解，又叫最少知道原则（Least Knowledge Principle，LKP），尽量降低类与类之间的耦合度。

设计一个权限系统，Boss需要查看目前发布到线上的课程数量。

public class Course {
}

public class TeamLeader {
    public void checkNumberOfCourses(List<Course> courseList) {
        System.out.println("目前已发布的课程数量是：" + courseList.size());
    }
}

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader) {
        // 模拟Boss一页一页往下翻页，TeamLeader实时统计
        List<Course> courseList = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        teamLeader.checkNumberOfCourses(courseList);
    }
}

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

目前已发布的课程数量是：20

根据迪米特原则，Boss只想要结果，不需要跟Course直接交流。改造如下：

public class TeamLeader {
    public void checkNumberOfCourses() {
        List<Course> courseList = new ArrayList<Course>();
        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.checkNumberOfCourses();
    }
}

1.6 里氏替换原则

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

使用里氏替换原则有以下优点：

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

public interface Quadangle {
    long getWidth();
    long getHeight();
}

public class Rectangle implements Quadangle {
    private long height;
    private long width;

    @Override
    public long getWidth() {
        return 0;
    }

    @Override
    public long getHeight() {
        return 0;
    }

    public void setHeight(long height) {
        this.height = height;
    }

    public void setWidth(long width) {
        this.width = width;
    }
}

public class Square extends Rectangle {
    private long length;
    public long getLength() {
        return length;
    }
    public void setLength(long length) {
        this.length = length;
    }

    @Override
    public long getWidth() {
        return getLength();
    }

    @Override
    public long getHeight() {
        return getLength();
    }

    @Override
    public void setHeight(long height) {
        setLength(height);
    }

    @Override
    public void setWidth(long width) {
        setLength(width);
    }
}

public class LiskovSubstiutionTest {
    public static void resize(Rectangle rectangle) {
        while (rectangle.getWidth() >= rectangle.getHeight()) {
            rectangle.setHeight(rectangle.getHeight()+1);
            System.out.println("width:" + rectangle.getWidth() +
                    "\nheight:" + rectangle.getHeight());
        }
        System.out.println("resize方法结束：" +
                "\nwidth:" + rectangle.getWidth() +
                "\nheight:" + rectangle.getHeight());

    }

    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(20);
        rectangle.setHeight(10);
        resize(rectangle);
    }
}

1.7 合成复用原则

Composite/Aggregate Reuse Principle，CARP：是指尽量使用对象组合（has-a）/聚合（contains-a）而不是继承关系达到软件复用的目的。

继承叫作白箱复用，相当于把所有的实现细节暴露给子类。组合/聚合称为黑箱复用，我们无法获取到类以外的对象的实现细节。

以数据库为例：

public class DBConnection {
    public String getConnection() {
        return "MySQL数据库连接";
    }
}

public class ProductDao {
    private DBConnection dbConnection;
    public void setDbConnection(DBConnection dbConnection) {
        this.dbConnection = dbConnection;
    }
    public void addProduct() {
        String conn = dbConnection.getConnection();
        System.out.println("使用" + conn + "增加产品");
    }
}

假设业务发生变化，数据库操作层要支持Oracle数据库，虽然可以在DBConnection中增加对Oracle数据库的支持，但是这违背了开闭原则。更改如下：

public abstract class DBConnection {
    public abstract String getConnection();
}

public class MySQLConnection extends DBConnection {
    @Override
    public String getConnection() {
        return "MySQL数据库连接";
    }
}

public class OracleConnection extends DBConnection {
    @Override
    public String getConnection() {
        return "Oracle数据库连接";
    }
}

具体选择交给应用层。