设计模式*六大原则

单一职责原则 single responsibility principle ： 尽可能的将对象划分成单一性的类别，使类的复杂性降低，实现什么职责都有清晰明确的定义。

示例：

@Data
public class UserInfo implements Serializable {

    private String userId;

    private String userName;

    private String password;
}

//不含业务逻辑
public interface IUserBO {

    String getUserId(String userId);

    String getPassword(String password);

    String getUserName();
}

//业务逻辑
public interface IUserInfoBiz {

    boolean changePassword(String oldPassword);

    boolean deleteUser(String userId);

    UserInfo getUser(String userId);

    boolean addUser(UserInfo userInfo);

    boolean addRole(String roleID);
}

public interface UserInfoService extends IUserBO,IUserInfoBiz{
}

@Slf4j
@Service
public class UserInfoServiceImpl implements UserInfoService {
    @Override
    public String getUserId(String userId) {
        return null;
    }

    @Override
    public String getPassword(String password) {
        return null;
    }

    @Override
    public String getUserName() {
        return null;
    }

    @Override
    public boolean changePassword(String oldPassword) {
        return false;
    }

    @Override
    public boolean deleteUser(String userId) {
        return false;
    }

    @Override
    public UserInfo getUser(String userId) {
        return null;
    }

    @Override
    public boolean addUser(UserInfo userInfo) {
        return false;
    }

    @Override
    public boolean addRole(String roleID) {
        return false;
    }
}

//业务调用
@Slf4j
public class BusinessInvocation {

    @Autowired
    IUserInfoBiz iUserInfoBiz;

    @Autowired
    IUserBO iUserBO;

    /**
     * 删除用户信息
     */
    public boolean changeUserMessage(UserInfo userInfo){
        String user = iUserBO.getUserId(userInfo.getUserId());
        if (user == null){
            log.info("-------无此用户，无法进行删除用户信息------");
        }
        return iUserInfoBiz.deleteUser(userInfo.getUserId());
    }
}

总结：在开发过程中设计类或接口时，尽量要将这些类和接口的职责唯一，明确。这样在进行合作开发时，不仅自己能够快速明确自己的目的，其他合作开发程序员也能够明白你的意思。

里氏替换原则Liskov Substitution Principle,LSP：所有引用基类的地方必须能够透明的使用其子类的对象。[父类出现的地方也可以用子类来替换，而子类出现的地方父类不一定能够替换]。

里氏替换原则的竭诚定义的规范：
1.子类必须完全实现父类的方法
2.子类可以有自己的个性
3.覆盖或实现父类的方法时输入参数可以被放大
4.覆盖或实现父类的方法时输出结果可以被缩小。

 

@Slf4j
public class Soldier {
    private AbstractGun gun;
    public void setGun(AbstractGun gun) {
        this.gun = gun;
    }
    public void killEnemy(){
        gun.shoot();
        log.info("正在射杀敌人... ...");
    }
}

//抽象枪对象
public abstract class AbstractGun {
    //射击do
    public void shoot(){};
}

@Slf4j
public class MachineGun extends AbstractGun {
    @Override
    public void shoot(){
      log.info("机关枪扫射");
    }
}

@Slf4j
public class Rifle extends AbstractGun{
    @Override
    public void shoot(){
        log.info("步枪射击... ...");
    }
}

public class Test {
    public static void main(String[] args) {
        Soldier soldier = new Soldier();
        soldier.setGun(new Rifle());
        soldier.killEnemy();
    }
}

 

依赖倒置原则 dependence inversion principle：高层模块不应该依赖底层模块，应该依赖其抽象，抽象不应该其细节，细节应该依赖其抽象。

底层：具体实现的java 类
抽象：接口或抽象类

依赖：存在类A 的一个方法S，S 传入的参数是另一个类B 的实例，那么类A 依赖于B。

示例：老司机要开车 [想开什么车就在底层implements 一个就好啦，别的不用动]

public interface IDriverService {

    void Driver(ICar car);
}

@Slf4j
@Service
public class DriverServiceImpl implements IDriverService {
    @Override
    public void Driver(ICar car) {
        car.run();
    }
}

public interface ICar {
    void run();
}

@Slf4j
@Service
public class BMWCar implements ICar {
    @Override
    public void run() {
      log.info("宝马车跑起来");
    }
}

@Slf4j
@Service
public class BenzCar implements ICar {
    @Override
    public void run() {
      log.info("奔驰车跑起来");
    }
}

//业务调用

public interface IBusinessInvocation {
    void invocation(int type);
}

@Slf4j
@Service
public class BusinessInvocation implements IBusinessInvocation{
    @Autowired
    IDriverService iDriverService;
    public void invocation(int type) {
        ICar iCar ;
        if (type == 1){
            iCar = new BenzCar();
            iDriverService.Driver(iCar);
        }else if(type == 2){
            iCar = new BMWCar();
            iDriverService.Driver(iCar);
        }
    }
}