<html><body><h2>1. Load Test </h2><h3>Definition</h3>A load test is a type of Performance test that evaluates the behaviors of the application under various loads. It helps to identify the maximum capacity of the system and the point at which it starts to degrade. Load test involves simulating a large number of users accessing the application simultaneously. The test measures the response time and the throughput of the application under different loads. The results help to identify potential bottlenecks and optimize the performance of the system.<h3>How to apply for a Load Test?</h3><ul><li>Use realistic scenarios that simulate real-world usage patterns.</li><li>Test early and often to identify issues early on.</li><li>Monitor system resources such as CPU usage, memory usage, and network usage during the test.</li><li>Use real data to simulate user behaviours.</li></ul>How to Apply Load Test to a Project:To apply a Load test to a project, first, define the objectives and goals of the test. Identify the expected load that the application will receive and create scenarios that simulate this load. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize the system accordingly.<h2>2. Stress Test</h2><h3>Definition</h3>Stress testing is a type of Performance test that evaluates the stability and robustness of the application under extreme conditions. It involves testing the application beyond its normal operational capacity to identify its breaking point. Stress testing helps to identify potential issues such as memory leaks, resource exhaustion, and unexpected crashes. The test also helps to optimize the system by identifying potential issues and fixing them before they affect the end users.<h3>How to apply for a Stress Test?</h3><ul><li>Define clear objectives for the test.</li><li>Use realistic scenarios that simulate extreme conditions.</li><li>Test early and often to identify issues early on.</li><li>Monitor system resources such as CPU usage, memory usage, and network usage during the test.</li><li>Use real data to simulate user behaviours.</li></ul>How to Apply Stress Testing to a Project:To apply stress testing to a project, first, define the objectives and goals of the test. Identify the extreme conditions that the application may experience and create scenarios that simulate these conditions. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize the system accordingly.<h2>3. Spike Test</h2><h3>Definition</h3>Spike testing is a type of performance test that evaluates the behaviour of the application under sudden and significant changes in load. It involves testing the application with a sudden and significant increase or decrease in load to identify how the system handles the spike. Spike testing helps to identify issues such as server crashes, service disruptions, and database failures. It also helps to optimize the system by identifying potential issues and fixing them before they affect the end users.<h3>How to apply for the Spike Test?</h3><ul><li>Use realistic scenarios that simulate sudden and significant changes in load.</li><li>Test early and often to identify issues early on.</li><li>Monitor system resources such as CPU usage, memory usage, and network usage during the test.</li><li>Use real data to simulate user behaviour.</li></ul>How to Apply Spike Testing to a Project:To apply spike testing to a project, first, define the objectives and goals of the test. Identify the sudden and significant changes in load that the application may experience and create scenarios that simulate these changes. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize the system accordingly.<h2>4. Endurance Test</h2><h3>Definition</h3>The endurance test is a type of Performance test that evaluates the behaviour of the application over a prolonged period. It involves testing the application under normal operational conditions for an extended period to identify issues such as memory leaks, performance degradation, and resource exhaustion. Endurance tests help to ensure that the application can handle sustained loads and perform consistently over time.<h3>How to apply for an Endurance Test?</h3><ul><li>Define clear objectives for the test.</li><li>Use realistic scenarios that simulate real-world usage patterns over a prolonged period.</li><li>Test early and often to identify issues early on.</li><li>Monitor system resources such as CPU usage, memory usage, and network usage during the test.</li><li>Use real data to simulate user behaviour.</li></ul>How to Apply Endurance Test to a Project:To apply an Endurance test to a project, first, define the objectives and goals of the test. Identify the sustained loads that the application may experience and create scenarios that simulate these loads over a prolonged period. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize<h2>5. Volume Test</h2><h3>Definition</h3>Volume test is a type of performance test that evaluates the behaviours of the application under varying volumes of data. It involves testing the application with different sizes of data to identify how the system handles the data. Volume test helps to identify issues such as slow response times, database failures, and system crashes. It also helps to optimize the system by identifying potential issues and fixing them before they affect the end users.<h3>How to apply a Volume Test?</h3><ul><li>Use realistic scenarios that simulate different volumes of data.</li><li>Test early and often to identify issues early on.</li><li>Monitor system resources such as CPU usage, memory usage, and network usage during the test.</li><li>Use real data to simulate user behaviours.</li></ul>How to Apply Volume Test to a Project:To apply a volume test to a project, first, define the objectives and goals of the test. Identify the different volumes of data that the application may handle and create scenarios that simulate these volumes. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize the system accordingly.<h2>6. Conclusion</h2>Each type of performance test has a specific purpose to ensure that the system performs well under specific conditions that meet the business expectations. Selecting an appropriate type of performance test depends on the kind of the system, the expected workload, and the performance goals defined for the application or system.References<ul><li>ISTQB Certified Tester Foundation Level Specialist.</li><li>ISO 25010 quality management</li></ul></body></html>

Performance testing is an essential activity to evaluate speed, stability, and scalability and help the Developers identify potential issues and optimize the performance of their applications. In this blog, let’s explore the differences, benefits, and best practices of each type of performance test to apply to a project.

&lt;html&gt;&lt;body&gt;&lt;h2 style=&quot;text-align:justify;&quot;&gt;1. What is Time Behavior?&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Time behavior is the measurement of an application's ability to react to different events over time, encompassing the duration required for the application to perform particular actions such as loading a page, running a query, or processing a transaction. Time behavior also includes evaluating how the application performs under various loads, including high traffic or heavy user activity.&lt;/p&gt;&lt;h2 style=&quot;text-align:justify;&quot;&gt;2. Why Is Time Behavior Important In Performance?&lt;/h2&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Time behavior is a critical aspect of performance testing as it helps in identifying potential bottlenecks and performance issues. By measuring the application's response time under different scenarios, performance engineers can identify which parts of the application are causing delays and where improvements are needed. This information can help developers optimize the application's performance and improve its overall efficiency.&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Time behavior also plays a crucial role in user satisfaction. Users expect applications to respond quickly and efficiently, and slow response times can result in frustration and dissatisfaction. By understanding the application's time behavior, developers can ensure that the application meets users' expectations and provides a seamless experience.&lt;/li&gt;&lt;/ul&gt;&lt;h2 style=&quot;text-align:justify;&quot;&gt;3. Measuring Time Behavior In Performance Testing&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&lt;strong&gt;Time Behavior in ISO 9126 quality management:&lt;/strong&gt;&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-Rn9TZQhJLz1ZjvKjSVbUhNp1aScn344bu4qCopSH.png&quot;&gt;&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&lt;strong&gt;Time Behavior&nbsp;in&nbsp;&lt;/strong&gt;&lt;i&gt;&lt;strong&gt;ISO 25010&lt;/strong&gt;&lt;/i&gt;&lt;strong&gt; quality management:&lt;/strong&gt;&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&lt;img src=&quot;https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-iy6V3h2r5aA5aglVRlvppvWdjEKqexXw4Y1u4XXg.png&quot;&gt;&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;The&nbsp;&lt;strong&gt;time behavior evaluation&lt;/strong&gt; is the most common objective of the performance testing. This aspect evaluates the ability of a component or system to respond to user behaviors within a specified duration and under the other conditions. The time behavior measurements can differ between the system's response time from user input and the number of CPU cycles needed by a software component to perform a specific task. Since&nbsp;&lt;strong&gt;time behavior is a quality metric&lt;/strong&gt; for dedicating the system to good or bad performance, it becomes the necessary metric to be verified while doing performance verification.&nbsp; Many questions can be raised while gathering the&lt;strong&gt; performance requirements&lt;/strong&gt;. A defined goal's first priority is the user behaviors' response time as&lt;/p&gt;&lt;blockquote&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;If the actual response time is exactly 2 seconds, is it a failure expectation?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;What about 2.01 seconds?&lt;/li&gt;&lt;/ul&gt;&lt;/blockquote&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Time behavior can be measured differently. It should become the standard practice&nbsp; for the performance engineer to acquire the performance requirements from the stakeholders. The performance engineer can ask the following questing for the&nbsp;&lt;strong&gt;TIME MEASUREMENT:&lt;/strong&gt;&lt;/p&gt;&lt;blockquote&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Is this the&nbsp;&lt;strong&gt;maximum response time&lt;/strong&gt;?&nbsp;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Is this the&nbsp;&lt;strong&gt;average response time&lt;/strong&gt;?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Is this a&nbsp;&lt;strong&gt;percentile time&lt;/strong&gt; and if so, what is the exact percentile?&lt;/li&gt;&lt;/ul&gt;&lt;/blockquote&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Increasingly, the percentile measure is being used. It can be more useful to know that 95% of the user responded within two seconds than dining a maximum response time. And the other concerned questions are:&lt;/p&gt;&lt;blockquote&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Why should it be 02 seconds? Should it be less than?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;What are the impacts if the system under test took longer than the expected response time?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Would the business lose the customers if the application makes them wait longer than the expected response time?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;How does the longer wait time affect the user&rsquo;s experiences?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;What does &ldquo;response time&rdquo; mean?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Does the response time mean that the time of transaction has completed the entire operation? Or that a connection time to the target server has been completed?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;What&rsquo;s the system?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Is the time of transaction measured from the end user&rsquo;s local machine through the application stack and back to their local machine?&nbsp;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Or is response time measured from the point the web request passes the organization firewall through the application stack and back to the firewall?&lt;/li&gt;&lt;/ul&gt;&lt;/blockquote&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Crucially, for what user actions or behavior is the attainment of a two-second response time deemed necessary? Is a single user logging in, and logging out of the system? Five users? A thousand? And thousands? What happens to the&lt;strong&gt;&nbsp;&lt;/strong&gt;&lt;i&gt;&lt;strong&gt;system's performance&lt;/strong&gt;&lt;/i&gt;? How does the system scale up to satisfy the&nbsp;&lt;i&gt;&lt;strong&gt;client&rsquo;s behaviors&lt;/strong&gt;&lt;/i&gt;?&nbsp;&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Besides, the total number of transactions that need to be completed (throughput) can also affect the timing behavior. A single transaction being processed can complete quite quickly, while a thousand transactions being processed together (much higher throughput rates) can take longer.&lt;/p&gt;&lt;h2 style=&quot;text-align:justify;&quot;&gt;4. Time Behavior In Static Testing&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;The performance engineers can detect and remove defects early in the&nbsp;&lt;i&gt;&lt;strong&gt;software development lifecycle&lt;/strong&gt;&lt;/i&gt; before the code execution by reviewing the requirements, architecture designs, and implementing source code. This activity is called&nbsp;&lt;i&gt;&lt;strong&gt;Static Testing.&lt;/strong&gt;&lt;/i&gt;&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;So, in the static testing the&nbsp;&lt;i&gt;&lt;strong&gt;performance issues&lt;/strong&gt;&lt;/i&gt; can be found beyond the scope of the project. Ultimately, static testing can also allow the performance engineers to ask relevant questions against the non-executable components of the project for detecting the potential issues of time behavior as below:&lt;/p&gt;&lt;blockquote&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Will the response time be within the defined time constraints?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Have all the all time constraints been explicitly defined in relation to average, maximum, or percentile response times?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Have all temporal restrictions been precisely delineated with regards to response times in terms of mean, maximum, or percentile values?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Have these response times been validated against real-world scenarios?&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Has the assessment of these response times been carried out by various parties involved in the project?&nbsp;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;Has the evaluation of aggressive&nbsp;&lt;i&gt;&lt;strong&gt;time behaviors' effects&lt;/strong&gt;&lt;/i&gt;, such as extremely low response times, been conducted in relation to the other project features, including&nbsp;&lt;i&gt;&lt;strong&gt;cost, scope, quality, and risk&lt;/strong&gt;&lt;/i&gt;?&lt;/li&gt;&lt;/ul&gt;&lt;/blockquote&gt;&lt;h2 style=&quot;text-align:justify;&quot;&gt;5. Conclusion&lt;/h2&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;Time behavior is a fundamental concept in performance testing that helps in identifying performance issues and optimizing application performance. By measuring response time, latency, and throughput, performance engineers can gain insight into the application's behavior under various scenarios and identify areas for improvement. Understanding time behavior is crucial for ensuring that applications meet users' expectations and provide a seamless experience.&lt;/p&gt;&lt;p style=&quot;text-align:justify;&quot;&gt;&lt;strong&gt;References&lt;/strong&gt;&lt;/p&gt;&lt;ul&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;&lt;i&gt;&lt;strong&gt;ISTQB Certified Tester Foundation Level Specialist.&lt;/strong&gt;&lt;/i&gt;&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;&lt;i&gt;&lt;strong&gt;ISO 9126&lt;/strong&gt;&lt;/i&gt; quality management&lt;/li&gt;&lt;li style=&quot;text-align:justify;&quot;&gt;&lt;i&gt;&lt;strong&gt;ISO 25010&lt;/strong&gt;&lt;/i&gt; quality management&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;

Developing a high-performance and scalable system is a complex task, and organizations must find practical and cost-effective approaches to build large-scale applications. Before we get into how to do it right, let's look at Time Behavior, which is one of the most important performance factors in ISO 25010.

The Basic Concepts Of Performance Test - Time Behavior

&lt;html&gt;&lt;body&gt;&lt;h2&gt;&lt;strong&gt;1. Load Test&nbsp;&lt;/strong&gt;&lt;/h2&gt;&lt;h3&gt;Definition&lt;/h3&gt;&lt;p&gt;A load test is a type of Performance test that evaluates the behaviors of the application under various loads. It helps to identify the maximum capacity of the system and the point at which it starts to degrade. Load test involves simulating a large number of users accessing the application simultaneously. The test measures the response time and the throughput of the application under different loads. The results help to identify potential bottlenecks and optimize the performance of the system.&lt;/p&gt;&lt;h3&gt;How to apply for a Load Test?&lt;/h3&gt;&lt;ul&gt;&lt;li&gt;Use realistic scenarios that simulate real-world usage patterns.&lt;/li&gt;&lt;li&gt;Test early and often to identify issues early on.&lt;/li&gt;&lt;li&gt;Monitor system resources such as CPU usage, memory usage, and network usage during the test.&lt;/li&gt;&lt;li&gt;Use real data to simulate user behaviours.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;How to Apply Load Test to a Project:&lt;/p&gt;&lt;p&gt;To apply a Load test to a project, first, define the objectives and goals of the test. Identify the expected load that the application will receive and create scenarios that simulate this load. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize the system accordingly.&lt;/p&gt;&lt;h2&gt;&lt;strong&gt;2. Stress Test&lt;/strong&gt;&lt;/h2&gt;&lt;h3&gt;Definition&lt;/h3&gt;&lt;p&gt;Stress testing is a type of Performance test that evaluates the stability and robustness of the application under extreme conditions. It involves testing the application beyond its normal operational capacity to identify its breaking point. Stress testing helps to identify potential issues such as memory leaks, resource exhaustion, and unexpected crashes. The test also helps to optimize the system by identifying potential issues and fixing them before they affect the end users.&lt;/p&gt;&lt;h3&gt;How to apply for a Stress Test?&lt;/h3&gt;&lt;ul&gt;&lt;li&gt;Define clear objectives for the test.&lt;/li&gt;&lt;li&gt;Use realistic scenarios that simulate extreme conditions.&lt;/li&gt;&lt;li&gt;Test early and often to identify issues early on.&lt;/li&gt;&lt;li&gt;Monitor system resources such as CPU usage, memory usage, and network usage during the test.&lt;/li&gt;&lt;li&gt;Use real data to simulate user behaviours.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;How to Apply Stress Testing to a Project:&lt;/p&gt;&lt;p&gt;To apply stress testing to a project, first, define the objectives and goals of the test. Identify the extreme conditions that the application may experience and create scenarios that simulate these conditions. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize the system accordingly.&lt;/p&gt;&lt;h2&gt;&lt;strong&gt;3. Spike Test&lt;/strong&gt;&lt;/h2&gt;&lt;h3&gt;Definition&lt;/h3&gt;&lt;p&gt;Spike testing is a type of performance test that evaluates the behaviour of the application under sudden and significant changes in load. It involves testing the application with a sudden and significant increase or decrease in load to identify how the system handles the spike. Spike testing helps to identify issues such as server crashes, service disruptions, and database failures. It also helps to optimize the system by identifying potential issues and fixing them before they affect the end users.&lt;/p&gt;&lt;h3&gt;How to apply for the Spike Test?&lt;/h3&gt;&lt;ul&gt;&lt;li&gt;Use realistic scenarios that simulate sudden and significant changes in load.&lt;/li&gt;&lt;li&gt;Test early and often to identify issues early on.&lt;/li&gt;&lt;li&gt;Monitor system resources such as CPU usage, memory usage, and network usage during the test.&lt;/li&gt;&lt;li&gt;Use real data to simulate user behaviour.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;How to Apply Spike Testing to a Project:&lt;/p&gt;&lt;p&gt;To apply spike testing to a project, first, define the objectives and goals of the test. Identify the sudden and significant changes in load that the application may experience and create scenarios that simulate these changes. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize the system accordingly.&lt;/p&gt;&lt;h2&gt;&lt;strong&gt;4. Endurance Test&lt;/strong&gt;&lt;/h2&gt;&lt;h3&gt;Definition&lt;/h3&gt;&lt;p&gt;The endurance test is a type of Performance test that evaluates the behaviour of the application over a prolonged period. It involves testing the application under normal operational conditions for an extended period to identify issues such as memory leaks, performance degradation, and resource exhaustion. Endurance tests help to ensure that the application can handle sustained loads and perform consistently over time.&lt;/p&gt;&lt;h3&gt;How to apply for an Endurance Test?&lt;/h3&gt;&lt;ul&gt;&lt;li&gt;Define clear objectives for the test.&lt;/li&gt;&lt;li&gt;Use realistic scenarios that simulate real-world usage patterns over a prolonged period.&lt;/li&gt;&lt;li&gt;Test early and often to identify issues early on.&lt;/li&gt;&lt;li&gt;Monitor system resources such as CPU usage, memory usage, and network usage during the test.&lt;/li&gt;&lt;li&gt;Use real data to simulate user behaviour.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;How to Apply Endurance Test to a Project:&lt;/p&gt;&lt;p&gt;To apply an Endurance test to a project, first, define the objectives and goals of the test. Identify the sustained loads that the application may experience and create scenarios that simulate these loads over a prolonged period. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize&lt;/p&gt;&lt;h2&gt;&lt;strong&gt;5. Volume Test&lt;/strong&gt;&lt;/h2&gt;&lt;h3&gt;Definition&lt;/h3&gt;&lt;p&gt;Volume test is a type of performance test that evaluates the behaviours of the application under varying volumes of data. It involves testing the application with different sizes of data to identify how the system handles the data. Volume test helps to identify issues such as slow response times, database failures, and system crashes. It also helps to optimize the system by identifying potential issues and fixing them before they affect the end users.&lt;/p&gt;&lt;h3&gt;How to apply a Volume Test?&lt;/h3&gt;&lt;ul&gt;&lt;li&gt;Use realistic scenarios that simulate different volumes of data.&lt;/li&gt;&lt;li&gt;Test early and often to identify issues early on.&lt;/li&gt;&lt;li&gt;Monitor system resources such as CPU usage, memory usage, and network usage during the test.&lt;/li&gt;&lt;li&gt;Use real data to simulate user behaviours.&lt;/li&gt;&lt;/ul&gt;&lt;p&gt;How to Apply Volume Test to a Project:&lt;/p&gt;&lt;p&gt;To apply a volume test to a project, first, define the objectives and goals of the test. Identify the different volumes of data that the application may handle and create scenarios that simulate these volumes. Conduct the test early in the development cycle and regularly throughout the development process. Monitor system resources during the test and use the results to optimize the system accordingly.&lt;/p&gt;&lt;h2&gt;&lt;strong&gt;6. Conclusion&lt;/strong&gt;&lt;/h2&gt;&lt;p&gt;Each type of performance test has a specific purpose to ensure that the system performs well under specific conditions that meet the business expectations. Selecting an appropriate type of performance test depends on the kind of the system, the expected workload, and the performance goals defined for the application or system.&lt;/p&gt;&lt;p&gt;&lt;strong&gt;References&lt;/strong&gt;&lt;/p&gt;&lt;ul&gt;&lt;li&gt;&lt;i&gt;&lt;strong&gt;ISTQB Certified Tester Foundation Level Specialist.&lt;/strong&gt;&lt;/i&gt;&lt;/li&gt;&lt;li&gt;&lt;i&gt;&lt;strong&gt;ISO 25010&lt;/strong&gt;&lt;/i&gt; quality management&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;

Types Of Performance Test

Performance Test

<html><body><h2>1. What is capacity in performance test? </h2>Capacity in performance testing refers to the ability of a system to handle a specific workload or user traffic volume while maintaining acceptable performance levels. In other words, it is the maximum amount of load or traffic a system can handle without any performance issues such as slow response times, high error rates, or system crashes. Capacity testing involves simulating a high volume of user traffic on the system to identify bottlenecks and performance issues, and to determine the maximum amount of load the system can handle.<h2>2. Why is capacity measurement important in performance test?</h2>- First, Capacity measurement can help ensure that an application can handle the expected number of users or data without experiencing any performance issues.- Second, the Capacity measurement helps to identify the bottlenecks in performance of system, and allow the performance engineers to optimize an application's performance to handle larger loads effectively. - Finally, the Capacity measurement ensures that an application is scalable for the future growth or increasing performance of the system in peak time.<h2>3. How to measure capacity in performance test?</h2>By considering factors that are able to affect the capacity of a system, performance engineers can identify exactly capacity and areas to optimize the system resources. Some of critical factors of the system should be considered as:- Hardware resources, including the CPU, memory, disk space, and network bandwidth.- Software architecture, including the number of servers, load balancers, and databases.- Expected user behavior, such as the number of users, the type of requests, and the frequency of requests- Network infrastructure, including the bandwidth, latency, and packet loss.- Testing environment, including the tools and techniques used for performance testing.- System configuration, including the settings for caching, logging, and other parameters.  To measure the capacity of system effectively and identify potential performance issues, performance engineers can use the following strategies and work closely with developer team and stakeholders as - Define realistic user scenarios and traffic volumes based on the system's expected usage patterns.- Choose appropriate performance testing tools that can simulate realistic user behavior and traffic volumes.- Conduct a series of tests with gradually increasing loads, starting from low loads and increasing to peak loads, to identify the system's maximum capacity.- Monitor key system metrics such as response time, throughput, CPU usage, memory usage, and network utilization during the tests.- Analyze the test results to identify performance issues such as slow response times, high error rates, or bottlenecked resources.- Use profiling tools to drill down and identify the root cause of performance issues.- Make more changes to improve capacity and performance of the system, such as optimizing code, tuning database settings, or upgrading hardware or infrastructure.- Repeat the testing process to ensure that the changes have had the desired effect on the system's capacity and performance.  Available tools to measure capacity of the system:- Apache JMeter is used to test the performance and capacity of web applications.- LoadRunner is a commercial tool from Micro Focus that can be used to test the performance and capacity of various types of applications, including web, mobile, and cloud applications.- Gatling is an open-source tool that can be used to test the performance and capacity of web applications.- Apache Bench is a command-line tool that can be used to test the performance and capacity of web servers.- Tsung is an open-source tool that can be used to test the performance and capacity of various types of applications, including web, SOAP, and XMPP applications.- Locust is an open-source tool that can be used to test the performance and capacity of web applications.<h2 style="text-align:justify;">4. Best practices for system capacity measurement </h2>Measuring capacity can present several challenges for performance engineers. Here are some of the most common challenges in capacity measurement:- Limited Resources, such as time, budget, or test hardware, can make it challenging to conduct thorough capacity testing. It can be difficult to simulate real-world traffic volumes and user behavior with limited resources.- Complex Systems with multiple components, dependencies, and integration points can be difficult to test comprehensively. It can be challenging to isolate performance issues in such systems.- Changing Requirements can make it difficult to plan and execute capacity testing effectively. Unexpected changes in traffic volumes or user behavior can lead to inaccurate test results.- Lack of Test Data can make it difficult to simulate realistic user behavior and traffic volumes. Without adequate test data, it can be challenging to generate accurate test results.- Scalability Issues can arise when the system's capacity is insufficient to handle growing traffic volumes or user activity. It can be challenging to predict future capacity requirements and ensure that the system can scale to meet them.- Unreliable performance testing tools can lead to inaccurate test results and make it challenging to identify performance issues. Using the wrong tools or outdated versions of tools can also result in inaccurate test results. Here are some best practices that can help performance engineers measure the capacity of a system effectively:- Defining clear objectives for capacity testing, such as determining the maximum number of users the system can handle or identifying performance bottlenecks, is important to help focus testing efforts and ensure that the testing is aligned with the goals of the project.- Using realistic test scenarios that reflect the expected usage patterns of the system will help ensure that the testing is relevant and accurate. Using production-like environments helps to ensure that the testing environment accurately reflects the production environment.- Using appropriate testing tools that can simulate realistic user behavior and traffic volumes will help ensure that the testing accurately reflects the expected usage patterns of the system.- Monitoring key system metrics during testing, such as response time, throughput, CPU usage, memory usage, and network utilization, will help identify performance issues and ensure that the testing accurately reflects the system's performance.- Conducting multiple rounds of testing with gradually increasing loads to identify the system's maximum capacity and any performance bottlenecks is essential.- Collaborating closely with development teams to identify and resolve performance issues will ensure that performance issues are resolved efficiently and effectively.- Documenting and sharing test results will ensure that everyone is aware of the system's capacity and any performance issues.<h2 style="text-align:justify;">5. Conclusion</h2>Capacity Measurement in performance test is essential to ensure that an application can handle the expected number of users or data without experiencing any performance issues. By using load testing, stress testing, and scalability testing, performance engineers can determine an application's capacity and optimize it for the expected usage. By following best practices such as defining realistic load scenarios, starting with baseline testing, monitoring key performance indicators, and using cloud-based testing, performance engineers can deliver high-performing applications that meet the needs of their users.Source: https://saigontechnology.com/blog/the-basic-concepts-of-performance-test-capacity</body></html>

Capacity is one of the most important performance factors in ISO 25010 and is a critical aspect of performance testing because it helps the organizations determine the scalability of their system and ensure that it can handle expected traffic volumes. In this article, we will discuss what capacity is in a performance test, why it is essential, and how to measure it effectively.

The Basic Concepts Of Performance Test - Capacity

<html><body><h2>1. What is Resource Utilization In Performance Test? </h2>Resource Utilization refers to the effective usage and allocation of various resources of the system such as CPU, memory, network bandwidth, and storage space to perform an operation. The purpose of measuring resource utilization is to identify performance bottlenecks and optimize resource usage to improve the overall performance of the application. This optimization process is critical in ensuring that performance tests yield accurate and reliable results, as well as identifying potential bottlenecks to ensure that the system can handle expected workloads.<h2>2. Why Is The Resource Utilization Important?</h2>Because of several benefits as below:<ul><li style="text-align:justify;">Optimizing resource utilization can help performance of the application better by reducing the performance bottlenecks, improving the response time faster, and reducing the downtime of system resources.</li><li style="text-align:justify;">Optimizing resource utilization can help reduce the number of resources required to run an application, resulting in cost savings on infrastructure, maintenance, and energy costs.</li><li style="text-align:justify;">By optimizing resource utilization, an application can better handle higher user loads and scale to meet future demand without requiring additional resources.</li><li style="text-align:justify;">Optimizing resource utilization can help ensure that an application is reliable and stable under varying loads, reducing the risk of crashes or system failures.</li><li style="text-align:justify;">By optimizing resource utilization, an application can provide a more consistent and reliable user experience, resulting in higher user satisfaction and engagement.</li></ul><h2>3. How To Optimize Resource Utilization?</h2>To optimize the resource utilization, the performance engineer can apply some below strategies:<ul><li style="text-align:justify;">Test Early and Often is to help detect the performance issues early on and prevent them from becoming major problems down the line.</li><li style="text-align:justify;">Monitor Resource Usage during performance testing is to detect the areas of high resource consumption, optimize resource allocation and prevent over-provisioning of resources.</li><li style="text-align:justify;">Use Realistic Scenarios that accurately simulate user behavior and workload patterns is to identify performance issues under real-world conditions and optimize resource utilization accordingly.</li><li style="text-align:justify;">Use Virtualization Technologies to create multiple test environments on a single physical machine is to help maximize resource utilization and reduce hardware costs.</li><li style="text-align:justify;">Optimize Code includes many techniques such as caching, reducing unnecessary database queries, and optimizing algorithms.</li><li style="text-align:justify;">Consider Using Cloud-Based Testing Services that provide on-demand access to scalable computing resources help optimize resource utilization by dynamically allocating resources based on demand.</li></ul>In addition, performance engineers frequently monitor various factors to identify potential performance issues and optimize resource utilization:<ul><li style="text-align:justify;">Workload: such as the number of concurrent users, the types of requests being made, and the volume of data being processed.</li><li style="text-align:justify;">System Configuration: including hardware specifications, network bandwidth, and operating system settings.</li><li style="text-align:justify;">Software Architecture: including the use of caching, load balancing, and other optimization techniques.</li><li style="text-align:justify;">Environment: such as the network topology, firewalls, and other security measures.</li><li style="text-align:justify;">Data Volume: including the size of the database, the number of files being processed, and the size of data being transferred over the network.</li></ul><h2>4. Best Practices For Optimizing Resource Utilization</h2><h3>Common challenges of optimizing resource utilization:</h3><ul><li style="text-align:justify;">Identifying the right set of resources to monitor and analyze based on the system under test and performance objectives.</li><li style="text-align:justify;">Balancing the trade-off between resource utilization and system performance - optimizing one may negatively impact the other.</li><li style="text-align:justify;">Dealing with intermittent performance issues or spikes in resource utilization that may be difficult to reproduce or diagnose.</li><li style="text-align:justify;">Scaling up or down resources dynamically based on changing workload or system demands.</li><li style="text-align:justify;">Managing the complexity of distributed systems and cloud environments, where resources may be distributed across multiple servers, containers, or instances.</li><li style="text-align:justify;">Ensuring that resource utilization is consistent and repeatable across multiple test runs and environments.</li><li style="text-align:justify;">Integrating resource monitoring and analysis tools with other performance testing tools and frameworks.</li></ul><h3>Best practices for optimizing resource utilization:</h3><ul><li style="text-align:justify;">Identify resource-intensive transactions: The first step in optimizing resource utilization is to identify transactions that consume a significant amount of resources. Once these transactions are identified, developers can analyze the code and optimize it to reduce the resource consumption.</li><li style="text-align:justify;">Optimize Resource Usage: Optimizing resource usage involves identifying areas where resources are being wasted or underutilized and optimizing them for better performance.</li><li style="text-align:justify;">Use caching: Caching is a technique used to store frequently accessed data in memory, which reduces the load on the database and improves performance. By implementing caching, developers can optimize resource utilization and improve the overall performance of the system.</li><li style="text-align:justify;">Monitor resource usage: Monitoring resource usage during performance testing is crucial to identify bottlenecks and optimize resource utilization. Developers can use tools such as monitoring software, profiling tools, and performance counters to track resource usage and identify areas that need improvement.</li><li style="text-align:justify;">Conduct Regular Performance Testing: Conducting regular performance testing can help identify performance bottlenecks and inefficiencies in an application's resource usage and allow developers to optimize resource usage over time.</li><li style="text-align:justify;">Use Realistic Load Scenarios: Using realistic load scenarios that reflect real-world usage can help ensure that resource utilization testing accurately reflects expected usage.</li></ul><h3>Available tools to measure resource utilization:</h3><ul><li style="text-align:justify;">Performance Monitor: is a built-in tool in the Windows operating system that provides real-time monitoring of system resources such as CPU, memory, disk, and network usage. It can be used to collect and analyze data during performance testing.</li><li style="text-align:justify;">JMeter: is an open-source tool that is widely used for performance test of the web applications. It includes built-in plugins that allow for the monitoring of system resources, including CPU usage, memory usage, and network usage.</li><li style="text-align:justify;">LoadRunner: is a commercial performance testing tool that includes built-in monitoring capabilities for system resources such as CPU, memory, disk I/O, and network usage. It also includes analysis tools for identifying performance bottlenecks.</li><li style="text-align:justify;">Gatling: is another open-source tool used for performance testing of web applications. It includes built-in plugins for monitoring system resources such as CPU and memory usage.</li><li style="text-align:justify;">New Relic: is a cloud-based tool that provides real-time monitoring of system resources, including CPU, memory, and network usage. It can be integrated with performance testing tools to provide detailed insights into resource utilization during performance testing.</li></ul><h2>5. Conclusion</h2>Resource utilization testing is critical for ensuring that an application can handle expected user loads efficiently and scale to meet future growth or demand. By using monitoring tools, profiling tools, and load testing, developers can measure an application's resource utilization and identify performance bottlenecks and inefficiencies. By following best practices such as identifying resource-intensive areas, optimizing resource usage, conducting regular performance testing, and using realistic load scenarios, developers can optimize an application's resource utilization and deliver high-performing applications that meet the needs of their users.Source: https://saigontechnology.com/blog/the-basic-concepts-of-performance-test-resource-utilization</body></html>

Resource Utilization is the other most important performance factor in ISO 25010. It refers to the measurement and analysis of the usage of various resources of the system efficiently. In  this article, let’s explore its significance and optimizing strategies to enhance performance of the system.

The Basic Concepts Of Performance Test - Resource Utilization

<html><body><h2 style="text-align:justify;">1. What is Time Behavior?</h2>Time behavior is the measurement of an application's ability to react to different events over time, encompassing the duration required for the application to perform particular actions such as loading a page, running a query, or processing a transaction. Time behavior also includes evaluating how the application performs under various loads, including high traffic or heavy user activity.<h2 style="text-align:justify;">2. Why Is Time Behavior Important In Performance?</h2><ul><li style="text-align:justify;">Time behavior is a critical aspect of performance testing as it helps in identifying potential bottlenecks and performance issues. By measuring the application's response time under different scenarios, performance engineers can identify which parts of the application are causing delays and where improvements are needed. This information can help developers optimize the application's performance and improve its overall efficiency.</li><li style="text-align:justify;">Time behavior also plays a crucial role in user satisfaction. Users expect applications to respond quickly and efficiently, and slow response times can result in frustration and dissatisfaction. By understanding the application's time behavior, developers can ensure that the application meets users' expectations and provides a seamless experience.</li></ul><h2 style="text-align:justify;">3. Measuring Time Behavior In Performance Testing</h2>Time Behavior in ISO 9126 quality management:<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-Rn9TZQhJLz1ZjvKjSVbUhNp1aScn344bu4qCopSH.png">Time Behavior in ISO 25010 quality management:<img src="https://api.careers.saigontechnology.com/storage/ck-editor/CKEDITOR-iy6V3h2r5aA5aglVRlvppvWdjEKqexXw4Y1u4XXg.png">The time behavior evaluation is the most common objective of the performance testing. This aspect evaluates the ability of a component or system to respond to user behaviors within a specified duration and under the other conditions. The time behavior measurements can differ between the system's response time from user input and the number of CPU cycles needed by a software component to perform a specific task. Since time behavior is a quality metric for dedicating the system to good or bad performance, it becomes the necessary metric to be verified while doing performance verification.  Many questions can be raised while gathering the performance requirements. A defined goal's first priority is the user behaviors' response time as<blockquote><ul><li style="text-align:justify;">If the actual response time is exactly 2 seconds, is it a failure expectation?</li><li style="text-align:justify;">What about 2.01 seconds?</li></ul></blockquote>Time behavior can be measured differently. It should become the standard practice  for the performance engineer to acquire the performance requirements from the stakeholders. The performance engineer can ask the following questing for the TIME MEASUREMENT:<blockquote><ul><li style="text-align:justify;">Is this the maximum response time? </li><li style="text-align:justify;">Is this the average response time?</li><li style="text-align:justify;">Is this a percentile time and if so, what is the exact percentile?</li></ul></blockquote>Increasingly, the percentile measure is being used. It can be more useful to know that 95% of the user responded within two seconds than dining a maximum response time. And the other concerned questions are:<blockquote><ul><li style="text-align:justify;">Why should it be 02 seconds? Should it be less than?</li><li style="text-align:justify;">What are the impacts if the system under test took longer than the expected response time?</li><li style="text-align:justify;">Would the business lose the customers if the application makes them wait longer than the expected response time?</li><li style="text-align:justify;">How does the longer wait time affect the user’s experiences?</li><li style="text-align:justify;">What does “response time” mean?</li><li style="text-align:justify;">Does the response time mean that the time of transaction has completed the entire operation? Or that a connection time to the target server has been completed?</li><li style="text-align:justify;">What’s the system?</li><li style="text-align:justify;">Is the time of transaction measured from the end user’s local machine through the application stack and back to their local machine? </li><li style="text-align:justify;">Or is response time measured from the point the web request passes the organization firewall through the application stack and back to the firewall?</li></ul></blockquote>Crucially, for what user actions or behavior is the attainment of a two-second response time deemed necessary? Is a single user logging in, and logging out of the system? Five users? A thousand? And thousands? What happens to the system's performance? How does the system scale up to satisfy the client’s behaviors? Besides, the total number of transactions that need to be completed (throughput) can also affect the timing behavior. A single transaction being processed can complete quite quickly, while a thousand transactions being processed together (much higher throughput rates) can take longer.<h2 style="text-align:justify;">4. Time Behavior In Static Testing</h2>The performance engineers can detect and remove defects early in the software development lifecycle before the code execution by reviewing the requirements, architecture designs, and implementing source code. This activity is called Static Testing.So, in the static testing the performance issues can be found beyond the scope of the project. Ultimately, static testing can also allow the performance engineers to ask relevant questions against the non-executable components of the project for detecting the potential issues of time behavior as below:<blockquote><ul><li style="text-align:justify;">Will the response time be within the defined time constraints?</li><li style="text-align:justify;">Have all the all time constraints been explicitly defined in relation to average, maximum, or percentile response times?</li><li style="text-align:justify;">Have all temporal restrictions been precisely delineated with regards to response times in terms of mean, maximum, or percentile values?</li><li style="text-align:justify;">Have these response times been validated against real-world scenarios?</li><li style="text-align:justify;">Has the assessment of these response times been carried out by various parties involved in the project? </li><li style="text-align:justify;">Has the evaluation of aggressive time behaviors' effects, such as extremely low response times, been conducted in relation to the other project features, including cost, scope, quality, and risk?</li></ul></blockquote><h2 style="text-align:justify;">5. Conclusion</h2>Time behavior is a fundamental concept in performance testing that helps in identifying performance issues and optimizing application performance. By measuring response time, latency, and throughput, performance engineers can gain insight into the application's behavior under various scenarios and identify areas for improvement. Understanding time behavior is crucial for ensuring that applications meet users' expectations and provide a seamless experience.References<ul><li style="text-align:justify;">ISTQB Certified Tester Foundation Level Specialist.</li><li style="text-align:justify;">ISO 9126 quality management</li><li style="text-align:justify;">ISO 25010 quality management</li></ul></body></html>

Tech Lead

Phuong Bui

.NET Developer

Vu Truong

Senior Developer

Trung Tran

Tech lead

Wind

Long Nguyen

Business Analyst

Duong Dat Thanh

Are you facing problems with data consistency in a highly concurrent environment? Are you looking for a way to limit and synchronize access to a shared resource across services in a distributed system? Let's see how a distributed lock can help in this situation.

Implement Distributed Lock For a Microservices Software System

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

Explore the enchanting world of CSS animation, elevating web designs with captivating transitions and dynamic effects. Unleash creativity as we delve into key techniques and practices, empowering you to create immersive experiences. Join our exciting CSS animation journey!

Hong Le