JAVA EE

Monday, 10 September 2018

Spring Auto-Wiring Beans with @Autowired annotation in setter method | Spring @Autowired Annotation

Master Spring & Java Development!

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

Overview: Setter Injection with @Autowired

In the Spring Framework, Dependency Injection can be achieved through multiple mechanisms, including constructor, field, and setter injection. Using the @Autowired annotation on setter methods allows Spring to inject dependencies via traditional JavaBean getter and setter conventions, providing flexibility for optional or reconfigurable dependencies.

In this guide, you will learn how setter-based dependency injection works using @Autowired, how Spring resolves bean dependencies by type, and how to configure it cleanly in your Java applications.

How @Autowired Works on Setter Methods

Applying @Autowired on a setter method follows standard Spring autowiring mechanics:

Injection by Type: Spring inspects the parameter type of the setter method and scans the ApplicationContext for a matching bean.
Encapsulation Preserved: Keeps internal class fields private while exposing standard mutator methods for dependency configuration.
Flexibility & Re-injection: Allows dependencies to be changed, reassigned, or supplied dynamically during unit testing or runtime reconfiguration.
Works with Arbitrary Method Names: Although conventionally used with standard setter methods (e.g., setService(...)), @Autowired can technically be placed on any configuration method with arguments.

Step-by-Step Implementation

Define the Dependency Bean: Create the component to be injected and register it within the Spring container (e.g., via @Component or XML bean definition).
Add the Setter Method: Define a setter method for the property and annotate it with @Autowired:
@Autowired public void setPaymentService(PaymentService paymentService) { this.paymentService = paymentService; }
Run the Spring Application: When the container instantiates the target bean, it automatically detects the annotated setter and passes the matching dependency into it.

Recommended Next Videos from Ram N Java

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

Click the below Image to Enlarge:

Spring Auto-Wiring Beans with @Autowired annotation in setter method | Spring @Autowired Annotation

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;

    private Address address;

    public Employee(String name)

    {

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

                + "is called by the Spring container");

        this.name = name;

    }

    @Autowired

    public void setAddress(Address address)

    {

        this.address = address;

    }

    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 18, 2018 10:35:33 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Sat Aug 18 10:35:33 IST 2018]; root of context hierarchy

Aug 18, 2018 10:35:33 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]]