责任链模式与lambda重构责任链模式

一、概念以及背景

责任链模式(Chain of Responsibility Pattern):责任链模式是一种创建处理对象序列（比如操作序列）的通用方案。一个处理对象可能需要在完成一些工作之后，将结果传递给另一个对象，这个对象接着做一些工作，再转交给下一个处理对象，以此类推。

简而言之，待处理的对象，需要经过好几个步骤的处理，形成一条链，一个步骤处理完之后，接着往下一个步骤继续处理。

本文涉及的代码在github上，点击链接可查看源码。

本文会用两种方式来实现责任链模式，第二种是用lambda表达式的方式来实现，参数行为化的方式实现。

本文所使用的场景如下：处理一封信，首先对会信的头部进行处理，然后会检查这份信的拼写有无错误，有的话把错误的单词修改过来，最后会对信的结尾进行处理。这样一来处理一封信就形成了一条链，先处理……，再处理……，最后处理……。

二、责任链模式

基于上面提到的场景，UML类图如下，责任链模式之所以能形成链，其核心是有一个抽象处理类，该抽象处理类会有一个字段（抽象处理者）被用来记录后续对象，即记录执行处理某个步骤的对象。然后该抽象处理类还有一个抽象方法，即handleWork抽象方法，每个处理步骤（链节点）都会实现该抽象方法，作为该步骤的处理逻辑，当然处理完之后还需要丢给下一个链节点处理。

uml图

Handler抽象类，即抽象处理类，含有一个字段是抽象处理者successor，当然也有setSuccessor方法，用来设置下一个处理者，即本步骤/链节点处理完之后，传递给下一个处理者继续处理。handleWork抽象方法提供了实现不同的处理步骤，有不同的处理逻辑，这里的handle方法也起到了不少的作用，形成链，本链节点handleWork之后，判断自身是否还拥有下一处理者，有的话，下一处理者继续进行handle->handleWork直到处理结束，无处理者。

public abstract class Handler {

    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    abstract protected String handleWork(String input);

    public String handle(String input) {
        //本节点处理完之后返回下一节点
        String nextNode = handleWork(input);
        if (successor != null) {
            return successor.handle(nextNode);
        }
        return nextNode;
    }
}

AddHeaderHandler类，信的头部处理器

public class AddHeaderHandler extends Handler{
    @Override
    protected String handleWork(String input) {
        return  "From Raoul, Mario and Alan: " + input;
    }
}

CheckSpellHandler类，检查信的拼写

public class CheckSpellHandler extends Handler{
    @Override
    protected String handleWork(String input) {
        return input.replaceAll("labda", "lambda");
    }
}

AddFooterHandler类，信的结尾处理器

public class AddFooterHandler extends Handler{
    @Override
    protected String handleWork(String input) {
        return  input + " Kind regards";
    }
}

public class ChainMain {
    public static void main(String[] args) {
        AddHeaderHandler addHeaderHandler = new AddHeaderHandler();
        CheckSpellHandler checkSpellHandler = new CheckSpellHandler();
        AddFooterHandler addFooterHandler = new AddFooterHandler();
        addHeaderHandler.setSuccessor(checkSpellHandler);
        checkSpellHandler.setSuccessor(addFooterHandler);
        String test = addHeaderHandler.handle("labda");
        System.out.println(test);
    }
}

最后控制台输出这封处理过的信：

From Raoul, Mario and Alan: lambda Kind regards

三、责任链模式，行为参数化，lambda方式重构

这里用了Java8的Function<T,R>函数式接口，方法apply输入T类型参数，返回R类型，T，R都是String类型，符合我们处理信件，输入和输出都是String类型。因为我们的核心在于处理信件的逻辑，故这里结合Java8函数式接口，把行为参数化，实现了处理信件的处理逻辑。

Function<T,R>

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

LambdaHandler

public class LambdaHandler {

    public static Function<String, String> addHeaderHandler() {
        return (input) -> "From Raoul, Mario and Alan: " + input;
    }

    public static Function<String, String> checkSpellHandler() {
        return (input) -> input.replaceAll("labda", "lambda");
    }

    public static Function<String, String> addFooterHandler() {
        return (input) -> input + " Kind regards";
    }
}

ChainMain

public class ChainMain {
    public static void main(String[] args) {
        Function<String, String> addHeaderHandler = LambdaHandler.addHeaderHandler();
        Function<String, String> checkSpellHandler = LambdaHandler.checkSpellHandler();
        Function<String, String> addFooterHandler = LambdaHandler.addFooterHandler();
        String test = addHeaderHandler.andThen(checkSpellHandler).andThen(addFooterHandler).apply("labda");
        System.out.println(test);
    }
}

最后控制台输出这封处理过的信：

From Raoul, Mario and Alan: lambda Kind regards

起核心作用的是Function<T, R>接口的默认方法andThen，除了内置函数式接口Function<T, R>有andThen默认方法，Consumer<T>等内置函数式接口也是提供andThen默认方法的，大部分是能满足我们的需求的。
我们可以看到，andThen方法的方法参数也是一个跟自身相同的函数式接口Function<T,R>，只不过这里的泛型有下界通配符和上界通配符Function<? super R, ? extends V> after，当然我们可以暂不用细究这个，因为我们实现的接口都是入参和返回结果都是String类型。
Objects.requireNonNull(after);首先判断传入的参数不能为空，毕竟这是下一个处理步骤的实现处理逻辑，关键是(T t) -> after.apply(apply(t));这句代码起了作用，这里分为两步，第一步是先执行自身的apply(t)方法，即在当前步骤，先对节点进行处理，然后返回处理结果，接着是对节点（本步骤的处理结果）进行下一步的处理，即after.apply(apply(t))

@FunctionalInterface
public interface Function<T, R> {
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
}

当然节点的最后一个处理步骤，我们需要在最后返回的Function<T,R>在执行一次apply，调用最后一个处理步骤的实现方法，即


String test = addHeaderHandler.andThen(checkSpellHandler).andThen(addFooterHandler).apply("labda");

本文如有不足之处，请指正或者提出好的建议｡◕‿◕｡谢谢。

参考资料：《Java8实战》