Một trong những mô hình thiết kế phổ biến là Mô hình Liên Kết Trách Nhiệm (Chain of Responsibility). Dưới đây là một số cách triển khai khác nhau của mô hình này.

1. Triển Khai Liên Kết Trách Nhiệm Đơn Giản

Đầu tiên, chúng ta cần định nghĩa một giao diện:

public interface Processor {
    Object process(Object input);
    void setNext(Processor nextProcessor);
    Processor getNext();
}

Và sau đó, thực hiện nó trong một lớp:

public class InitialProcessor implements Processor {
    private Processor next = null;

    @Override
    public Object process(Object input) {
        System.out.println(this.getClass().getName() + ": " + input);
        return input;
    }

    @Override
    public void setNext(Processor processor) {
        this.next = processor;
    }

    @Override
    public Processor getNext() {
        return next;
    }
}

Cách sử dụng:

Processor firstProcessor = new InitialProcessor();
Processor secondProcessor = new SubsequentProcessor();
Processor thirdProcessor = new FinalProcessor();
firstProcessor.setNext(secondProcessor);
secondProcessor.setNext(thirdProcessor);

Processor currentProcessor = firstProcessor;
while (currentProcessor != null) {
    currentProcessor.process("");
    currentProcessor = currentProcessor.getNext();
}

Lợi ích và hạn chế: Đảm bảo thứ tự thực hiện và an toàn, nhưng không hỗ trợ việc ngắt chuỗi.

2. Liên Kết Trách Nhiệm Dạng Lặp

Định nghĩa một lớp quản lý chuỗi xử lý:

private List<Processor> processors = new ArrayList<>();
private volatile int currentIndex = 0;

public boolean addProcessor(Processor processor) {
    return processors.add(processor);
}

public Processor getCurrentProcessor() {
    return processors.get(currentIndex);
}

public Object executeChain(Object input) {
    Object result = input;
    Iterator<Processor> iterator = processors.iterator();
    while (iterator.hasNext()) {
        currentIndex++;
        Processor processor = iterator.next();
        result = processor.process(result);
    }
    currentIndex = 0;
    return result;
}

Cách sử dụng:

ChainExecutor executor = new ChainExecutor();
Processor firstProcessor = new InitialProcessor();
Processor secondProcessor = new SubsequentProcessor();
Processor thirdProcessor = new FinalProcessor();
executor.addProcessor(firstProcessor);
executor.addProcessor(secondProcessor);
executor.addProcessor(thirdProcessor);
Object output = executor.executeChain("input");
System.out.println(output);

Lợi ích và hạn chế: Có thể dễ dàng ngắt chuỗi, nhưng không đảm bảo thứ tự thực hiện tuyệt đối và an toàn.

3. Liên Kết Trách Nhiệm Tương Tự Bộ Lọc, Bỏ Qua Một Số Nút Xử Lý

Định nghĩa một giao diện bộ lọc:

public interface Filter {
    boolean preProcess(Object input);
    Object process(Object input);
    Object postProcess(Object input);
}

Và thực hiện nó trong một lớp:

public class PrimaryFilter implements Filter {
    @Override
    public boolean preProcess(Object input) {
        System.out.println(this.getClass().getSimpleName() + " trước khi xử lý");
        return true;
    }

    @Override
    public Object process(Object input) {
        System.out.println(this.getClass().getName());
        return input + "_" + this.getClass().getSimpleName();
    }

    @Override
    public Object postProcess(Object input) {
        System.out.println(this.getClass().getSimpleName() + " sau khi xử lý");
        return input;
    }
}

Triển khai chuỗi bộ lọc:

public class FilterChain {
    private List<Filter> filters = new ArrayList<>();
    private volatile AtomicInteger currentIndex = new AtomicInteger();

    public boolean addFilter(Filter filter) {
        return filters.add(filter);
    }

    public Filter getCurrentFilter() {
        return filters.get(currentIndex.get());
    }

    public synchronized Object executeFilters(Object input) {
        Iterator<Filter> iterator = filters.iterator();
        while (iterator.hasNext()) {
            currentIndex.incrementAndGet();
            Filter filter = iterator.next();
            if (filter.preProcess(input)) {
                input = filter.process(input);
                input = filter.postProcess(input);
            }
        }
        currentIndex.set(0);
        return input;
    }
}

Cách sử dụng:

FilterChain chain = new FilterChain();
Filter firstFilter = new PrimaryFilter();
Filter secondFilter = new SecondaryFilter();
Filter thirdFilter = new TertiaryFilter();
chain.addFilter(firstFilter);
chain.addFilter(secondFilter);
chain.addFilter(thirdFilter);
Object output = chain.executeFilters("input");
System.out.println(output);

Lợi ích và hạn chế: Thực hiện liên kết, tách biệt bộ lọc khỏi chuỗi thực thi, hỗ trợ xử lý trước và sau cùng, có thể bỏ qua bất kỳ bộ lọc nào; hạn chế là phức tạp hơn và không đảm bảo an toàn hoặc thứ tự tuyệt đối.