Skip to content
Tagged articles

Design Patterns

500 articles · Page 4 of 5
Architecture Digest
Architecture Digest
Aug 12, 2024 · Fundamentals

Replacing If‑Else: Cleaner Code Strategies and Refactoring Techniques

This article explains why traditional if‑else statements often lead to complex, hard‑to‑maintain code and demonstrates several techniques—such as removing unnecessary else blocks, using fast returns, guard clauses, dictionary‑based dispatch, and the strategy pattern—to replace if‑else with cleaner, more extensible designs.

Design PatternsStrategy Patternguard clauses
0 likes · 6 min read
Replacing If‑Else: Cleaner Code Strategies and Refactoring Techniques
php Courses
php Courses
Aug 9, 2024 · Backend Development

Applying the Strategy Design Pattern with the Open/Closed Principle in Laravel

This article explains how to apply the Strategy design pattern together with the Open‑Closed Principle in Laravel, showing step‑by‑step code examples for defining a strategy interface, implementing concrete payment strategies, and creating a context class that dynamically selects the appropriate payment gateway while keeping the system extensible and maintainable.

Design PatternsLaravelOpen/Closed Principle
0 likes · 12 min read
Applying the Strategy Design Pattern with the Open/Closed Principle in Laravel
Java Architecture Stack
Java Architecture Stack
Aug 9, 2024 · Fundamentals

Unlocking Guava: How 7 Design Patterns Power Its Core

This article dissects the Guava library to reveal how seven classic design patterns—Builder, Proxy, Immutable, Singleton, Decorator, Adapter, and Observer—are implemented in its core classes, providing clear code examples, step‑by‑step construction processes, and practical insights for Java developers.

Builder PatternDesign PatternsGuava
0 likes · 27 min read
Unlocking Guava: How 7 Design Patterns Power Its Core
Go Programming World
Go Programming World
Aug 4, 2024 · Fundamentals

Applying the Adapter Pattern in Go: From Payment Systems to Multi‑Cloud Management and Model Training Platforms

This article explains the Adapter design pattern, illustrates its real‑world analogy, demonstrates a complete Go implementation for payment processing, and shows how the pattern can be used in production scenarios such as a multi‑cloud management platform and a model‑training service, highlighting its role in unifying incompatible interfaces.

Adapter PatternCloud NativeDesign Patterns
0 likes · 13 min read
Applying the Adapter Pattern in Go: From Payment Systems to Multi‑Cloud Management and Model Training Platforms
IT Architects Alliance
IT Architects Alliance
Aug 2, 2024 · Fundamentals

Mastering Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template & Adapter in Java

This article provides a comprehensive, code‑first guide to the most common design patterns—including Strategy, Simple Factory, Singleton, Proxy, Factory Method, Observer, Template Method and Adapter—explaining their concepts, real‑world use cases, and complete Java implementations with Spring Boot integration.

AdapterDesign PatternsJava
0 likes · 21 min read
Mastering Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template & Adapter in Java
DaTaobao Tech
DaTaobao Tech
Jul 31, 2024 · Fundamentals

A Java-Based Scenario Execution Framework Using Design Patterns

The article presents a Java‑based scenario execution framework that leverages design patterns, annotations, enums and a generic factory to replace repetitive if/else branches with abstract scene interfaces and concrete implementations, enabling developers to add new business cases by simply creating a class and enum constant while the infrastructure automatically discovers and wires it, improving extensibility, readability and code quality.

Design PatternsFactory PatternJava
0 likes · 13 min read
A Java-Based Scenario Execution Framework Using Design Patterns
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jul 27, 2024 · Backend Development

Refactoring a Billing Service with a Responsibility‑Chain Architecture for Better Extensibility

The article explains why a complex billing module in a settlement system needs optimization, describes the problems of monolithic code and tangled responsibilities, and demonstrates a refactor using the responsibility‑chain pattern with clear, pluggable nodes, accompanied by Java code examples and best‑practice recommendations.

BackendBillingDesign Patterns
0 likes · 12 min read
Refactoring a Billing Service with a Responsibility‑Chain Architecture for Better Extensibility
Python Programming Learning Circle
Python Programming Learning Circle
Jul 26, 2024 · Fundamentals

Python Coding Principles and Best Practices

This article presents a comprehensive collection of Python coding principles, best‑practice suggestions, library usage tips, design‑pattern ideas, internal language mechanisms, tooling recommendations, and performance‑profiling techniques to help developers write clean, efficient, and maintainable Python code.

Design Patternsbest-practicescoding standards
0 likes · 14 min read
Python Coding Principles and Best Practices
Architect
Architect
Jul 24, 2024 · Fundamentals

Master Design Patterns: Real‑World Examples and Complete Java Implementations

This article introduces design patterns, lists the most common patterns such as Strategy, Factory, Singleton, Proxy, Factory Method, Observer, Template Method, and Adapter, and walks through concrete Java code examples, step‑by‑step explanations, and practical scenarios that demonstrate how each pattern solves specific design problems.

AdapterDesign PatternsFactory Pattern
0 likes · 23 min read
Master Design Patterns: Real‑World Examples and Complete Java Implementations
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 24, 2024 · Backend Development

Mastering Domain-Driven Design: Core Concepts, Layers, and Practical C# Examples

Domain-Driven Design (DDD) is a software development methodology that bridges business and technology by defining clear domain models, improving communication, code quality, and handling complexity through layered architecture, with concrete C# examples of entities, value objects, aggregates, and domain services.

C++DDDDesign Patterns
0 likes · 7 min read
Mastering Domain-Driven Design: Core Concepts, Layers, and Practical C# Examples
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 22, 2024 · Backend Development

Understanding Domain-Driven Design (DDD) Architecture

This article introduces Domain-Driven Design (DDD), explains its core concepts, benefits, and the four-layered DDD architecture—including UI, Application, Domain, and Infrastructure layers—while also offering resources for deeper study and interview preparation.

DDDDesign Patternsbackend development
0 likes · 6 min read
Understanding Domain-Driven Design (DDD) Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Jul 18, 2024 · Backend Development

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

This article examines nine design patterns employed within MyBatis—Builder, Factory, Singleton, Proxy, Decorator, Adapter, Composite, Template Method, and Iterator—detailing their roles, source code examples, and how they facilitate configuration parsing, SQL execution, and caching in the framework.

Builder PatternDesign PatternsFactory Pattern
0 likes · 18 min read
Exploring Nine Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Decorator, Adapter, Composite, Template Method, and Iterator
Python Crawling & Data Mining
Python Crawling & Data Mining
Jul 14, 2024 · Fundamentals

Why Design Patterns Matter: Master Reusable Solutions in OOP

This article explains what design patterns are, why they are essential for creating reusable and maintainable object‑oriented code, outlines their main categories, learning steps, and provides a Python command‑pattern example along with a guide to a comprehensive Python design‑patterns book.

Creational PatternsDesign PatternsPython
0 likes · 7 min read
Why Design Patterns Matter: Master Reusable Solutions in OOP
Architect
Architect
Jul 11, 2024 · Backend Development

Architecture Refactoring of a Consumer Installment System: Background, Goals, Design, Deployment, and Monitoring

This article presents a comprehensive case study of refactoring a consumer installment platform, covering business restructuring, technical debt resolution, design of domain and module layers, code redesign with design patterns, phased deployment, monitoring setup, and the overall benefits achieved.

Design Patternsarchitecturemicroservices
0 likes · 11 min read
Architecture Refactoring of a Consumer Installment System: Background, Goals, Design, Deployment, and Monitoring
Selected Java Interview Questions
Selected Java Interview Questions
Jul 1, 2024 · Fundamentals

Java Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template Method, Adapter and More

This article provides a comprehensive introduction to common Java design patterns—including Strategy, Factory, Singleton, Proxy, Observer, Template Method, and Adapter—explaining their concepts, typical use‑cases, and complete code implementations with Spring Boot integration for practical application development.

Design PatternsFactory PatternJava
0 likes · 20 min read
Java Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template Method, Adapter and More
Shepherd Advanced Notes
Shepherd Advanced Notes
Jul 1, 2024 · Fundamentals

18 Essential Practices for Effectively Reading Open‑Source Code

The article outlines why reading source code matters—interview prep, skill growth, design insight—and presents a step‑by‑step guide of 18 practical habits, from mastering the JDK and design patterns to exploring demos, focusing on purpose, main flows, and thoughtful annotation.

Design PatternsJavaRocketMQ
0 likes · 14 min read
18 Essential Practices for Effectively Reading Open‑Source Code
php Courses
php Courses
Jun 27, 2024 · Backend Development

Observer Design Pattern in Laravel: Concepts and Implementation

This article explains the Observer design pattern, its role in reducing coupling, and demonstrates how to implement it in Laravel using Eloquent model events, including creating observers, registering them, and practical use cases such as activity logging, email notifications, and slug generation.

Design PatternsEloquentLaravel
0 likes · 12 min read
Observer Design Pattern in Laravel: Concepts and Implementation
Zhuanzhuan Tech
Zhuanzhuan Tech
Jun 26, 2024 · Backend Development

Refactoring the Game Business Product Update MQ Consumer: Architecture, Design, and Implementation

This article details the background, problem analysis, and comprehensive refactoring plan for a game business's product update MQ consumer, outlining architectural redesign using Flyweight and Strategy patterns, phased implementation, testing strategies, idempotent handling, monitoring, and the resulting 50‑80% reduction in downstream interface calls.

BackendDesign PatternsMQ
0 likes · 13 min read
Refactoring the Game Business Product Update MQ Consumer: Architecture, Design, and Implementation
Code Ape Tech Column
Code Ape Tech Column
Jun 20, 2024 · Backend Development

Implementation of Contract Signing Process Using Chain of Responsibility, Strategy, and Composite Patterns in Java

This article explains a Java-based contract signing system that combines the Chain of Responsibility, Composite, and Strategy design patterns within a Spring Boot application, detailing the processing flow, project structure, key code implementations, and how annotations and enums simplify bean injection.

Chain of ResponsibilityDesign PatternsJava
0 likes · 16 min read
Implementation of Contract Signing Process Using Chain of Responsibility, Strategy, and Composite Patterns in Java
php Courses
php Courses
Jun 19, 2024 · Fundamentals

Why We Need Secondary Constructors and How to Implement Them in Kotlin

The article explains the importance of auxiliary (secondary) constructors for flexible object creation, contrasts PHP's lack of support with Kotlin's feature, and demonstrates clean implementations using primary constructors and static factory methods to improve readability and maintainability.

Design PatternsKotlinconstructors
0 likes · 4 min read
Why We Need Secondary Constructors and How to Implement Them in Kotlin
Shepherd Advanced Notes
Shepherd Advanced Notes
Jun 19, 2024 · Fundamentals

A 20,000‑Word Deep Dive into 9 Overused Design Patterns in Real‑World Code

This article reviews nine widely used design patterns—Singleton, Builder, Factory, Strategy, Template Method, Chain of Responsibility, Proxy, Adapter, and Observer—explaining their concepts, common implementations in open‑source projects such as Spring, Dubbo, MyBatis, and providing concrete code examples and visual diagrams to help readers understand and apply them when reading source code.

AdapterBuilderChain of Responsibility
0 likes · 26 min read
A 20,000‑Word Deep Dive into 9 Overused Design Patterns in Real‑World Code
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 17, 2024 · Backend Development

20 Essential Spring Boot Best Practices to Boost Your Java Backend

This article presents a comprehensive collection of Spring Boot best practices—including package structuring, design patterns, starter usage, dependency management, constructor injection, SLF4J logging, pagination, caching, exception handling, naming conventions, and code quality tools—to help developers build more efficient, maintainable, and robust Java backend applications.

BackendDesign PatternsJava
0 likes · 10 min read
20 Essential Spring Boot Best Practices to Boost Your Java Backend
dbaplus Community
dbaplus Community
Jun 16, 2024 · Backend Development

Building a Scalable MySQL Data Migration Service with Microservices and Design Patterns

This article presents a comprehensive guide to designing and implementing a Java‑based MySQL large‑table migration tool using microservice architecture, multiple design patterns, multithreading, custom logging, and flexible migration modes, complete with code snippets, repository links, and deployment considerations.

Design PatternsJavaLogging
0 likes · 22 min read
Building a Scalable MySQL Data Migration Service with Microservices and Design Patterns
Architect
Architect
Jun 15, 2024 · Fundamentals

Mastering the Chain of Responsibility: From Basics to Real-World Frameworks

This article explains the Chain of Responsibility pattern, compares self‑driven and handler‑driven implementations with Java code, and demonstrates how major frameworks such as Spring Interceptor, Servlet Filter, Dubbo, and Sentinel realize the pattern, followed by practical usage scenarios.

Chain of ResponsibilityDesign PatternsDubbo
0 likes · 25 min read
Mastering the Chain of Responsibility: From Basics to Real-World Frameworks
Test Development Learning Exchange
Test Development Learning Exchange
Jun 6, 2024 · Backend Development

Applying Python Metaclasses for Dynamic API Enhancements

This article demonstrates how Python metaclasses can be leveraged to automatically add authentication headers, manage configuration, log requests, handle exceptions, generate test cases, switch environments, validate parameters, control API versioning, register response validators, and inject dependencies, streamlining backend development.

APIBackendDesign Patterns
0 likes · 10 min read
Applying Python Metaclasses for Dynamic API Enhancements
php Courses
php Courses
Jun 6, 2024 · Backend Development

Why Build a Custom PHP Framework and What It Can Achieve

This guide explains why creating a custom PHP framework is beneficial—addressing specific project needs, fostering learning, simplifying maintenance, improving performance, enhancing usability, and boosting security—while outlining the curriculum covering MVC, routing, error handling, namespaces, singleton pattern, configuration, and database abstraction.

Design PatternsMVCPHP
0 likes · 3 min read
Why Build a Custom PHP Framework and What It Can Achieve
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jun 5, 2024 · Backend Development

Design and Implementation of a Multi‑Level Cache Component Library in Go

This article explains the motivation, design principles, class diagram, and core Go code for a multi‑level cache library that supports in‑memory and distributed caches (Redis, Memcached) using adapter, builder, and responsibility‑chain patterns, and discusses cache‑database consistency strategies.

Adapter PatternCacheDesign Patterns
0 likes · 21 min read
Design and Implementation of a Multi‑Level Cache Component Library in Go
Ops Development & AI Practice
Ops Development & AI Practice
May 27, 2024 · Backend Development

Decoupling Gin Handlers with Dependency Injection in Go

This article explains how to apply Dependency Injection in the Go Gin framework to separate routing logic from business services, reducing code coupling, improving testability, and enhancing reusability through concrete interface definitions, a simple DI container, and practical code examples.

BackendDependency InjectionDesign Patterns
0 likes · 6 min read
Decoupling Gin Handlers with Dependency Injection in Go
JD Retail Technology
JD Retail Technology
May 23, 2024 · Backend Development

Designing a Message Processing Solution with MVEL Expressions and the Chain of Responsibility Pattern

This article explains how to combine MVEL expressions with the Chain of Responsibility design pattern to build a decoupled, extensible message‑processing framework, using an order‑splitting MQ example to illustrate the architecture, code implementation, and benefits for backend Java services.

Apache Commons ChainChain of ResponsibilityDesign Patterns
0 likes · 15 min read
Designing a Message Processing Solution with MVEL Expressions and the Chain of Responsibility Pattern
Architect
Architect
May 20, 2024 · Backend Development

Unlocking MyBatis: 10+ Design Patterns Powering Its Architecture

This article dissects MyBatis's source code, revealing how more than ten classic design patterns—such as Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—are applied to decouple complex scenarios, improve extensibility, and streamline ORM operations.

AdapterBuilderDesign Patterns
0 likes · 11 min read
Unlocking MyBatis: 10+ Design Patterns Powering Its Architecture
Selected Java Interview Questions
Selected Java Interview Questions
May 12, 2024 · Backend Development

Optimizing Contract Signing with Strategy, Chain of Responsibility, and Composite Patterns in Java

This article explains how to improve a Java Spring Boot contract signing workflow by combining the Strategy pattern, Chain of Responsibility, and Composite patterns, detailing the process steps, project structure, code implementations, custom annotations, and dynamic bean injection to achieve a flexible and maintainable solution.

BackendChain of ResponsibilityDesign Patterns
0 likes · 13 min read
Optimizing Contract Signing with Strategy, Chain of Responsibility, and Composite Patterns in Java
Java Tech Enthusiast
Java Tech Enthusiast
May 6, 2024 · Backend Development

Design Patterns in MyBatis Source Code

MyBatis, a widely used Java ORM, embeds around ten classic design patterns—including Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template Method, Strategy, and Iterator—to modularize object creation, structure, and behavior, thereby simplifying complex data access and caching mechanisms within its architecture.

Design PatternsJavaMyBatis
0 likes · 8 min read
Design Patterns in MyBatis Source Code
IT Services Circle
IT Services Circle
May 1, 2024 · Artificial Intelligence

Summary of Andrew Ng’s AI Agent Talk: Models, Workflows, and Design Patterns

The article summarizes Andrew Ng’s presentation on AI agents, contrasting traditional single‑prompt large‑model usage with iterative agent‑based workflows, reporting experimental accuracy gains, and outlining four agent design patterns—reflection, tool use, planning, and multi‑agent collaboration—while discussing practical trade‑offs such as latency and token speed.

AI agentDesign Patternslarge language model
0 likes · 7 min read
Summary of Andrew Ng’s AI Agent Talk: Models, Workflows, and Design Patterns
Ops Development & AI Practice
Ops Development & AI Practice
May 1, 2024 · Fundamentals

Mastering DTOs: Design Principles and Best Practices for Layered Architecture

Data Transfer Objects (DTOs) are essential for clean layered software design, and this article explains their purpose, key design principles such as encapsulation, orthogonality, and layer isolation, illustrates their role between presentation, service, and data layers, and provides a Go code example with benefits and challenges.

DTODesign PatternsGo
0 likes · 6 min read
Mastering DTOs: Design Principles and Best Practices for Layered Architecture
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 28, 2024 · Fundamentals

Master Java Fundamentals: OOP, Collections, Concurrency, and Design Patterns

This comprehensive guide covers Java's core concepts—including object‑oriented principles, differences from C++, polymorphism, static/final modifiers, abstract classes versus interfaces, generics, reflection, exception hierarchy, key data structures like ArrayList, LinkedList, HashMap, ConcurrentHashMap, serialization, String handling, and essential design patterns such as Singleton, Factory, and Abstract Factory—providing interview‑ready knowledge for developers.

ConcurrencyDesign PatternsGenerics
0 likes · 19 min read
Master Java Fundamentals: OOP, Collections, Concurrency, and Design Patterns
DeWu Technology
DeWu Technology
Apr 24, 2024 · Backend Development

State Machine Integration for New Product Onboarding

The article details how Dewu’s new product onboarding workflow was refactored into a Spring StateMachine‑driven architecture that separates channel‑specific logic via a Strategy‑pattern operation layer, defines clear enum status domains, and uses guards, actions, and choice states to achieve maintainable, extensible, and idempotent state transitions.

Design PatternsSpringState Machine
0 likes · 20 min read
State Machine Integration for New Product Onboarding
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 24, 2024 · Backend Development

How a Strategy Factory Refactors Complex HSF Checks for Cleaner Backend Code

This article explains how the smart‑auto testing tool’s tangled HSF interface validation logic was refactored using a strategy‑factory pattern, breaking long if‑else chains into modular strategies that improve readability, maintainability, and adherence to the Open/Closed principle.

Design PatternsStrategy Patternbackend development
0 likes · 12 min read
How a Strategy Factory Refactors Complex HSF Checks for Cleaner Backend Code
Architect's Guide
Architect's Guide
Apr 19, 2024 · Backend Development

API Gateway Design and Best Practices for Microservice Architectures

This article explains the role, core functions, design principles, and key considerations of API gateways in microservice architectures, compares popular gateway solutions, and provides guidance on achieving high performance, high availability, and scalability while ensuring security and operational efficiency.

BackendDesign PatternsSecurity
0 likes · 22 min read
API Gateway Design and Best Practices for Microservice Architectures
Java Interview Crash Guide
Java Interview Crash Guide
Apr 18, 2024 · Backend Development

14 Practical Java Code‑Optimization Tips for Cleaner, More Maintainable Code

This article presents fourteen actionable Java coding‑style and architecture tips—ranging from using configuration properties and Lombok constructors to modularizing methods, throwing exceptions, reducing DB calls, avoiding null returns, and leveraging IDE suggestions—to help developers write cleaner, more robust backend code.

Best PracticesDesign PatternsIDEA
0 likes · 9 min read
14 Practical Java Code‑Optimization Tips for Cleaner, More Maintainable Code
MoonWebTeam
MoonWebTeam
Apr 16, 2024 · Frontend Development

Mastering Dependency Injection in Frontend: Boost Maintainability and Testability

This article explains the concept of Dependency Injection for frontend projects, compares it with Inversion of Control, showcases practical code examples, discusses popular DI libraries and frameworks, and details implementation techniques such as decorators, reflection, singleton handling, and circular dependency resolution to improve maintainability and testability.

Dependency InjectionDesign PatternsIoC
0 likes · 26 min read
Mastering Dependency Injection in Frontend: Boost Maintainability and Testability
DaTaobao Tech
DaTaobao Tech
Apr 12, 2024 · Backend Development

HSF (High‑speed Service Framework) Overview and Usage Guide

HSF (High‑speed Service Framework) is Alibaba’s high‑performance SOA solution that decouples monolithic applications via non‑blocking RPC, offering service discovery, dynamic routing, grouping, and both synchronous and asynchronous calls, configurable serialization, timeout, and thread pools, and employing patterns such as proxy, chain‑of‑responsibility, observer and decorator.

Design PatternsHSFJava
0 likes · 22 min read
HSF (High‑speed Service Framework) Overview and Usage Guide
Java High-Performance Architecture
Java High-Performance Architecture
Apr 11, 2024 · Backend Development

Essential Microservice Design Patterns: Pros, Cons, and When to Use Them

This article explains the evolution of microservice architecture, defines its core characteristics, lists its advantages and disadvantages, and provides detailed guidance on when to adopt it, followed by an extensive review of key design patterns such as database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing.

Design Patterns
0 likes · 28 min read
Essential Microservice Design Patterns: Pros, Cons, and When to Use Them
Java High-Performance Architecture
Java High-Performance Architecture
Apr 11, 2024 · Backend Development

Mastering Microservice Architecture: Patterns, Pros, Cons, and When to Use Them

This article traces the evolution of software architecture to microservices, explains their core characteristics, lists advantages and drawbacks, and provides a comprehensive guide to essential design patterns such as database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing, with guidance on when to adopt each.

BackendDesign Patternsarchitecture
0 likes · 27 min read
Mastering Microservice Architecture: Patterns, Pros, Cons, and When to Use Them
Architect
Architect
Apr 9, 2024 · Backend Development

Microservice Architecture Design Patterns: Overview, Benefits, Drawbacks, and Usage Guidelines

This article provides a comprehensive overview of microservice architecture, detailing its definition, key characteristics, advantages and disadvantages, and presenting ten essential design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—along with their pros, cons, and appropriate scenarios.

Backend ArchitectureDesign PatternsDistributed Systems
0 likes · 29 min read
Microservice Architecture Design Patterns: Overview, Benefits, Drawbacks, and Usage Guidelines
Ops Development & AI Practice
Ops Development & AI Practice
Apr 9, 2024 · Backend Development

Mastering Redis Client Integration in Go with the Adapter Pattern

Learn how to use the Adapter pattern in Go to unify disparate Redis clients—*redis.Client* and *redis.ClusterClient*—by defining a common interface, implementing concrete adapters, and employing a factory method, resulting in cleaner, maintainable code that adheres to the open/closed principle.

Adapter PatternDesign PatternsGo
0 likes · 7 min read
Mastering Redis Client Integration in Go with the Adapter Pattern
IT Services Circle
IT Services Circle
Apr 9, 2024 · Backend Development

ByteDance Backend Interview Experience: Key Topics and Knowledge Points

This article shares a detailed ByteDance backend interview experience covering three rounds, summarizing essential topics such as Java HashMap internals, Spring circular dependencies, MySQL indexing, OS process/thread concepts, networking protocols, TLS handshake, HTTP/2 features, and common design patterns, providing concise explanations and practical tips.

BackendDesign PatternsInterview
0 likes · 25 min read
ByteDance Backend Interview Experience: Key Topics and Knowledge Points
Ubiquitous Tech
Ubiquitous Tech
Apr 9, 2024 · Fundamentals

Master Java Supplier and Consumer Interfaces with Practical Examples

This article explains Java 8's Supplier and Consumer functional interfaces, illustrates their definitions, shows real‑world use cases such as random number generation, object creation, stream data sources, printing and validation, compares them with anonymous classes and lambdas, and connects them to design patterns and parameterized method calls.

ConsumerDesign PatternsFunctional Interface
0 likes · 23 min read
Master Java Supplier and Consumer Interfaces with Practical Examples
Ops Development & AI Practice
Ops Development & AI Practice
Apr 6, 2024 · Backend Development

How to Simulate Monkey Patching in Go Using Interfaces and Reflection

The article explains why Go does not support traditional monkey patching, then demonstrates two practical approaches—using interfaces with wrapper types and employing reflection—to extend a SimpleLogger with log levels without modifying its source, while discussing trade‑offs such as readability and performance.

Design PatternsGoMonkey Patching
0 likes · 6 min read
How to Simulate Monkey Patching in Go Using Interfaces and Reflection
Ops Development & AI Practice
Ops Development & AI Practice
Apr 4, 2024 · Fundamentals

Mastering the Facade Pattern in Go: Simplify Complex Systems

This article explains the Facade design pattern, outlines its core roles, provides step‑by‑step guidance for implementing it in Go, showcases a complete code example, and discusses its advantages and typical use cases such as API gateways in microservice architectures.

Code ExampleDesign PatternsFacade Pattern
0 likes · 5 min read
Mastering the Facade Pattern in Go: Simplify Complex Systems
Smart Era Software Development
Smart Era Software Development
Apr 3, 2024 · Artificial Intelligence

Unveiling Andrew Ng’s Four AI Agent Design Patterns with Coze

The article explains Andrew Ng’s four AI agent design patterns—Reflection, Tool Use, Planning, and Multi‑agent Collaboration—illustrates each with concrete Coze workflows and real‑world examples such as automotive research briefs, milk‑tea industry reports, and high‑quality travel planning.

AI agentsCozeDesign Patterns
0 likes · 7 min read
Unveiling Andrew Ng’s Four AI Agent Design Patterns with Coze
Architect
Architect
Mar 21, 2024 · Backend Development

Refactoring a Complex Order Process with a Three‑Layer Interface and Strategy Template

This article analyzes the problems of a scattered, poorly‑designed order‑processing codebase, proposes a three‑layer interface combined with a strategy‑template pattern, walks through concrete Java implementations, testing and gray‑release safeguards, and shows how the redesign improves readability, maintainability, and extensibility.

Design PatternsStrategy Patternmicroservices
0 likes · 15 min read
Refactoring a Complex Order Process with a Three‑Layer Interface and Strategy Template
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 21, 2024 · Fundamentals

Refactoring Multi‑Board SDK Integration Using Abstract Factory, Adapter, and Facade Patterns

The article analyzes a multi‑board Android SDK integration problem, identifies hard‑coded type checks and inconsistent APIs, and proposes a refactor that employs the Abstract Factory, Adapter, and Facade design patterns with Kotlin examples to achieve loose coupling, extensibility, and clearer business concepts.

Abstract FactoryAdapter PatternDesign Patterns
0 likes · 10 min read
Refactoring Multi‑Board SDK Integration Using Abstract Factory, Adapter, and Facade Patterns
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Mar 12, 2024 · Fundamentals

Understanding Domain-Driven Design (DDD) Architecture: Concepts, Layers, and Core Principles

Domain-Driven Design (DDD) is a software design methodology that simplifies complex business domains by defining clear boundaries, layers, and core concepts such as aggregates, entities, value objects, and bounded contexts, helping teams achieve better business understanding, modularity, maintainability, and efficient architecture.

BackendDDDDesign Patterns
0 likes · 10 min read
Understanding Domain-Driven Design (DDD) Architecture: Concepts, Layers, and Core Principles
dbaplus Community
dbaplus Community
Mar 10, 2024 · Backend Development

How to Seamlessly Refactor MVC Projects into DDD Architecture

This article explains why legacy MVC codebases become tangled, introduces the domain‑driven design (DDD) layered architecture, and provides a step‑by‑step, low‑cost migration path—including layer mapping, call‑chain illustration, common pitfalls, and a concrete refactoring example with design patterns and code snippets.

DDDDesign PatternsMVC
0 likes · 20 min read
How to Seamlessly Refactor MVC Projects into DDD Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Mar 7, 2024 · Backend Development

Evolving an Order Processing System with Design Patterns: From Chain of Responsibility to Distributed Asynchronous Flow

This article walks through a real‑world order‑processing case, demonstrating how successive design‑pattern refinements—starting with the Chain of Responsibility, then adding Factory, Proxy, Template Method, Observer and distributed messaging—enable multi‑tenant, asynchronous, and scalable backend workflows.

Asynchronous ProcessingChain of ResponsibilityDesign Patterns
0 likes · 15 min read
Evolving an Order Processing System with Design Patterns: From Chain of Responsibility to Distributed Asynchronous Flow
Sohu Tech Products
Sohu Tech Products
Mar 6, 2024 · Fundamentals

JavaScript Design Patterns: A Comprehensive Guide

This guide explains JavaScript design patterns—creational, structural, and behavioral—detailing common examples such as Singleton, Factory, Module, Decorator, Observer, Strategy, and more, and shows how applying these proven solutions can make code clearer, more flexible, maintainable, and scalable.

Creational PatternsDesign PatternsFactory Pattern
0 likes · 28 min read
JavaScript Design Patterns: A Comprehensive Guide
Su San Talks Tech
Su San Talks Tech
Mar 6, 2024 · Backend Development

Mastering Java Design Patterns: From High Cohesion to Low Coupling in Spring

This article explains the core concepts of high cohesion and low coupling, introduces common Java design patterns, demonstrates how Spring applies these patterns such as Singleton, Factory, Proxy, Observer, Chain of Responsibility, and Template Method, and provides practical code examples for real‑world scenarios.

Design PatternsJavaSpring Framework
0 likes · 19 min read
Mastering Java Design Patterns: From High Cohesion to Low Coupling in Spring
Architect
Architect
Feb 25, 2024 · Backend Development

Unlocking Tomcat: A Deep Dive into Its Architecture and Design Patterns

This article dissects Tomcat’s mature architecture, explaining its macro and micro design, startup flow, connector and container components, lifecycle management, class‑loader hierarchy, hot‑reload mechanism, and how developers can apply the demonstrated patterns such as composite, observer, template method, and strategy in real projects.

Class LoaderDesign PatternsJava
0 likes · 43 min read
Unlocking Tomcat: A Deep Dive into Its Architecture and Design Patterns
Top Architect
Top Architect
Feb 21, 2024 · Backend Development

Cache Consistency Strategies Between MySQL and Redis

This article explains the classic cache consistency problem between MySQL and Redis, analyzes why inconsistencies occur, and details four common design patterns—delete‑then‑update, update‑then‑invalidate (Cache‑Aside), Read/Write‑Through, and Write‑Behind—along with their advantages, drawbacks, and typical execution flows.

Cache ConsistencyDatabase CachingDesign Patterns
0 likes · 9 min read
Cache Consistency Strategies Between MySQL and Redis
Architect's Guide
Architect's Guide
Feb 21, 2024 · Backend Development

Design and Implementation of a Java Rule Engine with Short‑Circuit Evaluation

This article explains a real‑world scenario of extending trial‑user eligibility rules, introduces a refactored Java rule‑engine architecture that separates data, abstract rule templates, concrete rule implementations, and a service supporting AND/OR short‑circuit logic, and evaluates its advantages and drawbacks.

Design PatternsJavabackend development
0 likes · 8 min read
Design and Implementation of a Java Rule Engine with Short‑Circuit Evaluation
php Courses
php Courses
Feb 6, 2024 · Backend Development

Why Build a Custom PHP Framework – Course Outline

This article explains the motivations for creating a custom PHP framework—such as meeting specific needs, learning, long‑term maintenance, performance, usability, and security—and provides a detailed course outline covering MVC, routing, error handling, namespaces, design patterns, configuration, and database operations.

BackendDesign PatternsMVC
0 likes · 4 min read
Why Build a Custom PHP Framework – Course Outline
Laravel Tech Community
Laravel Tech Community
Feb 5, 2024 · Backend Development

Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices

This article explains the relationship between MySQL and Redis, the classic cache‑consistency problem, and compares four common cache‑update patterns—delete‑then‑update, update‑then‑invalidate, read/write‑through, and write‑behind—detailing their workflows, advantages, and drawbacks.

Cache AsideCache ConsistencyDesign Patterns
0 likes · 7 min read
Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices
Sohu Tech Products
Sohu Tech Products
Jan 24, 2024 · Frontend Development

Five React Component Design Patterns: Compound, Controlled, Custom Hooks, Props Getters, and State Reducer

The article reviews five React component design patterns—Compound, Controlled, Custom Hooks, Props Getters, and State Reducer—explaining how each improves reusability, API simplicity, and state management while weighing their advantages, disadvantages, and ideal use‑cases for scalable, maintainable UI development.

Design PatternsJavaScriptReact
0 likes · 18 min read
Five React Component Design Patterns: Compound, Controlled, Custom Hooks, Props Getters, and State Reducer
php Courses
php Courses
Jan 22, 2024 · Backend Development

Common Design Patterns in PHP: Singleton, Factory, Observer, and Adapter

This article introduces four essential design patterns—Singleton, Factory, Observer, and Adapter—explaining their concepts and providing complete PHP code examples to demonstrate how each pattern can be implemented to create maintainable, extensible, and flexible applications.

AdapterDesign PatternsPHP
0 likes · 7 min read
Common Design Patterns in PHP: Singleton, Factory, Observer, and Adapter
Architects Research Society
Architects Research Society
Jan 21, 2024 · Fundamentals

Software Architect vs Enterprise Architect: Roles, Responsibilities, and Differences

The article explains the distinct roles of software architects, enterprise architects, solution architects, and technical architects, outlining their responsibilities, focus areas, and how they differ in scope, technical depth, and alignment with business goals within an organization.

Design Patternsenterprise architecturesoftware architecture
0 likes · 6 min read
Software Architect vs Enterprise Architect: Roles, Responsibilities, and Differences
DaTaobao Tech
DaTaobao Tech
Jan 15, 2024 · Backend Development

Refactoring Java Sale‑Type Parsing: From Simple Method to Design Patterns

Starting from a basic Java method that maps a sale‑type string to an integer, the article incrementally refactors the code by applying null‑safe utilities, constants, static methods, ternary/Optional expressions, enums with lookup maps, a combined relation enum, and finally a Strategy pattern with a container, illustrating how each step improves safety, readability, extensibility, and testability.

Design PatternsEnumJava
0 likes · 13 min read
Refactoring Java Sale‑Type Parsing: From Simple Method to Design Patterns
政采云技术
政采云技术
Jan 9, 2024 · Frontend Development

Five React Component Design Patterns with Advantages, Disadvantages, and Use Cases

This article introduces five reusable React component design patterns—Compound Component, Controlled Component, Custom Hook, Props Getters, and State Reducer—explaining their implementations, pros and cons, and suitable scenarios to help developers balance flexibility, complexity, and control in UI development.

Design PatternsReactcomponent design
0 likes · 17 min read
Five React Component Design Patterns with Advantages, Disadvantages, and Use Cases
IT Architects Alliance
IT Architects Alliance
Jan 8, 2024 · Fundamentals

Five Common Software Architecture Patterns and Their Ideal Use Cases

This article examines five prevalent software architecture styles—monolithic, microservices, client‑server, distributed, and cloud‑native—explaining their characteristics, advantages, and suitable scenarios to help developers choose the most appropriate design for their projects in modern software development.

Design Patternscloud-nativesoftware architecture
0 likes · 5 min read
Five Common Software Architecture Patterns and Their Ideal Use Cases
php Courses
php Courses
Jan 3, 2024 · Fundamentals

Adapter Design Pattern for Integrating Multiple E‑Commerce APIs in PHP

This article explains the Adapter design pattern, illustrates the challenges of aggregating product data from diverse e‑commerce APIs, and provides a complete PHP implementation—including interface definitions, adaptor classes for Shopify, BigCommerce, and WooCommerce, and a ProductFeed aggregator—to achieve a maintainable, extensible solution.

Adapter PatternBackend IntegrationDesign Patterns
0 likes · 9 min read
Adapter Design Pattern for Integrating Multiple E‑Commerce APIs in PHP
IT Niuke
IT Niuke
Jan 2, 2024 · Fundamentals

How to Use the Chain of Responsibility Pattern for Real‑World Data Filtering

This article explains the Chain of Responsibility design pattern, defines its three core roles, compares external and internal composition, demonstrates a lead‑filtering use case with Java and Spring code, and discusses benefits, drawbacks, and differences from the Strategy pattern.

Chain of ResponsibilityDependency InjectionDesign Patterns
0 likes · 9 min read
How to Use the Chain of Responsibility Pattern for Real‑World Data Filtering
IT Niuke
IT Niuke
Jan 2, 2024 · Fundamentals

How the Flyweight Pattern Cuts Memory Use in Real‑World Java Services

The article explains the Flyweight design pattern, shows how a surge of 30 KB country objects caused memory pressure in a marketing service, and demonstrates a Java implementation with Flyweight, FlyweightFactory, and related code, while comparing it to Singleton and caching approaches.

Design PatternsJavacaching
0 likes · 8 min read
How the Flyweight Pattern Cuts Memory Use in Real‑World Java Services
Java Architect Essentials
Java Architect Essentials
Dec 30, 2023 · Backend Development

Design and Implementation of a Java Rule Engine

This article presents a Java-based rule engine design, illustrating rule abstraction, concrete rule implementations, and a flexible executor supporting AND/OR logic, accompanied by code examples and a discussion of its advantages and drawbacks for maintainability.

Code ExampleDesign PatternsJava
0 likes · 8 min read
Design and Implementation of a Java Rule Engine
Yunxuetang Frontend Team
Yunxuetang Frontend Team
Dec 29, 2023 · Frontend Development

Master Frontend Design Patterns, Grid Layouts, and Node.js Addons

This article explores high‑frequency frontend design patterns, demonstrates how mastering CSS Grid simplifies layouts, introduces Node.js Addons for native capabilities, reviews Meta’s StyleX CSS‑in‑JS library, recaps major 2023 frontend developments, and highlights the Cloud Academy frontend team.

2023 trendsCSS GridDesign Patterns
0 likes · 4 min read
Master Frontend Design Patterns, Grid Layouts, and Node.js Addons
DaTaobao Tech
DaTaobao Tech
Dec 29, 2023 · Backend Development

Design Patterns and Practices for Fast, Stable Development in Taobao Innovation Projects

The article outlines how the Taobao “Calm Guard” project accelerates rapid‑iteration development by employing reusable patterns—including a Spring‑based Strategy registry, a hierarchical fatigue‑control framework, generic cache upsert via functional parameters, and precise AOP aspects—resulting in faster, more stable, and maintainable code.

AOPDesign PatternsJava
0 likes · 29 min read
Design Patterns and Practices for Fast, Stable Development in Taobao Innovation Projects
Programmer DD
Programmer DD
Dec 27, 2023 · Backend Development

Mastering State Machines in Spring: From Design Patterns to Order Workflows

This article explains the State design pattern, compares Spring State Machine with alternatives, and provides a complete Java example that models order status transitions using Spring Statemachine, including code, configuration, listeners, services, and test execution.

Design PatternsOrder WorkflowSpring StateMachine
0 likes · 15 min read
Mastering State Machines in Spring: From Design Patterns to Order Workflows
Architect
Architect
Dec 25, 2023 · Backend Development

Implementing API Idempotency Checks with Design Patterns in Java

This article explains the concept of idempotency, why it is essential for API reliability, and demonstrates four practical idempotency strategies—including database primary keys, optimistic locking, token validation, and Redis caching—implemented via custom annotations and the Strategy pattern in a Spring‑Boot Java project.

APIDesign PatternsIdempotency
0 likes · 23 min read
Implementing API Idempotency Checks with Design Patterns in Java
Watermelon Video Tech Team
Watermelon Video Tech Team
Dec 12, 2023 · Mobile Development

A Guide to the Architecture Design Process for Mobile Applications

This article outlines a systematic approach to mobile architecture design, covering goals, when to create new architectures, requirement analysis, business flow mapping, pattern discovery, layering, modularization, lifecycle interfaces, verification, and evolution, illustrated with a Feed scenario and code examples.

Design Patternsarchitecturemodularization
0 likes · 19 min read
A Guide to the Architecture Design Process for Mobile Applications
Code Ape Tech Column
Code Ape Tech Column
Dec 5, 2023 · Backend Development

Design and Implementation of a Java Rule Engine with AND/OR Logic

This article explains how to design and refactor a Java rule engine that supports short‑circuit AND/OR logic, demonstrates the abstraction of rules, shows concrete implementations, and provides a chainable service for executing combined rule sets with example code.

AND/OR LogicBackendDesign Patterns
0 likes · 8 min read
Design and Implementation of a Java Rule Engine with AND/OR Logic
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 27, 2023 · Fundamentals

27 Essential Java Programming Principles from Effective Java

This article distills the classic "Effective Java" book into twenty‑seven practical programming principles covering object construction, static factory methods, builders, enums for singletons, resource management, equals/hashCode, generics, method design, exception handling, and general coding best practices, providing clear guidance for Java developers.

Best PracticesDesign PatternsEffective Java
0 likes · 21 min read
27 Essential Java Programming Principles from Effective Java
Sohu Tech Products
Sohu Tech Products
Nov 22, 2023 · Fundamentals

Mastering the Chain of Responsibility: From SOLID Principles to Spring Integration

This article explains the seven SOLID design principles, introduces the Chain of Responsibility pattern, demonstrates its application to a video‑review workflow with step‑by‑step Java code, and shows how to evolve the implementation from a basic chain to a Spring‑managed, fully open‑closed solution.

Chain of ResponsibilityDependency InjectionDesign Patterns
0 likes · 13 min read
Mastering the Chain of Responsibility: From SOLID Principles to Spring Integration
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 22, 2023 · Fundamentals

Understanding the Five Creational Design Patterns

This article provides a comprehensive overview of the five creational design patterns—Singleton, Abstract Factory, Factory Method, Builder, and Prototype—explaining their concepts, UML structures, implementation details, typical use cases, advantages, disadvantages, and includes Java code examples and diagrams.

Creational PatternsDesign PatternsJava
0 likes · 9 min read
Understanding the Five Creational Design Patterns
Java Backend Technology
Java Backend Technology
Nov 21, 2023 · Backend Development

How to Inflate Your Java Codebase Without Sacrificing Quality

An irreverent guide shows how to artificially inflate Java code volume by adding unnecessary interfaces, redundant methods, extra configuration fields, event listeners, utility classes, custom exceptions, and classic design patterns, while warning that such practices harm readability and maintainability despite boosting line counts.

Design PatternsJavacode quality
0 likes · 13 min read
How to Inflate Your Java Codebase Without Sacrificing Quality
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 20, 2023 · Fundamentals

Prototype Pattern: Definition, UML Diagram, Implementation, Advantages, Disadvantages, and Use Cases

This article explains the Prototype design pattern, covering its definition, UML class diagram, Java implementation with shallow and deep copy examples, advantages and drawbacks, comparisons with Factory Method and Singleton patterns, and practical scenarios where cloning objects provides an efficient alternative to costly object creation.

Deep CopyDesign PatternsJava
0 likes · 14 min read
Prototype Pattern: Definition, UML Diagram, Implementation, Advantages, Disadvantages, and Use Cases
Senior Brother's Insights
Senior Brother's Insights
Nov 20, 2023 · Backend Development

Mastering the Chain of Responsibility Pattern for Scalable Product Validation in Java

This article explains the Chain of Responsibility design pattern, shows how to apply it to multi‑step product creation validation and expense‑approval workflows, walks through abstract and concrete handler implementations, dynamic configuration, and client execution with full Java code examples.

Chain of ResponsibilityDesign PatternsJava
0 likes · 20 min read
Mastering the Chain of Responsibility Pattern for Scalable Product Validation in Java
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 17, 2023 · Fundamentals

Factory Method Pattern: Definition, Structure, Implementation, Advantages, and Use Cases

This article explains the Factory Method design pattern, covering its definition, UML diagram, key participants, the problems it solves compared to the Simple Factory, step‑by‑step Java implementation with code examples, advantages, disadvantages, application scenarios, and differences from the Simple Factory pattern.

Design PatternsJavaUML
0 likes · 8 min read
Factory Method Pattern: Definition, Structure, Implementation, Advantages, and Use Cases