Advertisement

---

Top

< Prev

Next >

In our last tutorial, we understood how to perform Dependency Injection using setter methods, in this tutorial we are going to understand about how to perform Dependency Injection using constructor, within a Spring Project.


To understand this concept of Dependency Injection by the constructor, let's proceed with an example. 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 Spring Framework.

Creating the Java class - OutdoorSport

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

package decodejava;

public class OutdoorSport
{
	
	public void info() 
	{
		System.out.println("-An Outdoor Sport-");	
	}

}

Dependent class with an OutdoorSport object - Tennis

Next, we are going to add another Java class named Tennis and it is going to contain a String object and an OutdoorSport reference, hence Tennis class is dependent on OutdoorSport class.

These objects of String class and the OutdoorSport class will be injected into a Tennis instance/bean by an automatic call to the setter methods in the Tennis class by the Spring Container, when the Tennis bean is created by it using the configuration xml file(to be created in the upcoming section).

package decodejava;

public class Tennis 
{

	OutdoorSport sport;
	String message;
	
	
	//Constructor to set the String object and the OutdoorSport object.
	public Tennis(OutdoorSport sport, String message)
	{
		this.sport = sport;
		this.message = message;
	}

	
	//method to get the String object
	public void getMessage()
	{
		System.out.println("Message is : " + message);
	}
	
	
	//method to get the OutdoorSport object
	public OutdoorSport getSport()
	{
		return sport;
	}
}

Advertisement

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 -
  
  
  • Loads the configuration xml file - config.beans.xml
  
  
  • Creates the Tennis bean by calling its constructor and passing its first and the second index with values to set String object i.e. message and OutdoorSport object i.e. sport. This also creates the OutdoorSport bean and injects it into Tennis bean.
  
  
  • Accesses the Tennis bean specified in the configuration file by calling the getBean() method of ApplicationContext container.
  
  
  • Calls the methods of Tennis class - getMessage() and getSport().
  
  
  Utility.java

  package decodejava;
  
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.FileSystemXmlApplicationContext;
  
  public class Utility 
  {
  	public static void main(String[] args) 
  	{
  		ApplicationContext context = new FileSystemXmlApplicationContext("classpath:config.beans.xml");
  		Tennis tennisBean = context.getBean("TennisBean", Tennis.class);
  		tennisBean.getMessage();
  		tennisBean.getSport().info();
  	}
  }

  
  
  
  
  
  

  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 a Tennis instance with a unique id and a String object and an OutdoorSport instance is injected into the Tennis bean using the setter methods in Tennis class..
  
  
  config.beans.xml

  <?xml version="1.0" encoding="utf-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  
  
  <bean id ="TennisBean" class="decodejava.Tennis">
  	<constructor-arg index="0" ref="OutdoorSportBean"/>
  	<constructor-arg index="1" value="Let's play Tennis!"/>
  </bean>
  
  
  <bean id ="OutdoorSportBean" class="decodejava.OutdoorSport">
  </bean>
  
  
  </beans>

  
  
  
  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 -
  
  
  • The id attribute within the <bean> element defines a unique id associated with the bean.
  • The class attribute within the <bean> element defines the name of the class of this bean.
  
  
  
  The <constructor-arg> child element in <bean> tag refers to arguments within the constructor of Tennis class and it has some attributes -
  
  
  • The index child attribute refers to the index position of the argument in the constructor in the Tennis class i.e. 0th index represents the String argument i.e. message and the 1st index represents OutdoorSport argument i.e. sport.
  
  
  • The value child attribute refers to the value assigned to the argument at the specific index in the constructor of Tennis class, which is automatically called when the bean is created by Spring Container.
  
  
  • The ref child attribute refers to the reference name of the property which is matched with the id of another bean(another class - OutdoorSport) declared within a different <bean> tag. The leads to creation of OutdoorSport object by the Spring container.
  
  
  
  

  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 our 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 - SpringDependencyInjection is the name of our Project and it is a top-level directory.
  
  
  This project folder contains a package of our project i.e. decodejava containing three classes -
  • An POJO/Entity class file i.e. OutdootSport.java.
  • A dependent class named Tennis.java class, which contains an object of OutdoorSport class.
  • A class that calls the Spring Framework into action i.e. Utility.java.
  
  
  
  • Besides this, the project folder also contains a configuration file i.e. config.beans.xml, used to configure the beans of classes in the project.
    
    
  • The project folder also contains all the needed Spring JARs present in the libs folder of Spring Framework installation.
  
  
  
  
  
  

  Execution

  
  Finally, after executing Utility class, you will get the following output within the Console window. This 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 Tennis class and OutdoorSport class. It also injects OutdoorSport bean into Tennis bean and calls their methods.
  
  

  Jul 14, 2018 6:00:39 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
  INFO: Refreshing org.springframework.context.support.FileSystemXmlApplicationContext@1ee0005: startup date [Sat Jul 14 18:00:39 IST 2018]; root of context hierarchy
  Jul 14, 2018 6:00:39 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
  INFO: Loading XML bean definitions from class path resource [config.beans.xml]
  Message is : Let's play Tennis!
  -An Outdoor Sport-

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

  Please share this article -

  
  
  
  
  
  < Prev
  Next >
  < Spring Dependency Injection
  Dependency Injection with Annotation >

  
  
  Advertisement