BestHub
Sign in
Tagged articles

design patterns

880 articles · Page 8 of 9
JavaEdge
JavaEdge
Jul 10, 2020 · Fundamentals

Why Static Factory Methods Outshine Constructors in Java

This article explains how static factory methods improve readability, performance, and flexibility compared to public constructors, covering benefits such as named creation, instance reuse, subtype returns, service‑provider frameworks, as well as drawbacks like limited inheritance and discoverability, and offers naming conventions and real‑world Java examples.

API designJavaStatic Factory
0 likes · 10 min read
Why Static Factory Methods Outshine Constructors in Java
Alibaba Cloud Native
Alibaba Cloud Native
Jul 8, 2020 · Backend Development

Why COLA 3.0 Strips Away Complexity: An Ockham’s Razor‑Driven Refactor

This article examines the COLA application‑architecture framework, explains how the author applied Ockham’s razor to prune unnecessary concepts such as Command, Interceptor, and Convertor/Validator/Assembler, and shows concrete code before and after the simplification, culminating in a leaner, more maintainable backend design.

COLAJavaOckham's Razor
0 likes · 11 min read
Why COLA 3.0 Strips Away Complexity: An Ockham’s Razor‑Driven Refactor
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 2, 2020 · Fundamentals

Understanding Java Enums: Seven Practical Usage Patterns and Best Practices

This article introduces Java's enum type introduced in JDK 1.5, explains seven practical usage patterns—including constants, switch statements, adding methods, overriding methods, implementing interfaces, organizing enums in interfaces, and using EnumSet/EnumMap—while providing code examples, best‑practice guidelines, and comparisons with legacy int or String constants.

EnumJavabackend
0 likes · 14 min read
Understanding Java Enums: Seven Practical Usage Patterns and Best Practices
Programmer DD
Programmer DD
Jun 20, 2020 · Backend Development

Understanding Synchronous, Asynchronous Calls and Callbacks in Java

This article explains the differences between synchronous and asynchronous method calls, introduces callback mechanisms, and provides complete Java code examples for both sync and async callbacks, helping developers grasp how to design and implement these patterns in backend applications.

AsynchronousCallbackJava
0 likes · 14 min read
Understanding Synchronous, Asynchronous Calls and Callbacks in Java
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 10, 2020 · Fundamentals

Adapter Design Pattern: Concepts, Structure, Code Samples, and Spring MVC Application

This article explains the Adapter design pattern, illustrates its real‑world analogies, describes object and class adapter variants, provides complete Java code examples, demonstrates a voltage‑conversion demo, and shows how Spring MVC employs adapters to decouple controllers from request handling.

Adapter PatternClass AdapterJava
0 likes · 15 min read
Adapter Design Pattern: Concepts, Structure, Code Samples, and Spring MVC Application
Architects Research Society
Architects Research Society
Jun 4, 2020 · Fundamentals

Overview of Software Architecture Patterns and Styles

This article introduces software architecture patterns as reusable solutions to common design problems and catalogs various architecture styles—including layered, microservices, event‑driven, and distributed systems—providing a concise reference for architects and developers.

Microservicesarchitecture stylesdesign patterns
0 likes · 3 min read
Overview of Software Architecture Patterns and Styles
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 25, 2020 · Fundamentals

Understanding the Six SOLID Principles of Design Patterns

This article explains the six core SOLID principles—Single Responsibility, Interface Segregation, Dependency Inversion, Liskov Substitution, Law of Demeter, and Open/Closed—detailing their definitions, benefits, practical examples, and how they improve code reusability, readability, maintainability, and system extensibility.

SOLIDdesign patternsobject-oriented
0 likes · 8 min read
Understanding the Six SOLID Principles of Design Patterns
Top Architect
Top Architect
May 20, 2020 · Fundamentals

Eliminating Overused if…else Statements: Refactoring Techniques and Design Patterns

This article examines why excessive if…else statements harm code readability and maintainability, and presents a range of refactoring approaches—including table‑driven mapping, chain‑of‑responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism—to replace or simplify them, while also addressing deep nesting and complex conditional expressions.

code qualitydesign patternsif-else
0 likes · 19 min read
Eliminating Overused if…else Statements: Refactoring Techniques and Design Patterns
Selected Java Interview Questions
Selected Java Interview Questions
May 17, 2020 · Backend Development

Applying Strategy, Factory Method, and Builder Patterns in Spring for Reward Distribution

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.

BuilderFactory MethodJava
0 likes · 12 min read
Applying Strategy, Factory Method, and Builder Patterns in Spring for Reward Distribution
Architects Research Society
Architects Research Society
May 11, 2020 · Fundamentals

10 Common Software Architectural Patterns and Their Uses

This article introduces ten widely used software architectural patterns—including layered, client‑server, master‑slave, pipe‑filter, broker, peer‑to‑peer, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical applications, advantages, and disadvantages, and provides a comparative overview.

MVCclient-serverdesign patterns
0 likes · 8 min read
10 Common Software Architectural Patterns and Their Uses
High Availability Architecture
High Availability Architecture
May 11, 2020 · Backend Development

Understanding CQRS Complexity: Goals, Common Pitfalls, and Practical Solutions

This article examines the CQRS (Command Query Responsibility Segregation) pattern, outlining its objectives, three major complexity traps—over‑isolated commands, event sourcing coupling, and excessive tooling—and offers practical mitigation strategies, including relaxed isolation, alternative projection techniques, and careful service decomposition.

CQRSEvent SourcingMicroservices
0 likes · 10 min read
Understanding CQRS Complexity: Goals, Common Pitfalls, and Practical Solutions
Architect's Tech Stack
Architect's Tech Stack
May 9, 2020 · Backend Development

Unified Exception Handling and Assertion Techniques in Java Backend Development

This article explains how to replace repetitive try‑catch blocks in Java backend services with a unified exception handling framework using Spring's @ControllerAdvice, custom @ExceptionHandler methods, enum‑based error codes, and assertion utilities, improving code readability, maintainability, and error response consistency.

Springdesign patterns
0 likes · 21 min read
Unified Exception Handling and Assertion Techniques in Java Backend Development
Architecture Digest
Architecture Digest
May 7, 2020 · Fundamentals

Eliminating Excessive if…else: Patterns and Refactoring Techniques

This article examines the problems caused by overusing if…else statements in code—such as poor readability, maintainability, and violation of design principles—and presents a collection of refactoring patterns, including table‑driven design, chain of responsibility, annotation‑driven, event‑driven, state machines, Optional, guard clauses, and polymorphism, with concrete Java examples.

code qualitydesign patternsif-else
0 likes · 19 min read
Eliminating Excessive if…else: Patterns and Refactoring Techniques
Java Backend Technology
Java Backend Technology
May 7, 2020 · Backend Development

Eliminate Excessive Null Checks: Cleaner Java Code Without try‑catch

This article explains why overusing null‑check statements and try‑catch blocks makes Java code messy, distinguishes valid and invalid null returns, and offers practical techniques such as assertions, exceptions, empty collections, and the Null Object pattern to write safer, more concise code.

JavaNull Objectbest practices
0 likes · 6 min read
Eliminate Excessive Null Checks: Cleaner Java Code Without try‑catch
dbaplus Community
dbaplus Community
May 4, 2020 · Fundamentals

Why Design Patterns May Harm Your Projects More Than Help

The article argues that, despite the popularity of design patterns, blindly applying the 23 classic patterns rarely improves software quality and often leads to over‑engineered or fragile code, urging developers to critically assess their context, language features, and multi‑paradigm alternatives before using them.

Object-Oriented Programmingcode maintainabilitydesign patterns
0 likes · 16 min read
Why Design Patterns May Harm Your Projects More Than Help
Top Architect
Top Architect
Apr 29, 2020 · Fundamentals

Eliminating Excessive if...else Statements: Problems, Solutions, and Refactoring Techniques

The article examines the drawbacks of overusing if...else constructs in software, explains why they harm readability and maintainability, and presents ten practical refactoring methods—including table‑driven, chain‑of‑responsibility, annotation‑driven, event‑driven, state machine, Optional, Assert, guard clauses, and method extraction—to simplify or replace complex conditional logic.

code qualitydesign patternsif-else
0 likes · 16 min read
Eliminating Excessive if...else Statements: Problems, Solutions, and Refactoring Techniques
Bitu Technology
Bitu Technology
Apr 27, 2020 · Fundamentals

Recap of the 2020 Online Scala Meetup: Design Patterns, ZIO STM, Scala‑Java Integration, and Shapeless

On April 18, the inaugural 2020 Online Scala Meetup organized by Tubi featured four speakers who explored Scala design patterns, demonstrated ZIO STM usage, shared best practices for integrating Scala into Java codebases, and introduced Shapeless’s type-level programming, offering valuable insights for developers.

Functional ProgrammingScalaShapeless
0 likes · 6 min read
Recap of the 2020 Online Scala Meetup: Design Patterns, ZIO STM, Scala‑Java Integration, and Shapeless
vivo Internet Technology
vivo Internet Technology
Apr 22, 2020 · Fundamentals

Understanding ReactiveX and RxJava: Core Concepts, Design Patterns, and Observable Mechanics

RxJava implements ReactiveX’s observer‑based, pull‑model paradigm by using Observable as a factory and template class whose static creators and chainable operators (e.g., flatMap) apply factory, template, observer and decorator patterns, enabling Java 8‑style asynchronous pipelines that developers can reason about, debug, and optimize.

JavaReactive ProgrammingRxJava
0 likes · 9 min read
Understanding ReactiveX and RxJava: Core Concepts, Design Patterns, and Observable Mechanics
Top Architect
Top Architect
Apr 21, 2020 · Mobile Development

Designing a Cross‑Platform Architecture for WeChat Pay: From Problems to Solutions

The article analyzes the inconsistencies and maintenance challenges of separate iOS and Android implementations of WeChat Pay, then presents a C++‑based cross‑platform framework with UseCase‑driven business flow, routing, unified network handling and strict data passing, showing how these changes cut code size, keep crash rates stable and dramatically improve development productivity.

C++Mobile DevelopmentRouting
0 likes · 14 min read
Designing a Cross‑Platform Architecture for WeChat Pay: From Problems to Solutions
21CTO
21CTO
Apr 17, 2020 · Fundamentals

10 Proven Techniques to Eliminate Excessive if…else in Your Code

This article explains why overusing if…else harms code readability and maintainability, outlines ten practical methods—including table‑driven, chain of responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism—to refactor or replace complex conditional logic, and provides Java code examples for each approach.

code qualitydesign patternsif-else
0 likes · 16 min read
10 Proven Techniques to Eliminate Excessive if…else in Your Code
dbaplus Community
dbaplus Community
Apr 16, 2020 · Fundamentals

Why Code Quality Fails Projects and 4 Proven Ways to Fix It

The article examines why many software projects deteriorate due to poor code quality, outlines four common pitfalls such as oversized components, low cohesion, tangled logic, and rampant if‑else statements, and presents concrete refactoring strategies—including inverted‑pyramid design, lib/framework separation, Template Method pattern, and rich enums—to dramatically improve maintainability and project success.

code qualitydesign patternsmaintainability
0 likes · 37 min read
Why Code Quality Fails Projects and 4 Proven Ways to Fix It
macrozheng
macrozheng
Apr 14, 2020 · Fundamentals

Why Code Quality Matters: 4 Common Pitfalls and Proven Solutions for Developers

This article examines why high‑quality, maintainable code is essential for software projects, outlines four recurring code‑quality problems—including oversized components, low cohesion, tangled logic, and excessive if‑else—and presents concrete refactoring patterns such as inverted‑pyramid design, proper lib/framework reuse, Template Method separation, and rich enum types, while also introducing a CODEX indexing technique for large codebases.

best practicescode qualitydesign patterns
0 likes · 38 min read
Why Code Quality Matters: 4 Common Pitfalls and Proven Solutions for Developers
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 1, 2020 · Fundamentals

How to Rapidly Boost Your Software Design Skills: Practical Steps for Developers

This article shares practical advice on improving a programmer's design ability, covering coding practice, theory study, hands‑on implementation, revisiting concepts, summarizing lessons, sharing knowledge, and additional tips such as designing before coding and avoiding blind reliance on patterns.

Programming Fundamentalscoding practicedesign patterns
0 likes · 9 min read
How to Rapidly Boost Your Software Design Skills: Practical Steps for Developers
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 23, 2020 · Fundamentals

Mastering Software Architecture Patterns: From Layered to Cloud‑Native

This article explains the classic definition of patterns, introduces architecture patterns, and reviews five common software architecture styles—layered, microservices, microkernel, event‑driven, and cloud‑native—detailing their principles, advantages, drawbacks, and typical use cases, helping developers choose the right structure for complex systems.

Cloud NativeMicroservicesdesign patterns
0 likes · 14 min read
Mastering Software Architecture Patterns: From Layered to Cloud‑Native
Meituan Technology Team
Meituan Technology Team
Mar 19, 2020 · Backend Development

Applying Design Patterns and Domain‑Driven Design in Meituan Takeaway Marketing System

The Meituan Takeaway Marketing team shows how combining domain‑driven design with classic patterns such as Factory Method, Strategy, State and Responsibility Chain creates an extensible, maintainable reward system that adapts to rapidly changing business rules while keeping the domain model clean and SOLID‑compliant.

Domain-Driven DesignFactory MethodJava
0 likes · 25 min read
Applying Design Patterns and Domain‑Driven Design in Meituan Takeaway Marketing System
Suning Design
Suning Design
Mar 9, 2020 · Product Management

Master Onboarding: 7 Design Principles & 6 Patterns to Boost User Retention

This article explains what onboarding (new‑user guidance) is, why it matters for reducing friction, outlines seven core design principles, presents six reusable design patterns, and shows how advanced applications like Taobao’s Gold Coin feature apply these concepts to improve retention.

design patternsdesign principlesonboarding
0 likes · 12 min read
Master Onboarding: 7 Design Principles & 6 Patterns to Boost User Retention
Java Captain
Java Captain
Mar 1, 2020 · Backend Development

Summary of Design Patterns Used in the Spring Framework

This article explains how the Spring framework implements various classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation mechanisms, underlying principles, and practical significance within Spring's bean lifecycle and extension points.

AOPBeanFactoryDependency Injection
0 likes · 14 min read
Summary of Design Patterns Used in the Spring Framework
21CTO
21CTO
Feb 6, 2020 · Fundamentals

Mastering the Role of a Software Architect: Skills, Levels, and Daily Practices

This article explores what a software architect does, defines the role, outlines three architectural levels, details daily responsibilities, and breaks down ten essential skills—including design, decision‑making, simplification, programming, and documentation—to help engineers become better architects.

System Designarchitect skillsdesign patterns
0 likes · 14 min read
Mastering the Role of a Software Architect: Skills, Levels, and Daily Practices
Architecture Digest
Architecture Digest
Feb 6, 2020 · Backend Development

Refactoring a 3000‑Line C# System to 15 Lines: Lessons and Practices

An experienced developer recounts how he transformed a cumbersome three‑tier C# data‑center management system from thousands of lines to a concise, maintainable codebase using reflection, generics, and thoughtful refactoring, while sharing practical advice on avoiding code generators, reducing duplication, and embracing unit testing.

Backend DevelopmentC#Unit Testing
0 likes · 18 min read
Refactoring a 3000‑Line C# System to 15 Lines: Lessons and Practices
Programmer DD
Programmer DD
Jan 11, 2020 · Fundamentals

Mastering the Strategy Pattern: When and How to Use It in Java

This article explains the Strategy design pattern, its definition, roles, UML diagram, Java code examples, real‑world applications such as payment integration and compression, and provides guidance on when to use it, its advantages, drawbacks, and how to simplify it with Java 8 lambdas.

JavaLambdaStrategy Pattern
0 likes · 16 min read
Mastering the Strategy Pattern: When and How to Use It in Java
Programmer DD
Programmer DD
Jan 10, 2020 · Backend Development

How MyBatis Leverages 9 Classic Design Patterns

This article explores how MyBatis implements nine fundamental design patterns—Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations, diagrams, and code snippets to deepen developers' understanding of practical pattern usage.

Backend DevelopmentJavaMyBatis
0 likes · 23 min read
How MyBatis Leverages 9 Classic Design Patterns
Java Captain
Java Captain
Dec 25, 2019 · Backend Development

Handling Null Values and Optional in Java: Best Practices and Design Patterns

This article discusses common null‑value pitfalls in Java services, explains why returning null collections is dangerous, and presents robust solutions such as returning empty lists, using Optional, applying JSR‑303/JSR‑305 annotations, and employing the Null Object pattern to improve code safety and readability.

JSR-303JSR-305Java
0 likes · 13 min read
Handling Null Values and Optional in Java: Best Practices and Design Patterns
58 Tech
58 Tech
Dec 13, 2019 · Mobile Development

Refactoring the IM Module: Layered Architecture, Parallel Development and Business‑Line Splitting

This article describes the redesign of a large‑scale Android instant‑messaging (IM) module, detailing the shortcomings of the original architecture, the new three‑layer framework, the split‑converter for parallel business‑line development, component‑based UI design, and the design‑pattern techniques used to achieve a maintainable, extensible solution.

AndroidComponentizationIM
0 likes · 16 min read
Refactoring the IM Module: Layered Architecture, Parallel Development and Business‑Line Splitting
Architect's Tech Stack
Architect's Tech Stack
Dec 13, 2019 · Backend Development

Comprehensive Java Interview Guide and Preparation Checklist

This article provides a detailed Java interview preparation guide, covering personal experience, overall interview process, essential knowledge areas such as core Java, data structures, algorithms, JVM, multithreading, databases, networking, design patterns, distributed systems, caching, frameworks, emerging technologies, and practical tips for success.

JVMdesign patternsinterview
0 likes · 9 min read
Comprehensive Java Interview Guide and Preparation Checklist
Architecture Digest
Architecture Digest
Nov 1, 2019 · Fundamentals

Reflections on Transaction System Design: Principles, Patterns, and Evolution

This article reflects on the redesign of a large‑scale transaction system, describing a decision‑making routine that starts from purpose and goals, discusses programming paradigms, SOLID principles, domain‑driven design, bounded contexts, component splitting, layering, and the trade‑offs of patterns such as State and CQRS to achieve a flexible, maintainable backend architecture.

Domain-Driven DesignSOLIDSystem Design
0 likes · 21 min read
Reflections on Transaction System Design: Principles, Patterns, and Evolution
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 30, 2019 · Backend Development

Eliminating Complex if‑else Logic with Strategy and Factory Patterns in a Spring‑Based Java Application

This article explains how excessive if‑else statements in business code hurt readability and maintainability, and demonstrates how to replace them with the Strategy and Factory design patterns integrated with Spring, using a food‑delivery discount example and complete Java code snippets.

Factory PatternJavaSpring
0 likes · 12 min read
Eliminating Complex if‑else Logic with Strategy and Factory Patterns in a Spring‑Based Java Application
21CTO
21CTO
Oct 9, 2019 · Fundamentals

Mastering OOP in C: Implement the State Pattern with Real Code

This article walks you through applying object‑oriented concepts in C by implementing the State design pattern, covering class simulation with structs, inheritance via macros, lifecycle management, polymorphism, and a complete client example that demonstrates state transitions for a water model.

C#Memory ManagementObject-Oriented Programming
0 likes · 13 min read
Mastering OOP in C: Implement the State Pattern with Real Code
Python Programming Learning Circle
Python Programming Learning Circle
Sep 25, 2019 · Fundamentals

Why My Student Project’s Code Is a Nightmare—and How to Fix It

A graduate student recounts the chaotic state of his research team's C# data‑mining project, highlighting poor naming conventions, oversized classes, overuse of singletons, redundant code, lack of proper inheritance, and other anti‑patterns, while offering concrete suggestions such as using meaningful identifiers, applying the single‑responsibility principle, leveraging LINQ, and adopting MVVM for cleaner, more maintainable code.

C#best practicescode quality
0 likes · 8 min read
Why My Student Project’s Code Is a Nightmare—and How to Fix It
Programmer DD
Programmer DD
Sep 23, 2019 · Fundamentals

Mastering SOLID: Real‑World Java Examples for Clean Code

This article explains the nine essential SOLID design principles—why design patterns matter, and how the Open/Closed, Dependency Inversion, Single Responsibility, Law of Demeter, Interface Segregation, Liskov Substitution, and Composition principles can be applied in Java with clear code examples.

JavaOOP principlesSOLID
0 likes · 10 min read
Mastering SOLID: Real‑World Java Examples for Clean Code
Architect's Tech Stack
Architect's Tech Stack
Sep 20, 2019 · Backend Development

Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, Iterator

This article examines how MyBatis applies classic design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by analysing source code snippets and explaining each pattern's role in the framework's configuration, execution, caching, and dynamic SQL generation.

Backend DevelopmentMyBatisdesign patterns
0 likes · 18 min read
Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, Iterator
360 Tech Engineering
360 Tech Engineering
Sep 17, 2019 · Mobile Development

Design and Implementation of a Modular Mobile Application Framework

This article describes the background, design principles, layered architecture, and implementation details of a modular mobile framework that separates business, functional, UI, and support layers to enable rapid app development, easy extension, and reduced coupling.

AndroidLayered Designdesign patterns
0 likes · 9 min read
Design and Implementation of a Modular Mobile Application Framework
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 14, 2019 · Fundamentals

Unlocking Software Design Patterns: Complete Series Outline & Roadmap

This announcement outlines a new series on software design patterns, detailing its origin, purpose, structured article format, and a comprehensive roadmap covering object‑oriented fundamentals, design principles, and individual patterns such as Singleton, Factory, Adapter, and many more, with Java examples.

Javadesign patternssoftware architecture
0 likes · 5 min read
Unlocking Software Design Patterns: Complete Series Outline & Roadmap
Big Data Technology & Architecture
Big Data Technology & Architecture
Sep 13, 2019 · Backend Development

Comprehensive Java Interview Topics: Language Basics, Collections, Concurrency, JVM, Design Patterns, MySQL, and Netty

This article compiles essential Java interview questions covering language fundamentals, core APIs, collections, concurrency mechanisms, JVM internals, design patterns, database concepts, and Netty networking, providing a thorough reference for candidates preparing for backend development positions.

Backend DevelopmentJVMJava
0 likes · 12 min read
Comprehensive Java Interview Topics: Language Basics, Collections, Concurrency, JVM, Design Patterns, MySQL, and Netty
Qunar Tech Salon
Qunar Tech Salon
Aug 8, 2019 · Frontend Development

Understanding Design Patterns in JavaScript

This article explains why and how to use various JavaScript design patterns—such as module, revealing module, ES6 modules, singleton, factory, and decorator—by describing their purpose, benefits, and providing clear code examples while warning against over‑use.

DecoratorFactoryJavaScript
0 likes · 14 min read
Understanding Design Patterns in JavaScript
Programmer DD
Programmer DD
Jul 24, 2019 · Backend Development

Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master

This comprehensive guide explores the fundamentals of the Spring framework—including its core modules, dependency injection, IoC, bean scopes, configuration styles, annotation-driven setup, event handling, and common design patterns—providing Java developers with practical examples and code snippets to master Spring's capabilities.

Bean LifecycleConfigurationDependency Injection
0 likes · 25 min read
Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master
Java Captain
Java Captain
May 29, 2019 · Backend Development

Common Design Patterns Used in the Spring Framework

This article reviews the most frequently applied design patterns in Spring—including IoC/DI, Factory, Singleton, Proxy (AOP), Template Method, Observer, Adapter, and Decorator—explaining their purpose, how Spring implements them, and providing concise code examples for each.

AOPDependency InjectionFactory
0 likes · 17 min read
Common Design Patterns Used in the Spring Framework
Programmer DD
Programmer DD
May 28, 2019 · Backend Development

Mastering the Strategy Pattern in Spring: Real-World Java Examples

This article explains how to apply the Strategy pattern within a Spring project, covering background, learning objectives, step‑by‑step code examples for query services A, B, and C, the three‑part invocation process, and both list‑based and map‑based configurations.

Backend DevelopmentJavaSpring
0 likes · 3 min read
Mastering the Strategy Pattern in Spring: Real-World Java Examples
Architecture Digest
Architecture Digest
May 8, 2019 · Fundamentals

10 Common Software Architectural Patterns and Their Applications

This article introduces ten widely used software architectural patterns, explains their structure and key characteristics, and lists typical application scenarios for each, helping developers choose appropriate architectures for large‑scale enterprise systems.

MVCblackboardclient-server
0 likes · 9 min read
10 Common Software Architectural Patterns and Their Applications
Node Underground
Node Underground
Apr 25, 2019 · Frontend Development

How Inversion of Control Boosts Front‑End Development Efficiency

This article explains the Inversion of Control (IoC) pattern and its Dependency Injection implementation, showing how a simple container can decouple modules, improve modularity, speed up development, and make unit testing easier for front‑end JavaScript/TypeScript projects.

Dependency InjectionInversion of ControlUnit Testing
0 likes · 11 min read
How Inversion of Control Boosts Front‑End Development Efficiency
Senior Brother's Insights
Senior Brother's Insights
Apr 15, 2019 · Backend Development

How MyBatis Implements 9 Classic Design Patterns – A Deep Dive

This article explores how MyBatis applies nine fundamental design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations and concrete code snippets to deepen developers' understanding of real‑world pattern usage.

Backend DevelopmentBuilderFactory
0 likes · 19 min read
How MyBatis Implements 9 Classic Design Patterns – A Deep Dive
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 1, 2019 · Fundamentals

Must-Read Technical Books Recommended by Alibaba Experts

Alibaba’s senior engineers share their curated list of essential technical books—from software testing and design patterns to AI, machine learning, reinforcement learning, Rust programming, and database architecture—explaining why each title is valuable for developers seeking deeper knowledge and practical insights.

AIdatabase systemsdesign patterns
0 likes · 9 min read
Must-Read Technical Books Recommended by Alibaba Experts
21CTO
21CTO
Mar 21, 2019 · Fundamentals

Why Spending 80% of Your Time on Fundamentals Beats Chasing New Frameworks

The article argues that programmers should devote the majority of their limited time to mastering transferable fundamentals and design principles rather than constantly chasing the latest frameworks, using the Lindy effect and personal experience to illustrate this sustainable learning strategy.

FundamentalsLindy effectdesign patterns
0 likes · 8 min read
Why Spending 80% of Your Time on Fundamentals Beats Chasing New Frameworks
Java Captain
Java Captain
Feb 26, 2019 · Backend Development

How to Write Better Java Code: Refactoring, DTO Conversion, Lombok, and Design Practices

This article discusses practical Java programming techniques, including proper DTO conversion, use of BeanUtils, Lombok annotations, builder patterns, static constructors, validation with JSR‑303, and design considerations such as refactoring, strategy versus state patterns, to help developers write cleaner, more maintainable backend code.

DTOJavaLombok
0 likes · 27 min read
How to Write Better Java Code: Refactoring, DTO Conversion, Lombok, and Design Practices
Java Captain
Java Captain
Feb 20, 2019 · Backend Development

Java Interview Preparation Roadmap: JVM, Algorithms, Concurrency, Databases, Frameworks, Distributed Systems, and Design Patterns

This article outlines a comprehensive Java interview study plan, covering JVM fundamentals, sorting algorithms and collections, multithreading, key storage technologies like Redis, MySQL, and Elasticsearch, Spring framework deep dive, Dubbo-based distributed architecture, and essential design patterns to master for backend development roles.

Backend DevelopmentJVMJava
0 likes · 11 min read
Java Interview Preparation Roadmap: JVM, Algorithms, Concurrency, Databases, Frameworks, Distributed Systems, and Design Patterns
Java Backend Technology
Java Backend Technology
Feb 17, 2019 · Backend Development

9 Essential Spring Design Patterns Every Java Developer Should Master

This article explores nine commonly used Spring design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Wrapper, Proxy, Observer, Strategy, and Template Method—explaining their concepts, showing XML or Java code examples, and illustrating how Spring implements each pattern in real applications.

Backend DevelopmentDependency InjectionJava
0 likes · 9 min read
9 Essential Spring Design Patterns Every Java Developer Should Master
Java Captain
Java Captain
Feb 10, 2019 · Backend Development

Common Spring Design Patterns: Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method

This article explains how Spring implements nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—through configuration examples and Java code, illustrating their roles in building flexible, maintainable backend applications.

AdapterBackend DevelopmentFactory Method
0 likes · 9 min read
Common Spring Design Patterns: Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method
360 Tech Engineering
360 Tech Engineering
Jan 22, 2019 · Backend Development

Microservice Architecture Design Patterns: Decomposition and Integration Patterns (Part 1)

This article introduces microservice architecture design patterns, covering core architectural principles, decomposition approaches such as business‑capability, sub‑domain, and strangler patterns, and integration solutions like API‑gateway, aggregator, and client‑side UI composition, while highlighting common challenges and their remedies.

API Gatewaybackend-architecturedecomposition
0 likes · 7 min read
Microservice Architecture Design Patterns: Decomposition and Integration Patterns (Part 1)
360 Tech Engineering
360 Tech Engineering
Jan 17, 2019 · Backend Development

Microservice Architecture Design Patterns – Decomposition and Integration Patterns (Part 1)

This article introduces key microservice design patterns, covering decomposition approaches such as business‑capability and sub‑domain splits, the Strangler pattern, and integration solutions like API‑gateway, aggregator, and client‑UI composition, while outlining core microservice principles and challenges.

API Gatewaybackend-architecturedecomposition
0 likes · 8 min read
Microservice Architecture Design Patterns – Decomposition and Integration Patterns (Part 1)
Architect's Tech Stack
Architect's Tech Stack
Jan 17, 2019 · Backend Development

Comprehensive Java Interview Questions and Topics

This article compiles an extensive list of Java interview questions covering fundamentals, concurrency, collections, JVM internals, I/O, design patterns, testing, and best practices, providing candidates with a comprehensive study guide for modern backend development roles.

JVMJavabackend
0 likes · 12 min read
Comprehensive Java Interview Questions and Topics
Senior Brother's Insights
Senior Brother's Insights
Jan 2, 2019 · Backend Development

9 Essential Spring Design Patterns Explained with Code Samples

This article walks through nine commonly used design patterns in Spring, such as Simple Factory, Factory Method, Singleton, Adapter, Wrapper, Proxy, Observer, Strategy, and Template Method, providing clear explanations, XML configurations, and Java code examples to illustrate each pattern in practice.

AdapterFactoryJava
0 likes · 9 min read
9 Essential Spring Design Patterns Explained with Code Samples
21CTO
21CTO
Dec 22, 2018 · Fundamentals

Why Spending 80% of Your Time on Fundamentals Beats Chasing Every New Framework

The article argues that developers should devote the majority of their learning time to timeless fundamentals—design patterns, clean code, and architecture—rather than constantly chasing the latest frameworks and tools, using personal anecdotes and a mentor dialogue to illustrate the point.

Continuous DeliveryFundamentalsdesign patterns
0 likes · 8 min read
Why Spending 80% of Your Time on Fundamentals Beats Chasing Every New Framework
Programmer DD
Programmer DD
Dec 11, 2018 · Backend Development

Top 20 Java Interview Questions for Investment Banking (Answers Included)

This article compiles 20 common Java interview questions asked by investment banks, covering topics such as multithreaded HashMap usage, hashCode/equals contracts, String substring memory issues, singleton patterns, design patterns, deadlock avoidance, and performance considerations, each accompanied by concise answers and code examples.

CollectionsJavabackend
0 likes · 18 min read
Top 20 Java Interview Questions for Investment Banking (Answers Included)
Programmer DD
Programmer DD
Nov 24, 2018 · Fundamentals

Why OOP Still Rules: Composition, SOLID, and Refactoring Insights

The author reflects on a recent project refactor, emphasizing why object‑oriented programming remains dominant, exploring concepts like control inversion, dependency injection, SOLID principles, composition over inheritance, design patterns, layered architecture, and the balanced relationship between OOP and functional programming.

OOPSOLIDdesign patterns
0 likes · 7 min read
Why OOP Still Rules: Composition, SOLID, and Refactoring Insights
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Nov 6, 2018 · Backend Development

Mastering Microservice Design Patterns: Decomposition & Integration Strategies

This article introduces microservice architecture design patterns, covering decomposition and integration patterns, their associated challenges, and practical solutions such as business‑capability decomposition, domain‑driven design, API‑gateway and aggregator patterns, helping developers tackle scalability, resilience, and maintainability in modern backend systems.

Microservicesbackend-architecturedecomposition
0 likes · 9 min read
Mastering Microservice Design Patterns: Decomposition & Integration Strategies
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 29, 2018 · Frontend Development

How to Use React Context API to Build Flexible, Reusable Components

This tutorial demonstrates how to replace fragile prop‑drilling in a multi‑step React component by leveraging the React Context API, showing step‑by‑step creation of a context, provider, and consumer, refactoring the Stepper component for greater flexibility and reusability across the UI.

Component ReusabilityContext APIReAct
0 likes · 9 min read
How to Use React Context API to Build Flexible, Reusable Components
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 28, 2018 · Frontend Development

Master Flexible React Components with Compound Component Patterns

This article demonstrates how to transform a basic Stepper component into a highly reusable and configurable React component using the compound component pattern, static properties, and React's Children utilities, while addressing common customization challenges and preparing for context API integration.

Compound ComponentsContext APIReAct
0 likes · 11 min read
Master Flexible React Components with Compound Component Patterns
Java Captain
Java Captain
Aug 28, 2018 · Databases

Design and Implementation of a Mini Database Connection Pool

This article explains the concept, design considerations, and step‑by‑step implementation of a lightweight database connection pool in Java, covering its core components, thread‑safe management, configuration handling, and a test demonstration of its functionality.

Connection PoolJavadatabase
0 likes · 5 min read
Design and Implementation of a Mini Database Connection Pool
21CTO
21CTO
Aug 20, 2018 · Fundamentals

Microservices vs SOA: What’s the Real Difference and When to Use Each?

This article clarifies the core distinctions between Service‑Oriented Architecture (SOA) and microservices, covering their origins, communication models, bounded contexts, scalability, and suitable use‑cases, helping developers decide which architectural style best fits their application’s size, complexity, and deployment needs.

SOAdesign patternssoftware architecture
0 likes · 9 min read
Microservices vs SOA: What’s the Real Difference and When to Use Each?
Senior Brother's Insights
Senior Brother's Insights
Aug 19, 2018 · Backend Development

Spring’s 9 Core Design Patterns Explained with Code Examples

This article walks through nine common design patterns used in the Spring framework—Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—showing their concepts, Spring-specific implementations, and practical code snippets.

Dependency InjectionJavaSpring
0 likes · 9 min read
Spring’s 9 Core Design Patterns Explained with Code Examples
转转QA
转转QA
Aug 15, 2018 · Backend Development

Designing a Dynamic‑Proxy‑Based Interface Testing Framework for Transaction Order and Payment Systems

The article explains how to design a maintainable interface testing framework using Java dynamic proxies, illustrating the approach with a transaction order system and a payment account system, and discusses its advantages, drawbacks, and practical application in a backend testing environment.

Backend testingdesign patternsinterface testing
0 likes · 9 min read
Designing a Dynamic‑Proxy‑Based Interface Testing Framework for Transaction Order and Payment Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 9, 2018 · Backend Development

Essential Backend Architecture Knowledge Map for High‑Concurrency Systems

This article presents a curated knowledge map covering backend architecture, Java best practices, microservice design, distributed consistency, high‑traffic handling, Alibaba frameworks, and design patterns, offering internet high‑concurrency architects a comprehensive reference of essential concepts and skills.

High concurrencyJavaMicroservices
0 likes · 2 min read
Essential Backend Architecture Knowledge Map for High‑Concurrency Systems
Big Data and Microservices
Big Data and Microservices
Jul 30, 2018 · Backend Development

Six Essential Microservice Design Patterns and When to Apply Them

This article outlines six fundamental microservice design patterns—Aggregator, Proxy, Chain, Branch, Data‑Sharing, and Asynchronous Messaging—explaining their structures, use‑cases, scalability characteristics, and potential pitfalls to help architects choose the right approach for their systems.

Microservicesasynchronous messagingbackend-architecture
0 likes · 5 min read
Six Essential Microservice Design Patterns and When to Apply Them
Java Backend Technology
Java Backend Technology
Jul 27, 2018 · Backend Development

From Junior to Java Architect: Key Lessons on High‑Concurrency System Design

The article shares a developer's journey toward becoming a Java architect, highlighting common pitfalls such as over‑focusing on code, getting lost in component details, and neglecting reusability, while offering practical advice on mastering high‑concurrency architectures, component integration, and design patterns.

Backend DevelopmentJavadesign patterns
0 likes · 11 min read
From Junior to Java Architect: Key Lessons on High‑Concurrency System Design