[Design Patterns] Interpreter Pattern

Interpreter thông dịch viên – là pattern giúp tạo ra một phương thức để định tính một ngôn ngữ hoặc một biểu thức.
Interpreter được xếp vào nhóm các pattern Hành Vi.

Interpreter triển khai một giao diện biểu thức để thực hiện định tính các yêu cầu nhận được trong bối cảnh cụ thể.
Pattern này thường được sử dụng để phân tích các cú pháp SQL, hoặc dùng trong các thuật toán xử lý các ký hiệu v.v…

Áp dụng triển khai

Ở đây chúng ta có một phần mềm giúp truy vấn và xác thực thông tin liên quan tới người dùng.
Phần mềm này sẽ đưa ra kết luận đúng hoặc sai khi nhận được tên người dùng và câu hỏi được chọn để hỏi.

Một abstract có tên là Expression được tạo ra để đại diện cho các interpreter
hay các object đại diện cho câu hỏi và sẽ nhận vào tham số để kiểm định và trả lại kết quả
true hoặc false.

Class triển khai Terminal đại diện cho một Expression đơn nguyên giữ các nút dữ liệu để đưa ra nhận định
true hoặc false cho tham số được truyền vào. Bên cạnh đó là 2 class And và Or được sử dụng để
tạo ra các biểu thức Expression kết hợp – tức là kết hợp nhiều nút dữ liệu trở thành một interpreter tổng
thay vì mang mỗi tham số đi hỏi từng interpreter một rồi mới gom kết quả trả lời cho client.

Cách thức hoạt động của chương trình như chúng ta thấy rất đơn giản. Đầu tiên dữ liệu được tải từ database
lên rồi được chuyển thành các Expression đơn nguyên là các Terminal, rồi được ghép thành các Expression
phức hợp hay các interpreter nhận tham số trực tiếp để trả lời câu hỏi. Sau đó thì với mỗi tham số được
truyền vào, các interpreter phức sẽ cho câu trả lời cuối cùng là true hoặc false.

Bước 1

Tạo abstract Expression.

interpreterpattern/Expression.java

packageinterpreterpattern;publicabstractclassExpression{publicabstractbooleaninterpret(String context);}

Bước 2

Tạo class triển khai Terminal và 2 class tổng hợp And và Or.

interpreterpattern/Terminal.java

packageinterpreterpattern;publicclassTerminalextendsExpression{privateString data;publicTerminal(String data){this.data = data;}@Overridepublicbooleaninterpret(String context){return context.contains(data);}}

interpreterpatter/And.java

packageinterpreterpattern;publicclassAndextendsExpression{privateExpression expr1 =null;privateExpression expr2 =null;publicAnd(Expression expr1,Expression expr2
   ){this.expr1 = expr1;this.expr2 = expr2;}@Overridepublicbooleaninterpret(String context){return expr1.interpret(context)&& expr2.interpret(context);}}

interpreterpattern/Or.java

packageinterpreterpattern;publicclassOrextendsExpression{privateExpression expr1 =null;privateExpression expr2 =null;publicOr(Expression expr1,Expression expr2
   ){this.expr1 = expr1;this.expr2 = expr2;}@Overridepublicbooleaninterpret(String context){return expr1.interpret(context)|| expr2.interpret(context);}}

Bước 3

Sử dụng các class Expression để tạo ra các biểu thức dữ liệu và truyền vào một vài tham số hỏi để
kiểm tra hoạt động.

PatternDemo.java

importinterpreterpattern.And;importinterpreterpattern.Expression;importinterpreterpattern.Or;importinterpreterpattern.Terminal;publicclassPatternDemo{publicstaticvoidmain(String[] args){Expression isMale =getMale();Expression isMarriedWoman =getMarriedWoman();System.out.println("John is male? "+ isMale.interpret("John"));System.out.println("Julie is married? "+ isMarriedWoman.interpret("Julie"));}publicstaticExpressiongetMale(){Expression robert =newTerminal("Robert");Expression john =newTerminal("John");returnnewOr(robert, john);}publicstaticExpressiongetMarriedWoman(){Expression julie =newTerminal("Julie");Expression marry =newTerminal("Marry");returnnewAnd(julie, marry);}}

Bước 4

Kiểm chứng lại kết quả được in ra ở console.

console

John is male? true
Julie is married? false