Skip to main content

Spring Application Context

Introduction​

The Spring Application Context is a core component of the Spring Framework that serves as a container for all the beans in your application. It is an advanced implementation of the Bean Factory, providing enterprise-specific functionality such as transaction management, AOP integration, and internationalization support. Understanding the Application Context is essential for developing Spring applications, as it is the cornerstone of dependency injection and inversion of control principles that make Spring so powerful.

In this tutorial, you'll learn:

  • What the Spring Application Context is
  • How it relates to the IoC (Inversion of Control) container
  • Different types of Application Contexts
  • How to create and configure an Application Context
  • How to retrieve and use beans from the Application Context
  • Best practices for working with the Application Context

What is the Spring Application Context?​

The Spring Application Context is an interface that represents the IoC container in Spring and is responsible for instantiating, configuring, and assembling beans. It reads configuration metadata from XML files, Java annotations, or Java code and uses it to create fully configured applications.

Key Features of Spring Application Context​

  • Bean Lifecycle Management: Controls the creation, initialization, and destruction of beans
  • Dependency Injection: Automatically injects dependencies into your beans
  • AOP Support: Enables aspect-oriented programming capabilities
  • Event Handling: Publishes and handles application events
  • Resource Management: Provides access to resources like properties files
  • Internationalization: Supports internationalization of messages

Types of Application Contexts​

Spring provides several implementations of the Application Context interface, each designed for specific use cases:

1. ClassPathXmlApplicationContext​

This context loads bean definitions from XML files located in the classpath.

java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

2. FileSystemXmlApplicationContext​

Similar to ClassPathXmlApplicationContext but loads XML files from the file system.

java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

ApplicationContext context = new FileSystemXmlApplicationContext("C:/configs/applicationContext.xml");

3. AnnotationConfigApplicationContext​

Designed for Java-based configuration using annotations.

java
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

4. WebApplicationContext​

Designed for web applications, it's loaded by Spring's DispatcherServlet or ContextLoaderListener.

Creating a Spring Application Context​

Let's start with a simple example of creating an Application Context using Java configuration:

Step 1: Define a configuration class​

java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    
    @Bean
    public MessageService messageService() {
        return new MessageServiceImpl();
    }
    
    @Bean
    public MessagePrinter messagePrinter() {
        MessagePrinter printer = new MessagePrinter();
        printer.setMessageService(messageService());
        return printer;
    }
}

Step 2: Define the beans​

java
public interface MessageService {
    String getMessage();
}

public class MessageServiceImpl implements MessageService {
    @Override
    public String getMessage() {
        return "Hello, Spring Application Context!";
    }
}

public class MessagePrinter {
    private MessageService messageService;
    
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }
    
    public void printMessage() {
        System.out.println(messageService.getMessage());
    }
}

Step 3: Create and use the Application Context​

java
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {
    public static void main(String[] args) {
        // Create the application context
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        // Get a bean from the context
        MessagePrinter printer = context.getBean(MessagePrinter.class);
        
        // Use the bean
        printer.printMessage();
    }
}

Output:

Hello, Spring Application Context!

XML Configuration vs. Java Configuration vs. Annotation Configuration​

Spring supports three primary approaches for configuring the Application Context:

XML Configuration:​

xml
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="messageService" class="com.example.MessageServiceImpl" />
    
    <bean id="messagePrinter" class="com.example.MessagePrinter">
        <property name="messageService" ref="messageService" />
    </bean>
</beans>

Java Configuration:​

java
@Configuration
public class AppConfig {
    
    @Bean
    public MessageService messageService() {
        return new MessageServiceImpl();
    }
    
    @Bean
    public MessagePrinter messagePrinter() {
        MessagePrinter printer = new MessagePrinter();
        printer.setMessageService(messageService());
        return printer;
    }
}

Annotation-Based Configuration:​

java
@Component
public class MessageServiceImpl implements MessageService {
    @Override
    public String getMessage() {
        return "Hello, Spring Application Context!";
    }
}

@Component
public class MessagePrinter {
    private final MessageService messageService;
    
    @Autowired
    public MessagePrinter(MessageService messageService) {
        this.messageService = messageService;
    }
    
    public void printMessage() {
        System.out.println(messageService.getMessage());
    }
}

Then enable component scanning:

java
@Configuration
@ComponentScan("com.example")
public class AppConfig {
    // No explicit bean definitions needed
}

Bean Scopes in the Application Context​

Spring beans can have different scopes that define their lifecycle and visibility:

  1. Singleton (default): One instance per Spring container
  2. Prototype: A new instance is created each time the bean is requested
  3. Request: One instance per HTTP request (for web applications)
  4. Session: One instance per HTTP session (for web applications)
  5. Application: One instance per ServletContext (for web applications)
  6. Websocket: One instance per WebSocket (for web applications)

Example of defining bean scopes:

java
@Configuration
public class AppConfig {
    
    @Bean
    @Scope("singleton")
    public MessageService singletonMessageService() {
        return new MessageServiceImpl();
    }
    
    @Bean
    @Scope("prototype")
    public MessageService prototypeMessageService() {
        return new MessageServiceImpl();
    }
}

Real-World Example: A Simple Spring MVC Application​

Let's look at how the Application Context works in a real-world Spring MVC application:

1. Configure the web.xml​

xml
<web-app>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

2. Configure the root Application Context​

xml
<!-- applicationContext.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.example.service" />
    
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/mydb" />
        <property name="username" value="root" />
        <property name="password" value="password" />
    </bean>
</beans>

3. Configure the web Application Context​

xml
<!-- dispatcher-servlet.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.example.controller" />
    
    <mvc:annotation-driven />
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

This creates a hierarchy of Application Contexts:

  1. Root Application Context (applicationContext.xml) - contains service and data source beans
  2. Web Application Context (dispatcher-servlet.xml) - contains web-related beans like controllers

Events in Spring Application Context​

The Spring Application Context supports an event publication and handling mechanism:

Publishing Events​

java
@Service
public class UserService {
    
    private final ApplicationEventPublisher eventPublisher;
    
    @Autowired
    public UserService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public void registerUser(User user) {
        // Register user logic
        
        // Publish event
        eventPublisher.publishEvent(new UserRegisteredEvent(user));
    }
}

public class UserRegisteredEvent {
    private final User user;
    
    public UserRegisteredEvent(User user) {
        this.user = user;
    }
    
    public User getUser() {
        return user;
    }
}

Listening for Events​

java
@Component
public class EmailService {
    
    @EventListener
    public void handleUserRegistration(UserRegisteredEvent event) {
        User user = event.getUser();
        // Send welcome email to user
        System.out.println("Sending welcome email to " + user.getEmail());
    }
}

Best Practices for Working with the Application Context​

  1. Favor Constructor Injection: Use constructor injection over field injection for mandatory dependencies.
java
// Good practice
@Service
public class OrderService {
    private final ProductRepository productRepository;
    
    @Autowired
    public OrderService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }
}

// Avoid
@Service
public class OrderService {
    @Autowired
    private ProductRepository productRepository;
}

  1. Use Java-based or Annotation Configuration: Modern Spring applications typically use Java-based or annotation-based configuration instead of XML.

  2. Keep Configuration Classes Organized: Group related beans into separate configuration classes.

  3. Avoid Direct Access to the Application Context: Don't use ApplicationContextAware unless absolutely necessary.

  4. Use Appropriate Bean Scopes: Default to singleton scope unless another scope is specifically needed.

  5. Profile-Based Configuration: Use profiles to manage different environments.

java
@Configuration
@Profile("development")
public class DevelopmentDataSourceConfig {
    // Development-specific beans
}

@Configuration
@Profile("production")
public class ProductionDataSourceConfig {
    // Production-specific beans
}

Common Issues and Troubleshooting​

NoSuchBeanDefinitionException​

This occurs when requesting a bean that doesn't exist in the Application Context.

Solution: Check bean names, ensure proper component scanning, and verify that the bean is properly defined.

BeanCreationException​

This happens when Spring encounters an error while creating a bean.

Solution: Check the bean's constructor, dependencies, and initialization method for errors.

UnsatisfiedDependencyException​

This occurs when Spring cannot satisfy a bean's dependencies.

Solution: Verify that all required dependencies are available in the Application Context.

Summary​

The Spring Application Context is a powerful IoC container that manages the lifecycle of beans and their dependencies. It provides essential features like dependency injection, AOP support, and event handling that make Spring applications flexible and maintainable.

Key takeaways:

  • The Application Context is a more advanced container than the BeanFactory
  • Multiple implementations exist for different use cases (ClassPathXmlApplicationContext, AnnotationConfigApplicationContext, etc.)
  • Configuration can be done using XML, Java code, or annotations
  • The Application Context manages bean lifecycles and supports different scopes
  • Events can be published and handled within the Application Context
  • Following best practices leads to more maintainable applications

Additional Resources​

Exercises​

  1. Create a simple Spring application that uses AnnotationConfigApplicationContext with two beans: a UserService and a UserRepository.
  2. Convert an XML-configured Application Context to a Java-based configuration.
  3. Implement a custom ApplicationEvent and EventListener to send notifications when a user is created.
  4. Configure an Application Context with different bean scopes and observe the difference in behavior.
  5. Create a Spring application with multiple configuration profiles for different environments.

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)