JAVA EE: Spring Auto-Wiring Beans with @Autowired annotation[AutowiredAnnotationBeanPostProcessor]

Friday, 31 August 2018

Spring Auto-Wiring Beans with @Autowired annotation[AutowiredAnnotationBeanPostProcessor]

Master Spring & Java Development!

Subscribe to Ram N Java for clean, beginner-friendly coding guides!

Overview: How @Autowired Works Under the Hood

In the Spring Framework, the @Autowired annotation makes dependency injection simple and clean. But what happens behind the scenes when Spring encounters @Autowired on a field, constructor, or setter? The entire process is managed internally by a special component called the AutowiredAnnotationBeanPostProcessor.

In this guide, you will learn the internal mechanics of how AutowiredAnnotationBeanPostProcessor scans, processes, and injects dependencies to bring Spring's autowiring mechanism to life.

What is AutowiredAnnotationBeanPostProcessor?

The AutowiredAnnotationBeanPostProcessor is an implementation of Spring's BeanPostProcessor interface responsible for handling annotation-driven injection:

Annotation Detection: It scans managed beans for injection annotations, primarily @Autowired, @Value, and JSR-330's @Inject.
Lifecycle Hook: During bean instantiation, it intercepts the bean lifecycle right after instantiation and injects the corresponding dependencies into fields, setters, or methods before initialization callbacks run.
Automatic Registration: When using <context:annotation-config /> or <context:component-scan /> in XML, or using modern Java config, Spring automatically registers this post-processor into the ApplicationContext.
Candidate Resolution: It interacts with the BeanFactory to locate matching beans by type, resolve ambiguities with qualifiers, and evaluate required vs. optional dependencies.

Enabling AutowiredAnnotationBeanPostProcessor

Explicit Bean Declaration (Optional): You can define the processor directly as a bean in your XML:
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
Context Annotation Config: Alternatively, declaring <context:annotation-config/> automatically registers AutowiredAnnotationBeanPostProcessor along with other common annotation processors.
Autowiring Execution: Once registered, any class marked with @Autowired on fields, setters, or constructors will have its dependencies resolved seamlessly.

Recommended Next Videos from Ram N Java

Click here to watch on Youtube:
https://www.youtube.com/watch?v=_OCzBIVFSEI&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

Spring Auto-Wiring Beans with @Autowired annotation[AutowiredAnnotationBeanPostProcessor]

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0%20http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ram.core</groupId>

    <artifactId>SpringDemo</artifactId>

    <packaging>jar</packaging>

    <version>1.0-SNAPSHOT</version>

    <name>SpringDemo</name>

    <url>http://maven.apache.org</url>

    <properties>

        <spring.version>5.0.2.RELEASE</spring.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>3.8.1</version>

            <scope>test</scope>

        </dependency>

        <!-- Spring 5 dependencies -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

        </dependency>

    </dependencies>

</project>

Address.java

package com.ram.model;

public class Address

{

    private String city;

    private String state;

    private String country;

    public Address(String city, String state, String country)

    {

        this.city = city;

        this.state = state;

        this.country = country;

    }

    @Override

    public String toString()

    {

        return "Address [city=" + city + ", state=" + state + ", country="

                + country + "]";

    }

}

Employee.java

package com.ram.model;

import org.springframework.beans.factory.annotation.Autowired;

public class Employee

{

    private String name;

    @Autowired

    private Address address;

    public Employee(String name)

    {

        System.out.println("Employee(String name) constructor "

                + "is called by the Spring container");

        this.name = name;

    }

    public void displayEmployeeDetails()

    {

        System.out.println(

                "Employee [name=" + name + ", address=" + address + "]");

    }

}

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-4.3.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-4.3.xsd">

    <bean

        class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

    <bean id="address" class="com.ram.model.Address">

        <constructor-arg value="Chennai"></constructor-arg>

        <constructor-arg value="Tamil Nadu"></constructor-arg>

        <constructor-arg value="India"></constructor-arg>

    </bean>

    <bean id="employee" class="com.ram.model.Employee">

        <constructor-arg value="Peter"></constructor-arg>

    </bean>

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ram.model.Employee;

public class App

{

    public static void main(String[] args)

    {

        ApplicationContext context = new ClassPathXmlApplicationContext(

                "applicationContext.xml");

        System.out.println("---------------------------------------");

        Employee employee = (Employee) context.getBean("employee");

        System.out.println(

                "Got employee object from the ApplicationContext[Spring Container]");

        employee.displayEmployeeDetails();

    }

}

Output

Aug 17, 2018 10:15:46 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Fri Aug 17 10:15:46 IST 2018]; root of context hierarchy

Aug 17, 2018 10:15:47 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

INFO: Loading XML bean definitions from class path resource [applicationContext.xml]

Employee(String name) constructor is called by the Spring container

---------------------------------------

Got employee object from the ApplicationContext[Spring Container]

Employee [name=Peter, address=Address [city=Chennai, state=Tamil Nadu, country=India]]