<html><body><h2 style="text-align:justify;">1. Install Azure Cosmos Db Emulator</h2><ul><li style="text-align:justify;">You can try this link to download: <a href="https://learn.microsoft.com/en-us/azure/cosmos-db/local-emulator?tabs=ssl-netstd21">Install and develop locally with Azure Cosmos DB Emulator</a></li><li style="text-align:justify;">Step-by-step: follow <a href="https://careers.saigontechnology.com/blog-detail/azure-cosmos-db-overview#toc_2">this topic</a></li></ul><h2 style="text-align:justify;">2. Step by step</h2>This topic will use .NET 6.0 &amp; Visual Studio 2022<h3 style="text-align:justify;">Step 1: New project</h3><ul><li style="text-align:justify;">Create ASP .NET Core Web API</li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-FbtRD6kns5tpRNp6xnoa0GehQ93cITG6EFgeG5Nh.png"><ul><li style="text-align:justify;">Input project name</li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-3fesVkXPIpxxAEQZTCstHPrlaSBiCTDEfOkqbfjI.png"><ul><li style="text-align:justify;">Select framework</li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-yVyUIv5ekDfHjbYyNawgkYP9gkV7BluuhzvfhMxr.png"><ul><li style="text-align:justify;">Result</li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-lyFyg0RRcYghuGbSZwhD2PhMZilue1OdqeEcykmY.png"><ul><li style="text-align:justify;">Add infrastructure folders</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-n9THOXkmjbV8BhiBgDcOt3u1WcLplzb96z5edK1g.png"></figure><ul><li style="text-align:justify;">Enums: Store enumerations, default values, and constant values here.</li><li style="text-align:justify;">Models: Contain DTOs, object definitions: API response, app settings, etc.</li><li style="text-align:justify;">Options: Cosmos client options will be saved here.</li><li style="text-align:justify;">QueryBuilders: Define queries for CosmosDb here.</li><li style="text-align:justify;">Services: we could gather services here: cosmosDb, deployment services, etc.</li></ul><h3 style="text-align:justify;">Step 2: Add cosmosdb services</h3><ul><li style="text-align:justify;">CosmosDb services will have the following:<ul><li style="text-align:justify;">ILogger: used to log information, error, and warning.</li><li style="text-align:justify;">IConfiguration: we stored the database connection in the configuration file, and we need IConfiguration to read data from the configuration file.</li></ul></li><li style="text-align:justify;">Define services here: <ul><li style="text-align:justify;">The first function we need is: GetConnection()</li></ul></li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-ppbHDcryxRENalyoHIgptTLCl99uu24fyycyu85K.png"></figure><ul><li style="text-align:justify;">Private function, cannot be called outside CosmosDb Services</li><li style="text-align:justify;">Get CosmosConnection by using the connection string, environment, and client options from app settings.</li><li style="text-align:justify;">Steps:<ul><li style="text-align:justify;">Create CosmosClient by using a connection string and cosmos client options</li><li style="text-align:justify;">Get the database by using CosmosClient.</li></ul></li><li style="text-align:justify;">Then, we will need a get container function: GetContainer(string containerName)</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-9X1NLPsaMDXDCEGVW676BEoC0Kgstgfj73OxV1Yl.png"></figure><ul><li style="text-align:justify;">The same with GetConnection(), this one is a private function as well.</li><li style="text-align:justify;">We need to create container first, then container will be used to execute query, update, insert, or delete the item.</li><li style="text-align:justify;">At database explorer, click on … to create new container</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-tnybnsT0phg0Eek3NCCXeyAZikO91EyR5nq3Lo22.png"></figure>  <ul><li style="text-align:justify;">Input container name and partition key</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-ujvbtteg2hikiOkNCoULelIDn2lz3JUBod9hYg3Y.png"></figure><ul><li style="text-align:justify;">Input provision throughput</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-k4tff6mQBJS6QPbsP2sj7l66FAx7eBoQUnx9Vg5D.png"></figure><ul><li style="text-align:justify;">Execute:<ul><li style="text-align:justify;">Get container then execute.</li><li style="text-align:justify;">Log the request charge.</li><li style="text-align:justify;">The asynchronous function name should have “async” suffix.</li><li style="text-align:justify;">Get list items</li></ul></li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-WpC2Yxypwj5BWHaj3IAv7qkn7LOJrD7CnOvbieqo.png"></figure>query items<ul><li style="text-align:justify;">Using query definition. For example: select * from c order by c._ts DESC</li><li style="text-align:justify;">Need to know the container name. In the Azure Cosmos Database, data is stored as documents in containers.</li><li style="text-align:justify;">Update item</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-tU4BvYnz7FS9SzcMupWI5KSjuwi4KXWudKXoeoPT.png"></figure>update item<ul><li style="text-align:justify;">Container name is mandatory</li><li style="text-align:justify;">The partition key acts as a logical partition, every single object has to have a property, which is considered the partition key. In this topic, we consider Type as the partition key. That means Type will exist on every single object.</li><li style="text-align:justify;">Selecting a partition key for container is a very important design choice in Azure Cosmos DB. Be careful when selecting which property is the partition key. For example, if id serves as the partition key, and we have over 1000 documents in the container, and there are over 1000 unique id, that means we will have over 1000 partition keys, and the container will be split into over 1000 logical partitions. That’s why the partition key should have a high cardinality. To put it simply, the partition key should have a wide range of possible values.</li><li style="text-align:justify;">Partition key has two components:  partition key path and partition key value. In this topic, partition key path = /Type, partition key value = value of Type property.</li><li style="text-align:justify;">Type value cannot be updated.</li><li style="text-align:justify;">For example: </li></ul><pre><code class="language-plaintext">{
    "id": "b9572c40-56bc-42b4-8bee-8f8dbd650435",
    "Type": "DeploymentRequest"
}</code></pre><ul><li style="text-align:justify;">partition key path = /Type</li><li style="text-align:justify;">partition key value =  DeploymentRequest</li><li style="text-align:justify;">DeploymentRequest cannot be changed</li><li style="text-align:justify;">The <a href="https://www.rfc-editor.org/rfc/rfc8259#section-6">JSON specification</a> calls out that the partition key should only contain string values or you will get into trouble with interoperability problems. </li><li style="text-align:justify;">Insert item</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-CZ6fhtC5lgXdZHMa7ohEu29wlSzZC0AzPzGnzMxq.png"></figure>insert item<ul><li style="text-align:justify;">Container name is required</li><li style="text-align:justify;">Item is any object we want, with Type property because Type is the partition key</li><li style="text-align:justify;">If an item does not have an id, then after the item is inserted successfully, an id will be generated automatically with other system properties: _rid, _self, _etag, _attachments, _ts</li><li style="text-align:justify;">Example: </li></ul><pre><code class="language-plaintext">{
    "id": "b9572c40-56bc-42b4-8bee-8f8dbd650435",
    "Type": "DeploymentRequest",
    "Version": "v4.0.0",
    "VersionStatus": "Missing",
    "Environment": "DEV",
    "Status": "ResourcePending",
    "CreatedUser": "tu.phan@saigontechnology.com",
    "DeploymentDate": "2022-03-22T07:28:06.947Z",
    "CreatedDate": "2022-03-22T07:28:13.2721979Z",
    "Latest": true,
    "HasApprove": false,
    "_rid": "ug1nALpRWxcBAAAAAAAAAA==",
    "_self": "dbs/ug1nAA==/colls/ug1nALpRWxc=/docs/ug1nALpRWxcBAAA==/",
    "_etag": "\"00000000-0000-0000-d6e9-2895e3e001d8\"",
    "_attachments": "attachments/",
    "_ts": 1664774990
}</code></pre><ul><li style="text-align:justify;">Delete an item by id</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-HaetarOEs5MdiZf6W1Hu8fzSxUkpHhgya7bpgCHr.png"></figure>delete item<ul><li style="text-align:justify;">Container name and partition key is mandatory</li><li style="text-align:justify;">id is required, cosmos will delete the document based on document id</li><li style="text-align:justify;">Example: <ul><li style="text-align:justify;">id = "b9572c40-56bc-42b4-8bee-8f8dbd650435"</li><li style="text-align:justify;">partitionKey = "b9572c40-56bc-42b4-8bee-8f8dbd650435"</li><li style="text-align:justify;">containerName = "deployment"</li></ul></li></ul><h3 style="text-align:justify;">Step 3: Add deployment services</h3><ul><li style="text-align:justify;">CosmosServices class is a dependency of deployment services class.</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-CSTmV0qv4KfjFb7lxH0OwJEd42nxPDkl3R5qHnrU.png"></figure><ul><li style="text-align:justify;">Cosmos services are used to save/get deployment request into/from the database<ul><li style="text-align:justify;">Get deployment requests</li></ul></li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-LUblFd8YgrvLhoTbvK1xSXw2xTsYo1NalfOjdxeF.png"></figure><ul><li style="text-align:justify;">Define query as QueryDefinition</li><li style="text-align:justify;">Ex: Get all latest documents with type = DeploymentRequest, order by _ts descending</li></ul>SELECT VALUE cFROM cWhere c.Type = @Type and c.Latest = trueORDER BY c._ts DESC@Type = “DeploymentRequest”<ul><li style="text-align:justify;">Provide container name = deployment</li><li style="text-align:justify;">Partition Key is optional</li><li style="text-align:justify;">Insert deployment</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-w7nP3RwWFCkm77G819Xjc7Mr8XC4uINYglcGTEot.png"></figure><ul><li style="text-align:justify;">input param is the deployment object.</li><li style="text-align:justify;">when inserting, that’s means we are creating a new document, no need to have an id property, if it is missing, it will be generated automatically.</li><li style="text-align:justify;">We should provide container name, and partition key when using cosmos services to insert deployment into database. Because we are considering the input used to insert is an object, we should not get partition key value from the input.</li><li style="text-align:justify;">Ex:</li></ul><pre><code class="language-plaintext"> {
    "Type": "DeploymentRequest",
    "Version": "v4.0.0",
    "VersionStatus": "Missing",
    "Environment": "DEV",
    "Status": "ResourcePending",
    "CreatedUser": "tu.phan@saigontechnology.com",
    "DeploymentDate": "2022-03-22T07:28:06.947Z",
    "CreatedDate": "2022-03-22T07:28:13.2721979Z",
    "Latest": true,
    "HasApprove": false
}</code></pre><ul><li style="text-align:justify;">Update deployment</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-9k017UTGt06ie8tsaNuMF3gzAg9qiDu73312fQO5.png"></figure><ul><li style="text-align:justify;">Input param is the deployment object</li><li style="text-align:justify;">When updating, id, and type are required. If id is missing, container cannot update document, and we will get an error message.</li></ul><h3 style="text-align:justify;">Step 4: Add deployments controller</h3><ul><li style="text-align:justify;">DeploymentServices class is a dependency of the deployment controller class.</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-77g1nFIUpV61NUlEYvkevFt2ay9IdTNGMLHr4JUV.png"></figure><ul><li style="text-align:justify;">The result will be converted to OkObjectResult.</li><li style="text-align:justify;">Define APIs here:<ul><li style="text-align:justify;">Get all deployments</li></ul></li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-2VK6P0AAPHGPwIBkIwRO9N2OIGxDdGgK7AxgOb1d.png"></figure><ul><li style="text-align:justify;">HTTP GET method.</li><li style="text-align:justify;">No need param, we can pass params for pagination purposes later.</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-TMnb7RRsje1jtP1BkPdvJUu8Xvi7ckYQ7vDBOlDz.png"></figure><ul><li style="text-align:justify;">Get deployment by Entity Id</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-YCOkrMCYMyRITEP3g4LdF4eKuUUDegAhIoEhxVfd.png"></figure><ul><li style="text-align:justify;">HTTP GET method.</li><li style="text-align:justify;">EntityId is required. In this topic, we manage documents by state base, that means document will have an id and entityId. </li><li style="text-align:justify;">After the document is updated, id will be generated new, entity id will not be changed, every document will have Latest property. </li><li style="text-align:justify;">The latest document will have Latest = true, and Latest = false for the rest. In this way, we can track the history change of the document.</li><li style="text-align:justify;">The query used to get document by entity id is:</li></ul>SELECT VALUE c FROM c      Where c.EntityId = @EntityId and c.Latest = true<ul><li style="text-align:justify;">Value of @EntityId is entityId param. </li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-h2VcJDPtdS6cPV4a0Pmy4Dn7ibo8roHtObwyyaGW.png"></figure><ul><li style="text-align:justify;">Update deployment</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-vO4AAZz2Ww3OrZSingNk1Ql246leXNNK4osOCVON.png"></figure><ul><li style="text-align:justify;">HTTP PUT method should be used when updating something.</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-Rc2uHlnFHSCcpUQ0sjqWcqkUvJwFnjiobiQzHGwQ.png"></figure><ul><li style="text-align:justify;">Insert deployment</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-4UwdnCs4j7ZmX2t6zV7xpH8nLcybikR9PXqZbgKx.png"></figure><ul><li style="text-align:justify;">HTTP POST method should be used when inserting something.</li><li style="text-align:justify;">System properties are not required</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-gFXhysw5ZNb9DiwuJscbpO6M9sIc0mT4lv2geKnr.png"></figure></body></html>

This article provides a tutorial to create a basic API application with CosmosDb. The domain of this API application is deployment management. After this article, you will be able to create a CRUD RESTful API in .NET 6 and how to read, insert, delete, and update from Azure Cosmos Db using .NET 6 C#.

Basic API application with Azure Cosmos

Azure CosmosDb Series

<html><body><h2>    1. What is Azure Cosmos Db?</h2>Azure Cosmos Db is Microsoft's proprietary globally distributed, launched in May 2017.This is a Cloud-based database. That means your database is built, deployed, and delivered through a cloud platform.It is a NoSQL database. Your database could be stored in multi models-database, such as JSON documents store, Graph DBMS, Key-value store, and Wide column store, instead of columns and rows used by relational databases, such as SQL, Oracle, etc.With Azure Cosmos Db,  which is highly responsive and always online, we can build an application with low latency and high availability, and get the response data in milliseconds. <h2>    2. Why should we use it?</h2>Azure Cosmos Db support multi-model database. You can store data in multiple ways, by using different APIs:<figure class="table"><table class="ck-table-resized"><colgroup><col style="width:50%;"><col style="width:50%;"></colgroup><tbody><tr><td>API</td><td>Database</td></tr><tr><td>SQL API</td><td>JSON document database: non-relational database, store and query data as JSON documents</td></tr><tr><td>MongoDB API</td><td>MongoDB: A source-available cross-platform document-oriented database program</td></tr><tr><td>Cassandra API</td><td>Apache Cassandra: an open-source, NoSQL database, and designed to handle large amounts of data across many commodity servers with high availability and no single point of failure</td></tr><tr><td>Gremlin API</td><td>Graph database: Store data in graph structures, semantic queries with nodes, edges, and properties</td></tr><tr><td>Table API</td><td>Azure Table Storage: Store NoSQL database (non-relational structured data) in the cloud by using a schemaless design and a key/attribute store</td></tr></tbody></table></figure> Azure Cosmos Db will save your life from building a multi-center data environment. If you want to build a large-scale globally distributed application, a multi-center data environment should be required, which will take a lot of time, but Cosmos DB has already supported it and will help you skip those steps. You only have to configure it to replicate your data to all of your targeted regions. Low latency. With 60+ announced regions, you can easily place the data closer to the users, then they can have the minimum latency.Elastic Scale. Your cost is calculated by RU, which is calculated by 1 KB of data in 1 second. We can define max RU to manage throughput requirements and your money. When you set max RU = 1000 RU/s, if the throughput is over 1000 RU/s, an exception will be thrown. Cosmos DB starts rejecting the requests with 429 http status code then you can check your throughput, or update max RU in 2 ways: via the Azure portal or automatically via the Azure CLI.Support to create social media applications. (2)Social media applications need to store User Generated Content (UGC), such as text, images, videos, comments, posts, tweets, etc. UGC is unstructured data, it is a combination of free-form text, relationships, tags, etc. UGC required different and dynamic structures, that's why they cannot be stored in relational databases, which have fixed schema. But NoSQL database, schema-free, can do it. Easy to search content with Azure Cognitive Search - a cloud search service. Azure Cognitive Search provides APIs, and tools for building a search engine within a few minutes. Graph database with gremlin API is the best for sorting social media followers.Cost. 100 RU/s will cost £8.71 per month, a very cheap price for a global data center when compared with planning a multi-center data. So imagine that you have a global data center, and in order to support your applications smoothly, you have to spend plenty of money and time. That’s why we can say: 100 RU/s will cost £8.71 per month is too cheapOn the other hand, we can try CosmosDb for free.You can try this link to download: <a href="https://learn.microsoft.com/en-us/azure/cosmos-db/local-emulator?tabs=ssl-netstd21">Install and develop locally with Azure Cosmos DB Emulator | Microsoft Learn</a>Step by step instructions to install:You have to accept the license term<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-iLrMeBWk7UPHQlQjVX6NBkYA5gIHa6VNiUeXP8PZ.png">Install - Agreethen, installing<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-dAQlUQkDBRdEr9oxijvvNU2cMn6T55Edp2pbdYDl.png">Installingfinish<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-FLTDpZxKeJk5pfV0JmdKC4uBIMkg9CX2AHGI2glU.png">Install - FinishAfter installing, you can go to this Azure Cosmos Db Emulator shortcut to open the emulator<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-WM1s6O6igjkDbnknLMNJOrb4ZPQQi9YcPORX1dmb.png">Emulator - ShortcutAfter opening, you will get the notification at the corner of the screen<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-2wbr3FFehcbfB8ba6OIRwFib6KtmaC0YAx4IQFcw.png">Emulator - Startingand here is the notification when Azure Cosmos Emulator started<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-r45dNmJ4qj1UtWpMFSdnCnjJDTp9SiFyL4JNmThU.png">Emulator - StartedHere is the UI:<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-EID3us1hZbHBDLYQL0ka6rSMJ1fofoTyQvOAGZf4.png">UI - Web - UrlYes, we got the Web UI, with default URL is <a href="https://localhost:8081/_explorer/index.html">LOCAL-Azure Cosmos DB Emulator</a>In the web UI, we can try a sample at 1 <img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-QHLtZ0YAcKUUtkC2L3mBdG84t6E7tFevCLZkHsFU.png">UI - 1or learn more by reading document at 2<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-PYmvCcBdjoQ5YqXBsVQLASp4zF6aZMhOYU6Kolo7.png">UI - 2here is the explorer<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-SV06kpNem2Xu9jQNocVmFPysnKKCLQITxP9H6CVf.png">UI - Explorerthe query UI<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-KURmXJBAPdjFqIFXs0eUJAKt36jcT7azmHRyhAVr.png">UI - Querythe result<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-YIlDxbXuUJcZx7SrHVQkXGHrBRPzTHPIjyFEV2Dv.png">UI - Resultyou also have a minimap (code outline)<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-iWimMFQWqPw84CVHbYOvmEvjnzeYseFFoLaupOPe.png">UI - Minimap<h2>    3. Behind the scenes</h2>Case sensitive and only order by 1 column at default searchQuite expensive if we only have a small or medium systemThe migration of data from on-premises to cloud may take some timeBe careful when using partitioning. Every partition has to have PartitionKey. Microsoft guarantees that all the documents with the same PartitionKey are stored in the same Logical Partition. The maximum size of a logical partition (and consequently a physical partition) could not exceed 20 GB. We should choose the correct PartitionKey to make sure that every logical partition cannot exceed 20 GB.<h2 style="text-align:justify;">    4. When should we use it?</h2>Transactional volumes have many thousands of transactions per secondYou will get some challenges: concurrency, latency, and availabilityDistributed databases are the solution, but maintenance can still be a costly and time-consuming exercise.Azure CosmosDb will handle these challenges. It will be deployed worldwide across all Azure regions. Cloud-based will provide minimum latency and high availabilityDatabase contain many parent-child relationshipsIn this case, document-oriented databases are much better with object-oriented approaches, and Azure CosmosDb provides NoSQL document database.Your system is complex networks and relationshipsRelational databases present a less-than-optimal solution. Because relationships between entities do not actually exist in a relational database.Graph database engines could be considered a re-emergence of the network database paradigm, and Azure CosmosDb has Azure CosmosDb for Gremlin.When you want to build social media applications<h2>    5. Azure Cosmos Database vs SQL Server</h2><figure class="table"><table class="ck-table-resized"><colgroup><col style="width:33.33%;"><col style="width:33.33%;"><col style="width:33.34%;"></colgroup><tbody><tr><td> </td><td>Azure Cosmos Database</td><td>SQL Server</td></tr><tr><td>Type</td><td>NoSQL database</td><td>Relational database</td></tr><tr><td>Cloud-based</td><td>Yes</td><td>No</td></tr><tr><td>Server Operating Systems</td><td>Hosted</td><td>LinuxWindows</td></tr><tr><td>Data Scheme</td><td>Schema-free</td><td>yes</td></tr><tr><td>Query Language</td><td>SQL-like</td><td>SQL</td></tr><tr><td>APIs</td><td>DocumentDB APIGraph API (Gremlin)MongoDB APIRESTful HTTP APITable API</td><td>ADO.NETJDBCODBCOLE DBTabular Data Stream (TDS)</td></tr><tr><td>Supported Programming Languages</td><td>.NetC#JavaJavaScriptJavaScript (Node.js)MongoDB Python</td><td>C#C++DelphiGoJavaJavaScript (Node.js)PHPPythonRRubyVisual Basic</td></tr><tr><td>Scalability Methods</td><td>Scale-out: add more components in parallel to improve performance</td><td>Scale-up: update component to bigger, faster to improve performance</td></tr><tr><td>Database sharding</td><td>Automatically</td><td>Manually</td></tr><tr><td>Hierarchical data(1)</td><td>Document-oriented</td><td>Object-oriented</td></tr></tbody></table></figure> (1):<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-RfeTYop4Z8iWaWCYkDZJjX8oBRaP499biJkLqejt.png">Hierarchical Data- Relation and CosmosDb     Price<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-jb0fgq72CdcX1VNwZ5FW16Z1AVRwW1gphcsZgelP.png">Price-CosmosAzure CosmosDb Price with Region = East US and currency = USD<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-pCBddGwCLk924Bplh4GX5AWy1j6DwmbN6agYeM2f.png">Price-SQL</body></html>

This article provides an overview of the Azure Cosmos DB. Cloud-based NoSQL database, highly responsive, high availability, always online, low latency, multi-model database for managing data at large scales.

Azure Cosmos DB Overview

Tech Lead

Phuong Bui

.NET Developer

Vu Truong

Senior Developer

Trung Tran

Tech lead

Wind

Long Nguyen

Business Analyst

Duong Dat Thanh

<html><body>1. Understand Time-scales: Before diving deep to Instant, let’s discover some time-scales. UT (Universal Time) is a time standard based on Earth's rotation, essentially measuring time as observed from the planet. It reflects the natural cycle of day and night but can vary slightly due to irregularities in Earth's rotation. TAI (Temps Atomique International or International Atomic Time) is a highly precise time standard based entirely on atomic clocks, specifically using the vibrations of Cesium-133 atoms. UTC (Coordinated Universal Time): is the global time standard and is the combination of UT and TAI. It is designed to be more consistent than UT by relying on precise atomic clocks (same as TAI).  Because of tidal acceleration, the Earth’s rotation is gradually slowing down. As a result, at some point some time, the day in UT (solar day) will get longer than today by one atomic second, which means some day’s length will be 86400 + 1 atomic second. The day that will last 1-atomic-second-longer than today. That day is not predictable and can only be figured out by measurement. To deal with the issue, UTC is synchronized with UT through the use of leap seconds, ensuring it stays within ±0.9 seconds of UT, which helps keep it in line with the natural day. As the Earth’s rotation is slowing down, UTC will only add a leap second to be consistent with UT. As an observation, the earth's rotational acceleration is on average 0.002 atomic seconds per day, which means 500 days or 1.5 years will end up with 1 atomic second. Let's take a example: Today, Tuesday, January 20, 2024, which is exactly 86400 atomic seconds. 1.5 years from now, Friday, January 02, 2026, a day will be 86400 + 1 atomic seconds. But the difference between UT and UTC should be within ±0.9 seconds, then at some point of time between today and Friday, January 02, 2026, a leap second will be added at the end of that day, which introduces the 61st second of a minute: yyyy-MM-ddT23:59:60Z. While UTC adds a leap second to be synchronized with UT, TAI, on the other hand, does not. As a result, time in UTC and TAI will be further and further apart. At this moment, TAI is 37 seconds ahead of UTC: <ul><li style="text-align:justify;">UTC: 2024-08-20 14:47:55Z </li><li style="text-align:justify;">TAI: 2024-08-20 14:48:32Z  </li><li style="text-align:justify;">See real-time gap here: <a href="http://leapsecond.com/java/gpsclock.htm">http://leapsecond.com/java/gpsclock.htm</a>  </li></ul>Java Time-scale Although Instant represents a point in time in UTC, it follows a 99%-like UTC time-scale, called Java Time-scale. In Java Time-scale, one day includes exactly 86,400 seconds without a leap second. If a day in UTC contains a leap second, that leap second will be spread equally over the last 1000 seconds of the day, maintaining the appearance of exactly 86400 seconds per day. 2. How Instant is stored in Java Application Instant is an object that: <ul><li style="text-align:justify;">represents a point in time in UTC since 1970-01-01T00:00:00Z, we call 1970-01-01T00:00:00Z an EPOCH. </li><li style="text-align:justify;">with nanosecond precision. </li></ul>To represent a point in time, Instant introduces: <pre><code class="language-plaintext">/**  
* The number of seconds from the epoch of 1970-01-01T00:00:00Z.  
*/  
private final long seconds; </code></pre><ul><li style="text-align:justify;">seconds is the number of seconds from the EPOCH.  </li></ul>If seconds are negative, the instant is before the EPOCH. If seconds are positive, the instant is after the EPOCH. Despite Long.MIN_VALUE is -9,223,372,036,854,775,808, the minimum supported epoch second is -31,557,014,167,219,200, which is -1000000000-01-01T00:00Z (one billion year in the past) and the maximum supported epoch second is 31,556,889,864,403,199, which is 1000000000-12-31T23:59:59Z (the end of 1 billion years in the future). To represent a point in time with nanosecond precision, Instant introduces: <pre><code class="language-plaintext">/**  
* The number of nanoseconds, later along the time-line, from the seconds field.  
* This is always positive, and never exceeds 999,999,999.  
*/  
private final int nanos; </code></pre><ul><li style="text-align:justify;">nanos is always positive, and never bigger than 999,999,999 </li></ul>Some reasons why min/max supported epoch seconds is not Long.MAX/MIN_VALUE: From a usage perspective: <ul><li style="text-align:justify;">The universe is said to be aged 13.7 billion years old; Long.MIN_VALUE will introduce the time since more than 292 billion years. -&gt; Long.MIN_VALUE is not practical. </li><li style="text-align:justify;">292 billion years in the future (which is Long.MAX_VALUE) is an extreme value (compared to human lifetime), making it not practical either. </li><li style="text-align:justify;">According to research, the first humans emerged in Africa around 2 million years ago, so there should not be much historical data that modern-universal applications should deal with.</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Why-epoch-seconds-limits-are-not-long.max-min-value-CyrT3tzrMHPr1rGc2zUR0pnPNQWdhdbmKKBY8e53.webp"></figure><ul><li style="text-align:justify;">±1 billion of year make it have a good buffer in long type and make the year (1 billion) fit in an int. </li></ul>From a technical perspective: <ul><li style="text-align:justify;">Storing extreme value will easily cause exceptions. I asked ChatGPT to calculate the instant of Long.MIN_VALUE, ChatGPT could not answer due to an Overflow issue.</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/calculate-the-instant-of-Long.MIN_VALUE-jWF0AC5aTwa6CQqYCifAZQX00l4fjUhPAzaMX7fM.webp"></figure><ul><li style="text-align:justify;">Limiting the range of value to be far away from the edge will help operations like addition, subtraction, and comparison can be performed safely. </li><li style="text-align:justify;">Storing extremely large values can pose challenges in serialization, database storage, and data transmission. </li></ul>3. Instant.now() Returns the current moment in UTC with precision in: <ul><li style="text-align:justify;">Millisecond: Java 8 </li><li style="text-align:justify;">Microsecond: Java 9, Java 11 </li><li style="text-align:justify;">Nanosecond: Java 17+ </li></ul>Use the below code snippet to run on <a href="https://www.jdoodle.com/online-java-compiler">https://www.jdoodle.com/online-java-compiler</a> with each JDK, you’ll see the difference. <pre><code class="language-plaintext">import java.time.Instant;  
 
public class MyClass {  
 
    public static void main(String args[]) {  
        Instant instant = Instant.now();  
        System.out.println(instant);  
        //2024-08-19T15:47:28.487729962Z  
    }  
} </code></pre>The precision of  Instant.now() can vary between different JVMs and OS/Hardware. On some platforms, you might observe higher precision, while on others, it may be lower. Behind the Scenes of Instant.now() The Instant.now() method provides a seemingly straightforward way to retrieve the current moment in time. But what happens beneath the surface? Let's delve into the intricate workings of this method:   <pre><code class="language-plaintext">//This is simplified implementation from Clock.java without retry  
static Instant currentInstant() {  
    long localOffset = System.currentTimeMillis() / 1000 - 1024;  
    long adjustment = VM.getNanoTimeAdjustment(localOffset);  
    return Instant.ofEpochSecond(localOffset, adjustment);  
} </code></pre> Setting the Local Offset: The code starts by calculating a preliminary offset from the current system time. This offset, represented by localOffset, is obtained by dividing the system time in milliseconds (System.currentTimeMillis()) by 1000 (to convert milliseconds to seconds) and then subtracting 1024 seconds (approximately 17 minutes and 4 seconds). Fine-Tuning with Nanosecond Adjustment: The VM.getNanoTimeAdjustment(localOffset) method is called. This method interacts with the underlying system to determine the precise nanosecond adjustment needed to convert the localOffset to the current UTC time. The returned value, nanoTimeAdjustment, represents the time difference (in nanoseconds) between localOffset and the actual UTC time. Constructing the Instant: Finally, an Instant object is created using the localOffset (seconds since the epoch) and the nanoTimeAdjustment (nanoseconds within the second). Example Breakdown: Imagine the current UTC time is 2024-08-20T15:59:50.123Z, which translates to epoch milliseconds of 1724144390123. Below is how currentInstant() would run: <pre><code class="language-plaintext">long localOffset = System.currentTimeMillis() / 1000 - 1024;  
 
// localOffset = 1724144390123 / 1000 - 1024 = 1724143366  
long adjustment = VM.getNanoTimeAdjustment(localOffset);  
 
// 1024044595000  
return Instant.ofEpochSecond(localOffset, adjustment);  
 
// Instant.ofEpochSecond(1724143366, 1024044595000);   
// 2024-08-20T09:12:18.044595Z </code></pre>Nanosecond Adjustment: Suppose VM.getNanoTimeAdjustment(1724143366) returns 1024044595000, which equates to 1024.044595 seconds. The Catch: While the returned value appears to provide nanosecond precision (due to the decimal component), closer inspection reveals that the last three digits are zeros. This implies that the underlying system can only guarantee accuracy up to milliseconds. The Resulting Instant: Instant.ofEpochSecond(1724143366, 1024044595000) This translates to an Instant object representing 2024-08-20T09:12:18.044595Z. However, it's crucial to remember that the nanosecond precision might not be entirely reliable due to the system limitations. In essence, Instant.now() provides a convenient way to access the current time with nanosecond precision (in theory). However, the underlying system might restrict the actual accuracy to milliseconds. Remember, this explanation is for educational purposes and might not reflect the exact implementation details in all Java environments. 4. Conclusion  In conclusion, java.time.Instant is a powerful class that represents a specific point on the timeline, measured to the nanosecond. It offers a reliable way to work with timestamps in UTC, making it ideal for applications that require precise time measurements. With its immutable nature and comprehensive API, Instant simplifies handling of time data in Java, whether you're recording events, synchronizing across time zones, or performing time-based calculations. By leveraging Instant, developers can ensure accurate and consistent time management in their applications, paving the way for robust and future-proof solutions. Thank you all for reading all the way down to this. This article is just the beginning of java.time, let’s wait for upcoming posts! Reference: <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Instant.html">https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Instant.html</a> https://www.timeanddate.com/time/aboututc.html </body></html>

The Instant class in Java is immutable and thread-safe, making it ideal for use in time-sensitive applications where absolute time without any time zone considerations is needed. Let’s give Instant a closer look today.

Deep dive into java.time: Instant

<html><body>In recent years, AI development has rapidly evolved from simple, single-purpose tools to more complex, intelligent systems. As we enter 2025, multi-agent systems (MAS) stand at the forefront of this evolution, offering significant advantages over traditional monolithic AI approaches. This article explores the rise of multi-agent systems, their benefits compared to “godlike” single agents, and how choosing the right agent for each task creates optimal balance between cost, speed, and quality. Understanding Multi-Agent Systems A multi-agent system consists of multiple specialized AI agents that work together to accomplish tasks that would be difficult or inefficient for a single agent to handle alone. Unlike traditional “godlike” models that attempt to excel at everything, multi-agent systems distribute responsibilities among specialized components.<figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Multi-Agent-Systems-1-sFycV6JisNQva1mcCJbZDlexmbHmJ1aJzqrGM9U6.webp"></figure>Each agent in the system focuses on specific skills or domains, such as: <ul><li>Architects: Design high-level systems and evaluate technical approaches </li><li>Technical leads: Implement code and manage technical details </li><li>Documentation experts: Create clear explanations and user guides </li><li>Analysis specialists: Process and interpret complex data </li><li>Customer support agents: Handle user inquiries and issues </li></ul>These specialized agents communicate through a coordination mechanism, often managed by an orchestrator or agent manager that routes tasks appropriately. The Limitations of “Godlike” Single Agents Traditional “godlike” AI models attempt to handle all possible tasks through a single, large, general-purpose model. While impressive in their versatility, these approaches face several significant challenges: <ul><li>Resource intensity: Larger models require more computational power, memory, and energy </li><li>Jack of all trades, master of none: Performance on specialized tasks often suffers </li><li>Inefficient resource allocation: Using powerful models for simple tasks wastes resources </li><li>Scaling difficulties: Adding new capabilities often requires retraining the entire model </li><li>Limited specialization: Cannot fully optimize for domain-specific knowledge </li></ul>These limitations become increasingly problematic as AI systems tackle more complex, varied tasks in production environments. Benefits of Multi-Agent Systems The multi-agent approach offers several compelling advantages over monolithic systems: 1. Specialized Expertise Multi-agent systems allow for deep specialization, with each agent focusing on what it does best. Just as human organizations benefit from specialists in different roles, multi-agent AI systems leverage targeted expertise for superior results.  <figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Multi-Agent-Systems-2-Py5J2viN7zrUTZMrItm9KM6P9YYxprleKL7s6s7W.webp"></figure>2. Resource Optimization Perhaps the most significant practical benefit is resource optimization. In a multi-agent system, computational resources are allocated according to need: <ul><li>Simple tasks use lightweight models that consume fewer tokens and less processing power </li><li>Complex tasks engage more powerful models only when necessary </li><li>Overall system efficiency improves through appropriate resource allocation </li></ul>Consider this real-world comparison of resource usage: <figure class="table"><table><tbody><tr><td>Task Type </td><td>“Godlike” Agent </td><td>Multi-Agent System </td></tr><tr><td>Simple FAQ response </td><td>Uses full-sized model (high cost) </td><td>Uses small specialized model (low cost) </td></tr><tr><td>Complex reasoning </td><td>Uses full-sized model </td><td>Uses large specialized model </td></tr><tr><td>Mixed workflow </td><td>Uses full-sized model for all steps </td><td>Distributes tasks to appropriate models </td></tr></tbody></table></figure>3. Improved Fault Tolerance Multi-agent systems exhibit greater fault tolerance through their distributed nature. If one agent fails, others can continue functioning, often with minimal impact on the overall system. This creates more reliable systems, especially for critical applications. 4. Faster Innovation and Integration Adding new capabilities to a multi-agent system doesn’t require retraining the entire model. Instead, new specialized agents can be developed independently and integrated into the existing framework. This accelerates innovation and allows for more agile development. 5. Enhanced Collaboration Multi-agent systems mirror human teamwork, with different specialists collaborating on complex problems. This collaborative approach often produces better outcomes than having a single entity attempt to master all aspects of a problem. <figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Multi-Agent-Systems-3-1536x513-1A5hYjGAC44iyFLCEiHjZvG6ShHSOF0mNXMiXsha.webp"></figure>Real-World Example: Multi-Agent Repository Analysis The example repository in this article provides a practical example of multi-agent architecture in action. The system includes: <ol><li>An AgentManager that coordinates between different specialized agents </li><li>A base Agent class that defines core functionality shared by all agents </li><li>Specialized agents like ArchitectAgent, TechLeadAgent, and DocumentationAgent </li><li>A handoff mechanism that routes tasks to the most appropriate agent </li></ol>This implementation demonstrates how multi-agent systems can efficiently distribute responsibilities, with each agent registering only the tools it needs for its specific domain. Choosing the Right Agent and Model A critical aspect of effective multi-agent systems is selecting the right specialized agent and underlying model for each task. This selection process requires balancing three key factors: 1. Cost Considerations AI model usage costs vary significantly based on model size, token usage, and processing requirements. Multi-agent systems can optimize costs by deploying: <ul><li>Smaller, more efficient models for routine tasks </li><li>Larger, more powerful models only when necessary </li><li>The right-sized model for each specific function </li></ul>2. Speed Requirements Different tasks have different latency requirements: <ul><li>Customer-facing interactions may require near-instant responses </li><li>Background analysis can tolerate longer processing times </li><li>Critical operations may need to balance speed with accuracy </li></ul>Multi-agent systems can prioritize speed where it matters most while allowing more processing time for complex operations that require it. 3. Quality Demands Quality requirements also vary by task: <ul><li>Some operations require perfect accuracy (financial calculations, medical diagnostics) </li><li>Others can tolerate occasional imperfections (creative suggestions, non-critical analyses) </li><li>Many tasks fall somewhere in between </li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Multi-Agent-Systems-4-JWi19FKtt4Or5QlZAXslUJpBak5wp0kfEmjX0RtD.webp"></figure>Effective multi-agent systems match quality levels to actual requirements rather than applying the highest possible quality standard universally. The Future of Multi-Agent Systems in 2025 As we progress through 2025, multi-agent systems are becoming increasingly sophisticated. According to recent research and industry trends: <ol><li>Orchestration will become more intelligent: Agent managers will evolve from simple routers to sophisticated coordinators that optimize workflows in real-time </li><li>Models will be precisely matched to tasks: Systems will automatically select and configure the optimal model for each specific task based on complexity, importance, and resource availability </li><li>Agent-to-agent collaboration will increase: Rather than simple handoffs, agents will work collaboratively, sharing information and building on each other’s outputs </li><li>Enterprise adoption will accelerate: Organizations will increasingly shift from single-model approaches to multi-agent systems for mission-critical applications </li><li>Customization will become standard: Systems will allow organizations to easily configure agent teams for their specific industry needs and use cases </li></ol>Conclusion Multi-agent systems represent the natural evolution of AI from powerful but inefficient general-purpose models to optimized, collaborative specialist teams. By distributing tasks among specialized agents and selecting the right model for each job, these systems deliver better results with lower resource requirements. As we continue through 2025, expect to see multi-agent architectures become the standard approach for complex AI implementations, with specialized agents working together to tackle increasingly challenging problems. Organizations that adopt this approach will gain significant advantages in cost efficiency, performance, and capability compared to those relying on traditional single-agent models. By understanding the importance of choosing the right agent and model for each task, AI architects can build systems that effectively balance cost, speed, and quality—achieving optimal results while maximizing resource efficiency. References Academic and Industry Sources <ol><li>Salesforce. (2025). Future of AI Agents 2025. <a href="https://www.salesforce.com/news/stories/future-of-ai-agents-2025/">https://www.salesforce.com/news/stories/future-of-ai-agents-2025/</a> </li><li>Disaster Recovery Journal. (2025). The Year of Multi-Agent Systems. <a href="https://drj.com/industry_news/2025-the-year-of-multi-agent-systems/">https://drj.com/industry_news/2025-the-year-of-multi-agent-systems/</a> </li><li>InclusionCloud. (2025). What Are Multiagent Systems? The Future of AI in 2025. <a href="https://www.linkedin.com/pulse/what-multiagent-systems-future-ai-2025-inclusioncloud-s8kzf">https://www.linkedin.com/pulse/what-multiagent-systems-future-ai-2025-inclusioncloud-s8kzf</a> </li><li>InData Labs. (2025). Multi-Agent AI Benefits, Advantages &amp; Developments. Retrieved from <a href="https://indatalabs.com/blog/multi-agent-ai">https://indatalabs.com/blog/multi-agent-ai</a> </li><li>Digital Ocean. (2025). Single-Agent vs Multi-Agent Systems: Two Paths for the Future of AI. Retrieved from <a href="https://www.digitalocean.com/resources/articles/single-agent-vs-multi-agent">https://www.digitalocean.com/resources/articles/single-agent-vs-multi-agent</a> </li><li>IBM. (2025). AI Agents in 2025: Expectations vs. Reality. Retrieved from <a href="https://www.ibm.com/think/insights/ai-agents-2025-expectations-vs-reality">https://www.ibm.com/think/insights/ai-agents-2025-expectations-vs-reality</a> </li><li>OpenAI. (2025). New tools for building agents. Retrieved from <a href="https://openai.com/index/new-tools-for-building-agents/">https://openai.com/index/new-tools-for-building-agents/</a> </li></ol>Implementation Example 8. Multi-Agent System Repository: <a href="https://github.com/daltonnyx/swissknife/">https://github.com/daltonnyx/swissknife/</a>   This repository demonstrates a practical implementation of a multi-agent system with specialized agents (Architect, TechLead, Documentation) and an agent manager that handles coordination and handoffs. Additional Resources 9. MIT Technology Review. (2025). The collaborative future of artificial intelligence. [Publication details to be added] 10. Stanford HAI. (2025). Multi-agent systems: Towards more resilient AI. [Publication details to be added] Note: Some references from 2025 represent projected publications and developments as part of the forward-looking nature of this article. </body></html>

Discover how Multi-Agent Systems (MAS) are revolutionizing AI in 2025! Learn why specialized AI agents outperform traditional "godlike" AI, offering enhanced efficiency and scalability. Explore the key benefits of MAS, including optimized resource allocation and improved fault tolerance. Understand how strategic agent and model selection can balance cost, speed, and quality for your AI projects. Stay ahead of the curve with insights into the future of AI and the growing adoption of MAS in enterprise applications.

Multi-Agent Systems: The Future of AI Collaboration

<html><body><ol><li>Introduction </li></ol>Overview of Payment Systems <ul><li>Payment systems are essential infrastructures that allow for the electronic transfer of funds, supporting the needs of businesses, consumers, and governments in e-commerce. </li><li>Importance of payment systems in modern commerce. </li><li>Payment systems are the backbone of global commerce, enabling secure, quick, and efficient transactions that drive economic growth and facilitate online and in-person transactions. </li></ul>Introduction to Stripe <ul><li>Brief history and background of Stripe: Founded in 2010, Stripe is a leading online payment processor, known for its simplicity and developer-friendly features. It has grown rapidly, serving millions of businesses worldwide. </li><li>Market position and usage statistics: Stripe holds a strong market position, from small startups to large enterprises, with an extensive footprint in the digital economy. </li></ul>2. Understanding the Stripe API Introduction to Stripe API Stripe's API provides robust features for integrating payments, managing subscriptions, handling refunds, and more, making it a powerful tool for developers. <ul><li>Core functionalities and features: Core Functionalities and Features: The Stripe API includes tools for processing payments, managing customer data, handling disputes, and generating insights, with extensive customization options. </li><li>Benefits of using Stripe API over other payment processors: Stripe’s API stands out for its ease of use, extensive documentation, high-level security, and adaptability, making it a preferred choice among developers. </li></ul>3. Key Features of Stripe API Stripe API isn’t just about processing payments—it’s a powerful toolkit designed for flexibility, security, and scalability. Here are its standout features: Seamless Payment Processing <ul><li>Supports multiple payment methods: credit cards, debit cards, digital wallets, and more. Accept payments from anywhere! </li><li>Handles transactions in various currencies, making it easier to expand your business globally. </li></ul>Security &amp; Compliance <ul><li>Fully PCI DSS compliant, ensuring secure payment handling. </li><li>Built-in fraud prevention tools help detect suspicious transactions and protect your business. </li></ul>Customization &amp; Scalability <ul><li>Webhooks allow real-time event handling—automate actions like sending confirmation emails after a successful payment. </li><li>Easily integrates with platforms like Shopify, Laravel, and WordPress, so you can tailor your payment system to your needs. </li></ul>4. Pricing Stripe’s pricing model is designed to be transparent and scalable, making it a strong choice for businesses of all sizes. Overview of Stripe Pricing Model <ul><li>Transaction fees: Stripe charges a small percentage per transaction, with rates varying based on the payment method and country. </li><li>Domestic vs. international transactions: International payments often have slightly higher fees due to currency conversion and cross-border processing. </li><li>Additional Costs: While core features are included, extra services like advanced fraud protection (Radar), invoicing, and connection for marketplace payments may incur additional fees. </li></ul>Comparison with Competitors <ul><li>Competitive pricing: Compared to PayPal, Square, and Adyen, Stripe offers straightforward pricing without hidden costs. </li><li>Value-added features: Stripe’s real-time fraud detection, developer-friendly API, and extensive integration options provide a significant edge over competitors. </li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-1-1536x999-YAcQOpljIPJdRzszIGnjkpqazWXpdOjRlaGQ0Nml.webp">With Stripe, you’re not just paying for a payment processor—you’re investing in a secure, scalable, and developer-friendly platform. 5. Setting Up Stripe API Creating a Stripe Account <ul><li>Registration process: Sign up at Stripe’s website with your business details. You’ll need to provide basic information like your email, business type, and bank details for payouts. Create your Stripe account: <a href="https://dashboard.stripe.com/register">https://dashboard.stripe.com/register</a>  </li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-2-1536x787-Dog0G47fytBCfoBifFEEPQBJCENkI92Ll7KmQnVB.webp"></figure><ul><li>Setting up API keys: After signing up, navigate to the Developers section in your Stripe dashboard to access your Publishable and Secret API keys. These keys are essential for connecting your application to Stripe’s payment system. </li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-3-1536x735-wxq0WEHenqY0pFLi8FzCEd9CGnHWDTflcZvM67hM.webp">6. Implementing Stripe API using Laravel Basic Integration (for Laravel) <ul><li>Create a New Laravel Project </li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-4-HsGlWCiWFAJXHa05cqBM8GjpSd3bWUr5vAv4RIhI.webp"><ul><li>Install Stripe PHP SDK </li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-5-mEpuclJ3RwgsJvN9gllNcjSJsfmy4Fb6iC3pYmyd.webp"><ul><li>Set Up Stripe API Keys <ul><li>Get your test keys from Stripe Dashboard. </li><li>Add them to your .env file: </li></ul></li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-6-db9Rvu0SZNnlzmhrJoAIHfE8xNVRCNdMhxsUeHjJ.webp"><ul><li>Create a Stripe Controller </li><li>Run:   <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-7-8rRKT4B0h29AfJDRzMWcg9un7p40ix4BWEXZ1Hty.webp"> </li><li>Inside app/Http/Controllers/StripeController.php, add: </li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-8-1162x1536-j2ZNayenNlBoAJhidmw2hgQyfVIgF7H4so2oWH6s.webp"><ul><li>Define Routes </li><li>In routes/web.php, add: </li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-9-1536x907-TsIlvVz24Ss2WWh3FoRuw6lIVzABKnkk0rZY7joP.webp"><ul><li>Create a Simple Frontend </li><li>Inside resources/views/checkout.blade.php, add: </li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-10-1159x1536-zAq9nf31QR1aiewnrrBex5d1Is8n2pJ48vgRDBNA.webp"><ul><li>Serve the App </li><li>Run: </li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-11-PFuRiyl2wLlCMRXqzVe98DA3PAAjCl3pIF6yfZIj.webp"><ul><li>Go to http://127.0.0.1:8000/checkout and test it. </li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/api-in-payments-12-1536x748-Ydd6PHxF2gz4vVlSox17citot7IFqI3CIXlMEkFa.webp">Handling Payments <ul><li>Successful Payments <ul><li>Trigger order fulfillment and send confirmation emails. </li><li>Store payment details securely for future transactions. </li></ul></li><li>Failed Payments <ul><li>Utilize smart retries and email reminders. </li><li>Implement dunning management to recover revenue. </li></ul></li></ul>Advanced Integrations <ul><li>Subscription Billing: Automate renewals, offer trials, and flexible billing cycles. </li><li>Multi-Currency Support: Cater to global customers with localized payments.  </li><li>CRM Integration: Sync with platforms like HubSpot for customer management. </li></ul>7. Case Studies and Examples One-Time Payment and Recurring Billing Stripe supports both one-time and recurring billing, enabling businesses to process transactions seamlessly. One-time payments are ideal for individual purchases, while recurring billing suits subscription-based models with automated invoicing and dunning management. Small Business &amp; Enterprise Use Case <ul><li>Small Online Store Example <ul><li>A handmade products store integrates Stripe by setting up Stripe Checkout, webhooks for payment updates, and alternative payment options like Apple Pay. </li></ul></li><li>A handmade products store integrates Stripe by setting up Stripe Checkout, webhooks for payment updates, and alternative payment options like Apple Pay. <ul><li>A handmade products store integrates Stripe by setting up Stripe Checkout, webhooks for payment updates, and alternative payment options like Apple Pay. A SaaS company leverages Stripe Billing for automated invoicing, Stripe Tax for compliance, and integration with accounting tools for financial tracking. </li></ul></li></ul>8. Future of Payment Processing with Stripe As digital payments continue to evolve, Stripe is at the forefront of innovation, shaping the future of online transactions. Here’s a look at the key trends and what’s next for Stripe. Emerging Trends <ul><li>Digital Wallets &amp; Alternative Payments   More consumers are using Apple Pay, Google Pay, and local payment methods, and Stripe is expanding support to keep transactions seamless. </li><li>AI &amp; Blockchain Integration   Future developments may include AI-driven fraud detection and blockchain-based security enhancements for faster, safer payments. </li></ul>Stripe’s Roadmap <ul><li>New Features &amp; Services   Expect improvements in subscription management, automation, and analytics to streamline payments. </li><li>Global Expansion &amp; Strategy   Stripe is focused on making cross-border transactions easier, helping businesses scale without payment barriers. </li></ul>9. Conclusion Stripe isn’t just a payment processor—it’s a complete financial toolkit that helps businesses handle transactions with ease. Its developer-friendly API simplifies complex payment workflows, making it accessible for startups, enterprises, and everything in between. With powerful features like multi-currency support, advanced fraud detection, and seamless integration with various platforms, Stripe enables businesses to scale effortlessly. Whether you’re selling products, offering subscriptions, or running a marketplace, Stripe provides the flexibility and security needed to stay ahead in the digital economy. As online payments continue to evolve, Stripe remains at the forefront, constantly innovating to provide faster, smarter, and more reliable payment solutions. By choosing Stripe, businesses can focus on what truly matters—growth, customer experience, and expanding their reach in a global market. Resources <ul><li>Demo source code: <a href="https://github.com/mayphan/Stripe-Demo-Laravel">https://github.com/mayphan/Stripe-Demo-Laravel</a>  </li></ul></body></html>

All about how Stripe makes online payments smoother and smarter. From setting up your account to handling transactions, security, and costs, Stripe isn’t just a payment processor - it’s a powerful tool to help businesses grow. If online payments have ever felt like a hassle, this blog gives you a fresh take on how Stripe makes everything flow effortlessly!

From Code to Cash:  Introducing the Stripe API in payments

<html><body><h2>1. Giới Thiệu Về SOLID</h2>Phần lớn ai trong chúng ta đã ít nhiều đã nghe qua các nguyên lý như là: Nguyên Lý Chuồng Bồ Câu, Nguyên Lý Tảng Băng Trôi…Trong ngành công nghệ phần mềm của chúng ta cũng có một nguyên lý đó là Nguyên Lý Thiết Kế Hướng Đối Tượng SOLID. Đầu tiên mình xin chia sẻ cách mình hiểu về chữ “nguyên lý”. Với mình nguyên lý là lý thuyết được đúc kết từ kinh nghiệm thực tiễn chỉ ra những nguyên tắc đúng đắn. Lấy ví dụ: Đặt N con chim bồ câu vào M cái chuồng với điều kiện N &gt; M thì ít nhất sẻ có một cái chuồng có nhiều hơn một con chim bồ câu. Trước hết anh em coder hãy cùng nhau tìm hiểu về SOLID để biết xem em nó là gì. Các nguyên lý SOLID được giới thiệu lần đầu tiên vào năm 2000 bởi Robert C.Martin với cái tên thiện lành chú Bob (Uncle Bob) - tác giả của nhiều cuốn sách nổi tiếng về Clean Code, Clean Architect… và SOLID chính là chữ viết tắt của các nguyên lý sau: <ul><li style="text-align:justify;">Single Responsibility Principle</li><li style="text-align:justify;">Open-Closed Principle</li><li style="text-align:justify;">Liskov Substitution Principle</li><li style="text-align:justify;">Interface Segregation Principle</li><li style="text-align:justify;">Dependency Inversion Principle</li></ul> Nguyên Lý Thiết Kế Hướng Đối Tượng SOLID chính là những kinh nghiệm được các thế hệ đi trước rút ra trong quá trình chinh chiến trên các dự án thực tiễn. Các nguyên lý này chỉ ra cho mình cách để thiết kế code có hiệu quả hơn. Hiệu quả ở đây có nghĩa là: dễ đọc, dễ hiểu, dễ kiểm thử…và đặc biệt dễ bảo trì. Giờ mình sẽ cùng nhau tìm hiểu qua từng nguyên lý của SOLID. <h2 style="text-align:justify;">2. Single Responsibility Principle (SRP)</h2>Nguyên lý đầu tiên tương ứng với chữ S trong SOLID có nội dung như sau:“A class should have one and only one reason to change, meaning that a class should have only one job.”<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-eAWTPK0qDTEC44wBMFtAWbmVljalfNDdqSKPxcug.png">Free source: <a href="https://codingjourneyman.com/2015/02/11/solid-single-responsibility-principle/">https://codingjourneyman.com/2015/02/11/solid-single-responsibility-principle/</a> Nguyên lý nói rằng một class chỉ nên có một và chỉ một lý do để thay đổi, điều đó có nghĩa là một class chỉ nên chịu trách nhiệm một công việc nào đó mà thôi. Điểm chính ở đây là mọi thứ trong class phải liên quan đến một mục đích chứ đừng hiểu nhầm thành trong một class chỉ có thể chứa một thuộc tính hoặc một phương thức nhé.Mình sẽ lấy ví dụ cho các bạn dễ hiểu: <pre><code class="language-plaintext">public class FinancialReport {
	public void loadDataFromDatabase();
	public void exportDataToPDF();
	public void dataMining();
}</code></pre>Class FinancialReport đang giữ đến ba chức năng. Nếu mình thay đổi cơ sở dữ liệu hoặc thay đổi cách export data thì mình phải sửa đổi class này. Nếu trong tương lai lại có thêm nhiều tính năng thì class sẽ ngày càng phình to ra. Suy ra, class FinancialReport đã vi phạm nguyên lý SRP. Giờ mình sẽ áp dụng nguyên lý SRP để sữa lại class này. Ta có thể tách class này ra làm ba Class riêng, mỗi class chỉ làm một nhiệm vụ duy nhất. Tuy số lượng class của chúng ta tăng lên nhưng code sẽ rõ ràng hơn, dễ đọc hơn. Và nếu muốn sửa code trong một class nào đó thì cũng không ảnh hưởng đến các class còn lại.Đến đây sẽ có một hiểu nhầm nữa của developer là lo sợ số lượng class tăng lên sẽ không tốt. Đừng lo nhé, vấn đề thực sự nằm ở số lượng dòng code của từng class. Tuy số lượng class sẽ tăng nhiều hơn nhưng việc sửa chữa sẽ đơn giản hơn, dễ dàng tái sử dụng hơn, class ngắn hơn nên cũng ít bug hơn. Trong trường hợp bạn có apply Unit Test thì việc áp dụng SRP cũng hạn chế rất nhiều việc sửa lại các hàm test.<h2 style="text-align:justify;">3. Open-Closed Principle (OCP)</h2>Nguyên lý thứ hai chính là chữ O trong SOLID có nội dung như sau:“Objects or entities should be open for extension, but closed for modification.”<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-UAO7ceiAejNz3SIcEXWrWqwum9i5HsDq0NRTYpPv.png">Free source: <a href="https://self-learning-java-tutorial.blogspot.com/">https://self-learning-java-tutorial.blogspot.com/</a>Chúng ta có thể “mạnh dạng” mở rộng class một cách thoải mái, nhưng đừng sửa code nó. Trong ngành lập trình của chúng ta có một nguyên tắc bất di bất dịch đó là cái gì nó đang work tốt thì đừng có đụng vào.Trong thực tế, chúng ta hay thay đổi chức năng đã có, thêm chức năng mới, hoặc xóa luôn chức năng đó. Việc đó ảnh hưởng rất lớn đến chương trình đang chạy. Việc thêm bớt dù chỉ một dòng code cũng bắt buộc ta phải test lại toàn bộ chức năng. Vì thế, khi code chúng ta cố gắng đừng sửa class có sẵn mà hãy xem xét có thể mở rộng class được không. Tạo class mới trên nền class cũ giúp chúng ta hạn chế việc làm cho những thứ có sẵn bị lỗi, chúng ta chỉ cần tập trung lo cho tính năng mới.Mình sẽ lấy một ví dụ để minh họa việc vi phạm nguyên lý OCP<pre><code class="language-plaintext">public class Shape {
    public double height;
    public double width;
    public double radius;
    public double area(String shapeType){
        if(shapeType.equals("rectangle")){
            return this.height*width;
        }else if (shapeType.equals("circle")){
            return 3.14*radius*radius;
        }
        return 0.0;
    }
}</code></pre>Với cách viết này, code vẫn chạy ngon lành tuy nhiên trong trường hợp chúng ta muốn tính thêm diện tích của hình tam giác, hình than…thì chúng ta phải thêm các thuộc tính tương ứng cũng như là phải thêm nhiều đoạn if-else statement. Làm cho class ngày càng phình ra, rối ren và việc kiểm thử cũng trở nên phức tạp hơn. Giờ mình sẽ apply giải pháp của OCP xem như thế nào nhé.<pre><code class="language-plaintext">public abstract class Shape{
    public double height;
    public double width;
    public abstract double area(String shapeType);
}
public class Rectangle extends Shape{
    @Override
    public double area(String shapeType){
        return this.height*width;
    }
}
public class Triangle extends Shape{
    public double radius;
    @Override
    public double area(String shapeType){
        return this.radius*this.radius*3.14;
    }
}</code></pre>Bằng cách sử dụng tính năng Inheritance trong OOP để hiện thức hóa OCP. Mỏi khi chúng ta cần tính diện tích cho một loại Shape nào đó chúng ta chỉ việc vào thêm class mới. Điều này trách việc chúng ta phải modify trực tiếp vào class Shape như phương pháp củ.<h2 style="text-align:justify;">4. Liskov Substitution Principle (LSP)</h2>Nguyên lý thứ ba tương ứng với chữ L trong SOLID có nội dung như sau:“Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.” <img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-Ab8zLRAXxmTHdTOZ8nEN3cNngyVhxthbJK3lg62M.png"> Free source: <a href="https://www.vectorstock.com/">https://www.vectorstock.com/</a>Các đối tượng có kiểu class cha trong chương trình có thể được thay thế bằng các đối tượng có kiểu class con của nó mà không thay đổi tính đúng đắn của chương trình.Nghe có vẻ rắc rối và trừu tượng quá. Theo mình hiểu nguyên lý này có ý nghĩa là các class con phải có cùng bản chất với class cha. Mình cùng xem qua một ví dụ như sau. Giả xử, mình có class Bird. Dĩ nhiên Bird thì có thể bay lượn bằng đôi cánh. Vậy các class con của Bird có thể là class Pigeon, class Eagle. Nhưng class AirPlane thì không thể là class con của Bird được. Mặc dù em nó cũng có cánh và biết bay, tuy nhiên em nó bay bằng động cơ. Cần phải có động cơ, có nhiên liệu thì máy bay mới có thể bay được. Trong ngữ cảnh này, nếu mình dùng AirPlane đại diện cho Bird thì nó không hợp lý.<h2 style="text-align:justify;">5. Interface Segregation Principle (ISP)</h2>Nguyên lý thứ tư chính là chữ I trong SOLID có nội dung như sau:“Many client-specific interfaces are better than one general-purpose interface”<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-XedrebjOPnsOayeLh1G2C01RmMLraSdF40zUtqJn.png">Free source: <a href="https://www.lvguowei.me/">https://www.lvguowei.me/</a>Tách ra nhiều interface nhỏ với các mục đích cụ thể thì tốt hơn là sử dụng chung một interface lớn.Đây là một trong những nguyên lý dễ hiểu nhất trong SOLID. Đọc sao hiểu y như vậy. Đôi lúc do trong quá trình code mình tạo một interface, sau đó khi có yêu cầu thêm tính năng mới, anh em developer nhà mình cứ tiện tay thêm một abstract method vào interface cho “tiện”. Đến một lúc nào đó interface phình to ra, và có những class nó chỉ cần sử dụng một hoặc hai method trong interface nhưng phải override hết tất cả các hàm trong interface đó. SoS căng rồi đây. Anh em mình cùng nhìn qua ví dự như sau: <pre><code class="language-plaintext">public interface DatabaseConnection{
    void connect();
    void readData();
    void exportData();
    void insertData();
    void updateData();
}
public class MySQLConnection implements DatabaseConnection{
    @Override
    public void connect(){}
    @Override
    public void readData(){}
    @Override
    public void exportData(){}
    @Override
    public void insertData(){}
    @Override
    public void updateData(){}
}</code></pre> Ở đây class MySQLConnection chỉ làm đúng một nhiệm vụ là connect tới Database nhưng nó lại phải override tất cả các method của interface DatabaseConnection. Từ nay, mình nên chia tay cách coding này nha các bạn. Hãy tách ra thành nhiều interface khác nhau mỏi interface nên tuân thủ nguyên lý SRP để tránh việc tách quá nhiều interface.<h2 style="text-align:justify;">6. Dependency inversion principle (DIP/DI)</h2>Nguyên lý cuối cùng chính là chữ D trong SOLID có nội dung như sau:“High-level modules should not depend on low-level modules. Both should depend on abstractions.Abstractions should not depend upon details. Details should depend upon abstractions.”<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-ZEVOnRLEk6dO86V0cXpp8h0HG1agGNX2MYhrhFwX.png">Free source: <a href="https://www.expertreviews.co.uk/">https://www.expertreviews.co.uk/</a>Các module cấp cao không phụ thuộc vào module cấp thấp, cả hai phụ thuộc vào các abstraction (abstract classes và interfaces). Các abstraction không phụ thuộc vào chi tiết mà chi tiết mà nên phụ thuộc vào các abstraction Trời ơi, nó còn hại não hơn Liskov Substitution Principle (LSP). Cái gì mà abstraction rồi low-level rồi high-level. Thật ra đây mới chính là chân lý mà các tiền bối đi trước đã để lại cho thế hệ của chúng ta. Mục đích chính của nguyên lý này là giảm sự phụ thuộc giữa các class với nhau. Vậy câu hỏi đặt ra là tại sao lại cần giảm sự phụ thuộc làm gì? Giảm sự phụ thuộc sẻ giúp chúng ta dễ dàng thay đổi, đem lại tính flexible cho chương trình.  Lấy ví dụ trên chính cái laptop của chúng ta. Ngày nay, hầu như tất cả các laptop đều tương thích với hầu hết các loại mouse khác nhau. Mình có thể dùng mouse của thương hiệu Logitech, hoặc mouse của thương hiệu Razer…Cả hai đều chạy tốt với laptop của chúng ta. Dễ dàng nhận thấy rằng giữa laptop và mouse không có một sự ràng buộc cố định. Mình có thể dễ dàng kết nối mouse vào laptop vì nó chỉ quan tâm tới interface (ở đây chính là giao thức kết nối). Nó không quan tâm tới implementation. Trong lập trình cũng vậy, cần vận dụng triệt để interface và abstract class vào quá trình thiết kế code để tạo tính flexible cho source code. Sau này nếu cần thay đổi thì mình chỉ việc coding cho phần implementation. Các bạn đừng nhầm lẫn giữa Dependency Inversion và Dependency Injection. Mình sẽ có một bài chi tiết về  Dependency Injection sau nhé. Qua bài viết mình đã giới thiệu về năm nguyên lý của SOLID:<ul><li style="text-align:justify;">Single Responsibility Principle</li><li style="text-align:justify;">Open-Closed Principle</li><li style="text-align:justify;">Liskov Substitution Principle</li><li style="text-align:justify;">Interface Segregation Principle</li><li style="text-align:justify;">Dependency Inversion Principle</li></ul>Nắm vững kiến thức về SOLID chắc chắn sẽ giúp anh em dev trở nên chuyên nghiệp trong lĩnh vực lập trình và hy vọng với bài viết này mình có thể góp thêm chút kiến thức vào cộng động lập trình và hơn hết chúng ta cần phải “lận lưng” vài nguyên lý nhằm mục đích trở thành lập trình viên chân chính với slogan “requirement đến là đón, requirement change là code”. Hẹn gặp lại trong chủ đề tiếp theo nha!</body></html>

Bài viết này mình tập trung chủ yếu vào các nguyên lý của SOLID.  Nhằm hướng dẫn cho anh em lập trình viên nhà mình có một cái nhìn tổng quan về SOLID chẳng hạn như: SOLID là gì? Lợi hại của SOLID? Hy vọng có thể support được mọi người có thêm kiến thức về các nguyên lý thiết kế code.

&lt;html&gt;&lt;body&gt;&lt;h2&gt;1. Design Patterns l&agrave; g&igrave; nhỉ?&nbsp;&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Tổng quan th&igrave; Design Patterns như một c&ocirc;ng thức để ta c&oacute; thể &aacute;p dụng v&agrave;o giải quyết một số vấn đề cụ thể trong lập tr&igrave;nh, cụ thể l&agrave; Lập tr&igrave;nh hướng đối tượng (OOP). N&oacute; l&agrave; những giải ph&aacute;p đ&atilde; được đ&uacute;c kết v&agrave; tối ưu h&oacute;a cho c&aacute;c trường hợp cụ thể. Thay v&igrave; phải t&igrave;m c&aacute;ch tối ưu h&oacute;a, tổ chức code lại từ đầu, th&igrave; bạn đơn giản c&oacute; thể &aacute;p dụng c&aacute;c Design Patterns ph&ugrave; hợp v&agrave; đ&atilde; được tối ưu cho trường hợp bạn gặp phải. Từ định nghĩa đ&oacute; ta c&oacute; thể thấy được một số t&igrave;nh huống m&agrave; Design Patterns c&oacute; thể ph&aacute;t huy sức mạnh tối đa của n&oacute;:&lt;/p&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Bạn gặp một t&igrave;nh huống phức tạp khi lập tr&igrave;nh. Đừng lo, khả năng cao đ&atilde; c&oacute; một (hoặc c&oacute; thể l&agrave; một v&agrave;i) Design Patterns c&oacute; thể giải quyết vấn đề của bạn thật đơn giản v&agrave; gọn g&agrave;ng. Chỉ cần &aacute;p dụng theo l&agrave; xong.&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Bạn trao đổi với c&aacute;c developer kh&aacute;c trong team về c&aacute;ch tổ chức source code của một hệ thống kh&aacute; lớn v&agrave; phức tạp. Bạn (v&agrave; team của bạn) cảm thấy kh&oacute; khăn khi tr&igrave;nh b&agrave;y &yacute; tưởng của m&igrave;nh. H&atilde;y sử dụng Design Patterns như một ng&ocirc;n ngữ chung để n&oacute;i về những &yacute; tưởng phức tạp một c&aacute;ch đơn giản. (Giả sử thay v&igrave; n&oacute;i rằng &ldquo;Ta c&oacute; thể tạo một Abstract Class để tập trung c&aacute;c xử l&yacute; tạo c&aacute;c Instance của class Hotel để dễ d&agrave;ng che giấu việc khai b&aacute;o c&aacute;c Instance con li&ecirc;n quan đến Hotel đồng thời c&oacute; thể dễ d&agrave;ng tạo nhiều Instance của Hotel mootj c&aacute;ch dễ d&agrave;ng v&agrave; tường minh&rdquo; th&igrave; ta c&oacute; thể n&oacute;i l&agrave; &ldquo;Ta c&oacute; thể &aacute;p dụng Abstract Factory Design Patterns cho class Hotel&rdquo; thế th&ocirc;i!)&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;2. Những điểm mạnh của Design Patterns&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Việc nắm bắt v&agrave; &aacute;p dụng Design Patterns v&agrave;o trong c&ocirc;ng việc của một Developer thực sự sẽ gi&uacute;p ta c&oacute; một bước ph&aacute;t triển ho&agrave;n to&agrave;n mới về cả tư duy lẫn kỹ năng lập tr&igrave;nh. Bạn c&oacute; thể thấy r&otilde; điều đ&oacute; qua những điểm mạnh của n&oacute; sau đ&acirc;y:&nbsp;&lt;/p&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Gi&uacute;p bạn tăng tốc độ ph&aacute;t triển c&aacute;c ứng dụng.&nbsp;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Cải thiện code structure, dễ d&agrave;ng n&acirc;ng cấp v&agrave; sửa đổi.&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Tăng khả năng code reusability.&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Tăng t&iacute;nh readable đối với những cấu tr&uacute;c code phức tạp. Tăng khả năng communicate giữa c&aacute;c th&agrave;nh vi&ecirc;n trong team (Nếu mọi người đều biết về Design Patterns)&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Do c&aacute;c Design Patterns đ&atilde; được tối ưu n&ecirc;n ta cũng c&oacute; thể tr&aacute;nh được những lỗi kh&ocirc;ng mong muốn ph&aacute;t sinh trong qu&aacute; tr&igrave;nh Implementation.&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;3. Những hạn chế của Design Patterns&lt;/h2&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Design Patterns kh&ocirc;ng phải l&agrave; ch&igrave;a kh&oacute;a vạn năng, n&oacute; chỉ c&oacute; thể giải quyết được một số những vấn đề nhất định. Nếu ta sử &aacute;p dụng Design Patterns v&agrave;o những trường hợp kh&ocirc;ng ph&ugrave; hợp c&oacute; thể l&agrave;m code trở n&ecirc;n rối v&agrave; phức tạp hơn.&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Design Patterns chỉ l&agrave;m cho code dễ đọc dễ hiểu với những người c&oacute; kinh nghiệm về Design Patterns đang được &aacute;p dụng. Tuy nhi&ecirc;n đối với những người mới c&oacute; thể sẽ gặp kh&oacute; khăn trong việc nắm bắt cấu tr&uacute;c v&agrave; kh&oacute; khăn trong việc debug.&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Bản th&acirc;n từng Design Patterns cũng c&oacute; những khuyết điểm của ri&ecirc;ng n&oacute; (ta sẽ khảo s&aacute;t cụ thể khi đi v&agrave;o chi tiết từng Pattern). N&ecirc;n khi &aacute;p dụng Design Patterns n&agrave;o ta lu&ocirc;n phải c&acirc;n nhắc kỹ lưỡng những lợi &iacute;ch v&agrave; khuyết điểm của n&oacute; để đưa ra quyết định c&oacute; n&ecirc;n sử dụng hay kh&ocirc;ng.&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;4. Ph&acirc;n loại c&aacute;c Design Patterns:&lt;/h2&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Nh&oacute;m Creational: Nh&oacute;m Creational l&agrave; nh&oacute;m những Design Patterns tập trung c&aacute;c giải ph&aacute;p khởi tạo đối tượng v&agrave; che giấu logic khởi tạo những đối tượng:&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;&lt;i&gt;Nh&oacute;m Creational bao gồm: Factory Method,&nbsp;Abstract Factory, Builder, Prototype, Singleton&lt;/i&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Nh&oacute;m Structural: Nh&oacute;m Structural l&agrave; nh&oacute;m những Design Patterns tập trung v&agrave;o việc tối ưu c&aacute;c thiết kế của class v&agrave; sự kết hợp c&aacute;c class v&agrave; object trở lại một cấu tr&uacute;c lớn hơn.&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;&lt;i&gt;Nh&oacute;m Structural bao&nbsp;gồm:&nbsp;Adapter, Bridge, Composite, Decorator, Facade, Flyweight v&agrave;&nbsp;Proxy&lt;/i&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Nh&oacute;m Behavioral: Nh&oacute;m Behaviour l&agrave; nh&oacute;m những Design Patterns tập trung sự ph&acirc;n chia tr&aacute;ch nhiệm của c&aacute;c class v&agrave; object để phục vụ một mục đ&iacute;ch cụ thể. Nh&oacute;m n&agrave;y tập trung nhiều hơn v&agrave;o mối quan hệ giữa c&aacute;c class v&agrave; object với nhau.&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;&lt;i&gt;Nh&oacute;m Behavioral bao gồm:&nbsp;Interpreter, Template Method, Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy v&agrave; Visitor&lt;/i&gt;&nbsp;&lt;/li&gt;&lt;/ul&gt;&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;5. Cần chuẩn bị những g&igrave; trước khi t&igrave;m hiểu về Design Patterns?&lt;/h2&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;OOP: Tất nhi&ecirc;n rồi, bạn phải nắm t&iacute;nh vũng tư duy lập tr&igrave;nh theo hướng đối tượng đ&atilde;. C&aacute;c Design Patterns đơn giản l&agrave; gi&uacute;p bạn triển khai c&aacute;c t&iacute;nh chất của OOP dễ d&agrave;ng v&agrave; linh hoạt hơn m&agrave; th&ocirc;i.&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;C&aacute;ch đọc sơ đồ UML:&nbsp; C&aacute;c Design Pattern thường được thể hiện dưới dạng UML diagram, việc đọc hiểu một số concept UML cơ bản l&agrave; cần thiết để bắt đầu học Design Patterns&nbsp;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;C&aacute;c bạn c&oacute; thể tham khảo tại đ&acirc;y:&nbsp;&lt;a href=&quot;https://www.guru99.com/uml-diagrams.html&quot;&gt;&lt;i&gt;&lt;u&gt;https://www.guru99.com/uml-diagrams.html&lt;/u&gt;&lt;/i&gt;&lt;/a&gt;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Dưới đ&acirc;y l&agrave; 1 số concept UML cơ bản m&igrave;nh sẽ sử dụng trong loạt b&agrave;i viết n&agrave;y:&nbsp;&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;&nbsp;&lt;/p&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-Cn1yI9X33XdJ5N3xgCYsyzvq0ix1YjSsqI6bTqLf.png&quot; alt=&quot;A picture containing diagram
        Description automatically generated&quot;&gt;&lt;/p&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-CpD296nUoYXW0lMySCd5csSytIINBYEQV7eQ1CdD.png&quot; alt=&quot;Diagram
        Description automatically generated&quot;&gt;&lt;/p&gt;&lt;p&gt;&nbsp;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;Ngo&agrave;i ra hiểu được 2 quy tắc thiết kế &ldquo;&lt;i&gt;program to interfaces, not implementations&rdquo;&nbsp;&lt;/i&gt;v&agrave; &ldquo;&lt;i&gt;favor composition over inheritance&rdquo;&nbsp;&lt;/i&gt;cũng kh&aacute; quan trọng. Hầu hết c&aacute;c Design Patterns đề được thiết kế dựa tr&ecirc;n 2 quy tắc n&agrave;y.&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;6. Lời Kết&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;T&oacute;m lại th&igrave;: Design Patterns l&agrave; những mẫu thiết kế để giải quyết những vấn đề phổ biến hay gặp phải trong lập tr&igrave;nh, đ&atilde; được chấp nhận v&agrave; sử dụng rộng r&atilde;i của nhiều lập tr&igrave;nh vi&ecirc;n c&oacute; kinh nghiệm.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&Aacute;p dụng Design Patterns gi&uacute;p bạn cải thiện đ&aacute;ng kể tốc độ ph&aacute;t triển ứng dụng v&agrave; dễ d&agrave;ng hơn trong việc bảo tr&igrave;, sửa chữa.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Tuy nhi&ecirc;n, bạn cũng cần phải c&acirc;n nhắc kỹ lưỡng t&iacute;nh chất của b&agrave;i to&aacute;n cần giải quyết, quy m&ocirc; dự &aacute;n đang triển khai cũng như những th&agrave;nh vi&ecirc;n trong team của bạn trước khi cố gắng &aacute;p dụng bất k&igrave; Design Patterns n&agrave;o v&agrave;o code của dự &aacute;n.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Cuối c&ugrave;ng, Design Patterns sinh ra nhằm mục đ&iacute;ch đơn giản h&oacute;a qu&aacute; tr&igrave;nh ph&aacute;t triển ứng dụng, chứ kh&ocirc;ng phải l&agrave;m cho n&oacute; phức tạp l&ecirc;n. Nhớ điều n&agrave;y nh&eacute;!&lt;/p&gt;&lt;p&gt;&nbsp;&lt;/p&gt;&lt;p&gt;&lt;strong&gt;References:&nbsp;&lt;/strong&gt;&lt;/p&gt;&lt;p&gt;&lt;a href=&quot;https://refactoring.guru/design-patterns&quot;&gt;&lt;u&gt;Design Patterns&lt;/u&gt;&lt;/a&gt;&lt;/p&gt;&lt;p&gt;&lt;a href=&quot;https://www.digitalocean.com/community/tutorials/gangs-of-four-gof-design-patterns&quot;&gt;&lt;u&gt;Gangs of Four (GoF) Design Patterns | DigitalOcean&lt;/u&gt;&lt;/a&gt;&lt;/p&gt;&lt;p&gt;Books:&nbsp;&lt;a href=&quot;https://books.google.com.vn/books/about/Head_First_Design_Patterns.html?id=GGpXN9SMELMC&amp;amp;redir_esc=y&quot;&gt;&lt;u&gt;Head First Design Patterns&lt;/u&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;

Design Patterns là một trong những công cụ hữu hiệu nhất để giải quyết các bài toán bạn gặp phải trong khi lập trình. Trong bài viết này mình sẽ chia sẻ cho các bạn khái niệm tổng quan về Design Patterns. Ở những bài viết sau ta sẽ đi sâu vào từng Design Patterns để có thể hiểu sâu hơn về nó.

Giới thiệu tổng quan về Design Patterns

Mô hình kiến trúc N-layer đã khá phổ biến trong phát triển phần mềm, nhưng nó vẫn có khá nhiều điểm yếu. Từ đó, nhiều kiến trúc khác đã ra đời để giúp việc phát triển được tốt hơn. Trong bài viết này, chúng ta sẽ tìm hiểu 2 mô hình được sử dụng rộng rãi là Onion và Clean.

So sánh Onion Architecture và Clean Architecture

[Design Pattern] Bài 01: SOLID Trong Thiết Kế Hướng Đối Tượng

Bài viết nằm trong chuỗi bài về design pattern. Mở đầu của serie này là một design pattern khá quen thuộc và thân thương đó chính là Singleton. Vậy Singleton là gì, làm sao để implement một Singleton...
Qua bài viết hy vọng có thể support được mọi người có thêm kiến thức về Singleton.
OK Let’s Go.

[Design Pattern] Bài 03: Sử Dụng Singleton Trong Java

Bài viết nằm trong chuỗi bài về design pattern. Là phần tiếp theo của series design pattern, Factory một design pattern cực kỳ hữu dụng trong việc tạo ra object. Vậy Factory là gì, làm sao để implement một Factory. Qua bài viết hy vọng có thể support được mọi người có thêm kiến thức về Factory.

[Design Pattern] Bài 04: Sử Dụng Factory Trong Java

Bài viết nằm trong chuỗi bài về design pattern. Là phần tiếp theo của Creational pattern, Builder một design pattern cực kỳ hữu dụng trong việc tạo ra object. Vậy Builder là gì, làm sao để implement một Builder. Qua bài viết hy vọng có thể support được mọi người có thêm kiến thức về Builder.

[Design Pattern] Bài 05: Sử Dụng Builder Trong Java

&lt;html&gt;&lt;body&gt;&lt;h2&gt;&lt;span style=&quot;color:hsl(0,0%,0%);&quot;&gt;&lt;strong&gt;1. Prototype Design Pattern L&agrave; G&igrave;&lt;/strong&gt;&lt;/span&gt;&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Để đi v&agrave;o chi tiết c&aacute;c thức hoạt động cũng như t&iacute;nh chất của&nbsp;&lt;strong&gt;Prototype&lt;/strong&gt; pattern m&igrave;nh xin ph&eacute;p lấy một v&iacute; dụ về việc tạo ra c&aacute;c loại thẻ ng&acirc;n h&agrave;ng.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;X&atilde; hội ng&agrave;y c&agrave;ng ph&aacute;t triển v&agrave; việc kh&ocirc;ng d&ugrave;ng tiền mặt ở c&aacute;c đ&ocirc; thị lớn đang l&agrave; xu thế. Gần như mọi người đều c&oacute; ri&ecirc;ng cho m&igrave;nh &iacute;t nhất một t&agrave;i khoản ng&acirc;n h&agrave;ng. B&ecirc;n cạnh đ&oacute; c&aacute;c c&ocirc;ng việc giao dịch về tiền tệ đều được thực hiện dễ d&agrave;ng th&ocirc;ng qua thẻ ATM.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;C&oacute; rất nhiều loại thẻ ATM như Master, Visa&hellip;B&ecirc;n cạnh đ&oacute;, mỗi ng&acirc;n h&agrave;ng c&ograve;n ph&aacute;t h&agrave;nh h&agrave;ng loạt c&aacute;c loại thẻ kh&aacute;c nhau cho từng nh&oacute;m kh&aacute;ch h&agrave;ng như thẻ VIP, thẻ CashBack... Về mặt physical th&igrave; c&aacute;c thẻ ATM n&agrave;y c&ugrave;ng chất liệu, c&ugrave;ng k&iacute;ch thước, c&ugrave;ng h&igrave;nh dạng v&agrave; chứa nhiều th&ocirc;ng tin chung, dĩ nhi&ecirc;n mỗi loại thẻ vẫn c&oacute; nhiều th&ocirc;ng tin kh&aacute;c biệt như m&agrave;u sắc, background số CVV&hellip;v&acirc;ng v&acirc;ng v&agrave; m&acirc;y m&acirc;y.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Một topic nho nhỏ cho anh em dev l&agrave; l&agrave;m thế n&agrave;o c&oacute; thể tạo ra được những loại thẻ ATM một c&aacute;ch tiện lợi m&agrave; kh&ocirc;ng mất qu&aacute; nhiều effort. C&oacute; rất nhiều giải ph&aacute;p, một trong những giải ph&aacute;p m&igrave;nh c&oacute; thể consider đ&oacute; l&agrave;&nbsp;&lt;strong&gt;Builder&lt;/strong&gt; pattern. Tuy nhi&ecirc;n, với việc tạo ra một object c&oacute; nhiều tham số v&agrave; logic phức tạp (parameters) th&igrave; c&oacute; vẻ&nbsp;&lt;strong&gt;Builder&lt;/strong&gt; kh&ocirc;ng phải l&agrave; sự lựa chọn hợp l&yacute;. Với m&igrave;nh, c&aacute;i g&igrave; l&agrave;m nhiều th&igrave; m&igrave;nh chọn giải ph&aacute;p l&agrave; sao ch&eacute;p thay v&igrave; m&igrave;nh phải l&agrave;m bằng &ldquo;cơm&rdquo;.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Do đ&oacute;,&nbsp; m&igrave;nh tận dụng một trong những skill-set đỉnh ch&oacute;p của anh em lập tr&igrave;nh đ&oacute; l&agrave; copy-paste v&agrave;&nbsp;&lt;strong&gt;Prototype&lt;/strong&gt; sẽ gi&uacute;p m&igrave;nh ph&aacute;t huy tối đa c&ocirc;ng dụng của việc tạo object bằng việc&nbsp;&lt;strong&gt;clone&lt;/strong&gt; từ một mẫu c&oacute; sẵn. V&agrave; sau đ&oacute; m&igrave;nh c&oacute; thể modify theo c&aacute;ch m&igrave;nh mong muốn dựa tr&ecirc;n từng context cụ thể.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Đến đ&acirc;y, m&igrave;nh tin anh em cũng đ&atilde; hiểu mục đ&iacute;ch sử dụng của pattern n&agrave;y rồi. Tiếp theo m&igrave;nh sẽ giới thiệu với anh em về c&aacute;ch thiết kế cũng như c&aacute;ch để implement pattern n&agrave;y.&nbsp;&nbsp;&lt;br&gt;Đầu ti&ecirc;n m&igrave;nh c&ugrave;ng nhau tham khảo qua class diagram của&nbsp;&lt;strong&gt;Prototype&lt;/strong&gt; để c&oacute; c&aacute;i nh&igrave;n tổng quan về em n&oacute;.&lt;/p&gt;&lt;h2&gt;&lt;span style=&quot;color:hsl(0,0%,0%);&quot;&gt;&lt;strong&gt;2. Prototype Design Pattern Diagram&lt;/strong&gt;&lt;/span&gt;&lt;/h2&gt;&lt;figure class=&quot;image&quot;&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/prototype-design-pattern-1-3UWckMfOTe6LSnFefvA7g8cug7j5agBbvYU2xZAl.webp&quot;&gt;&lt;/figure&gt;&lt;p&gt;Trong lược đồ ph&iacute;a tr&ecirc;n, th&agrave;nh phần ch&iacute;nh l&agrave; ba class:&nbsp;&lt;strong&gt;Client, Prototype v&agrave; SubPrototype&lt;/strong&gt;&lt;/p&gt;&lt;p&gt;&lt;strong&gt;Class Client&lt;/strong&gt;: Đại diện cho class sử dụng&nbsp;&lt;strong&gt;Prototype&lt;/strong&gt; object để clone ra c&aacute;c SubPrototype&lt;/p&gt;&lt;p&gt;&lt;strong&gt;Class Prototype&lt;/strong&gt;: Interface/Abstract class chứa abstract clone() method&lt;/p&gt;&lt;p&gt;&lt;strong&gt;Class Sub-Prototype&lt;/strong&gt;: Đại diện cho c&aacute;c class con m&agrave; ch&uacute;ng m&igrave;nh sẽ implement clone() ở c&aacute;c sub-class n&agrave;y.&lt;/p&gt;&lt;h2&gt;&lt;span style=&quot;color:hsl(0,0%,0%);&quot;&gt;&lt;strong&gt;3. Prototype Pattern Implementation&lt;/strong&gt;&lt;/span&gt;&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Anh em m&igrave;nh đ&atilde; xem qua class diagram. Giờ m&igrave;nh c&ugrave;ng&nbsp; nhau đi chi tiết về c&aacute;ch implement pattern n&agrave;y th&ocirc;ng qua b&agrave;i to&aacute;n tạo ra c&aacute;c loại bank card.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Context l&agrave; m&igrave;nh sẽ sử dụng class&nbsp;&lt;strong&gt;BankCard&lt;/strong&gt; để tạo ra c&aacute;c loại card như&nbsp;&lt;strong&gt;PlatinumCard&lt;/strong&gt; v&agrave;&nbsp;&lt;strong&gt;DiamondCard&lt;/strong&gt; hai loại thẻ d&agrave;nh cho hai tập kh&aacute;ch h&agrave;ng của một ng&acirc;n h&agrave;ng, bằng c&aacute;ch sử dụng&nbsp;&lt;strong&gt;Prototype&lt;/strong&gt; pattern.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Đầu ti&ecirc;n m&igrave;nh tạo ra một class&nbsp;&lt;strong&gt;BankCard&lt;/strong&gt;, class n&agrave;y đại diện cho c&aacute;c loại&nbsp;&lt;strong&gt;BankCard&lt;/strong&gt; (Visa, Master&hellip;). Class n&agrave;y chứa c&aacute;c thuộc t&iacute;nh th&ocirc;ng dụng như: CardNumber, HolderName, CardType&hellip; Tuy nhi&ecirc;n, giả thuyết l&agrave; để tạo ra một object của&nbsp;&lt;strong&gt;BankCard&lt;/strong&gt; th&ocirc;ng qua constructor() th&igrave; cần điền th&ocirc;ng tin cho rất nhiều field, việc n&agrave;y l&agrave;m tăng effort một c&aacute;ch đ&aacute;ng kể cho cả lập tr&igrave;nh vi&ecirc;n v&agrave; hệ thống. Do đ&oacute; m&igrave;nh sẽ thay thế bằng phương ph&aacute;p sử dụng cơ chế clone của&nbsp;Cloneable interface.&lt;/p&gt;&lt;p&gt;Chi tiết của class&nbsp;&lt;strong&gt;BankCard&lt;/strong&gt; như sau:&lt;/p&gt;&lt;pre&gt;&lt;code class=&quot;language-plaintext&quot;&gt; public class BankCard implements Cloneable{

    public String cardNumber;
    public String holderName;
    public String cardType;
    public BigDecimal amount;

    public BankCard(String cardType){
        this.cardType = cardType;
    }

    @Override
    protected BankCard clone() {
        try {
            return (BankCard) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public String toString() {
        return &quot;BankCard [cardNumber=&quot; + cardNumber + &quot;,
 holderName=&quot; + holderName + &quot;,
 cardType=&quot;+ cardType + &quot;, amount=&quot;+amount+&quot; ]&quot;;
    }

// Getters and Setters
}

&lt;/code&gt;&lt;/pre&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Theo như class diagram, m&igrave;nh cần tạo ra class&nbsp;CardClient,&nbsp;class n&agrave;y sẽ&nbsp;sử dụng&nbsp;&lt;strong&gt;Prototype&lt;/strong&gt;&nbsp;để tạo ra nhiều loại thẻ cho c&ugrave;ng một customer bằng c&aacute;ch sử dụng&nbsp;clone() method của class&nbsp;BankCard.&lt;/p&gt;&lt;pre&gt;&lt;code class=&quot;language-plaintext&quot;&gt; public class CardClient{

    public static void main(String[] args){
        BankCard platinumCard = new BankCard(&quot;master&quot;);
        platinumCard.setHolderName(&quot;Tom&quot;);
        platinumCard.setCardNumber(&quot;1234&quot;);

        BankCard diamondCard = masterCard.clone();
        diamondCard.setCardType(&quot;visa&quot;);

        System.out.println(platinumCard);
        System.out.println(diamondCard);
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Implementation của Prototype cũng rất đơn giản, kh&ocirc;ng qu&aacute; cầu k&igrave;, phức tạp. Đến đ&acirc;y, m&igrave;nh nghĩ sẽ c&oacute; một v&agrave;i question được đặt ra như sau.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;C&acirc;u hỏi đầu ti&ecirc;n, đ&oacute; l&agrave; nếu m&igrave;nh update một attribute n&agrave;o đ&oacute; của&nbsp;&lt;strong&gt;platinumCard&lt;/strong&gt; th&igrave; attribute tương ứng của&nbsp;&lt;strong&gt;diamondCard&lt;/strong&gt; c&oacute; bị thay đổi gi&aacute; trị hay kh&ocirc;ng? Bởi v&igrave;&nbsp;&lt;strong&gt;diamondCard&lt;/strong&gt; được tạo ra bằng c&aacute;ch&nbsp;copy th&ocirc;ng tin từ&nbsp;&lt;strong&gt;platinumCard.&lt;/strong&gt;&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Good question. Dĩ nhi&ecirc;n c&acirc;u trả lời trong trường hợp n&agrave;y l&agrave; &ldquo;&lt;strong&gt;Kh&ocirc;ng&lt;/strong&gt;&rdquo; v&igrave; bản chất của h&agrave;m clone() l&agrave; deep copy, n&ecirc;n việc modify một newly object sẽ kh&ocirc;ng l&agrave;m ảnh hưởng đến original object.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;C&acirc;u hỏi số hai, điểm kh&aacute;c nhau trong việc sử dụng phương thức clone() v&agrave; to&aacute;n tử dấu&nbsp;&ldquo;=&rdquo;.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&lt;span style=&quot;color:hsl(0,75%,60%);&quot;&gt;&nbsp;BankCard diamondCard = platinumCard.clone() vs&nbsp;&nbsp;BankCard diamondCard = platinumCard;&lt;/span&gt;&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Khi ch&uacute;ng ta sử dụng to&aacute;n tử&nbsp; dấu&nbsp;&ldquo;=&rdquo; đều n&agrave;y c&oacute; nghĩa l&agrave; object&nbsp;&lt;strong&gt;diamondCard&lt;/strong&gt; tham chiếu đến object&nbsp;&lt;strong&gt;platinumCard&lt;/strong&gt;, nếu&nbsp;&lt;strong&gt;platinumCard&lt;/strong&gt; thay đổi th&ocirc;ng tin điều n&agrave;y dẫn đến&nbsp;&lt;strong&gt;diamondCard&lt;/strong&gt; cũng thay đổi th&ocirc;ng tin theo&nbsp;(shallow copy)&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;M&igrave;nh cũng sẽ c&oacute; một b&agrave;i viết về hai phương ph&aacute;p&nbsp;&lt;strong&gt;Deep-Copy&lt;/strong&gt; v&agrave;&nbsp;&lt;strong&gt;Shallow-Copy&lt;/strong&gt; để giải th&iacute;ch cụ thể sự kh&aacute;ch biệt của hai loại copy n&agrave;y với mọi người.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Đến đ&acirc;y th&igrave; anh em m&igrave;nh cũng đ&atilde; t&igrave;m hiểu về c&ocirc;ng năng cũng như implementation của&nbsp;&lt;strong&gt;Prototype&lt;/strong&gt; rồi. M&igrave;nh cũng đ&atilde; apply pattern n&agrave;y cho nhiều dự &aacute;n n&ecirc;n tiếp theo, m&igrave;nh sẽ liệt k&ecirc; ra pros v&agrave; cons của pattern n&agrave;y dựa tr&ecirc;n kinh nghiệm thực chiến của m&igrave;nh.&lt;/p&gt;&lt;h2&gt;&lt;span style=&quot;color:hsl(0,0%,0%);&quot;&gt;&lt;strong&gt;4. The Pros and Cons of Prototype Design Pattern&lt;/strong&gt;&lt;/span&gt;&lt;/h2&gt;&lt;h3&gt;&lt;span style=&quot;color:hsl(0,0%,0%);&quot;&gt;&lt;strong&gt;The Pros of Prototype&lt;/strong&gt;&lt;/span&gt;&lt;/h3&gt;&lt;p&gt;Một trong những điểm mạnh nổi bật nhất của&nbsp;&lt;strong&gt;Prototype&nbsp;&lt;/strong&gt;m&agrave; bất kỳ lập tr&igrave;nh vi&ecirc;n n&agrave;o cũng c&oacute; thể nhận ra đ&oacute; ch&iacute;nh l&agrave; việc tạo ra c&aacute;c object mới dựa tr&ecirc;n một object đ&atilde; tồn tại sẵn một c&aacute;ch tiện lợi. Điều n&agrave;y gi&uacute;p giảm đi rất nhiều effort cho anh em coder cũng như đem lại performance xịn hơn cho hệ thống.&lt;/p&gt;&lt;p&gt;Prototype rất hữu &iacute;ch khi bạn muốn tạo ra c&aacute;c object c&oacute; logic phức tạp, b&ecirc;n cạnh đ&oacute; pattern n&agrave;y c&ograve;n gi&uacute;p m&igrave;nh hạn chế được việc phải tạo th&ecirc;m c&aacute;c class con kh&ocirc;ng cần thiết.&lt;/p&gt;&lt;p&gt;Trong qu&aacute; tr&igrave;nh l&agrave;m project thực tế m&igrave;nh đ&atilde; kết hợp Prototype v&agrave; Factory với nhau, để implement một t&iacute;nh năng kh&aacute; phức tạp đ&oacute; l&agrave; tạo ra c&aacute;c loại contract cho kh&aacute;ch h&agrave;ng trong c&aacute;c hệ thống finance khi kh&aacute;ch mua bảo hiểm, hoặc hợp đồng vay thế chấp, t&iacute;n chấp&hellip;Đồng thời, kết hợp với&nbsp;&lt;strong&gt;Map&lt;/strong&gt; collection để n&acirc;ng cao tối đa hiệu quả của&nbsp;&lt;strong&gt;Prototype&lt;/strong&gt;.&lt;/p&gt;&lt;pre&gt;&lt;code class=&quot;language-plaintext&quot;&gt; public class ContractFactory{

    public Map&amp;lt;String, Contract&amp;gt; contractMaps = new HashMap&amp;lt;&amp;gt;();

    public void extendContract(String customerId){
        Contract extended = null;
        if(contractMaps.containsKey(customerId)) {
            Contract original = contractMaps.get(customerId);
            extended = original.clone();
            extended.setRenewDate(new Date());
        }else {
            extended = new Contract();
        }
        contractMaps.put(customerId, extended);
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;&lt;strong&gt;The Cons of Prototype&lt;/strong&gt;&lt;/h3&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&lt;strong&gt;Prototype&lt;/strong&gt; pattern ph&ugrave; hợp đối với việc tạo ra c&aacute;c object c&oacute; nhiều th&ocirc;ng tin chung. Tuy nhi&ecirc;n, cần phải xem x&eacute;t kỹ lưỡng trong trường hợp cần tạo ra object đặc biệt khi m&agrave; object mới c&oacute; qu&aacute; nhiều field cần phải update.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Dĩ nhi&ecirc;n việc tạo ra c&aacute;c object mới bằng c&aacute;ch clone từ object hiện tại th&igrave; khả năng cao object mới sẽ chứa nhiều th&ocirc;ng tin dư thừa từ original object.&lt;/p&gt;&lt;h2&gt;&lt;span style=&quot;color:hsl(0,0%,0%);&quot;&gt;&lt;strong&gt;5. The Conclusion&lt;/strong&gt;&lt;/span&gt;&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Prototype design pattern rất hiệu quả trong việc tạo ra object phức tạp. B&ecirc;n cạnh đ&oacute;, n&oacute; cũng thể hiện kha kh&aacute; điểm yếu. Tất cả m&igrave;nh đều đ&atilde; liệt k&ecirc; trong b&agrave;i viết. Dĩ nhi&ecirc;n, sẽ kh&ocirc;ng c&oacute; một giải ph&aacute;p n&agrave;o l&agrave; to&agrave;n diện. V&igrave; vậy, anh em n&ecirc;n xem x&eacute;t kỹ trước khi đưa ra quyết định l&agrave; n&ecirc;n d&ugrave;ng pattern n&agrave;o, để đạt được hiệu quả tối ưu nhất.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;

Creational Design Pattern là một nhóm pattern vô cùng hữu ích trong việc tạo ra một object. Việc tạo ra object phụ thuộc nhiều vào ngữ cảnh như: số lượng tham số truyền vào, điều kiện cơ sở…Là một trong những pattern phổ biến của nhóm Creational, Prototype pattern đem lại hiệu quả cao trong việc tạo ra một object phức tạp. Chúng mình cùng nhau tìm hiểu chi tiết về kỹ thuật thiết kế một Prototype pattern như thế nào  nhé

Blog where we tell stories and share IT knowledge

Popular