BestHub
Sign in
Tagged articles
853 articles
Page 3 of 9
Architect
Architect
Jul 11, 2024 · Backend Development

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

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

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

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

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

Design PatternsFactory PatternJava
0 likes · 20 min read
Java Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template Method, Adapter and More
php Courses
php Courses
Jun 27, 2024 · Backend Development

Observer Design Pattern in Laravel: Concepts and Implementation

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

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

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

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

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

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

Why Build a Custom PHP Framework and What It Can Achieve

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

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

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

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

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

Decoupling Gin Handlers with Dependency Injection in Go

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

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.

AdapterBackend DevelopmentBuilder
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.

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

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

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

AI AgentDesign PatternsLarge Language Model
0 likes · 7 min read
Summary of Andrew Ng’s AI Agent Talk: Models, Workflows, and Design Patterns
Ops Development & AI Practice
Ops Development & AI Practice
May 1, 2024 · Fundamentals

Mastering DTOs: Design Principles and Best Practices for Layered Architecture

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

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

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

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

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

State Machine Integration for New Product Onboarding

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

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

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

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

Backend DevelopmentCode RefactoringDesign Patterns
0 likes · 12 min read
How a Strategy Factory Refactors Complex HSF Checks for Cleaner Backend Code
Architect's Guide
Architect's Guide
Apr 19, 2024 · Backend Development

API Gateway Design and Best Practices for Microservice Architectures

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

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

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

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

Best PracticesCode OptimizationDesign Patterns
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 PatternsFrontend DevelopmentIoC
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.

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

Mastering Redis Client Integration in Go with the Adapter Pattern

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

Adapter PatternBackend DevelopmentDesign Patterns
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
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 PatternsGoInterface
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
Architect
Architect
Mar 21, 2024 · Backend Development

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

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

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

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

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

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

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

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

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 PatternsCreational PatternsDesign 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.

Backend DevelopmentDesign PatternsHigh Cohesion
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.

Backend DevelopmentCode RefactoringDesign Patterns
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 PatternsFrameworkMVC
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 ConsistencyDesign PatternsMySQL
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.

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

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

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

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

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

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

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.

Adapter PatternBackend IntegrationDesign Patterns
0 likes · 9 min read
Adapter Design Pattern for Integrating Multiple E‑Commerce APIs in PHP
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.

Backend DevelopmentCode ExampleDesign Patterns
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.

AOPBackend DevelopmentDesign Patterns
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 PatternsIdempotency
0 likes · 23 min read
Implementing API Idempotency Checks with Design Patterns in Java
Watermelon Video Tech Team
Watermelon Video Tech Team
Dec 12, 2023 · Mobile Development

A Guide to the Architecture Design Process for Mobile Applications

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

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

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

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

AND/OR LogicCode RefactoringDesign Patterns
0 likes · 8 min read
Design and Implementation of a Java Rule Engine with AND/OR Logic
Goodme Frontend Team
Goodme Frontend Team
Dec 4, 2023 · Frontend Development

How Design Systems Empower Frontend Teams: Principles, Patterns, and Practices

This article explains what a design system is, how design patterns and shared design language work together, the role of pattern libraries, effective design principles, and a practical case study, offering frontend developers a comprehensive guide to building cohesive, user‑focused interfaces.

Design PatternsDesign SystemFrontend Development
0 likes · 26 min read
How Design Systems Empower Frontend Teams: Principles, Patterns, and Practices
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 27, 2023 · Fundamentals

27 Essential Java Programming Principles from Effective Java

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

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

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

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

Chain of 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.

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

AdapterDesign PatternsFactory
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.

Code ReuseComposite Reuse PrincipleComposition over Inheritance
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 PatternsFactoryPython
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.

Backend DevelopmentDesign PatternsFactory Pattern
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 PatternsEnterprise ArchitectureGovernance
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.

Backend DevelopmentDesign PatternsJava
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.

Backend DevelopmentDesign PatternsFactory Pattern
0 likes · 12 min read
Design Patterns Used in the MyBatis Framework
Java Architect Essentials
Java Architect Essentials
Sep 29, 2023 · Backend Development

Why Lombok @Builder Is Discouraged and @Accessors Is a Better Alternative

The article explains the pitfalls of Lombok's @Builder annotation—such as loss of required‑parameter enforcement, mutable builders, and limited flexibility—and demonstrates how using @Accessors (or manually crafted fluent setters) provides a safer, more expressive way to construct Java objects.

AccessorsBackend DevelopmentBuilder
0 likes · 10 min read
Why Lombok @Builder Is Discouraged and @Accessors Is a Better Alternative
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 PatternsJavaScriptSoftware Architecture
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