Java 設計模式之責任鏈模式及異步責任鏈詳解

更新時間：2021年11月08日 14:27:38 作者：普通人zzz~

顧名思義，責任鏈模式（Chain of Responsibility Pattern）為請求創(chuàng)建了一個接收者對象的鏈。這種模式給予請求的類型，對請求的發(fā)送者和接收者進行解耦。這種類型的設計模式屬于行為型模式

一、定義

責任鏈模式(Chain of Responsibility Pattern)：避免將一個請求的發(fā)送者與接受者耦合在一起，讓多個對象都有機會處理請求。將接受請求的對象連接成一條鏈，并且沿著這條鏈傳遞請求，直到有一個對象能夠處理它為止。

在很多源碼都有涉及，如Mybatis攔截器、Filter…

在這里插入圖片描述

責任鏈模式屬于行為型模式。

二、普通責任鏈模式

在這里插入圖片描述

抽象處理類：AbstractProcessor

/**
 * 抽象處理類
 */
public abstract class AbstractProcessor {
    // 責任鏈
    private AbstractProcessor nextProcessor;

    public void setNextProcessor(AbstractProcessor nextProcessor){
        this.nextProcessor = nextProcessor;
    }

    /**
     * 鏈路調(diào)用
     * @param obj
     */
    public void execute(Object obj) {
        this.processor(obj);
        if (this.nextProcessor != null){
            this.nextProcessor.execute(obj);
        }
    }

    public abstract void processor(Object obj);
}

具體類：ParamsProcessor、CheckProcessor、FinalProcessor

public class ParamsProcessor extends AbstractProcessor{

    @Override
    public void processor(Object obj) {
        System.out.println("paramsProcessor>>>>>>>>>>" + obj.toString());
    }
}

public class CheckProcessor extends AbstractProcessor{

    @Override
    public void processor(Object obj) {
        System.out.println("checkProcessor>>>>>>>>>>" + obj.toString());
    }
}

public class FinalProcessor extends AbstractProcessor{

    @Override
    public void processor(Object obj) {
        System.out.println("finalProcessor>>>>>>>>>>" + obj.toString());
    }
}

測試類：ProcessorMainTest

public class ProcessorMainTest {
    public static void main(String[] args) {
        /**
         * 構(gòu)建一個鏈路
         * paramsProcessor -> checkProcessor -> finalProcessor
         */
        AbstractProcessor paramsProcessor = new ParamsProcessor();
        AbstractProcessor checkProcessor = new CheckProcessor();
        AbstractProcessor finalProcessor = new FinalProcessor();

        paramsProcessor.setNextProcessor(checkProcessor);
        checkProcessor.setNextProcessor(finalProcessor);

        paramsProcessor.execute("Java責任鏈模式");
    }
}

執(zhí)行結(jié)果

paramsProcessor>>>>>>>>>>Java責任鏈模式
checkProcessor>>>>>>>>>>Java責任鏈模式
finalProcessor>>>>>>>>>>Java責任鏈模式

三、異步責任鏈模式

異步責任鏈模式采用責任鏈模式、生產(chǎn)者消費者模式組合。

在這里插入圖片描述

抽象處理類：AbstractAsynProcessor

/**
 * 異步責任鏈：采用線程、生產(chǎn)者消費者模式實現(xiàn)
 */
public abstract class AbstractAsynProcessor extends Thread {
    // 用于存放當前責任鏈需要處理的對象
    protected BlockingQueue<Object> queue;
    // 鏈路對象
    private AbstractAsynProcessor nextProcessor;

    /**
     * 執(zhí)行
     *
     * @param obj
     */
    public void execute(Object obj) throws InterruptedException {
        this.processor(obj);
        if (this.nextProcessor != null) {
            this.nextProcessor.getQueue().put(obj);
        }
    }

    @Override
    public void run() {
        // 執(zhí)行
        try {
            while (true) {
                // 生產(chǎn)者消費者
                Object obj = this.queue.take();
                execute(obj);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public abstract void processor(Object obj);

    public BlockingQueue<Object> getQueue() {
        return queue;
    }

    public void setNextProcessor(AbstractAsynProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }
}

具體類：AsynParamsProcessor、AsynCheckProcessor、AsynFinalProcessor

public class AsynParamsProcessor extends AbstractAsynProcessor {

    public AsynParamsProcessor() {
        // 初始化隊列
        this.queue = new LinkedBlockingQueue<>();
    }

    @Override
    public void processor(Object obj) {
        System.out.println("asynParamsProcessor>>>>>>>>>>" + obj.toString());
    }
}

public class AsynCheckProcessor extends AbstractAsynProcessor {

    public AsynCheckProcessor(){
        this.queue = new LinkedBlockingQueue<>();
    }

    @Override
    public void processor(Object obj) {
        System.out.println("asynCheckProcessor>>>>>>>>>>" + obj.toString());
    }
}

public class AsynFinalProcessor extends AbstractAsynProcessor {

    public AsynFinalProcessor() {
        this.queue = new LinkedBlockingQueue<>();
    }

    @Override
    public void processor(Object obj) {
        System.out.println("asynFinalProcessor>>>>>>>>>>" + obj.toString());
    }
}

測試類：AsynProcessorMainTest

public class AsynProcessorMainTest {
    public static void main(String[] args) throws InterruptedException {
        /**
         * 構(gòu)建一個鏈路
         * asynParamsProcessor -> asynCheckProcessor -> asynFinalProcessor
         */
        AbstractAsynProcessor asynParamsProcessor = new AsynParamsProcessor();
        asynParamsProcessor.start();
        AbstractAsynProcessor asynCheckProcessor = new AsynCheckProcessor();
        asynCheckProcessor.start();
        AbstractAsynProcessor asynFinalProcessor = new AsynFinalProcessor();
        asynFinalProcessor.start();

        asynParamsProcessor.setNextProcessor(asynCheckProcessor);
        asynCheckProcessor.setNextProcessor(asynFinalProcessor);

        Scanner input = new Scanner(System.in);
        while (true) {
            Thread.sleep(1000);
            System.out.print("請輸入：");
            asynParamsProcessor.getQueue().put(input.next());
        }
    }
}

執(zhí)行結(jié)果