职责链模式

什么是职责链模式

  将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。
  这么说比较抽象，我用更加容易理解的话来进一步解读一下。
  在职责链模式中，多个处理器（也就是刚刚定义中说的“接收对象”）依次处理同一个请求。一个请求先经过 A 处理器处理，然后再把请求传递给 B 处理器，B 处理器处理完后再传递给 C 处理器，以此类推，形成一个链条。链条上的每个处理器各自承担各自的处理职责，所以叫作职责链模式。

为什么要用职责链模式

  应用设计模式主要是为了应对代码的复杂性，让其满足开闭原则，提高代码的扩展性。这里应用职责链模式也不例外。
  我们举例来说明，现在我们有个这样的需求，我们现在的系统分为管理端和终端，管理端可以管控终端软件的安装卸载等，可以在管理端上传安装包，然后下发到终端安装。上传安装包时需要校验安装包是否有病毒：root权限获取、木马、流氓广告弹窗等；使用职责链模式之前的代码可能是这样的：

public class InstallationPackageVirusFilter {
    public boolean filter(InstallationPackageInfo installationPackageInfo) {
        if (!filterRootePrmissioncAquisition(installationPackageInfo)) {
            return false;
        }
        if (!filterTrojanHorse(installationPackageInfo)) {
            return false;
        }
        if (!filterAdvertisingPopUp(installationPackageInfo)) {
            return false;
        }
        return true;
    }

    private boolean filterRootPermissionAcquisition(InstallationPackageInfo installationPackageInfo) {
        // root权限获取
    }

    private boolean filterTrojanHorse(InstallationPackageInfo installationPackageInfo) {
        // 木马
    }

    private boolean filterAdvertisingPopUp(InstallationPackageInfo installationPackageInfo) {
        // 过滤广告弹框
    }
}

  上面这段代码用起来没有问题，那么我们如果需要增加一种病毒类型的检测，那么就需要增加一个if分支并在此类中再增加一个工具方法，这显然是不复合开闭原则的。
  接下来，我们使用职责链模式对这段代码进行优化。

如何使用职责链模式

  职责链模式有两种实现方式，一种是链表形式，一种是数组形式，接下来我们给出两种形式的代码示例。

• 链表形式的职责链模式

// 安装包病毒过滤器抽象类
public abstract class InstallationPackageVirusFilter {
    // 下一过滤器
    protected InstallationPackageVirusFilter nextFilter = null;

    // 设置下一过滤器
    public void setNextFilter(InstallationPackageVirusFilter nextFilter) {
        this.nextFilter = nextFilter;
    }

    // 执行处理（此处使用模板模式，避免重写时忘记执行nextFilter.handle()）
    public final void handle() {
        boolean handled = doHandle();
        if (nextFilter != null && !handled) {
            nextFilter.handle();
        }
    }

    // 具体逻辑
    protected abstract boolean doHandle();
}

// Root权限获取过滤器
public class RootPermissionAcquireFilter extends InstallationPackageVirusFilter{
    @Override
    protected boolean doHandle() {
        // 具体的检测逻辑...
        return false;
    }
}

// 此处省略其他具象类的实现，与Root权限获取过滤器一致
...

// 安装包病毒过滤器链
public class InstallationPackageVirusFilterChain {
    // 链表的头
    private InstallationPackageVirusFilter head = null;
    // 链表的尾
    private InstallationPackageVirusFilter tail = null;

    // 添加过滤器
    public void addHandler(InstallationPackageVirusFilter handler) {
        handler.setNextFilter(null);
        if (head == null) {
            head = handler;
            tail = handler;
            return;
        }
        tail.setNextFilter(handler);
        tail = handler;
    }

    // 执行过滤逻辑
    public void handle() {
        if (head != null) {
            head.handle();
        }
    }
}

// 具体应用
public class Test {
    public static void main(String[] args) {
        InstallationPackageVirusFilterChain chain = new InstallationPackageVirusFilterChain();
        chain.addHandler(new RootPermissionAcquireFilter());
        // 省略其他过滤器的添加
        chain.addHandler(...);
        chain.handle();
    }
}

• 数组形式的职责链模式

// 安装包病毒过滤器接口
public interface IInstallationPackageVirusFilter {
    boolean handle();
}


// Root权限获取过滤器
public class RootPermissionAcquireFilter implements IInstallationPackageVirusFilter{
    @Override
    public boolean handle() {
        // 具体的检测逻辑...
        return false;
    }
}

// 此处省略其他具象类的实现，与Root权限获取过滤器一致
...

// 安装包病毒过滤器链
public class InstallationPackageVirusFilterChain {
    private final List<IInstallationPackageVirusFilter> handlers = new ArrayList<>();

    // 添加过滤器
    public void addHandler(IInstallationPackageVirusFilter handler) {
        this.handlers.add(handler);
    }

    // 处理
    public void handle() {
        for (IInstallationPackageVirusFilter handler : handlers) {
            boolean handled = handler.handle();
            if (handled) {
                break;
            }
        }
    }
}

// 具体应用
public class Test {
    public static void main(String[] args) {
        chain.chain.InstallationPackageVirusFilterChain chain = new InstallationPackageVirusFilterChain();
        chain.addHandler(new RootPermissionAcquireFilter());
        // 省略其他过滤器的添加
        // chain.addHandler(...);
        chain.handle();
    }
}

  通过上面的代码，我们可以明显感觉到比使用职责链之前的代码简洁，增加一种病毒检测只需要继承/实现指定的抽象类或接口，在使用的时候添加到链中即可。

总结

• 职责链模式可以应对代码的复杂性。
    将大块代码逻辑拆分成函数，将大类拆分成小类，是应对代码复杂性的常用方法。应用职责链模式，我们把各个安装包病毒过滤函数拆分出来，设计成独立的类，进一步简化了 InstallationPackageVirusFilter类，让 InstallationPackageVirusFilter 类的代码不会过多，过复杂。
• 职责链模式更满足开闭原则，提高代码的扩展性。
    当我们要扩展新的过滤算法的时候，比如，我们还需要过滤扣费，按照非职责链模式的代码实现方式，我们需要修改 InstallationPackageVirusFilter 的代码，违反开闭原则。不过，这样的修改还算比较集中，也是可以接受的。
    而职责链模式的实现方式更加优雅，只需要新添加一个 Filter 类，并且通过 addFilter() 函数将它添加到 FilterChain 中即可，其他代码完全不需要修改。 不过，你可能会说，即便使用职责链模式来实现，当添加新的过滤算法的时候，还是要修改客户端代码（Test），这样做也没有完全符合开闭原则。
    实际上，细化一下的话，我们可以把上面的代码分成两类：框架代码和客户端代码。其中，Test 属于客户端代码，也就是使用框架的代码。除 Test 之外的代码属于敏感词过滤框架代码。 假设敏感词过滤框架并不是我们开发维护的，而是我们引入的一个第三方框架，我们要扩展一个新的过滤算法，不可能直接去修改框架的源码。这个时候，利用职责链模式就能达到开篇所说的，在不修改框架源码的情况下，基于职责链模式提供的扩展点，来扩展新的功能。换句话说，我们在框架这个代码范围内实现了开闭原则。
    除此之外，利用职责链模式相对于不用职责链的实现方式，还有一个好处，那就是配置过滤算法更加灵活，可以只选择使用某几个过滤算法。