Spring Annotation using @Autowired

In this article, we will learn Spring Framework’s feature Annotation based configuration an alternative to XML configuration. Since Spring 2.5, tedious bean wiring in XML configuration has been replaced with annotation on the component class itself. It could be on the relevant class, method or filed declaration

Annotation wiring by itself doesn’t gets activated, we need to turn ON by adding the following line of code <context:annotation-config/>  in the Spring configuration which helps to detect the annotation in the beans registered with the application context (container)

Developers can wire beans using both annotation injection & XML injection, but annotation injection is performed before XML injection. So, XML injection overrides Annotation injection.

Note: Below two tags in the XML configuration helps t o turn ON the annotations on the component class. First angle bracket helps to turn ON annotation on the registered beans which are defined in the XML configuration file whereas second activates the annotation tags on the base-packages and it sub-packages.

<context:annotation-config /> &

<context:component-scan base-package="com.spring.series.annotation" />

For more details on Spring Annotation see here

Let’s move on to implement one example on @Autowired annotation, where address bean is autowired in the employee bean.

Technology Used

  • Java 1.7
  • Eclipse Kepler IDE
  • Maven 3.0.4
  • Spring-4.0.0-RELEASE

Mavenize or download required jars

Add Spring-4.0.0 dependencies to the pom.xml

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

Folks who aren’t familiar with Maven concepts or don’t require maven for their project, can download the below jars individually from the spring site and include them in the classpath.

  • spring-core-4.0.0-RELEASE
  • spring-context-4.0.0-RELEASE
  • spring-beans-4.0.0-RELEASE
  • spring-aop-4.0.0-RELEASE
  • spring-expression-4.0.0-RELEASE
  • commons-logging-1.1.1
  • aopalliance-1.0

Let’s see coding in action

 

Create simple Spring bean for Employee & Addess

Addess class

Four simple properties with their setter/getter

Addess.java

package com.spring.series.annotation;

public class Address {

	private String street;
	private String city;
	private String state;
	private String zipcode;

	/**
	 * getter's and setter's
	 */
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
	public String getZipcode() {
		return zipcode;
	}
	public void setZipcode(String zipcode) {
		this.zipcode = zipcode;
	}

	/**
	 * This method prints the address details
	 */
	public void printAddressDetail(){
		System.out.println("Address Street \t\t: " + street);
		System.out.println("Address City \t\t: " + city);
		System.out.println("Address State \t\t: " + state);
		System.out.println("Address Zip Code \t: " + zipcode);
	}
}

Employee class

Four simple properties and its setter/getter & one complex property named Address annotated with @Autowired and getter/setter.

Note: When we declared @Autowired, actually it autowire byType. There one more annotation available in Spring like @Resource which autowires using byname

Employee.java

package com.spring.series.annotation;

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

public class Employee {

	private String name;
	private int age;
	private String employeeCode;
	private String designation;

	// property address autowired using annotation
	@Autowired
	private Address address;

	/**
	 * getter's and setter's
	 */
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getEmployeeCode() {
		return employeeCode;
	}
	public void setEmployeeCode(String employeeCode) {
		this.employeeCode = employeeCode;
	}
	public String getDesignation() {
		return designation;
	}
	public void setDesignation(String designation) {
		this.designation = designation;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}

	/**
	 * This method prints the employee details
	 */
	public void printEmployeeDetail(){

		System.out.println("Employee Name \t\t: " + name);
		System.out.println("Employee Age \t\t: " + age);
		System.out.println("Employee Code \t\t: " + employeeCode);
		System.out.println("Employee Designation \t: " + designation);

		System.out.println("\nAutowired Address object & Printing Address details\n");

		// this loc invokes method of Address class & this object is injected during spring bean instantiation
		address.printAddressDetail();
	}
}

Create Spring Bean Configuration file (Spring XML)

Two simple beans employee & address are defined in the Spring configuration file with no explicit relationship between them because dependent address bean gets injected into the employee via @Autowired annotation declared in the component class (i.e.; Employee.java)

SpringContext.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: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-4.0.xsd">

	<context:annotation-config />

	<!-- employee bean definition goes here -->
	<bean id="employee" class="com.spring.series.annotation.Employee">
		<property name="name" value="Mark" />
		<property name="age" value="32" />
		<property name="employeeCode" value="E10910" />
		<property name="designation" value="Software Architect" />
	</bean>

	<!-- address bean definition goes here -->
	<bean id="address" class="com.spring.series.annotation.Address">
		<property name="street" value="Spring Office St." />
		<property name="city" value="Columbus" />
		<property name="state" value="OHIO" />
		<property name="zipcode" value="43211" />
	</bean>

</beans>

Note: Name of the Spring Bean Configuration file can be anything (not necessary to have SpringContext.xml) and it’s your choice. But, in the enterprise application keep these file names appropriate to the business context. So that it will increase the readability of the application

Project Structure in Eclipse (Package Explorer view)

SpringAnnotation

Test the Application that’s exactly …. Run it!

Let’s test using ApplicationContext

Simple test class – self descriptive

TestEmployee.java

package com.spring.series.annotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestEmployee {

	public static void main(String[] args) {
		testAnnotation();
	}

	private static void testAnnotation(){

		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/spring/series/annotation/SpringContext.xml");
		Employee employee = (Employee) applicationContext.getBean("employee");

		System.out.println("\nSpring Annoatation \n");

		// invoke print() method of Employee class
		employee.printEmployeeDetail();
	}
}

Output in console

Spring Annoatation 

Employee Name 		: Mark
Employee Age 		: 32
Employee Code 		: E10910
Employee Designation 	: Software Architect

Autowired Address object & Printing Address details

Address Street 		: Spring Office St.
Address City 		: Columbus
Address State 		: OHIO
Address Zip Code 	: 43211

Note: With @Autowired, annotation implicitly makes the dependency mandatory but with required=false in the parenthesis gives you an option to disable the dependency checking on the runtime. In simple words, it doesn’t enforce to supply its values

In the next article, we will explore on @Qualifier annotation to resolve ambiguity issues when we got two beans registered with same data type

Download project

Spring Annotation using @Autowired (3kB)

Happy Coding!!
Happy Learning!!