Chia sẻ kiến thức lập trình

Memento Design Pattern

Viên đá thời gian

Hãy tưởng tượng bạn vừa viết xong 1 văn bản với 10 nghìn dòng, và lỡ tay ấn nhầm nút xoá, và thế là trời ơi, bao nhiêu công sức của bạn đổ xuống sông xuống biển. Nhưng thật may chúng ta đã có tổ hợp phím Ctrl + Z để đưa văn bản trở lại. Không có ước tính cụ thể rằng một ngày có bao nhiêu lần Ctrl + Z đã được sử dụng, và đã có bao nhiêu công sức được cứu lại mỗi ngày, nhưng mình cho rằng nó giống như một viên đá thời gian, giúp cho chúng ta có thể quay trở lại trạng thái trước đó để sửa chữa những sai lầm, và đây cũng chính là mục tiêu ra đời của Memento Design Pattern.

Bài toán thực tế

Bây giờ chúng ta sẽ cần phải xây dựng 1 ứng dụng soạn thảo văn bản đơn giản gồm các chức năng:

  1. Soạn thảo và lưu văn bản
  2. Cho phép người dùng restore lại các băn bản đã lưu

Cách giải quyết đơn giản nhất chắc sẽ kiểu thế này (bạn có thể tham khảo bản đầy đủ tại đây:

public class TextEditor {

    private final Stack<String> stateStack = new Stack<>();
    private final StringBuilder text = new StringBuilder();

    @SuppressWarnings("resource")
    public void start() {
        System.out.println("please enter you text:");
        Scanner scanner = new Scanner(System.in);
        while(true) {
            String line;
            try {
                line = scanner.nextLine();
            }
            catch (Exception e) {
                continue;
            }
            if(line.equals("b")) {
                restore();
            }
            else if(line.equals("c")) {
                close();
                break;
            }
            else {
                stateStack.add(text.toString());
                if(text.length() > 0) {
                    text.append(" ");
                }
                text.append(line);
                System.out.println("saved: " + text);
            }
        }
    }

    public void restore() {
        text.delete(0, text.length());
        String beforeState = stateStack.isEmpty() ? "" : stateStack.pop();
        text.append(beforeState);
        System.out.println("you just restore, current text is: " + text);
    }

    public void close() {
        System.out.println("finished, your text is: " + text);
    }

    public static void main(String[] args) throws Exception {
        TextEditor textEditor = new TextEditor();
        textEditor.start();
    }
}

Sử dụng 1 stack để lưu lại các văn bản trước đó và tương tác trên stack này.

Tuy nhiên một chương trình soạn thảo văn bản có cả nghìn chức năng, nếu chức năng nào chúng ta cũng viết hết và lớp TextEditor này thì nó sẽ cả triệu dòng, như vậy phải có 1 cách nào đó để restore lại được mà vẫn đảm bảo một thiết kế mềm dẻo và dễ dàng mở rộng. Câu trả lời sẽ đến từ Memento.

Mục tiêu ra đời

Memento ra đời với 2 mục tiêu chính:

  • Lưu giữ các trạng của đối tượng nhưng không vi phạm nguyên tắc đóng gói: nghĩa là chỉ đối tượng sử dụng mới có quyền truy cập đến các trạng thái được lưu giữ này
  • Cung cấp một phương thức để restore lại trạng thái trước đó của đối tượng.

Giải quyết bài toán

Vẫn là bài toán trình soạn thảo văn bản, chúng ta sẽ tách chức năng restore ra một lớp Memento riêng, nhưng trước tiên hãy thiết kế lớp 1 chút nhé

Sơ đồ lớp

Sơ đồ lớp cũng tương đối đơn giản với các lớp:

  1. Memento: là lớp lưu giữ các văn bản đã được lưu để restore khi cần thiết
  2. TextEditor: là lớp đại diện cho trình soạn thảo văn bản, lớp này sẽ sử dụng lớp Memento cho chức năng restore, để không vi phạm nguyên tắc đóng gói, lớp Memento sẽ chỉ được sử dụng bởi TextEditor mà không để lộ ra bên ngoài
  3. Client: là lớp sử dụng TextEditor, nó sẽ không biết sự tồn tại của lớp Memento

Cài đặt

Mã nguồn cài đặt cũng sẽ tương đối đơn giản như thế này (bạn có thể tham khảo bản đầy đủ tại đây:

public static class Memento {
    private final Stack<String> stateStack = new Stack<>();

    public void addNewState(String state) {
        stateStack.add(state);
    }

    public String takeLastState() {
        return stateStack.isEmpty() ? "" : stateStack.pop();
    }
}

public class TextEditor {

    private final Memento memento = new Memento();
    private final StringBuilder text = new StringBuilder();

    @SuppressWarnings("resource")
    public void start() {
        System.out.println("please enter you text:");
        Scanner scanner = new Scanner(System.in);
        while(true) {
            String line;
            try {
                line = scanner.nextLine();
            }
            catch (Exception e) {
                continue;
            }
            if(line.equals("b")) {
                restore();
            }
            else if(line.equals("c")) {
                close();
                break;
            }
            else {
                save(line);
            }
        }
    }

    public void save(String line) {
        memento.addNewState(text.toString());
        if(text.length() > 0) {
            text.append(" ");
        }
        text.append(line);
        System.out.println("saved: " + text);
    }

    private void restore() {
        text.delete(0, text.length());
        text.append(memento.takeLastState());
        System.out.println("you just restore, current text is: " + text);
    }

    public void close() {
        System.out.println("finished, your text is: " + text);
    }
}

Và sử dụng sẽ thế này:

    public static void main(String[] args) throws Exception {
        TextEditor textEditor = new TextEditor();
        textEditor.start();
    }

Như vậy chúng ta có thể thấy, dù lớp Memento có phức tạp và cần thay đổi như thế nào thì lớp TextEditor cũng sẽ không cần thay đổi theo, nó sẽ giữ cho mọi thứ được an toàn và mềm dẻo.

Tổng kết

Memento có một vai trò rất quan trọng khi chúng ta phải làm với việc dữ liệu và cần phải lưu giữ nhiều trạng thái để restore khi cần thiết ví dụ như:

  • Xử lý transaction: chúng ta cần phải commit và rollback lại phiên bản trước khi có lỗi xảy ra
  • Git hay svn: lưu giữ các commit và có thể rollback lại phiên bản cũ nếu muốn
  • Các trình soạn thảo văn bản: lưu giữ các văn bản đã được lưu để restore khi có sai sót

Và còn rất rất nhiều ứng dụng khác, bạn hãy nghĩ đến nó khi bạn cần thao tác với dữ liệu nhiều phiên bản nhé.

Share: