责任链模式在Java日志处理中的应用

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许对象对请求进行处理，并将请求沿着链传递给下一个接收者。这种模式可以使得多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。在Java日志处理中，责任链模式可以很好地应用，以提高代码的可扩展性和可维护性。

在Java日志处理中，责任链模式通常包括以下几个角色：

1. 日志处理器（Log Handler）：负责处理日志请求的核心类，每个处理器都有一个后继处理器。当处理器无法处理请求时，可以将请求传递给后继处理器。
2. 具体日志处理器（Concrete Log Handler）：实现了日志处理器的抽象类或接口，负责具体的日志处理逻辑。
3. 日志请求（Log Request）：封装了需要处理的日志信息。

下面是一个简单的Java日志处理示例，展示了责任链模式的应用：

// 日志处理器接口
public interface LogHandler {
    void handleLog(String logMessage);
    void setNextHandler(LogHandler nextHandler);
}

// 具体日志处理器A
public class ConcreteLogHandlerA implements LogHandler {
    private LogHandler nextHandler;

    @Override
    public void handleLog(String logMessage) {
        if (logMessage.contains("A")) {
            System.out.println("ConcreteLogHandlerA handled: " + logMessage);
        } else if (nextHandler != null) {
            nextHandler.handleLog(logMessage);
        }
    }

    @Override
    public void setNextHandler(LogHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
}

// 具体日志处理器B
public class ConcreteLogHandlerB implements LogHandler {
    private LogHandler nextHandler;

    @Override
    public void handleLog(String logMessage) {
        if (logMessage.contains("B")) {
            System.out.println("ConcreteLogHandlerB handled: " + logMessage);
        } else if (nextHandler != null) {
            nextHandler.handleLog(logMessage);
        }
    }

    @Override
    public void setNextHandler(LogHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
}

// 日志请求类
public class LogRequest {
    private String message;

    public LogRequest(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

// 日志处理器链类
public class LogHandlerChain {
    private LogHandler firstHandler;

    public void addHandler(LogHandler handler) {
        if (firstHandler == null) {
            firstHandler = handler;
        } else {
            LogHandler current = firstHandler;
            while (current.getNextHandler() != null) {
                current = current.getNextHandler();
            }
            current.setNextHandler(handler);
        }
    }

    public void processLog(String logMessage) {
        LogRequest request = new LogRequest(logMessage);
        if (firstHandler != null) {
            firstHandler.handleLog(request.getMessage());
        }
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        LogHandlerChain chain = new LogHandlerChain();
        chain.addHandler(new ConcreteLogHandlerA());
        chain.addHandler(new ConcreteLogHandlerB());

        chain.processLog("This is a log message A");
        chain.processLog("This is a log message B");
        chain.processLog("This is a log message C");
    }
}

在这个示例中，我们定义了一个LogHandler接口和两个实现了该接口的具体处理器ConcreteLogHandlerA和ConcreteLogHandlerB。我们还定义了一个LogRequest类来封装日志请求，以及一个LogHandlerChain类来管理日志处理器链。在Main类中，我们创建了一个处理器链，并添加了两个具体处理器。然后，我们通过processLog方法处理了一些日志请求，这些请求会根据其内容被不同的处理器处理。