为何实现Logger不能用工厂模式替代责任链模式？

我的责任链模式实现代码 #

package com.company;

enum LogLevel {
    DEBUG(0),
    INFO(1),
    WARN(2),
    ERROR(3);

    private final Integer enumCode;

    private LogLevel(Integer enumCode) {
        this.enumCode = enumCode;
    }

    private Integer getEnumCode() {
        return enumCode;
    }
}

abstract class LogProcessor {

    protected LogProcessor nextLogProcessor;

    public LogProcessor(LogProcessor nextLogProcessor) {
        this.nextLogProcessor = nextLogProcessor;
    }

    public LogProcessor() {
        this.nextLogProcessor = null;
    }

    public void log(LogLevel logLevel, String message) {
        if (this.nextLogProcessor != null) {
            this.nextLogProcessor.log(logLevel, message);
        }
    }
}

class InfoLogProcessor extends LogProcessor {

    public InfoLogProcessor(LogProcessor nextLogProcessor) {
        this.nextLogProcessor = nextLogProcessor;
    }

    public InfoLogProcessor() {
        this.nextLogProcessor = null;
    }

    public void log(LogLevel logLevel, String message) {
        if (LogLevel.INFO.equals(logLevel)) {
            System.out.println("[" + LogLevel.INFO + "] " + message);
        } else {
            System.out.println("[" + LogLevel.INFO + "] This request can't be processed");
            super.log(logLevel, message);
        }
    }
}

class WarnLogProcessor extends LogProcessor {

    public WarnLogProcessor(LogProcessor nextLogProcessor) {
        this.nextLogProcessor = nextLogProcessor;
    }

    public WarnLogProcessor() {
        this.nextLogProcessor = null;
    }

    public void log(LogLevel logLevel, String message) {
        if (LogLevel.WARN.equals(logLevel)) {
            System.out.println("[" + LogLevel.WARN + "] " + message);
        } else {
            System.out.println("[" + LogLevel.WARN + "] This request can't be processed");
            super.log(logLevel, message);
        }
    }
}

class ErrorLogProcessor extends LogProcessor {

    public ErrorLogProcessor(LogProcessor nextLogProcessor) {
        this.nextLogProcessor = nextLogProcessor;
    }

    public ErrorLogProcessor() {
        this.nextLogProcessor = null;
    }

    public void log(LogLevel logLevel, String message) {
        if (LogLevel.ERROR.equals(logLevel)) {
            System.out.println("[" + LogLevel.ERROR + "] " + message);
        } else {
            System.out.println("[" + LogLevel.ERROR + "] This request can't be processed");
            super.log(logLevel, message);
        }
    }
}

public class CombinedClass {
    public static void main(String[] args) {
        LogProcessor logProcessor = new InfoLogProcessor(new WarnLogProcessor(new ErrorLogProcessor()));
        logProcessor.log(LogLevel.INFO, "This is an info message");
        System.out.println();
        logProcessor.log(LogLevel.WARN, "This is an warn message");
        System.out.println();
        logProcessor.log(LogLevel.ERROR, "This is an error message");
    }
}

我的疑问 #

我已查阅诸多资料，但仍未找到为何此处不能使用工厂方法/简单工厂设计模式的具体原因。多数回答仅模糊提及工厂是创建型模式因此无法使用，我的疑问是：即便它是创建型模式，也能以更短时间完成相同工作——责任链最坏情况复杂度为O(n)，而工厂通过Map可实现O(1)复杂度。恳请给出具体解答。

解答 #

1. 两种模式解决的核心问题完全不同

• **工厂模式（含简单工厂）是创建型模式，核心作用是封装对象的创建逻辑，让调用方无需关心具体类的实例化细节，解决的是"如何创建对象"**的问题，而非请求处理流程的问题。
• 责任链模式是行为型模式，核心是让多个处理器依次有机会处理请求，请求会沿着链传递，直到被处理或走完整个链，解决的是**"请求如何被多步骤/多处理器协作处理"**的问题。

2. 工厂模式无法替代责任链的核心能力

用Map<LogLevel, LogProcessor>实现的工厂模式，确实能通过级别直接定位处理器，做到O(1)的调用效率，但它丢失了责任链的核心价值：

• 多处理器协作处理：比如你想让ERROR级日志先经过Error处理器记录日志，再经过Warn处理器触发告警，最后经过Info处理器归档，这种多步骤的串联处理是工厂模式无法直接实现的——工厂模式只会找到对应处理器执行一次，无法传递请求到下一个处理器。
• 灵活的链调整：责任链可以随时调整处理器的顺序、新增或移除处理器，比如临时插入DEBUG处理器，只需要修改链的构建逻辑，无需改动原有处理器代码；而工厂模式要扩展这类处理流程，往往需要修改Map初始化或原有处理器逻辑，违反开闭原则。
• 请求的动态传递：标准责任链中，处理器可以根据业务逻辑决定是否传递请求（比如INFO日志既可以自己处理，也可以传递给下一级做额外处理），这种动态决策能力是工厂模式不具备的。

3. 复杂度的实际影响可忽略

日志级别通常只有固定的几个（DEBUG/INFO/WARN/ERROR），就算责任链是O(n)，n的数值极小，实际性能差异几乎可以忽略。如果既想追求O(1)的定位效率，又想保留责任链的灵活处理能力，完全可以结合两种模式：用工厂模式封装处理器的创建逻辑，再用责任链模式组装这些处理器，兼顾两者的优势。

内容的提问来源于stack exchange，提问作者james gem