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

4,333 阅读5分钟

一、概念以及背景

责任链模式(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等内置函数式接口也是提供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实战》