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

Design Pattern - Observer

Nó là gì ?

Observer cho phép các đối tượng có thể lắng nghe và phản ứng khi có thông báo từ một đối tượng khác. Tức là khi một đối tượng gửi một thông báo, các đối tượng lắng nghe nó có thể phản ứng lại với thông báo đó.

Sử dụng khi nào ?

Khi bạn muốn các đối tượng liên lạc với nhau. Khi đối tượng này gửi 1 thông điệp thì các đối tượng đăng ký lắng nghe thông điệp sẽ phản ứng lại với thông điệp đó. Đối tượng gửi thông điệp sẽ không cần biết nó sẽ gửi cho ai và đối tượng nhận thông điệp sẽ không cần biết ai gửi thông điệp đó.

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

Giả sử trong một hệ thống bán hàng, mỗi khi có sản phẩm mới hệ thống sẽ thông báo cho tất cả các khách hàng quan tâm đến sản phẩm này. Đầu tiên tôi tạo ra một lớp interface với 1 phương thức sẽ phản ứng khi có sản phẩm mới .

1. public interface Observer{
2.    void update(String message);//phương thức phản ứng lại khi nhận được thông báo.
3. }
   

Và lớp Customer sẽ triển khai interface trên :

1. public class Customer implements Observer{
2. private String name;
3. private int age;
5. public Customer(String name, int age) {
6. super();
7. this.name = name;
8. this.age = age;
9. }
10. 
    
11. @Override
12. public void update(String message) {
13. System.out.println(name + " " + message);
14. }
15. 
    
16. }

Tiếp theo tạo một interface với các phương thức, cho phép đối tượng Observer đăng ký phản ứng, hủy đăng ký nhận, và thông báo đến tất cả các đối tượng Observer đã đăng ký :

1. public interface Subject {  
2.     public void attachObserver(Observer observer);// thêm đối tượng đăng ký lắng nghe thông báo.
3.     public void detachObserver(Observer observer);// hủy đối tượng đăng ký lắng nghe thông báo
4.     public void notifyObserver();//thong bao đến tất cả các đối tượng đã đăng ký thông báo.
5. }

Và class Product sẽ triển khai interface trên:

1. public class Product implements Subject{
2. private List<Observer> obs = new ArrayList<Observer>();
3. private String nameProduct;
5. public Product(String nameProduct) {
6. super();
7. this.nameProduct = nameProduct;
8. }
9. 
   
10. @Override
11. public void attachObserver(Observer observer) {
12. obs.add(observer);
13. }
14. 
    
15. @Override
16. public void detachObserver(Observer observer) {
17. obs.remove(observer);
18. }
19. 
    
20. @Override
21. public void notifyObserver() {
22. for(Observer ob : obs){
23. ob.update(nameProduct);
24. }
25. }
26. }

Ok đến đây ta đã có một class có thể thông báo đến các observer và observer sẽ phản ứng lại với thông báo này. Tạo hàm main như sau:

1. public class Main {
2. public static void main(String[] args) {
3. Customer cus1 = new Customer("Ti", 11);
4. Customer cus2 = new Customer("Teo", 12);
5. Product product1 = new Product("Laptop");
6. product1.attachObserver(cus1);//cus1 dang ky phan ung khi có thông báo từ product
7. product1.attachObserver(cus2);
8. product1.notifyObserver();//thông báo đến tất cả các Observer.
9. }
10. }

Oke vậy đã xong Observer.

Read More

Design Pattern .Lời mở đầu!

Design Pattern là một tứ khá là quan trọng mà mọi lập trình viên muốn giỏi đều phải biết. Được sử dụng thường xuyên trong các ngôn ngữ OOP. Nó sẽ cung cấp cho bạn các "mẫu thiết kế", giải pháp để giải quyết các vấn đề chung, thường gặp trong lập trình. Các vấn đề mà bạn gặp phải có thể bạn sẽ tự nghĩ ra cách giải quyết nhưng có thể nó chưa phải là tối ưu. Design Pattern giúp bạn giải quyết vấn đề một cách tối ưu nhất, cung cấp cho bạn các giải pháp trong lập trình OOP.

Trong Design Pattern có 3 nhóm bao gồm:
   - Creational Pattern (nhóm khởi tạo) gồm : Abstract Factory, Factory Method, Singleton, Builder, Prototype. Nó sẽ giúp bạn trong việt khởi tạo đối tượng, như bạn biết để khởi tạo bạn phải sử dụng từ khóa new, nhóm Creational Pattern sẽ sử dụng một số thủ thuật để khởi tạo đối tượng mà bạn sẽ không nhìn thấy từ khóa này.
   - Structural Pattern (nhóm cấu trúc) gồm : Adapter, Bridge, Composite, Decorator, Facade, Proxy và Flyweight.. Nó dùng để thiết lập, định nghĩa quan hệ giữa các đối tượng.
   - Cuối cùng là nhóm Behavioral Pattern gồm : Interpreter, Template Method, Chain of Responsibility, Command,  Iterator, Mediator, Memento, Observer, State, Strategy và Visitor. Nhóm này dùng trong thực hiện các hành vi của đối tượng.

Design Pattern giúp bạn tái sử dụng mã lệnh và dẽ dàng mở rộng.

Để chuẩn bị học Design Pattern bạn cần phải nắm chắc các khái niệm sau :
   - Bốn đặc tính của OOP : Thừa kế, Đa hình, Trừu tượng, Bao đóng.
   - Khái niệm interface và abstract . Cái này cực kỳ quan trọng, để hiểu và áp dụng 2 khái niệm này có thể sẽ mất một thời gian, nhưng khi bạn nắm chắc nó bạn sẽ thấy nó thực sự cần thiết.
   - Bỏ tư duy theo lối cấu trúc, nâng tư duy hoàn toàn OOP.

Nếu có khó khăn trong công việc chuẩn bị trên, bạn có thể liên hệ mình, mình sẽ cố gắng giúp bổ sung cho bạn những kiến thức cơ bạn trong OOP. Sau khi bạn đã nắm chắc các thứ kể trên, bạn nên bắt tay vào học Design Pattern càng sớm càng tốt. Sau khi biết Design Pattern giúp bạn đặt trình cao mới .

Trong loạt bài về Design Pattern sắp tới, mình sẽ đặt ra 3 câu hỏi : Nó là gì? Khi nào thì áp dụng nó? Và Áp dụng nó như thế nào. Hy vọng các bạn có thể hiểu và áp dụng nó một cách nhanh nhất. Mọi thắc mắc trong bài viết các bạn có thể để lại comment hoặc liên hệ với mình. Một số link về Design pattern :
 - http://www.mif.vu.lt/~donatas/PSArchitekturaProjektavimas/Library/refcards/refcard-designpatterns.pdf

 - http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf

Read More

Design Pattern - Singleton

Mẫu thiết kế singleton:
Nó là gì?
Mẫu thiết kế singleton đảm bảo chỉ duy nhất môt thực thể của một class được tạo ra và nó sẽ cung cấp cho bạn một phương thức để truy cập đến thực thế đó.
Kiểm soát việc tạo ra các thực thể nhưng có thể lấy ra thực thế.
Dùng nó trong trường hợp nào?
Khi bạn tạo ra một class mà bạn chỉ muốn chỉ có duy nhất một thực thể là thể hiện của class đó và bạn có thể truy cập đến nó ở bất kỳ nơi đâu khi bạn muốn.
Ví dụ như : Khi bạn tạo ra một class làm việc với file, config ,class lưu collection dùng chung, hoặc database . Bản chỉ cần duy nhất một thực thể của class đó và bạn sẽ sử dụng nó ở bất kỳ nơi đâu.
Dùng nó như thế nào?
Đầu tiên tôi tạo ra một class với tên là Database. Để không class nào có thể khỏi tạo nó (đảm bảo duy nhất có một thực thể) tôi sẽ private contructor của class trên.

1. public class Database{
      private Database();
   }
   

Và tạo một thuộc tính có tên là INSTANCE có kiểu Database  và một phương trả về thuộc tính đó. Để các class khác có thể sử dụng phương thức này, tôi thêm từ khóa static để biến phương thức này thành phương thức của lớp.

1. private Database INSTANCE;
2. public static Database getInstance(){
3.    if(INSTANCE == null){
4.       INSTANCE = new Database();
5.    }
6.    return INSTANCE;
7. }
   

Như trên tôi kiểm tra xem INSTANCE có bằng null hay không. Nếu bằng null thì tôi tạo một đối tượng. Và trả về INSTANCE.
Có một vấn đề xảy ra. Nếu có hai luồng (thread) chạy song song và thực hiện hàm if thì sẽ có 2 thực thể được tạo ra. Để tránh trường hợp này mình thêm từ khóa synchronized. Khi hàm getInstance đã được chạy thì bất kỳ các luồng khác phải đợi hàm này chạy xong mới gọi được.

1. public static synchronized Database getInstance(){
2.    if(INSTANCE == null){
3.      INSTANCE = new Database();
4.    }
5.    return INSTANCE;
6. }
   

Ok đến đây đã khá ổn nhưng sử dụng từ khóa synchronized đồng nghĩa với việc các luồng có thể phải đợi chờ lâu vì phải đợi luồng đang gọi hạm getInstance chạy xong mới gọi được. Để tránh trường hợp này, tôi sẽ tạo 1 thực thể của lớp Database ngày khi class này được sử dụng, và sử dụng từ khóa final để ngăn không cho thay đổi đối tượng mà INSTANCE trỏ đến  :

1. private static final Database INSTANCE = new Database();
   

Lúc này hàm getInstance sẽ trả về đối tượng INSTANCE:

1. public static Database getInstance(){
2.    return INSTANCE;
3. }
   
   

Để truy cập đến thực thể của class Database bạn thực hiện : Database.getInstance() lúc này trả về 1 thực thể có kiểu Database.

OK ! Đến đây bạn có thể chắc chắn rằng sẽ chỉ có duy nhất một thực thể của class Database được tạo ra và bạn có thể sử dụng hàm getInstance để truy cập vào thực thế đó. Việc còn lại là bạn viết các phương thức, các setter, getter cho nó. Đây chính là mẫu thiết kế singleton.

Read More