BestHub
Sign in
Tagged articles

IOC

103 articles · Page 1 of 2
CodeSmart Hoops
CodeSmart Hoops
Aug 6, 2026 · Backend Development

Spring Container Full-Stack Walkthrough: 12 Interview Questions & Answers

This article provides a comprehensive Spring container walkthrough covering the full lifecycle—from bean definition scanning and proxy creation during startup to request handling, AOP interception, transaction and caching mechanisms—plus detailed answers to 12 common interview questions with code examples and best‑practice recommendations.

AOPBackendIOC
0 likes · 21 min read
Spring Container Full-Stack Walkthrough: 12 Interview Questions & Answers
Java Architect Handbook
Java Architect Handbook
Jul 17, 2026 · Backend Development

Interview Question: What’s the Relationship Between BeanFactory and FactoryBean?

This article explains the distinction between Spring's BeanFactory and FactoryBean, covering their roles, core APIs, typical implementations, key differences in registration and retrieval, classic use cases, common pitfalls, and frequent interview follow‑up questions, with concrete code examples and comparison tables.

BeanFactoryFactoryBeanIOC
0 likes · 10 min read
Interview Question: What’s the Relationship Between BeanFactory and FactoryBean?
Coder Trainee
Coder Trainee
Jul 14, 2026 · Backend Development

Top 10 Must‑Know Spring Interview Questions for Java Developers

This article walks through the ten most frequently asked Spring interview topics—including IoC/DI concepts, bean lifecycle, AOP mechanics, circular‑dependency resolution, @Transactional behavior, Spring Boot startup steps, auto‑configuration, @Autowired vs @Resource, bean scopes, and the differences between servlet filters and Spring interceptors—providing concrete code examples and key points that can earn interviewers' extra credit.

AOPBean ScopeDependency Injection
0 likes · 12 min read
Top 10 Must‑Know Spring Interview Questions for Java Developers
Java Tech Workshop
Java Tech Workshop
Jul 1, 2026 · Backend Development

Resolving AOP + IOC Circular Dependency Conflicts in Spring

The article explains why Spring's three‑level cache solves simple circular dependencies but fails for AOP‑enhanced beans, describes the timeline mismatch that causes BeanCurrentlyInCreationException, and presents tiered solutions including @Lazy injection, setter refactoring, early proxy processing, and architectural redesign.

@BeanAOPIOC
0 likes · 14 min read
Resolving AOP + IOC Circular Dependency Conflicts in Spring
Frontline Investigation
Frontline Investigation
Jun 30, 2026 · Information Security

Beyond IOCs: Turning Threat Intelligence into Actionable Disposal Clues

The article explains why many threat intelligence platforms generate noise instead of actionable clues, proposing a four-layer operational model (data, matching, judgment, action) and a risk-prioritization framework (exposure, exploitability, impact, actionability) to bridge the gap between raw IOCs and effective security response.

CISA KEVEPSSIOC
0 likes · 14 min read
Beyond IOCs: Turning Threat Intelligence into Actionable Disposal Clues
Frontline Investigation
Frontline Investigation
Jun 21, 2026 · Information Security

Beyond IOCs: Building a Closed-Loop Threat Intelligence Operations Framework

This article explains how to move threat intelligence from static IOC collection into a five-step closed loop—collect, normalize, correlate, remediate, review—integrating with assets, vulnerabilities, logs, and ticketing to prioritize real risks, avoid alert fatigue, and enable actionable security operations.

IOCMITRE ATT&CKSecurity Operations
0 likes · 16 min read
Beyond IOCs: Building a Closed-Loop Threat Intelligence Operations Framework
Java Tech Workshop
Java Tech Workshop
Jun 19, 2026 · Backend Development

BeanFactory vs ApplicationContext: The Real Differences You Must Know

The article explains how BeanFactory is a minimal, lazy‑loading container that only creates and caches beans, while ApplicationContext extends it with eager pre‑loading, full annotation, AOP, transaction, environment and event support, and outlines their respective use cases and pitfalls.

ApplicationContextBeanFactoryDependency Injection
0 likes · 9 min read
BeanFactory vs ApplicationContext: The Real Differences You Must Know
Coder Trainee
Coder Trainee
May 7, 2026 · Backend Development

Deep Dive into Spring Boot IoC Container Initialization (Part 4)

This article breaks down Spring Boot's core refresh() method into twelve detailed steps, explaining how the IoC container prepares, configures, and starts up—including bean factory preparation, post‑processor registration, singleton instantiation, and final event publishing—providing interview‑ready insights and code illustrations.

BeanFactoryIOCSpring Boot
0 likes · 14 min read
Deep Dive into Spring Boot IoC Container Initialization (Part 4)
java1234
java1234
Apr 5, 2026 · Backend Development

Why Spring and Spring MVC Use Parent‑Child Containers

The article explains how Spring’s parent‑child container pattern separates core beans like DataSource and TransactionManager from business‑level beans, improving modularity, configuration reuse, decoupling, and flexible bean management, and shows concrete XML and Spring Boot examples for defining and loading these containers.

Bean ConfigurationIOCParent-Child Container
0 likes · 7 min read
Why Spring and Spring MVC Use Parent‑Child Containers
java1234
java1234
Mar 15, 2026 · Backend Development

BeanFactory vs ApplicationContext in Spring: Key Differences Explained

This article compares Spring's BeanFactory and ApplicationContext, detailing their roles, loading strategies, feature sets, code examples, and recommended usage scenarios, helping developers choose the appropriate container for their projects.

ApplicationContextBeanFactoryDependency Injection
0 likes · 6 min read
BeanFactory vs ApplicationContext in Spring: Key Differences Explained
Alibaba Cloud Developer
Alibaba Cloud Developer
Feb 8, 2025 · Backend Development

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

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

BeanFactoryDependency InjectionDesign Patterns
0 likes · 52 min read
Unlocking Spring’s Core: A Deep Dive into the IOC Container Mechanics
Open Source Tech Hub
Open Source Tech Hub
Dec 15, 2024 · Backend Development

Mastering PHP IoC: Build a Singleton Container from Scratch

This tutorial explains how to create a lightweight Inversion of Control (IoC) container in PHP, covering the singleton pattern, binding services, PSR‑11 compliance, retrieving and injecting dependencies, and implementing class and method resolvers with practical code examples.

Dependency InjectionIOCPHP
0 likes · 16 min read
Mastering PHP IoC: Build a Singleton Container from Scratch
Code Mala Tang
Code Mala Tang
Oct 11, 2024 · Backend Development

Mastering Dependency Injection in Node.js: From Manual to Automatic

This article explains the concept of dependency injection, its benefits such as decoupling, easier maintenance, testing and reusability, and demonstrates both manual and automatic implementations in Node.js, including usage of third‑party libraries like InversifyJS.

BackendIOCInversifyJS
0 likes · 10 min read
Mastering Dependency Injection in Node.js: From Manual to Automatic
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 8, 2024 · Frontend Development

Understanding Inversion of Control (IoC) and Dependency Injection in Front‑End Development

This article explains the Inversion of Control (IoC) principle, why it matters for growing front‑end applications, and demonstrates how to refactor a simple App component using dependency injection and a module registration system, turning the App into a container that manages its dependencies rather than directly instantiating them.

Dependency InjectionIOCJavaScript
0 likes · 7 min read
Understanding Inversion of Control (IoC) and Dependency Injection in Front‑End Development
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 16, 2024 · Backend Development

Mastering Spring’s IOC Container: Concepts, Types, and Startup Steps

This article explains the Inversion of Control principle, defines what an IOC container is, compares Spring’s BeanFactory and ApplicationContext, and walks through the three-stage startup process—including loading configurations, registering bean definitions, and instantiating beans with automatic dependency injection.

Dependency InjectionIOCJava
0 likes · 5 min read
Mastering Spring’s IOC Container: Concepts, Types, and Startup Steps
DeWu Technology
DeWu Technology
Jun 24, 2024 · Frontend Development

Feishu Cloud Document to HTML Email: Architecture Redesign and Implementation

The article details a complete redesign of Feishu’s cloud‑document‑to‑HTML‑email converter, introducing IoC/DI architecture, inline‑style utilities, and specialized renderers for headings, lists, tables, images, code blocks, and equations, resulting in high‑fidelity Outlook‑compatible emails while shrinking the core code to under three hundred lines.

CSS-in-JSFeishuHTML email
0 likes · 31 min read
Feishu Cloud Document to HTML Email: Architecture Redesign and Implementation
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
May 25, 2024 · Backend Development

Understanding Spring's IoC Container: BeanFactory, ListableBeanFactory, HierarchicalBeanFactory, and AutowireCapableBeanFactory

This article explains the core Spring IoC concepts by analyzing the top‑level BeanFactory interface and its three important sub‑interfaces—HierarchicalBeanFactory, ListableBeanFactory, and AutowireCapableBeanFactory—illustrating their responsibilities, inheritance relationships, and practical usage with code examples.

BeanFactoryDependency InjectionIOC
0 likes · 8 min read
Understanding Spring's IoC Container: BeanFactory, ListableBeanFactory, HierarchicalBeanFactory, and AutowireCapableBeanFactory
MoonWebTeam
MoonWebTeam
Apr 16, 2024 · Frontend Development

Mastering Dependency Injection in Frontend: Boost Maintainability and Testability

This article explains the concept of Dependency Injection for frontend projects, compares it with Inversion of Control, showcases practical code examples, discusses popular DI libraries and frameworks, and details implementation techniques such as decorators, reflection, singleton handling, and circular dependency resolution to improve maintainability and testability.

Dependency InjectionDesign PatternsIOC
0 likes · 26 min read
Mastering Dependency Injection in Frontend: Boost Maintainability and Testability
Sohu Tech Products
Sohu Tech Products
Sep 6, 2023 · Information Security

Unveiling DarkComet: In‑Depth Static & Dynamic Analysis of a Delphi RAT

This article provides a comprehensive technical breakdown of the DarkComet remote‑access trojan, covering its classification, Delphi‑based static characteristics, step‑by‑step dynamic behaviors such as hidden startup, file dropping, registry auto‑run, QQ data harvesting, SMS bombing, plus extracted IOCs and practical mitigation recommendations.

DarkCometDelphiIOC
0 likes · 9 min read
Unveiling DarkComet: In‑Depth Static & Dynamic Analysis of a Delphi RAT
Architect
Architect
Jun 22, 2023 · Backend Development

Understanding Spring’s Core Concepts: IoC, DI, AOP and Bean Management

The article explains how Spring’s IoC container, dependency injection, singleton beans, and AOP simplify Java backend development by abstracting object creation, configuration, and cross‑cutting concerns, illustrated with code examples and practical scenarios such as conditional bean loading and Redis client selection.

AOPIOCJava
0 likes · 12 min read
Understanding Spring’s Core Concepts: IoC, DI, AOP and Bean Management
Selected Java Interview Questions
Selected Java Interview Questions
Jun 15, 2023 · Backend Development

How Spring IOC Reduces Coupling: From Direct Instantiation to Interfaces, Factory Method, and Reflection

This article explains the concept of coupling, demonstrates how traditional object creation leads to high coupling, and shows how using interfaces, the factory pattern, and reflection—culminating in Spring IOC—can dramatically lower coupling, improve reuse, and simplify maintenance in Java backend development.

CouplingDependency InjectionFactory Pattern
0 likes · 8 min read
How Spring IOC Reduces Coupling: From Direct Instantiation to Interfaces, Factory Method, and Reflection
Yunxuetang Frontend Team
Yunxuetang Frontend Team
Mar 17, 2023 · Frontend Development

Top Frontend Tech Insights: IOC, JS Frameworks, Mobile Evolution, and AI Trends

This article curates key front‑end and emerging tech topics—including Inversion of Control in JavaScript, the overload of JS frameworks, Facebook's iOS codebase evolution, GPT‑4's launch, prompt‑engineering automation, and nuanced UI control design—offering concise insights for modern developers.

Artificial IntelligenceIOCJavaScript
0 likes · 4 min read
Top Frontend Tech Insights: IOC, JS Frameworks, Mobile Evolution, and AI Trends
Top Architect
Top Architect
Feb 16, 2023 · Backend Development

Understanding Dependency Injection and IoC in Spring: From Direct Instantiation to Factory Pattern and Reflection

This article explains why dependency injection reduces coupling compared with direct object creation, walks through traditional instantiation, interface programming, factory methods, and reflection, and shows how Spring IoC combines these techniques to manage object lifecycles and improve code maintainability.

Dependency InjectionFactory PatternIOC
0 likes · 8 min read
Understanding Dependency Injection and IoC in Spring: From Direct Instantiation to Factory Pattern and Reflection
macrozheng
macrozheng
Oct 10, 2022 · Backend Development

Unlock Spring’s Power: 11 Essential Extension Points You Must Master

This article walks through the eleven most commonly used Spring extension points—including custom interceptors, bean retrieval methods, global exception handling, type converters, import configurations, startup runners, bean definition tweaks, post‑processing, initialization and destruction callbacks, and custom scopes—providing clear explanations and code samples for each.

IOCJavaSpring
0 likes · 16 min read
Unlock Spring’s Power: 11 Essential Extension Points You Must Master
Programmer DD
Programmer DD
Sep 26, 2022 · Backend Development

5 Ways to Register Beans in Spring: From @Configuration to FactoryBean

This article explains five different techniques for adding beans to the Spring IoC container—including @Configuration + @Bean, @ComponentScan, @Import with various selectors, FactoryBean, and BeanDefinitionRegistryPostProcessor—providing complete code examples and practical usage notes for developers.

@BeanConfigurationFactoryBean
0 likes · 10 min read
5 Ways to Register Beans in Spring: From @Configuration to FactoryBean
IT Services Circle
IT Services Circle
Sep 20, 2022 · Backend Development

Understanding the Spring Bean Lifecycle: From Instantiation to Destruction

This article explains the complete Spring Bean lifecycle—including IoC fundamentals, bean creation, property injection, initialization callbacks, custom init/destroy methods, and post‑processor hooks—by walking through detailed source‑code examples and step‑by‑step execution traces for a sample bean.

Bean LifecycleDependency InjectionIOC
0 likes · 10 min read
Understanding the Spring Bean Lifecycle: From Instantiation to Destruction
Java Captain
Java Captain
Sep 7, 2022 · Backend Development

Understanding Spring Core Concepts and Building a Minimal Servlet‑Based Framework

This article explains Spring's core features such as IoC, DI, and AOP, demonstrates a simple Hello World application with Spring Boot, then shows how to implement the same functionality using raw Servlets and a handcrafted mini‑Spring framework, complete with code examples and deployment steps.

Dependency InjectionIOCJava
0 likes · 23 min read
Understanding Spring Core Concepts and Building a Minimal Servlet‑Based Framework
Su San Talks Tech
Su San Talks Tech
Sep 7, 2022 · Backend Development

Demystifying Spring Bean Lifecycle: From Creation to Destruction

This article explains the Spring Bean lifecycle in depth, covering IoC fundamentals, each lifecycle stage, extension points such as Aware interfaces and BeanPostProcessor, and provides a step‑by‑step code walkthrough that maps the execution flow from bean creation to destruction.

BackendBean LifecycleDependency Injection
0 likes · 12 min read
Demystifying Spring Bean Lifecycle: From Creation to Destruction
Top Architect
Top Architect
Aug 29, 2022 · Backend Development

Ways to Register Beans into the Spring Container

This article explains various methods to add beans to the Spring IoC container, including @Configuration with @Bean, component scanning, @Import with selectors or registrars, FactoryBean usage, and BeanDefinitionRegistryPostProcessor, providing code examples and detailed explanations for each approach.

Bean RegistrationDependency InjectionIOC
0 likes · 9 min read
Ways to Register Beans into the Spring Container
Laravel Tech Community
Laravel Tech Community
Aug 1, 2022 · Fundamentals

Understanding Inversion of Control (IoC) with PHP Code Examples

This article explains the Inversion of Control (IoC) principle, contrasts a tightly coupled logging implementation with a dependency‑injected version in PHP, and demonstrates how passing a logger via the constructor decouples classes and follows the open‑closed principle.

Dependency InjectionDesign PatternsIOC
0 likes · 3 min read
Understanding Inversion of Control (IoC) with PHP Code Examples
Selected Java Interview Questions
Selected Java Interview Questions
Jul 31, 2022 · Backend Development

Understanding Spring IoC, Bean Instantiation, and Dependency Injection

This article explains the concepts of coupling, Inversion of Control, and Dependency Injection in the Spring framework, demonstrates various bean instantiation methods—including no‑arg constructors, static and instance factory methods—and provides a complete example of configuring and using Spring beans in a Java application.

@BeanDependency InjectionIOC
0 likes · 9 min read
Understanding Spring IoC, Bean Instantiation, and Dependency Injection
Top Architect
Top Architect
Jul 11, 2022 · Backend Development

Spring Core Concepts and Building a Mini Framework Without Spring

This article explains Spring's core features such as IoC, DI and AOP, demonstrates creating a simple Hello World service with Spring Boot, then shows how to implement the same functionality using raw Servlets and finally builds a miniature Spring‑like framework with custom annotations, an IOC container and a dispatcher servlet.

AOPIOCJava
0 likes · 19 min read
Spring Core Concepts and Building a Mini Framework Without Spring
Sanyou's Java Diary
Sanyou's Java Diary
May 19, 2022 · Backend Development

Mastering Spring: Core Concepts, Modules, Annotations & Advanced Features

This comprehensive guide walks through Spring’s fundamentals—including IoC, DI, core modules, common annotations, AOP concepts, transaction management, MVC workflow, and Spring Boot auto‑configuration—while also covering advanced topics such as bean lifecycle, circular dependencies, proxy mechanisms, and an introduction to Spring Cloud.

AOPDependency InjectionIOC
0 likes · 54 min read
Mastering Spring: Core Concepts, Modules, Annotations & Advanced Features
IT Xianyu
IT Xianyu
Apr 1, 2022 · Backend Development

Why Use Spring? Understanding How It Solves Coupling Problems with Dependency Injection

This article compares traditional object creation with Spring’s dependency injection, demonstrating how injecting DAO beans via XML configuration decouples service and data layers, includes Java code examples, test results, and visual analogies of gear systems to illustrate reduced coupling.

Dependency InjectionIOCInversion of Control
0 likes · 5 min read
Why Use Spring? Understanding How It Solves Coupling Problems with Dependency Injection
Sohu Tech Products
Sohu Tech Products
Mar 23, 2022 · Backend Development

Building a Simple Spring IOC Container: XML and Annotation‑Based Bean Assembly

This article demonstrates how to create a lightweight Spring‑style IoC container in Java by parsing a properties file for XML‑like configuration, implementing annotation‑driven bean registration with a custom @Bean annotation, and adding automatic field injection using a custom @Autowired annotation, complete with full source code examples.

Dependency InjectionIOCJava
0 likes · 11 min read
Building a Simple Spring IOC Container: XML and Annotation‑Based Bean Assembly
macrozheng
macrozheng
Mar 16, 2022 · Backend Development

Build a Mini Spring IoC Container in 5 Minutes: Hands‑On Tutorial

This article walks through the fundamentals of Spring’s IoC container by manually implementing a lightweight version, covering concepts such as IOC, DI, bean definitions, resource loading, bean registration, and a simple BeanFactory with example code and a test demonstrating singleton caching.

BeanFactoryDependency InjectionIOC
0 likes · 10 min read
Build a Mini Spring IoC Container in 5 Minutes: Hands‑On Tutorial
Java High-Performance Architecture
Java High-Performance Architecture
Mar 1, 2022 · Backend Development

Unlocking Spring: Core Principles, Design Patterns, and IoC Explained

This comprehensive guide walks through Spring's lightweight Java framework, covering its core principles, key features, advantages and drawbacks, the design patterns it employs, core modules, IoC container mechanics, bean scopes, lifecycle, dependency injection techniques, and AOP fundamentals, all illustrated with diagrams and code snippets.

AOPDependency InjectionDesign Patterns
0 likes · 48 min read
Unlocking Spring: Core Principles, Design Patterns, and IoC Explained
政采云技术
政采云技术
Jan 4, 2022 · Backend Development

Understanding Dependency Injection in NestJS

This article explains the core concepts of dependency injection, inversion of control, and metadata reflection in NestJS, demonstrates how they are implemented with TypeScript decorators and reflective metadata, and walks through the framework's internal IoC container, module scanning, and instance creation process.

Dependency InjectionIOCNestJS
0 likes · 15 min read
Understanding Dependency Injection in NestJS
Su San Talks Tech
Su San Talks Tech
Dec 15, 2021 · Backend Development

Top 18 Spring Interview Questions and Answers You Must Know

Explore a comprehensive list of 18 essential Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy types, bean lifecycle, circular dependency resolution, transaction management, and Spring Boot auto‑configuration, complete with concise explanations and illustrative diagrams to help you ace your interview.

AOPBackendIOC
0 likes · 17 min read
Top 18 Spring Interview Questions and Answers You Must Know
Code Ape Tech Column
Code Ape Tech Column
Nov 13, 2021 · Backend Development

Spring Framework Interview Questions and Answers Overview

This article compiles a comprehensive set of Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy mechanisms, bean lifecycle, circular dependency resolution, transaction isolation and propagation, as well as Spring Boot auto‑configuration principles, providing concise explanations for each topic.

AOPDependency InjectionDesign Patterns
0 likes · 16 min read
Spring Framework Interview Questions and Answers Overview
Java Architect Essentials
Java Architect Essentials
Sep 22, 2021 · Backend Development

Spring Framework Overview: Concepts, Modules, Configuration, and Annotations

This article provides a comprehensive overview of the Spring Framework, covering its definition, advantages, core features such as IoC, AOP, MVC, transaction management, the various modules and their purposes, configuration methods (XML, annotations, Java API), bean scopes, lifecycle, autowiring, and key annotations used in modern Java backend development.

Bean LifecycleDependency InjectionIOC
0 likes · 14 min read
Spring Framework Overview: Concepts, Modules, Configuration, and Annotations
Architecture Digest
Architecture Digest
Aug 26, 2021 · Backend Development

Injecting Beans with Annotations in Spring

This article explains how to use Spring annotations such as @Component, @Configuration, @Bean, @Autowired, and @Qualifier to inject beans via XML replacement, constructor injection, setter injection, property injection, List and Map injection, providing code examples and detailed explanations for each method.

BackendDependency InjectionIOC
0 likes · 9 min read
Injecting Beans with Annotations in Spring
Tencent Cloud Developer
Tencent Cloud Developer
Aug 25, 2021 · Fundamentals

A Comprehensive Guide to JavaScript/TypeScript Decorators and Their Practical Use

The guide explains JavaScript/TypeScript decorators—an ECMAScript stage‑2 proposal used in frameworks like Angular, Nest.js, and TypeORM—by distinguishing the decorator pattern, function, and @syntax, demonstrating a four‑step manual implementation that logs execution time, and linking decorators to AOP, IoC, and DI concepts.

AOPDecoratorIOC
0 likes · 10 min read
A Comprehensive Guide to JavaScript/TypeScript Decorators and Their Practical Use
Top Architect
Top Architect
Jul 31, 2021 · Backend Development

Understanding Spring Bean Instantiation Process

This article explains how Spring's IoC container creates and manages beans, covering the container startup phase, bean definition loading, BeanFactoryPostProcessor and BeanPostProcessor extensions, object creation strategies, property injection, Aware interfaces, and bean lifecycle callbacks.

@BeanDependency InjectionIOC
0 likes · 14 min read
Understanding Spring Bean Instantiation Process
Top Architect
Top Architect
Jun 20, 2021 · Backend Development

Understanding Spring IoC (Inversion of Control) and Dependency Injection (DI)

This article explains the concepts of Inversion of Control (IoC) and Dependency Injection (DI) in the Spring framework, describing how containers manage object creation, reduce coupling, improve testability, and embody the Hollywood principle for more flexible Java backend development.

Dependency InjectionIOCInversion of Control
0 likes · 9 min read
Understanding Spring IoC (Inversion of Control) and Dependency Injection (DI)
Programmer DD
Programmer DD
Jun 14, 2021 · Backend Development

Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained

This comprehensive guide explores the Spring framework’s fundamentals, including its lightweight architecture, core IoC container, dependency injection mechanisms, bean scopes and lifecycle, annotation‑based configuration, data‑access support, and aspect‑oriented programming features, providing developers with a solid foundation for building robust Java applications.

AOPBean LifecycleDependency Injection
0 likes · 45 min read
Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained
Java Tech Enthusiast
Java Tech Enthusiast
Jun 3, 2021 · Backend Development

Master Spring IoC: From Bean Creation to Dependency Injection

This tutorial explains the concept of Inversion of Control in Spring, demonstrates how to configure beans with XML, compares BeanFactory and ApplicationContext, explores bean scopes and lifecycle, and provides detailed examples of constructor, static‑factory, instance‑factory, and collection injection techniques.

@BeanDependency InjectionIOC
0 likes · 19 min read
Master Spring IoC: From Bean Creation to Dependency Injection
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 13, 2021 · Backend Development

Spring Framework Core Components, IOC, AOP, Bean Lifecycle and Related Concepts

This article provides a comprehensive overview of the Spring framework, covering its core modules, version compatibility, core concepts such as IoC and AOP, proxy implementations, bean factories, lifecycle management, transaction handling, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.

AOPBackendIOC
0 likes · 34 min read
Spring Framework Core Components, IOC, AOP, Bean Lifecycle and Related Concepts
Java Interview Crash Guide
Java Interview Crash Guide
Apr 28, 2021 · Backend Development

Inside Spring: How Beans Are Instantiated Step by Step

This article explains the two‑phase lifecycle of Spring beans, covering container startup tasks, metadata loading, bean definition registration, and the detailed instantiation process including object creation strategies, BeanWrapper, property injection, Aware interfaces, post‑processors, and custom init/destroy logic.

@BeanDependency InjectionIOC
0 likes · 16 min read
Inside Spring: How Beans Are Instantiated Step by Step
Selected Java Interview Questions
Selected Java Interview Questions
Apr 27, 2021 · Backend Development

Understanding the Spring Bean Instantiation Process

This article explains how the Spring IoC container prepares and creates Bean instances, detailing the two main phases—container startup and Bean instantiation—along with the roles of BeanDefinition, BeanFactoryPostProcessor, BeanWrapper, Aware interfaces, BeanPostProcessor, and custom initialization and destruction logic.

@BeanBackendDependency Injection
0 likes · 16 min read
Understanding the Spring Bean Instantiation Process
Programmer DD
Programmer DD
Apr 16, 2021 · Backend Development

Demystifying Spring IoC and Dependency Injection: A Clear Guide for Beginners

This article explains the core concepts of Spring's Inversion of Control (IoC) and Dependency Injection (DI), illustrating how a container takes over object creation and wiring, why this reversal improves modularity and testability, and how the two ideas are essentially two views of the same design principle.

BackendDependency InjectionDesign Patterns
0 likes · 10 min read
Demystifying Spring IoC and Dependency Injection: A Clear Guide for Beginners
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 9, 2021 · Backend Development

Understanding Spring: Core Concepts, IoC, DI, AOP, and Annotations Explained

This article provides a comprehensive overview of the Spring framework, covering its lightweight architecture, core principles such as Inversion of Control and Dependency Injection, AOP mechanisms, design goals, module structure, common design patterns, bean lifecycle, circular dependency handling, and the most frequently used Spring annotations with code examples.

AOPIOCJava
0 likes · 41 min read
Understanding Spring: Core Concepts, IoC, DI, AOP, and Annotations Explained
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.

Dependency InjectionIOCInversion of Control
0 likes · 10 min read
Understanding IoC: Inversion of Control, Dependency Injection, and Their Benefits
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 18, 2020 · Backend Development

Understanding Spring Framework: Core Concepts, Advantages, and Bean Management

This article provides a comprehensive overview of the Spring framework, explaining its IoC and AOP core, architectural layers, key advantages such as decoupling and declarative transactions, bean scopes, lifecycle settings, and practical object‑creation methods for Java backend development.

BackendBean ScopeIOC
0 likes · 7 min read
Understanding Spring Framework: Core Concepts, Advantages, and Bean Management
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
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 InjectionDesign Patterns
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 InjectionDesign PatternsIOC
0 likes · 7 min read
Understanding IoC, Simple Factory, and Dependency Injection in PHP
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.

BackendDependency InjectionDesign Patterns
0 likes · 20 min read
Deep Dive into Spring IOC Container Initialization Process
JD Retail Technology
JD Retail Technology
Apr 8, 2020 · Backend Development

Building a Simplified Spring Framework: Step‑by‑Step IOC, DI, and MVC Implementation

This article walks through creating a lightweight Spring‑like framework in Java, detailing the project structure, startup process, MVC module initialization, core IOC container design, BeanDefinition handling, bean registration, dependency injection, and circular‑dependency resolution, all illustrated with diagrams and code snippets.

IOCMVCSpring
0 likes · 7 min read
Building a Simplified Spring Framework: Step‑by‑Step IOC, DI, and MVC Implementation
Node Underground
Node Underground
Mar 10, 2020 · Backend Development

Building a Micro‑Backend with Midway: Split Monorepo Apps into Independent Services

This article explores the concept of a “micro‑backend” by adapting micro‑frontend principles to server‑side applications, detailing how to use IoC, monorepo management with Lerna, and Midway’s configurable scanning to split a large Node.js codebase into independent, maintainable domain modules without changing developer workflows.

IOCService Splittingmicro-backend
0 likes · 10 min read
Building a Micro‑Backend with Midway: Split Monorepo Apps into Independent Services
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
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 InjectionDesign Patterns
0 likes · 17 min read
Common Design Patterns Used in the Spring Framework
Node Underground
Node Underground
Mar 10, 2019 · Backend Development

Build Your Own IoC Container in JavaScript: A Step‑by‑Step Guide

This tutorial walks you through creating a simple Inversion of Control (IoC) container in JavaScript, covering basic dependency injection, adding caching for singleton instances, and extending the container to load arbitrary classes automatically, all with clear code examples.

IOCcontainer
0 likes · 7 min read
Build Your Own IoC Container in JavaScript: A Step‑by‑Step Guide
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.

AOPBackendDependency Injection
0 likes · 26 min read
Mastering Spring Framework: Core Concepts, Modules, and Practical Guides
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
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
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 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
Java Backend Technology
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
MaGe Linux Operations
MaGe Linux Operations
Aug 19, 2017 · Information Security

How XShell Became a Backdoor: Deep Dive into Its Malicious Shellcode

Tencent Security Lab dissected the compromised XShell remote terminal, revealing a three‑stage malicious process where patched binaries load encrypted shellcode, exfiltrate system information via dynamically generated DGA domains, and ultimately deploy a svchost‑based payload, with detailed IOC listings and remediation advice.

DGAIOCMalware Analysis
0 likes · 7 min read
How XShell Became a Backdoor: Deep Dive into Its Malicious Shellcode
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
Architecture Digest
Architecture Digest
May 17, 2016 · Backend Development

Introduction to the Spring Framework: Core Concepts, Bean Management, and AOP

This article provides a comprehensive overview of the Spring framework, covering its low‑invasion design, IoC container, dependency injection types, bean scopes, autowiring options, bean creation methods, post‑processors, zero‑configuration annotations, and AOP support with AspectJ, supplemented by practical code examples.

@BeanAOPBackend
0 likes · 20 min read
Introduction to the Spring Framework: Core Concepts, Bean Management, and AOP
Architecture Digest
Architecture Digest
Apr 3, 2016 · Backend Development

Design and Development of Albianj: A Distributed Java Framework for Large-Scale Data Access

The article presents the design and implementation of Albianj, a Java‑based distributed development framework that emphasizes consistency, scalability, and data routing to handle massive real‑time data across hundreds of servers, detailing its architecture, kernel, IoC, DataRouter, ORM, and distributed transaction mechanisms.

BackendDistributed FrameworkIOC
0 likes · 30 min read
Design and Development of Albianj: A Distributed Java Framework for Large-Scale Data Access
Qunar Tech Salon
Qunar Tech Salon
Jan 31, 2016 · Backend Development

Understanding Dependency Injection in Spring: Concepts, Configuration Methods, and Code Samples

This article explains the fundamentals of dependency and dependency injection in Spring, compares class relationships such as inheritance, association, aggregation, and composition, and demonstrates constructor, static‑factory, instance‑factory, setter, constant, and ID reference injection with detailed XML configurations and Java code examples.

Bean ConfigurationConstructor InjectionDependency Injection
0 likes · 18 min read
Understanding Dependency Injection in Spring: Concepts, Configuration Methods, and Code Samples
Qunar Tech Salon
Qunar Tech Salon
Jan 30, 2016 · Backend Development

Spring IoC Bean Configuration, Naming, and Instantiation Guide

This article explains how to structure Spring XML configuration files, define bean metadata, use id/name/alias for bean naming, and instantiate beans via constructors, static factory methods, or instance factories, providing detailed code examples and JUnit tests for each approach.

@BeanDependency InjectionIOC
0 likes · 12 min read
Spring IoC Bean Configuration, Naming, and Instantiation Guide