Introduction

The Spring Context is one of the most critical aspects of the Spring Framework. It's part of the larger Spring Framework ecosystem, responsible for managing the lifecycle of beans and enabling dependency injection.

What is Spring Context?#

The Spring Context is the core component of the Spring Framework, representing the Spring IoC (Inversion of Control) container. It is responsible for managing the lifecycle of beans, including their creation, configuration, and destruction. The Spring Context acts as a container that holds the beans and provides them to the application whenever required.

In simple terms, it manages the dependencies between objects, ensuring that they are appropriately initialized and configured before being used.

Core Concepts of Spring Context#

Before diving into examples, let's explore some core concepts:

Beans: Objects managed by the Spring IoC container. Beans are instantiated, configured, and assembled by the container.
Dependency Injection (DI): A technique where the Spring IoC container injects dependencies (beans) into other beans. This decouples the objects, making them easier to manage and test.
BeanFactory: The most basic container in Spring that provides the configuration framework and basic functionality. However, it is often replaced by ApplicationContext in modern applications.
ApplicationContext: A more advanced container that provides additional features like event propagation, declarative mechanisms to create a bean, and integration with Spring's AOP.

Types of ApplicationContext#

Spring provides several implementations of the ApplicationContext, each suitable for different use cases:

ClassPathXmlApplicationContext: Loads the context definition from an XML file located in the classpath.
FileSystemXmlApplicationContext: Loads the context definition from an XML file in the file system.
AnnotationConfigApplicationContext: Loads the context definition from Java-based configuration classes using annotations.
WebApplicationContext: A specialized version of ApplicationContext used in web applications.

Setting Up a Spring Context#

Let's start with a basic example using AnnotationConfigApplicationContext.

Example: Setting Up Spring Context with Annotations#

Step 1: Define a simple bean



package com.example;

import org.springframework.stereotype.Component;

@Component
public class HelloWorld {
    public void sayHello() {
        System.out.println("Hello, Spring Context!");
    }
}

Step 2: Define a configuration class


package com.example;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

Step 3: Load the Spring Context in the main application


package com.example;

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        HelloWorld helloWorld = context.getBean(HelloWorld.class);
        helloWorld.sayHello();
    }
}

Explanation:

HelloWorld Bean: A simple bean managed by Spring, defined with the @Component annotation.
AppConfig: A configuration class annotated with @Configuration, which tells Spring to use this class for configuration. The @ComponentScan annotation is used to specify the package where Spring should look for beans.
MainApp: The main application class that loads the Spring context using AnnotationConfigApplicationContext and retrieves the HelloWorld bean.

When you run MainApp, you'll see the output "Hello, Spring Context!" printed on the console.

Example: Setting Up Spring Context with XML Configuration#

If you prefer XML configuration, here’s how you can achieve the same with ClassPathXmlApplicationContext.


<!-- Step 1: Define the bean in XML (beans.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="helloWorld" class="com.example.HelloWorld"/>

</beans>


// Step 2: Load the Spring Context in the main application
package com.example;

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
        helloWorld.sayHello();
    }
}

In this example, the beans.xml file defines the HelloWorld bean. The MainApp class loads this XML file using ClassPathXmlApplicationContext.

Full Example: A Simple Spring Application#

Let's put everything together in a full example of a simple Spring application that manages an employee database.

Step 1: Create the Employee Class


package com.example;

import org.springframework.stereotype.Component;

@Component
public class Employee {
    private String name;
    private String department;

    // Constructors, Getters, and Setters

    public Employee() {}

    public Employee(String name, String department) {
        this.name = name;
        this.department = department;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public void displayEmployeeInfo() {
        System.out.println("Employee Name: " + name);
        System.out.println("Employee Department: " + department);
    }
}

Step 2: Create a Configuration Class


package com.example;

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

@Configuration
public class AppConfig {

    @Bean
    public Employee employee() {
        return new Employee("John Doe", "Engineering");
    }
}

Step 3: Load the Context and Use the Bean


package com.example;

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        Employee employee = context.getBean(Employee.class);
        employee.displayEmployeeInfo();
    }
}

Explanation:

The Employee class is a simple POJO with fields for name and department, along with methods
The AppConfig class is annotated with @Configuration, and it defines a @Bean method that returns an instance of Employee.
In MainApp, we load the Spring Context using AnnotationConfigApplicationContext and retrieve the Employee bean to display the employee's information.

When you run the MainApp class, it will output:


Employee Name: John Doe
Employee Department: Engineering

This simple application demonstrates how Spring Context manages beans and their dependencies, allowing you to focus on building your application without worrying about the underlying object creation and wiring.

In this article, we covered the Spring Context, a vital component of the Spring Framework responsible for managing the lifecycle of beans and enabling dependency injection. We explored key concepts such as beans, dependency injection, BeanFactory, and ApplicationContext, and discussed different types of ApplicationContext for various use cases. Through practical examples, we demonstrated how to set up a Spring Context using both annotation-based and XML-based configurations, showcasing how the Spring IoC container simplifies object management and dependency wiring in applications.

Introduction To Spring Boot