The article explains how the Iterator pattern, built into Java as Iterable and Iterator interfaces, lets you traverse any collection uniformly without exposing its internal structure, demonstrates the fail‑fast mechanism, and shows when custom collections should implement Iterable.
The article explains the Chain of Responsibility design pattern, showing how to replace tangled nested if‑checks in order‑validation logic with a series of independent handler objects linked together, and demonstrates its implementation, variations, real‑world uses in filters, interceptors, and guidelines for when the pattern is appropriate.
The article explains the Template Method design pattern, showing how to lock a fixed process skeleton in a parent class while delegating variable steps to subclasses, contrasting it with the Strategy pattern and illustrating its use in real‑world frameworks.
This article walks through the evolution from direct object instantiation to Simple Factory and finally to the Factory Method pattern, explaining why scattering new statements is problematic, how Simple Factory centralizes creation but still violates the Open/Closed principle, and how the Factory Method delegates the decision to specialized factories, complete with code examples, role definitions, and guidance on when to apply each approach.
The article examines the evolution of six singleton implementations in Java, explains why the double‑checked locking pattern requires the volatile keyword to prevent instruction reordering bugs, compares Spring container‑managed singletons with classic GoF singletons, and highlights common pitfalls such as mutable state in singleton beans.
This article introduces the Flyweight design pattern, explains its intrinsic and extrinsic state concepts, presents real-world use cases such as board games and text editors, and provides a complete Java implementation with an abstract piece, concrete piece, factory pool, and test demonstration, highlighting memory savings and potential pitfalls.
This article introduces the Bridge design pattern, explains its purpose of separating two independent dimensions to reduce class explosion, provides practical real‑world examples, and walks through a complete Java implementation with interface, abstract bridge, concrete classes, and a test driver.
This article explains the Factory Method design pattern, illustrates its core principle of separating object creation from business logic, presents everyday analogies, and provides a complete Java implementation with abstract product, concrete products, abstract factory, concrete factories, and a test driver.
The article explains the Singleton pattern—ensuring a class has only one global instance—to save resources and avoid conflicts, illustrates two Java implementations (eager and lazy), and lists typical scenarios such as logging utilities, connection pools, global configuration, and exclusive resources.
The article explains how an Extension‑Point mechanism can cleanly isolate tenant‑specific logic in SaaS systems by defining variation interfaces, providing per‑tenant implementations annotated with @Extension, and routing calls at runtime using hierarchical bizCode matching, avoiding tangled if‑else or inheritance explosion.
The article reveals five sophisticated ways to leverage Java enums—state‑machine implementation, built‑in strategy pattern, enum‑lambda combos, responsibility‑chain routing, and enum‑Map DSL—showing how major frameworks like Tomcat, Spring Boot and RocketMQ employ them to write cleaner, type‑safe, and easily extensible code.
The article shows how a growing list of if‑else checks for user eligibility becomes hard to maintain, then walks through designing and implementing a Java rule engine—defining rule abstractions, building an AND/OR executor, and demonstrating usage with concrete examples, while discussing its advantages and drawbacks.
This article explains the Chain of Responsibility pattern, outlines its core components, demonstrates a complete Spring Boot order‑processing example with concrete handlers, and shares advanced techniques such as dynamic handler configuration and asynchronous processing, concluding with practical best‑practice tips.
This article explains the Chain of Responsibility design pattern, shows classic Java implementations, demonstrates its use in Spring Security, provides real‑world examples such as order processing, logging pipelines, and approval workflows, and offers advanced functional and asynchronous techniques along with performance tips and common pitfalls.
This article explains the Chain of Responsibility design pattern, its core concepts, typical use‑cases such as approval workflows and logging, provides step‑by‑step Java examples—including a basic leave‑request system and an advanced builder‑based chain—covers real‑world framework integrations, compares it with other patterns, and lists practical pros, cons, and best‑practice tips.
Explore the Chain of Responsibility design pattern, its definition, real‑world doctor analogy, when and why to use it, advantages and drawbacks, and a complete Kotlin implementation that demonstrates dynamic request routing, extensibility, and practical code output.
This article demonstrates how to implement a clear, maintainable state machine for a publishing workflow using Python's Enum type, covering state definitions, forward and backward transitions, validation, entry actions, and visualisation without external dependencies.
This article explains the Chain of Responsibility design pattern, outlines its typical application scenarios, and demonstrates two practical implementations—a multi‑step product creation validation and an expense‑approval workflow—showing how to configure, assemble, and execute handler chains dynamically in Java.
This article demonstrates how to replace cumbersome if‑else logic in Spring Boot 3.4.2 by using the Service Locator pattern with ServiceLocatorFactoryBean, providing a clean way to select parsers for different file types through an enum, interface, and Spring‑managed beans.
This article explains the Chain of Responsibility design pattern, detailing its definition, key characteristics, integration with the Strategy pattern, and practical Java code examples—including abstract interfaces, handlers, context management, and execution flow—illustrating how to build flexible, decoupled processing pipelines for complex business logic.
This article explains how to split a multi‑function OpenAPI endpoint into independent steps using the responsibility‑chain pattern in Spring, detailing the abstract component, context sharing, bean retrieval via ApplicationContext, and a controller that dynamically orders execution through a query parameter, with full code examples.
This article explains how to split a multi‑function OpenAPI interface into independent components using the chain‑of‑responsibility pattern in Spring, detailing the abstract base class, concrete handlers, a shared context, execution order configuration, and a test controller with full code examples.
This article explains Python decorators—how they wrap functions to add behavior without modifying the original code—provides clear syntax examples, a practical timing decorator, a class‑diagram illustration, and shows how the @tool decorator integrates functions into LangChain agents.
The article demonstrates how to build a dynamic Chain of Responsibility in a Spring Boot and MyBatis‑Plus application by defining an abstract handler, implementing concrete @Component beans that modify a shared Lombok‑based context, retrieving them via an ApplicationContext‑aware proxy utility, and invoking them in a client‑specified order through a REST endpoint, while suggesting LiteFlow as a production alternative.
This article explains the singleton design pattern in Python, demonstrates how to implement it using a decorator with a wrapper class, provides step‑by‑step code examples, discusses its advantages, appropriate use cases, and cautions against overuse.
This article explains the Chain of Responsibility design pattern, demonstrates its application in multi‑step product validation and expense‑approval workflows with detailed Java code, configuration handling, Spring bean injection, and discusses its advantages and drawbacks.
This article explains the singleton design pattern in PHP, detailing its purpose, core components, practical use cases such as database connection management, guidelines on when to apply or avoid it, and provides a complete runnable code example.
This article explains the Chain of Responsibility design pattern, its core concepts, characteristics, and problems it solves, then demonstrates how to combine it with the Strategy pattern through detailed Java code examples that illustrate a product‑up‑shelf validation workflow and a generic request‑handling scenario.
This article explains the object pool design pattern, its working mechanism, advantages and disadvantages, and provides step‑by‑step Java code using Apache Commons Pool along with real‑world examples for web servers and game development to improve performance and resource management.
This article explains the Chain of Responsibility design pattern, demonstrates its application in a product creation workflow with concrete Java code, shows how to configure and assemble handlers dynamically using Spring, and discusses the pattern's advantages, drawbacks, and testing scenarios.
This article explains the Singleton design pattern in Python, covering various implementation methods—including modules, decorators, classic classes, __new__ method, and metaclasses—while demonstrating thread‑safety concerns and solutions with locking, and provides complete code examples for each approach.
The article explains how adding a new reducePrincipal field to the RepayPlan class caused existing interfaces to miscalculate remaining principal, and demonstrates fixing the low‑cohesion bug by centralizing the updated calculation in a RepaymentCalculator utility so future changes occur in one place.
This article explains the difference between static and dynamic proxies in Java, walks through JDK dynamic‑proxy implementation steps, analyzes the underlying Proxy class generation process, and compares performance and usage with static proxies and CGLIB.
This article explains the State design pattern, demonstrates its Java implementation with example code, introduces Spring State Machine concepts, and provides a complete step‑by‑step guide to building and testing an order status workflow using Spring State Machine, including configuration, listeners, services, and a controller.
This article explains the Singleton design pattern, compares lazy and eager implementations in Java, discusses thread‑safety issues with double‑checked locking, presents complete code examples, and outlines the advantages, disadvantages, and appropriate use‑cases for singletons.
This article explains the Chain of Responsibility design pattern using a real‑world iron‑chain analogy, then demonstrates a complete Java Spring implementation for order validation, including interface definition, abstract base class, concrete handlers, Spring configuration, service, and controller code.
This article explains the Chain of Responsibility design pattern, demonstrates its use in multi‑step product validation and expense‑approval workflows with concrete Java examples, shows how to configure and assemble handlers dynamically, and discusses the pattern's advantages and drawbacks.
This article introduces a Spring‑based asynchronous processing SDK that leverages annotations, transaction event listeners, Kafka, XXL‑Job, and a dedicated database to achieve non‑blocking execution, fault tolerance, and eventual consistency while preserving transaction integrity and providing a clear configuration and usage guide.
This article explains the Chain of Responsibility design pattern, its typical use cases, demonstrates a flawed nested‑if implementation for a multi‑level game, and then shows step‑by‑step refactorings—including an abstract handler, concrete handlers, and a factory‑based dynamic chain—using Java code examples.
This article explains the Singleton design pattern in Python and presents seven implementation techniques—including module‑level variables, module instances, decorators, metaclasses, class methods, and thread‑safe approaches—complete with code examples and guidance on choosing the appropriate method.
The article demonstrates how to achieve high abstraction in Java by using abstract methods overridden by subclasses, passing behavior through anonymous inner classes, and implementing an asynchronous Future pattern with listeners to handle request results, providing complete code examples for each technique.
Bilibili created a unified front‑end request library using a Koa‑style middleware “onion” architecture—ConfigCtrl, AssembleCtrl, and RequestCtrl—to standardize error handling, cut code redundancy, improve performance, and provide consistent, extensible API calls across SSR/CSR, Vue2/Vue3, and in‑app H5 environments.
The article explains Go’s built‑in Goroutine concurrency model and introduces the For‑Select‑Done design pattern, detailing its three components, ideal use cases, a complete code example, and the benefits of improved readability, flow control, and resource‑leak prevention.
The article introduces the State design pattern as a behavioral pattern that lets objects change their behavior when their internal state changes, compares it with the Strategy pattern, and provides a detailed PHP example illustrating its components and usage.
This article explains the Chain of Responsibility design pattern, demonstrates its use for multi‑step product validation and a reimbursement workflow in Java with Spring, provides UML diagrams, configuration handling, concrete handler implementations, client execution code, and discusses the pattern’s advantages and drawbacks.
This article walks through the design and implementation of a simple, thread‑safe object pool in Java using a LinkedBlockingQueue, explains the underlying concepts such as factory pattern and queue trimming, and provides a complete code example with a test script and output analysis.
This article explains the DAO (Data Access Object) pattern, its origins, benefits, and how to implement it in Go with a complete example that demonstrates defining a model, creating an interface, providing a mock MySQL implementation, and using the DAO in application code.
This article explains the classic State design pattern, demonstrates a traffic‑light example, compares Spring State Machine with COLA, and walks through building a complete order‑status workflow in Spring Boot using enums, configuration, listeners, services, and a test controller, while highlighting trade‑offs and alternatives.
This article explains what a finite state machine (FSM) is, illustrates it with a car transmission example, outlines its components and diagramming, discusses its technical pros and cons, explores business benefits, and examines how state machines relate to domain‑driven design.
Design PatternFinite State Machinedomain-driven design
The article explains how the Value Object pattern, combined with PHP 8.1/8.2 features like readonly properties and named arguments, can eliminate primitive‑type validation duplication, prevent parameter‑order mistakes, and ensure immutability, thereby making PHP code more robust, maintainable, and self‑documenting.
This article explains the Singleton design pattern in PHP, covering best‑practice guidelines such as a private constructor, static accessor methods, and static instance storage, and presents performance‑enhancing techniques like lazy instantiation and safe serialization/deserialization with illustrative code examples.
This article explains the Chain of Responsibility design pattern and demonstrates how to apply it in a Java backend to evaluate login risk factors such as password errors, unusual login times, IP whitelist violations, and abnormal login locations, providing full code examples and execution flow.
The Chain of Responsibility pattern links a series of handler objects so that a request can be passed along until one processes it, decoupling sender and receiver, supporting dynamic composition, runtime flexibility, and the Open/Closed principle, as illustrated by a Java leave‑approval workflow.
Object Factory is a design pattern that centralizes object creation, enhancing decoupling, extensibility, and management of instances, and this article explains its principles, benefits, and provides five Python code examples illustrating various scenarios such as type-based creation, configuration-driven instantiation, logging factories, singleton factories, and object caching.
This article explains how the Chain of Responsibility design pattern is implemented within Spring MVC interceptors, detailing the request flow, interceptor lifecycle methods, and practical differences from the classic GoF definition, while also exploring other typical use cases of the pattern.
This article explains how the Chain of Responsibility design pattern is employed within Spring MVC interceptors, detailing the interceptor lifecycle, code implementation, differences from the classic GoF definition, and broader use cases such as authentication, logging, and order processing.
This article explains the Singleton pattern in PHP, detailing best practices such as private constructors and static access methods, and presents performance optimizations including lazy instantiation and proper serialization handling, accompanied by concrete code examples.
The article explains the Chain of Responsibility design pattern, compares its two implementation styles—chain‑driven and processor‑self‑driven—and demonstrates how open‑source frameworks such as Spring Interceptor, Servlet Filter, Dubbo, and Sentinel employ the pattern to achieve low coupling, high extensibility, and flexible request processing.
This article explains the Chain of Responsibility design pattern, its roles, and how to implement it in Java using a leave‑approval scenario to achieve decoupled, flexible, and easily extensible request handling across multiple handlers.
This article explains the Object Factory design pattern, its benefits such as decoupling, extensibility, and centralized instance management, and demonstrates five practical Python examples covering basic product creation, configuration‑driven factories, logger factories, singleton factories, and object caching factories.
This article demonstrates how to replace tightly‑coupled if‑else or switch‑case parser selection with the Service Locator Pattern in a Spring Java application, enabling easy addition of new file‑type parsers without modifying client code and adhering to the open‑closed principle.
This article explains the Chain of Responsibility design pattern, shows why naïve nested if‑statements are problematic, demonstrates a step‑by‑step refactor using linked handlers, introduces an abstract handler hierarchy, and finally presents a factory‑based dynamic configuration for scalable request processing in Java.
This article explains the purpose of the Singleton pattern, demonstrates multiple Python implementations—including module‑based, decorator, class‑based, __new__ method, and metaclass approaches—covers thread‑safety with locking, and provides complete code examples for each technique.
This article explains the Singleton design pattern in Python, describing why a single instance may be needed, and demonstrates five implementation techniques—including module-level singletons, decorators, class methods, the __new__ method, and metaclasses—while addressing thread‑safety concerns with locking mechanisms.
This article explains three Java singleton implementations—double‑checked locking with volatile, static inner‑class holder, and enum singleton—detailing their thread‑safety, lazy initialization, and how they prevent issues such as instruction reordering, serialization, and reflection attacks.
This article explains the object pool design pattern, its working mechanism, step‑by‑step Java implementation using Apache Commons Pool, advantages, drawbacks, and real‑world scenarios such as web server connection pooling and game object reuse, providing complete code examples.
This article explains the three main factory design patterns—Simple Factory, Factory Method, and Abstract Factory—detailing their concepts, typical use cases such as document parsing and browser automation, and providing complete Java‑style code examples to illustrate each pattern's implementation and benefits.
The Template Method pattern defines an algorithm’s fixed skeleton in an abstract class while delegating variable steps to subclasses via abstract or hook methods, enabling reusable, maintainable code through a final template method, concrete implementations, and practical examples such as online shopping and JDK’s AbstractList, with benefits of encapsulation and extensibility but potential complexity from inheritance.
This article explains how to replace tightly‑coupled if‑else or switch‑case logic for selecting file parsers (JSON, CSV, XML) with a Service Locator Pattern using Spring's ServiceLocatorFactoryBean, demonstrating a clean, extensible solution that follows the Open/Closed principle.
Learn how to use Spring's Application Event mechanism to separate main and sub‑processes in Java applications, covering custom event and listener creation, publishing events, abstract base event design, singleton manager, and a real‑world order‑cancellation SMS notification case.
This article demonstrates how to implement the Chain of Responsibility design pattern in PHP using the Hyperf framework, detailing the file structure, core classes such as IndexController, HandlerInterface, AbstractHandler, and concrete handlers, and includes a unit test example to verify the workflow.
This article explains the Chain of Responsibility design pattern, demonstrates its use in multi‑step product creation validation and expense‑approval workflows with concrete Java/Spring code, and discusses configuration, dynamic composition, advantages, drawbacks, and testing scenarios.
This article explains the Chain of Responsibility design pattern, demonstrates its use for request validation and processing in Java backend applications, provides complete code examples—including abstract handler, concrete validators, business logic, and a test harness—while discussing its advantages, drawbacks, and real‑world analogues such as servlet filters.
This article explains the Observer (publish‑subscribe) pattern, illustrates it with a humorous dialogue, provides complete Go interface and struct implementations for subjects and observers, shows sample client code and output, and discusses practical refactoring using the pattern for configuration changes.
This article explains the singleton design pattern, shows standard and lazy implementations in JavaScript with code examples, discusses reducing global variable pollution, and demonstrates practical usage in popular front‑end libraries such as Vuex, Ant Design message, and Axios request cancellation.
This article explains multiple Java singleton implementations—including eager initialization, static block, lazy initialization, double‑checked locking, static inner‑class holder, and enum—detailing their code, thread‑safety characteristics, advantages, and limitations such as reflection and serialization issues.
This article explains the Chain of Responsibility design pattern, illustrates it with a historical Three Kingdoms story, shows progressive refactorings from procedural code to abstract handlers in TypeScript, and demonstrates practical front‑end scenarios such as flexible location retrieval.
This article explains the factory design pattern, covering simple factory, factory method, and abstract factory variants, their typical use cases such as document parsing and automated testing, and provides complete Java code examples illustrating each implementation.
This article explains the purpose of the Singleton design pattern, demonstrates multiple Python implementations—including module‑level singletons, decorators, class‑based approaches, __new__ method, and metaclass techniques—and shows how to add thread‑safety with locks to ensure only one instance exists across concurrent executions.
This article explains the PageObject design pattern for Selenium-based test automation in Python, detailing its principles, structure, and step-by-step implementation with example code for pages, base classes, test cases, and execution scripts to improve maintainability and reduce duplication.
This article explains the Chain of Responsibility design pattern in Java, illustrating its use for multi‑level approval workflows during high‑traffic events, provides step‑by‑step code implementations, refactors naive IF logic into modular link classes, and demonstrates testing, highlighting benefits for clean, extensible backend architecture.
This article explains how to handle large Excel uploads in Java by offloading parsing and validation to a thread pool, using the Template Method pattern to reduce boilerplate, and finally applying a custom AOP annotation to manage logging, error handling, and asynchronous execution in a clean, reusable way.
This article explains the Chain of Responsibility design pattern, illustrates common misuse with a multi‑if game‑level example, and then shows step‑by‑step refactorings—including linked handlers, an abstract base class, a factory and enum‑based configuration—to produce clean, extensible Java code.
This article explores various Java singleton patterns—including eager initialization, static blocks, lazy initialization, double‑checked locking, volatile variables, static inner‑class holder, and serialization handling—explaining their mechanisms, thread‑safety concerns, and how to choose the most appropriate implementation for robust, high‑performance backend systems.
This article explains how to implement the Singleton pattern in Java using both an enum‑based approach and a static inner‑class technique, providing thread‑safe examples from Spring Data JDBC and MyBatis along with Maven dependency snippets and detailed code illustrations.
This article explains Python's object model, showing that numbers, strings, lists, tuples, sets, dictionaries, functions, classes, and modules are all objects, and then thoroughly introduces decorators, describing their design‑pattern nature, typical uses such as logging and profiling, and demonstrates class‑decorator implementation with practical examples.
This article explains Python’s special __new__ constructor, shows how to override it to create singleton and multiton patterns with caching, and demonstrates the impact on object creation, memory usage, and performance through clear code examples.
This article explains the proper C++ singleton implementation known as Meyers' Singleton, showing how a static local variable inside a getInstance() function ensures thread‑safe lazy initialization, avoids static‑initialization‑order problems, and handles inheritance correctly.
This article introduces JavaScript decorators, explains their relation to the decorator design pattern, shows how to configure Babel for decorator support, demonstrates class and method decorator syntax with detailed code examples, and discusses practical usage scenarios and execution order in modern front‑end projects.
This article explains Java's Simple Factory design pattern, covering its definition, class structure, implementation steps with code examples, advantages and disadvantages, and suitable application scenarios, helping developers understand when and how to use this creational pattern effectively.
This article explains the Chain of Responsibility design pattern, showing how to refactor order processing in a Spring 5.2 Java 8 application by defining abstract handlers, implementing concrete handlers, configuring bean ordering, and extending the chain for new order types.
The article explains why excessive null‑checking in Java code is problematic, distinguishes between null as a valid response and null as an error, and offers practical techniques such as returning empty collections, using assertions, throwing exceptions, and applying the Null Object pattern to write cleaner, safer code.
This article explains the Chain of Responsibility design pattern, outlines its four roles, demonstrates a real‑world Java implementation for encrypted request handling, and shows how to build an extensible processing chain that improves code readability and maintainability.
This article explains the Builder design pattern, detailing its definition, roles, Java implementation with code examples, practical use cases, advantages and drawbacks, comparison with the Factory pattern, and a real‑world illustration using JDK’s StringBuilder, helping developers understand when and how to apply it.
This article explains the Chain of Responsibility design pattern, covering its concept, UML class diagram, Java code examples, advantages, disadvantages, typical application scenarios, extensions, and comparison with the Decorator pattern in software development.
This article explains the Chain of Responsibility design pattern by linking a historical story of Guan Yu’s five passes with an OA leave‑approval workflow, provides a clear definition, discusses its pros and cons, and presents comprehensive Java code examples illustrating abstract handlers, concrete handlers, and client usage.
This article explains the Template Method design pattern, illustrating its algorithm skeleton and step customization with Java code examples, and demonstrates real‑world applications in Spring, MyBatis, and other backend frameworks, highlighting advantages, drawbacks, and practical implementation details.
This article explains the Template Method design pattern, illustrating its structure with Java drink‑making examples, discussing hook methods, and showing real‑world usages in JDK’s Comparable and Spring’s ApplicationContext, while highlighting advantages, drawbacks, and practical scenarios.
This article explains the Chain of Responsibility design pattern, illustrates it with a company expense‑approval scenario, and provides complete Go code—including an interface, Staff, Manager, and CEO structs—showing how to build a flexible, extensible approval chain.
Chain of ResponsibilityDesign PatternExtensibility