Trong quyển GoF Design Pattern có 23 mẫu thiết kế và khi được phân chia theo mục đích sử dụng thì có 5 mẫu kiến tạo (creational pattern) bao gồm: Abstract factory, Builder, Factory method, Prototype và Singleton. Creational Pattern trừu tượng hóa quá trình khởi tạo object. Các mẫu creational giúp hệ thống không phải phụ thuộc vào cách một object được tạo ra, xây dựng và thể hiện.

1. Mục đích và ý nghĩa

Prototype Pattern giúp cho việc khởi tạo object bằng một object nguyên mẫu (prototype), là copy của object “mẫu” đó. Ý tưởng của mẫu là chúng ta được cung cấp một object và sẽ dùng chính object này để như là một hình mẫu (template) khi cần tạo lập một đối tượng mới. Việc tạo lập object mới sẽ dựa trên object mẫu mà không sử dụng toán tử new hoặc constructor … được cụng cấp bởi ngôn ngữ lập trình. Lý do là chúng ta không biết được thông tin nội tại chi tiết bên trong object và object có thể che dấu và chỉ cung cấp ra bên ngoài một lượng thông tin giới hạn. Do vậy ta không thể dùng toán tử new và sao chép những dữ liệu được object cung cấp (vốn không đầy đủ) cho một object mới. Cách tốt nhất là để cho chính object “mẫu” tự xác định thông tin và dữ liệu sao chép.

2. Cấu trúc

- Prototype: Cung cấp interface để copy chính bản thân nó (phương thức clone())

- ConcreatePrototype: Implement interface được cung cấp bởi Prototype để copy chính bản thân nó. (thể hiện cụ thể phương thức clone())

- Client: Tạo một object mới bằng cách yêu cầu prototype copy chính bản thân nó.

3. Ưu và nhược điểm

Prototype ẩn đi những lớp con rời rạc từ phía client, do vậy làm giảm đi số lớp con mà client cần biết. Hơn thế nữa pattern này làm cho client hoạt động với những lớp con cụ thể mà không phải thay đổi gì.

Sau đây là một vài lợi ích khác của prototype pattern:

- Thêm và loại bỏ lớp concreate lúc run-time: Prototype hợp nhất quá trình khởi tạo một object mới vào trong hệ thống đơn giản chỉ bằng cách đăng ký một thực thể nguyên mẫu với client. Điều đó linh động hơn một chút so với các mẫu kiến tạo khác bởi vì client có thể cài đặt và loại bỏ các nguyên mẫu tại thời điểm run-time.

- Khởi tạo object mới bằng cách thay đổi một vài attribute của object (các object có ít điểm khác biệt nhau): Một hệ thống linh động sẽ để cho chúng ta tự define một hành động nào đó thông qua sự kết hợp với một object (nghĩa là một phương thức của một class) hơn là define một class mới. Client có thể thể hiện một tác động khác bằng cách ủy quyền cho lớp prototype. Đồng thời cách thức khởi tạo này cũng giúp cho chúng ta khai báo một “lớp mới” mà không phải lập trình gì cả. Thực tế thì việc copy một nguyên mẫu giống như việc khởi tạo một object từ một class mới. Prototype pattern giúp giảm số lớp mà hệ thống cần dùng.

- Khởi tạo object mới bằng cách thay đổi cấu trúc: Rất nhiều ứng dụng xây dựng hệ thống từ nhiều phần và các phần con. Các phần con lại khởi tạo từ nhiều phần con khác (chia nhỏ bài toán). Prototype pattern cũng hỗ trợ điều này. Nghĩa là các phần có đó có thể được khởi tạo từ việc copy một nguyên mẫu từ một “cấu trúc” khác. Miễn là các phần kết hợp đều thể hiện Clone() và được sử dụng với cấu trúc khác nhau làm nguyên mẫu.

- Giảm việc phân lớp: Đôi khi hệ thống quá phức tạp vì có quá nhiều class, và cây thừa kế của lớp khởi tạo có quá nhiều lớp song song cùng mức. Prototype pattern rõ ràng làm giảm số lớp và sự phức tạp của cây thừa kế (class hierarchy)

Một điểm hạn chế của prototype pattern là đôi khi việc phải implement mỗi phương thức clone() của mỗi lớp con của Prototype sẽ gặp khó khăn. Ví dụ như việc implement clone() sẽ khó khăn khi mà những object nội hàm của chúng không hỗ trợ việc copy hoặc có một reference (không copy được reference. Xem bài phân biệt pointer và reference).

4. Implementation

Trong C++ cài đặt rất đơn giản sử dụng copy constructor hoặc assignment operator.

Ví dụ mẫu:

#include <iostream>
#include <map>

using namespace std;

enum RECORD_TYPE_en
{
    CAR,
    BIKE,
    PERSON
};

/**
 * Record is the Prototype
 */

class Record
{
  public :
    Record() {}
    ~Record() {}

    Record* Clone()=0;
    virtual void Print()=0;
};

/**
 * CarRecord is Concrete Prototype
 */

class CarRecord : public Record
{
  private :
    string m_oStrCarName;
    u_int32_t m_ui32ID;

  public :
    CarRecord(string _oStrCarName,u_int32_t _ui32ID)
    : Record(), m_oStrCarName(_oStrCarName),
      m_ui32ID(_ui32ID)
    {
    }

    CarRecord(CarRecord& _oCarRecord)
    : Record()
    {
        m_oStrCarName = _oCarRecord.m_oStrCarName;
        m_ui32ID = _oCarRecord.m_ui32ID;
    }

    ~CarRecord() {}

    Record* Clone()
    {
        return new CarRecord(*this);
    }

    void Print()
    {
        cout << "Car Record" << endl
             << "Name  : " << m_oStrCarName << endl
             << "Number: " << m_ui32ID << endl << endl;
    }
};

/**
 * BikeRecord is the Concrete Prototype
 */

class BikeRecord : public Record
{
  private :
    string m_oStrBikeName;
    u_int32_t m_ui32ID;

  public :
    BikeRecord(string _oStrBikeName,u_int32_t _ui32ID)
    : Record(), m_oStrBikeName(_oStrBikeName),
      m_ui32ID(_ui32ID)
    {
    }

    BikeRecord(BikeRecord& _oBikeRecord)
    : Record()
    {
        m_oStrBikeName = _oBikeRecord.m_oStrBikeName;
        m_ui32ID = _oBikeRecord.m_ui32ID;
    }

    ~BikeRecord() {}

    Record* Clone()
    {
        return new BikeRecord(*this);
    }

    void Print()
    {
        cout << "Bike Record" << endl
             << "Name  : " << m_oStrBikeName << endl
             << "Number: " << m_ui32ID << endl << endl;
    }
};

/**
 * PersonRecord is the Concrete Prototype
 */

class PersonRecord : public Record
{
  private :
    string m_oStrPersonName;

    u_int32_t m_ui32Age;

  public :
    PersonRecord(string _oStrPersonName, u_int32_t _ui32Age)
    : Record(), m_oStrPersonName(_oStrPersonName),
      m_ui32Age(_ui32Age)
    {
    }

    PersonRecord(PersonRecord& _oPersonRecord)
    : Record()
    {
        m_oStrPersonName = _oPersonRecord.m_oStrPersonName;
        m_ui32Age = _oPersonRecord.m_ui32Age;
    }

    ~PersonRecord() {}

    Record* Clone()
    {
        return new PersonRecord(*this);
    }

    void Print()
    {
        cout << "Person Record" << endl
             << "Name : " << m_oStrPersonName << endl
             << "Age  : " << m_ui32Age << endl << endl ;
    }
};

/**
 * RecordFactory is the client
 */

class RecordFactory
{
  private :
    map<RECORD_TYPE_en, Record* > m_oMapRecordReference;

  public :
    RecordFactory()
    {
        m_oMapRecordReference[CAR]  = new CarRecord("Ferrari", 5050);
        m_oMapRecordReference[BIKE] = new BikeRecord("Yamaha", 2525);
        m_oMapRecordReference[PERSON] = new PersonRecord("Tom", 25);
    }

    ~RecordFactory()
    {
        delete m_oMapRecordReference[CAR];
        delete m_oMapRecordReference[BIKE];
        delete m_oMapRecordReference[PERSON];
    }

    Record* CreateRecord(RECORD_TYPE_en enType)
    {
        return m_oMapRecordReference[enType]->Clone();
    }
};

int main()
{
    RecordFactory* poRecordFactory = new RecordFactory();

    Record* poRecord;
    poRecord = poRecordFactory->CreateRecord(CAR);
    poRecord->Print();
    delete poRecord;

    poRecord = poRecordFactory->CreateRecord(BIKE);
    poRecord->Print();
    delete poRecord;

    poRecord = poRecordFactory->CreateRecord(PERSON);
    poRecord->Print();
    delete poRecord;

    delete poRecordFactory;
    return 0;
}

Tham khảo thêm: http://www.vincehuston.org/dp/prototype.html

Singleton có lẽ là một trong những pattern có tính trừu tượng dễ hiểu nhất mà người học design pattern nào cũng biết. Trong dự án vừa rồi tôi có phải implement một cái database connection pool và thread pool mà nó chính xác là một singleton object. Tôi đã chọn Singleton để implement những class đó. Tất nhiên singleton chỉ là một phần nhỏ, không phải phần cốt lõi trong những cái pool đó, nhưng trong bài viết này tôi sẽ viết về singleton pattern như là bài viết đầu tiên về loạt bài design pattern tiếp theo. Những bài viết của tôi thường lấy ý tưởng từ những quyển sách kinh điển (nhiều khi là dịch lại – vì họ viết quá xuất sắc và không có gì cần thêm hay bớt). Tôi chỉ cố gắng hiểu một cách sâu sắc nhất và ghi lại theo cách hiểu. Trong ví dụ về design pattern, tôi chọn quyển Gang Of Four – Design Patterns – Elements of Reusable Object-Oriented Sofware, một quyển sách kinh điển nhất về design pattern. Nếu bạn có thời gian thì hãy dành thời gian đọc nó (bằng tiếng Anh để hiểu sâu sắc hơn).

1. Mục đính và ý nghĩa.

- Đảm bảo rằng một class có duy nhất một thực thể (instance) hay đối tượng (object) và cung cấp một cách thức truy nhập toàn cục để có thể từ bất kỳ đâu cũng lấy được instance duy nhất đó. Chúng ta cũng gọi thực thể duy nhất đó là thực thể chính (solely) của class đó.

Đối với một vài class thì việc chỉ có duy nhất một instance (object) là rất quan trọng. Mặc dù có rất nhiều máy in trong hệ thống nhưng chỉ có một printer spooler. Cũng chỉ có một file system và một windows manager. Cũng như trong thiết kế connection pool thì chỉ có một connection pool quản lý nhiều connection.

Làm thế nào để chúng ta đảm bảo một class chỉ có một thể hiện duy nhất và dễ dàng truy nhập được? Một object toàn cục có thể làm cho nó dễ dàng truy nhập được nhưng không ngăn cấm bạn tạo thêm nhiều object khác.

Một giải pháp tốt hơn là làm cho class đó tự bản thân nó có thể điều khiển được thực thể chính của nó. Class đó có thể đảm bảo rằng không có thực thể khác được tạo ra (bằng cách chặn đứng các yêu cầu tạo object mới) và cung cấp cách thức để truy nhập được thực thể chính của nó. Đó là singleton pattern.

2. Cấu trúc

3. Implementation

Phương pháp chung nhất để đảm bảo có một thực thể duy nhất là giấu đi cách thức tạo ra thực thể ở bên trong lớp đó (hoặc là static member function hoặc một member function của class đó) và trong những hàm này thì đã đảm bảo rằng chỉ một thực thể được tạo ra. Có nghĩa là người sử dụng sẽ không thể gọi hàm constructor và destructor mà phải gọi thông qua một member function của lớp. Member function sẽ truy nhập vào biến mà lưu giữ thực thể duy nhất và đảm bảo rằng biến này được khởi tạo với thực thể duy nhất trước khi trả về giá trị. Cách tiếp cận này đảm bảo rằng singleton được tạo ra và khởi tạo trước khi nó được sử dụng lần đầu tiên. Bạn có thể định nghĩa hàm này trong C++ như một static member function Instance() của lớp Singleton. Singleton cũng định nghĩa biến static member variable _instance là con trỏ đến thực thể duy nhất.

class Singleton
{
public:
    static Singleton* Instance();
protected:
    Singleton();
private:
    static Singleton* _instance;
};

Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance ()
{
    if (_instance == 0) {
        _instance = new Singleton;
    }
    return _instance;
}

 

Người sử dụng hoàn toàn truy nhập vào singleton thông qua member function Instance(). Biến _instance được khởi tạo là 0 và Instance() sẽ trả về giả trị của biến đó, khởi tạo nó bởi một thực thể duy nhất nếu nó là 0. Hàm này sử dụng cách thức khởi tạo lười biếng, nghĩa là thực thể không được tạo ra và lưu trữ cho đến khi nó lần đầu được truy nhập.

Chú ý rằng hàm constructor là protected. Người sử dụng cố gắng khởi tạo một thực thể mới Singleton trực tiếp (bằng constructor) sẽ gặp lỗi lúc biên dịch. Điều này đảm bảo rằng chỉ có một thực thể có thể được tạo ra.

Hơn thế nữa, vì _instance là pointer đến đối tượng Singleton, nên member function Instance() có thể gán con trỏ tới một subclass của Singleton vào biến _instance.