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

Preface

The previous three articles explored why Spring exists, introduced the early ideas of IoC and AOP, and traced Spring's historical evolution. This piece assumes you are already comfortable using Spring and focuses on the core principles of Spring IoC.

Basic Concepts of IoC and DI

IoC (Inversion of Control) is the kernel of the Spring container; AOP, transaction management, and other features are built on it. IoC means the control of selecting a concrete implementation for an interface is handed over to a third‑party container. Martin Fowler later coined the term Dependency Injection (DI) to describe the same idea from a different angle: a container injects the required dependencies into a class.

Today IoC and DI are used interchangeably to describe this mechanism.

Where to Start with the IoC Container?

Understanding Spring’s internals starts with a clear view of the project structure, inheritance relationships, and bean configuration files, as illustrated by the following diagrams.

Key classes highlighted in red are the entry points for using the container.

The main code example shows how ClassPathXmlApplicationContext and FileSystemXmlApplicationContext inherit from the top‑level Spring interfaces.

Relationship Between BeanFactory and ApplicationContext

Both BeanFactory and ApplicationContext are forms of the Spring IoC container. BeanFactory implementations constitute a simple container series that provide only the most basic features. ApplicationContext implementations form an advanced container series that add framework‑level capabilities such as internationalization, event publishing, and more.

In practice we often refer to BeanFactory as the “IoC container” and ApplicationContext as the “Spring container.”

First Route: Simple Container Series Based on BeanFactory

Using BeanFactory you can load bean definitions from XML, register them, and retrieve beans. The typical steps are:

Create an abstract resource representing the IoC configuration file (bean definitions).

Instantiate a DefaultListableBeanFactory.

Create an XmlBeanDefinitionReader to load the XML definitions into the factory.

Read and parse the configuration, completing the container setup.

After registration, the container is ready for use.

The DefaultListableBeanFactory implementation provides the basic injection and retrieval capabilities.

The BeanFactory interface sits at the top of the hierarchy, defining the essential features of an IoC container.

Second Route: Advanced Container Series Based on ApplicationContext

ApplicationContext builds on BeanFactory by adding features such as MessageSource, ApplicationEventPublisher, and other framework‑level services, making it a fully‑featured container suitable for most applications.

Key implementations are ClassPathXmlApplicationContext (loads configuration from the classpath) and FileSystemXmlApplicationContext (loads from the file system).

Third Route: Web Container Series Based on WebApplicationContext

For web applications, Spring provides WebApplicationContext, which extends ApplicationContext with web‑specific features. When integrating Spring MVC, ContextLoaderListener uses the contextConfigLocation parameter to locate the configuration file, typically loading an XmlWebApplicationContext instance.

Conclusion

This article does not aim to exhaustively detail every aspect of the Spring IoC container; instead, it organizes the core concepts into three learning routes to help readers gradually master the framework without being overwhelmed by its extensive class hierarchy.

Further study is encouraged, with recommended books such as “Spring in Action” and “Mastering Spring 4.x Enterprise Application Development.”