< Prev
Next >

Autowiring with Constructor

In our last tutorial, we understood how to perform Dependency Injection using the byType value of autowire attribute. In this tutorial, we are going to understand how to perform Dependency Injection using the constructor value of autowire attribute.

Recap - Autowiring is a feature provided by Spring Framework which automates the process of wiring the beans in a Spring Project. To perform the autowiring of beans, Spring provides us an attribute -autowire.

Attribute autowire may have any of the three values -

What does autowire="constructor" do?

When a class A contains a property/reference of class B and also has a constructor with argument type class B, the use of attribute autowire="constructor" within the class A bean(configured in the XML file) leads the Spring container to look for the bean(in the XML file) of type class B(as defined in the constructor argument) and inject it into the class A bean.

In the upcoming section, we are going to create a few loosely coupled Java classes also known as beans, configure these beans in a configuration XML file, load and instantiate the beans and perform dependency injection using the attribute - autowire with its value - constructor.

Creating the Java class - Company

We are going to create a java class named Company within the decodejava package and this class contains a message info().

package decodejava;

public class Company
	public void info() 
		System.out.println("Company A");	


Dependent Class containing a Company object - Employee

Next, we are going to add another Java class named Employee and it is going to contain a String object, a primitive int, and a Company reference, hence Employee class is dependent on Company class as it contains its reference.

We are also going to create a constructor(a must when using autowire="constructor") of Employee class with argument type Company, String and a primitive int.

The objects of String class and Company class and primitive int value will be injected into an Employee instance/bean by an automatic call to the constructor of Employee class by the Spring Container when the Employee bean is created by it using the configuration XML file(to be created in the upcoming section).

package decodejava;

public class Employee

	Company company ;
	String name;
	int yearsOfExp;
	//Constructor is a must when using autowire="constructor"
	public Employee(Company company, String name, int yearsOfExp)
	{ = company; = name;
		this.yearsOfExp = yearsOfExp;

	public Company getCompany()
		return company;
	public String getName()
		return name;
	public int getYearsOfExp()
		return yearsOfExp;


Adding the Utility class that calls the Spring API

Next, we are going to create another class named - Utility, which is a simple java class. The Utility class uses the ApplicationContext container(an interface) of Spring Framework by creating its instance using its implemented class FileSystemXmlApplicationContext, which -

Eventually, this class calls the method of Employee class - getName() and getYearsOfExp.
package decodejava;

import org.springframework.context.ApplicationContext;

public class Utility 
	public static void main(String[] args) 
		ApplicationContext context = new FileSystemXmlApplicationContext("classpath:config.beans.xml");
		Employee employeeBean = context.getBean("EmployeeBean", Employee.class);
		System.out.println("Employee Name : " + employeeBean.getName());
		System.out.println("Years of experience : " + employeeBean.getYearsOfExp());

Adding a configuration file

Next, we are going to add a configuration file to our project. This configuration document is an Extensible Markup Language(XML) file, ending with .xml extension and we are going to name file as config.beans.xml.

In this file, we have configured an Employee bean with a unique id, a String object, a primitive int value and a Company bean is injected into the Employee bean, using the autowire="constructor" attribute.

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns=""

<bean id ="EmployeeBean" class="decodejava.Employee" autowire = "constructor">
	<constructor-arg index="1" value="Employee1"/>
	<constructor-arg index="2" value="7"/>

<bean id ="CompanyBean" class="decodejava.Company">


This mapping document has a parent <beans> tag as the root element and its individual child elements, each with a <bean> tag, containing all the attributes such as -

Adding JARs

  • We are going to add some JARs files to our Java project. These JARs are required in order to successfully execute a Spring project.

    All these JARs are included in the folder named libs(within our Spring installation folder). So, we need to add all the JARs in the libs folder to the build path of our Java project.

    Note: Those who don't know how to add JARs to the build path of your Java project in Eclipse IDE, please refer to our section Adding JARs to your Spring project in Eclipse.

Directory Structure of Project

The picture above depicts how and where to arrange classes and interfaces comprising this Spring Project, in a specific directory structure.

Project Folder - SpringDependencyInjectionAutowireByConstructor is the name of our Project and it is a top-level directory.


Finally, after executing Utility class, you will get the following output within the Console window. Ths output shown below shows how the Utility class has used the ApplicationContext container of Spring Framework to load the configuration XML file - config.beans.xml, access the beans specified in it, instantiate the Company class and Employee class.

It also injects a String object, a primitive int value, and a Company bean into Employee bean and calls the methods of the respective classes.

Jul 17, 2018 11:21:23 AM prepareRefresh
INFO: Refreshing startup date [Tue Jul 17 11:21:23 IST 2018]; root of context hierarchy
Jul 17, 2018 11:21:23 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [config.beans.xml]
Employee Name : Employee1
Years of experience : 7
Company A

This concludes performing the dependency injection by injecting a bean into another bean using the value of autowire attribute - constructor. In the next article, we are going to show you how to perform the dependency injection using the autowiring with annotations.

Please share this article -

< Prev
Next >
< Autowiring with byType
Autowiring with byType >


Please Subscribe

Please subscribe to our social media channels for daily updates.

Decodejava Facebook Page  DecodeJava Twitter Page Decodejava Google+ Page



Please check our latest addition