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

Master Spring & Java Development!

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

🔔 Subscribe to Ram N Java

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

1. Explicit Bean Declaration (Optional): You can define the processor directly as a bean in your XML:
   <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
2. Context Annotation Config: Alternatively, declaring <context:annotation-config/> automatically registers AutowiredAnnotationBeanPostProcessor along with other common annotation processors.
3. 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

• 👉 Understanding Field Injection with @Autowired Annotation in Spring | Spring @Autowired Annotation
• 👉 Understanding @Autowired Annotation in Setter Injection | Spring @Autowired Annotation
• 👉 Dependency Injection via Constructors with @Autowired annotation | Spring @Autowired Annotation

---

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]

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

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]]

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_AutowiredAnnotationBeanPostProcessor.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_AutowiredAnnotationBeanPostProcessor

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/32e1a08cd31cd492b211ed76e0174200305d8672/Spring_2018/SpringDemo_AutowiredAnnotationBeanPostProcessor/?at=master

See also:

All JavaEE Videos Playlist

All JavaEE Videos

All JAVA EE Links

Spring Tutorial

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

Spring Auto-Wiring Beans with @Autowired annotation | Spring @Autowired Annotation | Spring Tutorial

Master Spring & Java Development!

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

🔔 Subscribe to Ram N Java

Overview: Simplifying Dependency Injection with @Autowired

Dependency Injection (DI) is one of the foundational design patterns of the Spring Framework, allowing components to remain loosely coupled and easily testable. In traditional configurations, wiring beans required verbose XML property mappings. With the introduction of the @Autowired annotation, Spring revolutionized bean wiring by allowing the framework to resolve and inject dependencies automatically by type.

In this guide, you will learn how the @Autowired annotation simplifies dependency management, eliminates boilerplate XML configurations, and streamlines your Spring application architecture.

Key Benefits of @Autowired in Spring

The @Autowired annotation brings clean, declarative dependency injection to your code:

• Automatic Type-Driven Wiring: Spring inspects the target dependency type and automatically searches the container for a compatible bean match.
• Reduced XML Configuration: Replaces lengthy <property> or <constructor-arg> XML tags with concise annotations.
• Flexible Injection Points: Can be applied across constructors, setter methods, and directly on fields.
• Seamless Framework Integration: Works seamlessly with Spring's component scanning and bean lifecycle post-processors.

Step-by-Step Implementation

1. Register the Collaborator Bean: Create the class to be injected and register it within your Spring application context.
2. Apply the @Autowired Annotation: Mark the target dependency in your consumer class using @Autowired:
   @Autowired
private UserService userService;
3. Enable Annotation Processing: Ensure annotation config is enabled in your configuration (e.g., via <context:annotation-config /> or component scanning).
4. Run the Application: Spring instantiates the bean and injects the corresponding dependency automatically at startup.

Recommended Next Videos from Ram N Java

• 👉 Spring Auto-Wiring Beans with @Autowired annotation: AutowiredAnnotationBeanPostProcessor Explained
• 👉 Understanding Field Injection with @Autowired Annotation in Spring | Spring @Autowired Annotation
• 👉 Understanding @Autowired Annotation in Setter Injection | Spring @Autowired Annotation

---

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

Click the below Image to Enlarge:

Spring Auto-Wiring Beans with @Autowired annotation | Spring @Autowired Annotation | Spring Tutorial

Spring Auto-Wiring Beans with @Autowired annotation | Spring @Autowired Annotation | Spring Tutorial

Spring Auto-Wiring Beans with @Autowired annotation | Spring @Autowired Annotation | Spring Tutorial

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">

    <context:annotation-config />
 
    <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 9:50:25 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Fri Aug 17 09:50:25 IST 2018]; root of context hierarchy
Aug 17, 2018 9:50:25 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]]

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_Auto-Wiring_Beans_Autowired.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_Auto-Wiring_Beans_Autowired

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/32e1a08cd31cd492b211ed76e0174200305d8672/Spring_2018/SpringDemo_Auto-Wiring_Beans_Autowired/?at=master

See also:

All JavaEE Videos Playlist

All JavaEE Videos

All JAVA EE Links

Spring Tutorial

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

How to filter components in auto scanning? | Spring Filter components in auto scanning

Master Spring & Java Development!

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

🔔 Subscribe to Ram N Java

Overview: Filtering Components in Auto Scanning

In the Spring Framework, component scanning enables automatic detection and registration of beans marked with stereotypes such as @Component, @Repository, @Service, and @Controller. However, in larger enterprise applications, you often need fine-grained control over which classes get detected or excluded. Spring provides powerful filtering mechanisms using include-filter and exclude-filter options.

In this tutorial, you will learn how to customize component scanning by applying filters to include or exclude specific classes, annotations, or regex patterns in Spring.

Understanding Include and Exclude Filters

Spring's component scanning allows multiple filter types to customize bean registration:

• Include Filters (include-filter): Extends component scanning to detect classes that may not even have standard stereotype annotations.
• Exclude Filters (exclude-filter): Disallows specific classes or packages from being registered as beans, even if they have @Component annotations.
• Filter Types Supported:
  • annotation: Filter based on presence of a specific annotation.
  • assignable: Filter based on whether a class extends or implements a class/interface.
  • regex: Filter using regular expressions matching full class names.
  • aspectj: Filter matching AspectJ type patterns.

How to Configure Filters

1. Specify the Base Package: Define the base package to be scanned inside <context:component-scan> or @ComponentScan.
2. Add Exclude or Include Filter: Define the filter criteria directly inside the scanning configuration:
   <context:component-scan base-package="com.example">
  <context:exclude-filter type="regex" expression=".*Test.*"/>
</context:component-scan>
3. Bootstrap Application Context: When Spring starts up, it applies your custom filters, registering only the beans that pass your criteria.

Recommended Next Videos from Ram N Java

• 👉 Simplifying Dependency Injection with @Autowired Annotation | Spring Tutorial
• 👉 Spring Auto-Wiring Beans with @Autowired annotation: AutowiredAnnotationBeanPostProcessor Explained
• 👉 Understanding Field Injection with @Autowired Annotation in Spring | Spring @Autowired Annotation

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

Click the below Image to Enlarge:

How to filter components in auto scanning? | Spring Filter components in auto scanning

How to filter components in auto scanning? | Spring Filter components in auto scanning

How to filter components in auto scanning? | Spring Filter components in auto scanning

How to filter components in auto scanning? | Spring Filter components in auto scanning

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>

EmployeeDAO.java

package com.ram.dao;

public class EmployeeDAO
{
    public void addEmployee()
    {
        System.out.println("inside EmployeeDAO addEmployee()");
    }

}

EmployeeService.java

package com.ram.service;

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

import com.ram.dao.EmployeeDAO;

public class EmployeeService
{
    @Autowired
    EmployeeDAO employeeDAO;

    public void addEmployee()
    {
        System.out.println("inside EmployeeService addEmployee()");
        employeeDAO.addEmployee();
    }

    @Override
    public String toString()
    {
        return "EmployeeService [employeeDAO=" + employeeDAO + "]";
    }

}

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">

    <context:component-scan base-package="com.ram">

        <context:include-filter type="regex"
            expression="com.ram.dao.*DAO.*" />

        <context:include-filter type="regex"
            expression="com.ram.service.*Service.*" />

    </context:component-scan>

</beans>

App.java

package com.ram.core;

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

import com.ram.service.EmployeeService;

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

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

        EmployeeService employeeService = context.getBean("employeeService",
                EmployeeService.class);
        System.out.println(
                "Got employeeService object from the ApplicationContext(Spring Container)");

        System.out.println(employeeService);

        employeeService.addEmployee();

    }

}

Output

Aug 16, 2018 9:31:41 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Thu Aug 16 09:31:41 IST 2018]; root of context hierarchy
Aug 16, 2018 9:31:41 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
---------------------------------------
Got employeeService object from the ApplicationContext(Spring Container)
EmployeeService [employeeDAO=com.ram.dao.EmployeeDAO@782663d3]
inside EmployeeService addEmployee()
inside EmployeeDAO addEmployee()

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_Filter_auto_scanning.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_Filter_auto_scanning

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/32e1a08cd31cd492b211ed76e0174200305d8672/Spring_2018/SpringDemo_Filter_auto_scanning/?at=master

See also:

All JavaEE Videos Playlist

All JavaEE Videos

All JAVA EE Links

Spring Tutorial

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial