<html><body>1. Introduction ECMAScript, the standard behind JavaScript, continues to evolve, bringing new features and improvements to the language. The latest version, ECMAScript 2024, introduces several exciting updates that promise to enhance the way developers write and manage their code. In this blog post, we’ll explore the key features of ECMAScript 2024 and their potential impact on the JavaScript ecosystem. JavaScript is one of the most widely used programming languages in the world, powering everything from simple web pages to complex web applications. As the language evolves, new features are introduced to make development more efficient, intuitive, and powerful. ECMAScript 2024, the latest version of the ECMAScript standard, brings a host of new features that promise to take JavaScript to the next level. Whether you’re a seasoned developer or just starting out, understanding these new features can help you write better code and stay ahead of the curve. 2. New Features in ECMAScript 2024 2.1. Object.groupBy() and Map.groupBy() One of the standout features in ECMAScript 2024 is the introduction of Object.groupBy() and Map.groupBy(). These methods allow developers to group elements of an object or map based on the values returned by a callback function. This feature simplifies the process of organizing data, making it more intuitive and efficient. Example:<pre><code class="language-plaintext"> const people = [ 
 { name: "Alice", age: 21 }, 
 { name: "Bob", age: 25 }, 
 { name: "Charlie", age: 21 }, 
 ]; 
 const groupedByAge = Object.groupBy(people, (person) =&gt; person.age); 
 console.log(groupedByAge); // Output: { '21': [{ name: 'Alice', age: 21 }, { name: 'Charlie', age: 21 }], '25': [{ name: 'Bob', age: 25 }] } 
 </code></pre>In this example, the Object.groupBy() method groups the people array by age, creating a new object where the keys are the ages and the values are arrays of people with that age. This can be incredibly useful for tasks like data analysis, where you need to group data by certain criteria. The Map.groupBy() method works similarly but operates on maps instead of objects. This can be particularly useful when working with more complex data structures or when you need the benefits of a map, such as maintaining the order of insertion. Use Cases: <ol><li style="text-align:justify;">Data Analysis: Grouping data by specific criteria for easier analysis. </li><li style="text-align:justify;">Reporting: Creating reports that group data by categories, such as sales by region or users by age group. </li><li style="text-align:justify;">UI Development: Grouping items for display in a user interface, such as grouping products by category in an e-commerce application. </li></ol>2.2. Temporal API The Temporal API is another significant addition to ECMAScript 2024. It provides a modern way to work with dates and times, addressing many of the limitations of the existing Date object. The Temporal API offers precise and flexible date-time manipulation, making it easier to handle complex date and time operations. Key Classes: <ol><li style="text-align:justify;">Temporal.PlainDate </li><li style="text-align:justify;">Temporal.PlainTime </li><li style="text-align:justify;">Temporal.PlainMonthDay </li><li style="text-align:justify;">Temporal.PlainYearMonth </li></ol>Example: <pre><code class="language-plaintext"> const date = Temporal.PlainDate.from("2024-08-14"); 
 console.log(date.add({ days: 1 }).toString()); // Output: 2024-08-15 
 </code></pre>In this example, the Temporal.PlainDate class is used to create a date object, and the add method is used to add one day to the date. The Temporal API provides a more intuitive and powerful way to work with dates and times, making it easier to perform common tasks like adding or subtracting time, comparing dates, and formatting dates for display. Benefits: <ol><li style="text-align:justify;">Precision: The Temporal API provides precise control over dates and times, avoiding many of the pitfalls of the existing Date object. </li><li style="text-align:justify;">Flexibility: The API is designed to handle a wide range of date and time operations, from simple tasks like adding days to complex tasks like working with time zones. </li><li style="text-align:justify;">Ease of Use: The API is designed to be intuitive and easy to use, with clear and consistent methods for common tasks. </li></ol>Use Cases: <ol><li style="text-align:justify;">Scheduling: Creating and managing schedules, such as meeting times or event dates. </li><li style="text-align:justify;">Time Zone Management: Handling dates and times across different time zones, such as scheduling meetings with participants in different parts of the world. </li><li style="text-align:justify;">Date Calculations: Performing complex date calculations, such as calculating the number of days between two dates or determining the next occurrence of a recurring event. </li></ol>2.3. Unicode Strings ECMAScript 2024 brings improvements in handling Unicode strings, enhancing the language’s ability to work with international text. These improvements ensure that developers can work with Unicode strings more accurately, benefiting applications that require internationalization. Example: <pre><code class="language-plaintext"> const str = "𝌆"; 
 console.log(str.length); // Output: 2 (in older versions) 
 console.log([...str].length); // Output: 1 (correct length) 
 </code></pre>In this example, the string 𝌆 is a single Unicode character, but in older versions of JavaScript, it would be counted as two characters. The improvements in ECMAScript 2024 ensure that the length is correctly reported as one character, making it easier to work with Unicode strings. Benefits: <ol><li style="text-align:justify;">Accuracy: The improvements ensure that Unicode strings are handled accurately, avoiding common pitfalls like incorrect string lengths or character counts. </li><li style="text-align:justify;">Internationalization: The improvements make it easier to work with international text, benefiting applications that need to support multiple languages or scripts. </li><li style="text-align:justify;">Consistency: The improvements provide a consistent way to work with Unicode strings, making it easier to write and maintain code. </li></ol>Use Cases: <ol><li style="text-align:justify;">Text Processing: Working with text in different languages or scripts, such as processing user input or displaying text in a user interface. </li><li style="text-align:justify;">Internationalization: Developing applications that need to support multiple languages or scripts, such as translating text or formatting dates and times for different locales. </li><li style="text-align:justify;">Data Validation: Validating and processing text input, such as checking the length of a string or ensuring that a string contains only valid characters. </li></ol>2.4. ArrayBuffer Transfer The new ArrayBuffer Transfer feature allows for efficient transfer of ArrayBuffer objects between different contexts, such as web workers. This feature enhances performance by avoiding the need to copy data, making it ideal for high-performance applications. Example: <pre><code class="language-plaintext"> const buffer = new ArrayBuffer(8); 
 const worker = new Worker("worker.js"); 
 worker.postMessage(buffer, [buffer]); 
 </code></pre>In this example, an ArrayBuffer is created and transferred to a web worker using the postMessage method. The ArrayBuffer is transferred without being copied, improving performance and efficiency. Benefits: <ol><li style="text-align:justify;">Performance: The feature improves performance by avoiding the need to copy data, making it ideal for high-performance applications. </li><li style="text-align:justify;">Efficiency: The feature allows for efficient transfer of data between different contexts, such as web workers or iframes. </li><li style="text-align:justify;">Flexibility: The feature provides a flexible way to transfer data, making it easier to build complex applications that need to share data between different parts of the application. </li></ol>Use Cases: <ol><li style="text-align:justify;">Web Workers: Transferring data between the main thread and web workers, such as offloading computationally intensive tasks to a web worker. </li><li style="text-align:justify;">Data Sharing: Sharing data between different parts of an application, such as transferring data between iframes or different tabs. </li><li style="text-align:justify;">High-Performance Applications: Building high-performance applications that need to transfer large amounts of data efficiently, such as real-time data processing or gaming applications. </li></ol>3. Impact on Development The new features in ECMAScript 2024 are set to improve coding practices by providing more powerful and intuitive tools. Developers can expect to write cleaner, more efficient code, leading to better performance and maintainability. These updates also bring JavaScript closer to other modern programming languages in terms of functionality and ease of use. Improved Coding Practices: The new features in ECMAScript 2024 encourage better coding practices by providing more powerful and intuitive tools. For example, the Object.groupBy() and Map.groupBy() methods make it easier to organize data, while the Temporal API provides a more intuitive way to work with dates and times. These features help developers write cleaner, more efficient code, leading to better performance and maintainability. Enhanced Performance: The new features in ECMAScript 2024 also enhance performance by providing more efficient ways to handle common tasks. For example, the ArrayBuffer Transfer feature allows for efficient transfer of data between different contexts, improving performance in high-performance applications. Similarly, the improvements in handling Unicode strings ensure that text is processed accurately and efficiently, benefiting applications that need to support multiple languages or scripts. Increased Flexibility: The new features in ECMAScript 2024 provide increased flexibility, allowing developers to handle a wider range of tasks more easily. For example, the Temporal API provides a flexible way to work with dates and times, while the improvements in handling Unicode strings make it easier to work with international text. These features help developers build more powerful and flexible applications, meeting the needs of a diverse range of users and use cases. Comparison with Previous Versions: Compared to previous versions of ECMAScript, the 2024 edition brings significant improvements and new features that enhance the language’s capabilities. For example, the introduction of Object.groupBy() and Map.groupBy() provides a more intuitive way to organize data, while the Temporal API offers a modern way to work with dates and times. These features address many of the limitations and pain points that developers have faced in the past, making JavaScript a more powerful and versatile language. Developer Experience: The enhancements in ECMAScript 2024 are designed to improve the overall developer experience. By providing more intuitive and powerful tools, developers can focus more on solving problems and building features rather than dealing with the intricacies of the language. This leads to increased productivity and satisfaction, as developers can achieve more with less effort. Community and Ecosystem: The JavaScript community and ecosystem are likely to benefit significantly from the new features in ECMAScript 2024. As developers adopt these new features, we can expect to see a wave of new libraries, frameworks, and tools that leverage the capabilities of ECMAScript 2024. This will further enrich the JavaScript ecosystem, providing developers with even more resources and options to build high-quality applications. Learning Curve: While the new features in ECMAScript 2024 bring many benefits, they also introduce new concepts and APIs that developers need to learn. However, the learning curve is mitigated by the fact that these features are designed to be intuitive and consistent with existing JavaScript paradigms. Additionally, the wealth of resources available in the JavaScript community, including tutorials, documentation, and community support, will help developers quickly get up to speed with the new features. 4. ConclusionsECMAScript 2024 introduces several exciting features that promise to enhance the JavaScript development experience. From grouping objects to handling dates and times more effectively, these updates are set to make a significant impact. As the language continues to evolve, it’s an exciting time to be a JavaScript developer. The new features not only address long-standing pain points but also open up new possibilities for building more powerful and efficient applications. Thank you for following along with this blog. I hope it has been helpful and inspiring. Happy blogging!  - Reference: <a href="https://ecma-international.org/wp-content/uploads/ECMA-262_15th_edition_june_2024.pdf">ECMAScript 2024</a>  </body></html>

ECMAScript 2024 (ES2024) introduces exciting new features like Object.groupBy(), Map.groupBy(), and enhancements to the Temporal API. These updates aim to improve JavaScript’s functionality and developer productivity, making it more robust and expressive for modern web development.

Exploring ECMAScript 2024: What’s New and Exciting?

Creating an English learning video for TikTok using Remotion involves scripting educational content, audio, text, images, and adding animation to engage viewers.

How to Create an English Learning Video for TikTok Using Remotion

Explore essential clean code practices for JavaScript, React, and Node.js. Learn best practices, tools, and techniques to create maintainable and efficient code.

The Essential Guide to Clean Code Practices for JavaScript, React, and Node.js Projects

<html><body><h2>1. The Changing Landscape of Software Development</h2>The world of software development is undergoing a seismic shift, driven by rapid technological advancements and ever-evolving industry trends. As we navigate this transformative landscape, software developers must adapt and equip themselves with the skills necessary to thrive in this dynamic field. One of the most significant trends shaping the future of software development is the rise of artificial intelligence (AI) and machine learning (ML). These technologies are revolutionizing the way we approach problem-solving and automation, enabling software developers to create more intelligent and efficient applications. Mastering AI and ML techniques will be a key differentiator for developers seeking to stay ahead of the curve. Moreover, the proliferation of cloud computing and containerization technologies, such as Docker and Kubernetes, has redefined the way software is developed, deployed, and scaled. Embracing these technologies allows for greater flexibility, scalability, and cost-efficiency, making it essential for developers to acquire expertise in cloud-native architectures and DevOps practices. Another area of focus is the growing emphasis on user experience (UX) and design thinking. As software becomes increasingly integrated into our daily lives, developers must prioritize creating intuitive and engaging interfaces that seamlessly blend functionality with aesthetics. Collaboration with UX designers and a deep understanding of human-centered design principles will be crucial for delivering exceptional software products. Furthermore, the rapid pace of technological change necessitates a commitment to continuous learning and professional development. Developers must embrace a growth mindset, constantly expanding their knowledge and skills to stay relevant in an ever-evolving industry. This may involve exploring new programming languages, frameworks, or paradigms, as well as honing soft skills such as communication, problem-solving, and collaboration. In this dynamic landscape, software developers who can adapt, learn, and innovate will be well-positioned to capitalize on the opportunities that lie ahead. By embracing emerging technologies, adopting modern practices, and cultivating a passion for continuous improvement, software developers can not only future-proof their careers but also contribute to the creation of transformative software solutions that shape the world around us.<h2>2. Soft Skills: The Secret Weapon for Software Developers</h2>In the ever-evolving landscape of software development, technical prowess alone is no longer enough to guarantee success. While mastering programming languages, frameworks, and development methodologies is undoubtedly crucial, the true secret weapon for software developers lies in cultivating a robust set of soft skills. Soft skills, often overlooked or undervalued, are the intangible abilities that enable effective collaboration, communication, and problem-solving within a team environment. These skills transcend the boundaries of code and technology, fostering a deeper understanding of human interactions and the ability to navigate complex professional relationships. Effective communication is perhaps the most vital soft skill for software developers. Clear and concise communication not only facilitates seamless teamwork but also ensures that project requirements, design decisions, and technical complexities are accurately conveyed to stakeholders and end-users. By mastering the art of active listening, developers can better comprehend client needs, mitigate misunderstandings, and ultimately deliver solutions that align with business objectives. Problem-solving, a cornerstone of software development, extends beyond writing code. It encompasses the ability to think critically, analyze complex situations from multiple perspectives, and devise innovative solutions. Soft skills such as analytical thinking, creativity, and adaptability empower developers to tackle challenges head-on, embrace change, and continuously refine their approaches.In today's agile and fast-paced software development environment, adaptability is paramount. Soft skills like flexibility, resilience, and a growth mindset enable developers to seamlessly navigate evolving project requirements, embrace new technologies, and thrive in dynamic team settings. By cultivating these skills, developers can future-proof their careers and remain valuable assets in an ever-changing industry. While technical expertise is undoubtedly crucial, the true power of software developers lies in their ability to harmonize their technical skills with a well-rounded set of soft skills. By prioritizing communication, problem-solving, and adaptability, developers can elevate their impact, foster stronger collaboration, and deliver exceptional software solutions that drive innovation and business success.<h2 style="text-align:justify;">3. Empathy: The Key to Effective Collaboration</h2><figure class="image image_resized" style="width:92.44%;"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Essential-Soft-Skills-You-Need%20(3)%20(1)-3TPUPxWIewWjwu1Ap4ltWFBvioehxy5HbrvTPvuu.webp"></figure>Empathy is a critical skill that facilitates effective collaboration and fosters a productive work environment. By cultivating empathy, we can better understand the perspectives, needs, and motivations of our colleagues, clients, and end-users. This understanding allows us to create software solutions that truly resonate with their intended audience, resulting in higher user satisfaction and adoption rates. In the realm of user-centric design, empathy enables us to step into the shoes of our users, comprehending their pain points, desires, and workflows. By immersing ourselves in their experiences, we can identify opportunities for improvement and design intuitive interfaces that seamlessly integrate into their daily routines. This user-focused approach not only enhances the overall user experience but also ensures that our products align with real-world requirements. Moreover, empathy plays a pivotal role in fostering effective teamwork and collaboration. When team members actively listen to one another, acknowledge diverse perspectives, and demonstrate a genuine understanding of each other's concerns, a culture of trust and respect emerges. This environment encourages open communication, constructive feedback, and the free exchange of ideas, ultimately leading to more innovative and robust solutions. Conflict resolution is another area where empathy shines. By actively seeking to understand the motivations and emotions behind conflicting viewpoints, we can approach disagreements with an open mind and a willingness to find common ground. Empathy enables us to reframe conflicts as opportunities for growth, fostering compromise and mutually beneficial solutions. Furthermore, empathy is closely tied to emotional intelligence, a crucial aspect of effective leadership and interpersonal relationships. Emotionally intelligent individuals can recognize and manage their own emotions while also understanding and responding appropriately to the emotions of others. This ability to navigate the emotional landscape of the workplace contributes to a more positive and supportive environment, where individuals feel valued and motivated to perform at their best. In conclusion, empathy is a powerful tool that unlocks the potential for successful collaboration, user-centric design, conflict resolution, and emotional intelligence in the software development industry. By cultivating empathy within our teams and organizations, we can create software solutions that truly resonate with users, foster productive working relationships, and ultimately drive innovation and success.<h2 style="text-align:justify;">4. Critical Thinking: Solving Complex Problems with Ease</h2>Developing strong critical thinking abilities is essential for navigating the complexities of our modern world. It empowers individuals to approach problems methodically, gather and evaluate information objectively, and formulate innovative solutions. With a well-honed analytical mindset, even the most intricate challenges can be dissected and tackled with precision. Critical thinkers possess the invaluable skill of separating fact from fiction, identifying logical fallacies, and recognizing biases that could cloud their judgment. This objectivity allows them to consider multiple perspectives and weigh the merits of each, ultimately leading to more informed and effective decision-making. Moreover, critical thinking fosters a proactive approach to problem-solving. Instead of merely reacting to issues as they arise, individuals with strong critical thinking skills can anticipate potential roadblocks and devise preemptive strategies. This proactive mindset enables them to troubleshoot efficiently, minimizing disruptions and maximizing productivity. In today's rapidly evolving landscape, the ability to think critically and adapt to change is paramount. Those who embrace critical thinking are better equipped to navigate uncertainty, seize opportunities, and develop innovative solutions that push boundaries and drive progress. Whether in personal or professional settings, critical thinking is a powerful tool that empowers individuals to thrive in an ever-changing world.<h2>5. Adaptability: Thriving in a Rapidly Changing Industry</h2>Adaptability is an essential trait for software developers in today's rapidly evolving technological landscape. The industry is constantly shifting, with new tools, frameworks, and methodologies emerging at an unprecedented pace. Those who can embrace change and continuously learn and grow will not only survive but thrive in this dynamic environment. A growth mindset is crucial for fostering adaptability. Developers must be open to new ideas, willing to step out of their comfort zones, and eager to acquire new skills. Clinging to outdated practices or resisting change will only hinder their professional growth and limit their opportunities. Moreover, technological advancements are driving the need for continuous learning. Software developers must stay up-to-date with the latest trends, tools, and best practices to remain competitive and deliver innovative solutions. Attending workshops, conferences, and online courses can provide valuable opportunities to expand their knowledge and stay ahead of the curve. Embracing change also means being flexible and agile in one's approach to problem-solving. As requirements and technologies evolve, developers must be able to pivot quickly and adapt their strategies accordingly. This agility allows them to respond effectively to changing market demands and customer needs, ensuring their solutions remain relevant and valuable. In summary, adaptability is a critical asset for software developers in today's rapidly changing industry. By cultivating a growth mindset, embracing continuous learning, and remaining flexible and open to change, developers can position themselves for success and contribute to the creation of innovative, cutting-edge solutions that drive technological progress.<h2>6. Effective Communication: Bridging the Gap Between Developers and Stakeholders</h2><figure class="image image_resized" style="width:92.5%;"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Essential-Soft-Skills-You-Need%20(1)-L0HUgSHSKNJmuyyzd01oeFx1ne2sE4NhNQ5smHS3.webp"></figure>Effective communication is the cornerstone of successful collaboration between developers and stakeholders. It bridges the gap between the technical intricacies of software development and the business objectives of the organization. By honing their communication skills, developers can articulate complex concepts in a clear and comprehensible manner, ensuring that stakeholders understand the rationale behind technical decisions and the implications they hold for the project's success. Presenting technical concepts to non-technical stakeholders is a crucial aspect of this communication process. Developers must learn to break down intricate details into easily digestible information, using analogies, visuals, and real-world examples to facilitate understanding. By doing so, they can foster a shared understanding and align expectations, minimizing misinterpretations and potential conflicts. Client management and stakeholder engagement are also vital components of effective communication. Developers should actively seek feedback, address concerns, and maintain open channels of communication throughout the project lifecycle. Regular updates, progress reports, and transparent discussions about challenges and solutions can cultivate trust and strengthen the collaborative relationship between developers and stakeholders. Moreover, proficiency in both written and verbal communication is essential. Clear and concise documentation, such as technical specifications, user manuals, and project reports, ensure that stakeholders have access to accurate and up-to-date information. Simultaneously, strong verbal communication skills enable developers to convey their ideas effectively during meetings, presentations, and discussions, facilitating productive dialogue and decision-making. By mastering effective communication, developers can position themselves as invaluable assets to their organizations. They can bridge the gap between technical expertise and business acumen, fostering a collaborative environment where ideas are shared, concerns are addressed, and solutions are co-created. Ultimately, effective communication paves the way for successful project delivery, stakeholder satisfaction, and long-lasting partnerships built on mutual understanding and trust.<h2>7. Conclusion: Invest in Your Soft Skills to Future-Proof Your Software Development Career </h2>Developing strong soft skills is an investment that will pay dividends throughout your software development career. In today's rapidly evolving tech landscape, technical expertise alone is no longer enough to stay competitive and future-proof your career. Soft skills such as effective communication, collaboration, problem-solving, and adaptability are becoming increasingly valuable assets. By honing your soft skills, you'll gain a competitive edge that sets you apart from other developers. You'll be better equipped to navigate complex projects, work seamlessly with cross-functional teams, and effectively communicate your ideas and solutions to both technical and non-technical stakeholders. Moreover, soft skills are transferable across different roles, technologies, and industries. As the tech industry continues to evolve, your ability to adapt, learn new skills, and collaborate effectively will be crucial for career growth and longevity. Employers highly value professionals who can not only write code but also demonstrate strong interpersonal skills, emotional intelligence, and leadership potential. Investing in your soft skills is an investment in your personal and professional development. It will open doors to new opportunities, foster stronger relationships with colleagues and clients, and enhance your overall job satisfaction and career fulfillment. Don't underestimate the power of soft skills in shaping your software development career. Embrace continuous learning, seek feedback, and actively work on developing these essential skills. By doing so, you'll future-proof your career, unlock your full potential, and thrive in the ever-changing tech landscape.</body></html>

Discover the essential soft skills that can future-proof your software development career. From communication to adaptability, learn how to thrive in a dynamic tech landscape.

Future-Proof Your Software Development Career: The Essential Soft Skills You Need

Join me as I share my first AWS adventure, transitioning from FE to Fullstack, and the solutions that saved me from common pitfalls.

Lessons Learned Using AWS Services - Part 1

From Front-End to Full Stack

Tech Lead

Phuong Bui

.NET Developer

Vu Truong

Senior Developer

Trung Tran

Tech lead

Wind

Long Nguyen

Business Analyst

Duong Dat Thanh

<html><body><h2>1/ What is a Database Transaction?</h2>Database Transaction is a unit of work, which may include many actions we want to perform with the database system. In a simple word, the transaction represents any change in the database.The main purpose of the transaction is:<ul><li>Furnish a dependable operational entity capable of facilitating accurate recovery and preserving database consistency during system failure.</li><li>Provide isolation between programs and allow concurrent access to the database.</li></ul><figure class="image image_resized" style="width:35.94%;"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/database-nj4N9CS0ArL3krODuPO9XLykiFwjdWyA6THcbKa6.webp"></figure><h2>2/ Transaction basic and ACID properties</h2>Each transaction can have a single operation or a set of operations, which will be performed sequentially. Transaction will wrap this set and use the following pattern to handle SQL execution:<ul><li>Begin the transaction.</li><li>Perform a series of data manipulations and/or queries.</li><li>If executed without encountering errors, commit the transaction.</li><li>However, if an error arises during the process, roll back the transaction to its initial state.</li></ul><figure class="image image_resized" style="width:79.12%;"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Data%203-xzNeMcIxl87PmIk3glBKO8IMWq7llhuzFddFdgJl.webp"></figure>By following this pattern, the database can ensure it will provide the ACID properties, which will guarantee data validity despite errors, power failures, and other mishaps.<figure class="image image_resized" style="width:81.75%;"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Data%201-q35H71HVdpwhb2wVlJtpjweXJY9XcYTZNvbRKFkC.webp"></figure><h3>2.1/ Atomicity</h3>Atomicity ensures that every transaction is viewed as a singular "unit," ensuring it either completes entirely or fails. In a simple word, it means all or nothing. All the statements (operations) in one transaction must either succeed or fail.Consider a monetary transfer from bank account A to account B as an illustration of an atomic transaction. This process entails two distinct operations: withdrawing funds from account A and depositing them into account B. To maintain consistency, we mustn't observe the deduction from account A until we're confident that the corresponding credit has been made to account B. By executing these actions within an atomic transaction, we ensure that the database preserves its integrity. In the event of a failure in either operation, the database remains consistent, preventing any debits or credits from occurring.<h3>2.2/ Consistent</h3>Consistency guarantees that a transaction transitions the database from one coherent state to another, upholding database invariants. This means that any data modifications adhering to defined rules, such as constraints, cascades, triggers, and their combinations, must maintain validity. In essence, consistency ensures that the database remains in a reliable and predictable state after each transaction, preventing the introduction of invalid or contradictory data.CREATE TABLE acid test (A INTEGER, B INTEGER, CHECK (A + B = 100));Let’s imagine we have a table with a validation requirement check that A+B = 100.Suppose a transaction attempts to deduct 10 from A without updating B. Given that consistency checks occur after each transaction, it's established that A + B equals 100 before the transaction initiation. While the deduction from A may succeed, ensuring atomicity, a subsequent validation check reveals A + B now equals 90, violating the database's rules. Consequently, the entire transaction must be aborted, and the affected rows rolled back to their pre-transaction state to maintain consistency.<h3>2.3/ Isolation</h3>If our system only executes one transaction by one, everything will be simple. Transactions are frequently executed concurrently, necessitating isolation to ensure that concurrent transaction execution results in the same database state as if the transactions were executed sequentially. Isolation serves as the primary objective of concurrency control, guaranteeing that each transaction's effects on the database remain isolated from those of concurrently executing transactions. This isolation prevents interference or inconsistency between transactions, maintaining data integrity and consistency across the database.Consider two transactions:<ul><li>T1 transfers 10 from A to B.</li><li>T2 transfers 20 from B to A.</li></ul>Combined, there are four actions:<ul><li>T1 subtracts 10 from A.</li><li>T1 adds 10 to B.</li><li>T2 subtracts 20 from B.</li><li>T2 adds 20 to A.</li></ul>If isolation is maintained, these operations are performed in order.But if isolation is not maintained, the order of operations might be messed up. One of the possibilities might be:<ul><li>T1 subtracts 10 from A.</li><li>T2 subtracts 20 from B.</li><li>T2 adds 20 to A.</li><li>T1 adds 10 to B.</li></ul>Consider if T1 fails, but T2 already modified data so it cannot restore data before T1.Depending on the isolation level used, the effects of an incomplete transaction might not be visible to other transactions, which we will deep dive into in another section of this article.<h3>2.4/ Durability</h3>Durability ensures that once a transaction has been successfully committed, its changes are permanently saved and will persist even in the event of a system failure, such as a power outage or crash. This means that once a transaction is confirmed as complete, its effects on the database are guaranteed to endure and will not be lost due to unexpected system failures.<h2>3/ Concurrently control mechanism</h2>There are many mechanisms to ensure that transactions are executed reliably, maintaining data integrity and allowing multiple transactions to work concurrently while preserving consistency like concurrency control mechanisms, transaction logging, and buffer management. In this section, I will talk about concurrent control mechanisms and how they work.Executing transactions sequentially can indeed lead to increased waiting times for other transactions, potentially causing delays in overall execution. To enhance system throughput and efficiency, multiple transactions are executed concurrently. Concurrency control plays a crucial role in database management systems (DBMS) by facilitating simultaneous data manipulation or execution by multiple processes or users without compromising data consistency. By carefully coordinating the concurrent execution of transactions, concurrency control mechanisms ensure that data remains consistent and that transactions do not interfere with each other's operations, thereby optimizing system performance and resource utilization.There are some commonly used concurrency control mechanisms: Lock-based concurrency control, Timestamp-based concurrency control, multi-version concurrency control (MVCC), Optimistic concurrency control, Two-phase locking (2PL), and Snapshot isolation. However, the most popular methods to be used to handle concurrent control are Lock-based and MVCC.<h3>3.1/ Lock-based</h3>This mechanism involves acquiring and releasing locks on database objects such as tables, rows, or columns to control access by concurrent transactions.<figure class="image image_resized" style="width:59.61%;"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Data%204-A26jrksvP0Sx9GnYZ5yFkTwgyMnZ9CMB3iScsqSa.webp"></figure><h4>Type of locks</h4>There are different types of locks, including shared locks (read locks) and exclusive locks (write locks), which help prevent conflicting operations:<ul><li>Share locks: Allows multiple transactions to read the data item concurrently but prevents any transaction from modifying it until all shared locks are released.</li><li>Exclusive locks: Grants exclusive access to a data item, preventing other transactions from reading or writing it until the lock is released. Once a process acquires a lock on a resource, other processes attempting to acquire the same lock must wait.</li></ul>Multiple shared locks can be held simultaneously on a resource. However, if a resource is already locked with a shared lock, another process can't acquire an exclusive lock. Likewise, a process can't acquire a shared lock on a resource that's exclusively locked.<h4>Locking problems</h4>Although locking is a good way to handle concurrent access, it still has some issues. The three most common problems of locking are:<ul><li>Fails to release the lock:  What if the lock fails to release? It will block other transactions and the whole process will be blocked. </li><li>Lock contentions: Some resources may be accessed frequently and multiple transactions could try to acquire locks on these resources at the same time. It leads to subsequent transactions that may encounter delays while waiting for others to complete, resulting in contention for these resources or locks. Imagine you are in a line waiting to check out but there is only 1 counter.</li><li>Locking deadlock: one transaction locks resource A and tries to access the lock on resource B before releasing the lock on the first resource. Simultaneously, another process acquires the lock on resource B while attempting to acquire the lock on resource A. Consequently, both processes remain incomplete until they obtain these locks.</li></ul><h3>3.2/ MVCC</h3>An alternative approach to locking is multiversion concurrency control (MVCC), where the database offers each reading transaction the original, unaltered version of data being modified by another active transaction. This enables readers to function without requiring locks, meaning writing transactions doesn't impede reading transactions, and vice versa.<h4>Isolation and its problems</h4>Remember that the results of the transaction are only visible after a commit to the database happens so what happens when a transaction tries to read a row updated by another transaction? Now our application can handle multiple concurrent actions at the same time, that’s why we will be faced with more complex problems.Most of our operations are READ and that’s why most of the problem is about read phenomena.We have 4 common read phenomena including:<ul><li>Dirty read: Occurs when a transaction reads data modified by another concurrent transaction that has not yet been committed. This can lead to reading inconsistent or erroneous data.</li><li>Nonrepeatable read: This happens when a transaction re-reads data it has previously retrieved and finds that the data has been altered by another transaction that has since been committed. This inconsistency may cause unexpected behaviour.</li><li>Phantom read: Occurs when a transaction re-executes a query with a search condition and finds that the set of rows satisfying the condition has changed due to another transaction being committed in the meantime. This can lead to inconsistencies in query results.</li><li>Serialization anomaly: Refers to a situation where the outcome of executing a group of transactions together is different from the result obtained by executing the same transactions sequentially, one after the other. This inconsistency can violate the desired consistency of the database.</li></ul><h4>Isolation levels</h4>With the special problems of reading data when operating with multiple concurrent operations, our database system needs to implement different levels of isolation to solve problems for different use cases.<ul><li>Read uncommitted: The lowest isolation level, allowing transactions to read data that hasn't been committed by other transactions. This level doesn't provide isolation, meaning that concurrent transactions may see uncommitted data, potentially leading to inconsistent or incorrect results.</li><li>Read committed: This level allows transactions to read only committed data, preventing dirty reads. However, it doesn't address non-repeatable or phantom reads, as it doesn't lock data during read operations. This is the default isolation level in PostgreSQL.</li><li>Read committed: Transactions at this level lock resources throughout the transaction, preventing other transactions from modifying the same data. While it helps against non-repeatable reads, it may still encounter phantom reads. This level is often used to maintain consistency in data-intensive operations.</li><li>Serializable: The highest level of isolation, emulating serial execution of transactions. All concurrent transactions are treated as if they were executed one after the other, ensuring the highest level of consistency and preventing all concurrency-related anomalies, including non-repeatable reads and phantom reads.</li></ul><figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/Data%205-A3N7amL9p17duVPtyxsPcxNXMqBu9QyfKKw9rGc4.webp"></figure>Although read uncommitted is the lowest isolation level. Some modern relational database systems like PostgreSQL do not allow it to happen in their system.<h2>4/ Demo</h2>One of the most valuable characteristics of isolation with developers is Atomicity. When you have to implement an API with a ton of operations including read, write, and update and once an operation fails, others fail and immediately roll back data to the previous state to make sure our database system is consistent. Remember to use database transactions in this case.  My simple demo will help you to know how you can use transactions with NodeJS and Prisma: wrap all your operations with Prisma inside the transaction. In my code, assume my application is an application that only allows users to add money to their account with a specific money source: MOMO and VPBANK. My scenario is to create a transaction to add money from the “MOMON” source, which is not allowed in our system.  Please check my code for more details.<h2>5/ Conclusion</h2>In conclusion, transactions are a vital aspect of database management systems, providing a mechanism for ensuring data integrity, consistency, and reliability. By grouping database operations into atomic units, transactions allow for the execution of multiple operations as a single, indivisible entity. This ensures that either all operations succeed and are committed to the database, or none of them are executed, maintaining data integrity and preventing partial updates.Choosing a higher isolation level usually comes with a performance trade-off due to increased locking or versioning mechanisms to maintain consistency. The choice of isolation level depends on the specific requirements of your application, balancing the need for data consistency with the desired level of concurrency.Resources:<ul><li>Demo source code: <a href="https://github.com/saigontechnology/Blog-Resources/tree/main/NodeJS/Khanh.Nguyen/NestJS-Prisma-Transaction">Repo’s link</a></li></ul>References:   - https://medium.com/inspiredbrilliance/what-are-database-locks-1aff9117c290  - https://www.postgresql.org/docs/current/transaction-iso.html</body></html>

Let's take a look into one of the most fundamental concepts of databases. This article will show you the main concepts of transaction and  how you can manage transactions in NodeJS with Prisma.

Database Transaction and how to handle it in NodeJS with Prisma

AWS Lambda and Google Cloud Functions are serverless computing platforms. Lambda offers broader language support and integrates well within the AWS ecosystem, while Cloud Functions excels at integration with Google Cloud services and shines in real-time data processing scenarios.

Comparison of AWS Lambda and Google Cloud Functions

Cám ơn bài viết hay, nhưng mình thấy lý thuyết hơn nhiều, chưa có ví dụ để làm rõ

Nin Tran

<html><body><h2 style="text-align:justify;">1. Kiến trúc N-Layer</h2>Chúng ta sẽ có các lớp logic và vật lý khác nhau đáp ứng cho các nhu cầu trong quá trình phát triển ứng dụng. Hầu hết các ứng dụng sử dụng kiến trúc này đều sẽ chứa 4 lớp: presentation, business, persistence và database. Tùy thuộc vào độ phức tạp của ứng dụng mà các lớp sẽ nhiều hoặc ít hơn.<figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-qMDyPoAWykT2Iwws5bsA5h2lA9Asp2r769b8hj8N.png"></figure><h6 style="text-align:justify;">Nguồn: <a href="https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/?_gl=1*7a1tjd*_ga*NzE5NTM3ODY4LjE2NzkzODcyOTk.*_ga_092EL089CH*MTY3OTYzMDAzNy42LjEuMTY3OTYzMDA1NS40Mi4wLjA.">Software Architecture Patterns by Mark Richards</a></h6>Các lớp trong mô hình kiến trúc này sẽ đảm nhiệm một vai trò cụ thể, và khi đứng từ một lớp nào đó, chúng ta chỉ có thể giao tiếp với các lớp bên trên hoặc bên dưới của nó. Trong đó:<ul><li style="text-align:justify;">Presentation: là lớp sẽ đảm nhiệm việc tương tác với người dùng, như là giao diện người dùng hoặc cung cấp thông tin dưới dạng Web API.</li><li style="text-align:justify;">Business: được xem như là thành phần chính trong các ứng dụng, là lớp sẽ chứa các logic nghiệp vụ, ánh xạ trực tiếp đến các nghiệp vụ thực tế mà ứng dụng cần đáp ứng.</li><li style="text-align:justify;">Persistence: là lớp truy xuất và lưu trữ dữ liệu bằng cách giao tiếp với lớp Database.</li><li style="text-align:justify;">Database: là nơi lưu trữ dữ liệu của ứng dụng, như là các cơ sở dữ liệu (SQL, No-SQL) hoặc File (Excel, CSV) ...</li></ul>Kiến trúc N-Layer có một số ưu điểm có thể kể đến đó là đơn giản, có thể tái sử dụng, kiểm thử độc lập, giúp cho lập trình viên có thể dễ tiếp cận và làm việc với các logic nghiệp vụ nhanh chóng. Vì vậy, chúng ta có thể sử dụng kiến trúc này cho các ứng dụng quy mô nhỏ hoặc thông thường.Tuy nhiên, đối với các ứng dụng quy mô lớn, tính mở rộng và phức tạp cao, thì kiến trúc sẽ hoạt động không hiệu quả. Do thiết kế phân lớp, việc thay đổi logic ở một lớp nào đó sẽ khó cập nhật lại ở các lớp khác, đồng thời cũng gây giảm hiệu suất vì các lớp không liền kề phải giao tiếp gián tiếp thông qua một lớp khác. Điều này làm cho ứng dụng sẽ ngày càng trở nên phức tạp và cồng kềnh hơn khi logic nghiệp vụ cũng nhiều hơn.<h2 style="text-align:justify;">2. Kiến trúc Onion</h2>Được giới thiệu lần đầu tiên bởi Jeffrey Palermo và năm 2008, để khắc phục các vấn đề kể trên của N-Layer, dựa trên mô hình Domain Driven, tức là xây dựng ứng dụng theo hướng tập trung vào Domain (nghiệp vụ). Từ cái tên "Onion", dịch ra là củ hành tây, ta có thể hiểu được ý đồ của mô hình này là đặt domain làm trung tâm, và bao bọc dần xung quanh bởi các lớp hệ thống khác.<figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-PLCfIJtUNLXs2P2w7dVtbBJaIFlEafSq30vXLWIj.png"></figure><h6 style="text-align:justify;">Nguồn: <a href="https://www.thoughtworks.com/insights/blog/architecture/demystify-software-architecture-patterns">Demystifying software architecture patterns</a></h6>Các lớp trong Onion được cải tiến dựa trên nguyên lý Dependency Inversion để giải quyết vấn đề phân lớp quá chặt chẽ của N-Layer. Đối với các lập trình viên .NET Core, việc cải tiến này được thể hiện thông qua Dependency Injection, được hỗ trợ sẵn, nhằm giảm tối đa sự phụ thuộc giữa các lớp, service với nhau.Thông thường, Onion sẽ có 4 lớp chính: domain model, domain services, application service và presentation. Như đã đề cập ở trên, Domain Model sẽ là lớp trung tâm của kiến trúc này. Trong đó:<ul><li style="text-align:justify;">Domain Model: là nơi tập trung các trạng thái và phương thức, hành vi nghiệp vụ của ứng dụng.</li><li style="text-align:justify;">Domain Services: là lớp kế tiếp domain model, chứa các interfaces cho việc lưu trữ dữ liệu, phương thức truy xuất, còn được gọi là Repository.</li><li style="text-align:justify;">Application Services: chứa các interfaces với các phương thức như là Thêm, xóa, sửa.. Ở các lớp services sẽ chỉ chứa các interfaces và các commons class.</li><li style="text-align:justify;">Presentation: chứa UI và tests. Lớp này cũng chứa các cài đặt của các interface ở tầng services.</li></ul>Một số ưu điểm của kiến trúc này:<ul><li style="text-align:justify;">Ít bị ràng buộc giữa các lớp với nhau</li><li style="text-align:justify;">Xây dựng tập trung vào nghiệp vụ</li><li style="text-align:justify;">Linh hoạt, dễ chuyển đổi, bổ sung và mở rộng</li><li style="text-align:justify;">Có thể đưa vào phát triển với mẫu DDD (Domain-Driven Design)</li></ul>Bên cạnh đó, một số nhược điểm dễ nhận thấy ở kiến trúc Onion này là:<ul><li style="text-align:justify;">Khó tiếp cận đối với những lập trình viên mới bắt đầu tham gia, đòi hỏi thời gian học và tìm hiểu sâu</li><li style="text-align:justify;">Phức tạp và khó áp dụng nếu ứng dụng không có nhiều nghiệp vụ</li></ul><h2 style="text-align:justify;">3. Kiến trúc Clean</h2>Kiến trúc Clean được giới thiệu bởi Uncle Bob vào năm 2012, dựa trên nguyên lý và thừa hưởng các đặc tính của kiến trúc Onion. Điểm khác biệt là kiến trúc này lấy Entities (các đối tượng nghiệp vụ) làm trung tâm.<figure class="image"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-ddf3HUlqvDtDKQ9V9OIRe0gUVlbphOCyCuX7NF5U.png"></figure><h6 style="text-align:justify;">Nguồn: The Clean Code Blog by Robert C. Martin</h6>Các lớp trong kiến trúc clean sẽ được phân tách dựa trên các vai trò cụ thể:<ul><li style="text-align:justify;">Các entities sẽ là nơi chứa các logic nghiệp vụ chính (enterprise wide business), có thể là các đối tượng cùng phương thức, hành vi của nó, hoặc là tập hợp các cấu trúc dữ liệu (danh sách, node..) và các hàm. Các entities có thể được sử dụng ở nhiều nơi khác trong ứng dụng hoặc xuyên suốt quá trình xử lý nghiệp vụ. Các entities sẽ chỉ ràng buộc với chính nó.</li><li style="text-align:justify;">Bên ngoài sẽ là lớp chứa nghiệp vụ của ứng dụng - use cases (application specific business). Các thành phần trong lớp này sẽ chứa những cài đặt cho việc ứng dụng đó làm những gì (use cases). Những thay đổi ở lớp này sẽ không được tác động tới các entities, cũng như chính nó cũng sẽ không bị tác động bởi sự thay đổi của các thành phần khác (database, UI, thư viện...).</li><li style="text-align:justify;">Bao bọc các lớp nghiệp vụ sẽ là lớp thứ ba, chứa các interface adapters, dùng để khai báo interface chuyển đổi dữ liệu và thông tin được yêu câu giữa các lớp nghiệp vụ và các dịch bên ngoài, như là cơ sở dữ liệu, các frameworkss hay là API bên thứ ba.</li><li style="text-align:justify;">Lớp ngoài cùng sẽ chứa các frameworks và drivers, là các cái đặt cụ thể cho các interface adapters. Đây được xem là nơi chứa mọi chi tiết mà ở các lớp khác khai báo thông qua interfaces. Các frameworks và tools như là cơ sở dữ liệu, web framework, các thư viện bên thứ ba...</li></ul>Kiến trúc Clean vẫn đi theo nguyên lý của Onion: ràng buộc giữa các lớp nên là từ cấp thấp hơn sẽ phụ thuộc vào lớp cấp cao hơn thông qua các interfaces, có thể sử dụng Dependency Injection. Như vậy các logic xử lý chính sẽ không bị phụ thuộc vào các thay đổi đến từ lớp bên ngoài (frameworks and drivers). Ngoài ra, số lượng các lớp ở kiến trúc này cũng không cố định. Nó tùy thuộc vào ứng dụng cụ thể phức tạp ra sao, các yêu cầu nghiệp vụ như thế nào...Từ đó, ta có thể thấy một số ưu nhược điểm của kiến trúc này:<ul><li style="text-align:justify;">Ưu điểm:<ul><li style="text-align:justify;">Có thể sử dụng với mô hình microservices hay mẫu DDD</li><li style="text-align:justify;">Các lớp độc lập với nhau, các logic nghiệp vụ không bị phụ thuộc vào các lớp khác</li><li style="text-align:justify;">Dễ kiểm thử</li><li style="text-align:justify;">Dễ mở rộng, vì các lớp đã có vai trò riêng của nó</li></ul></li><li style="text-align:justify;">Nhược điểm:<ul><li style="text-align:justify;">Khó để học và hiểu các nghiệp vụ đã được chia tách thành các lớp</li><li style="text-align:justify;">Cấu trúc phức tạp vì cần phải triển khai qua nhiều lớp</li><li style="text-align:justify;">Do các lớp không phụ thuộc nhau nên sẽ khá trừu tượng</li></ul></li></ul><h2 style="text-align:justify;">4. Vậy kiến trúc Onion và Clean có giống nhau?</h2>Tuy kiến trúc Clean ra đời có nhiều ảnh hưởng từ Onion, giữa 2 kiến trúc vẫn có những điểm giống và khác nhau.Cả hai kiến trúc đều hướng tới việc chia ứng dụng thành nhiều lớp xử lý với các vai trò khác nhau, giúp cho việc xây dựng và triển khai dự án dễ dàng hơn. Cả hai kiến trúc đều áp dụng nguyên lý Dependency Inversion giữa các lớp, giúp cho sự ràng buộc giữa các lớp giảm bớt, các lớp cấp thấp hơn sẽ phụ thuộc lớp cấp cao hơn thông qua abstractions chứ không phải là trực tiếp. Ngoài ra các ứng dụng xây dựng trên 2 kiến trúc này sẽ có khả năng mở rộng cao và có thể được kiểm thử độc lập cho từng lớp.Những điiểm khác nhau giữa hai kiến trúc:<ul><li style="text-align:justify;">Kiến trúc Onion<ul><li style="text-align:justify;">Tập trung vào xử lý nghiệp vụ và đưa nó vào trung tâm</li><li style="text-align:justify;">Các lớp được chia theo vai trò chung (domain, repositories, services..), chủ yếu để phục vụ cho lớp domain trung tâm</li><li style="text-align:justify;">Các xử lý liên quan đến kỹ thuật, công nghệ được đưa các xử lý ra các lớp bên ngoài</li></ul></li><li style="text-align:justify;">Kiến trúc Clean:<ul><li style="text-align:justify;">Chia việc xử lý nghiệp vụ thành 2 lớp: enitities (enterprise wide business) và use cases (application specific business)</li><li style="text-align:justify;">Các lớp được chia theo vai trò cụ thể (entities, interface adapters, frameworks and drivers..)</li><li style="text-align:justify;">Sử dụng dependency inversion để phân tách các xử lý rồi mới đưa ra bên ngoài</li></ul></li></ul><h2 style="text-align:justify;">5. Vậy ta nên sử dụng kiến trúc nào?</h2>Các ứng dụng khác nhau sẽ có khối nghiệp vụ và độ phức tạp khác nhau. Cho nên, tùy vào mỗi ứng dụng và các yêu cầu chức năng của nó mà ta sẽ chọn kiến trúc cho phù hợp.Một số gợi ý khi chọn kiến trúc Onion:<ul><li style="text-align:justify;">Thường dành cho mô hình nghiệp vụ của ứng dụng tương đối phức tạp, yêu cầu khá nhiều về tính nhất quán cũng như nhiều tính toán chặt chẽ.</li><li style="text-align:justify;">Các công nghệ, thư viện sử dụng ở các lớp services có thể linh động</li></ul>Chúng ta sẽ cân nhắc chọn kiến trúc Clean khi:<ul><li style="text-align:justify;">Mô hình nghiệp vụ không quá phức tạp, có thể chứa trong các đối tượng truyền dữ liệu cùng các hành vi và phương thức</li><li style="text-align:justify;">Các công nghệ, thư viên sử dụng ở các lớp services có tính phổ biến, cung cấp nhiều tính năng cho hệ thống</li></ul><h2 style="text-align:justify;">6. Kết luận</h2>Onion và Clean đều là những kiến trúc rất hay, hướng ứng dụng tới việc xử lý những khía cạnh của nghiệp vụ, đưa các thư viện, dịch vụ khác ra các lớp bên ngoài. Những ứng dụng này sẽ có khả năng linh động cao, mở rộng tốt, và có tính bảo trì. Có thể nói, 2 kiến trúc này có thể sử dụng để xây dựng bất kỳ loại ứng dụng nào. Và các lập trình viên sẽ cần phải lựa chọn loại kiến trúc phù hợp với nhu cầu, sự phát triển của dự án, ứng dụng.Tài liệu tham khảo<ol><li style="text-align:justify;"><a href="https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/?_gl=1*7a1tjd*_ga*NzE5NTM3ODY4LjE2NzkzODcyOTk.*_ga_092EL089CH*MTY3OTYzMDAzNy42LjEuMTY3OTYzMDA1NS40Mi4wLjA.">Software Architecture Patterns by Mark Richards</a></li><li style="text-align:justify;"><a href="https://www.oreilly.com/library/view/clean-architecture-a/9780134494272/">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a></li><li style="text-align:justify;"><a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html">The Clean code blog - Clean Architecture (Uncle Bob)</a></li><li style="text-align:justify;"><a href="https://jeffreypalermo.com/2008/07/the-onion-architecture-part-1/">The Onion Architecture - Jeffrey Palermo</a></li></ol></body></html>

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.

&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

So sánh Onion Architecture và Clean Architecture

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.

[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é

[Design Pattern] Bài 06: Sử Dụng Prototype Trong Java

Design Patterns

<html><body><h2>1. Microservices là gì?    </h2><ul><li>Microservices là một kiến trúc phần mềm bao gồm nhiều services nhỏ (micro-service). Ý tưởng của microservices là chia bài toán lớn thành nhiều bài toán nhỏ.    </li><li>Kiến trúc microservices khá phổ biến hiện nay và được nhiều công ty lớn sử dụng như: Netflix, eBay, Amazon, Twitter, PayPal,...    </li><li>Mỗi service trong kiến trúc này là mỗi module độc lập giúp dễ dàng phát triển, kiểm thử, mở rộng và triển khai…    </li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-Mewjv7fi3suPq2CCAtJF0o301ALiBtXDl6TkhQTk.png">  <h2>2. Lợi ích của microservices?</h2><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-GUiY1ZOvBclZZJQsHuJmcENmljTDZcZcUs5aumJ2.png">    <ul><li>Linh động: các services được tổ chức thành các modules độc lập phân tán giúp dễ dàng phát triển, tích hợp và triển khai từng phần (CI/CD).    </li><li>Nhiều lựa chọn về công nghệ: có thể lựa chọn các kiến trúc, công nghệ, ngôn ngữ, cơ sở dữ liệu cho từng service.</li></ul>Ví dụ: có thể tận dụng nguồn lực thế mạnh của nhiều team để áp dụng công nghệ phù hợp cho mỗi service. Service này sử dụng .net, sql server, service khác sử dụng nodejs, mongodb, cosmosdb...<ul><li>Khả năng chịu lỗi: Khi một hoặc một vài service xảy ra lỗi thì các services khác không hoặc ít bị ảnh hưởng. Đảm bảo toàn hệ thống vẫn vận hành được. Khi sửa lỗi chỉ sửa lỗi ở đúng service đó do các service được thiết kế độc lập, ít phụ thuộc vào nhau nhất có thể.    </li><li>Tối ưu hiệu quả về chi phí: tối ưu và chia nhỏ chi phí cho từng service nhỏ thay vì một ứng dụng lớn.    Ví dụ: service cần lưu trữ dung lượng database, file.. thì ta sẽ scale trên riêng service đó, hoặc đôi lúc có thể tận dụng nhiều công nghệ miễn phí cho các service nhỏ.    </li></ul><h2>3. So sánh monolithic và microservices    </h2><ul><li>Monolithic   <ul><li>Tập trung toàn bộ vào một ứng dụng lớn, dự án lớn thì team size và soure code sẽ phình to ra.    </li><li>Việc triển khai (deployment) sẽ đơn giản do toàn bộ tập trung vào một dự án.    </li><li>Kiến trúc truyền thống, dễ tiếp cận.    </li><li>Quá trình deployment không linh hoạt, thời gian build ứng dụng sẽ lâu, khi có một thay đổi nhỏ cũng phải build lại toàn bộ ứng dụng.    </li><li>Khó khăn trong việc kiểm tra lỗi và bảo trì do các modules, services trong dự án phụ thuộc chặt chẽ vào nhau (coupling code).    </li><li>Gặp vấn đề về khả năng chịu lỗi. Khi bị bất kỳ một lỗi nào thì có khả năng toàn bộ ứng dụng bị chết.    </li><li>Khả năng mở rộng hạn chế do tập trung một khối lớn.    </li><li>Khó áp dụng nhiều công nghệ vào dự án.</li></ul></li></ul> <img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-q3M6Qc9vOBMnX5mcuzaZsL99ieLtelloX59KhL0a.png"> <ul><li>Microservices   <ul><li>Chia nhỏ ứng dụng thành các services nhỏ hơn. Ý tưởng của microservices là chia bài toán lớn thành các bài toán nhỏ.    </li><li>Các services được xây dựng độc lập, có khả năng phát triển, kiểm lỗi và triển khai độc lập.    </li><li>Các team làm việc độc lập trên từng services, từng features.    </li><li> Áp dụng các công nghệ, ngôn ngữ khác nhau vào từng services.    </li><li>Khả năng chịu lỗi tốt do các service độc lập, một service bị lỗi thì toàn hệ thống có khả năng vẫn hoạt động được và dễ dàng sửa lỗi đúng service đó.</li></ul></li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-vRHmvtjLk6G4z9cXcw4wF248JGhu7rkr6Aj4xlNs.png"><h2>4. Ưu và nhược điểm của microservices    </h2><h3>Ưu điểm</h3><ul><li>Chia nhỏ hệ thống lớn thành các services nhỏ độc lập nên dễ dàng phát triển, bảo trì và triển khai độc lập.</li><li>Dễ dàng cho các thành viên mới khi tham gia vào dự án, chỉ cần học các service nhỏ.</li><li>Khả năng kiểm soát lỗi tốt, một hoặc vài services bị lỗi thị hệ thống không bị crash.</li><li>Có thể lựa chọn nhiều công nghệ khác nhau cho từng services.</li><li>Khả năng mở rộng linh hoạt, khi cần scale module, feature nào thì scale service tương ứng.</li></ul><h3>Nhược điểm</h3><ul><li>Kiến trúc phức tạp, đòi hỏi phải có kiến thức chuyên sâu về devops (CI/CD) để có thể triển khai các services nhỏ trong một hệ thống lớn</li><li>Khó để đồng bộ và thống nhất giữa các services (dữ liệu, mã nguồn, con người trong các team..), cần phải chú ý việc giao tiếp giữa các services sao cho hiệu quả.</li><li>Khó đảm bảo sự toàn vẹn và nhất quán dữ liệu giữa các services do mỗi service sử dụng một database riêng.    </li></ul><h2>5. Các nguyên lý khi xây dựng service trong microservices </h2><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-J1NR21J9UiZ0pCvFU35ifBXiwbyrMrUAF1vylsYV.png"><ul><li>Một service chỉ nên xử lý một nhiệm vụ chính duy nhất.    </li><li>Mỗi service phải độc lập, có khả năng đóng gói và triển khai độc lập. (CI/CD)    </li><li>Có thể di chuyển các services từ môi trường này sang môi trường khác dễ dàng, thuận tiện cho việc tích hợp và triển khai.    </li><li>Mỗi service nên có dữ liệu của riêng nó, không nên chứa dữ liệu của các service khác. Nếu các service muốn chia sẻ dữ liệu thì nên giao tiếp qua các public interface.    </li><li>Khi một service bị lỗi thì không ảnh hưởng đến toàn hệ thống. Có thể dễ dàng hủy và tạo lại service theo yêu cầu.    </li></ul><h2>6. Giới thiệu về series thực chiến xây dựng hệ thống microservices</h2><ul><li>Phần 1 chủ yếu lý thuyết tổng quan về kiến trúc microservices. Hiểu được khái niệm và tư tưởng.</li><li>Phần 2 sẽ giới thiệu cấu trúc dự án microservices. Đồng thời xây dựng 2 services đầu tiên là product (.net 6 + mySql) và customer (.net 6 Minimal API + PostgreSQL)</li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-qLj1llkf735WjoFuThx1oA7ZYt6xYxlMfY2ejItU.png"><ul><li>Phần 3 nội dung về Clean Architecture và CQRS pattern. Đồng thời xây dựng 3 service: basket service (.net 6 + redis), order service (.net 6 + sql server) và email service.</li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-aiMfOSPBsazfROOz1eOttNvaK4PaJCrcByXRxrjk.png"><ul><li>Phần 4 nội dung tập trung vào cách các micro service giao tiếp với nhau. Phần này mình sẽ giới thiệu về RabbitMQ và Kaffka. Tích hợp RabbitMQ vào hệ thống hiện tại cho quy trình đặt hàng - 2 services Basket và Order sẽ giao tiếp với nhau.</li></ul><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-NYxyyimZvdGmiBWMw58hKfsboBCN5aJV7omqOXOx.png"><img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-wGUMGuu8WLpsYAJ1Lc0B3FL0dulfQ6X3nvWtd7S7.png"><ul><li>Phần 5 về API Gateway (Ocelot) trong microservices   <img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-UMvqaAIhhxwHKr3oKiPVz5ajX8ck5lbhFolqhPEA.png"></li><li>Phần cuối là một số nội dung khác về micorservices như quản lý transaction giữa các services, xử lý logging cho các request giữa các service, health check và retry (polly),.…</li></ul><h2>7. Tổng kết    </h2><ul><li>Vậy là chúng ta đã đi qua tổng quan về microservices và giới thiệu về nội dung tiếp theo trong series thực chiến xây dựng hệ thống microservices.</li><li>Cảm ơn mọi người đã xem bài viết. Chúc mọi người một cuối tuần vui vẻ.</li><li>Nếu có thắc mắc về các phần trong bài này mọi người có thể inbox qua mail: <a href="mailto:long.nguyendh@saigontechnology.com">long.nguyendh@saigontechnology.com</a>. Mình sẽ giải đáp thắc mắc trong tầm hiểu biết. Cảm ơn mọi người.</li></ul> References<ul><li><a href="https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/microservices">Microservice architecture - Azure</a></li><li><a href="https://learn.microsoft.com/en-us/dotnet/architecture/microservices/architect-microservice-container-applications/microservices-architecture">Microservices architecture | Microsoft Learn</a></li><li><a href="https://learn.microsoft.com/en-us/dotnet/architecture/microservices/architect-microservice-container-applications/direct-client-to-microservice-communication-versus-the-api-gateway-pattern">The API gateway pattern versus the direct client-to-microservice communication | Microsoft Learn</a></li><li><a href="https://rabbitmq.com/">https://rabbitmq.com/</a></li><li>https://kafka.apache.org/</li></ul></body></html>

Giới thiệu tổng quan về microservice, lợi ích khi xây dựng dự án sử dụng kiến trúc microservice, các nguyên lý khi xây dựng microservice, điểm mạnh điểm yếu của microservices, đồng thời giới thiệu series thực chiến xây dựng hệ thống microservices.

&lt;html&gt;&lt;body&gt;&lt;h2&gt;1. Microservices l&agrave; g&igrave;?&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/h2&gt;&lt;ul&gt;&lt;li&gt;Microservices l&agrave; một kiến tr&uacute;c phần mềm bao gồm nhiều services nhỏ (micro-service). &Yacute; tưởng của microservices l&agrave; chia b&agrave;i to&aacute;n lớn th&agrave;nh nhiều b&agrave;i to&aacute;n nhỏ.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Kiến tr&uacute;c microservices kh&aacute; phổ biến hiện nay v&agrave; được nhiều c&ocirc;ng ty lớn sử dụng như: Netflix, eBay, Amazon, Twitter, PayPal,...&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Mỗi service trong kiến tr&uacute;c n&agrave;y l&agrave; mỗi module độc lập gi&uacute;p dễ d&agrave;ng ph&aacute;t triển, kiểm thử, mở rộng v&agrave; triển khai&hellip;&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-Mewjv7fi3suPq2CCAtJF0o301ALiBtXDl6TkhQTk.png&quot;&gt;&lt;/p&gt;&lt;p&gt;&nbsp;&lt;/p&gt;&lt;p&gt;&nbsp;&lt;/p&gt;&lt;h2&gt;2. Lợi &iacute;ch của microservices?&lt;/h2&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-GUiY1ZOvBclZZJQsHuJmcENmljTDZcZcUs5aumJ2.png&quot;&gt; &nbsp;&lt;br&gt;&lt;br&gt;&nbsp;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;&lt;strong&gt;Linh động:&lt;/strong&gt; c&aacute;c services được tổ chức th&agrave;nh c&aacute;c modules độc lập ph&acirc;n t&aacute;n gi&uacute;p dễ d&agrave;ng ph&aacute;t triển, t&iacute;ch hợp v&agrave; triển khai từng phần (CI/CD).&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;&lt;strong&gt;Nhiều lựa chọn về c&ocirc;ng nghệ:&lt;/strong&gt; c&oacute; thể lựa chọn c&aacute;c kiến tr&uacute;c, c&ocirc;ng nghệ, ng&ocirc;n ngữ, cơ sở dữ liệu cho từng service.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;V&iacute; dụ: c&oacute; thể tận dụng nguồn lực thế mạnh của nhiều team để &aacute;p dụng c&ocirc;ng nghệ ph&ugrave; hợp cho mỗi service. Service n&agrave;y sử dụng .net, sql server, service kh&aacute;c sử dụng nodejs, mongodb, cosmosdb...&lt;/p&gt;&lt;ul&gt;&lt;li&gt;&lt;strong&gt;Khả năng chịu lỗi:&lt;/strong&gt; Khi một hoặc một v&agrave;i service xảy ra lỗi th&igrave; c&aacute;c services kh&aacute;c kh&ocirc;ng hoặc &iacute;t bị ảnh hưởng. Đảm bảo to&agrave;n hệ thống vẫn vận h&agrave;nh được. Khi sửa lỗi chỉ sửa lỗi ở đ&uacute;ng service đ&oacute; do c&aacute;c service được thiết kế độc lập, &iacute;t phụ thuộc v&agrave;o nhau nhất c&oacute; thể.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;&lt;strong&gt;Tối ưu hiệu quả về chi ph&iacute;:&lt;/strong&gt; tối ưu v&agrave; chia nhỏ chi ph&iacute; cho từng service nhỏ thay v&igrave; một ứng dụng lớn.&nbsp;&nbsp;&nbsp;&lt;br&gt;V&iacute; dụ: service cần lưu trữ dung lượng database, file.. th&igrave; ta sẽ scale tr&ecirc;n ri&ecirc;ng service đ&oacute;, hoặc đ&ocirc;i l&uacute;c c&oacute; thể tận dụng nhiều c&ocirc;ng nghệ miễn ph&iacute; cho c&aacute;c service nhỏ.&nbsp;&nbsp;&lt;br&gt;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;3. So s&aacute;nh monolithic v&agrave; microservices&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/h2&gt;&lt;ul&gt;&lt;li&gt;&lt;strong&gt;Monolithic&lt;/strong&gt;&nbsp;&nbsp;&lt;br&gt;&lt;br&gt;&lt;ul&gt;&lt;li&gt;Tập trung to&agrave;n bộ v&agrave;o một ứng dụng lớn, dự &aacute;n lớn th&igrave; team size v&agrave; soure code sẽ ph&igrave;nh to ra.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Việc triển khai (deployment) sẽ đơn giản do to&agrave;n bộ tập trung v&agrave;o một dự &aacute;n.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Kiến tr&uacute;c truyền thống, dễ tiếp cận.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Qu&aacute; tr&igrave;nh deployment kh&ocirc;ng linh hoạt, thời gian build ứng dụng sẽ l&acirc;u, khi c&oacute; một thay đổi nhỏ cũng phải build lại to&agrave;n bộ ứng dụng.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Kh&oacute; khăn trong việc kiểm tra lỗi v&agrave; bảo tr&igrave; do c&aacute;c modules, services trong dự &aacute;n phụ thuộc chặt chẽ v&agrave;o nhau (coupling code).&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Gặp vấn đề về khả năng chịu lỗi. Khi bị bất kỳ một lỗi n&agrave;o th&igrave; c&oacute; khả năng to&agrave;n bộ ứng dụng bị chết.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Khả năng mở rộng hạn chế do tập trung một khối lớn.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Kh&oacute; &aacute;p dụng nhiều c&ocirc;ng nghệ v&agrave;o dự &aacute;n.&lt;/li&gt;&lt;/ul&gt;&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;&nbsp;&lt;/p&gt;&lt;p&gt;&lt;strong&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-q3M6Qc9vOBMnX5mcuzaZsL99ieLtelloX59KhL0a.png&quot;&gt;&lt;/strong&gt;&lt;/p&gt;&lt;p&gt;&nbsp;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;&lt;strong&gt;Microservices&lt;/strong&gt;&nbsp;&nbsp;&lt;br&gt;&lt;br&gt;&lt;ul&gt;&lt;li&gt;Chia nhỏ ứng dụng th&agrave;nh c&aacute;c services nhỏ hơn. &Yacute; tưởng của microservices l&agrave; chia b&agrave;i to&aacute;n lớn th&agrave;nh c&aacute;c b&agrave;i to&aacute;n nhỏ.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;C&aacute;c services được x&acirc;y dựng độc lập, c&oacute; khả năng ph&aacute;t triển, kiểm lỗi v&agrave; triển khai độc lập.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;C&aacute;c team l&agrave;m việc độc lập tr&ecirc;n từng services, từng features.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;&nbsp;&Aacute;p dụng c&aacute;c c&ocirc;ng nghệ, ng&ocirc;n ngữ kh&aacute;c nhau v&agrave;o từng services.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Khả năng chịu lỗi tốt do c&aacute;c service độc lập, một service bị lỗi th&igrave; to&agrave;n hệ thống c&oacute; khả năng vẫn hoạt động được v&agrave; dễ d&agrave;ng sửa lỗi đ&uacute;ng service đ&oacute;.&lt;/li&gt;&lt;/ul&gt;&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-vRHmvtjLk6G4z9cXcw4wF248JGhu7rkr6Aj4xlNs.png&quot;&gt;&lt;/p&gt;&lt;h2&gt;4. Ưu v&agrave; nhược điểm của microservices&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/h2&gt;&lt;h3&gt;&lt;strong&gt;Ưu điểm&lt;/strong&gt;&lt;/h3&gt;&lt;ul&gt;&lt;li&gt;Chia nhỏ hệ thống lớn th&agrave;nh c&aacute;c services nhỏ độc lập n&ecirc;n dễ d&agrave;ng ph&aacute;t triển, bảo tr&igrave; v&agrave; triển khai độc lập.&lt;/li&gt;&lt;li&gt;Dễ d&agrave;ng cho c&aacute;c th&agrave;nh vi&ecirc;n mới khi tham gia v&agrave;o dự &aacute;n, chỉ cần học c&aacute;c service nhỏ.&lt;/li&gt;&lt;li&gt;Khả năng kiểm so&aacute;t lỗi tốt, một hoặc v&agrave;i services bị lỗi thị hệ thống kh&ocirc;ng bị crash.&lt;/li&gt;&lt;li&gt;C&oacute; thể lựa chọn nhiều c&ocirc;ng nghệ kh&aacute;c nhau cho từng services.&lt;/li&gt;&lt;li&gt;Khả năng mở rộng linh hoạt, khi cần scale module, feature n&agrave;o th&igrave; scale service tương ứng.&lt;/li&gt;&lt;/ul&gt;&lt;h3&gt;&lt;strong&gt;Nhược điểm&lt;/strong&gt;&lt;/h3&gt;&lt;ul&gt;&lt;li&gt;Kiến tr&uacute;c phức tạp, đ&ograve;i hỏi phải c&oacute; kiến thức chuy&ecirc;n s&acirc;u về devops (CI/CD) để c&oacute; thể triển khai c&aacute;c services nhỏ trong một hệ thống lớn&lt;/li&gt;&lt;li&gt;Kh&oacute; để đồng bộ v&agrave; thống nhất giữa c&aacute;c services (dữ liệu, m&atilde; nguồn, con người trong c&aacute;c team..), cần phải ch&uacute; &yacute; việc giao tiếp giữa c&aacute;c services sao cho hiệu quả.&lt;/li&gt;&lt;li&gt;Kh&oacute; đảm bảo sự to&agrave;n vẹn v&agrave; nhất qu&aacute;n dữ liệu giữa c&aacute;c services do mỗi service sử dụng một database ri&ecirc;ng.&nbsp;&nbsp;&lt;br&gt;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;5. C&aacute;c nguy&ecirc;n l&yacute; khi x&acirc;y dựng service trong microservices&nbsp;&lt;/h2&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-J1NR21J9UiZ0pCvFU35ifBXiwbyrMrUAF1vylsYV.png&quot;&gt;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;Một service chỉ n&ecirc;n xử l&yacute; một nhiệm vụ ch&iacute;nh duy nhất.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Mỗi service phải độc lập, c&oacute; khả năng đ&oacute;ng g&oacute;i v&agrave; triển khai độc lập. (CI/CD)&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;C&oacute; thể di chuyển c&aacute;c services từ m&ocirc;i trường n&agrave;y sang m&ocirc;i trường kh&aacute;c dễ d&agrave;ng, thuận tiện cho việc t&iacute;ch hợp v&agrave; triển khai.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Mỗi service n&ecirc;n c&oacute; dữ liệu của ri&ecirc;ng n&oacute;, kh&ocirc;ng n&ecirc;n chứa dữ liệu của c&aacute;c service kh&aacute;c. Nếu c&aacute;c service muốn chia sẻ dữ liệu th&igrave; n&ecirc;n giao tiếp qua c&aacute;c public interface.&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;li&gt;Khi một service bị lỗi th&igrave; kh&ocirc;ng ảnh hưởng đến to&agrave;n hệ thống. C&oacute; thể dễ d&agrave;ng hủy v&agrave; tạo lại service theo y&ecirc;u cầu.&nbsp;&nbsp;&lt;br&gt;&lt;br&gt;&nbsp;&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;6. Giới thiệu về series thực chiến x&acirc;y dựng hệ thống microservices&lt;/h2&gt;&lt;ul&gt;&lt;li&gt;Phần 1 chủ yếu l&yacute; thuyết tổng quan về kiến tr&uacute;c microservices. Hiểu được kh&aacute;i niệm v&agrave; tư tưởng.&lt;/li&gt;&lt;li&gt;Phần 2 sẽ giới thiệu cấu tr&uacute;c dự &aacute;n microservices. Đồng thời x&acirc;y dựng 2 services đầu ti&ecirc;n l&agrave; product (.net 6 + mySql) v&agrave; customer (.net 6 Minimal API + PostgreSQL)&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-qLj1llkf735WjoFuThx1oA7ZYt6xYxlMfY2ejItU.png&quot;&gt;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;Phần 3 nội dung về Clean Architecture v&agrave; CQRS pattern. Đồng thời x&acirc;y dựng 3 service: basket service (.net 6 + redis), order service (.net 6 + sql server) v&agrave; email service.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-aiMfOSPBsazfROOz1eOttNvaK4PaJCrcByXRxrjk.png&quot;&gt;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;Phần 4 nội dung tập trung v&agrave;o c&aacute;ch c&aacute;c micro service giao tiếp với nhau. Phần n&agrave;y m&igrave;nh sẽ giới thiệu về RabbitMQ v&agrave; Kaffka. T&iacute;ch hợp RabbitMQ v&agrave;o hệ thống hiện tại cho quy tr&igrave;nh đặt h&agrave;ng - 2 services Basket v&agrave; Order sẽ giao tiếp với nhau.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-NYxyyimZvdGmiBWMw58hKfsboBCN5aJV7omqOXOx.png&quot;&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-wGUMGuu8WLpsYAJ1Lc0B3FL0dulfQ6X3nvWtd7S7.png&quot;&gt;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;Phần 5 về API Gateway (Ocelot) trong microservices&nbsp;&nbsp;&lt;br&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-UMvqaAIhhxwHKr3oKiPVz5ajX8ck5lbhFolqhPEA.png&quot;&gt;&lt;/li&gt;&lt;li&gt;Phần cuối l&agrave; một số nội dung kh&aacute;c về micorservices như quản l&yacute; transaction giữa c&aacute;c services, xử l&yacute; logging cho c&aacute;c request giữa c&aacute;c service, health check v&agrave; retry (polly),.&hellip;&lt;/li&gt;&lt;/ul&gt;&lt;h2&gt;7. Tổng kết&nbsp;&nbsp;&lt;br&gt;&nbsp;&lt;/h2&gt;&lt;ul&gt;&lt;li&gt;Vậy l&agrave; ch&uacute;ng ta đ&atilde; đi qua tổng quan về microservices v&agrave; giới thiệu về nội dung tiếp theo trong series thực chiến x&acirc;y dựng hệ thống microservices.&lt;/li&gt;&lt;li&gt;Cảm ơn mọi người đ&atilde; xem b&agrave;i viết. Ch&uacute;c mọi người một cuối tuần vui vẻ.&lt;/li&gt;&lt;li&gt;Nếu c&oacute; thắc mắc về c&aacute;c phần trong b&agrave;i n&agrave;y mọi người c&oacute; thể inbox qua mail:&nbsp;&lt;a href=&quot;mailto:long.nguyendh@saigontechnology.com&quot;&gt;&lt;u&gt;long.nguyendh@saigontechnology.com&lt;/u&gt;&lt;/a&gt;. M&igrave;nh sẽ giải đ&aacute;p thắc mắc trong tầm hiểu biết. Cảm ơn mọi người.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;&nbsp;&lt;/p&gt;&lt;p&gt;&lt;strong&gt;References&lt;/strong&gt;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;&lt;a href=&quot;https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/microservices&quot;&gt;&lt;u&gt;Microservice architecture - Azure&lt;/u&gt;&lt;/a&gt;&lt;/li&gt;&lt;li&gt;&lt;a href=&quot;https://learn.microsoft.com/en-us/dotnet/architecture/microservices/architect-microservice-container-applications/microservices-architecture&quot;&gt;&lt;u&gt;Microservices architecture | Microsoft Learn&lt;/u&gt;&lt;/a&gt;&lt;/li&gt;&lt;li&gt;&lt;a href=&quot;https://learn.microsoft.com/en-us/dotnet/architecture/microservices/architect-microservice-container-applications/direct-client-to-microservice-communication-versus-the-api-gateway-pattern&quot;&gt;&lt;u&gt;The API gateway pattern versus the direct client-to-microservice communication | Microsoft Learn&lt;/u&gt;&lt;/a&gt;&lt;/li&gt;&lt;li&gt;&lt;a href=&quot;https://rabbitmq.com/&quot;&gt;&lt;u&gt;https://rabbitmq.com/&lt;/u&gt;&lt;/a&gt;&lt;/li&gt;&lt;li&gt;&lt;u&gt;https://kafka.apache.org/&lt;/u&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;

Tổng quan về Microservices (Phần 1)

Cài đặt môi trường làm việc cho dự án microservices với docker, xây dựng cấu trúc ban đầu cho dự án, triển khai logging và product service, containerize cho product.service.

Thực chiến xây dựng kiến trúc dự án Microservices và triển khai Product Service (phần 2)

In the previous section (part 2), I provided an overview of how to set up a working environment using Docker containers and build a Product Service. In this section (part 3), we will shift our focus to building Customer Service using .NET, Minimal API, and PostgreSQL.