Tagged articles

Design Patterns

943 articles · Page 9 of 10

Feb 6, 2020 · Backend Development

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

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

C++Design PatternsRefactoring

0 likes · 18 min read

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

Programmer DD

Jan 11, 2020 · Fundamentals

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

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

Design PatternsJavaLambda

0 likes · 16 min read

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

Programmer DD

Jan 10, 2020 · Backend Development

How MyBatis Leverages 9 Classic Design Patterns

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

Design PatternsJavaMyBatis

0 likes · 23 min read

How MyBatis Leverages 9 Classic Design Patterns

Java Captain

Dec 25, 2019 · Backend Development

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

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

Design PatternsJSR-303JSR-305

0 likes · 13 min read

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

58 Tech

Dec 13, 2019 · Mobile Development

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

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

AndroidComponentizationDesign Patterns

0 likes · 16 min read

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

Architect's Tech Stack

Dec 13, 2019 · Backend Development

Comprehensive Java Interview Guide and Preparation Checklist

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

Design PatternsJVMinterview

0 likes · 9 min read

Comprehensive Java Interview Guide and Preparation Checklist

Alibaba Cloud Developer

Nov 7, 2019 · Fundamentals

Why Interfaces Matter: Standards, Abstraction, and Dependency Inversion Explained

This article explains the strategic benefits of using interfaces in software design—standardization, abstraction, and decoupling—illustrates when and why to apply them, and shows how the Dependency Inversion Principle enables flexible, testable, and maintainable architectures.

API standardsDependency InversionDesign Patterns

0 likes · 11 min read

Why Interfaces Matter: Standards, Abstraction, and Dependency Inversion Explained

Architecture Digest

Nov 1, 2019 · Fundamentals

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

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

Design PatternsDomain-Driven DesignSOLID

0 likes · 21 min read

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

Java Captain

Oct 31, 2019 · Backend Development

Eliminating Complex if‑else Logic with Strategy and Factory Patterns in Spring

This article explains how to replace tangled if‑else statements in business code with the Strategy and Factory design patterns, demonstrates their implementation in Java and Spring, and shows how to register strategy beans to improve readability and maintainability.

Design PatternsFactory PatternJava

0 likes · 11 min read

Eliminating Complex if‑else Logic with Strategy and Factory Patterns in Spring

Full-Stack Internet Architecture

Oct 30, 2019 · Backend Development

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

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

Design PatternsFactory PatternJava

0 likes · 12 min read

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

21CTO

Oct 9, 2019 · Fundamentals

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

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

C++Design PatternsMemory Management

0 likes · 13 min read

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

Python Programming Learning Circle

Sep 25, 2019 · Fundamentals

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

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

C++Design Patternsbest practices

0 likes · 8 min read

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

ITFLY8 Architecture Home

Sep 24, 2019 · Fundamentals

Unlocking Architecture Secrets: How to Learn from Classic Source Code

This article explores how reading classic source code, from SPI implementations to framework internals, can reveal architectural principles, offering a three‑level approach to deepen understanding, extract universal patterns, and apply them to design scalable, extensible systems.

Design PatternsFrameworksSPI

0 likes · 13 min read

Unlocking Architecture Secrets: How to Learn from Classic Source Code

Programmer DD

Sep 23, 2019 · Fundamentals

Mastering SOLID: Real‑World Java Examples for Clean Code

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

Design PatternsJavaOOP principles

0 likes · 10 min read

Mastering SOLID: Real‑World Java Examples for Clean Code

Architect's Tech Stack

Sep 20, 2019 · Backend Development

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

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

Design PatternsMyBatisSoftware Architecture

0 likes · 18 min read

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

Architecture Digest

Sep 19, 2019 · Fundamentals

Design and Implementation of a Multi‑Layered Basic Framework Architecture

The article outlines the background, design principles, layered implementation details, and optimization considerations of a reusable, extensible basic framework architecture that separates business, functional, UI, and support layers to reduce coupling and accelerate app development.

Design PatternsModular Designarchitecture

0 likes · 7 min read

Design and Implementation of a Multi‑Layered Basic Framework Architecture

360 Tech Engineering

Sep 17, 2019 · Mobile Development

Design and Implementation of a Modular Mobile Application Framework

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

AndroidDesign PatternsModular Architecture

0 likes · 9 min read

Design and Implementation of a Modular Mobile Application Framework

Python Programming Learning Circle

Sep 17, 2019 · Backend Development

How to Future‑Proof Your Java Career: Skills Every Backend Engineer Must Master

A 25‑year‑old Beijing Java developer reflects on stagnation and offers a detailed learning roadmap—including source‑code reading, distributed and microservice architectures, concurrency, performance tuning, and design patterns—to avoid being eliminated and secure a lasting technical career.

Design PatternsJavabackend

0 likes · 7 min read

How to Future‑Proof Your Java Career: Skills Every Backend Engineer Must Master

ITFLY8 Architecture Home

Sep 14, 2019 · Fundamentals

Unlocking Software Design Patterns: Complete Series Outline & Roadmap

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

Design PatternsJavaSoftware Architecture

0 likes · 5 min read

Unlocking Software Design Patterns: Complete Series Outline & Roadmap

Big Data Technology & Architecture

Sep 13, 2019 · Backend Development

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

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

Design PatternsJVMJava

0 likes · 12 min read

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

System Architect Go

Aug 28, 2019 · Fundamentals

Master Software Design Patterns: Creational, Structural & Behavioral Basics

This article introduces the core concepts of software design patterns, explaining the three main categories—creational, structural, and behavioral—through concise definitions, real‑world analogies, and code examples to help developers build more reusable and robust systems.

BehavioralCreationalDesign Patterns

0 likes · 9 min read

Master Software Design Patterns: Creational, Structural & Behavioral Basics

Qunar Tech Salon

Aug 8, 2019 · Frontend Development

Understanding Design Patterns in JavaScript

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

Design PatternsJavaScriptModule Pattern

0 likes · 14 min read

Understanding Design Patterns in JavaScript

Programmer DD

Jul 24, 2019 · Backend Development

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

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

Bean LifecycleConfigurationDesign Patterns

0 likes · 25 min read

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

Java Backend Technology

Jul 15, 2019 · Backend Development

Master Java Proxy Patterns: From Static to Dynamic and MyBatis Integration

This article explains static and dynamic proxy patterns in Java, demonstrates how to use them for recording service response times, and shows how MyBatis leverages dynamic proxies to generate mapper implementations, complete with UML diagrams and sample code.

Design PatternsDynamic ProxyJava

0 likes · 5 min read

Master Java Proxy Patterns: From Static to Dynamic and MyBatis Integration

Big Data Technology & Architecture

Jun 25, 2019 · Fundamentals

Refactoring Nested If‑Else Statements with Design Patterns in Java

This article examines the problems of deeply nested if‑else statements in Java code and demonstrates how to replace them with cleaner alternatives such as the Factory pattern, enums, the Command pattern, and a simple rule engine, improving readability and maintainability.

Command PatternDesign PatternsFactory Pattern

0 likes · 9 min read

Refactoring Nested If‑Else Statements with Design Patterns in Java

Full-Stack Internet Architecture

Jun 5, 2019 · Fundamentals

Open‑Closed Principle Explained with a Hospital Billing Example

This article explains the Open‑Closed Principle of design patterns, illustrates it with Java code that models a hospital’s medicine‑selling process, compares naive and extensible implementations, and shows how to keep software open for extension while closed for modification.

Design PatternsJavaOOP

0 likes · 9 min read

Open‑Closed Principle Explained with a Hospital Billing Example

Java Captain

May 29, 2019 · Backend Development

Common Design Patterns Used in the Spring Framework

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

AOPDesign PatternsIoC

0 likes · 17 min read

Common Design Patterns Used in the Spring Framework

Programmer DD

May 28, 2019 · Backend Development

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

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

Design PatternsJavaSpring

0 likes · 3 min read

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

ITFLY8 Architecture Home

May 13, 2019 · Fundamentals

Mastering Software Architecture: Methodologies, Principles, and Patterns

This comprehensive guide explains software architecture methodologies, system decomposition techniques, core design principles, common patterns, and the 4+1 view model, offering readers a solid foundation for purposeful learning and application in modern software projects.

Design PatternsMethodologiesSoftware Architecture

0 likes · 16 min read

Mastering Software Architecture: Methodologies, Principles, and Patterns

Architecture Digest

May 8, 2019 · Fundamentals

10 Common Software Architectural Patterns and Their Applications

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

Client‑ServerDesign PatternsMVC

0 likes · 9 min read

10 Common Software Architectural Patterns and Their Applications

Node Underground

Apr 25, 2019 · Frontend Development

How Inversion of Control Boosts Front‑End Development Efficiency

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

Design PatternsInversion of Controldependency injection

0 likes · 11 min read

How Inversion of Control Boosts Front‑End Development Efficiency

Java Backend Technology

Apr 20, 2019 · Backend Development

Simplify Order Processing with Strategy Pattern and Custom Annotations in Java

This article demonstrates how to replace cumbersome if‑else logic in an order‑processing system with a concise Strategy pattern implementation, using a custom @HandlerType annotation and Spring bean registration to make adding new order types effortless and maintainable.

Custom AnnotationDesign PatternsJava

0 likes · 4 min read

Simplify Order Processing with Strategy Pattern and Custom Annotations in Java

Senior Brother's Insights

Apr 15, 2019 · Backend Development

How MyBatis Implements 9 Classic Design Patterns – A Deep Dive

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

BuilderDesign PatternsJava

0 likes · 19 min read

How MyBatis Implements 9 Classic Design Patterns – A Deep Dive

Alibaba Cloud Developer

Apr 1, 2019 · Fundamentals

Must-Read Technical Books Recommended by Alibaba Experts

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

AIDatabase SystemsDesign Patterns

0 likes · 9 min read

Must-Read Technical Books Recommended by Alibaba Experts

21CTO

Mar 21, 2019 · Fundamentals

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

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

Design PatternsLindy effectfundamentals

0 likes · 8 min read

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

Java Captain

Feb 26, 2019 · Backend Development

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

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

DTODesign PatternsJava

0 likes · 27 min read

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

Java Captain

Feb 20, 2019 · Backend Development

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

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

Design PatternsJVMJava

0 likes · 11 min read

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

Java Backend Technology

Feb 17, 2019 · Backend Development

9 Essential Spring Design Patterns Every Java Developer Should Master

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

Design PatternsJavaSpring

0 likes · 9 min read

9 Essential Spring Design Patterns Every Java Developer Should Master

Programmer DD

Feb 13, 2019 · Backend Development

When Should You Use Abstract Classes in Java? Avoid the Swiss‑Army‑Knife Controller Anti‑Pattern

This article explains the purpose and proper use of abstract classes in Java, illustrates common misuse such as the Swiss‑Army‑Knife controller anti‑pattern, and demonstrates how the Template Method pattern can provide a cleaner design with concrete examples and code snippets.

Abstract ClassesDesign PatternsJava

0 likes · 11 min read

When Should You Use Abstract Classes in Java? Avoid the Swiss‑Army‑Knife Controller Anti‑Pattern

Java Captain

Feb 10, 2019 · Backend Development

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

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

Design PatternsFactory MethodJava

0 likes · 9 min read

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

360 Tech Engineering

Jan 22, 2019 · Cloud Native

Microservice Design Patterns: Database, Observability, and Cross‑Cutting Concerns

This article introduces a series of microservice design patterns—including database isolation, observability, and cross‑cutting concerns—explaining the underlying problems each pattern solves and providing concrete solutions such as CQRS, Saga, log aggregation, health checks, and blue‑green deployments.

Design PatternsObservabilitySAGA

0 likes · 13 min read

Microservice Design Patterns: Database, Observability, and Cross‑Cutting Concerns

360 Tech Engineering

Jan 22, 2019 · Backend Development

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

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

API GatewayDesign PatternsIntegration

0 likes · 7 min read

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

360 Tech Engineering

Jan 17, 2019 · Backend Development

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

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

API GatewayDesign PatternsIntegration

0 likes · 8 min read

Architect's Tech Stack

Jan 17, 2019 · Backend Development

Comprehensive Java Interview Questions and Topics

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

Design PatternsJVMJava

0 likes · 12 min read

Comprehensive Java Interview Questions and Topics

Senior Brother's Insights

Jan 2, 2019 · Backend Development

9 Essential Spring Design Patterns Explained with Code Samples

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

Design PatternsJavaSpring

0 likes · 9 min read

9 Essential Spring Design Patterns Explained with Code Samples

21CTO

Dec 22, 2018 · Fundamentals

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

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

Continuous DeliveryDesign Patternsfundamentals

0 likes · 8 min read

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

Programmer DD

Dec 11, 2018 · Backend Development

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

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

Design PatternsOOPSOLID

0 likes · 7 min read

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

Java Captain

Nov 12, 2018 · Fundamentals

Reflections on Object‑Oriented Design, SOLID Principles, and Design Patterns

The author shares personal reflections on OOP, SOLID, composition versus inheritance, design patterns, and layered architecture while recounting a recent project refactoring experience and emphasizing practical insights over textbook theory.

Design PatternsOOPSOLID

0 likes · 6 min read

Reflections on Object‑Oriented Design, SOLID Principles, and Design Patterns

360 Zhihui Cloud Developer

Nov 6, 2018 · Backend Development

Mastering Microservice Design Patterns: Decomposition & Integration Strategies

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

Design PatternsIntegrationbackend architecture

0 likes · 9 min read

Mastering Microservice Design Patterns: Decomposition & Integration Strategies

Java Backend Technology

Sep 22, 2018 · Fundamentals

Mastering the Strategy Pattern in Spring: A Step-by-Step Guide

This tutorial walks you through the background, learning goals, and detailed Spring-based code examples of the Strategy pattern, including list and map implementations, configuration files, and a complete run‑time demonstration for Java developers.

Design PatternsJavaSpring

0 likes · 3 min read

Mastering the Strategy Pattern in Spring: A Step-by-Step Guide

Tencent IMWeb Frontend Team

Sep 2, 2018 · Frontend Development

Mastering Render Props: A Deep Dive into Advanced React Design Patterns

This article explains how the render props pattern solves the flexibility and prop‑passing limitations of earlier React design approaches, illustrating the concept with JSX examples, Babel compilation details, and comparisons to props.children for creating highly reusable and readable components.

Design PatternsJSXJavaScript

0 likes · 8 min read

Mastering Render Props: A Deep Dive into Advanced React Design Patterns

Tencent IMWeb Frontend Team

Aug 29, 2018 · Frontend Development

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

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

Component ReusabilityContext APIDesign Patterns

0 likes · 9 min read

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

Tencent IMWeb Frontend Team

Aug 28, 2018 · Frontend Development

Master Flexible React Components with Compound Component Patterns

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

Compound ComponentsContext APIDesign Patterns

0 likes · 11 min read

Master Flexible React Components with Compound Component Patterns

Java Captain

Aug 28, 2018 · Databases

Design and Implementation of a Mini Database Connection Pool

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

DatabaseDesign PatternsJava

0 likes · 5 min read

Design and Implementation of a Mini Database Connection Pool

Senior Brother's Insights

Aug 23, 2018 · Fundamentals

Mastering the Singleton Pattern in Java: Eager, Lazy, Double‑Check, and More

Explore the GOF 23 design patterns with a deep dive into the Singleton pattern, covering its purpose, characteristics, comparison to static classes, and multiple Java implementations—including eager, lazy, double‑checked locking, volatile, static inner class, and enum approaches—plus Spring’s real‑world usage.

Design PatternsEnumJava

0 likes · 12 min read

Mastering the Singleton Pattern in Java: Eager, Lazy, Double‑Check, and More

21CTO

Aug 20, 2018 · Fundamentals

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

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

Design PatternsSOASoftware Architecture

0 likes · 9 min read

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

Senior Brother's Insights

Aug 19, 2018 · Backend Development

Spring’s 9 Core Design Patterns Explained with Code Examples

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

Design PatternsJavaSpring

0 likes · 9 min read

Spring’s 9 Core Design Patterns Explained with Code Examples

转转QA

Aug 15, 2018 · Backend Development

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

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

Backend testingDesign Patternsinterface testing

0 likes · 9 min read

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

ITFLY8 Architecture Home

Aug 9, 2018 · Backend Development

Essential Backend Architecture Knowledge Map for High‑Concurrency Systems

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

Design PatternsJavaarchitecture

0 likes · 2 min read

Essential Backend Architecture Knowledge Map for High‑Concurrency Systems

ITFLY8 Architecture Home

Aug 8, 2018 · Fundamentals

Understanding MVC, MVP, and MVVM: Concepts, Differences, and When to Use Them

This article explains the MVC, MVP, and MVVM architectural patterns, detailing their structures, interaction flows, advantages, disadvantages, and suitable scenarios, helping developers choose the right pattern for their projects.

Design PatternsMVCMVP

0 likes · 12 min read

Understanding MVC, MVP, and MVVM: Concepts, Differences, and When to Use Them

Big Data and Microservices

Jul 30, 2018 · Backend Development

Six Essential Microservice Design Patterns and When to Apply Them

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

Design Patternsasynchronous messagingbackend architecture

0 likes · 5 min read

Six Essential Microservice Design Patterns and When to Apply Them

Java Backend Technology

Jul 27, 2018 · Backend Development

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

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

Design PatternsJavabackend development

0 likes · 11 min read

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

JD Tech

Jun 26, 2018 · Backend Development

Design and Development of an IntelliJ Plugin for Smart Code Completion and Formatting

This article describes the motivation, design, implementation, and deployment of an IntelliJ IDEA plugin that automatically inserts semicolons and braces, formats code, and uses a chain‑of‑responsibility pattern to decouple business logic, providing developers with a smoother coding experience.

Design PatternsIDEIntelliJ

0 likes · 18 min read

Design and Development of an IntelliJ Plugin for Smart Code Completion and Formatting

Java Captain

Jun 19, 2018 · Fundamentals

Understanding the Proxy Pattern: Static vs Dynamic Proxy and AOP in Java

This article explains the proxy design pattern, compares static and dynamic proxy implementations in Java, demonstrates how to use Java reflection and InvocationHandler for dynamic proxies, and shows how these techniques enable AOP features such as logging and transaction handling.

AOPDesign PatternsDynamic Proxy

0 likes · 12 min read

Understanding the Proxy Pattern: Static vs Dynamic Proxy and AOP in Java

DevOps

Jun 13, 2018 · Fundamentals

The Importance of Methodology and Best Practices in Software Development

Understanding and applying solid methodologies—such as design patterns, coding standards, and domain‑driven design—constitutes the core of software development best practices, helping programmers evolve from “wild” coders to professionals who write clean, maintainable code and continuously improve through disciplined practice.

Design Patternsbest practicescoding standards

0 likes · 8 min read

The Importance of Methodology and Best Practices in Software Development

Architecture Digest

Jun 13, 2018 · Fundamentals

Common Misconceptions About Software Architecture, High Concurrency, and Microservices

The article debunks three prevalent misconceptions—treating a development framework as a substitute for an architect, assuming high concurrency and big‑data challenges are inherently difficult, and believing microservice architecture is a universal solution—by emphasizing the importance of proper design, testing, and realistic evaluation of trade‑offs.

Design PatternsSoftware ArchitectureSystem Design

0 likes · 6 min read

Common Misconceptions About Software Architecture, High Concurrency, and Microservices

Java Captain

Jun 5, 2018 · Backend Development

Comprehensive Java Learning Roadmap: Fundamentals, Core Java, JVM, Databases, Design Patterns, and Backend Development

This guide outlines a complete Java learning path covering computer fundamentals, core Java concepts, JVM internals, database basics, design patterns, HTTP protocol, Spring framework, and advanced backend topics such as web services, distributed systems, and Hadoop.

Design PatternsJVMJava

0 likes · 9 min read

Comprehensive Java Learning Roadmap: Fundamentals, Core Java, JVM, Databases, Design Patterns, and Backend Development

MaGe Linux Operations

Jun 4, 2018 · Fundamentals

From Assembly to OOP: A 7-Day Mythic Journey Through Programming Fundamentals

The article narrates a seven‑day mythic saga where God bestows programming concepts—assembly, functions, data structures, objects, classes, inheritance, polymorphism, and design patterns—on humanity, illustrating how each breakthrough transformed code from tangled sequences into organized, reusable, and abstracted software.

Design PatternsProgramming Fundamentalsinheritance

0 likes · 7 min read

From Assembly to OOP: A 7-Day Mythic Journey Through Programming Fundamentals

ITFLY8 Architecture Home

May 20, 2018 · Backend Development

Why Microservices Matter: A Complete Guide to Architecture, Patterns, and Pitfalls

Microservice architecture, introduced in 2012, breaks monolithic applications into independent services, offering benefits like scalability and flexibility while introducing challenges such as complexity, communication overhead, and testing, and the article explores its evolution, core characteristics, design patterns, implementation practices, and trade‑offs.

API GatewayDesign Patternsarchitecture

0 likes · 21 min read

Why Microservices Matter: A Complete Guide to Architecture, Patterns, and Pitfalls

Java Captain

May 1, 2018 · Backend Development

From Raw Code to AOP: Using Decorator, Proxy, CGLIB, and Spring AOP for Method Timing

This article walks through the evolution from plain Java implementations of a DAO interface to using the Decorator pattern, Java dynamic proxies, CGLIB proxies, and finally Spring AOP, demonstrating how each approach adds reusable timing logic while discussing their advantages and drawbacks.

AOPCGLIBDesign Patterns

0 likes · 15 min read

From Raw Code to AOP: Using Decorator, Proxy, CGLIB, and Spring AOP for Method Timing

ITFLY8 Architecture Home

Apr 29, 2018 · Fundamentals

Unlocking Code Reuse: Design Patterns, Frameworks, Architecture & Platforms Explained

This article explains how design patterns, frameworks, software architecture, and platforms each contribute to different levels of code reuse—from class-level patterns to system-wide architectures—while also detailing key design principles, framework basics, and Java platform classifications for developers seeking deeper engineering insight.

Design PatternsFrameworksSoftware Architecture

0 likes · 13 min read

Unlocking Code Reuse: Design Patterns, Frameworks, Architecture & Platforms Explained

Java Captain

Apr 23, 2018 · Backend Development

Overview of Common Java Backend Technologies: Spring MVC, Spring, MyBatis, Dubbo, Maven, RabbitMQ, Log4j, Ehcache, Redis, Shiro, and Design Patterns

This article provides a comprehensive introduction to essential Java backend technologies—including Spring MVC, Spring IoC/AOP, MyBatis, Dubbo, Maven, RabbitMQ, Log4j, Ehcache, Redis, Shiro—and outlines basic design‑pattern concepts, helping developers understand their roles, core mechanisms, and practical usage.

Design PatternsDubboJava

0 likes · 13 min read

Overview of Common Java Backend Technologies: Spring MVC, Spring, MyBatis, Dubbo, Maven, RabbitMQ, Log4j, Ehcache, Redis, Shiro, and Design Patterns

Alibaba Cloud Developer

Apr 23, 2018 · Fundamentals

Top Technical Books Recommended by Alibaba Experts for World Book Day

On World Book Day, nine Alibaba technology veterans share a curated list of essential technical books—covering software testing, design patterns, AI, machine learning, reinforcement learning, Rust, and database architecture—offering concise reasons why each title is valuable for developers and engineers.

Database ArchitectureDesign PatternsMachine Learning

0 likes · 10 min read

Top Technical Books Recommended by Alibaba Experts for World Book Day

Java Captain

Apr 14, 2018 · Fundamentals

Java Design Patterns: Singleton, Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy

This article introduces several core Java design patterns—including Singleton (lazy, eager, static inner class, enum, double‑checked locking), Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy—explaining their intent, providing concise code examples, and showing how they solve common software design problems.

Design PatternsJavadecorator

0 likes · 13 min read

Java Design Patterns: Singleton, Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy

ITFLY8 Architecture Home

Apr 3, 2018 · Fundamentals

How to Cultivate Object‑Oriented Thinking and Architecture Skills as a Junior Developer

After years of coding without guidance, the author shares practical insights on developing object‑oriented design thinking, when to use interfaces, the limits of OOD, and how continuous refactoring and learning design patterns can gradually build a junior developer’s architectural competence.

Design PatternsObject-Oriented DesignRefactoring

0 likes · 11 min read

How to Cultivate Object‑Oriented Thinking and Architecture Skills as a Junior Developer

Architect's Tech Stack

Mar 21, 2018 · Fundamentals

Comprehensive Java Interview Questions and Topics Guide

This article compiles over 300 essential Java interview questions covering fundamentals, multithreading, design patterns, JVM internals, data structures, algorithms, databases, Spring, Netty, caching, distributed systems, Linux, and networking to help developers prepare for technical interviews and deepen their understanding of core backend concepts.

Design PatternsJVMJava

0 likes · 16 min read

Comprehensive Java Interview Questions and Topics Guide

Java Captain

Mar 9, 2018 · Backend Development

Comprehensive Java Interview Topics and Core Concepts

This guide compiles a thorough list of Java interview questions and key concepts, ranging from basic collections and JVM memory to concurrency, database optimization, messaging systems, NoSQL, Zookeeper, Linux commands, and system design challenges, providing a solid study roadmap for developers.

DatabaseDesign PatternsJava

0 likes · 7 min read

Comprehensive Java Interview Topics and Core Concepts

Java Backend Technology

Mar 6, 2018 · Backend Development

Surviving an Alibaba Backend Interview: Key Java, Spring, and Distributed System Insights

A candid recount of a technical interview at Alibaba reveals essential Java, Spring, database, Linux, JVM, threading, distributed systems, and design pattern knowledge that candidates should master to succeed in backend development roles.

Design PatternsJavabackend interview

0 likes · 9 min read

Surviving an Alibaba Backend Interview: Key Java, Spring, and Distributed System Insights

360 Quality & Efficiency

Mar 5, 2018 · Backend Development

Design Patterns for Node.js Applications

This article explains key Node.js design patterns—including EventEmitter, streams, control‑flow libraries, coding style, testing, and logging—providing practical guidance and recommended tools for building robust, maintainable backend applications.

Design PatternsEventEmitterNode.js

0 likes · 11 min read

Design Patterns for Node.js Applications

Java Backend Technology

Mar 3, 2018 · Backend Development

Essential Java Interview Questions Every Backend Developer Should Master

A comprehensive collection of Java interview questions covering fundamentals, common collections, concurrency, JVM internals, design patterns, data structures, networking, databases, caching, messaging, frameworks, distributed systems, and micro‑service architecture to help developers prepare for junior to mid‑level positions.

Design PatternsJavaconcurrency

0 likes · 19 min read

Essential Java Interview Questions Every Backend Developer Should Master

ITFLY8 Architecture Home

Mar 1, 2018 · Fundamentals

Top 10 Software Architecture Patterns Explained with Pros & Cons

This article introduces the concept of architecture patterns, outlines ten common software architecture styles—including layered, client‑server, master‑slave, pipe‑filter, proxy, peer‑to‑peer, event‑bus, MVC, blackboard, and interpreter—detailing their structures, typical use cases, advantages, and disadvantages.

Design PatternsSoftware ArchitectureSystem Design

0 likes · 11 min read

Top 10 Software Architecture Patterns Explained with Pros & Cons

Tencent IMWeb Frontend Team

Feb 8, 2018 · Frontend Development

How Does JavaScript’s Promise Work Under the Hood? A Deep Dive

This article walks through the inner mechanics of JavaScript Promises, explaining their basic prototype, asynchronous handling with the event loop, state management, chainable behavior, and error handling, all illustrated with step‑by‑step code examples and diagrams.

AsynchronousDesign PatternsJavaScript

0 likes · 10 min read

How Does JavaScript’s Promise Work Under the Hood? A Deep Dive

21CTO

Feb 3, 2018 · Fundamentals

10 Essential Software Architecture Patterns Every Developer Should Know

Explore ten common software architectural patterns—including layered, client‑server, master‑slave, pipe‑filter, proxy, peer‑to‑peer, event‑bus, MVC, blackboard, and interpreter—detailing their structures, typical use cases, advantages, and drawbacks, to help you choose the right architecture for enterprise‑scale systems.

Design PatternsSoftware ArchitectureSystem Design

0 likes · 12 min read

10 Essential Software Architecture Patterns Every Developer Should Know

ITFLY8 Architecture Home

Feb 2, 2018 · Backend Development

From Coder to Web Architect: Essential Skills, Mindset, and Roadmap

This article outlines the philosophical questions, practical steps, and essential knowledge—ranging from object‑oriented fundamentals and design patterns to refactoring, DBA, and operations—that developers need to master in order to evolve into competent web architects.

Design PatternsRefactoringSoftware Architecture

0 likes · 19 min read

From Coder to Web Architect: Essential Skills, Mindset, and Roadmap

ITFLY8 Architecture Home

Jan 29, 2018 · Fundamentals

Mastering Software Architecture: Roles, Patterns, Evaluation, and Risk Management

This comprehensive guide explains software architecture fundamentals, the responsibilities and skills of architects, key architectural patterns, evaluation methods like ATAM, risk identification and mitigation, practical view models, domain‑specific frameworks, and common enterprise architecture styles.

ATAT evaluationDesign PatternsSoftware Architecture

0 likes · 30 min read

Mastering Software Architecture: Roles, Patterns, Evaluation, and Risk Management

Java Captain

Jan 5, 2018 · Fundamentals

Overview of Design Patterns, SOLID Principles, and Java Implementations

This article introduces the three major categories of design patterns, explains the six SOLID principles, and provides detailed Java code examples for creational patterns such as Factory Method, Abstract Factory, Singleton, Builder, and Prototype, illustrating their structure and usage.

BuilderCreationalDesign Patterns

0 likes · 14 min read

Overview of Design Patterns, SOLID Principles, and Java Implementations

Java Backend Technology

Dec 25, 2017 · Backend Development

Why Spring Needs AOP: Solving Repetitive Code with Dynamic Proxies

This article explores the pain points of traditional Java web development, demonstrates how design patterns and JDK dynamic proxies introduce Aspect‑Oriented Programming concepts, explains Spring AOP's relationship to AOP, and compares JDK and CGLib proxy implementations for clean, reusable code.

AOPDesign PatternsDynamic Proxy

0 likes · 9 min read

Why Spring Needs AOP: Solving Repetitive Code with Dynamic Proxies

Java Backend Technology

Dec 24, 2017 · Backend Development

Why Spring Exists: Tracing Java’s Framework Evolution and Core Principles

The article explores the historical evolution of web development—from early Model1 and Model2 approaches through three‑tier architecture to modern Spring and Spring Boot—explaining why Spring was created, its core IoC concepts, design‑pattern foundations, and practical lessons for developers seeking a solid backend foundation.

Design PatternsIoCJava

0 likes · 13 min read

Why Spring Exists: Tracing Java’s Framework Evolution and Core Principles

DevOps

Dec 22, 2017 · Cloud Native

Translation of 32 Cloud Design Patterns for Cloud‑Native Applications

This article presents a Chinese translation of 32 cloud design patterns originally documented by the Azure cloud team, explaining how these patterns—covering availability, data management, security, scalability, and more—can guide enterprises in migrating monolithic applications to cloud‑native architectures across any major cloud provider.

Design Patternscloud migrationcloud-native

0 likes · 4 min read

Translation of 32 Cloud Design Patterns for Cloud‑Native Applications

Baixing.com Technical Team

Dec 12, 2017 · Mobile Development

Why Composition Beats Inheritance in Android List Refactoring

This article explains how refactoring the Baixing Android app’s list feature from an inheritance-heavy design to a composition-based architecture improves modularity, reduces coupling, and eases future extensions by applying OOP principles such as dependency inversion and component interfaces.

Component ArchitectureComposition over InheritanceDependency Inversion

0 likes · 11 min read

Why Composition Beats Inheritance in Android List Refactoring

Java Captain

Dec 11, 2017 · Fundamentals

Comprehensive Java Interview Topics: Data Structures, Algorithms, JVM, Concurrency, Linux, Frameworks, Databases, Networking, Caching, and Design Patterns

This document compiles a wide range of Java interview questions covering data structures and algorithms, core Java concepts, JVM internals, multithreading, Linux usage, popular frameworks, database fundamentals, network protocols, caching systems, and common design patterns to help candidates prepare comprehensively.

AlgorithmsDesign PatternsJVM

0 likes · 12 min read

Comprehensive Java Interview Topics: Data Structures, Algorithms, JVM, Concurrency, Linux, Frameworks, Databases, Networking, Caching, and Design Patterns

Architecture Digest

Dec 8, 2017 · Fundamentals

Reflections on Refactoring a Decade‑Old Core Module: Mindset, Techniques, and Design Patterns

The article shares a developer's hard‑won lessons from refactoring a ten‑year‑old core system, emphasizing the crucial role of mindset, careful business‑logic analysis, selective task handling, and the use of design patterns to achieve clean, extensible code.

Design PatternsRefactoringcode quality

0 likes · 9 min read

Reflections on Refactoring a Decade‑Old Core Module: Mindset, Techniques, and Design Patterns

Architecture Digest

Dec 4, 2017 · Fundamentals

Rethinking Object‑Oriented Programming: From Myth to Practical Understanding

The article reflects on a decade of programming experience to demystify object‑oriented programming, arguing that OOP should be taught as a practical tool for reducing complexity rather than an abstract doctrine, and discusses how to organize functions into classes, avoid misuse of inheritance and design patterns, and focus on solving real problems.

Code OrganizationDesign PatternsProgramming Fundamentals

0 likes · 10 min read

Rethinking Object‑Oriented Programming: From Myth to Practical Understanding

Java Captain

Nov 30, 2017 · Fundamentals

Module Interaction: Synchronous, Asynchronous, and Callback Calls in Java

This article explains the three main ways modules can call each other—synchronous calls, asynchronous calls, and callbacks—illustrates each with Java code examples, and discusses when to use each approach for flexible and non‑blocking program design.

AsynchronousDesign PatternsSynchronous

0 likes · 10 min read

Module Interaction: Synchronous, Asynchronous, and Callback Calls in Java

Java Captain

Nov 28, 2017 · Fundamentals

Proxy Pattern in Java: Static, Dynamic, and Cglib Implementations

This article explains the Proxy design pattern in Java, covering static proxy, dynamic JDK proxy, and Cglib subclass proxy with detailed code examples and discussion of their advantages, limitations, and typical usage in AOP frameworks.

AOPCGLIBDesign Patterns

0 likes · 10 min read

Proxy Pattern in Java: Static, Dynamic, and Cglib Implementations

Zhuanzhuan Tech

Oct 31, 2017 · Cloud Native

Key Technologies and Design Patterns for Implementing Microservices: Architecture Characteristics, Patterns, and Data Consistency

This article explains microservice architecture fundamentals, typical design patterns such as chain, aggregator, data‑sharing and asynchronous messaging, and presents practical solutions for service splitting, data consistency, and distributed transaction management based on real‑world experience at the ZhaiZhai platform.

Data ConsistencyDesign PatternsDistributed Transactions

0 likes · 9 min read

Key Technologies and Design Patterns for Implementing Microservices: Architecture Characteristics, Patterns, and Data Consistency

Hujiang Technology

Oct 26, 2017 · Frontend Development

Design Patterns in Front-End JavaScript Development

This article explains how to apply common design patterns such as Singleton and Observer in front‑end JavaScript, demonstrating practical extensions using Function.prototype, discussing the Open‑Closed Principle, and providing code examples for flexible, maintainable code without invasive modifications.

Design PatternsJavaScriptOpen-Closed Principle

0 likes · 10 min read

Design Patterns in Front-End JavaScript Development

Java Backend Technology

Oct 24, 2017 · Fundamentals

ThreadLocal OOM? Exploring Singleton Pitfalls in Java Multithreading

This article examines common Java singleton implementations—including eager, thread‑safe lazy, double‑checked locking, and static inner‑class approaches—explaining their requirements, potential memory‑leak pitfalls such as ThreadLocal‑induced OOM, and how improper usage in multithreaded environments can lead to unexpected instance creation and performance issues.

Design PatternsJavaOOM

0 likes · 6 min read

ThreadLocal OOM? Exploring Singleton Pitfalls in Java Multithreading

ITFLY8 Architecture Home

Sep 26, 2017 · Fundamentals

Master Design Patterns in One Sentence: Quick Insights for Beginners and Pros

This article presents concise, one‑sentence summaries of common design patterns—Simple Factory, Factory Method, Abstract Factory, Builder, Prototype, Singleton, Adapter, Bridge, Composite, Facade, Flyweight, Decorator, and Proxy—offering quick insights for beginners to form an initial impression and for experienced developers to refresh their knowledge.

Design PatternsObject-OrientedProgramming Fundamentals

0 likes · 7 min read

Master Design Patterns in One Sentence: Quick Insights for Beginners and Pros