2. 程式人生 > >實際專案中運用責任鏈模式 | 併發程式設計網

實際專案中運用責任鏈模式 | 併發程式設計網

阿新 • • 發佈：2018-12-16

1 模式概要

1.1 簡介

  • 責任鏈模式為請求建立一個接收者物件鏈，每個接收者都包含對另一個接收者的引用，如果一個物件不能處理該請求，那麼它會把請求傳給下一個接收者，依此類推
  • 責任鏈模式避免了請求的傳送者和接收者耦合在一起，讓多個物件都有可能接收請求，將這些物件連成一條鏈，並且沿著這條鏈傳遞請求，直到有物件處理它為止。

1.2 責任鏈模式優缺點

優點

降低耦合度。它將請求的傳送者和接收者解耦 簡化了物件，使得物件不需要知道鏈的結構 增強給物件指派職責的靈活性，允許動態地新增或者刪除責任鏈 增加新的請求處理類方便

缺點

不能保證請求一定被接收； 系統性能將受到一定影響，除錯時不方便，可能會造成迴圈呼叫

2 模式結構

2.1 物件定義

Handler（抽象處理者）： 定義一個處理請求的介面，提供對後續處理者的引用 ConcreteHandler（具體處理者）： 抽象處理者的子類，處理使用者請求，可選將請求處理掉還是傳給下家；在具體處理者中可以訪問鏈中下一個物件，以便請求的轉發

2.2 類圖及設計

責任鏈

程式碼詳解：

抽象處理者

public abstract class Handler {

    protected Handler nextHandler; // 下一個責任鏈成員

    public Handler getNextHandler() {
        return
 
 nextHandler;
    }

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    // 處理傳遞過來的時間
    public abstract void handleMessage(int type);
}

具體處理者 在當前處理者物件無法處理時，將執行權傳給下一個處理者物件

public class ConcreteHandler1 extends Handler {

    @Override
    public
 
 void handleMessage(int type) {
        if (type == 1 || type == 3) {
            System.out.println("ConcreteHandler1解決了問題！");
        } else {
            System.out.println("ConcreteHandler1解決不了問題......");
            if (nextHandler != null) {
                nextHandler.handleMessage(type);
            } else {
                System.out.println("沒有人能處理這個訊息");
            }
        }
    }
}

public class ConcreteHandler2 extends Handler {

    @Override
    public void handleMessage(int type) {
        if (type == 2 || type == 5) {
            System.out.println("ConcreteHandler2解決了問題！");
        } else {
            System.out.println("ConcreteHandler2解決不了問題......");
            if (nextHandler != null) {
                nextHandler.handleMessage(type);
            } else {
                System.out.println("沒有人能處理這個訊息");
            }
        }
    }
}

public class ConcreteHandler3 extends Handler {

    @Override
    public void handleMessage(int type) {
        if (type == 4 || type == 6) {
            System.out.println("ConcreteHandler3解決了問題！");
        } else {
            System.out.println("ConcreteHandler3解決不了問題......");
            if (nextHandler != null) {
                nextHandler.handleMessage(type);
            } else {
                System.out.println("沒有人能處理這個訊息");
            }
        }
    }
}

Client 客戶端呼叫

    // 初始化責任鏈：handler1 -> handler2 -> handler3
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        handler2.setNextHandler(handler3);
        handler1.setNextHandler(handler2);
        // 處理事件
        System.out.println("--------------Message1");
        handler1.handleMessage(1);
        System.out.println("--------------Message2");
        handler1.handleMessage(2);
        System.out.println("--------------Message3");
        handler1.handleMessage(4);
        System.out.println("--------------Message4");
        handler1.handleMessage(7);

從上述模式可以知道，當我們需要多個ifelse做邏輯判斷的時候，可以引入，從而提高程式碼可維護性

2.3 適用場景：

  • 有多個物件可以處理同一個請求，具體哪個物件處理該請求由執行時刻自動確定
  • 在不明確指定接收者的情況下，向多個物件中的某一個物件提交一個請求
  • 可動態指定一組物件的處理請求

3 Spring中的過濾器

我們來分析Spring中Filter的載入流程和執行流程

3.1 初始化流程

初始化過濾器載入資料流如下：

filter初始化載入時序圖

關鍵性程式碼

public void onStartup(ServletContext servletContext) throws ServletException {
        Filter filter = getFilter();
        Assert.notNull(filter, "Filter must not be null");
        String name = getOrDeduceName(filter);
        if (!isEnabled()) {
            this.logger.info("Filter " + name + " was not registered (disabled)");
            return;
        }
        //增加過濾器,資料流向 HashMap<String, FilterDef> filterDefs
        FilterRegistration.Dynamic added = servletContext.addFilter(name, filter);
        if (added == null) {
            this.logger.info("Filter " + name + " was not registered "
                    + "(possibly already registered?)");
            return;
        }
                //配置過濾器註冊資訊
        configure(added);
    }

configure()方法主要關注

  if (isMatchAfter) {
                context.addFilterMap(filterMap);
            } else {
                context.addFilterMapBefore(filterMap);
            }

不管是資料走哪裡，最終會通過 System.arraycopy 陣列擴容，增加過濾器資訊到private FilterMap[] array 這個陣列中。 最後呼叫StandardContext類中的 filterStart() 方法完成過濾器的初始化

3.2 執行過程

主要分兩步，建立過濾器責任鏈 和 執行責任鏈

3.2.1 建立過程

建立filterChain方法主要在ApplicationFilterFactory.createFilterChain(request, wrapper, servlet) 中，部分程式碼講解：

{
  // 獲取過濾器上下文
        StandardContext context = (StandardContext) wrapper.getParent();
       //獲取載入的過濾器列表
        FilterMap filterMaps[] = context.findFilterMaps();

        // If there are no filter mappings, we are done
        if ((filterMaps == null) || (filterMaps.length == 0))
            return (filterChain);

        //  獲取匹配的過濾器對映資訊
        DispatcherType dispatcher =
                (DispatcherType) request.getAttribute(Globals.DISPATCHER_TYPE_ATTR);

        String requestPath = null;
        Object attribute = request.getAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR);
        if (attribute != null){
            requestPath = attribute.toString();
        }

        String servletName = wrapper.getName();

        // 每個過濾器配置對應處理的請求路徑資訊
        for (int i = 0; i < filterMaps.length; i++) {
            if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
                continue;
            }
            if (!matchFiltersURL(filterMaps[i], requestPath))
                continue;
            ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
                context.findFilterConfig(filterMaps[i].getFilterName());
            if (filterConfig == null) {
                // FIXME - log configuration problem
                continue;
            }
            filterChain.addFilter(filterConfig);
        }

        // 配置對應servletName資訊，最後返回過濾器鏈
        for (int i = 0; i < filterMaps.length; i++) {
            if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
                continue;
            }
            if (!matchFiltersServlet(filterMaps[i], servletName))
                continue;
            ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
                context.findFilterConfig(filterMaps[i].getFilterName());
            if (filterConfig == null) {
                // FIXME - log configuration problem
                continue;
            }
            filterChain.addFilter(filterConfig);
        }

        // Return the completed filter chain
        return filterChain;
}

在StandardWrapperValue類的invoke()方法中呼叫ApplicationFilterChai類的createFilterChain()方法 在ApplicationFilterChai類的createFilterChain()方法中呼叫ApplicationFilterChain類的addFilter()方法 在ApplicationFilterChain類的addFilter()方法中給ApplicationFilterConfig陣列賦值

生成呼叫鏈

3.2.2 執行責任鏈

呼叫ApplicationFilterChain的 doFilter() 方法中最後會呼叫一個internalDoFilter() 方法，目的就是執行ApplicationFilterChain中的全部過濾器，從程式碼中可以發現它呼叫了 doFilter ，而在 doFilter 又會呼叫internalDoFilter 從而使所有Filter都得以呼叫

private void internalDoFilter(ServletRequest request,ServletResponse response) throws IOException, ServletException {

    // 如果存在下一個，繼續呼叫下一個過濾器
    if (pos < n) {
        ApplicationFilterConfig filterConfig = filters[pos++];
        try {
            Filter filter = filterConfig.getFilter();

            if (request.isAsyncSupported() && "false".equalsIgnoreCase(
                    filterConfig.getFilterDef().getAsyncSupported())) {
                request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
            }
            if( Globals.IS_SECURITY_ENABLED ) {
                final ServletRequest req = request;
                final ServletResponse res = response;
                Principal principal =
                    ((HttpServletRequest) req).getUserPrincipal();

                Object[] args = new Object[]{req, res, this};
                SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
            } else {
                // 此處呼叫Filter的doFilter()方法  / 而 doFilter 又會呼叫 internalDoFilter 直到呼叫完所有的過濾器
                filter.doFilter(request, response, this);
            }
        } catch (IOException | ServletException | RuntimeException e) {
            throw e;
        } catch (Throwable e) {
            e = ExceptionUtils.unwrapInvocationTargetException(e);
            ExceptionUtils.handleThrowable(e);
            throw new ServletException(sm.getString("filterChain.filter"), e);
        }
        return;
    }

    // 從最後一個開始呼叫
    try {
        if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
            lastServicedRequest.set(request);
            lastServicedResponse.set(response);
        }

        if (request.isAsyncSupported() && !servletSupportsAsync) {
            request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                    Boolean.FALSE);
        }
        // 包裝請求
        if ((request instanceof HttpServletRequest) &&
                (response instanceof HttpServletResponse) &&
                Globals.IS_SECURITY_ENABLED ) {
            final ServletRequest req = request;
            final ServletResponse res = response;
            Principal principal =
                ((HttpServletRequest) req).getUserPrincipal();
            Object[] args = new Object[]{req, res};
            SecurityUtil.doAsPrivilege("service", servlet, classTypeUsedInService,args, principal);
        } else {
            servlet.service(request, response);
        }
    } catch (IOException | ServletException | RuntimeException e) {
        throw e;
    } catch (Throwable e) {
        e = ExceptionUtils.unwrapInvocationTargetException(e);
        ExceptionUtils.handleThrowable(e);
        throw new ServletException(sm.getString("filterChain.servlet"), e);
    } finally {
        if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
            lastServicedRequest.set(null);
            lastServicedResponse.set(null);
        }
    }
}

這樣，一個完整的過濾器鏈就形成，然後進行呼叫

4 專案中的實際運用

業務場景

我們在專案中使用了阿里的MQ訊息中介軟體，來加快請求的響應時間和非同步解耦處理。RocktMQ主要可以按Topic來分割槽，然後按Tag分組，不同的業務區分不同的tag 比如： 簡訊類的訊息 messageTag 手機推送訊息 pushTag 延時任務訊息 delayTag 等等。。。

常規寫法

if(message.getTag() == messageTag){
 //doSomething
}else if(message.getTag() == pushTag){
 //doSomething
}else if (message.getTag() == delayTag){
 //doSomething
}
....

要是ifelse多了，最後會形成箭頭程式碼，最後連自己都不知道邏輯了。所以我就想到了責任鏈模式，剛好符合我們的實際場景。

具體設計方案如下：

設計UML類圖

類圖

抽象公共監聽器，主要用到了單例模式獲取常量

public abstract class AbstractCommonListener {

    private ParametersDO parametersDO;

    protected AbstractCommonListener() {
        //獲取單例物件
        this.parametersDO = ParametersDO.getInstance();
    }

     public final String getAccessKey() {
        return parametersDO.getAccessKey();
    }

    public final String getSecretKey() {
        return  parametersDO.getSecretKey();
    }

    public final String getConsumerId() {
        return parametersDO.getConsumerId();
    }

    public final String getONSAddr() {
        return parametersDO.getONSAddr();
    }

    public final String getTopic() {
        return parametersDO.getTopic();
    }


}


class ParametersDO{

    private static volatile boolean initialize = false;

    private String accessKey;

    private String secretKey;

    private String consumerId;

    private String ONSAddr;

    private String topic;

    private ParametersDO() {

        synchronized (ParametersDO.class) {
            if (!initialize) {
                this.accessKey = BundleUtil.getResult("mq.accesskey");
                this.consumerId = BundleUtil.getResult("mq.public.consumer.id");
                this.ONSAddr = BundleUtil.getResult("mq.ons.addr");
                this.topic = BundleUtil.getResult("mq.public.topic");
                this.secretKey = BundleUtil.getResult("mq.secretkey");
                initialize = !initialize;
            } else {
                throw new RuntimeException("ParametersDO單例已被破壞");
            }

        }

    }

    static ParametersDO getInstance() {
        return ListenerHolder.INSTANCE;
    }

    private static class ListenerHolder{
        private static final ParametersDO INSTANCE = new ParametersDO();
    }


    final String getAccessKey() {
        return accessKey;
    }

    final String getSecretKey() {
        return secretKey;
    }

    final String getConsumerId() {
        return consumerId;
    }

    final String getONSAddr() {
        return ONSAddr;
    }

    final String getTopic() {
        return topic;
    }

}

具體監聽器，監聽器主要用於MQ監聽消費Topic

public class GlobalOrderListener extends AbstractCommonListener implements MessageOrderListener {

    @Override
    public OrderAction consume(Message message, ConsumeOrderContext context) {

        //新增處理消費tag 只需新增Handler
        AbstractMessageHandler<OrderAction, Message> handler = HandlerFactory.getHandlerResponsibilityChain(
                        JpushOrderHandler.class,
                        DelayRemoveOrderHandler.class);
        return handler.handleMessage(message);
    }
}

正常情況下，我們會在consume()方法中區分tag來做不同業務的資料處理

抽象處理者

/**
 * @author nicky_chin [[email protected]]
 * @since --created on 2018/6/26 at 14:42
 * 責任鏈抽象類
 */
public abstract class AbstractMessageHandler<T, R> extends AbstractCommonListener {

    /**
     * 下一個責任鏈成員
     */
    protected AbstractMessageHandler<T, R> nextHandler;

    public AbstractMessageHandler getNextHandler() {
        return nextHandler;
    }

    public void setNextHandler(AbstractMessageHandler<T, R> nextHandler) {
        this.nextHandler = nextHandler;
    }

    /**
     * 處理傳遞過來的tag
     * @param message 表示式
     * @return T
     */
    public abstract T handleMessage(R message);

}

具體處理者 :推送訊息Handler

@Slf4j
public class JpushOrderHandler extends AbstractMessageHandler<OrderAction, Message> {

    @Override
    public OrderAction handleMessage(Message message) {
        String tagList = BundleUtil.getResult("mq.tag");
        String[] tags = tagList.split(",");
        if (message.getTopic().equals(getTopic()) && Arrays.asList(tags).contains(message.getTag())) {  //避免消費到其他訊息 json轉換報錯
            log.info(" 監聽到推送訊息,[topic:" + message.getTopic() + "], [tag:" + message.getTag() + "]。開始解析...");
            try {
                // res 是生產者傳過來的訊息內容
                byte[] body = message.getBody();
                String res = new String(body);
                String substring = res.substring(res.length() -1, res.length());
                PushInfo info = JSON.parseObject(res.substring(0, res.length() - 1), PushInfo.class);
  
                if ("1".equals(substring)){
                    // 分組推送
                    CommonUtil.Jpush2SingleUserMq(info,true);
                 }else {
                 //  多個使用者推送
                    CommonUtil.Jpush2SingleUserMq(info,false);
                }
                return OrderAction.Success;
            }catch (Exception e) {
                log.error("MessageListener.consume error:" + e.getMessage(), e);
                return OrderAction.Suspend;
            }
        } else {
           if (nextHandler == null) {
               log.info("未匹配到topic:{}, tag:{}跳過,",message.getTopic(), message.getTag());
               return OrderAction.Success;
           }
           return nextHandler.handleMessage(message);
       }
    }
}

具體處理者 :延時訂單處理Handler

@Slf4j
public class DelayRemoveOrderHandler extends AbstractMessageHandler<OrderAction, Message> {

    private static Lock lock = new ReentrantLock(true);

    @Override
    public OrderAction handleMessage(Message message) {
        //消費延時訂單tag
        if (message.getTopic().equals(getTopic()) && message.getTag().equals(CommonConstants.TAG)) {
            log.info(" 監聽訂單刪除訊息,[topic:" + message.getTopic() + "], [tag:" + message.getTag() + "]。開始解析...");
            //userId + UNDER_BAR + borrowOrderId
            try {
                String content = new String(message.getBody(), Charsets.UTF_8);
                log.info("消費內容 userId_borrowOrderId :{}", content);
                if (StringUtils.isEmpty(content)) {
                    return OrderAction.Success;
                }
                String[] info = content.split(CommonConstants.UNDER_BAR);
                String userId = info[0];
                String key = CommonConstants.CART_ID_LIST + userId;

                lock.tryLock(3, TimeUnit.SECONDS);
                //查詢使用者購物車列表
                String orders = RedisUtil.getString(key);
                if (StringUtils.isEmpty(orders)) {
                    return OrderAction.Success;
                }
                List<Integer> orderList = JSONObject.parseArray(orders, Integer.class);
                List<Integer> delList;
                String idStr = info[1];
                //判斷是否是批量加入
                if (idStr.startsWith(CommonConstants.LIST_MARK)) {
                    String[] s = content.split(CommonConstants.LIST_MARK);
                    delList = JSONObject.parseArray(s[1], Integer.class);
                } else {
                    delList = Collections.singletonList(Integer.valueOf(info[1]));
                }
                orderList.removeAll(delList);
                RedisUtil.setString(key, GsonUtil.objectConvertJson(orderList));
                log.info("刪除使用者:{},延時訂單:{},成功", userId, delList.toString());
                return OrderAction.Success;
            } catch (Exception e) {
                //消費失敗，掛起當前佇列
                log.error("延時訂單:{}消費異常", new String(message.getBody(), Charsets.UTF_8));
                return OrderAction.Suspend;
            } finally {
                lock.unlock();
            }

        } else {
            if (nextHandler == null) {
                log.info("未匹配到topic:{}, tag:{}跳過,",message.getTopic(), message.getTag());
                return OrderAction.Success;
            }
           return nextHandler.handleMessage(message);
        }
    }
}

模式工廠 HandlerFactory

public final class HandlerFactory {

    private static TypeConverterManager typeConverterManager = JoddBean.get().typeConverterManager();


    public static  <T, R>AbstractMessageHandler newJpushOrderHandler(){
        return new JpushOrderHandler();
    };

    public static <T, R>AbstractMessageHandler newDelayRemoveOrderHandler(){
        return new DelayRemoveOrderHandler();
    }

    /**
     * 責任鏈模式
     */
    @SafeVarargs
    public static <T, R>AbstractMessageHandler<T, R> getHandlerResponsibilityChain(Class< ? extends AbstractMessageHandler<T, R>> ... handlers ) {

        Preconditions.checkNotNull(handlers, "handler列表不能為空");
        if (handlers.length == CommonConstants.TRUE) {
            return BeanUtils.instantiate(handlers[CommonConstants.FIRST_ELEMENT]);
        }
        List<Object> list = Arrays.stream(handlers).map(BeanUtils::instantiate).collect(Collectors.toList());
        AbstractMessageHandler<T, R> result = null;
        for (int i = 1; i < list.size(); i++) {
            AbstractMessageHandler<T, R> pre = typeConverterManager.convertType(list.get(i - 1), handlers[i - 1]);
            AbstractMessageHandler<T, R> cur = typeConverterManager.convertType(list.get(i), handlers[i]);
            cur.setNextHandler(pre);
            result = cur;
        }
        return result;
    }
}

getHandlerResponsibilityChain() 主要是建立責任鏈，動態生成自己想要的邏輯責任鏈

客戶端呼叫

public class RoborderConsumerAdapter{

    private OrderConsumer orderConsumer;

    public RoborderConsumerAdapter(OrderConsumer orderConsumer) {
        Assert.notNull(orderConsumer, "orderConsumer is null");
        this.orderConsumer = orderConsumer;
    }

    /**
     * 消費
     */
    public void consumerMessages(){
        AbstractCommonListener listener = BeanUtils.instantiate(GlobalOrderListener.class);
        this.orderConsumer.subscribe(listener.getTopic(), "*", (MessageOrderListener) listener);
    }

}

按這種設計方式，如果有一個新的業務處理場景，只需新增新的一個Handler實現抽象處理者就好，然後呼叫getHandlerResponsibilityChain()的時候，加入想要使用的Handler，就能處理，這樣不會導致多人維護程式碼時，出現邏輯混亂問題，業務直接解耦，減少開發和維護成本

Reference

nicky_chin野生Java程式設計師逆襲之路個人部落格：https://nicky-chen.github.io/
nicky_chin

Latest posts by nicky_chin

相關推薦

實際專案中運用責任鏈模式 | 併發程式設計網

1 模式概要 1.1 簡介 責任鏈模式為請求建立一個接收者物件鏈，每個接收者都包含對另一個接收者的引用，如果一個物件不能處理該請求，那麼它會把請求傳給下一個接收者，依此類推 責任鏈模式避免了請求的傳送者和接收者耦合在一起，讓多個物件都有可能接收請求，將這些物件連成一條鏈，並且沿著這條鏈傳遞請

怎樣實際專案中運用責任鏈模式

1 模式概要 1.1 簡介 責任鏈模式為請求建立一個接收者物件鏈，每個接收者都包含對另一個接收者的引用，如果一個物件不能處理該請求，那麼它會把請求傳給下一個接收者，依此類推 責任鏈模式避免了請求的傳送者和接收者耦合在一起，讓多個物件都有可能接收請求，將這些物件連成一條鏈，並且沿著這條鏈傳遞請

Netty中的責任鏈模式

適用場景: 對於一個請求來說,如果有個物件都有機會處理它,而且不明確到底是哪個物件會處理請求時,我們可以考慮使用責任鏈模式實現它,讓請求從鏈的頭部往後移動,直到鏈上的一個節點成功處理了它為止 優點: 傳送者不需要知道自己傳送的這個請求到底會被哪個物件處理掉,實現了傳送者和接受者的解耦 簡化了傳送者物件的

如何在C#/.NET Core中使用責任鏈模式

> 原文：[Chain Of Responsbility Pattern In C#/.NET Core](https://dotnetcoretutorials.com/2020/04/19/chain-of-responsbility-pattern-in-c-net-core/) > 作者：**Wade

責任鏈模式在專案中的實際應用(Java)

1.責任鏈模式 首先簡單介紹一下責任鏈模式。 定義：使多個物件都有機會處理請求，從而避免了請求的傳送者和接受者之間的耦合關係。將這些物件連成一條鏈，並沿著這條鏈傳遞該請求，直到有物件處理它為止。將所有處理者形成一條鏈，在鏈中決定哪個物件能夠處理請求，並返回結果，不能處理則

設計模式-責任鏈模式在實際項目中的使用

模式 getc erro build strac orm collected pack server 　　最近一次叠代，參與了公司數據應用平臺的開發，其中負責的一塊功能早早的就完成了代碼的編寫工作，即將進入測試階段，因為有時間思考和總結代碼編寫中遇到的難題，便想著將代碼做一

責任鏈模式和工廠模式在處理被動響應訊息中的應用

        在公眾號建設中，傳送被動響應訊息是最核心的環節，使用者主動發給微信的訊息經微信伺服器處理後，統一變成xml格式的報文，微信公眾平臺後臺需要對這些報文進行分別處理，然後組織響應報文響應給使用者，同時針對某些特殊操作的行為需要修改資料庫的某些資訊。      

責任鏈模式在 iOS 中的應用

名稱 責任鏈模式 Chain of Responsibility Pattren 用途 解耦訊息的傳送者和接受者。 讓多個物件有機會處理某個請求（UI 響應鏈、Planck 中介軟體、流式

實際專案中手動測試和自動測試的合理運用

一、手動測試         手動測試，就是指完全依賴人工測試軟體，主要根據測試用例來執行測試，但是測試用例也不可能100%覆蓋軟體功能還要通過其他方式來發現軟體缺陷，這樣就要求測試人員的經驗要豐富並且具有發散思維的能力，通過錯誤猜測等方法來彌補測試用例沒有覆蓋的部分。 手

iOS開發多執行緒在實際專案中的運用

在實際專案開發中為了能夠給使用者更好的體驗，有些延時操作我們都會放在子執行緒中進行。 今天我們就來聊聊多執行緒在實際專案中的運用。 我們先來看看多執行緒的基礎知識： 1.多執行緒的原理：      

淺談springMVC中的設計模式(1)——責任鏈模式

最近終於閒了下來，準備自己記錄些東西。網上關於springMVC的資料很多，但關於設計模式的還有限，我就想把springMVC原始碼中的設計模式抽出來做成一個系列，簡單的談一下其中的實現原理，作為一種學習分享，以後有更深的感悟也會更新。 先從一張圖對整個spr

工廠模式與抽象工廠在實際專案中的應用

在面向物件程式設計中, 最通常的方法是一個new操作符產生一個物件例項,new操作符就是用來構造物件例項的。但是在一些情況下, new操作符直接生成物件會帶來一些問題。舉例來說, 許多型別物件的創造需要一系列的步驟: 你可能需要計算或取得物件的初始設定; 比如在我的一個報表

非同步併發利器：實際專案中使用CompletionService提升系統性能的一次實踐

場景 隨著網際網路應用的深入，很多傳統行業也都需要接入到網際網路。我們公司也是這樣，保險核心需要和很多保險中介對接，比如阿里、京東等等。這些公司對於介面服務的效能有些比較高的要求，傳統的核心無法滿足要求，所以資訊科技部領導高瞻遠矚，決定開發網際網路接入服務，滿足來自效能的需求。 概念 CompletionSe

重學 Java 設計模式：實戰責任鏈模式「模擬618電商大促期間，專案上線流程多級負責人審批場景」

![](https://img-blog.csdnimg.cn/20200618222937768.png) 作者：小傅哥 部落格：[https://bugstack.cn](https://bugstack.cn) - `原創系列專題文章` >沉澱、分享、成長，讓自己和他人都能有所收穫！

Java設計模式應用——責任鏈模式

調用 stat 事務 抽象類 pan 主動 需要 return 包含 生產一個產品，需要依次執行多個步驟，才能完成，那麽是使用責任鏈模式則是極好的。 在性能告警模塊開發過程中，創建一條告警規則需要執行閾值解析，中間表生成，流任務生成，規則入庫，告警事件入庫等諸多操作。如果把

設計模式—責任鏈模式

[] .com repl ring replace servlet 就業 返回 array 責任鏈將處理請求在鏈條的節點上傳遞，每到一個節點可被處理或者也可不被處理。 典型的是在servlet中過濾器filter的的處理方式。當request請求或者response請求時，

設計模式之責任鏈模式

設計模式 責任鏈模式 chain of responsibility 1、責任鏈模式 chainOfResponsiblity : a、責任鏈模式屬於行為型模式，行為型模式關註系統中對象之間的相互交互，研究系統在運行時對象之間的相互通信和協作，進一步明確對象的職責，共有11中模式。 b

跟我學設計模式視頻教程——管擦者模式（下），責任鏈模式（上）

tar eight color font content 設計模式 name -m ack 課程視頻 觀察者模式（下） 責任鏈模式（上） 課程筆記 課程筆記 課程代碼 課程代碼 新課程火熱報名中 課程介紹

責任鏈模式（chain of responsbility）

src private ons wan resp ring bject send 都是 責任鏈模式定義如下： 　　avoid coupling the sender of a request to its receiver by giving more than one o

請求的鏈式處理——責任鏈模式

next return pop extend pri fin 職責 人員 spa 什麽是責任鏈模式 職責鏈能夠是一條直線、一個環或者一個樹形結構，最常見的職責鏈是直線型。即沿著一條單向的鏈來傳遞請求。鏈上的每個對象都是請求處理者。職責鏈模式能夠將請求的