聊一聊責任鏈模式

責任鏈模式（Chain of Responsibility Pattern）是將鏈中每一個節點看作是一個對象，每個節點處理的請求均不同，且內部自動維護一個下一節點對象。

將一堆“事情”串聯在一起，有序執行，就叫責任鏈

一、概述

責任鏈模式（Chain of Responsibility Pattern）是將鏈中每一個節點看作是一個對象，每個節點處理的請求均不同，且內部自動維護一個下一節點對象。當一個請求從鏈式的首端發出時，會沿著鏈的路徑依次傳遞給每一個節點對象，直至有對象處理這個請求為止，屬于行為型模式。
下面放一張足球比賽的圖，通過層層傳遞，最終射門。通過這張圖，可以更好的理解責任鏈模式。

二、入門案例

2.1 類圖

2.2 基礎類介紹

抽象接口RequestHandler

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 13:41
 * @description
 */
public interface RequestHandler {

    void doHandler(String req);
}

抽象類BaseRequestHandler

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 13:45
 * @description
 */
public abstract class BaseRequestHandler implements RequestHandler {

    protected RequestHandler next;

    public void next(RequestHandler next) {
        this.next = next;
    }
}

具體處理類AHandler

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 14:00
 * @description
 */
public class AHandler extends BaseRequestHandler {

    @Override
    public void doHandler(String req) {
        // 處理自己的業務邏輯
        System.out.println("A中處理自己的邏輯");
        // 傳遞給下個類（若鏈路中還有下個處理類）
        if (next != null) {
            next.doHandler(req);
        }
    }
}

當然還有具體的處理類B、C等等，這里不展開贅述。
使用類Client

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 14:06
 * @description
 */
public class Client {
    public static void main(String[] args) {
        BaseRequestHandler a = new AHandler();
        BaseRequestHandler b = new BHandler();
        BaseRequestHandler c = new CHandler();
        a.next(b);
        b.next(c);
        a.doHandler("鏈路待處理的數據");
    }
}

2.3 處理流程圖

三、應用場景

3.1 場景舉例

場景一

前兩年，在一家金融公司待過一段時間，其中就有一個業務場景：一筆訂單進來，會先在后臺通過初審人員進行審批，初審不通過，訂單流程結束。初審通過以后，會轉給終審人員進行審批，不通過，流程結束；通過，流轉到下個業務場景。
對于這塊業務代碼，之前一代目是一個叫知了的同事，他擼起袖子就是干，一套if-else干到底。后來，技術老大CodeReview，點名要求改掉這塊。于是乎，想到用用設計模式吧，然后就噼里啪啦一頓改。（當然，比較復雜的情況，還是可以用工作流來處理這個場景，當時礙于時間成本，也就放棄了）。

場景二

上家公司對接甲方爸爸的時候，對方會調用我們接口，將數據同步過來。同樣，我們需要將處理好的數據，傳給他們。由于雙方傳輸數據都是加密傳輸，所以在接受他們數據之前，需要對數據進行解密，驗簽，參數校驗等操作。同樣，我們給他們傳數據也需要進行加簽，加密操作。

具體案例

話不多說，對于場景二，我來放一些偽代碼，跟大家一起探討下。
1、一切從注解開始，我這里自定義了一個注解@Duty,這個注解有spring的@Component注解，也就是標記了這個自定義注解的類，都是交給spring的bean容器去管理。
注解中，有兩個屬性：1.type，定義相同的type類型的bean，會被放到一個責任鏈集合中。2.order，同一個責任鏈集合中，bean的排序，數值越小，會放到鏈路最先的位置，優先處理。

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 16:11
 * @description
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Service
public @interface Duty {
    /**
     * 標記具體業務場景
     * @return
     */
    String type() default "";

    /**
     * 排序：數值越小，排序越前
     * @return
     */
    int order() default 0;
}

2、定義一個頂層的抽象接口IHandler，傳入2個泛型參數，供后續自定義。

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 15:31
 * @description 責任鏈頂層抽象類
 */
public interface IHandler<T, R> {
    /**
     * 抽象處理類
     * @param t
     * @return
     */
    R handle(T t);
}

3、定義一個責任鏈bean的管理類HandleChainManager，用來存放不同業務下的責任鏈路集合。在該類中，有一個Map和兩個方法。

handleMap：這個map會存放責任鏈路中，具體的執行類，key是注解@Duty中定義的type值，value是標記了@Duty注解的bean集合，也就是具體的執行類集合。
setHandleMap：傳入具體執行bean的集合，存放在map中。
executeHandle：從map中找到具體的執行bean集合，并依次執行。

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 16:00
 * @description 責任鏈管理類
 */
public class HandleChainManager {
    /**
     * 存放責任鏈路上的具體處理類
     * k-具體業務場景名稱
     * v-具體業務場景下的責任鏈路集合
     */
    private Map<String, List<IHandler>> handleMap;

    /**
     * 存放系統中責任鏈具體處理類
     * @param handlerList
     */
    public void setHandleMap(List<IHandler> handlerList) {
        handleMap = handlerList
                .stream()
                .sorted(Comparator.comparingInt(h -> AnnotationUtils.findAnnotation(h.getClass(), Duty.class).order()))
                .collect(Collectors.groupingBy(handler -> AnnotationUtils.findAnnotation(handler.getClass(), Duty.class).type()));
    }

    /**
     * 執行具體業務場景中的責任鏈集合
     * @param type 對應@Duty注解中的type，可以定義為具體業務場景
     * @param t 被執行的參數
     */
    public <T, R> R executeHandle(String type, T t) {
        List<IHandler> handlers = handleMap.get(type);
        R r = null;
        if (CollectionUtil.isNotEmpty(handlers)) {
            for (IHandler<T, R> handler : handlers) {
               r = handler.handle(t);
            }
        }
        return r;
    }
}

4、定義一個配置類PatternConfiguration，用于裝配上面的責任鏈管理器HandleChainManager。

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 15:35
 * @description 設計模式配置類
 */
@Configuration
public class PatternConfiguration {

    @Bean
    public HandleChainManager handlerChainExecute(List<IHandler> handlers) {
        HandleChainManager handleChainManager = new HandleChainManager();
        handleChainManager.setHandleMap(handlers);
        return handleChainManager;
    }

}

5、具體的處理類：SignChainHandler、EncryptionChainHandler、RequestChainHandler，這里我以SignChainHandler為例。
在具體處理類上標記自定義注解@Duty，該類會被注入到bean容器中，實現IHandler接口，只需關心自己的handle方法，處理具體的業務邏輯。

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/10/25 15:31
 * @description 加簽類
 */
@Duty(type = BusinessConstants.REQUEST, order = 1)
public class SignChainHandler implements IHandler<String, String> {
    /**
     * 處理加簽邏輯
     * @param s
     * @return
     */
    @Override
    public String handle(String s) {
        // 加簽邏輯
        System.out.println("甲方爸爸要求加簽");
        return "加簽";
    }
}

6、具體怎么調用？這里我寫了個測試controller直接調用，具體如下：

/**
 * @author 往事如風
 * @version 1.0
 * @date 2022/9/6 17:32
 * @description
 */
@RestController
@Slf4j
public class TestController {

    @Resource
    private HandleChainManager handleChainManager;

    @PostMapping("/send")
    public String duty(@RequestBody String requestBody) {
        String response = handleChainManager.executeHandle(BusinessConstants.REQUEST, requestBody);
        return response;
    }
}

7、執行結果，會按照注解中標記的order依次執行。

至此，完工。又可以開心的擼代碼了，然后在具體的執行類中，又是一頓if-else。。。

四、源碼中運用

4.1Mybatis源碼中的運用

Mybatis中的緩存接口Cache，cache作為一個緩存接口，最主要的功能就是添加和獲取緩存的功能，作為接口它有11個實現類，分別實現不同的功能，下面是接口源碼和實現類。

package org.apache.ibatis.cache;

import java.util.concurrent.locks.ReadWriteLock;

public interface Cache {
    String getId();

    void putObject(Object var1, Object var2);

    Object getObject(Object var1);

    Object removeObject(Object var1);

    void clear();

    int getSize();

    default ReadWriteLock getReadWriteLock() {
        return null;
    }
}

下面，我們來看下其中一個子類LoggingCache的源碼。主要看他的putObject方法和getObject方法，它在方法中直接傳給下一個實現去執行。這個實現類其實是為了在獲取緩存的時候打印緩存的命中率的。

public class LoggingCache implements Cache {
    private final Log log;
    private final Cache delegate;
    protected int requests = 0;
    protected int hits = 0;

    public LoggingCache(Cache delegate) {
        this.delegate = delegate;
        this.log = LogFactory.getLog(this.getId());
    }

    // ...
    public void putObject(Object key, Object object) {
        this.delegate.putObject(key, object);
    }

    public Object getObject(Object key) {
        ++this.requests;
        Object value = this.delegate.getObject(key);
        if (value != null) {
            ++this.hits;
        }

        if (this.log.isDebugEnabled()) {
            this.log.debug("Cache Hit Ratio [" + this.getId() + "]: " + this.getHitRatio());
        }

        return value;
    }
    // ...
}

最后，經過Cache接口各種實現類的處理，最終會到達PerpetualCache這個實現類。與之前的處理類不同的是，這個類中有一個map，在map中做存取，也就是說，最終緩存還是會保存在map中的。

public class PerpetualCache implements Cache {
    private final String id;
    private final Map<Object, Object> cache = new HashMap();

    public PerpetualCache(String id) {
        this.id = id;
    }

	// ...

    public void putObject(Object key, Object value) {
        this.cache.put(key, value);
    }

    public Object getObject(Object key) {
        return this.cache.get(key);
    }
	// ...

}

4.2spring源碼中的運用

4.2.1DispatcherServlet類

DispatcherServlet 核心方法 doDispatch。HandlerExecutionChain只是維護HandlerInterceptor的集合，可以向其中注冊相應的攔截器，本身不直接處理請求，將請求分配給責任鏈上注冊處理器執行，降低職責鏈本身與處理邏輯之間的耦合程度。

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;
		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		try {
			ModelAndView mv = null;
			Exception dispatchException = null;
			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);
				// Determine handler for the current request.
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}
				// Determine handler adapter for the current request.
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}
				// Actually invoke the handler.
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}
				applyDefaultViewName(processedRequest, mv);
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

4.2.2HandlerExecutionChain類

這里分析的幾個方法，都是從DispatcherServlet類的doDispatch方法中請求的。

獲取攔截器，執行preHandle方法

boolean applyPreHandle(HttpServletRequest request, 
                       HttpServletResponse response) throws Exception {
    HandlerInterceptor[] interceptors = this.getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for(int i = 0; i < interceptors.length; this.interceptorIndex = i++) {
            HandlerInterceptor interceptor = interceptors[i];
            if (!interceptor.preHandle(request, response, this.handler)) {
                this.triggerAfterCompletion(request, response, (Exception)null);
                return false;
            }
        }
    }
    return true;
}

在applyPreHandle方法中，執行triggerAfterCompletion方法

void triggerAfterCompletion(HttpServletRequest request, 
                            HttpServletResponse response, Exception ex) throws Exception {
    HandlerInterceptor[] interceptors = this.getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for(int i = this.interceptorIndex; i >= 0; --i) {
            HandlerInterceptor interceptor = interceptors[i];
            try {
                interceptor.afterCompletion(request, response, this.handler, ex);
            } catch (Throwable var8) {
                logger.error("HandlerInterceptor.afterCompletion threw exception", var8);
            }
        }
    }
}

獲取攔截器，執行applyPostHandle方法

void applyPostHandle(HttpServletRequest request, 
                     HttpServletResponse response, ModelAndView mv) 
                     throws Exception {
    HandlerInterceptor[] interceptors = this.getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for(int i = interceptors.length - 1; i >= 0; --i) {
            HandlerInterceptor interceptor = interceptors[i];
            interceptor.postHandle(request, response, this.handler, mv);
        }
    }
}

五、總結

5.1 優點

將請求與處理解耦。
請求處理者（節點對象）只需要關注自己感興趣的請求進行處理即可，對于不感興趣的請求，轉發給下一個節點。
具備鏈式傳遞處理請求功能，請求發送者無需知曉鏈路結構，只需等待請求處理結果。
鏈路結構靈活，可以通過改變鏈路的結構動態的新增或刪減責任。
易于擴展新的請求處理類（節點），符合開閉原則。

5.2 缺點

責任鏈太長或者處理時間過長，會影響整體性能。
如果節點對象存在循環引用時，會造成死循環，導致系統崩潰。

六、參考源碼

編程文檔：
https://gitee.com/cicadasmile/butte-java-note

應用倉庫：
https://gitee.com/cicadasmile/butte-flyer-parent

posted @ 2022-11-01 08:39 七號樓閱讀(904) 評論(0) 收藏舉報

刷新頁面返回頂部

七號樓

于是轉身獨立開發者。

聊一聊責任鏈模式

一、概述

二、入門案例

2.1 類圖

2.2 基礎類介紹

2.3 處理流程圖

三、應用場景

3.1 場景舉例

場景一

場景二

具體案例

四、源碼中運用

4.1Mybatis源碼中的運用

4.2spring源碼中的運用

4.2.1DispatcherServlet類

4.2.2HandlerExecutionChain類

五、總結

5.1 優點

5.2 缺點

六、參考源碼

公告

七號樓

于是轉身獨立開發者。

聊一聊責任鏈模式

一、概述

二、入門案例

2.1 類圖

2.2 基礎類介紹

2.3 處理流程圖

三、應用場景

3.1 場景舉例

場景一

場景二

具體案例

四、源碼中運用

4.1Mybatis源碼中的運用

4.2spring源碼中的運用

4.2.1DispatcherServlet類

4.2.2HandlerExecutionChain類

五、總結

5.1 優點

5.2 缺點

六、參考源碼

公告

二、入門案例

三、應用場景

四、源碼中運用

五、總結