Move to WriterSide

Writerside/hi.tree

@@ -4,7 +4,8 @@
 
 <instance-profile id="hi"
                  name="Help Instance"
-                 start-page="Default-topic.md">
+                 start-page="1. Intro.md">
 
-    <toc-element topic="Default-topic.md"/>
+    <toc-element topic="1. Intro.md"/>
+    <toc-element topic="2. Creational Patterns.md"/>
 </instance-profile>

Writerside/topics/1. Intro.md

@@ -0,0 +1,86 @@
+# 1. Giới thiệu Design Pattern
+
+## Định nghĩa Design Pattern
+
+Design Pattern là một mô hình thiết kế được sử dụng để giải quyết một vấn đề cụ thể trong lập trình. Nó cung cấp một giải pháp đã được kiểm nghiệm và tối ưu hóa, giúp các lập trình viên tiết kiệm thời gian và công sức khi phát triển phần mềm
+
+## Lịch sử ra đời và phát triển
+
+Design Pattern được khai sinh vào những năm 1970 với sự phát triển của lập trình hướng đối tượng (OOP). Kể từ đó, nó đã trở thành một phần quan trọng trong quá trình phát triển phần mềm.
+
+Năm 1994, ba lập trình viên Erich Gamma, Richard Helm, Ralph Johnson và John Vlissides đã xuất bản cuốn sách "Design Patterns: Elements Of Resuable Object - Oriented Software". Cuốn sách này đã trở thành một trong những tài liệu tham khảo quan trọng nhất về Design Pattern.
+
+Trong những năm gần đây, Design Pattern tiếp tục được phát triển và mở rộng. Ngày càng có nhiều Design Pattern mới được giới thiệu, phù hợp với các yêu cầu mới của lâp trình.
+
+## Ý nghĩa và lợi ích của Design Pattern
+
+Design Pattern mang lại nhiều ý nghĩa và lợi ích cho lập trình, bao gồm:
+
+- **Giúp giải quyết vấn đề một cách hiệu quả và tối ưu:** Design Pattern cung cấp các giải pháp đã được kiểm nghiệm và tối ưu hóa, giúp các lập trình viên giải quyết các vấn đề một cách nhanh chóng và hiêu quả.
+- **Tăng tính tái sử dụng của code:** Design Pattern giúp các lập trình viên tái sử dụng code đã có, từ đó giảm thiểu thời gian và công ức phát triển phần mềm.
+- **Tăng tính bảo trì và bảo dưỡng của phần mềm:** Design Pattern giúp phần mềm dễ dàng bảo trì và bảo dưỡng hơn.
+- **Tăng tính dể hiểu và dễ đọc của code:** Design Pattern giúp code dễ hiểu và dễ đọc hơn, giúp việc công tác giữa các lập trình viên trở nên dễ dàng hơn.
+
+Design Pattern là một kỹ thuật nâng cao của OOP, nó cực kì quan trọng trong lập trình. Nó mang lại nhiều ý nghĩa và lợi ích cho lập trình, giúp các lập trình viên phát triển phần mềm hiệu quả hơn.
+
+# 2. Phân loại Design Pattern
+
+## Creational Design Patterns
+
+Creational Design Patterns liên quan tới việc khởi tạo đối tượng. Nhóm pattern này cung cấp các cơ chế tạo đối tượng một cách linh hoạt và phù hợp với bối cảnh sử dụng. Một số pattern phổ biến:
+
+- [Singleton](2.1%20Singleton.md), [Factory Method](2.3%20Factory%20Method.md), [Abstract Factory](2.4%20Abstract%20Factory.md), [Builder](2.2%20Builder.md), [Prototype](2.5%20Prototype.md)
+
+Sử dụng Creational Patterns giúp tạo ra các đối tượng một cách linh hoạt, dễ dàng thay đổi và tối ưu hóa bộ nhớ.
+## Structural Design Patterns
+
+Structural Patterns liên quan tới cấu trúc và mối quan hệ giữa các lớp, đối tượng. Nhóm này giúp xây dựng cấu trúc phần mềm dễ thay đổi và bảo trì. Một số pattern:
+
+- [Adapter](3.1%20Adapter.md), [Bridge](3.2%20Bridge.md), [Composite](3.4%20Composite.md), [Decorator](3.5%20Decorator.md), [Facade](3.6%20Facade.md), [Flyweight](3.7%20Flyweight.md), [Proxy](3.8%20Proxy.md)
+
+Sử dụng Structural Patterns giúp xây dựng hệ thống linh hoạt, dễ mở rộng và tối ưu hóa bộ nhớ.
+
+## Behavioral Design Patterns
+
+Behavioral Patterns liên quan tới hành vi giao tiếp giữa các đối tượng. Nhóm này giúp định nghĩa rõ ràng mối quan hệ giữa các object. Một số pattern:
+
+- [Chain of Responsibility](4.1%20Chain%20of%20Responsibility.md), [Command](4.2%20Command.md), [Iterator](4.3%20Iterator.md), [Mediator](4.4%20Mediator.md), [Memento](4.5%20Memento.md), [Observer](4.6%20Observer.md), [State](4.7%20State.md), [Strategy](4.8%20Strategy.md), [Template Method](4.9%20Template%20Method.md), [Visitor](4.10%20Visitor.md)
+
+Sử dụng Behavioral Patterns giúp tạo hệ thống linh hoạt, dễ thay đổi và tối ưu hóa hiệu suất.
+
+# 3. Sử dụng Design Pattern
+
+## Nguyên tắc và phương pháp áp dụng Design Pattern
+
+### Nguyên Tắc
+
+Để áp dụng Design Pattern hiệu quả, các lập trinh viên cần nắm được các nguyên tắc và phương pháp sau đây:
+
+- **Nguyên tắc đầu tiên là phải hiểu rõ vấn đề cần giải quyết:** Trước khi áp dụng Design Pattern, các lập trinh viên cần hiểu rõ vấn đề cần giải quyết là gì. Từ đó, họ có thể lựa chọn được Design Pattern phù hợp nhất.
+
+- **Nguyên tắc thứ hai là phải hiểu rõ Design Pattern:** Các lập trình viên cần hiểu rõ bản chất và cách hoạt động của Design Pattern. Từ đó, họ có thể áp dụng Design Pattern một cách chính xác và hiệu quả.
+
+- **Nguyên tắc thứ ba là phải linh hoạt trong việc áp dụng Design Pattern:** Không phải lúc nào cũng có thể áp dụng Design Pattern một cách cứng nhắc. Các lập trình viên cần linh hoạt trong việc áp dụng Design Pattern để phù hợp với nhu cầu cụ thể của dự án.
+
+### Phương pháp
+
+- **Phương pháp trực tiếp:** Phương pháp này áp dụng Design Pattern một cách trực tiếp, không cần thay đổi cấu trúc của code.
+
+- **Phương pháp gián tiếp:** Phương pháp này sử dụng các thư viện hoặc framework để áp dụng Design Pattern.
+
+
+## Lợi ích của việc sử dụng Design Pattern trong phát triển phần mềm
+
+- **Giúp giải quyết vấn đề một cách hiệu quả và tối ưu:** Design Pattern cung cấp các giải pháp đã được kiểm nghiệm và tối ưu hoá, giúp các lập trình viên giải quyết các vấn đề một cách nhanh chóng và hiệu quả hơn.
+- **Tăng tính tái sử dụng của code:** Design Pattern giúp các lập trình viên tái sử dụng code đã có, từ đó giảm thiểu thời gian và công sức phát triển phần mềm.
+- **Tăng tính linh hoạt và mở rộng của phần mềm:** Design Pattern giúp phần mềm linh hoạt và dễ dàng mở rộng khi có nhu cầu thay đổi.
+- **Tăng tính bảo trì và bảo dưỡng của phần mềm:** Design Pattern giúp phền mềm dễ dàng bảo trì và bảo dưỡng hơn.
+- **Tăng tính dễ hiểu và dễ đọc của code:** Design Pattern giúp code dễ hiểu và dễ đọc hơn, giúp việc công tá giữa các lập trình viên trở nên dễ dàng.
+
+## Lưu ý khi áp dụng Design Pattern
+
+Khi áp dụng Design Pattern, các lập trình viên cần lưu ý những điểm sau:
+
+- **Không nên áp dụng Design Pattern một cách cứng nhắc:** Design Pattern là một giải pháp tổng thể, không phải là một giải pháp hoàn hảo. Các lập trình viên cần linh hoạt trong việc áp dụng Design Pattern để phù hợp với nhu cầu cụ thể của dự án.
+- **Không nên làm dụng Design Pattern:** Design pattern không phải là một giải pháp cho mọi vấn đề. Các lập trình viên chỉ nên áp dụng Design Pattern khi nó thực sự cần thiết.
+- **Cần có thời gian để học hỏi và nghiên cứu Design Pattern:** Design Pattern là một kỹ thuật phức tạp, cần có thời gian để học hỏi và nghiên cứu. Các lập trình viên không nên vội vàng áp dụng Design Pattern mà không hiểu rõ bản chất và cách hoạt động của nó.

Writerside/topics/2. Creational Patterns.md

@@ -0,0 +1,25 @@
+# Giới thiệu Design Pattern
+
+Creational Patterns cung cấp các giải pháp khởi tao đối tượng một cách linh hoạt và phù hợp với bối cảnh sử dụng. Các Pattern thuộc nhóm này gồm:
+
+## [Singleton](2.1%20Singleton.md)
+
+Đảm bảo chỉ có duy nhất một instance của một class trong toàn bộ chương trình.
+
+## [Factory Method](2.3%20Factory%20Method.md)
+
+Định nghĩa một interface để tạo các đối tượng trong superclass nhưng cho phép lớp con quyết định instance nào sẽ được tạo.
+
+## [Abstract Factory](2.4%20Abstract%20Factory.md)
+
+Cung cấp một interface để tạo ra các họ đối tượng liên quan hoặc phụ thuộc lẫn nhau.
+
+## [Builder](2.2%20Builder.md)
+
+Tách biệt quá trình khởi tạo đối tượng phức tạp khởi các đại diện của nó
+
+## [Prototype](2.5%20Prototype.md) 
+
+Tạo ra các đối tượng dựa trên một mẫu đối tượng ban đầu
+
+Các Pattern này giải quyết vấn đề khởi tạo đối tượng một cách linh hoạt, thay vì khởi tạo trực tiếp bằng từ khóa new. Giúp tăng tính mềm dẻo và tái sử dụng code.

Writerside/topics/2.1 Singleton.md

@@ -0,0 +1,189 @@
+# Singleton
+
+## Giới thiệu
+
+Singleton là một Design Pattern thuộc nhóm Creational Pattern. Nó đảm bảo chỉ duy nhất một thể hiện của một lớp được tạo ra trong suốt chương trình.
+### Đặt vấn đề
+
+Trong nhiều trường hợp, cần đảm bảo chỉ có một thể hiện của một lớp. Ví dụ trong hệ thống quản lý người dùng, chỉ nên có duy nhất một đối tượng UserManager để quản lý người dùng.
+
+Nếu tạo nhiều đối tượng UserManager có thể dẫn đến:
+
+- Dữ liệu bị trùng lặp
+- Xung đột tài nguyên
+- Khó kiểm soát
+
+```mermaid
+graph TD
+    A[User Management System] --> B1[UserManager 1]
+    A --> B2[UserManager 2]
+    A --> B3[UserManager 3]
+
+    B1 --> C[User 1]
+    B2 --> D[User 2]
+    B3 --> E[User 3]
+
+    classDef grey fill:#dddddd,stroke:#333333,stroke-width:2px;
+    classDef pink fill:#ffd6d6,stroke:#333,stroke-width:2px;
+
+    class A grey
+    class B1,B2,B3 grey
+    class C,D,E pink
+```
+
+### Giải quyết
+
+Singleton giải quyết bằng cách đảm bảo chỉ tạo duy nhất một thể hiện trong toàn bộ chương trình.
+
+```mermaid
+graph TD
+
+    A[User Management System] --> B[UserManager]
+
+    B --> C[User 1]
+    B --> D[User 2]
+    B --> E[User 3]
+
+    classDef grey fill:#dddddd,stroke:#333333,stroke-width:2px;
+    classDef pink fill:#ffd6d6,stroke:#333,stroke-width:2px;
+
+    class A grey
+    class B grey
+    class C,D,E pink
+```
+
+Giải thích:
+
+- Lớp UserManager được triển khai Singleton
+- Chỉ có DUY NHẤT một đối tượng UserManager trong hệ thống
+- Quản lý tất cả người dùng một cách tập trung
+- Tránh được các vấn đề như dữ liệu trùng lặp, xung đột tài nguyên, khó kiểm soát
+
+Với cách triển khai này, chỉ có một đối tượng UserManager duy nhất được tạo ra, và đối tượng này có thể được truy cập từ bất kỳ nơi nào trong chương trình.
+
+### Cấu tạo
+
+Singleton Pattern có cấu trúc đơn giản, bao gồm các thành phần sau:
+
+```mermaid
+classDiagram
+    direction TB
+    class Singleton {
+        -static instance:Singleton
+        -Singleton()
+        +static getInstance() : Singleton
+    }
+
+    class Client {
+        +main()
+    }
+
+    Client --> Singleton
+    Singleton ..> Singleton : return instance
+```
+
+- Lớp Singleton: Lớp này chứa các phương thức và biến cần thiết để triển khai Singleton Pattern.
+- Phương thức khởi tạo private: Phương thức này chỉ có thể được gọi từ bên trong lớp.
+- Biến static private: Biến này giữ đối tượng của lớp.
+- Phương thức static public để trả về đối tượng của lớp: Phương thức này trả về đối tượng của lớp.
+
+
+## Cách triển khai
+
+Có nhiều cách để triển khai Singleton Pattern trong Java. Một cách phổ biến là sử dụng một biến static private để lưu trữ instance của class.
+
+```java
+public class Singleton {
+
+    private static Singleton instance;
+
+    private Singleton() {
+        // Constructor is private to prevent direct instantiation
+    }
+
+    public static Singleton getInstance() {
+        if (instance == null) {
+            instance = new Singleton();
+        }
+        return instance;
+    }
+}
+```
+
+Cách triển khai này đảm bảo rằng chỉ có một instance của Singleton được tạo ra. Khi một đối tượng Singleton được yêu cầu, phương thức `getInstance()` sẽ kiểm tra xem instance đã tồn tại hay chưa. Nếu chưa, phương thức sẽ tạo ra một instance mới. Nếu đã tồn tại, phương thức sẽ trả về instance hiện tại.
+
+Một cách triển khai khác của Singleton Pattern là sử dụng một biến static final private.
+
+```java
+public final class Singleton {
+
+    private static final Singleton instance = new Singleton();
+
+    private Singleton() {
+        // Constructor is private to prevent direct instantiation
+    }
+
+    public static Singleton getInstance() {
+        return instance;
+    }
+}
+```
+
+Cách triển khai này tương tự như cách triển khai đầu tiên, nhưng nó sử dụng một biến static final private thay vì một biến static private. Cách triển khai này có một số ưu điểm như sau:
+
+- Sử dụng biến static final private sẽ ngăn chặn việc thay đổi giá trị của biến instance.
+- Cấu trúc code sẽ gọn gàng hơn.
+
+
+## Ví dụ minh họa
+
+Dưới đây là một ví dụ minh họa cách sử dụng Singleton Pattern để tạo một đối tượng DatabaseConnection.
+
+```java
+public class DatabaseConnection {
+
+    private static final DatabaseConnection instance = new DatabaseConnection();
+
+    private DatabaseConnection() {
+        // Connect to database
+    }
+
+    public static DatabaseConnection getInstance() {
+        return instance;
+    }
+
+    public void query(String sql) {
+        // Execute query
+    }
+}
+```
+
+Trong ví dụ này, DatabaseConnection là một class singleton. Nó có một phương thức getInstance() để truy cập instance duy nhất của class.
+
+## So sánh
+
+Singleton Pattern có thể được so sánh với một số Design Pattern tương tự, chẳng hạn như:
+
+- Factory Pattern: Factory Pattern cung cấp một cách để tạo các đối tượng của lớp một cách linh hoạt. Tuy nhiên, Factory Pattern không đảm bảo rằng chỉ có một đối tượng của lớp được tạo ra.
+- Prototype Pattern: Prototype Pattern cung cấp một cách để tạo các bản sao của đối tượng. Prototype Pattern cũng có thể được sử dụng để tạo một đối tượng duy nhất của lớp. Tuy nhiên, Prototype Pattern có thể phức tạp hơn Singleton Pattern.
+
+## Lưu ý
+
+Khi áp dụng Singleton Pattern, cần lưu ý một số điểm sau:
+
+- Singleton Pattern có thể làm giảm tính linh hoạt của ứng dụng. Ví dụ, nếu bạn cần tạo ra nhiều instance của một class, bạn sẽ cần phải thay đổi code để xóa phương thức getInstance().
+- Singleton Pattern có thể gây ra vấn đề khi test. Ví dụ, nếu bạn đang test một class sử dụng Singleton Pattern, bạn sẽ cần tạo ra một instance giả của class đó.
+
+
+## Kết luận
+
+Singleton Pattern là một Design Pattern hữu ích trong những trường hợp cần đảm bảo rằng chỉ có một thể hiện duy nhất của một lớp được tạo ra. Tuy nhiên, cần lưu ý những điểm hạn chế của Singleton Pattern khi áp dụng.
+
+Dưới đây là một số hướng dẫn sử dụng Singleton Pattern:
+
+- Nên sử dụng Singleton Pattern khi cần đảm bảo rằng chỉ có một thể hiện duy nhất của một lớp được tạo ra.
+- Tránh sử dụng Singleton Pattern khi không cần thiết.
+- Hạn chế sử dụng Singleton trong các hệ thống lớn hoặc phức tạp.
+
+
+