Hướng dẫn Chain of Responsibility Pattern trong Java

1. Giới thiệu Chain of Responsibility Pattern

Chain of Responsibility Pattern là một mẫu thiết kế thuộc nhóm Behavioral Patterns, cho phép một yêu cầu được gửi qua một chuỗi các đối tượng xử lý. Mỗi đối tượng trong chuỗi quyết định xử lý yêu cầu hoặc chuyển tiếp nó đến đối tượng tiếp theo trong chuỗi. Mẫu thiết kế này giúp tách biệt các lớp gửi yêu cầu từ các lớp xử lý yêu cầu và thúc đẩy tính linh hoạt và khả năng mở rộng của hệ thống.

2. Các trường hợp ứng dụng Chain of Responsibility Pattern

• Hệ thống xử lý yêu cầu: Khi cần xây dựng hệ thống xử lý yêu cầu có thể có nhiều bước hoặc mức độ xử lý khác nhau.

• Kiểm tra và xác thực: Khi cần thực hiện các kiểm tra hoặc xác thực theo thứ tự cụ thể.

• Xử lý lỗi và sự kiện: Khi cần xử lý lỗi hoặc sự kiện qua nhiều lớp xử lý.

3. Triển khai Chain of Responsibility Pattern

3.1. Ví dụ triển khai đơn giản

Giả sử chúng ta có một hệ thống xử lý yêu cầu hỗ trợ các mức độ xử lý khác nhau như INFO, DEBUG, và ERROR.

// Bước 1: Tạo lớp trừu tượng cho Handler
public abstract class Logger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;
    protected Logger nextLogger;

    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message) {
        if (this.level <= level) {
            write(message);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }

    abstract protected void write(String message);
}

// Bước 2: Tạo các lớp Handler cụ thể
public class ConsoleLogger extends Logger {
    public ConsoleLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Standard Console::Logger: " + message);
    }
}

public class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Error Console::Logger: " + message);
    }
}

public class FileLogger extends Logger {
    public FileLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("File::Logger: " + message);
    }
}

// Bước 3: Tạo chuỗi các Logger
public class ChainPatternDemo {
    private static Logger getChainOfLoggers() {
        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        Logger fileLogger = new FileLogger(Logger.DEBUG);
        Logger consoleLogger = new ConsoleLogger(Logger.INFO);

        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consoleLogger);

        return errorLogger;
    }

    public static void main(String[] args) {
        Logger loggerChain = getChainOfLoggers();

        loggerChain.logMessage(Logger.INFO, "This is an information.");
        loggerChain.logMessage(Logger.DEBUG, "This is a debug level information.");
        loggerChain.logMessage(Logger.ERROR, "This is an error information.");
    }
}

3.2. Ví dụ triển khai phức tạp

Giả sử chúng ta có một hệ thống xử lý yêu cầu hỗ trợ các bước xác thực người dùng, kiểm tra quyền truy cập và xử lý dữ liệu.

// Bước 1: Tạo lớp trừu tượng cho Handler
public abstract class RequestHandler {
    protected RequestHandler nextHandler;

    public void setNextHandler(RequestHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handleRequest(Request request) {
        if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// Bước 2: Tạo lớp Request
public class Request {
    private String userName;
    private String userRole;
    private String requestData;

    public Request(String userName, String userRole, String requestData) {
        this.userName = userName;
        this.userRole = userRole;
        this.requestData = requestData;
    }

    public String getUserName() {
        return userName;
    }

    public String getUserRole() {
        return userRole;
    }

    public String getRequestData() {
        return requestData;
    }
}

// Bước 3: Tạo các lớp Handler cụ thể
public class AuthenticationHandler extends RequestHandler {
    @Override
    public void handleRequest(Request request) {
        if (request.getUserName() != null) {
            System.out.println("User authenticated: " + request.getUserName());
            super.handleRequest(request);
        } else {
            System.out.println("Authentication failed.");
        }
    }
}

public class AuthorizationHandler extends RequestHandler {
    @Override
    public void handleRequest(Request request) {
        if (request.getUserRole().equals("Admin")) {
            System.out.println("User authorized: " + request.getUserName());
            super.handleRequest(request);
        } else {
            System.out.println("Authorization failed for user: " + request.getUserName());
        }
    }
}

public class DataProcessingHandler extends RequestHandler {
    @Override
    public void handleRequest(Request request) {
        System.out.println("Processing data: " + request.getRequestData());
    }
}

// Bước 4: Tạo chuỗi các Handler
public class ChainPatternDemo {
    private static RequestHandler getChainOfHandlers() {
        RequestHandler authHandler = new AuthenticationHandler();
        RequestHandler authzHandler = new AuthorizationHandler();
        RequestHandler dataHandler = new DataProcessingHandler();

        authHandler.setNextHandler(authzHandler);
        authzHandler.setNextHandler(dataHandler);

        return authHandler;
    }

    public static void main(String[] args) {
        RequestHandler handlerChain = getChainOfHandlers();

        Request request = new Request("John Doe", "Admin", "Important Data");

        handlerChain.handleRequest(request);
    }
}

4. Phân tích các trường hợp ứng dụng Chain of Responsibility Pattern

4.1. Hệ thống xử lý yêu cầu

• Ưu điểm: Cho phép xử lý yêu cầu theo từng bước hoặc mức độ xử lý khác nhau một cách linh hoạt và mở rộng.

• Nhược điểm: Cần quản lý chuỗi các handler một cách cẩn thận để tránh vòng lặp vô hạn hoặc xử lý thiếu sót.

4.2. Kiểm tra và xác thực

• Ưu điểm: Giúp thực hiện các kiểm tra hoặc xác thực theo thứ tự cụ thể, đảm bảo rằng yêu cầu được xử lý một cách chính xác.

• Nhược điểm: Cần thiết kế và triển khai các handler một cách hợp lý để đảm bảo tính nhất quán và chính xác.

4.3. Xử lý lỗi và sự kiện

• Ưu điểm: Cho phép xử lý lỗi hoặc sự kiện qua nhiều lớp xử lý, giúp tăng tính linh hoạt và mở rộng của hệ thống.

• Nhược điểm: Cần đảm bảo rằng các handler được thiết kế và quản lý một cách hợp lý để tránh xung đột và lỗi xử lý.

5. Kết luận

Chain of Responsibility Pattern là một mẫu thiết kế mạnh mẽ và linh hoạt, giúp xử lý các yêu cầu qua một chuỗi các đối tượng xử lý một cách hiệu quả và linh hoạt. Việc hiểu và áp dụng đúng Chain of Responsibility Pattern sẽ giúp lập trình viên xây dựng các hệ thống dễ bảo trì, dễ mở rộng và hiệu quả hơn.