Java软件架构七大设计原则详解

一、开闭原则

开闭原则（Open-Close Principle,OCP）是指软件实体，如类、模块、函数应该对扩展开放，对修改关闭的原则。强调的是用抽象构建框架，用实现扩展细节。可以提高软件系统的可复用性和可维护性，是面向对象设计中最基础的设计原则。例如，很多项目都是迭代开发，我们想增加新的功能，尽量不修改原有的类中代码进行扩展。实现开闭原则的核心就是面向抽象编程，下面用代码示例：
比如，以校外培训机构为例，有很多课程，比如英语课，数学课，物理课等，首先创建一个课程接口类，类中有三个方法，分别获取课程ID，课程名称，课程价格

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 9:44
 **/
//演示开闭原则，定义一个课程接口,它有三个方法
public interface ICourse {
    Integer getId();
    String getName();
    Double getPrice();
}

然后，新建一个数学课程，继承这个课程接口

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 9:46
 **/
//演示开闭原则，用数学课实现类实现课程接口
public class MathCourese implements ICourse{
    private Integer id;
    private String name;
    private Double price;
    public MathCourese(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;
    }
}

现在比如到了双十二，我们要给这个数学课程做活动，打5折，如果修改原有这个数学类的getPrice()方法有风险，万一别处也在调用。此时遵循开闭原则，不应在原有类中修改，可以新增一个MathDiscountCourse类，扩展原有数学类的功能，代码如下：

public class MathDiscountCourse extends MathCourese {
    public MathDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }
    public Double getOriginPrice(){
        //调用父类的方法
        return super.getPrice();
    }
    public Double getDiscountPrice(){
        return super.getPrice()*0.5;
    }
}

在这里可以思考一下，为甚么这个类叫MathDiscountCoures，而不叫DiscountCourse???此时看下这个时候类图结构：


类图

二、依赖倒置原则

依赖倒置原则（Dependence Inversion Principle,DIP）是指代码结构设计时，高层模块不依赖低层模块，二者都应该依赖于抽象。举个例子，笔记本电脑，主板上有内存接口，硬盘接口，风扇接口等，如果内存坏了，换个内存就好了，不需要把整块主板换掉，因为主板上有内存制定好的统一的标准接口，生成内存的厂商有很多，只要按照这个接口标准生产就可以了。通过依赖倒置，可以提高系统稳定性，代码的可读性和可维护性，并且能够降低迭代开发修改代码带来的风险。接下来，上代码：
首先新建一个JackMa类：

//演示依赖倒置原则
public class JackMa {
    public void sing(){
        System.out.println("马云在唱摇滚");
    }
    public void speech(){
        System.out.println("马云在演讲");
    }
}

在主线程中调用一下

public class JackMaTest {
    public static void main(String[] args) {
        JackMa jackMa = new JackMa();
        jackMa.sing();
        jackMa.sing();
    }
}
在这里插入图片描述

随着年龄增大，马云爸爸的兴趣也越来越多，比如打高尔夫，拍电影，此时如果我们在JackMa类中新增方法，就需要从底层到高层，一次次的添加新增的方法，如此一来，代码复用性差，修改代码的风险也提高了，接下来优化我们的代码，新增一个兴趣爱好的抽象接口：

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 13:49
 **/
public interface Hobby {
    void doSomthing();
}

然后写唱歌类SingHobby，演讲类SpeechHobby

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 13:50
 **/
public class SingHobby implements Hobby{
    @Override
    public void doSomthing() {
        System.out.println("马云在唱歌");
    }
}


/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 13:50
 **/
public class SpeechHobby implements Hobby {
    @Override
    public void doSomthing() {
        System.out.println("马云在演讲");
    }
}

修改JackMa类：

//演示依赖倒置原则
public class JackMa {
   public void doHobbyThing(Hobby hobby){
       hobby.doSomthing();
   }
}

最后来看调用：

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 13:45
 **/
public class JackMaTest {
    public static void main(String[] args) {
        JackMa jackMa = new JackMa();
        jackMa.doHobbyThing(new SingHobby());
        jackMa.doHobbyThing(new SpeechHobby());
    }
}

这时候我们再看代码，无论马云的兴趣爱好多广泛，只要新增一个对应的爱好实现类，再调用的时候传参，而不需要修改底层代码就实现了扩展，其实这就是本质上的依赖注入。注入的方式还有构造器方式和Setter方式，我们来看构造器注入方式的代码：

public class JackMa {
    private Hobby hobby;
    public JackMa(Hobby hobby){
        this.hobby=hobby;
    }
    public void doHobbyThing(){
       hobby.doSomthing();
    }
}

此时调用代码

public class JackMaTest {
    public static void main(String[] args) {
        JackMa jackMa = new JackMa(new SingHobby());
        jackMa.doHobbyThing();
    }
}

根据构造器注入，我们每次调用都要创建实例，如果JackMa是全局单例的，我们只能选择Setter方式注入了，修改JackMa代码：

public class JackMa {
    private Hobby hobby;

    public void setHobby(Hobby hobby) {
        this.hobby = hobby;
    }
    public void doHobbyThing(){
       hobby.doSomthing();
    }
}

此时调用代码：

public class JackMaTest {
    public static void main(String[] args) {
        JackMa jackMa = new JackMa();
        jackMa.setHobby(new SingHobby());
        jackMa.doHobbyThing();
        jackMa.setHobby(new SpeechHobby());
        jackMa.doHobbyThing();
    }
}

三、单一职责原则

单一职责（Simple Responsibility Pinciple，SRP）是指不要存在多于一个导致类变更的原因，通常一个类只做一件事。假设一个类中负责两个职责，其中一个职责需求的变更，需要修改代码，势必可能会影响到另一个职责的功能发生故障。如何解决呢，那就是这两个职责用两个类完成，实现解耦，易维护，后期需求变更互不影响，这样设计，可降低类的复杂度，提高代码可读性和可维护性，降低后期维护成本，接下来看代码：
用课程举例，比如有直播课和录播课之分，直播课只能在线直播观看，不能快进快退，录播课可以随意反复观看，功能职责不一样，很多人喜欢像下面这样写：

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 14:11
 **/
public class Course {
    public void study(String couresName){
        if ("直播课".equals(couresName)){
            System.out.println(couresName+"不能快进");
        }else{
            System.out.println(couresName+"可以反复观看");
        }
    }
}

代码调用：

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 14:13
 **/
public class CourseTest {
    public static void main(String[] args) {
        Course course = new Course();
        course.study("直播课");
        course.study("录播课");
    }
}

上面的代码，Course一个类完成了两个职责，假如现在直播课和录播课的加密方式不一样，需要修改代码，势必会相互影响造成不可控的风险。我们对职责进行解耦，拆分成ReplayCourse和LiveCourse

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

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

调用代码：

public class CourseTest {
    public static void main(String[] args) {
        LiveCourse liveCourse = new LiveCourse();
        liveCourse.study("直播课");
        ReplayCourse replayCourse = new ReplayCourse();
        replayCourse.study("录播课");
    }
}

这样修改之后，开发简单，维护简单，在我们编写代码的过程中，尽量一个接口一个类一个方法只做一件事情，这样后期扩展维护起来比较容易。

四、接口隔离原则

接口隔离（Interface Segregation Principle, ISP）是指用多个专门的接口，而不是一个总接口，客户端不需要依赖它不需要的接口，这个原则指导我们在设计接口时应当注意以下几点：
1.一个类对另一个类的依赖应该建立在最小接口上；
2.建立单一接口，不要用臃肿庞大的接口；
3.尽量细化接口，一个接口中方法尽量少（不是越少越好，要适当）
接口隔离原则符合我们常说的低耦合高内聚的思想，从而使类具有很好的可读性、可扩展性、可维护性。我们在设计接口时，要多花时间思考，考虑业务模型，甚至以后随着业务的发展，后面对接口的可扩展性进行考虑。下面举个例子，定义一个动物animal抽象接口：

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 14:46
 **/
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() {}
}

此时看下类图更加清晰，


在这里插入图片描述

五、迪米特法则

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

/**
 * @Author lixiangyang
 * @Date 2019/12/13 0013 15:00
 **/
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){
        ArrayList<Course> courses = new ArrayList<>();
        for (int i=0;i<20;i++){
            courses.add(new Course());
        }
        teamLeader.checkNumberOfCourses(courses);
    }
}

测试代码：

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

写到这里，代码似乎已经完成了，但是根据迪米特法则，Boss只想知道结果，不需要关心Course，下面对代码进行改造。
TeamLeader类：

public class TeamLeader {
    public void checkNumberOfCourses(){
        ArrayList<Course> courses = new ArrayList<>();
        for (int i=0;i<20;i++){
            courses.add(new Course());
        }
        System.out.println("目前课程数量"+courses.size());
    }
}

Boss类：

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader){
        teamLeader.checkNumberOfCourses();
    }
}

这样Boss类就和Course类没有关系了，只需要关系TeamLeader。

六、里式替换原则

里式替换原则（Liskov Substitution Principle,LSP）是指如果对每一个类型为 T1 的对象 o1,都有类型为 T2 的对象 o2,使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型，这样理解比较抽象。可以理解为一个软件实体如果适用一个父类的话，那一定是适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。它有以下优点：
1.约束继承泛滥，开闭原则的一种体现；
2.加强程序的健壮性，提供程序的扩展性可维护性，降低需求变更引入的风险；
现在来描述一个经典的业务场景，用正方形，矩形，四边形的关系说明里式替换原则，我们都知道正方形是一个特殊的矩形，那么就可以创建一个矩形父类Rectangle 类：

public class Rectangle {
    private Long height;
    private Long weigh;

    public Long getHeight() {
        return height;
    }

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

    public Long getWeigh() {
        return weigh;
    }

    public void setWeigh(Long weigh) {
        this.weigh = weigh;
    }
}

创建正方形 Square 类继承长方形：

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

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

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

    @Override
    public Long getWeigh() {
        return getLength();
    }

    @Override
    public void setWeigh(Long weigh) {
        setLength(weigh);
    }
}

在测试类中创建 resize()方法，根据逻辑长方形的宽应该大于等于高，我们让高一直自增，直到高等于宽变成正方形

public class TestDemo {
    public static void resize(Rectangle rectangle){
        while (rectangle.getWeigh()>=rectangle.getHeight()){
            rectangle.setHeight(rectangle.getHeight()+1);
            System.out.println("width:"+rectangle.getWeigh() + ",height:"+rectangle.getHeight());
        }
        System.out.println("resize 方法结束" + "width:"+rectangle.getWeigh() + ",height:"+rectangle.getHeight());
    }
}

调用代码：

public class RectangleTest {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWeigh(20L);
        rectangle.setHeight(10L);
        TestDemo.resize(rectangle);
    }
}

运行结果：


在这里插入图片描述

发现高比宽还大了，在长方形中是一种非常正常的情况。现在我们再来看下面的代码，把长方形 Rectangle 替换成它的子类正方形 Square，修改测试代码：

public class RectangleTest {
    public static void main(String[] args) {
        Square square = new Square();
        square.setLength(10L);
        TestDemo.resize(square);
    }
}

这时候我们运行的时候就出现了死循环，违背了里氏替换原则，将父类替换为子类后，程序运行结果没有达到预期。因此，我们的代码设计是存在一定风险的。里氏替换原则只存在父类与子类之间，约束继承泛滥。我们再来创建一个基于长方形与正方形共同的抽象四边形 Quadrangle 接口：

public interface Quadrangle {
    long getHeight();
    long getWeigth();
}

修改长方形 Rectangle 类：

public class Rectangle implements Quadrangle {
    private Long height;
    private Long weigh;
    @Override
    public Long getHeight() {
        return height;
    }

    public void setHeight(Long height) {
        this.height = height;
    }
    @Override
    public Long getWeigh() {
        return weigh;
    }

    public void setWeigh(Long weigh) {
        this.weigh = weigh;
    }
}

修改正方形类 Square 类：

public class Square implements Quadrangle {
    private Long length;
    public Long getLength(){
        return length;
    }
    public void setLength(Long length){
        this.length=length;
    }

    @Override
    public Long getHeight() {
        return length;
    }

    @Override
    public Long getWeigh() {
        return length;
    }

}

此时，如果我们把 resize()方法的参数换成四边形 Quadrangle 类，方法内部就会报错，因为正方形 Square 已经没有了 setWidth()和 setHeight()方法了。因此，为了约束继承泛滥，resize()的方法参数只能用 Rectangle 长方形。

七、合成复用原则

合成复用原则（Composite/Aggregate Reuse Principle,CARP）是指尽量使用对象组合(has-a)/聚合(contanis-a)，而不是继承关系达到软件复用的目的。可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。继承我们叫做白箱复用，相当于把所有的实现细节暴露给子类。组合/聚合也称之为黑箱复用，对类以外的对象是无法获取到实现细节的。要根据具体的业务场景来做代码设计，其实也都需要遵循 OOP 模型。还是以数据库操作为例，先来创建 DBConnection 类：

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

创建 ProductDao 类：

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+"增加产品");
    }
}

这就是一种非常典型的合成复用原则应用场景。但是，目前的设计来说DBConnection还不是一种抽象，不便于系统扩展。目前的系统支持 MySQL 数据库连接，假设业务发生变化，数据库操作层要支持 Oracle 数据库。当然，我们可以在 DBConnection 中增加对Oracle 数据库支持的方法。但是违背了开闭原则。其实，我们可以不必修改 Dao 的代码，将 DBConnection 修改为 abstract，来看代码：

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

然后，将 MySQL 的逻辑抽离：

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

再创建 Oracle 支持的逻辑

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

最后看下类图结构，更加容易理解：


在这里插入图片描述

总结

平常日常开发中，业务代码写多了，容易忘记设计原则，导致后面新增需求或者需求变更时，扩展困难，难以维护，结果坑越来越多，也给后面接手的人留下来一堆烂摊子。所以在平时开发中，尽量要多想想，怎么设计更合理，这都是前人过来总结的经验，我们要站在巨人的肩膀上开发。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 215,874评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,102评论 3赞 391
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 161,676评论 0赞 351
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,911评论 1赞 290
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,937评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,935评论 1赞 295
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,860评论 3赞 416
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,660评论 0赞 271
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,113评论 1赞 308
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,363评论 2赞 331
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,506评论 1赞 346
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,238评论 5赞 341
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,861评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,486评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,674评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,513评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,426评论 2赞 352