Advertisement

---

Top

< Prev

Next >

Today we are going to understand how to put Spring into an execution using the Annotations without configuring the beans in configuration file(.xml). For this, we will use the Eclipse Integrated Development Environment(IDE) application.

As you know that Spring Framework allows us to develop scalable and maintainable enterprise applications while keeping the code simple and loosely coupled. So, in the next section, we are going to create a few loosely coupled Java classes also known as beans. We will not configure these beans in a configuration xml file, instead the beans will be created, loaded and instantiated using some specific Spring Annotations.

The two simple Spring Annotations

• @Component
• @Autowired

• @Component




@Component
class Sport


The @Component annotation is added on the top of each Java class to configure it as a java bean to be wired with another class in a Spring project. Doing so, will make Spring Framework treat this class as a java bean. In the absence of @Component annotation, Spring Framework would take the class as just a regular java class, without configuring it as a java bean.






• @Autowired




@Component
public class Tennis 
{
	@Autowired
	Sport sport;
}


The @Autowired annotation is added on the top of an instance variable/property in a class which is injected into the bean i.e. dependency injection, after the bean is constructed.
• This property to be injected could be a primitive value, an instance of another class.
• The @Autowired annotation could even be used on the top of a method or a constructor, which is used to inject a value.
• The @Autowired annotation has a required attribute which can be set to false, to disable the injection of this bean.







Creating a Java class in our Spring Project



We are going to create a java interface called Sport which is going to be implemented by some classes in our Spring project. We are going to use the @Component annotation on the top of this Java interface to configure it as a java bean, to be wired with another java bean classes in a Spring project. Doing so, will make Spring Framework treat this class as a java bean and will automatic the creation, loading, instantiation and deletion of its beans.

Sport.java

package decodejava;
import org.springframework.stereotype.Component;

@Component
public interface Sport 
{
	public void info();
}









Class that implements Sport interface


Next, we are going to add another Java class which implements the Sport interface. This class will be called OutdoorSport and we are going to use the @Component annotation on the top of this Java class to configure it as a java bean, to be wired with another java bean classes in a Spring project.

Doing so, will make Spring Framework treat this class as a java bean and will automatic the creation, loading, instantiation and deletion of its beans.


OutdoorSport.java

package decodejava;

import org.springframework.stereotype.Component;

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

}








Class that uses the Sport interface


Next, we are going to add another Java class and this class will be called Tennis. We are going to use the @Component annotation on the top of this class to configure it as a java bean, to be wired with another java bean classes in a Spring project.

Doing so, will make Spring Framework treat this class as a java bean and will automatic the creation, loading, instantiation and deletion of its beans.

Tennis class is going to contain a Sport reference named sport, hence the @Autowired annotation is added on the top of this property. Doing so, injects he bean sportinto the bean of Tennis class i.e. dependency injection, after the bean of Tennis is constructed.




package decodejava;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Tennis 
{
	@Autowired
	Sport sport;
	
	public void setSport(Sport sport)
	{
		this.sport = sport;
	}
	
	public void playSport() {
		System.out.println("Playing Tennis");
		sport.info();
	}

}






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 and we won't annotate it with @Component annotation to configure it as a bean.


The Utility class uses the ApplicationContext container(an interface) of Spring Framework by creating its instance using its implemented class FileSystemXmlApplicationContext to -
• Load the configuration xml file - config.beans.xml,
• To access the bean specified in the configuration file by calling the getBean() method of ApplicationContext container,
• Instantiate the Tennis class and call its methods.


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.playSport();
	}
}








Adding a configuration file


Next, we are going to add a configuration file to our project and we are going to name this configuration file as config.beans.xml.

This configuration document is an Extensible Markup Language(XML) file, ending with .xml extension, and we have named it config.beans.xml. In this file, we have configured a Tennis instance with a unique id and an OutdoorSport instance is injected into the Tennis bean using the property named sport.


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"
       xmlns:util="springframework.org/schema/util"
       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
       https://www.springframework.org/context/spring-context.xsd
       ">
           
       
<context:component-scan base-package="decodejava"/>

</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 property child element in <bean> tag refers to a property within the Tennis.
• The name child attribute refers to the name of a property in the Tennis class i.e. sport.
• The ref child attribute refers to the reference name of this property which is matched with the id of another bean(another class - OutdoorSport) declared in this configuration file within the <bean> tag.







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 - SpringDependencyInjectionByAnnotation 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 and an interface -
• An interface Sport.java.
• A Java class OutdootSport.java.
• Another Java class Tennis.java 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 calls its methods.



Jul 06, 2018 1:02:02 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.FileSystemXmlApplicationContext@1ee0005: startup date [Fri Jul 06 13:02:02 IST 2018]; root of context hierarchy
Jul 06, 2018 1:02:03 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [config.beans.xml]
Playing Tennis
-An Outdoor Sport-








Please share this article -






< Prev
Next >
< Dependency Injection with Constructor
Autowiring byName >



Advertisement