1 views collected around this technical thread.
This article introduces five essential design patterns—Observer, Strategy, Builder, Facade, and Adapter—explaining their concepts, typical roles, UML diagrams, and providing complete Java code demos that illustrate how each pattern can be applied to improve software design and maintainability.
This article explains why Lombok's @Builder annotation ignores field default values in Java classes, demonstrates the issue with sample code, and shows how using @Builder.Default resolves the problem by generating static default methods in the compiled builder class.
This article introduces seven core design patterns—Singleton, Factory, Builder, Strategy, Observer, Proxy, and Template—explaining their purpose, typical use cases, and providing complete Java code examples that integrate with Spring Boot 3 and Java 21, helping developers write cleaner, more maintainable software.
This article explains why combining Lombok's @Data and @Builder annotations can remove the automatically generated no‑args constructor, demonstrates the resulting compilation errors, and provides two practical solutions using @Tolerate or a combination of @RequiredArgsConstructor and @NoArgsConstructor, while also describing Lombok's annotation‑processing mechanism.
The article explains the pitfalls of Lombok's @Builder annotation—such as loss of required‑parameter enforcement, mutable builders, and limited flexibility—and demonstrates how using @Accessors (or manually crafted fluent setters) provides a safer, more expressive way to construct Java objects.
The article explains the pitfalls of Lombok’s @Builder annotation—such as loss of default values, mutable builders, and limited applicability—and demonstrates how using @Accessors with chainable setters provides a safer, more flexible alternative for Java backend development.
This article introduces JavaScript design patterns—covering creational, structural, and behavioral categories—and provides clear explanations and complete code examples for patterns such as Factory Method, Abstract Factory, Singleton, Builder, Prototype, Adapter, Decorator, Proxy, Facade, Bridge, Composite, Flyweight, Strategy, Template Method, Observer, Iterator, Chain of Responsibility, Command, Memento, State, Visitor, Mediator and Interpreter, helping developers write cleaner, more maintainable code.
This article lists and briefly describes fifteen widely used design patterns in Python, including Singleton, Factory, Abstract Factory, Builder, Prototype, Adapter, Decorator, Proxy, Observer, Strategy, Template Method, Iterator, Chain of Responsibility, Command, and State patterns.
This article explains nine widely used design patterns—Singleton, Builder, Factory, Strategy, Template Method, Chain of Responsibility, Proxy, Adapter, and Observer—detailing their concepts, typical use‑cases, and concrete Java code examples drawn from popular open‑source projects such as Spring, Dubbo, MyBatis and Guava.
This article explains how Lombok annotations such as @Data, @Builder, @Wither, and @Accessors can simplify Java bean creation for ORM entities, builder pattern utilities, wither-style object modification, and fluent accessor methods, while addressing common pitfalls like missing constructors and default values.
This article explains how the Austin Java backend project applies several classic design patterns—including Chain of Responsibility, Template Method, Builder, Strategy, Producer‑Consumer, Singleton, and Proxy—detailing their benefits, drawbacks, and specific code locations for each pattern.
This article humorously explains 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—using everyday dating analogies to illustrate their intent and structure.
This article provides a comprehensive tutorial on Lombok's @Builder annotation, covering basic usage, generated code details, @Singular collection handling, @Builder.Default defaults, toBuilder feature, and global configuration, with numerous Java code examples and explanations.
This article introduces several classic design patterns—Singleton, Factory, Builder, Prototype, Decorator, Strategy, Template Method, and Observer—showing how they can be implemented concisely in Kotlin with code examples, while also explaining the underlying language features such as object declarations, companion objects, delegation, lazy initialization, and higher‑order functions.
This article presents a playful yet informative walkthrough of twenty‑three classic software design patterns—Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method and Visitor—using everyday analogies to illustrate their intent and structure.
This article humorously explains 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—by comparing each pattern to everyday dating scenarios.
This article explains how to implement the Strategy, Factory Method, and Builder design patterns within a Spring application to decouple reward‑distribution logic, showing interface definitions, concrete implementations, a factory for dynamic bean selection, and a prototype‑scoped builder for request construction.
This article examines how MyBatis implements numerous classic design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—through its source code, explaining each pattern's role, related classes, and code examples to deepen developers' understanding of backend architecture.
The article examines Java performance optimization by profiling constructor initialization, individual setter calls, and Lombok's builder pattern, showing that direct constructor usage consistently outperforms setters and builders, and provides practical coding tips for faster Java applications.
This article introduces the three major categories of design patterns, explains the six SOLID principles, and provides detailed Java code examples for creational patterns such as Factory Method, Abstract Factory, Singleton, Builder, and Prototype, illustrating their structure and usage.