JAVA EE: Spring Auto-Wiring Beans with @Autowired annotation | Spring @Autowired Annotation

Friday, 31 August 2018

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!

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

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

Recommended Next Videos from Ram N Java

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

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