BestHub
Sign in
Tagged articles

Dependency Injection

514 articles · Page 5 of 6
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 3, 2021 · Frontend Development

How Baidu Redesigned Its Mobile Search Front‑End Architecture for Scale and Performance

This article examines Baidu's mobile search front‑end architecture, identifies scalability and maintainability challenges such as massive codebases, unclear responsibilities, tight coupling and outdated tech stacks, and explains the three‑layer solution—foundation, modular middle layer, and componentization—along with implementation details, dependency injection, SSR adoption, and performance optimizations.

BaiduComponentizationDependency Injection
0 likes · 14 min read
How Baidu Redesigned Its Mobile Search Front‑End Architecture for Scale and Performance
Top Architect
Top Architect
Mar 3, 2021 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains Spring's approach to resolving circular dependencies in singleton beans using a three‑level cache, contrasts it with prototype bean limitations, provides a simplified implementation example, and draws an analogy to the classic two‑sum algorithm to illustrate the core concept.

Dependency InjectionJavaSingleton
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
Baidu Geek Talk
Baidu Geek Talk
Mar 1, 2021 · Frontend Development

Frontend Architecture Design: Evolution and Solutions

The article examines the evolution and challenges of frontend architecture through Baidu’s mobile search case, identifies problems such as vague responsibilities, tight coupling, and legacy stacks, and proposes a three‑tier solution—infra, independent modules, and componentization—implemented via server‑client designs, a Molecule interface, DI container, SSR optimization, and cross‑platform strategies to enable flexible upgrades and business agility.

ComponentizationCross-PlatformDependency Injection
0 likes · 12 min read
Frontend Architecture Design: Evolution and Solutions
Selected Java Interview Questions
Selected Java Interview Questions
Feb 26, 2021 · Backend Development

Understanding IoC: Inversion of Control, Dependency Injection, and Their Benefits

The article explains the core concept of Inversion of Control (IoC), how a third‑party container manages resources to reduce coupling, illustrates the idea with everyday examples, and clarifies the related terms dependency injection and control inversion, especially in the context of Spring.

Backend DevelopmentDependency InjectionIOC
0 likes · 10 min read
Understanding IoC: Inversion of Control, Dependency Injection, and Their Benefits
Programmer DD
Programmer DD
Feb 24, 2021 · Backend Development

Why Field Injection in Spring Is Discouraged and What to Use Instead

The article explains Spring's warning about field injection, compares constructor, setter, and field injection methods with code examples, outlines the drawbacks of field injection such as final‑field incompatibility, hidden dependencies, and tight IOC coupling, and recommends using constructor injection for required beans and setter injection for optional ones.

Backend DevelopmentConstructor InjectionDependency Injection
0 likes · 6 min read
Why Field Injection in Spring Is Discouraged and What to Use Instead
Architect's Tech Stack
Architect's Tech Stack
Feb 18, 2021 · Backend Development

Summary of Design Patterns Used in the Spring Framework

This article provides a comprehensive overview of how Spring implements classic design patterns such as Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, and Template Method, explaining their implementation details, underlying principles, and practical code examples within the Spring container.

Dependency InjectionFactoryObserver
0 likes · 15 min read
Summary of Design Patterns Used in the Spring Framework
Java Captain
Java Captain
Feb 13, 2021 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains how Spring resolves circular dependencies in singleton beans using a three‑level cache, contrasts it with prototype beans, provides a minimal reflective implementation, and draws an analogy to the classic two‑sum algorithm to illustrate the core principle.

Dependency InjectionJavaSpring
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
Architect
Architect
Feb 5, 2021 · Backend Development

Spring Container Startup Listeners and Initialization Techniques

This article explains various ways to execute custom logic during Spring container startup, covering bean constructors, @PostConstruct, InitializingBean, ApplicationListener events, @EventListener, constructor injection, CommandLineRunner, and SmartLifecycle, with code examples and usage guidelines.

Bean InitializationCommandLineRunnerDependency Injection
0 likes · 10 min read
Spring Container Startup Listeners and Initialization Techniques
Programmer DD
Programmer DD
Feb 1, 2021 · Backend Development

Unlock Spring’s Power: 9 Essential Design Patterns Every Backend Engineer Should Master

This article explores nine key Spring framework design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation, underlying principles, and practical code examples, while highlighting how they enable loose coupling and extensibility in backend development.

Backend DevelopmentDependency InjectionJava
0 likes · 15 min read
Unlock Spring’s Power: 9 Essential Design Patterns Every Backend Engineer Should Master
Java Architect Essentials
Java Architect Essentials
Jan 16, 2021 · Backend Development

Integrating Retrofit with Spring Boot Using retrofit‑spring‑boot‑starter

This article explains how to quickly integrate the Retrofit HTTP client into a Spring Boot project with the retrofit‑spring‑boot‑starter, covering dependency setup, configuration annotations, interface definition, custom annotation‑based interceptors, connection‑pool management, logging, exception formatting, call adapters, converters, and global interceptors, all illustrated with complete code examples.

Dependency InjectionHTTPJava
0 likes · 13 min read
Integrating Retrofit with Spring Boot Using retrofit‑spring‑boot‑starter
Top Architect
Top Architect
Jan 9, 2021 · Backend Development

Guice Dependency Injection Tutorial: Modules, Bindings, Scopes, and Assisted Injection

This article introduces Google Guice, a lightweight Java dependency injection framework, covering its core concepts, module configuration, various binding types, scopes, injection methods, provider usage, assisted injection, and includes extensive code examples demonstrating how to replace manual object creation with Guice-managed dependencies.

Assisted InjectionBindingsDependency Injection
0 likes · 10 min read
Guice Dependency Injection Tutorial: Modules, Bindings, Scopes, and Assisted Injection
Java Captain
Java Captain
Jan 9, 2021 · Backend Development

Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects

This article examines whether Service and DAO layers in Java Spring projects should always have interfaces, discusses the arguments for and against using interfaces, and proposes practical structuring and dependency‑injection techniques to decide when interfaces are truly necessary.

Dependency InjectionInterfaceJava
0 likes · 8 min read
Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 7, 2021 · Backend Development

Overview of Spring Core Components, IOC, AOP, and Related Technologies

This article provides a comprehensive guide to the Spring framework, covering its core modules, the concepts of Inversion of Control and Aspect‑Oriented Programming, various container implementations, proxy mechanisms, bean lifecycle, design patterns, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.

AOPDependency InjectionJava
0 likes · 31 min read
Overview of Spring Core Components, IOC, AOP, and Related Technologies
Code Ape Tech Column
Code Ape Tech Column
Jan 7, 2021 · Backend Development

How Spring Solves Circular Dependencies: Inside the Three‑Cache Mechanism

This article explains how Spring resolves circular dependencies for singleton beans using a three‑level cache, contrasts it with prototype limitations, provides a minimal container implementation that mimics the mechanism, and draws an analogy to the classic two‑sum algorithm to illustrate the core caching principle.

Dependency InjectionJavaSpring
0 likes · 11 min read
How Spring Solves Circular Dependencies: Inside the Three‑Cache Mechanism
Java Backend Technology
Java Backend Technology
Dec 27, 2020 · Backend Development

Do You Really Need Interfaces for Service and DAO Layers in Spring?

This article examines whether Service and DAO layers in Spring projects truly require interfaces, debunks common justifications, explores alternative project structures for single and multiple implementations, and offers practical guidelines on when to use or omit interfaces.

Dependency InjectionSpringdao
0 likes · 8 min read
Do You Really Need Interfaces for Service and DAO Layers in Spring?
Tuhu Marketing Technology Team
Tuhu Marketing Technology Team
Dec 26, 2020 · Backend Development

Unveiling Spring Boot Auto‑Configuration: How It Works Under the Hood

This article walks through the inner workings of Spring Boot’s auto‑configuration mechanism, starting from a simple Hello World project, dissecting key annotations like @SpringBootApplication and @EnableAutoConfiguration, and tracing the source code of selectors, import groups, and the SpringApplication run process to reveal how beans are discovered, loaded, and registered at startup.

Auto-ConfigurationDependency InjectionJava
0 likes · 27 min read
Unveiling Spring Boot Auto‑Configuration: How It Works Under the Hood
Architecture Digest
Architecture Digest
Dec 21, 2020 · Backend Development

Do You Need an Interface for the Service Layer? A Critical Examination

This article examines whether a Service layer in a Spring‑based backend project truly requires an interface, debunks common justifications, proposes practical development workflows, and outlines the advantages and drawbacks of using or omitting interfaces in various architectural scenarios.

Dependency InjectionInterfaceSpring
0 likes · 8 min read
Do You Need an Interface for the Service Layer? A Critical Examination
vivo Internet Technology
vivo Internet Technology
Dec 9, 2020 · Backend Development

Understanding Dubbo SPI: Features, Implementation and Comparison with JDK SPI

The article explains Service Provider Interface (SPI) concepts, shows how the JDK’s built‑in SPI works, and details Dubbo’s extended SPI mechanism—including named and adaptive extensions, dependency injection, AOP wrappers, and activation filtering—highlighting its richer features and implementation compared to standard Java SPI.

AOPAdaptiveDependency Injection
0 likes · 26 min read
Understanding Dubbo SPI: Features, Implementation and Comparison with JDK SPI
Code Ape Tech Column
Code Ape Tech Column
Dec 7, 2020 · Backend Development

Unlock Spring’s Power: 9 Design Patterns Every Java Developer Should Master

This article explores nine core design patterns implemented in Spring—simple factory, factory method, singleton, adapter, decorator, proxy, observer, strategy, and template method—detailing their implementation mechanisms, underlying principles, code examples, and practical significance for building loosely coupled, extensible Java applications.

AOPBackend DevelopmentDependency Injection
0 likes · 16 min read
Unlock Spring’s Power: 9 Design Patterns Every Java Developer Should Master
Architect
Architect
Dec 6, 2020 · Backend Development

Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects

This article examines whether a Service layer in a Spring‑based application truly requires an interface, analyzes common arguments for and against using interfaces, explores project structuring options, and offers practical recommendations based on real‑world development experience.

AOPDependency InjectionInterface
0 likes · 7 min read
Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Nov 25, 2020 · Fundamentals

Implementing IoC and DI in TypeScript: A Practical Guide

This guide shows how to build a lightweight Inversion of Control container in TypeScript and use Reflect‑Metadata decorators to register providers and inject dependencies, demonstrating how constructor‑based injection decouples classes, simplifies testing, and mirrors patterns used in frameworks such as NestJS, Midway, and Angular.

DecoratorDependency InjectionIOC
0 likes · 16 min read
Implementing IoC and DI in TypeScript: A Practical Guide
IT Xianyu
IT Xianyu
Nov 16, 2020 · Backend Development

14 Tips for Writing Spring MVC Controllers

This article presents fourteen practical techniques for creating Spring MVC controller classes, covering annotation-based definitions, interface implementation, extending abstract controllers, URL mapping, HTTP method specification, request parameter binding, model and view handling, redirects, form validation, file uploads, dependency injection, request/response access, and adherence to the single‑responsibility principle.

Dependency InjectionJavaREST
0 likes · 14 min read
14 Tips for Writing Spring MVC Controllers
Programmer DD
Programmer DD
Nov 11, 2020 · Backend Development

BeanFactory vs ApplicationContext: When to Choose Each in Spring

Spring provides two IoC containers—BeanFactory and ApplicationContext—each with distinct loading strategies, features, and registration behaviors; this article demonstrates their differences through practical code examples, highlighting lazy versus eager loading, automatic post‑processor registration, and why ApplicationContext is generally preferred for enterprise applications.

ApplicationContextBeanFactoryDependency Injection
0 likes · 9 min read
BeanFactory vs ApplicationContext: When to Choose Each in Spring
php Courses
php Courses
Nov 4, 2020 · Backend Development

Implementing and Using ThinkPHP Container for Dependency Management

This article explains how to extend ThinkPHP's Container class with static get, getInstance, make, and magic methods, defines a bind array for aliases, modifies the entry script, and demonstrates retrieving Request instances to illustrate proper dependency injection in a PHP backend framework.

Dependency InjectionPHPThinkPHP
0 likes · 4 min read
Implementing and Using ThinkPHP Container for Dependency Management
macrozheng
macrozheng
Nov 4, 2020 · Backend Development

Why Lombok’s @RequiredArgsConstructor Beats Field Injection in Spring

This article explains how Lombok reduces Java boilerplate, compares Spring's field, setter, and constructor injection, and demonstrates using @RequiredArgsConstructor with final fields to create clean, concise constructors without extra annotations, improving code readability and maintainability.

Constructor InjectionDependency InjectionJava
0 likes · 7 min read
Why Lombok’s @RequiredArgsConstructor Beats Field Injection in Spring
Top Architect
Top Architect
Nov 3, 2020 · Backend Development

Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects

This article examines whether every Service and DAO class in a Spring‑based backend should implement an interface, evaluates the common arguments for using interfaces, explains why they often do not hold up, and proposes practical structuring and development approaches for projects that may or may not need multiple implementations.

Dependency InjectionInterfaceJava
0 likes · 9 min read
Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects
Top Architect
Top Architect
Oct 5, 2020 · Backend Development

Deep Dive into Spring Framework Container Startup: Constructor, BeanFactory, Reader, and Scanner Initialization

This article walks through the Spring Framework container startup process, explaining how the AnnotationConfigApplicationContext constructor prepares the environment, registers readers and scanners, initializes the BeanFactory, sets up condition evaluators and post‑processors, and outlines the default filters used for component scanning.

AnnotationConfigApplicationContextBeanFactoryDependency Injection
0 likes · 15 min read
Deep Dive into Spring Framework Container Startup: Constructor, BeanFactory, Reader, and Scanner Initialization
Top Architect
Top Architect
Sep 26, 2020 · Backend Development

Building a Mini Spring MVC Framework from Scratch Using Pure JDK

This article walks through creating a lightweight Spring MVC‑like framework by setting up a clean web project, defining custom annotations, implementing a DispatcherServlet that scans packages, instantiates beans, performs dependency injection, maps URLs to controller methods, and finally runs the application without any Spring dependencies.

Custom AnnotationsDependency InjectionJava
0 likes · 5 min read
Building a Mini Spring MVC Framework from Scratch Using Pure JDK
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 26, 2020 · Fundamentals

Understanding Factory Patterns: Simple Factory, Factory Method, and Abstract Factory with Spring Dependency Injection

This article explains the three common factory design patterns—simple factory, factory method, and abstract factory—illustrates their Java implementations with product and factory classes, demonstrates client usage, and shows how Spring's dependency injection can replace manual factory instantiation, providing a comprehensive guide for developers.

Abstract FactoryDependency InjectionFactory Pattern
0 likes · 7 min read
Understanding Factory Patterns: Simple Factory, Factory Method, and Abstract Factory with Spring Dependency Injection
Selected Java Interview Questions
Selected Java Interview Questions
Sep 21, 2020 · Backend Development

Understanding Spring Framework Core Interfaces and Bean Lifecycle from Source Code

This article explains the core interfaces of the Spring Framework, such as BeanDefinition, BeanFactory, ApplicationContext, and BeanPostProcessor, and walks through the bean creation process—including refresh, preInstantiateSingletons, getBean, and the three‑level singleton caches—providing detailed code examples and insights into how Spring resolves circular dependencies.

Bean LifecycleDependency InjectionJava
0 likes · 28 min read
Understanding Spring Framework Core Interfaces and Bean Lifecycle from Source Code
JavaEdge
JavaEdge
Sep 19, 2020 · Backend Development

Mastering Spring Bean Definitions: Naming, Aliases, and Instantiation

Learn how Spring stores bean metadata, the structure of BeanDefinition, naming conventions, alias configuration, and various bean instantiation methods—including constructors, static and instance factory methods—while also discovering how to determine a bean's runtime type using BeanFactory.getType.

BeanDefinitionDependency InjectionJava
0 likes · 11 min read
Mastering Spring Bean Definitions: Naming, Aliases, and Instantiation
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Sep 11, 2020 · Backend Development

Master Dependency Injection in TypeScript: Build Maintainable Code with IoC

This tutorial explains what dependencies are, why Dependency Injection (DI) and Inversion of Control (IoC) improve code maintainability, shows how to set up TypeScript with reflect‑metadata, and provides a full DI container implementation with Service and Inject decorators, complete usage examples and best‑practice notes.

DI ContainerDependency InjectionIOC
0 likes · 10 min read
Master Dependency Injection in TypeScript: Build Maintainable Code with IoC
Laravel Tech Community
Laravel Tech Community
Aug 11, 2020 · Backend Development

Understanding IoC, Simple Factory, and Dependency Injection in PHP

This article explains the Inversion of Control (IoC) pattern, demonstrates a simple factory for creating traffic‑tool objects, and shows how to apply Dependency Injection (DI) in PHP to decouple a Student class from concrete transportation implementations, culminating in a lightweight IoC container example.

Dependency InjectionIOCPHP
0 likes · 7 min read
Understanding IoC, Simple Factory, and Dependency Injection in PHP
Top Architect
Top Architect
Jul 21, 2020 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains how Spring resolves circular dependencies for singleton beans using a three‑level cache, demonstrates a simple prototype implementation, draws an analogy to the classic two‑sum algorithm, and highlights the core principle behind Spring's dependency injection mechanism.

Dependency InjectionJavaSpring
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
Selected Java Interview Questions
Selected Java Interview Questions
Jul 18, 2020 · Backend Development

Deep Dive into Spring IOC Container Initialization Process

This article provides a comprehensive, step‑by‑step analysis of how Spring's IoC container is initialized, covering resource loading, BeanDefinition creation, BeanFactory setup, template‑method refresh logic, and practical debugging tips, all illustrated with UML diagrams and code snippets.

Dependency InjectionIOCJava
0 likes · 20 min read
Deep Dive into Spring IOC Container Initialization Process
Continuous Delivery 2.0
Continuous Delivery 2.0
Jul 15, 2020 · Fundamentals

When Constructors Do Too Much Work: Symptoms, Risks, and Refactoring Techniques

The article explains why having constructors perform excessive work is a design flaw, describes how to spot this problem through code symptoms, discusses its impact on testability and maintainability, and provides concrete refactoring strategies such as dependency injection, factories, and builder patterns.

Dependency InjectionUnit Testingcode smell
0 likes · 13 min read
When Constructors Do Too Much Work: Symptoms, Risks, and Refactoring Techniques
Sohu Tech Products
Sohu Tech Products
Jun 10, 2020 · Mobile Development

Understanding RIB Architecture in iOS: A Complete Guide to Router‑Interactor‑Builder

This article explains the RIB (Router‑Interactor‑Builder) architecture for iOS, detailing its core components, how to generate and connect them with Xcode templates, manage navigation, inject dependencies, write unit tests with mock generation, and integrate the whole structure into a root RIB for a production‑ready app.

Dependency InjectionMobile DevelopmentRIB
0 likes · 21 min read
Understanding RIB Architecture in iOS: A Complete Guide to Router‑Interactor‑Builder
vivo Internet Technology
vivo Internet Technology
Jun 10, 2020 · Backend Development

Understanding Spring Boot Configuration Class Parsing and Core Annotations

Spring Boot parses @SpringBootApplication by combining @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan, then processes @Import, @Conditional, and bean post‑processors, uses SpringFactoriesLoader for auto‑configuration, and follows an eight‑step configuration‑class parsing flow to register beans during startup.

Auto-ConfigurationBean ProcessingConfiguration
0 likes · 35 min read
Understanding Spring Boot Configuration Class Parsing and Core Annotations
macrozheng
macrozheng
May 9, 2020 · Backend Development

How Does Spring Resolve Circular Dependencies? Inside the Three‑Level Cache

This article explains how Spring handles circular dependencies in singleton beans by using a three‑level cache, contrasts it with prototype beans that cannot participate, and demonstrates a minimal implementation that mimics Spring's approach, linking the concept to the classic two‑sum algorithm.

Backend DevelopmentDependency InjectionJava
0 likes · 10 min read
How Does Spring Resolve Circular Dependencies? Inside the Three‑Level Cache
Java Captain
Java Captain
May 4, 2020 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains how Spring resolves circular dependencies for singleton beans using a three‑level cache, demonstrates a simple prototype implementation that mimics Spring's behavior, and relates the problem to the classic two‑sum algorithm to reveal its fundamental nature.

BeanDependency InjectionJava
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
Java Backend Technology
Java Backend Technology
May 3, 2020 · Backend Development

How Spring Solves Circular Dependencies: The 3‑Cache Trick Explained

This article explains how Spring resolves circular dependencies in singleton beans using a three‑level cache, why prototype beans cannot participate, provides a minimal example implementation, and draws an analogy to the classic two‑sum algorithm to illustrate the underlying principle.

Dependency InjectionJavaSpring
0 likes · 10 min read
How Spring Solves Circular Dependencies: The 3‑Cache Trick Explained
Java Backend Technology
Java Backend Technology
Apr 23, 2020 · Backend Development

Why Spring’s Constructor Injection Fails on Circular Dependencies (and How Setters Help)

This article explains what circular dependencies are in Spring, shows three ways the framework handles them—constructor injection, singleton setter injection, and prototype setter injection—illustrates each with Java classes and XML configuration, and clarifies why only the singleton setter approach avoids runtime errors.

Bean ScopeConstructor InjectionDependency Injection
0 likes · 9 min read
Why Spring’s Constructor Injection Fails on Circular Dependencies (and How Setters Help)
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 19, 2020 · Backend Development

How Spring Implements 9 Core Design Patterns – From Simple Factory to Template Method

This article explains how Spring applies nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation approaches, underlying principles, and the benefits they bring to Spring's IoC container and AOP mechanisms.

Backend DevelopmentDependency InjectionFactory Method
0 likes · 18 min read
How Spring Implements 9 Core Design Patterns – From Simple Factory to Template Method
Java Backend Technology
Java Backend Technology
Mar 3, 2020 · Backend Development

Unlock Spring’s Power: 9 Essential Design Patterns for Backend Engineers

This article explains how Spring implements nine core design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation, underlying principles, and practical significance for Java backend development.

Dependency InjectionFactoryJava
0 likes · 16 min read
Unlock Spring’s Power: 9 Essential Design Patterns for Backend Engineers
Java Captain
Java Captain
Mar 1, 2020 · Backend Development

Summary of Design Patterns Used in the Spring Framework

This article explains how the Spring framework implements various classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation mechanisms, underlying principles, and practical significance within Spring's bean lifecycle and extension points.

AOPBeanFactoryDependency Injection
0 likes · 14 min read
Summary of Design Patterns Used in the Spring Framework
Architecture Digest
Architecture Digest
Feb 27, 2020 · Backend Development

Spring Bean Lifecycle: Detailed Process Flow and Code Explanation

This article provides a comprehensive walkthrough of the Spring Bean lifecycle, covering bean retrieval, creation, property population, initialization, and destruction, illustrated with flowcharts and extensive Java code snippets from the AbstractBeanFactory and AbstractAutowireCapableBeanFactory classes.

Bean LifecycleDependency InjectionJava
0 likes · 12 min read
Spring Bean Lifecycle: Detailed Process Flow and Code Explanation
Programmer DD
Programmer DD
Feb 24, 2020 · Backend Development

Unveiling Spring's Bean Lifecycle: From Retrieval to Destruction

This article provides a comprehensive, step‑by‑step walkthrough of Spring's Bean lifecycle—including bean retrieval, creation, property population, initialization, and destruction—illustrated with flowcharts and complete Java code snippets to help developers understand the inner workings of the framework.

Bean LifecycleDependency InjectionJava
0 likes · 14 min read
Unveiling Spring's Bean Lifecycle: From Retrieval to Destruction
Laravel Tech Community
Laravel Tech Community
Jan 2, 2020 · Backend Development

Master Laravel Controllers: From Basics to Advanced Resource Routing

This guide explains how to organize request handling with Laravel controllers, covering basic controller creation, namespace handling, single‑action controllers, middleware assignment, resource controllers with custom routes, dependency injection techniques, and route caching for production performance.

ControllersDependency InjectionLaravel
0 likes · 13 min read
Master Laravel Controllers: From Basics to Advanced Resource Routing
Laravel Tech Community
Laravel Tech Community
Jan 2, 2020 · Backend Development

Master Laravel Request Handling: DI, Input Retrieval, Cookies & File Uploads

This guide explains how to inject the Illuminate\Http\Request into Laravel controllers, retrieve route parameters, access request paths, methods, query strings, filter input, work with old input, manage cookies, handle uploaded files, and configure trusted proxies for accurate HTTPS detection.

Dependency InjectionHTTP requestInput Handling
0 likes · 15 min read
Master Laravel Request Handling: DI, Input Retrieval, Cookies & File Uploads
Laravel Tech Community
Laravel Tech Community
Dec 31, 2019 · Backend Development

Introduction to Laravel Facades and Their Usage

This article explains Laravel Facades as static-like interfaces to the service container, shows how to define and use them, compares them with dependency injection and helper functions, and demonstrates testing techniques including real‑time facades with comprehensive code examples.

Dependency InjectionFacadesLaravel
0 likes · 8 min read
Introduction to Laravel Facades and Their Usage
Laravel Tech Community
Laravel Tech Community
Dec 31, 2019 · Backend Development

Understanding Laravel Contracts: Benefits, Usage, and Comparison with Facades

Laravel contracts are framework-provided interfaces that define core services such as queues and mail, offering low-coupling and clear dependencies; the article explains their purpose, compares them with facades, demonstrates refactoring for decoupling with code examples, and shows how to inject contracts via the service container.

Backend DevelopmentContractsDependency Injection
0 likes · 7 min read
Understanding Laravel Contracts: Benefits, Usage, and Comparison with Facades
Java Captain
Java Captain
Dec 29, 2019 · Backend Development

Comprehensive Overview of the Spring Framework and Its Ecosystem

This article provides a comprehensive introduction to the Spring ecosystem, covering its core concepts such as IoC and AOP, detailing each of the seven framework modules, and explaining related projects like Spring MVC, Spring Security, Spring Data, Spring Boot, and Spring Cloud for modern Java backend development.

AOPBackend DevelopmentDependency Injection
0 likes · 18 min read
Comprehensive Overview of the Spring Framework and Its Ecosystem
Programmer DD
Programmer DD
Nov 22, 2019 · Backend Development

Mastering Spring: A Comprehensive Guide to Java’s Leading Backend Framework

An in‑depth overview of the Spring ecosystem explains its core container, modules such as AOP, MVC, Data, Security, Boot and Cloud, detailing how IoC and dependency injection simplify Java enterprise development, and guides readers through configuration, architecture, and the advantages of using Spring for modern backend applications.

AOPBackend DevelopmentDependency Injection
0 likes · 19 min read
Mastering Spring: A Comprehensive Guide to Java’s Leading Backend Framework
Java Backend Technology
Java Backend Technology
Aug 18, 2019 · Backend Development

Mastering Spring Annotations: From @Controller to @CacheEvict

This article provides a comprehensive guide to essential Spring annotations—including @Controller, @RestController, @Service, @Autowired, @RequestMapping, @ModelAttribute, @Cacheable, @CacheEvict, @Resource, @PostConstruct, @PreDestroy, @Repository, @Component, @Scope, @SessionAttributes, @Required and @Qualifier—explaining their purposes, usage patterns, and practical examples with accompanying diagrams.

Dependency InjectionJavaSpring
0 likes · 9 min read
Mastering Spring Annotations: From @Controller to @CacheEvict
Didi Tech
Didi Tech
Aug 9, 2019 · Backend Development

Introducing Go‑Spring: A Spring‑like Application Framework for Go

Go‑Spring is a Go‑language application framework that brings Spring‑style conventions such as dependency injection, auto‑configuration, starter modules, interface‑based design, and integrated testing to developers, enabling organized code, easy component swapping, configuration binding, and full‑stack unit tests while supporting databases, messaging, and microservice features.

Backend FrameworkDependency InjectionGo
0 likes · 10 min read
Introducing Go‑Spring: A Spring‑like Application Framework for Go
Programmer DD
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 LifecycleConfigurationDependency Injection
0 likes · 25 min read
Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master
Programmer DD
Programmer DD
Jul 21, 2019 · Backend Development

Understanding Spring, Spring MVC, and Spring Boot: Core Problems Solved and Best Use Cases

This article provides a comprehensive overview of the Spring framework, Spring MVC, and Spring Boot, explaining how dependency injection reduces boilerplate and enables loose coupling, illustrating code examples with and without DI, and describing Spring Boot’s auto‑configuration, starter projects and typical starter options for building modern Java backend applications.

Backend DevelopmentDependency InjectionJava
0 likes · 12 min read
Understanding Spring, Spring MVC, and Spring Boot: Core Problems Solved and Best Use Cases
Programmer DD
Programmer DD
Jul 2, 2019 · Backend Development

BeanFactory vs ApplicationContext in Spring: When to Use Which?

This article compares Spring's BeanFactory and ApplicationContext, explaining their roles in retrieving beans, detailing lazy versus eager loading, providing Java and XML code examples, and offering guidance on when to choose each interface for efficient backend development.

ApplicationContextBackend DevelopmentBeanFactory
0 likes · 7 min read
BeanFactory vs ApplicationContext in Spring: When to Use Which?
Java Captain
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.

AOPDependency InjectionFactory
0 likes · 17 min read
Common Design Patterns Used in the Spring Framework
Node Underground
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.

Dependency InjectionInversion of ControlUnit Testing
0 likes · 11 min read
How Inversion of Control Boosts Front‑End Development Efficiency
Senior Brother's Insights
Senior Brother's Insights
Feb 25, 2019 · Backend Development

Master Spring @Configuration and @Bean: From Java Classes to Fully Configured Beans

Spring’s shift from XML to annotation‑based configuration is explained, covering @Configuration and @Bean requirements, example Java classes, equivalent XML, annotation definitions, bean scopes, component scanning, unit‑testing, and practical tips for wiring beans without field injection, providing a complete guide for modern Spring development.

AnnotationBeanDependency Injection
0 likes · 8 min read
Master Spring @Configuration and @Bean: From Java Classes to Fully Configured Beans
Java Backend Technology
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.

Backend DevelopmentDependency InjectionJava
0 likes · 9 min read
9 Essential Spring Design Patterns Every Java Developer Should Master
Node Underground
Node Underground
Jan 10, 2019 · Backend Development

How Midway v1.0 Simplifies Node.js Development with IoC and Decorators

Midway v1.0, the core framework of the MidwayJs ecosystem, introduces IoC‑based dependency injection, web‑scenario decorators, full Egg.js plugin support, and a TypeScript‑first API, offering a concise example that shows how business code can stay clean and decoupled.

Dependency InjectionIOCMidway
0 likes · 3 min read
How Midway v1.0 Simplifies Node.js Development with IoC and Decorators
Senior Brother's Insights
Senior Brother's Insights
Jan 3, 2019 · Backend Development

Mastering Spring Framework: Core Concepts, Modules, and Practical Guides

This comprehensive guide walks Java developers through Spring Framework’s essential features—including its modular architecture, dependency injection mechanisms, bean lifecycle, annotation‑based configuration, data‑access support, AOP concepts, and MVC workflow—providing clear explanations, code examples, and visual diagrams to deepen understanding.

AOPDependency InjectionIOC
0 likes · 26 min read
Mastering Spring Framework: Core Concepts, Modules, and Practical Guides
Senior Brother's Insights
Senior Brother's Insights
Dec 31, 2018 · Backend Development

Why Field Injection Is the Least Recommended in Spring: A Deep Dive

This article examines Spring's three annotation-based dependency injection styles—field, constructor, and setter—showing why the widely used field injection is actually the least advisable, and explains the advantages of constructor injection introduced in Spring 4.x with concrete code examples and best‑practice guidelines.

Constructor InjectionDependency InjectionField Injection
0 likes · 5 min read
Why Field Injection Is the Least Recommended in Spring: A Deep Dive
Senior Brother's Insights
Senior Brother's Insights
Dec 30, 2018 · Backend Development

From Spring Framework to Spring Boot: A Complete Historical Timeline

This article chronicles the evolution of the Spring ecosystem—from its origins as a lightweight dependency‑injection framework, through rapid version growth and corporate changes, to the emergence of Spring Boot and Spring IO, highlighting key releases, architectural shifts, and the impact on Java backend development.

Backend DevelopmentDependency InjectionFramework History
0 likes · 11 min read
From Spring Framework to Spring Boot: A Complete Historical Timeline
iQIYI Technical Product Team
iQIYI Technical Product Team
Dec 14, 2018 · Backend Development

Introducing Navi: An Open‑Source Component Routing Framework for Scalable Backend Systems

Navi is an open‑source component‑routing framework that separates routing logic from business code using matcher annotations, allowing developers to define reusable handlers for different client types and versions, thereby reducing code complexity, improving extensibility, and simplifying backend services while supporting future extensions and community contributions.

Dependency InjectionJavacomponent routing
0 likes · 10 min read
Introducing Navi: An Open‑Source Component Routing Framework for Scalable Backend Systems
Java Captain
Java Captain
Dec 3, 2018 · Backend Development

Common Spring Framework Annotations and Their Usage

This article explains the purpose and usage of frequently used Spring annotations such as @Controller, @RestController, @Service, @Autowired, @RequestMapping, @RequestParam, @ModelAttribute, @Cacheable, @CacheEvict, @Resource, @PostConstruct, @PreDestroy, @Repository, @Component, @Scope, @SessionAttributes, and @Qualifier, providing code examples and practical notes for Java backend development.

CachingDependency InjectionJava
0 likes · 12 min read
Common Spring Framework Annotations and Their Usage
Programmer DD
Programmer DD
Oct 27, 2018 · Backend Development

Why Spring Framework Dominates Java Development: Key Features Explained

This article provides a comprehensive overview of the Spring framework, detailing its lightweight nature, modular architecture, core features such as AOP, dependency injection, transaction management, integration capabilities, and the major enhancements introduced in Spring 5.0, including Java 8/9 support, reactive programming, and testing improvements.

AOPBackend DevelopmentDependency Injection
0 likes · 10 min read
Why Spring Framework Dominates Java Development: Key Features Explained
Java Captain
Java Captain
Oct 7, 2018 · Backend Development

A Comprehensive Overview of Spring Framework Concepts and Practices

This article provides a systematic summary of Spring's core concepts—including IoC, AOP, bean configuration via XML and annotations, dependency injection mechanisms, transaction management, and web integration—offering Java developers a clear guide to effectively using the framework in real-world projects.

AOPBean ConfigurationDependency Injection
0 likes · 9 min read
A Comprehensive Overview of Spring Framework Concepts and Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 21, 2018 · Backend Development

Mastering Domain‑Driven Design: From Data Models to Rich Domain Objects

This article explores practical Domain‑Driven Design in a B‑to‑B setting, comparing data‑centric and object‑centric modeling, illustrating blood‑loss, anemia, and rich models, and showing how dependency injection, testing strategies, repository abstractions, and deployment architectures can improve software quality and maintainability.

Dependency InjectionDomain-Driven DesignMicroservices
0 likes · 15 min read
Mastering Domain‑Driven Design: From Data Models to Rich Domain Objects
Senior Brother's Insights
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.

Dependency InjectionJavaSpring
0 likes · 9 min read
Spring’s 9 Core Design Patterns Explained with Code Examples
Java Captain
Java Captain
Aug 5, 2018 · Backend Development

Spring Framework Overview: Core Concepts, IoC, Beans, AOP, MVC, and Configuration

This article provides a comprehensive overview of the Spring Framework, covering its version history, core features, dependency injection, bean definitions and scopes, annotation‑based configuration, data‑access support, aspect‑oriented programming, and the MVC request‑handling workflow, all illustrated with code examples.

AOPBeansDependency Injection
0 likes · 20 min read
Spring Framework Overview: Core Concepts, IoC, Beans, AOP, MVC, and Configuration
360 Tech Engineering
360 Tech Engineering
Jun 4, 2018 · Backend Development

Understanding Web Framework Architectural Patterns: Middleware, MVC, and Dependency Injection

This article explores the philosophical limits of design patterns and then dives into three core backend architectural patterns—Middleware, MVC, and Dependency Injection—illustrating their purpose, implementation in Node.js frameworks like Express and Koa, and their impact on code modularity and scalability.

Dependency InjectionExpressKoa
0 likes · 12 min read
Understanding Web Framework Architectural Patterns: Middleware, MVC, and Dependency Injection
21CTO
21CTO
May 20, 2018 · Backend Development

Why Design Patterns Still Matter: Middleware, MVC & DI

Exploring the limits and practical value of software design patterns, this article examines philosophical critiques of scientific induction, then delves into three core web architecture patterns—Middleware, MVC, and Dependency Injection—illustrating their implementation in Node.js and Java, and highlighting how they improve code modularity, communication, and scalability.

Dependency InjectionMVCNode.js
0 likes · 13 min read
Why Design Patterns Still Matter: Middleware, MVC & DI
Ctrip Technology
Ctrip Technology
May 9, 2018 · Mobile Development

Modular Refactoring and Decoupling Strategies for Large‑Scale Android Applications

This article explains how to apply modular refactoring—removing unnecessary files, reorganizing packages, degrading monolithic classes, and decoupling components—using tools such as IronBank, BizLifecycle, and AAR‑based platform support to achieve zero‑coupling, easier version management, and faster builds in Android projects.

AARAndroidCode Decoupling
0 likes · 13 min read
Modular Refactoring and Decoupling Strategies for Large‑Scale Android Applications
Java Captain
Java Captain
Apr 25, 2018 · Backend Development

Understanding Spring Framework: IoC, AOP, and Modular Design with Java Example

This article explains the purpose of using a framework, introduces Spring's core concepts of container, inversion of control, and aspect‑oriented programming, and demonstrates them through a Java banking report example with complete code, XML configuration, and annotation‑based AOP to achieve loose coupling and modularity.

AOPDependency InjectionIOC
0 likes · 17 min read
Understanding Spring Framework: IoC, AOP, and Modular Design with Java Example
Java Captain
Java Captain
Apr 10, 2018 · Backend Development

Deep Dive into Spring Framework: IOC Container, BeanFactory, Bean Loading, and FactoryBean

This article provides an in‑depth exploration of Spring's core concepts—including the IOC container, ApplicationContext vs BeanFactory, bean instantiation lifecycles, and the role of FactoryBean—supplemented with diagrams and source code excerpts to help Java developers understand the framework's inner workings.

BeanFactoryDependency InjectionJava
0 likes · 16 min read
Deep Dive into Spring Framework: IOC Container, BeanFactory, Bean Loading, and FactoryBean
Hujiang Technology
Hujiang Technology
Apr 2, 2018 · Backend Development

Introducing NestJS and Nesk: Backend Framework Overview and Koa Integration

This article explains the core concepts of NestJS—including modules, controllers, providers, guards, interceptors, and validation pipes—provides practical code examples, and describes how the Nesk fork adapts Nest's architecture to a Koa‑based environment for seamless integration with existing internal frameworks.

Backend DevelopmentDependency InjectionGuards
0 likes · 10 min read
Introducing NestJS and Nesk: Backend Framework Overview and Koa Integration
Java Backend Technology
Java Backend Technology
Jan 4, 2018 · Backend Development

Mastering Spring IoC: 3 Clear Paths to Understand the Core Container

This article guides Java backend developers through the fundamentals of Spring IoC and DI, illustrating three practical learning routes—from simple BeanFactory containers to advanced ApplicationContext and WebApplicationContext implementations—using diagrams, code examples, and concise explanations to demystify the core container.

ApplicationContextBeanFactoryDependency Injection
0 likes · 12 min read
Mastering Spring IoC: 3 Clear Paths to Understand the Core Container
Liulishuo Tech Team
Liulishuo Tech Team
May 24, 2017 · Mobile Development

Understanding Dagger 2 Modules, Components, and Subcomponents in Android

This article explains how Dagger 2 structures dependency injection for Android apps using Modules, Components, and Subcomponents, illustrating their roles with diagrams, comparing them to manual injection, and showing how they clarify code dependencies while keeping runtime overhead minimal.

AndroidDagger2Dependency Injection
0 likes · 4 min read
Understanding Dagger 2 Modules, Components, and Subcomponents in Android
Architecture Digest
Architecture Digest
Apr 30, 2017 · Backend Development

Essential Java Libraries You Should Not Miss in 2017

This article compiles a curated list of indispensable Java libraries—including Guice, OkHttp, Retrofit, JDeferred, RxJava, MBassador, Lombok, SLF4J, JUnitParams, Mockito, Jukito, Awaitility, Spock, and WireMock—providing concise descriptions and practical code examples to help developers choose the right tools for modern backend development.

Dependency InjectionHTTP Clientbackend
0 likes · 13 min read
Essential Java Libraries You Should Not Miss in 2017
Architecture Digest
Architecture Digest
Oct 29, 2016 · Backend Development

Understanding Laravel’s Core Concepts: Lifecycle, Service Container, Dependency Injection, Contracts, and Facades

This article explains Laravel’s underlying architecture by detailing PHP’s execution phases, Laravel’s request lifecycle, the bootstrap process, the service container, dependency injection, binding mechanisms, and the role of contracts and facades, providing practical code examples for each concept.

Backend DevelopmentContractsDependency Injection
0 likes · 16 min read
Understanding Laravel’s Core Concepts: Lifecycle, Service Container, Dependency Injection, Contracts, and Facades
Tencent Music Tech Team
Tencent Music Tech Team
Oct 14, 2016 · Mobile Development

Understanding ButterKnife: Dependency Injection in Android with JavaPoet and Annotation Processing

ButterKnife is a compile‑time, annotation‑based dependency injection library for Android that uses JavaPoet‑generated helper classes to replace repetitive findViewById calls, offering faster development and runtime performance while adding a modest number of auxiliary classes and a one‑time reflection cost.

AndroidAnnotation ProcessingButterKnife
0 likes · 20 min read
Understanding ButterKnife: Dependency Injection in Android with JavaPoet and Annotation Processing
Java Backend Technology
Java Backend Technology
Oct 11, 2016 · Backend Development

Mastering Spring: Core Concepts, Modules, and Best Practices

This comprehensive guide explains what Spring is, its advantages, core modules, container architecture, bean factories, dependency injection types, bean scopes, lifecycle, AOP concepts, MVC framework, data access support, and transaction management, providing a solid foundation for Java backend development.

AOPDependency InjectionIOC
0 likes · 20 min read
Mastering Spring: Core Concepts, Modules, and Best Practices