Design Pattern - Adapter

Tiếp tục với mẫu thiết kế adapter.

Nó là gì?
 Mẫu adapter chuyển đổi giao diện thành một giao diện khác mà phù hợp với yêu cầu. Giúp kết nối các lớp có giao diện không tương thích để làm việc với nhau

Dùng nó trong trường hợp nào?.
Khi ta muốn chuyển đổi một lớp với một giao diện thành giao diện mà ta mong muốn.
Xậy dựng, mở rộng các phương thức của lớp có sẵn phù hợp với yêu cầu.
Tái sử dụng giao diện cũ. Giảm thiểu việc viết lại mã lệnh.

Dùng nó như thế nào?

Tình Huống:

   Thực tế : Có một công ty muốn mỏ rông công ty bằng cách chuyển địa điểm làm việc. Khi chuyển địa điểm thì có thêm các cơ sở mới.
   Trong Java : giả sử ta đã có lớp với phương thức có sẵn để hiển thị 1 chuồi như sau ra màn hình: void ShowName (String str) với chuỗi đã được chuẩn hóa nhưng chương trình mới yêu cầu ta phải hiển thị một danh sách các chuỗi được chuẩn hóa với giao diện mới. 

- Xử lí tình huống : 

   Tình huống 1) Có người để xuất ý kiến ta sẽ mua toàn bộ các cơ sở vật chất đề phù hợp với môi trường mới. Nhưng có một đề xuất khác là ta sẽ sử dụng lại các công cụ có sẵn của công từ và từ đó sẽ thêm các cơ sở vật chất mới phù hợp.
   Tình huống 2)  Một lập trình viên đề xuất , ta sẽ tạo một lớp hoàn toàn mới để ghi 1 danh sách chuỗi với phương thức để chuẩn hóa. Nhưng không, một lập trình viên khác nêu ý kiến: “Tôi có một giải pháp, tôi sẽ sử dụng mẫu chuyển đổi Adapter để tạo một lớp phù hợp từ lớp có sẵn”. 

Tạo mẫu Adapter đầu tiên :
Đầu tiên lớp có sẵn của ta được mô tả với  1 interface:

1. public interface IShowName { 
2.    void showName(String name); 
3. }

Và một lớp thực thi interface trên :

1. public class ShowName implements IShowName{
2.    @Override public void showName(String name){   
3.       System.out.println(this.standardize(name));
4.    }
5.    public String standardize(String name){
6.       String resuilt = name.trim();
7.       return name;
8.    }
9. }

Và một interface mô tả phương thức phù hợp với chương trình của ta :

1. public interface IShowListName {
2.    void showListName(List listName);
3. }

Và một lớp thực thi interface :

1. public class ShowListNameAdapter implements IShowListName{
2.       private ShowName shownName;
3.       public ShowListNameAdapter(ShowName shownName) {
4.          this.shownName = shownName;
5.          }
6.       @Override
7.       public void showListName(List listName) {
8.          for (String name : listName) {
9.          shownName.showName(name);
10.       }
11.    }
12. }

Thử chạy mẫu Adapter:

1. public class TestAdapter {
2.    public static void main(String[] args) {
3.       ArrayList array = new ArrayList<>();
4.       array.add(" Teo ");
5.       array.add(" Ti ");
6.       array.add(" Ku ");
7.       IShowListName adapter = new ShowListNameAdapter(new ShowName());    
8.       adapter.showListName(array); 
9.    }
10. }

Kết quả chương trình sẽ hiển thị “Teo”, ”Ti”, “Ku” đã được chuẩn hóa.
Đây chỉ là một ví dụ nhỏ của Adapter pattern. Hy vọng bạn sẽ sớm có cái nhìn tổng quát và hiểu rõ thêm về Adapter pattern.

Read More

Design Pattern - Proxy

Nó là gì?
 - Mẫu Proxy (người đại diện) đại diện cho 1 chức năng của lớp khác. Bạn có thể hiểu, ta thuê 1 luật sư về đại diện cho ta, người luật sư này có thể dùng các quyền của mình một cách gián tiếp để nói cho các người khác một cách chính xác vì luật sư am hiểu về pháp luật hơn mình.

Khi nào dùng nó?

 - Khi bạn muốn bảo vệ quyền truy xuất vào các chức năng (phương thức) của thực thể.
 - Bổ sung trước khi thực hiện phương thức của thực thể.
 - Tạo đối tượng với chức năng được nâng cao theo yêu cầu.

Dùng nó như thế nào?

 Tôi sẽ xây dựng một ví dụ đơn giản như sau:
- Tôi có 1 inteface mô tả chức năng của một class :

1. public interface ReadFile { 
2.      public String readFile(); 
3. }

}

Tiếp theo tạo class User triển khai interface trên:

1. public class User implements ReadFile{
2.       private String name; //Tên của người dùng 
3.       public User(String name) { 
4.            this.name = name; 
5.       } @Override public String readFile() { //Phương thức đọc file            return name + "readed"; 
6.       } 
7.  }

Và một class Proxy đại diện cho lớp User:

1. public class UserProxy implements ReadFile{ 
2.       private ReadFile instance; 
3.       private String name; 
4.       public UserProxy (String name){ 
5.            this.name = name; 
6.       } 
7.       @Override 
8.        public String readFile() { 
9.             if(name.equals("ok")){ //nêu tên người dùng là ok thì mới thực hiện phương thức của lớp User, không thì báo lỗi!                           if(instance ==null){ 
10.                     instance = new User(name); 
11.                   }
12.                 return instance.readFile(); 
13.             } 
14.           return "You can't read file"; 
15.         } 
16.  }

Thử chạy chương trình test như sau :

1. public class Main {
2.     public static void main(String[] args) { 
3.         UserProxy user1 = new UserProxy("ok");
4.         System.out.println(user1.readFile());
5.         UserProxy user2 = new UserProxy("hello"); 
6.         System.out.println(user2.readFile()); 
7.      } 
8. }

Kết quả :

ok readed

You can't read file

Trên chỉ là một ví dụ nhỏ về proxy, nó còn có rất nhiều cách dùng khác. Hy vọng bạn có thể nắm bắt được các mẫu thiết kế pattern bởi nó thực sự cần thiết đối với một lập trình viên.

Read More