设计模式 – 那啥快看

Java 单例模式的实现方法总结，你青睐于哪种方式？

/**
 * 饿汉式（静态常量）
 */
public class Singleton {

    private Singleton(){

    }
    // 类里的静态变量只会初始化一次
    private static final Singleton singleton = new Singleton();

    public static Singleton getInstance(){
        return singleton;
    }

}

/**

* 饿汉式（静态常量）

public class Singleton {

private Singleton(){

}

// 类里的静态变量只会初始化一次

private static final Singleton singleton = new Singleton();

public static Singleton getInstance(){

return singleton;

}

/**
 * 饿汉式（静态代码块）
 */
public class Singleton {

    private Singleton(){

    }

    private static Singleton singleton;

    static {
        singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return singleton;
    }

}

/**

* 饿汉式（静态代码块）

public class Singleton {

private Singleton(){

}

private static Singleton singleton;

static {

singleton = new Singleton();

}

public static Singleton getInstance(){

return singleton;

}

/**
 * 懒汉式（线程不安全）
 */
public class Singleton {

    private Singleton(){

    }

    private static Singleton singleton;

    public static Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

}

/**

* 懒汉式（线程不安全）

public class Singleton {

private Singleton(){

}

private static Singleton singleton;

public static Singleton getInstance(){

if (singleton == null){

singleton = new Singleton();

}

return singleton;

}

/**
 * 懒汉式（线程安全:同步方法）
 */
public class Singleton {

    private Singleton(){

    }

    private static Singleton singleton;

    public static synchronized Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

}

/**

* 懒汉式（线程安全:同步方法）

public class Singleton {

private Singleton(){

}

private static Singleton singleton;

public static synchronized Singleton getInstance(){

if (singleton == null){

singleton = new Singleton();

}

return singleton;

}

/**
 * 懒汉式（线程安全:synchronized + volatile + double check）
 * 这是推荐的单例模式实现方式
 */
public class Singleton {

    private Singleton(){

    }

    // volatile 是为了确保线程间的静态变量的可见性，需要注意工作内存和主内存的关系哦
    private static volatile Singleton singleton;

    public static Singleton getInstance(){
        if (singleton == null){
            synchronized(Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

}

/**

* 懒汉式（线程安全:synchronized + volatile + double check）

* 这是推荐的单例模式实现方式

public class Singleton {

private Singleton(){

}

// volatile 是为了确保线程间的静态变量的可见性，需要注意工作内存和主内存的关系哦

private static volatile Singleton singleton;

public static Singleton getInstance(){

if (singleton == null){

synchronized(Singleton.class){

if(singleton == null){

singleton = new Singleton();

}

return singleton;

}

/**
 * 懒汉式（静态内部类）
 * 这是第二推荐的单例模式实现方式
 */
public class Singleton {

    private Singleton(){

    }

    // 当类Singleton被加载时，静态内部类是不会被加载的，这是重点1 ！！！！！！
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance(){
        // 代码执行到下面一行时，才开始加载SingletonInstance静态内部类，并且只会装载一次，也是线程安全的，这是重点2 ！！！！！！
        return SingletonInstance.INSTANCE;
    }

}

/**

* 懒汉式（静态内部类）

* 这是第二推荐的单例模式实现方式

public class Singleton {

private Singleton(){

}

// 当类Singleton被加载时，静态内部类是不会被加载的，这是重点1 ！！！！！！

private static class SingletonInstance{

private static final Singleton INSTANCE = new Singleton();

}

public static Singleton getInstance(){

// 代码执行到下面一行时，才开始加载SingletonInstance静态内部类，并且只会装载一次，也是线程安全的，这是重点2 ！！！！！！

return SingletonInstance.INSTANCE;

}

/**
 * 懒汉式（枚举）
 * 可以避免多线程同步问题，也能防止反序列化重新创建新的对象
 * 这也是比较推荐的方式
 */
public enum Singleton {
    INSTANCE;
    public Singleton getInstance(){
        return INSTANCE;
    }
}

/**

* 懒汉式（枚举）

* 可以避免多线程同步问题，也能防止反序列化重新创建新的对象

* 这也是比较推荐的方式

public enum Singleton {

INSTANCE;

public Singleton getInstance(){

return INSTANCE;

}

jdk里的Runtime类就是使用的单例模式

开闭原则

即Open Closed Principle,它是最基础也是最重要的设计原则，我们遵循其它的设计原则如单一职责原则、依赖倒置原则、里氏替换原则等最终都是为了开闭原则。

开闭原则要求一个软件实体，如类、函数或模块，要对扩展开放（提供方），对修改关闭（使用方）。当有一个新的功能或需求来了时，我们应该是通过增加新的类、函数、模块等手段来代替直接修改原来的类或函数。

总之一句话就是用抽象构建框架，用实现扩展细节。

案例

重构前UML图

代码1

/**
 * 统计各个电商平台的商户销售情况
 */
public class Statistics {

    /**
     * 统计某商户的年销售额
     * @param platformType 平台类型 1天猫 2淘宝 3京东
     * @param merchantId 商户id
     */
    public void yearSales(int platformType, String merchantId){
        if (platformType == 1){
            System.out.println("商户"+merchantId+"在天猫的年销售额是1000万");
        }else if(platformType == 2){
            System.out.println("商户"+merchantId+"在淘宝的年销售额是800万");
        }else if(platformType == 3){
            System.out.println("商户"+merchantId+"在京东的年销售额是850万");
        }
    }

}

/**

* 统计各个电商平台的商户销售情况

public class Statistics {

/**

* 统计某商户的年销售额

* @param platformType 平台类型 1天猫 2淘宝 3京东

* @param merchantId 商户id

public void yearSales(int platformType, String merchantId){

if (platformType == 1){

System.out.println("商户"+merchantId+"在天猫的年销售额是1000万");

}else if(platformType == 2){

System.out.println("商户"+merchantId+"在淘宝的年销售额是800万");

}else if(platformType == 3){

System.out.println("商户"+merchantId+"在京东的年销售额是850万");

}

public class Client {
    public static void main(String[] args) {
        Statistics statistics = new Statistics();
        statistics.yearSales(1, "123456789");
        statistics.yearSales(2, "123456789");
        statistics.yearSales(3, "123456789");
    }
}

public class Client {

public static void main(String[] args) {

Statistics statistics = new Statistics();

statistics.yearSales(1, "123456789");

statistics.yearSales(2, "123456789");

statistics.yearSales(3, "123456789");

}

现在若要增加一个统计平台拼多多，那就需要在yearSales方法里增加if else判断分支，另外调用方的客户端也要跟着修改，这就违背了开闭原则。根据对修改关闭，对扩展开放的宗旨，我们需要这样改。

代码2

/**
 * 统计各个电商平台的商户销售情况
 */
public abstract class PlatformStatistics {

    /**
     * 平台类型 1天猫 2淘宝 3京东 4拼多多
     */
    abstract int getType();

    /**
     * 统计某商户的年销售额
     * @param merchantId 商户id
     */
    abstract void yearSales(String merchantId);

}

/**

* 统计各个电商平台的商户销售情况

public abstract class PlatformStatistics {

/**

* 平台类型 1天猫 2淘宝 3京东 4拼多多

abstract int getType();

/**

* 统计某商户的年销售额

* @param merchantId 商户id

abstract void yearSales(String merchantId);

}

public class TmallStatistics extends PlatformStatistics {
    @Override
    int getType() {
        return 1;
    }

    @Override
    void yearSales(String merchantId) {
        System.out.println("商户"+merchantId+"在天猫的年销售额是1000万");
    }
}

public class TmallStatistics extends PlatformStatistics {

@Override

int getType() {

return 1;

}

@Override

void yearSales(String merchantId) {

System.out.println("商户"+merchantId+"在天猫的年销售额是1000万");

}

public class TaobaoStatistics extends PlatformStatistics {
    @Override
    int getType() {
        return 2;
    }

    @Override
    void yearSales(String merchantId) {
        System.out.println("商户"+merchantId+"在淘宝的年销售额是800万");
    }
}

public class TaobaoStatistics extends PlatformStatistics {

@Override

int getType() {

return 2;

}

@Override

void yearSales(String merchantId) {

System.out.println("商户"+merchantId+"在淘宝的年销售额是800万");

}

public class JdStatistics extends PlatformStatistics {
    @Override
    int getType() {
        return 3;
    }

    @Override
    void yearSales(String merchantId) {
        System.out.println("商户"+merchantId+"在京东的年销售额是850万");
    }
}

public class JdStatistics extends PlatformStatistics {

@Override

int getType() {

return 3;

}

@Override

void yearSales(String merchantId) {

System.out.println("商户"+merchantId+"在京东的年销售额是850万");

}

public class PinduoduoStatistics extends PlatformStatistics {
    @Override
    int getType() {
        return 4;
    }

    @Override
    void yearSales(String merchantId) {
        System.out.println("商户"+merchantId+"在拼多多的年销售额是1050万");
    }
}

public class PinduoduoStatistics extends PlatformStatistics {

@Override

int getType() {

return 4;

}

@Override

void yearSales(String merchantId) {

System.out.println("商户"+merchantId+"在拼多多的年销售额是1050万");

}

public class PlatformFactory {

    private ConcurrentHashMap<Integer, PlatformStatistics> statisticsMap = new ConcurrentHashMap<>(5);

    public PlatformFactory(){
        TmallStatistics tmallStatistics = new TmallStatistics();
        statisticsMap.put(tmallStatistics.getType(), tmallStatistics);
        TaobaoStatistics taobaoStatistics = new TaobaoStatistics();
        statisticsMap.put(taobaoStatistics.getType(), taobaoStatistics);
        JdStatistics jdStatistics = new JdStatistics();
        statisticsMap.put(jdStatistics.getType(), jdStatistics);
        PinduoduoStatistics pinduoduoStatistics = new PinduoduoStatistics();
        statisticsMap.put(pinduoduoStatistics.getType(), pinduoduoStatistics);
    }

    public PlatformStatistics getInstance(int platformType){
        return statisticsMap.get(platformType);
    }
}

public class PlatformFactory {

private ConcurrentHashMap<Integer, PlatformStatistics> statisticsMap = new ConcurrentHashMap<>(5);

public PlatformFactory(){

TmallStatistics tmallStatistics = new TmallStatistics();

statisticsMap.put(tmallStatistics.getType(), tmallStatistics);

TaobaoStatistics taobaoStatistics = new TaobaoStatistics();

statisticsMap.put(taobaoStatistics.getType(), taobaoStatistics);

JdStatistics jdStatistics = new JdStatistics();

statisticsMap.put(jdStatistics.getType(), jdStatistics);

PinduoduoStatistics pinduoduoStatistics = new PinduoduoStatistics();

statisticsMap.put(pinduoduoStatistics.getType(), pinduoduoStatistics);

}

public PlatformStatistics getInstance(int platformType){

return statisticsMap.get(platformType);

}

public class Client {
    static PlatformFactory factory = new PlatformFactory();
    public static void main(String[] args) {
        PlatformStatistics instance = factory.getInstance(4);
        instance.yearSales("123456789");
    }
}

public class Client {

static PlatformFactory factory = new PlatformFactory();

public static void main(String[] args) {

PlatformStatistics instance = factory.getInstance(4);

instance.yearSales("123456789");

}

接口隔离原则

Interface Segregation Principle,即ISP。客户端不应该被迫实现一些它们用不到的接口。我们需要把胖接口分组，用多个细分的接口代替它，每个接口只服务于一个子模块，或者只提供一种功能。

案例

有一个设备事件接口DeviceEvent，里面有分别是设备开启、设备关闭、设备报警、开灯、改变温度这5个方法。Light类和Temperature类分别实现了这个接口，LightUse类依赖了Light类的turnOn()、turnOff()、turnColor()方法。TemperatureUse类依赖了Temperature类的turnOn()、turnOff()、changeTemperature()方法。

重构前UML图

重构前代码

/**
 * @author shaww 791202.com
 */
public interface DeviceEvent {

    /**
     * 设备启动
     */
    void turnOn();

    /**
     * 设备关闭
     */
    void turnOff();

    /**
     * 设备报警
     */
    void alarm();

    /**
     * 改变灯光颜色
     */
    void turnColor();

    /**
     * 改变温度
     */
    void changeTemperature();

}

/**

* @author shaww 791202.com

public interface DeviceEvent {

/**

* 设备启动

void turnOn();

/**

* 设备关闭

void turnOff();

/**

* 设备报警

void alarm();

/**

* 改变灯光颜色

void turnColor();

/**

* 改变温度

void changeTemperature();

}

public class Light implements DeviceEvent {
    @Override
    public void turnOn() {
        System.out.println("设备开启。。。");
    }

    @Override
    public void turnOff() {
        System.out.println("设备关闭。。。");
    }

    @Override
    public void alarm() {
        
    }

    @Override
    public void turnColor() {
        System.out.println("改变灯光颜色。。。");
    }

    @Override
    public void changeTemperature() {
        
    }
}

public class Light implements DeviceEvent {

@Override

public void turnOn() {

System.out.println("设备开启。。。");

}

@Override

public void turnOff() {

System.out.println("设备关闭。。。");

}

@Override

public void alarm() {

}

@Override

public void turnColor() {

System.out.println("改变灯光颜色。。。");

}

@Override

public void changeTemperature() {

}

public class LightUse {
    public void run(){
        DeviceEvent deviceEvent = new Light();
        deviceEvent.turnOn();
        deviceEvent.turnOff();
        deviceEvent.turnColor();
    }
}

public class LightUse {

public void run(){

DeviceEvent deviceEvent = new Light();

deviceEvent.turnOn();

deviceEvent.turnOff();

deviceEvent.turnColor();

}

public class Temperature implements DeviceEvent {
    @Override
    public void turnOn() {
        System.out.println("设备开启。。。");
    }

    @Override
    public void turnOff() {
        System.out.println("设备关闭。。。");
    }

    @Override
    public void alarm() {

    }

    @Override
    public void turnColor() {
        
    }

    @Override
    public void changeTemperature() {
        System.out.println("改变温度。。。");
    }
}

public class Temperature implements DeviceEvent {

@Override

public void turnOn() {

System.out.println("设备开启。。。");

}

@Override

public void turnOff() {

System.out.println("设备关闭。。。");

}

@Override

public void alarm() {

}

@Override

public void turnColor() {

}

@Override

public void changeTemperature() {

System.out.println("改变温度。。。");

}

public class TemperatureUse {
    public void run(){
        DeviceEvent deviceEvent = new Temperature();
        deviceEvent.turnOn();
        deviceEvent.turnOff();
        deviceEvent.changeTemperature();
    }
}

public class TemperatureUse {

public void run(){

DeviceEvent deviceEvent = new Temperature();

deviceEvent.turnOn();

deviceEvent.turnOff();

deviceEvent.changeTemperature();

}

存在的问题

1.Light类实现了DeviceEvent接口的alarm()和changeTemperature()方法，但确没有具体实现逻辑，因为它不需要这两个方法。同理，Temperature类也是一样，也有两个空方法。相当于多出来的空方法是强加给他们的。

2.DeviceEvent接口职责不清晰，不能笼统的让Light类和Temperature类实现它。

3.如果现在又增加了一种声控设备，那又会影响到Light类和Temperature类。

使用接口隔离原则进行重构

重构后的UML图

重构后代码

/**
 * @author shaww 791202.com
 */
public interface DeviceCommonEvent {

    /**
     * 设备启动
     */
    void turnOn();

    /**
     * 设备关闭
     */
    void turnOff();

}

/**

* @author shaww 791202.com

public interface DeviceCommonEvent {

/**

* 设备启动

void turnOn();

/**

* 设备关闭

void turnOff();

}

/**
 * @author shaww 791202.com
 */
public interface DeviceLightEvent {

    /**
     * 改变灯光颜色
     */
    void turnColor();

}

/**

* @author shaww 791202.com

public interface DeviceLightEvent {

/**

* 改变灯光颜色

void turnColor();

}

/**
 * @author shaww 791202.com
 */
public interface DeviceTempEvent {

    /**
     * 改变温度
     */
    void changeTemperature();

}

/**

* @author shaww 791202.com

public interface DeviceTempEvent {

/**

* 改变温度

void changeTemperature();

}

public class Light implements DeviceCommonEvent, DeviceLightEvent {
    @Override
    public void turnOn() {
        System.out.println("设备开启。。。");
    }

    @Override
    public void turnOff() {
        System.out.println("设备关闭。。。");
    }

    @Override
    public void turnColor() {
        System.out.println("改变灯光颜色。。。");
    }
}

public class Light implements DeviceCommonEvent, DeviceLightEvent {

@Override

public void turnOn() {

System.out.println("设备开启。。。");

}

@Override

public void turnOff() {

System.out.println("设备关闭。。。");

}

@Override

public void turnColor() {

System.out.println("改变灯光颜色。。。");

}

public class LightUse {
    public void run(){
        Light deviceEvent = new Light();
        deviceEvent.turnOn();
        deviceEvent.turnOff();
        deviceEvent.turnColor();
    }
}

public class LightUse {

public void run(){

Light deviceEvent = new Light();

deviceEvent.turnOn();

deviceEvent.turnOff();

deviceEvent.turnColor();

}

public class Temperature implements DeviceCommonEvent, DeviceTempEvent {
    @Override
    public void turnOn() {
        System.out.println("设备开启。。。");
    }

    @Override
    public void turnOff() {
        System.out.println("设备关闭。。。");
    }

    @Override
    public void changeTemperature() {
        System.out.println("改变温度。。。");
    }
}

public class Temperature implements DeviceCommonEvent, DeviceTempEvent {

@Override

public void turnOn() {

System.out.println("设备开启。。。");

}

@Override

public void turnOff() {

System.out.println("设备关闭。。。");

}

@Override

public void changeTemperature() {

System.out.println("改变温度。。。");

}

public class TemperatureUse {
    public void run(){
        Temperature deviceEvent = new Temperature();
        deviceEvent.turnOn();
        deviceEvent.turnOff();
        deviceEvent.changeTemperature();
    }
}

public class TemperatureUse {

public void run(){

Temperature deviceEvent = new Temperature();

deviceEvent.turnOn();

deviceEvent.turnOff();

deviceEvent.changeTemperature();

}

接口隔离原则的重点

1.一个类对另外一个类的依赖应该是建立在最小接口上的。不强迫接口实现类实现它们不需要的接口（出现空方法）。同时也可降低不同客户间的影响。

2.客户端程序不应该依赖它不需要的接口方法。

3.过于臃肿的接口设计是对接口的污染。

设计模式里的责任链模式的实际应用

前言

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

使用责任链模式是避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

实际使用

一个事件需要经过多个对象处理是一个挺常见的场景，譬如检验系统的检验流程。

电梯的检验流程

起重机检验流程

代码

github地址：https://github.com/shaweiwei/mall-tiny-docker-file

整体图

抽象流程处理类AbstractProcessHandler

/**
 * @author shamo
 */
@Data
public abstract class AbstractProcessHandler {

    protected ProcessStep processStep;
    protected AbstractProcessHandler nextProcessHandler;

    public void dealWithRequest(ProcessRequestDTO processRequestDTO){
        handle(processRequestDTO);
        if (nextProcessHandler != null){
            nextProcessHandler.dealWithRequest(processRequestDTO);
        }
    }

    abstract void handle(ProcessRequestDTO processRequestDTO);

}

/**

* @author shamo

@Data

public abstract class AbstractProcessHandler {

protected ProcessStep processStep;

protected AbstractProcessHandler nextProcessHandler;

public void dealWithRequest(ProcessRequestDTO processRequestDTO){

handle(processRequestDTO);

if (nextProcessHandler != null){

nextProcessHandler.dealWithRequest(processRequestDTO);

}

abstract void handle(ProcessRequestDTO processRequestDTO);

}

每个流程步骤对应的处理类

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author shamo
 */
@Slf4j
@Component
public class InspectionApplyHandler extends AbstractProcessHandler {

    public InspectionApplyHandler() {
        this.processStep = ProcessStep.INSPECTION_APPLY;
    }

    @Override
    void handle(ProcessRequestDTO processRequestDTO) {
        log.info("current step {}, content {}", processStep.getName(), processRequestDTO.toString());
    }
}

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;

/**

* @author shamo

@Slf4j

@Component

public class InspectionApplyHandler extends AbstractProcessHandler {

public InspectionApplyHandler() {

this.processStep = ProcessStep.INSPECTION_APPLY;

}

@Override

void handle(ProcessRequestDTO processRequestDTO) {

log.info("current step {}, content {}", processStep.getName(), processRequestDTO.toString());

}

import com.macro.mall.tiny.config.ProcessStep;
import com.macro.mall.tiny.dto.ProcessRequestDTO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author shamo
 */
@Slf4j
@Component
public class InstructionIssueHandler extends AbstractProcessHandler {
    public InstructionIssueHandler() {
        this.processStep = ProcessStep.INSTRUCTION_ISSUE;
    }

    @Override
    void handle(ProcessRequestDTO processRequestDTO) {
        log.info("current step {}, content {}", processStep.getName(), processRequestDTO.toString());
    }
}

import com.macro.mall.tiny.config.ProcessStep;

import com.macro.mall.tiny.dto.ProcessRequestDTO;

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;

/**

* @author shamo

@Slf4j

@Component

public class InstructionIssueHandler extends AbstractProcessHandler {

public InstructionIssueHandler() {

this.processStep = ProcessStep.INSTRUCTION_ISSUE;

}

@Override

void handle(ProcessRequestDTO processRequestDTO) {

log.info("current step {}, content {}", processStep.getName(), processRequestDTO.toString());

}


import com.macro.mall.tiny.config.ProcessStep;
import com.macro.mall.tiny.dto.ProcessRequestDTO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author shamo
 */
@Slf4j
@Component
public class InspectHandler extends AbstractProcessHandler {
    public InspectHandler() {
        this.processStep = ProcessStep.INSPECT;
    }

    @Override
    void handle(ProcessRequestDTO processRequestDTO) {
        log.info("current step {}, content {}", processStep.getName(), processRequestDTO.toString());
    }
}

import com.macro.mall.tiny.config.ProcessStep;

import com.macro.mall.tiny.dto.ProcessRequestDTO;

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;

/**

* @author shamo

@Slf4j

@Component

public class InspectHandler extends AbstractProcessHandler {

public InspectHandler() {

this.processStep = ProcessStep.INSPECT;

}

@Override

void handle(ProcessRequestDTO processRequestDTO) {

log.info("current step {}, content {}", processStep.getName(), processRequestDTO.toString());

}

/**
 * @author shamo
 */
@Slf4j
@Component
public class CheckHandler extends AbstractProcessHandler {
    public CheckHandler() {
        this.processStep = ProcessStep.CHECK;
    }

    @Override
    void handle(ProcessRequestDTO processRequestDTO) {
        log.info("current step {}, content {}", processStep.getName(), processRequestDTO.toString());
    }
}

/**

* @author shamo

@Slf4j

@Component

public class CheckHandler extends AbstractProcessHandler {

public CheckHandler() {

this.processStep = ProcessStep.CHECK;

}

@Override

void handle(ProcessRequestDTO processRequestDTO) {

log.info("current step {}, content {}", processStep.getName(), processRequestDTO.toString());

}

两个枚举类

/**
 * 流程步骤
 * @author shamo
 */
public enum ProcessStep {

    /**
     * 检测申请
     */
    INSPECTION_APPLY("0", "inspectionApply"),

    /**
     * 检测指令下发
     */
    INSTRUCTION_ISSUE("1", "instructionIssue"),

    /**
     * 检验员检验
     */
    INSPECT("2", "inspect"),

    /**
     * 审核人审核
     */
    CHECK("3", "check");

    private String code;
    private String name;

    ProcessStep(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public String getCode() {
        return code;
    }

    @Override
    public String toString() {
        return getName();
    }

}

/**

* 流程步骤

* @author shamo

public enum ProcessStep {

/**

* 检测申请

INSPECTION_APPLY("0", "inspectionApply"),

/**

* 检测指令下发

INSTRUCTION_ISSUE("1", "instructionIssue"),

/**

* 检验员检验

INSPECT("2", "inspect"),

/**

* 审核人审核

CHECK("3", "check");

private String code;

private String name;

ProcessStep(String code, String name) {

this.code = code;

this.name = name;

}

public String getName() {

return name;

}

public String getCode() {

return code;

}

@Override

public String toString() {

return getName();

}

/**
 * @author shamo
 */
public enum EquipmentType {

    /**
     * 检测申请
     */
    LIFT("0", "lift"),

    /**
     * end
     */
    CRANE("1", "crane");

    private String code;
    private String name;

    EquipmentType(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public String getCode() {
        return code;
    }

    @Override
    public String toString() {
        return getName();
    }

    public static EquipmentType getByCode(String code){
        for(EquipmentType processStep : EquipmentType.values()){
            if(code.equals(processStep.getCode())){
                return processStep;
            }
        }
        return  null;
    }
}

/**

* @author shamo

public enum EquipmentType {

/**

* 检测申请

LIFT("0", "lift"),

/**

* end

CRANE("1", "crane");

private String code;

private String name;

EquipmentType(String code, String name) {

this.code = code;

this.name = name;

}

public String getName() {

return name;

}

public String getCode() {

return code;

}

@Override

public String toString() {

return getName();

}

public static EquipmentType getByCode(String code){

for(EquipmentType processStep : EquipmentType.values()){

if(code.equals(processStep.getCode())){

return processStep;

}

return null;

}

service类和实现类

import com.macro.mall.tiny.config.EquipmentType;
import com.macro.mall.tiny.dto.ProcessRequestDTO;

public interface ProcessService {

    void dispose(EquipmentType equipmentType, ProcessRequestDTO processRequestDTO);

}

import com.macro.mall.tiny.config.EquipmentType;

import com.macro.mall.tiny.dto.ProcessRequestDTO;

public interface ProcessService {

void dispose(EquipmentType equipmentType, ProcessRequestDTO processRequestDTO);

}

import com.macro.mall.tiny.config.EquipmentType;
import com.macro.mall.tiny.dto.ProcessRequestDTO;
import com.macro.mall.tiny.handler.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

/**
 * @author shamo
 */
@Service
public class ProcessServiceImpl implements ProcessService {

    @Autowired
    private InspectionApplyHandler inspectionApplyHandler;

    @Autowired
    private InstructionIssueHandler instructionIssueHandler;

    @Autowired
    private InspectHandler inspectHandler;

    @Autowired
    private CheckHandler checkHandler;

    @Override
    public void dispose(EquipmentType equipmentType, ProcessRequestDTO processRequestDTO) {
        if (equipmentType == EquipmentType.LIFT){
            inspectionApplyHandler.setNextProcessHandler(instructionIssueHandler);
        }else{
            inspectionApplyHandler.setNextProcessHandler(inspectHandler);
        }
        instructionIssueHandler.setNextProcessHandler(inspectHandler);
        inspectHandler.setNextProcessHandler(checkHandler);
        inspectionApplyHandler.dealWithRequest(processRequestDTO);
    }
}

import com.macro.mall.tiny.config.EquipmentType;

import com.macro.mall.tiny.dto.ProcessRequestDTO;

import com.macro.mall.tiny.handler.*;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Service;

/**

* @author shamo

@Service

public class ProcessServiceImpl implements ProcessService {

@Autowired

private InspectionApplyHandler inspectionApplyHandler;

@Autowired

private InstructionIssueHandler instructionIssueHandler;

@Autowired

private InspectHandler inspectHandler;

@Autowired

private CheckHandler checkHandler;

@Override

public void dispose(EquipmentType equipmentType, ProcessRequestDTO processRequestDTO) {

if (equipmentType == EquipmentType.LIFT){

inspectionApplyHandler.setNextProcessHandler(instructionIssueHandler);

}else{

inspectionApplyHandler.setNextProcessHandler(inspectHandler);

}

instructionIssueHandler.setNextProcessHandler(inspectHandler);

inspectHandler.setNextProcessHandler(checkHandler);

inspectionApplyHandler.dealWithRequest(processRequestDTO);

}

DTO类

import lombok.Data;

import java.io.Serializable;
/**
 * @author shamo
 */
@Data
public class ProcessRequestDTO implements Serializable {

    private static final long serialVersionUID = 4498181465722961122L;

    private String taskId;

    // ...

}

import lombok.Data;

import java.io.Serializable;

/**

* @author shamo

@Data

public class ProcessRequestDTO implements Serializable {

private static final long serialVersionUID = 4498181465722961122L;

private String taskId;

// ...

}

Controller类

import com.macro.mall.tiny.config.EquipmentType;
import com.macro.mall.tiny.dto.ProcessRequestDTO;
import com.macro.mall.tiny.service.ProcessService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author shamo
 */
@RequestMapping("process")
@RestController
public class ProcessController {

    @Autowired
    private ProcessService processService;

    @PostMapping(value = "/dispose/{equipmentCode}")
    public void dispose(@RequestBody ProcessRequestDTO processRequestDTO, @PathVariable String equipmentCode) {
        processService.dispose(EquipmentType.getByCode(equipmentCode), processRequestDTO);
    }

}

import com.macro.mall.tiny.config.EquipmentType;

import com.macro.mall.tiny.dto.ProcessRequestDTO;

import com.macro.mall.tiny.service.ProcessService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

/**

* @author shamo

@RequestMapping("process")

@RestController

public class ProcessController {

@Autowired

private ProcessService processService;

@PostMapping(value = "/dispose/{equipmentCode}")

public void dispose(@RequestBody ProcessRequestDTO processRequestDTO, @PathVariable String equipmentCode) {

processService.dispose(EquipmentType.getByCode(equipmentCode), processRequestDTO);

}

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MallTinyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MallTinyApplication.class, args);
    }

}

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class MallTinyApplication {

public static void main(String[] args) {

SpringApplication.run(MallTinyApplication.class, args);

}

application.yml

server:
  port: 8047

1 2	server: port: 8047

启动后用postman测试

先测试电梯检验流程

2020-07-05 17:58:35.665  INFO 16156 --- [nio-8047-exec-7] c.m.m.t.handler.InspectionApplyHandler   : current step inspectionApply, content ProcessRequestDTO(taskId=1111)
2020-07-05 17:58:35.666  INFO 16156 --- [nio-8047-exec-7] c.m.m.t.handler.InstructionIssueHandler  : current step instructionIssue, content ProcessRequestDTO(taskId=1111)
2020-07-05 17:58:35.666  INFO 16156 --- [nio-8047-exec-7] c.m.mall.tiny.handler.InspectHandler     : current step inspect, content ProcessRequestDTO(taskId=1111)
2020-07-05 17:58:35.666  INFO 16156 --- [nio-8047-exec-7] c.macro.mall.tiny.handler.CheckHandler   : current step check, content ProcessRequestDTO(taskId=1111)

2020-07-05 17:58:35.665 INFO 16156 --- [nio-8047-exec-7] c.m.m.t.handler.InspectionApplyHandler : current step inspectionApply, content ProcessRequestDTO(taskId=1111)

2020-07-05 17:58:35.666 INFO 16156 --- [nio-8047-exec-7] c.m.m.t.handler.InstructionIssueHandler : current step instructionIssue, content ProcessRequestDTO(taskId=1111)

2020-07-05 17:58:35.666 INFO 16156 --- [nio-8047-exec-7] c.m.mall.tiny.handler.InspectHandler : current step inspect, content ProcessRequestDTO(taskId=1111)

2020-07-05 17:58:35.666 INFO 16156 --- [nio-8047-exec-7] c.macro.mall.tiny.handler.CheckHandler : current step check, content ProcessRequestDTO(taskId=1111)

再测试起重机检验流程

2020-07-05 17:58:51.338  INFO 16156 --- [nio-8047-exec-8] c.m.m.t.handler.InspectionApplyHandler   : current step inspectionApply, content ProcessRequestDTO(taskId=1111)
2020-07-05 17:58:51.338  INFO 16156 --- [nio-8047-exec-8] c.m.mall.tiny.handler.InspectHandler     : current step inspect, content ProcessRequestDTO(taskId=1111)
2020-07-05 17:58:51.339  INFO 16156 --- [nio-8047-exec-8] c.macro.mall.tiny.handler.CheckHandler   : current step check, content ProcessRequestDTO(taskId=1111)

2020-07-05 17:58:51.338 INFO 16156 --- [nio-8047-exec-8] c.m.m.t.handler.InspectionApplyHandler : current step inspectionApply, content ProcessRequestDTO(taskId=1111)

2020-07-05 17:58:51.338 INFO 16156 --- [nio-8047-exec-8] c.m.mall.tiny.handler.InspectHandler : current step inspect, content ProcessRequestDTO(taskId=1111)

2020-07-05 17:58:51.339 INFO 16156 --- [nio-8047-exec-8] c.macro.mall.tiny.handler.CheckHandler : current step check, content ProcessRequestDTO(taskId=1111)

总结

责任链的代码核心是nextHandler，这边因为我的两个链（电梯检验流程和起重机检验流程）是事先知道的，所以直接预先把每个handler的nexthandler设置好了。有的时候我们可能需要根据请求的具体参数（ProcessRequestDTO）里的不同属性值动态判断某个handler的nextHandler，那就可以在具体的Handler的重写的handle方法里根据参数决定set哪个handler为nextHandler。

标签：设计模式

Java 单例模式的实现方法总结，你青睐于哪种方式？

设计模式原则的开闭原则的理解

开闭原则

案例

重构前UML图

代码1

代码2

设计模式原则的接口隔离原则的理解

接口隔离原则

案例

重构前UML图

重构前代码

存在的问题

使用接口隔离原则进行重构

重构后的UML图

重构后代码

接口隔离原则的重点

设计模式里的责任链模式的实际应用

前言

实际使用

电梯的检验流程

起重机检验流程

代码

整体图

抽象流程处理类AbstractProcessHandler

每个流程步骤对应的处理类

两个枚举类

service类和实现类

DTO类

Controller类

启动类

application.yml

启动后用postman测试

先测试电梯检验流程

再测试起重机检验流程

总结