责任链模式的应用

1、定义一个抽象处理器，来规定具体需要处理的方法。

2、HandlerChainContext handler上下文，主要负责维护链，和链的执行

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);
    }
}

执行结果