BestHub
Sign in
Tagged articles

Design Patterns

943 articles · Page 3 of 10
macrozheng
macrozheng
Mar 14, 2025 · Backend Development

Inside Xiaomi Car Interviews: SpringBoot, MySQL Tuning & Distributed Transactions

This article shares Xiaomi car interview salary data, explains SpringBoot's startup process, discusses Spring IOC/AOP benefits, offers MySQL table creation and indexing tips, compares lock types, reviews common design patterns, outlines network device differences, and summarizes distributed transaction solutions including Seata.

Design PatternsDistributed TransactionsMySQL
0 likes · 20 min read
Inside Xiaomi Car Interviews: SpringBoot, MySQL Tuning & Distributed Transactions
macrozheng
macrozheng
Mar 13, 2025 · Backend Development

Mastering the Strategy Pattern in Spring Boot: Clean, Extensible Code with Real Examples

This article walks through the concept and practical implementation of the Strategy design pattern in Spring Boot, showing how to define operation interfaces, create concrete strategy classes, use factories and Spring's IoC container for clean, maintainable, and extensible backend code.

Design PatternsStrategy Patternbackend development
0 likes · 9 min read
Mastering the Strategy Pattern in Spring Boot: Clean, Extensible Code with Real Examples
Test Development Learning Exchange
Test Development Learning Exchange
Mar 7, 2025 · Fundamentals

Mastering Polymorphism: 10 Real-World Python Examples and When to Use Them

This article explains the core concept of polymorphism in object‑oriented programming, distinguishes compile‑time and runtime polymorphism, and provides ten practical Python examples—from animal sounds and shape drawing to payment processing, file handling, logging, and game characters—illustrating when and how to apply each technique.

Design PatternsMethod OverloadingPython
0 likes · 9 min read
Mastering Polymorphism: 10 Real-World Python Examples and When to Use Them
JD Tech Talk
JD Tech Talk
Mar 7, 2025 · Fundamentals

Understanding Java Service Provider Interface (SPI): Introduction, Example, and Implementation Details

This article introduces Java's Service Provider Interface (SPI), demonstrates a step‑by‑step example with multiple Maven modules, explains how to create interface and implementation classes, configure META‑INF/services files, and delves into the ServiceLoader internals that enable runtime discovery and instantiation of providers.

Design PatternsJavaSPI
0 likes · 9 min read
Understanding Java Service Provider Interface (SPI): Introduction, Example, and Implementation Details
Test Development Learning Exchange
Test Development Learning Exchange
Mar 6, 2025 · Fundamentals

Understanding Class Inheritance in Python: Basics, Overriding, Polymorphism, super() and Advanced Applications

This article explains Python class inheritance—from basic single inheritance and method overriding to polymorphism, super() calls, multiple inheritance, and design‑pattern implementations—providing code examples, usage scenarios, and best‑practice recommendations for writing reusable, extensible object‑oriented code.

Design PatternsOOPPython
0 likes · 10 min read
Understanding Class Inheritance in Python: Basics, Overriding, Polymorphism, super() and Advanced Applications
Top Architecture Tech Stack
Top Architecture Tech Stack
Feb 27, 2025 · Fundamentals

Understanding the Facade Design Pattern and Its Application in Spring Boot

This article explains the Facade design pattern, illustrating its purpose of simplifying complex systems with real‑world analogies, detailing its benefits, showing UML class diagram relationships, and providing a comprehensive Spring Boot example that encapsulates flight, hotel, and package services behind a BookingFacade, while also including promotional content for IDE licenses.

Design PatternsFacade PatternSoftware Architecture
0 likes · 15 min read
Understanding the Facade Design Pattern and Its Application in Spring Boot
JavaScript
JavaScript
Feb 21, 2025 · Frontend Development

10 Clever Ways to Replace if‑else in JavaScript

This article presents ten practical techniques—including object mapping, Array.includes, ternary chains, logical operators, switch patterns, Proxy, functional programming, state machines, and decorators—to simplify and shorten JavaScript conditional logic, each illustrated with clear code examples.

Code RefactoringConditional LogicDesign Patterns
0 likes · 3 min read
10 Clever Ways to Replace if‑else in JavaScript
php Courses
php Courses
Feb 17, 2025 · Backend Development

Applying Strategy and Chain of Responsibility Patterns in Symfony: Deep Dive with PHP Code Examples

This article explains how the Strategy and Chain of Responsibility design patterns are applied within the Symfony framework, providing detailed PHP code examples, discussing their integration in core components, and highlighting the architectural benefits such as flexibility, loose coupling, and maintainability.

Chain of ResponsibilityDesign PatternsPHP
0 likes · 7 min read
Applying Strategy and Chain of Responsibility Patterns in Symfony: Deep Dive with PHP Code Examples
Java Tech Enthusiast
Java Tech Enthusiast
Feb 13, 2025 · Backend Development

Facade Design Pattern with Spring Boot Example

The article explains the Facade design pattern and demonstrates its use in a Spring Boot travel‑booking application, where a BookingFacade aggregates FlightService, HotelService, and PackageService to provide a single bookTravel method that a REST controller calls, simplifying the API and reducing coupling.

Design PatternsFacade PatternJava
0 likes · 12 min read
Facade Design Pattern with Spring Boot Example
Python Programming Learning Circle
Python Programming Learning Circle
Feb 12, 2025 · Fundamentals

Python Coding Principles, Best Practices, and Design Patterns

These comprehensive guidelines cover Pythonic concepts, coding conventions, function design, module organization, library usage, design patterns, internal mechanisms, development tools, performance profiling, and optimization techniques, providing developers with practical advice to write clean, efficient, and maintainable Python code.

Design Patternsbest practicescoding standards
0 likes · 14 min read
Python Coding Principles, Best Practices, and Design Patterns
Sanyou's Java Diary
Sanyou's Java Diary
Feb 10, 2025 · Backend Development

10 Essential Backend Optimization Techniques Every Developer Should Master

This comprehensive guide explores ten critical backend optimization strategies—from defensive validation and batch N+1 query elimination to asynchronous processing, parallel execution, caching, connection pooling, compression, message queuing, and design patterns—providing practical examples, Go code snippets, and best‑practice insights to boost performance and reliability.

Design Patternsbackend developmentconcurrency
0 likes · 32 min read
10 Essential Backend Optimization Techniques Every Developer Should Master
Alibaba Cloud Developer
Alibaba Cloud Developer
Feb 8, 2025 · Backend Development

Unlocking Spring’s Core: A Deep Dive into the IOC Container Mechanics

This article explores the fundamental mechanisms of the Spring container, detailing its architecture, core jars, bean factory processes, configuration parsing, bean instantiation, property population, and design patterns such as Factory, Singleton, Builder, Decorator, Observer, and Strategy, while providing extensive code examples and diagrams.

BeanFactoryDesign PatternsIoC
0 likes · 52 min read
Unlocking Spring’s Core: A Deep Dive into the IOC Container Mechanics
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 27, 2025 · Fundamentals

Master 7 Essential Java Design Patterns with Real-World Spring Boot Examples

This article introduces seven core design patterns—Singleton, Factory, Builder, Strategy, Observer, Proxy, and Template—explaining their purpose, typical use cases, and providing complete Java code examples that integrate with Spring Boot 3 and Java 21, helping developers write cleaner, more maintainable software.

BuilderDesign PatternsSpring Boot
0 likes · 20 min read
Master 7 Essential Java Design Patterns with Real-World Spring Boot Examples
php Courses
php Courses
Jan 10, 2025 · Backend Development

Why Build a Custom PHP Framework and Course Outline

This article explains the motivations for creating a custom PHP framework—such as meeting specific project needs, learning opportunities, long‑term maintenance, performance optimization, ease of use, and security—and provides a detailed chapter‑by‑chapter outline of the accompanying tutorial.

Design PatternsMVCPHP
0 likes · 4 min read
Why Build a Custom PHP Framework and Course Outline
Java Architect Essentials
Java Architect Essentials
Jan 6, 2025 · Backend Development

Understanding API Gateways: Concepts, Design Principles, and Comparison of Popular Implementations

This article explains the fundamental concepts of API gateways, their role in decoupling clients from services, key design considerations such as routing, load balancing, resilience and security, and provides a detailed comparison of popular gateway solutions like OpenResty, Kong, Zuul, and Spring Cloud Gateway.

API GatewayDesign PatternsPerformance
0 likes · 27 min read
Understanding API Gateways: Concepts, Design Principles, and Comparison of Popular Implementations
Top Architect
Top Architect
Jan 4, 2025 · Backend Development

A Comprehensive Guide to Java Enums: Basics, Advanced Techniques, and Design Patterns

This article explains what Java enums are, why they are preferable to constants, demonstrates basic and custom enum definitions, shows how to compare, switch, and extend enums with properties, methods and constructors, and explores advanced uses such as EnumSet, EnumMap, Singleton and Strategy patterns, including Java 8 stream examples and JSON serialization.

Design PatternsEnumMapEnumSet
0 likes · 16 min read
A Comprehensive Guide to Java Enums: Basics, Advanced Techniques, and Design Patterns
Code Mala Tang
Code Mala Tang
Jan 3, 2025 · Fundamentals

How the Adapter Pattern Seamlessly Integrates PayPal and Stripe Payments

This article explains the Adapter design pattern, demonstrates step‑by‑step how to wrap existing PayPal payment code with a Stripe adapter in TypeScript, and discusses best practices, common pitfalls, and extensions such as factories and nested adapters for flexible payment integration.

Design PatternsObject-Oriented DesignPayment Integration
0 likes · 13 min read
How the Adapter Pattern Seamlessly Integrates PayPal and Stripe Payments
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 30, 2024 · Backend Development

Comprehensive Introduction to Domain-Driven Design (DDD)

This article provides a comprehensive overview of Domain-Driven Design (DDD), explaining its core principles, layered architecture, domain model components such as entities, value objects, aggregates, and bounded contexts, and includes Java code examples to illustrate implementation.

DDDDesign PatternsDomain-Driven Design
0 likes · 6 min read
Comprehensive Introduction to Domain-Driven Design (DDD)
BirdNest Tech Talk
BirdNest Tech Talk
Dec 29, 2024 · Fundamentals

Unlocking Distributed System Design: 20 Core Patterns Explained

This article distills the key design patterns behind distributed systems—covering replication, partitioning, consensus, and fault‑tolerance—by presenting each pattern’s problem statement, concrete solution, trade‑offs, and technical considerations, all illustrated with real‑world examples from projects like Kafka and Cassandra.

ConsensusDesign PatternsReplication
0 likes · 18 min read
Unlocking Distributed System Design: 20 Core Patterns Explained
php Courses
php Courses
Dec 24, 2024 · Backend Development

Implementing the Repository Pattern in Laravel: A Step‑by‑Step Guide

This guide explains the repository pattern for Laravel, detailing its benefits, step‑by‑step implementation for an e‑commerce product management module—including model, interface, repository, controller code—and offers best practices, caching tips, and common pitfalls to improve code structure, maintainability, and testability.

Design PatternsPHPbackend development
0 likes · 9 min read
Implementing the Repository Pattern in Laravel: A Step‑by‑Step Guide
Ubiquitous Tech
Ubiquitous Tech
Dec 17, 2024 · Backend Development

Refactoring E‑Commerce Login Using Strategy, Template, Chain‑of‑Responsibility & Decorator Patterns

The article examines how a growing e‑commerce login module becomes tangled with duplicated code and scattered logic, then demonstrates a step‑by‑step refactor using strategy‑factory, template method, chain‑of‑responsibility and decorator patterns to achieve clear responsibilities, extensibility, and easier maintenance.

Chain of ResponsibilityDecorator PatternDesign Patterns
0 likes · 18 min read
Refactoring E‑Commerce Login Using Strategy, Template, Chain‑of‑Responsibility & Decorator Patterns
Su San Talks Tech
Su San Talks Tech
Dec 11, 2024 · Fundamentals

8 Essential Design Patterns Every Java Developer Should Master

This article introduces eight core design patterns—Singleton, Factory, Strategy, Proxy, Observer, Decorator, Template Method, and Builder—explaining their concepts, providing Java code examples, and showing typical JDK and Spring framework usages to help developers write cleaner, more maintainable code.

BuilderDesign PatternsJava
0 likes · 12 min read
8 Essential Design Patterns Every Java Developer Should Master
Architect
Architect
Dec 8, 2024 · Backend Development

16 Essential Redis Patterns Every Backend Engineer Should Master

This article compiles sixteen practical Redis use‑cases—from caching and distributed locks to rate limiting, bitmaps, shopping carts, timelines, queues, likes, tags, filtering, follow/fan relationships, and leaderboards—providing code snippets and command examples to help backend developers design scalable systems.

Design PatternsRedisbackend
0 likes · 11 min read
16 Essential Redis Patterns Every Backend Engineer Should Master
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 7, 2024 · Backend Development

Online SQL-to-ER Diagram Tool: Features, Usage, and Implementation Details

This article introduces an online SQL-to-ER diagram tool, explains its advantages, provides step‑by‑step usage instructions, showcases example SQL and Java code for parsing and generating ER diagrams, and discusses the underlying design‑pattern architecture such as Strategy, Factory, Dependency Injection, and Singleton.

Design PatternsER diagramJava
0 likes · 17 min read
Online SQL-to-ER Diagram Tool: Features, Usage, and Implementation Details
php Courses
php Courses
Dec 6, 2024 · Backend Development

Best Practices for Object‑Oriented Programming in PHP

This article presents PHP object‑oriented programming best practices, covering class design, access modifiers, constructors, method chaining, and the Strategy pattern, each illustrated with clear code examples to improve readability, maintainability, and flexibility.

Design PatternsOOPPHP
0 likes · 5 min read
Best Practices for Object‑Oriented Programming in PHP
Top Architect
Top Architect
Nov 28, 2024 · Backend Development

A Comprehensive Guide to Java Enums: Basics, Advanced Usage, and Design Patterns

This article explains Java enums introduced in Java 5, shows how to define simple and complex enum types, demonstrates their use in comparisons, switch statements, collections like EnumSet and EnumMap, and illustrates applying enums to design patterns such as Singleton and Strategy, while providing practical code examples and JSON serialization techniques.

CollectionsDesign PatternsEnum
0 likes · 16 min read
A Comprehensive Guide to Java Enums: Basics, Advanced Usage, and Design Patterns
Java Backend Technology
Java Backend Technology
Nov 26, 2024 · Backend Development

How the Chain of Responsibility Pattern Simplifies Java Import Logic

This article explains the Chain of Responsibility design pattern, shows why a naïve nested‑if implementation is problematic, and demonstrates step‑by‑step refactorings—including abstract handlers and a factory‑based configuration—to create clean, maintainable Java backend code.

Chain of ResponsibilityDesign PatternsRefactoring
0 likes · 12 min read
How the Chain of Responsibility Pattern Simplifies Java Import Logic
21CTO
21CTO
Nov 20, 2024 · Frontend Development

Top 10 Modern JavaScript Patterns Shaping Development in 2025

This article explores ten cutting‑edge JavaScript patterns—from native pattern matching and immutable data to module federation and type‑first development—explaining how each enhances code readability, maintainability, and scalability as the ecosystem evolves toward 2025.

2025Design PatternsJavaScript
0 likes · 6 min read
Top 10 Modern JavaScript Patterns Shaping Development in 2025
DevOps
DevOps
Nov 19, 2024 · Backend Development

10 Common Interface Performance Optimization Techniques for Backend Development

This article presents ten widely applicable backend performance‑optimization strategies—including defensive validation, batch processing to eliminate N+1 queries, asynchronous execution, parallelism, caching, connection pooling, security hardening, compression, message‑queue decoupling, and design‑pattern reuse—each illustrated with Go code examples and practical case studies.

AsynchronousDesign PatternsValidation
0 likes · 30 min read
10 Common Interface Performance Optimization Techniques for Backend Development
Tencent Cloud Developer
Tencent Cloud Developer
Nov 19, 2024 · Backend Development

Ten Common Interface Performance Optimization Techniques

Ten practical techniques—early validation, batch queries, asynchronous processing, parallel execution, caching, connection pooling, response compression, message‑queue decoupling, security best practices, and reusable design patterns—collectively reduce latency, boost throughput, and improve scalability of high‑concurrency interfaces.

Asynchronous ProgrammingDesign PatternsGo
0 likes · 29 min read
Ten Common Interface Performance Optimization Techniques
Java Tech Enthusiast
Java Tech Enthusiast
Nov 14, 2024 · Backend Development

Comprehensive Backend Interview Q&A: Golang, Networking, OS, MySQL, Redis, Design Patterns, and Algorithms

The article presents recent tech-company salary figures and a comprehensive set of backend interview questions spanning Go language fundamentals, memory management, networking protocols, OS synchronization, MySQL transaction isolation and indexing, Redis performance, design‑pattern implementations, and classic algorithms such as quicksort.

AlgorithmsDatabaseDesign Patterns
0 likes · 11 min read
Comprehensive Backend Interview Q&A: Golang, Networking, OS, MySQL, Redis, Design Patterns, and Algorithms
php Courses
php Courses
Nov 12, 2024 · Backend Development

Best Practices for Object-Oriented Programming in PHP

This article presents PHP OOP best‑practice guidelines—including class design, access modifiers, constructors, method chaining, and the Strategy pattern—illustrated with clear code examples to improve readability, maintainability, and flexibility.

Design PatternsOOPPHP
0 likes · 4 min read
Best Practices for Object-Oriented Programming in PHP
Python Programming Learning Circle
Python Programming Learning Circle
Nov 6, 2024 · Fundamentals

Comprehensive Python Cheat Sheet and Advanced Topics Summary

This article compiles an extensive Python reference covering Python 2 vs 3 differences, essential and advanced libraries, concurrency models, language internals, testing techniques, design patterns, data structures, algorithms, networking basics, MySQL and Redis insights, Linux I/O models, and performance‑optimization strategies, all illustrated with practical code snippets.

Cheat SheetDesign PatternsLinux
0 likes · 31 min read
Comprehensive Python Cheat Sheet and Advanced Topics Summary
Sohu Tech Products
Sohu Tech Products
Oct 30, 2024 · Mobile Development

Design and Implementation of External Deep Linking (Return Flow) for Android Applications

The article presents a unified external deep‑linking (return flow) architecture for Android apps that consolidates all entry points into a single ActionActivity, standardizes URLs, employs a configurable protocol dispatcher, uses a chain‑of‑responsibility checker system with interruption recovery via CheckerActivity, thereby decoupling routing logic, eliminating duplication, and scaling complex navigation scenarios.

Android DevelopmentApp RoutingChain of Responsibility
0 likes · 18 min read
Design and Implementation of External Deep Linking (Return Flow) for Android Applications
IT Services Circle
IT Services Circle
Oct 20, 2024 · Backend Development

Huawei Campus Interview Experience and Technical Q&A: Java, MySQL, Redis, Design Patterns, and Networking Fundamentals

This article combines a Huawei campus recruitment overview—including interview timeline, salary grades, and interview process—with extensive technical Q&A covering Java vs C differences, Java features, OOP concepts, common design patterns, Redis and MySQL comparisons, MySQL transaction properties, B‑Tree indexes, list deduplication, stack implementations, and the low‑level workings of the ping command.

Data StructuresDesign PatternsJava
0 likes · 23 min read
Huawei Campus Interview Experience and Technical Q&A: Java, MySQL, Redis, Design Patterns, and Networking Fundamentals
Ubiquitous Tech
Ubiquitous Tech
Oct 9, 2024 · Backend Development

How to Build a Personal‑Contract Lantu Pay SDK: Design Patterns, Request Flow, and Implementation Details

This article continues the open‑source design series by detailing the remaining design points of the Lantu Pay SDK, including the end‑to‑end request chain, the Post method with retry support, the use of strategy and template method patterns, and a custom @Require annotation for mandatory parameter validation.

Design PatternsJavaSDK
0 likes · 8 min read
How to Build a Personal‑Contract Lantu Pay SDK: Design Patterns, Request Flow, and Implementation Details
Ubiquitous Tech
Ubiquitous Tech
Sep 24, 2024 · Backend Development

Designing a Spring Boot Starter for Lantu Pay’s Personal‑Sign‑Up SDK

This article walks through the design and implementation of a Spring Boot Starter for the Lantu Pay SDK that supports personal sign‑up, covering project structure, configuration classes, HTTP layer abstraction using strategy and template patterns, and request/response model design with concrete code examples.

Design PatternsJavaLantu Pay
0 likes · 8 min read
Designing a Spring Boot Starter for Lantu Pay’s Personal‑Sign‑Up SDK
Java Backend Full-Stack
Java Backend Full-Stack
Sep 21, 2024 · Backend Development

How a Full‑Stack Charging‑Station Project Can Boost Your Interview Portfolio

This article walks through a zero‑to‑one charging‑station system built with Spring Cloud microservices, Vue front‑end, and a suite of enterprise features such as distributed locks, idempotency, multi‑level caching, and custom starters, providing concrete design documents and module breakdowns to help candidates showcase real project experience in interviews.

Charging StationDesign PatternsMessage Queue
0 likes · 9 min read
How a Full‑Stack Charging‑Station Project Can Boost Your Interview Portfolio
Test Development Learning Exchange
Test Development Learning Exchange
Sep 20, 2024 · Fundamentals

Comprehensive Python Programming Guide: Data Types, Control Flow, Functions, OOP, and Advanced Features

This guide provides a thorough overview of Python programming, covering basic data types, control flow statements, function definitions, modules and packages, exception handling, file I/O, object‑oriented concepts, iterators, generators, context managers, decorators, functional programming, asynchronous code, metaclasses, standard and third‑party libraries, type annotations, design patterns, and practical tips such as enums and dataclasses.

Async ProgrammingDesign PatternsProgramming Fundamentals
0 likes · 19 min read
Comprehensive Python Programming Guide: Data Types, Control Flow, Functions, OOP, and Advanced Features
Ubiquitous Tech
Ubiquitous Tech
Sep 19, 2024 · Backend Development

Exploring wxjava: A Deep Dive into the Open‑Source WeChat SDK Design Process

This article walks through the wxjava open‑source Java SDK for WeChat, detailing its starter pattern, configuration handling, request/response modeling, token management, custom annotations, duplicate‑message checkers, and the design patterns employed, offering concrete code examples to help readers master SDK design.

Design PatternsJava SDKWeChat
0 likes · 18 min read
Exploring wxjava: A Deep Dive into the Open‑Source WeChat SDK Design Process
Ubiquitous Tech
Ubiquitous Tech
Sep 12, 2024 · Backend Development

How the wxjava Spring Boot Starter Is Designed – Open Source SDK Insights

This article examines the wxjava open‑source Java SDK for WeChat, focusing on its Spring Boot Starter design, modular architecture, key configuration and service classes, code examples, and the design patterns it employs, offering developers a concrete roadmap for learning and extending the SDK.

Design PatternsJava SDKModular Design
0 likes · 18 min read
How the wxjava Spring Boot Starter Is Designed – Open Source SDK Insights
Ubiquitous Tech
Ubiquitous Tech
Sep 11, 2024 · Backend Development

How to Apply for a Personal‑Signed Payment Platform and Master Payment Integration

This article walks through why real payment integration matters for C‑end projects and resumes, introduces the Blue Rabbit personal‑signing platform, details the step‑by‑step application, verification, fee payment, merchant activation, and provides Java SDK design patterns and code samples for integrating the API.

APIBlue RabbitDesign Patterns
0 likes · 19 min read
How to Apply for a Personal‑Signed Payment Platform and Master Payment Integration
Top Architect
Top Architect
Sep 6, 2024 · Backend Development

14 Java Backend Code‑Optimization Tips from a Senior Architect

This article presents fourteen practical Java backend optimization techniques—including configuration‑file management, Lombok’s @RequiredArgsConstructor, modular code design, exception handling, reducing DB queries, avoiding null returns, minimizing if‑else, slimming controllers, IDE shortcuts, source‑code reading, design patterns, and efficient collections—each illustrated with clear code examples.

Design PatternsJavaLombok
0 likes · 10 min read
14 Java Backend Code‑Optimization Tips from a Senior Architect
Sohu Tech Products
Sohu Tech Products
Sep 5, 2024 · Backend Development

Understanding Dubbo's Microkernel Architecture

Dubbo’s microkernel architecture isolates only essential core functions—service invocation, clustering, and routing—while delegating all other capabilities to dynamically loaded extensions via its advanced SPI mechanism, which scans META‑INF files, supports precise lookups, dependency injection, bytecode generation, and hierarchical extension points, enabling flexible, modular, and fault‑tolerant RPC services.

Design PatternsDubboRPC Framework
0 likes · 13 min read
Understanding Dubbo's Microkernel Architecture
21CTO
21CTO
Sep 4, 2024 · Backend Development

How to Refactor Complex if‑else Chains in Java: Enums, Factories & Strategies

This article explains why excessive if‑else statements increase cost and complexity in Java applications and demonstrates several refactoring techniques—including enums, the factory pattern, the strategy pattern, and Stream API maps—to produce cleaner, more maintainable code.

Design PatternsEnumJava
0 likes · 10 min read
How to Refactor Complex if‑else Chains in Java: Enums, Factories & Strategies
Cognitive Technology Team
Cognitive Technology Team
Sep 1, 2024 · Fundamentals

Fundamental Design Patterns, Layered Architecture, and Concurrency Principles for Enterprise Applications

The article explains core software design patterns, the benefits and pitfalls of layered architecture, essential database and transaction practices, and concurrency control techniques such as isolation, immutability, optimistic and pessimistic locking, guiding developers to build robust enterprise systems.

Design PatternsTransactionslayered architecture
0 likes · 10 min read
Fundamental Design Patterns, Layered Architecture, and Concurrency Principles for Enterprise Applications
Architect
Architect
Aug 30, 2024 · Backend Development

How to Streamline Contract Signing Using Strategy, Chain‑of‑Responsibility, and Annotations

This article walks through a Java Spring‑Boot implementation of a contract‑signing workflow, explains the original chain‑of‑responsibility design, shows its limitations, and demonstrates how to replace manual bean wiring with a strategy‑based annotation and enum configuration for flexible node management.

Chain of ResponsibilityContract SigningDesign Patterns
0 likes · 15 min read
How to Streamline Contract Signing Using Strategy, Chain‑of‑Responsibility, and Annotations
JD Tech
JD Tech
Aug 16, 2024 · Fundamentals

Refactoring: Concepts, Boundaries, Timing, Practices, and Techniques

This article explains the philosophy and practical steps of software refactoring, covering its definition, scope, when and why to refactor, systematic processes, risk management, and a catalog of common refactoring techniques illustrated with Java code examples.

Design PatternsRefactoringsoftware engineering
0 likes · 26 min read
Refactoring: Concepts, Boundaries, Timing, Practices, and Techniques
Java Interview Crash Guide
Java Interview Crash Guide
Aug 13, 2024 · Backend Development

How to Build a Robust Asynchronous Processing SDK with Spring and Kafka

This article explains the design, advantages, and implementation details of a generic asynchronous processing SDK that leverages Spring transactional events, Kafka messaging, XXL‑Job scheduling, and a non‑intrusive architecture to ensure data consistency, fault tolerance, and easy integration across services.

Design PatternsKafkaSpring
0 likes · 11 min read
How to Build a Robust Asynchronous Processing SDK with Spring and Kafka
Senior Tony
Senior Tony
Aug 13, 2024 · Fundamentals

How to Refactor Course Display Logic with the Decorator Pattern in Java

This article demonstrates how to identify long‑method and duplicated code smells in a Java curriculum‑display service and refactor the implementation using the Decorator pattern, providing clear component diagrams, full code examples, and a runnable demo that showcases flexible extensions for different course types.

Bad SmellDecorator PatternDesign Patterns
0 likes · 11 min read
How to Refactor Course Display Logic with the Decorator Pattern in Java
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 PatternsRefactoringStrategy Pattern
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 PatternsOpen-Closed PrincipleStrategy Pattern
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.

Design PatternsGoKubernetes
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.

Design PatternsJavaadapter
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.

Design PatternsJavabackend
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 PatternsPerformancebest-practices
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.

Design PatternsFactory PatternSoftware Architecture
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 PatternsDomain-Driven Design
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.

Behavioral PatternsCreational PatternsDesign Patterns
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 PatternsMonitoringRefactoring
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 PatternsEloquentObserver Pattern
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.

Design PatternsMQbackend
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.

ConstructorsDesign PatternsKotlin
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.

BuilderChain of ResponsibilityDesign Patterns
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.

Design PatternsJavaLogging
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.

Data MigrationDesign PatternsJava
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.

APIDesign PatternsPython
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
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.

Design PatternsGinGo
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.

BuilderDesign PatternsFactory Pattern
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.

Chain of ResponsibilityDesign PatternsJava
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 PatternsModel Evaluation
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.

Design PatternsOOPconcurrency
0 likes · 19 min read
Master Java Fundamentals: OOP, Collections, Concurrency, and Design Patterns