BestHub
Sign in
Tagged articles

Design Patterns

943 articles · Page 4 of 10
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 PatternsSpringWorkflow
0 likes · 20 min read
State Machine Integration for New Product Onboarding
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.

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

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

Design PatternsIoCSoftware Architecture
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.

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

Design Patternsbackend architecturedistributed 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.

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

Design PatternsInterviewJava
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 PatternsRefactoringStrategy Pattern
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 FactoryDesign PatternsKotlin
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.

DDDDesign PatternsDomain-Driven Design
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.

Chain of ResponsibilityDesign PatternsFactory Pattern
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.

Behavioral PatternsCode ArchitectureCreational Patterns
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 PatternsHigh CohesionJava
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.

Code RefactoringDesign PatternsJava
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.

Design PatternsMVCPHP
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 PatternsHooksJavaScript
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.

Design PatternsPHPadapter
0 likes · 7 min read
Common Design Patterns in PHP: Singleton, Factory, Observer, and Adapter
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.

Code RefactoringDesign PatternsEnum
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 PatternsSoftware Architecturecloud-native
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.

Backend IntegrationDesign PatternsE‑Commerce APIs
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 ResponsibilityDesign PatternsJava
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 WorkflowState Pattern
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 PatternsJava
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 PatternsModularizationarchitecture
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 LogicCode RefactoringDesign 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.

Design PatternsEffective JavaJava
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 ResponsibilityDesign PatternsJava
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.

Design PatternsJavaObject Cloning
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 PatternsFactory MethodJava
0 likes · 8 min read
Factory Method Pattern: Definition, Structure, Implementation, Advantages, and Use Cases
php Courses
php Courses
Nov 17, 2023 · Fundamentals

Using the Strategy Pattern in PHP to Send Notifications

An overview of the Strategy design pattern demonstrates how to encapsulate notification-sending algorithms in independent PHP classes, allowing runtime selection among email, SMS, or FCM implementations without modifying client code, and highlights benefits such as flexibility, reusability, and testability.

Design PatternsNotificationPHP
0 likes · 5 min read
Using the Strategy Pattern in PHP to Send Notifications
Ubiquitous Tech
Ubiquitous Tech
Nov 10, 2023 · Backend Development

Java: Elegant Sitemap Generation Using 4 Design Patterns and the Open/Closed Principle

This article demonstrates how to generate website sitemap.xml files in Java by combining four design patterns—Strategy, Factory, Template Method, and Builder—along with the Open/Closed Principle, providing extensible, maintainable code illustrated with enums, configuration classes, and concrete implementations.

Design PatternsFactory PatternJava
0 likes · 16 min read
Java: Elegant Sitemap Generation Using 4 Design Patterns and the Open/Closed Principle
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 6, 2023 · Fundamentals

Seven Fundamental Design Principles Behind Design Patterns

This article provides a comprehensive overview of design patterns by first explaining the seven core design principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, and others—detailing their definitions, benefits, UML diagrams, practical examples, and offering a downloadable PDF for deeper study.

Design PatternsSOLIDSoftware Architecture
0 likes · 12 min read
Seven Fundamental Design Principles Behind Design Patterns
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 6, 2023 · Fundamentals

Fundamental OOP Concepts and Design Patterns in Java

This article explains core object‑oriented concepts such as encapsulation, abstraction, inheritance and polymorphism, then details common design principles and a wide range of design patterns—including factory, builder, bridge, singleton, strategy, adapter, and proxy—illustrated with complete Java code examples and usage guidelines.

Design PatternsJavaOOP
0 likes · 23 min read
Fundamental OOP Concepts and Design Patterns in Java
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 4, 2023 · Fundamentals

Understanding the Composite Reuse Principle (CRP): Concepts, Benefits, UML, and Implementation Examples

This article provides a comprehensive explanation of the Composite Reuse Principle (CRP), covering its definition, background, advantages over inheritance, UML representation, practical Java code examples, and guidelines for choosing between composition and inheritance in object‑oriented design.

Composite Reuse PrincipleComposition over InheritanceDesign Patterns
0 likes · 11 min read
Understanding the Composite Reuse Principle (CRP): Concepts, Benefits, UML, and Implementation Examples
Architect's Guide
Architect's Guide
Nov 4, 2023 · Backend Development

Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping

This article explains how to reduce repetitive Java backend code by extracting common logic into abstract classes, applying the Template Method and Factory patterns, using custom annotations with reflection for API serialization, and leveraging bean‑mapping utilities to copy properties between DTOs and DOs.

Code RefactoringDesign PatternsJava
0 likes · 21 min read
Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping
DaTaobao Tech
DaTaobao Tech
Nov 3, 2023 · Fundamentals

Mastering the Strategy Pattern: From Simple IF‑ELSE to Scalable Design

This article explains why hard‑coded if‑else logic hinders extensibility, introduces the Strategy pattern, shows its structure and Java implementation for data synchronization, then enhances the design with a Factory to decouple object creation, concluding with best‑practice recommendations.

Design PatternsFactory PatternJava
0 likes · 8 min read
Mastering the Strategy Pattern: From Simple IF‑ELSE to Scalable Design
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 2, 2023 · Fundamentals

Understanding the Proxy Design Pattern with Java Examples

This article explains the Proxy design pattern, illustrates its core participants with clear Chinese idiom analogies, and provides a complete static‑proxy implementation in Java—including interface, real subject, proxy class, and client code—while also noting the distinction between static and dynamic proxies.

Design PatternsJavaProxy Pattern
0 likes · 6 min read
Understanding the Proxy Design Pattern with Java Examples
Test Development Learning Exchange
Test Development Learning Exchange
Oct 29, 2023 · Fundamentals

Common Design Patterns in Python

This article lists and briefly explains fifteen common Python design patterns, including Singleton, Factory, Abstract Factory, Builder, Prototype, Adapter, Decorator, Proxy, Observer, Strategy, Template Method, Iterator, Chain of Responsibility, Command, and State, helping developers understand their purposes and usage.

Design PatternsPythonSoftware Architecture
0 likes · 4 min read
Common Design Patterns in Python
Test Development Learning Exchange
Test Development Learning Exchange
Oct 25, 2023 · Fundamentals

Understanding the Command Pattern with Python Examples

This article explains the Command design pattern, describes its key participants and advantages, and provides five Python examples demonstrating command encapsulation, undo/redo functionality, file operations, shopping‑cart management, and menu handling to illustrate how the pattern decouples request senders from receivers.

Command PatternDecouplingDesign Patterns
0 likes · 9 min read
Understanding the Command Pattern with Python Examples
Java Architect Essentials
Java Architect Essentials
Oct 23, 2023 · Backend Development

Design Patterns Employed in the MyBatis Framework

This article analyzes the MyBatis source code, illustrating how it applies a variety of design patterns—including Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—to solve complex architectural challenges and improve modularity, extensibility, and maintainability.

Design PatternsFactory PatternJava
0 likes · 8 min read
Design Patterns Employed in the MyBatis Framework
Architects Research Society
Architects Research Society
Oct 23, 2023 · Fundamentals

Applying EA Principles in Enterprise Technology Architecture

The article explains how enterprise architecture (EA) principles and design architecture principles (DAPs) should be defined, prioritized, and linked to business goals to guide technical standards, overcome resistance, and drive effective governance and behavioral change within organizations.

Design PatternsGovernanceenterprise architecture
0 likes · 8 min read
Applying EA Principles in Enterprise Technology Architecture
Test Development Learning Exchange
Test Development Learning Exchange
Oct 22, 2023 · Fundamentals

Master 10 Essential Python Design Patterns with Ready-to-Run Code

This article introduces ten classic software design patterns—Singleton, Factory, Observer, Strategy, Adapter, Builder, Prototype, Decorator, Template Method, and Facade—explaining their purpose, structure, and providing complete Python code examples that demonstrate how to implement and apply each pattern in real projects.

CreationalDesign PatternsSoftware Architecture
0 likes · 9 min read
Master 10 Essential Python Design Patterns with Ready-to-Run Code
Java Captain
Java Captain
Oct 7, 2023 · Backend Development

Understanding Java Dynamic Proxies: Principles, Implementation, and Use Cases

This article explains the principles behind Java dynamic proxies, demonstrates how to implement them using interfaces, InvocationHandler, and Proxy classes, and outlines common application scenarios such as logging, transaction management, and access control, helping developers extend object behavior at runtime.

Design PatternsDynamic ProxyInvocationHandler
0 likes · 5 min read
Understanding Java Dynamic Proxies: Principles, Implementation, and Use Cases
Selected Java Interview Questions
Selected Java Interview Questions
Oct 5, 2023 · Backend Development

Design Patterns Employed in the MyBatis Framework

The MyBatis source code, spanning over twenty thousand lines, extensively applies creational, structural, and behavioral design patterns—such as Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—to decouple complex scenarios and illustrate advanced backend architecture practices.

Design PatternsJavaMyBatis
0 likes · 7 min read
Design Patterns Employed in the MyBatis Framework
Code Ape Tech Column
Code Ape Tech Column
Oct 2, 2023 · Backend Development

Design Patterns Used in the MyBatis Framework

This article reviews the various design patterns—creational, structural, and behavioral—employed within MyBatis's source code, illustrating each pattern with diagrams and explaining their roles in simplifying factory creation, singleton configuration, builders, adapters, proxies, decorators, templates, strategies, and iterators.

Design PatternsFactory PatternMyBatis
0 likes · 12 min read
Design Patterns Used in the MyBatis Framework
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 26, 2023 · Fundamentals

Understanding the Strategy Pattern in JavaScript

This article explains the Strategy design pattern, demonstrates its implementation in JavaScript through three code versions, discusses the drawbacks of naïve if‑else approaches, and outlines the pattern's advantages and disadvantages for creating flexible, maintainable code.

Design PatternsJavaScriptRefactoring
0 likes · 6 min read
Understanding the Strategy Pattern in JavaScript
Java High-Performance Architecture
Java High-Performance Architecture
Sep 23, 2023 · Backend Development

From JDBC to MyBatis: Why Java Persistence Evolved and How to Optimize It

This article walks through the step‑by‑step JDBC query process, explains why wrapping JDBC in a framework like MyBatis is beneficial, analyzes MyBatis’s core components and execution flow, and presents five practical optimizations—from connection pooling to dynamic SQL and result caching—to improve Java backend performance.

Connection PoolingDesign PatternsJDBC
0 likes · 35 min read
From JDBC to MyBatis: Why Java Persistence Evolved and How to Optimize It
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 20, 2023 · Fundamentals

Observer Design Pattern in Java: Concepts, UML, and Full Code Example

This article explains the Observer behavioral design pattern, describes its participants, illustrates a real‑world e‑commerce scenario, and provides complete Java code for the observer interface, subject interface, concrete subject, concrete observers, and a test client, concluding with the pattern’s benefits.

Design PatternsJavaObserver Pattern
0 likes · 7 min read
Observer Design Pattern in Java: Concepts, UML, and Full Code Example
macrozheng
macrozheng
Sep 11, 2023 · Backend Development

Mastering Code Refactoring: From Repetition to Design Patterns in Java

This article walks through a step‑by‑step refactoring of repetitive Java code, illustrating how to extract common methods, use reflection, apply generics with lambda expressions, leverage inheritance and the template method pattern, and finally combine factory, template, and strategy patterns into a clean, reusable solution.

Design PatternsFactory PatternJava
0 likes · 13 min read
Mastering Code Refactoring: From Repetition to Design Patterns in Java
Top Architect
Top Architect
Sep 7, 2023 · Backend Development

From JDBC to MyBatis: Evolution, Design, and Optimization of the Persistence Layer

This article explains how JDBC evolves into MyBatis, detailing the seven-step JDBC query process, the motivations for encapsulating JDBC, MyBatis architecture, core components, initialization mechanisms, design patterns, and code examples, while offering optimization strategies for connection handling, SQL management, and result mapping.

Design PatternsJDBCMyBatis
0 likes · 39 min read
From JDBC to MyBatis: Evolution, Design, and Optimization of the Persistence Layer
Architecture Digest
Architecture Digest
Sep 1, 2023 · Backend Development

Replacing if‑else with Strategy Pattern and Map‑Based Functional Interfaces in a Java Coupon Service

The article demonstrates how to refactor a Java coupon‑distribution service by first applying the Strategy design pattern and then using a Map of lambda expressions to replace bulky if‑else or switch statements, improving maintainability and readability while discussing their respective trade‑offs.

Design PatternsFunctional InterfaceJava
0 likes · 7 min read
Replacing if‑else with Strategy Pattern and Map‑Based Functional Interfaces in a Java Coupon Service
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 31, 2023 · Fundamentals

JavaScript Design Patterns: Factory Method, Abstract Factory, Singleton, Builder, Prototype and More

This article introduces JavaScript design patterns—covering creational, structural, and behavioral categories—and provides clear explanations and complete code examples for patterns such as Factory Method, Abstract Factory, Singleton, Builder, Prototype, Adapter, Decorator, Proxy, Facade, Bridge, Composite, Flyweight, Strategy, Template Method, Observer, Iterator, Chain of Responsibility, Command, Memento, State, Visitor, Mediator and Interpreter, helping developers write cleaner, more maintainable code.

BuilderDesign PatternsFactory Method
0 likes · 35 min read
JavaScript Design Patterns: Factory Method, Abstract Factory, Singleton, Builder, Prototype and More
Architect
Architect
Aug 29, 2023 · Fundamentals

Understanding AOP: From Joinpoint Design to Spring’s Dynamic Weaving

This article analyzes AOP’s origins, defines join points and cross‑cutting logic, designs interfaces based on the AOP Alliance specifications, and compares static versus dynamic weaving approaches, illustrating each step with Java code examples and diagrams to show how Spring implements AOP.

AOPDesign PatternsDynamic Weaving
0 likes · 10 min read
Understanding AOP: From Joinpoint Design to Spring’s Dynamic Weaving
Top Architect
Top Architect
Aug 23, 2023 · Backend Development

Understanding API Gateways: Concepts, Design Principles, and Common Implementations

This article explains what an API gateway is, why it is needed in micro‑service architectures, outlines key design considerations such as routing, load‑balancing, resilience and security, and compares popular open‑source gateway solutions like OpenResty, Kong, Zuul and Spring Cloud Gateway.

API GatewayDesign Patternsload balancing
0 likes · 26 min read
Understanding API Gateways: Concepts, Design Principles, and Common Implementations
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 18, 2023 · Fundamentals

Understanding the Strategy Design Pattern with Java Examples

This article explains the Strategy design pattern, its definition, structure, and how to refactor a typical e‑commerce discount calculation in Java using interfaces, concrete strategy classes, and a context, highlighting benefits, drawbacks, and best‑practice considerations.

Design PatternsJavaSoftware Architecture
0 likes · 9 min read
Understanding the Strategy Design Pattern with Java Examples
Selected Java Interview Questions
Selected Java Interview Questions
Aug 17, 2023 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Java Examples

This article introduces the Chain of Responsibility design pattern, explains its purpose and typical use cases, demonstrates common pitfalls with a naïve implementation, and provides step‑by‑step Java refactorings—including a basic chain, an abstract handler hierarchy, and a factory‑based configuration—to illustrate how to build flexible, maintainable processing pipelines.

Chain of ResponsibilityDesign PatternsJava
0 likes · 11 min read
Understanding the Chain of Responsibility Design Pattern with Java Examples
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 16, 2023 · Backend Development

Refactoring the Game Account Order Process with a Three‑Layer Interface and Strategy‑Template Pattern

This article describes how a game‑account order system with scattered core code and no design patterns was refactored into a clean three‑layer interface architecture using a strategy‑template approach, detailing the design, implementation, testing, gray‑release strategy, and post‑deployment safeguards.

Design PatternsJavaRefactoring
0 likes · 12 min read
Refactoring the Game Account Order Process with a Three‑Layer Interface and Strategy‑Template Pattern
ByteFE
ByteFE
Aug 2, 2023 · Fundamentals

Understanding Dependency Injection and Inversion of Control with TypeScript

This article explains the concepts of Inversion of Control and Dependency Injection, demonstrates how to implement a lightweight DI container in TypeScript using decorators and reflection, and covers advanced features such as provider registration, abstraction, lazy loading, and handling circular dependencies.

Design PatternsIOC ContainerInversion of Control
0 likes · 35 min read
Understanding Dependency Injection and Inversion of Control with TypeScript