責任鏈模式在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方法處理了一些日志請求，這些請求會根據其內容被不同的處理器處理。