设计模式（一）设计原则_carinfo类的设计不符合以下哪些设计原则-CSDN博客

本文链接：https://blog.csdn.net/smith789/article/details/104073235

开闭原则

定义：一个软件实体，如类、模块、函数应该对扩展开放，对修改关闭。例如面向抽象编程，而不要面向实现编程。
优点：提高软件系统的可复用性、可维护性。
例如对于一个汽车类Car来说，有汽车品牌属性和汽车引擎，如果按照下面的设计：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Car {
    /**
     * 汽车型号名称
     */
    private String carName;
    /**
     * 汽车引擎
     */
    private V4Engine engine;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
class V4Engine{
    private String engineName;
}

@Slf4j
class Test{
    public static void main(String[] args) {
        Car car = new Car();
        car.setCarName("皮卡");
        car.setEngine(new V4Engine("V4发动机"));
        log.info("{}",car);
    }
}

如果要修改发动机，就不得不修改Car类。发动机的变化应该独立出来，不能修改原有类，但可以扩展原有类。如果要加新的发动机，不能修改原有的Car类，只需要添加新的发动机类就行了，如下所示：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Car {
    /**
     * 汽车型号名称
     */
    private String carName;
    /**
     * 汽车引擎
     */
    private Engine engine;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
abstract class Engine{
    protected String engineName;

}

class V4Engine extends Engine{
    V4Engine(String engineName){
        super(engineName);
    }
}

class V8Engine extends Engine{
    V8Engine(String engineName){
        super(engineName);
    }
}

@Slf4j
class Test{
    public static void main(String[] args) {
        Car car = new Car();
        car.setCarName("皮卡");
        car.setEngine(new V4Engine("V4发动机"));
        log.info("{}",car);

        car.setEngine(new V8Engine("V8发动机"));
        log.info("{}",car);
    }
}

在这里插入图片描述

依赖倒置原则

定义：高层不应该依赖底层模块，二者都应该依赖抽象。要针对接口编程，不要针对实现编程。

优点：减少类的耦合性，提高稳定性、代码可读性、可维护性。

依赖倒置原则和开闭原则举例：

MyBatis在使用Mapper的时候

SqlSession sqlSession = sqlSessionFactory.openSession();

会调用DefaultSqlSessionFactory的openSessionFromDataSource方法。

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
   	略
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    略
  }

其中Configuration.newExecutor方法。

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

Configuration持有的引用是Executor接口，而Executor接口有3个实现类：

在这里插入图片描述

BaseExecutor抽象类使用模板方法模式，定义了通用的方法实现。供ReuseExecutor、SimpleExecutor、BatchExecutor调用。
SimpleExecutor是最简单的Executor接口实现，ReuseExecutor和SimpleExecutor的区别是：ReuseExecutor能重用Statement。而BatchExecutor能够批量执行sql。
CachingExecutor使用了装饰模式，给Executor接口实现类封装了二级缓存的功能，稍后专写一篇关于它的介绍。

这里就遵循了依赖导致原则和开闭原则，Configuration持有的引用是Executor接口，依赖的是Executor接口，而非具体的实现类。同时对扩展开放，如果要增加新的Executor，只需要新增加一个XXXExecutor，并在初始化的时候new即可。

单一职责原则

定义：一个类、接口、方法应该只有一个职责。

现实编码中，很难严格遵守，基本上没有哪个类做到单一职责。建议方法级别做到单一职责原则。

优点：降低类的复杂度，提高类的可读性、可维护性。

单一职责举例：

在MyBatis的mapper文件中经常可以看到通用型的update方法：

public int update(Student student);

对应的xml文件往往是：

<update id="update">
    UPDATE student SET 
    name = #{name}, 
    age = #{age}, 
    gender = #{gender}, 
    phone = #{phone}, 
    class = #{class}, 
    type = #{type}, 
    update_by = #{updateBy.id}, 
    update_date = #{updateDate}, 
    remarks = #{remarks}
    WHERE id = #{id}
</update>

无论要修改Student的那个属性，所有属性都要修改一遍，如果要修改name，就要写一个单一职责的方法：

public int update(@Param("name") String name,@Param("id") String id);

<update id="update">
    UPDATE student SET 
    name = #{name}
    WHERE id = #{id}
</update>

迪米特法则

定义：又叫做最少知道原则。一个对象应该对其他对象保持最少的了解。

强调只和朋友交流，不和陌生人说话。

出现在成员变量、方法的输入输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。

优点：降低耦合度。

迪米特法则举例：

Java中有PO/Entity: persistent object持久对象、VO：view object表现层对象、DTO：data transfer object，数据传输对象、DAO ：data access object数据访问对象、POJO ：plain ordinary java object用这个名字用来强调它是一个普通java对象，而不是一个特殊的对象。

它们有时可以通用，各自有各自的生命周期作用范围。

在这里插入图片描述