DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports
Events Video Library
Refcards
Trend Reports

Events

View Events Video Library

Zones

Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks

How does AI transform chaos engineering from an experiment into a critical capability? Learn how to effectively operationalize the chaos.

Data quality isn't just a technical issue: It impacts an organization's compliance, operational efficiency, and customer satisfaction.

Are you a front-end or full-stack developer frustrated by front-end distractions? Learn to move forward with tooling and clear boundaries.

Developer Experience: Demand to support engineering teams has risen, and there is a shift from traditional DevOps to workflow improvements.

Related

  • Modify JSON Data in Postgres and Hibernate 6
  • Java Bean Validation: Applying Constraints Programmatically
  • How Stalactite ORM Implements Its Fluent DSL
  • Top 10 C# Keywords and Features

Trending

  • AI-Native Platforms: The Unstoppable Alliance of GenAI and Platform Engineering
  • From Code to Customer: Building Fault-Tolerant Microservices With Observability in Mind
  • Operationalizing Data Quality in Cloud ETL Workflows: Automated Validation and Anomaly Detection
  • Defining Effective Microservice Boundaries - A Practical Approach To Avoiding The Most Common Mistakes
  1. DZone
  2. Data Engineering
  3. Data
  4. Autowiring in Spring

Autowiring in Spring

Spring can automatically detect the relationships between various beans. Learn how to do this using the XML-based autowiring functionality.

By 
John Thompson user avatar
John Thompson
·
Updated May. 16, 22 · Tutorial
Likes (44)
Comment
Save
Tweet
Share
218.3K Views

Join the DZone community and get the full member experience.

Join For Free

In this post, I’ll explain how to work with autowiring in Spring.

  • First, we’ll begin with a brief introduction on autowiring.
  • Then, we’ll look at the different modes of autowiring using XML configuration.
  • Finally, we’ll look at the @Autowired annotation with its different modes.

The Modes of Autowiring are:

  1. ‘no’ means the autowiring is OFF.
  2. ‘byName’ will look for a bean named exactly the same as the property that needs to be autowired.
  3. ‘byType’ permits a property to be autowired if there is exactly one bean of the property type in the container.
  4. ‘constructor’  is equivalent to byType but operates to constructor arguments.
  5. ‘Autodetect’ has been deprecated.

Introduction

Spring provides a way to automatically detect the relationships between various beans. This can be done by declaring all the bean dependencies in Spring configuration file. So, Spring is able to utilize the BeanFactory to know the dependencies across all the used beans.

The XML-configuration-based autowiring functionality has five modes – no, byName, byType, constructor, and autodetect. The default mode is no.

Autowiring Modes

Spring supports the following autowiring modes:

  • no: It’s the default autowiring mode. It means no autowiring.
  • byName: The byName mode injects the object dependency according to name of the bean. In such a case, the property and bean name should be the same. It internally calls the setter method.
  • byType: The byType mode injects the object dependency according to type. So it can have a different property and bean name. It internally calls the setter method.
  • constructor: The constructor mode injects the dependency by calling the constructor of the class. It calls the constructor having a large number of parameters.
  • autodetect: In this mode, Spring first tries to autowire by the constructor. If this fails, it tries to autowire by using byType.

1. Autowiring ‘no’:

This is a default autowiring mode. It means no autowiring.

<bean id="department" class="guru.springframework.autowiringdemo.Department">
  <property name="deptName" value="Information Technology" />
</bean>
<bean id="employee" class="guru.springframework.autowiringdemo.Employee"></bean>


2. Autowiring ‘byName’:

This option enables autowire based on bean names. Spring looks up the configuration file for a matching bean name. If found, this bean is injected in the property. However, if no such bean is found, an error is raised.

In this case, the name of the department bean is the same as the employee bean’s property (Department), so Spring will be autowired to it via the setter method –  setDepartment(Department department).

<bean id="department" class="guru.springframework.autowiringdemo.Department">
<property name="deptName" value="Information Technology" />
</bean>
<bean id="employee" class="guru.springframework.autowiringdemo.Employee" autowire="byName"></bean>


3. Autowiring ‘byType’:

This option enables the autowire based on bean type. It searches the property’s class type in the configuration file. It injects the property if such bean is found; otherwise, an error is raised.

In this case, the data type of the department bean is same as the data type of the employee bean’s property (Department object); therefore, Spring will autowire it via the setter method –  setDepartment(Department department).

<bean id="department" class="guru.springframework.autowiringdemo.Department">
<property name="deptName" value="Information Technology" />
</bean>
<bean id="employee" class="guru.springframework.autowiringdemo.Employee" autowire="byType"></bean>


4. Autowiring ‘constructor’

Autowiring by constructor is similar to byType but it applies to constructor arguments. It will look for the class type of constructor arguments, and then do an autowire byType on all constructor arguments. If exactly one bean of the constructor argument type is not present in the container, a fatal error will be raised.

The data type of department bean is the same as the constructor argument data type in the employee bean’s property (Department object). Therefore, Spring autowires it using the constructor method –  public Employee(Department department).

<bean id="department" class="guru.springframework.autowiringdemo.Department">
<property name="deptName" value="Information Technology" />
</bean>
<bean id="employee" class="guru.springframework.autowiringdemo.Employee" autowire="constructor"></bean>


5. Autowiring ‘autodetect’

Autowiring by autodetect uses two modes, i.e.constructor or byType modes. First, it will look for valid constructor with arguments. If it is found, then the constructor mode is chosen. If there is no constructor defined in a bean, the autowire byType mode is chosen.

In the following case, since there is a Department object in the Employee class, Spring autowires it using byType via the setter method – setDepartment(Department department).

<bean id="department" class="guru.springframework.autowiringdemo.Department">
<property name="deptName" value="Information Technology" />
</bean>
<bean id="employee" class="guru.springframework.autowiringdemo.Employee" autowire="autodetect"></bean>


Note: Autodetect functionality will work with the 2.5 and 2.0 schemas. It will not work from 3.0+.

Example of Autowiring

We’ll create a simple Java Bean, named Department. Department will have department name property with getter and setter methods. After that, we will initialize this property value in the Spring bean configuration file.

public class Department {
    private String deptName;
    public String getDeptName() {
        return deptName;
    }
    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
}

Now, let’s create our Employee class, in which we will inject Department bean through Spring autowiring.

public class Employee {
    private int eid;
    private String ename;
    private Department department;
    public int getEid() {
        return eid;
    }
    public void setEid(int eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }
    public void showEployeeDetails(){
        System.out.println("Employee Id : " + eid);
        System.out.println("Employee Name : " + ename);
        System.out.println("Department : " + department.getDeptName());
    }
}


Now, looking at the Spring bean configuration file, it is the main part of any Spring application. So, let’s see how our Spring bean configuration file looks.

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="department" class="guru.springframework.autowiringdemo.Department">
<property name="deptName" value="Information Technology" />
</bean>
<bean id="emp" class="guru.springframework.autowiringdemo.Employee" autowire="byName"></bean>
</beans>

Now, our Spring application is ready with all types of Spring autowiring. So, let’s write a simple test program to see if it works as expected.

@SpringBootApplication
public class AutowiringdemoApplication {
public static void main(String[] args) {

SpringApplication.run(AutowiringdemoApplication.class, args);
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Employee emp = context.getBean("employee", Employee.class);
emp.setEid(101);
emp.setEname("Spring Framework Guru");
emp.showEployeeDetails();
}

}

In the above program, we are just creating the Spring application context and using it to get different beans and printing the employee details.

After we run the above program, we get the following output:

Employee Id: 101
Employee Name: Spring Framework Guru
Department: Information Technology
Process finished with exit code 0


@Autowired Annotation

In Spring, you can use @Autowired annotation to auto-wire bean on the setter method, constructor, or a field. Moreover, it can autowire the property in a particular bean. We must first enable the annotation using below configuration in the configuration file.

If you are using Java-based configuration, you can enable annotation-driven injection by using below spring configuration:

@Configuration
@ComponentScan("guru.springframework.autowiringdemo")
public class AppConfig {}

As an alternative, we can use below XML-based configuration in Spring:

<context:annotation-config />

We have enabled annotation injection. After that, it can be used on modes like properties, setters, and constructors. Let’s discuss them one by one.

@Autowired on Properties

In the below example, when the annotation is directly used on properties, Spring looks for and injects Department when Employee is created. This is how it eliminates the need for getters and setters.

import org.springframework.stereotype.Component;
@Component
public class Department {
private String deptName;
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
}


import org.springframework.beans.factory.annotation.Autowired;
public class Employee {
    private int eid;
    private String ename;
    @Autowired
    private Department department;
    public int getEid() {
        return eid;
    }
    public void setEid(int eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void showEployeeDetails(){
        System.out.println("Employee Id : " + eid);
        System.out.println("Employee Name : " + ename);
        department.setDeptName("Information Technology");
        System.out.println("Department : " + department.getDeptName());
    }
}


@Autowired on Setters

In the below example, when the annotation is used on the setter method, the setter method is called with the instance of Department when Employee is created.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class Employee {
    private int eid;
    private String ename;
    private Department department;
    public int getEid() {
        return eid;
    }
    public void setEid(int eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public Department getDepartment() {
        return department;
    }
    @Autowired
    public void setDepartment(Department department) {
        this.department = department;
    }
    public void showEployeeDetails(){
        System.out.println("Employee Id : " + eid);
        System.out.println("Employee Name : " + ename);
        department.setDeptName("Information Technology");
        System.out.println("Department : " + department.getDeptName());
    }
}


@Autowired on Constructors

In the below example, the annotation is used on a constructor, an instance of Department is injected as an argument to the constructor when Employee is created.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class Employee {
    private int eid;
    private String ename;
    private Department department;
    @Autowired
    public EmployeeBean(DepartmentBean deptBean) {
        System.out.println("*** Autowiring by using @Autowire annotation on constructor ***");
        this.deptBean = deptBean;
    }
    public int getEid() {
        return eid;
    }
    public void setEid(int eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }
    public void showEployeeDetails(){
        System.out.println("Employee Id : " + eid);
        System.out.println("Employee Name : " + ename);
        department.setDeptName("Information Technology");
        System.out.println("Department : " + department.getDeptName());
    }
}


Writing a Test Program

So, let’s write a simple test program for @Autowired on the property to see if it works as expected.

@SpringBootApplication
public class AutowiringdemoApplication {
  public static void main(String[] args) {
    ConfigurableApplicationContext context = SpringApplication.run(AutowiringdemoApplication.class, args);
    Employee emp = context.getBean(Employee.class);
    emp.setEid(104);
    emp.setEname("Spring Framework Guru");
    emp.showEployeeDetails();
  }
}

After we run the above program, we get the following output:

Employee Id : 104 
Employee Name : Spring Framework Guru 
Department : Information Technology 
Process finished with exit code 0


Autowire Conflict Resolution

By default, Spring resolves @Autowired entries byType. If more than one bean of the same type is available in the container, the framework will throw NoUniqueBeanDefinitionException exception, indicating that more than one bean is available for autowiring. Please click here to know more on how to fix NoUniqueBeanDefinitionException exceptions.

Summary

In this post, we’ve seen a few modes of the autowiring object using Spring ApplicationContext and Spring configuration file. We have looked at examples using different modes which are:

  •  no 
  •  byName 
  •  byType 
  •  constructor 
  •  autodetect 

We also saw a simple example of autowiring using @Autowired annotation using different modes which are:

  •  property
  •  setter 
  •  constructor 

You can download the complete source code of this post from GitHub.

Spring Framework Property (programming) Data Types Annotation

Published at DZone with permission of John Thompson, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

Related

  • Modify JSON Data in Postgres and Hibernate 6
  • Java Bean Validation: Applying Constraints Programmatically
  • How Stalactite ORM Implements Its Fluent DSL
  • Top 10 C# Keywords and Features

Partner Resources

×

Comments

The likes didn't load as expected. Please refresh the page and try again.

ABOUT US

  • About DZone
  • Support and feedback
  • Community research
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Core Program
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 3343 Perimeter Hill Drive
  • Suite 100
  • Nashville, TN 37211
  • [email protected]

Let's be friends: