责任链模式的应用

- 日理万妓 2023-02-16 00:57 14阅读 0赞

### 概念 ###

责任链模式是一种对象的行为模式，就是用来处理相关事务责任的一条执行链，执行链上有多个节点，每个节点都有机会（条件匹配）处理请求事务，如果某个节点处理完了就可以根据实际业务需求传递给下一个节点继续处理或者返回处理完毕。

### 场景 ###

我们在遇到需要对一条数据进行处理，处理到一个标准，直到这个获取的结果满足这个标准。

### 实现 ###

1、定义一个抽象处理器，来规定具体需要处理的方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70]

2、HandlerChainContext handler上下文，主要负责维护链，和链的执行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 1]  
1、处理器

// 处理器抽象类
    public abstract class AbstractHandler<T> {
        /**
         * 处理器，这个处理器就做一件事情
         */
        // handler方法
        abstract T doHandler(HandlerChainContext<T> handlerChainContext, Object arg0);
    }
    
    
    @Component
    @Order(10)
    class Handler1 extends AbstractHandler<String> {
        @Override
        String doHandler(HandlerChainContext<String> handlerChainContext, Object arg0) {
            arg0 = arg0.toString() + "..handler1的处理结果.....";
            System.out.println("我是Handler1的实例，我在处理：" + arg0);
            if (String.valueOf(arg0).length() > 20) {
                return String.valueOf(arg0);
            }
            // 继续执行下一个
           return handlerChainContext.runNext(arg0);
        }
    }
    
    @Component
    @Order(20)
    class Handler2 extends AbstractHandler<String> {
        @Override
        String doHandler(HandlerChainContext<String> handlerChainContext, Object arg0) {
            arg0 = arg0.toString() + "..handler2的处理结果.....";
            System.out.println("我是Handler2的实例，我在处理：" + arg0);
            if (String.valueOf(arg0).length() > 20) {
                return String.valueOf(arg0);
            }
            // 继续执行下一个
            return handlerChainContext.runNext(arg0);
        }
    
    
    }

2、handler上下文

/**
     * handler上下文，主要负责维护链，和链的执行
     */
    public class HandlerChainContext<T> {
    
        // 下一个节点
        HandlerChainContext<T> next;
        AbstractHandler<T> handler;
    
        /**
         * 初始化的时候造一个head，作为责任链的开始，但是并没有具体的处理
         */
        public HandlerChainContext head;
    
        public HandlerChainContext() {
           this.head = new HandlerChainContext<T>(new AbstractHandler<T>() {
                @Override
                T doHandler(HandlerChainContext<T> handlerChainContext, Object arg0) {
                    return   handlerChainContext.runNext(arg0);
                }
            });
        }
    
        public HandlerChainContext(AbstractHandler handler) {
            this();
            this.handler = handler;
        }
    
       public T handler(Object arg0) {
           return this.handler.doHandler(this, arg0);
        }
    
        /**
         * 继续执行下一个
         */
         T runNext(Object arg0) {
            if (this.next != null) {
               return this.next.handler(arg0);
            }
             return null;
        }
    
    
    
        public T requestProcess(Object arg0) {
            return (T) this.head.handler(arg0);
        }
    
        public void addLast(AbstractHandler handler) {
            HandlerChainContext context = head;
            while (context.next != null) {
                context = context.next;
            }
            context.next = new HandlerChainContext(handler);
        }
    
    }

3、客户端

@Service
    public class ChainModelDemo {
    
    
        @Autowired
        private List<AbstractHandler> handlerList;
    
    
    
    
        @PostConstruct
        public void adjustChainOrder(){
            handlerList = Optional.ofNullable(handlerList).orElseGet(ArrayList::new);
            handlerList.sort(AnnotationAwareOrderComparator.INSTANCE);
            HandlerChainContext<String> handlerChainContext = new HandlerChainContext();
            for (AbstractHandler handler : handlerList) {
                handlerChainContext.addLast(handler);
            }
            String result = handlerChainContext.requestProcess("执行入参");
            System.out.println(result);
        }
    }

执行结果

![在这里插入图片描述][20200607004114485.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200607003043992.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200607003124556.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU=,size_16,color_FFFFFF,t_70
[20200607004114485.png]: https://img-blog.csdnimg.cn/20200607004114485.png