In my one of the post I have discussed on setter injection using Spring 2.5(old method). Going through that post will help you to find the difference between these two dependency injection approach. Lets get started.

What is Dependency Injection ? The answer is , It is a Design Pattern. Inversion of control or dependency injection pattern used to resolve component dependencies by injecting an instantiated component to satisfy dependency as opposed to explicitly requesting a component. So components will not be explicitly requested but components are provided as needed with the help of an Inversion of controller containers. Please read the post to know more on it.

Spring has a concept of instantiated component , i.e , bean. Previously , we used to configure bean in the Application Context xml file but with Spring 3.0 , we will be configuring bean and injecting services(dependencies) from our java classes. Lets do it with an example use case.

Have a look at the following class relations

Class Relation

Use Case : OpsClient is a normal Java Class which is registered with two services , i.e , Calculator Service and Print Service. Calculator Service is an interface to different calculation services available , like , addition , multiplication etc. Print Service is another interface to different printing services available , like , printing to a file or printing to console etc. The OpsClient makes use of these different services to perform different calculation and print them on different printing interfaces.

Approach with Spring 3.0 :

CalculatorService and PrintService are two interfaces. AddCalculatorServiceImpl , MultiplyCalculatorServiceImpl are the implementation of CalculatorService interface and ConsolePrintServiceImpl , FilePrintServiceImpl are the implementation of the PrintService interface. Hence , these implementation classes are the beans in Spring. Lets define them one by one.

Listing 1 : CalculatorService.java Interface

package com.company.spring.basic.service;

public interface CalculatorService {

	public long calculate(long x,long y);
	public String getOperationName();

}

Listing 2 : PrintService.java Interface

package com.company.spring.basic.service;

public interface PrintService {

	public void print(String result);
}

Lets define all the implementation (beans) of the services

Listing 3 : AddCalculatorServiceImpl.java

package com.company.spring.basic.service.impl;

import javax.inject.Named;

import com.company.spring.basic.service.CalculatorService;
@Named("AddCalcService")
public class AddCalculatorServiceImpl implements CalculatorService {

	@Override
	public long calculate(long x, long y) {
		return x+y;
	}

	@Override
	public String getOperationName() {
		return " plus ";
	}
}

Listing 4 : MultiplyCalculatorServiceImpl.java

package com.company.spring.basic.service.impl;

import javax.inject.Named;

import com.company.spring.basic.service.CalculatorService;
@Named("MultiplyCalcService")
public class MultiplyCalculatorServiceImpl implements CalculatorService {

	@Override
	public long calculate(long x, long y) {

		return x*y;
	}

	@Override
	public String getOperationName() {

		return " multiplies ";
	}
}

Listing 5 : ConsolePrintServiceImpl.java

package com.company.spring.basic.service.impl;

import javax.inject.Named;

import com.company.spring.basic.service.PrintService;
@Named("ConsolePrintService")
public class ConsolePrintServiceImpl implements PrintService {

	@Override
	public void print(String result) {
		System.out.println(result);

	}
}

Listing 6 : ConsolePrintServiceImpl.java

package com.company.spring.basic.service.impl;

import javax.inject.Named;

import com.company.spring.basic.service.PrintService;

@Named("FilePrintService")
public class FilePrintServiceImpl implements PrintService{

	@Override
	public void print(String result) {
          // Code to write to a file
	}
}

Listing 3 – Listing 6 shows the normal but special implementation of the interfaces. They are special , because they are to support the Spring Framework’s Bean concept. To do that , each of this implementation is annotated with @Named(”SomeName”) annotation. In Spring 3.x you can use JSR 330’s @Named annotation in place of stereotype annotations and they will be automatically detected during component-scanning.
The value of the @Named property will be used as the Bean Name. At this time Spring defaults for bean
scope will be applied when using @Named.

This annotation will be available if if the JSR330 jar is present on the classpath. This jar is not part of the Spring 3.0 download. It is available under SpringSource Enterprise Bundle Repository. This annotation will be available under the com.springsource.javax.inject-1.0.0.jar. You can find the other jars here.

The next task is to build the Application context. Wait , we are not going to build any xml file here. It is going to be a simple Java class annotated with some useful annotations. Have a look at the following code.

Listing 7 : ApplicationConfig.java

package com.company.spring.basic;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.company.spring.basic.client.OpsClient;
import com.company.spring.basic.service.CalculatorService;
import com.company.spring.basic.service.PrintService;
import com.company.spring.basic.service.impl.AddCalculatorServiceImpl;
import com.company.spring.basic.service.impl.ConsolePrintServiceImpl;
import com.company.spring.basic.service.impl.FilePrintServiceImpl;
import com.company.spring.basic.service.impl.MultiplyCalculatorServiceImpl;

@Configuration
public class ApplicationConfig {
	@Bean
	public PrintService screnPrint(){
		return new ConsolePrintServiceImpl();
	}
	@Bean
	public PrintService filePrint(){
		return new FilePrintServiceImpl();
	}
	@Bean
	public CalculatorService add(){
		return new AddCalculatorServiceImpl();
	}
	@Bean
	public CalculatorService Multiply(){
		return new MultiplyCalculatorServiceImpl();
	}
	@Bean
	public OpsClient result(){
		return new OpsClient();
	}
}

The class is annotated with @Configuration annotation. Annotating a class with the @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. These classes(@ Configuration annotated) consist principally of @Bean-annotated methods that define instantiation,configuration, and initialization logic for objects to be managed by the Spring IoC container.

To declare the beans , we have created methods and annotated with the @Bean annotation. The @Bean annotation plays the same role as the element.When @Configuration classes are provided as input, the @Configuration class itself is registered as a bean definition, and all declared @Bean methods within the class are also registered as bean definitions.

So we have five beans declared all together. The last bean declared is the OpsClient bean which has two references , i.e , CalculatorService and PrintService(Please refer to the Class Relations diagram above). We will achieve this reference injection with the help of a very special annotation @Inject. Have a look.

Listing 8 : OpsClient.java

package com.company.spring.basic.client;

import javax.inject.Inject;
import javax.inject.Named;
import com.company.spring.basic.service.CalculatorService;
import com.company.spring.basic.service.PrintService;

public class OpsClient {

	@Inject
	@Named("FilePrintService")
	private PrintService printService;

	@Inject
	@Named("MultiplyCalcService")
	private CalculatorService calculatorService;

	public void execute(long op1,long op2)  {
		printService.print("The result of " + op1 +
				calculatorService.getOperationName() + op2 + " is "
	   			+ calculatorService.calculate(op1, op2) + "!");

	}
}

printService and the calculatorCulatorService are the references to the different service implementations which can be injected using the @Inject annotation and @Named annotations. Here @Named annotation work as a mapping of service implementations. The name supplied as a parameter to the @Named annotation should be matched with one of the service implementation annotated with the same @Named annotation.

Like @Named , @Inject annotation can be found under the same package javax.inject.Inject. In the above class we are injecting the multiplication calculator service and the file print service using the annotations. Now the only thing pending is to instantiate the Application Context and call the client. It is explained below ,

Listing 9 : OperationTest.java

public class OperationTest {
	public static void main(String[] args) {
		ApplicationContext ctx = new AnnotationConfigApplicationContext(
				com.company.spring.basic.ApplicationConfig.class);
		OpsClient opsBean = ctx.getBean(OpsClient.class);
		opsBean.execute(2, 3);
	}
}

Once you run the above method , multiplication of the value 2 and 3 will be written in a file.

You would need to add the following jar files to the class-path ,
- cglib-nodep-2.1_3.jar
- classworlds-1.1-alpha-2.jar
- com.springsource.javax.inject-1.0.0.jar
- com.springsource.javax.inject-sources-1.0.0.jar
- jcl-over-slf4j-1.5.10.jar
- log4j-1.2.15.jar
- slf4j-api-1.5.10.jar
- slf4j-log4j12-1.5.10.jar
- spring-aop-3.0.0.RELEASE.jar
- spring-asm-3.0.0.RELEASE.jar
- spring-beans-3.0.0.RELEASE.jar
- spring-context-3.0.0.RELEASE.jar
- spring-core-3.0.0.RELEASE.jar
- spring-expression-3.0.0.RELEASE.jar
- spring-jdbc-3.0.0.RELEASE.jar
- spring-tx-3.0.0.RELEASE.jar

Most of the above jars can be downloaded as part of Spring 3.x download. Other jars can be found here.

Dependency can be injected using the setter method of a class. If a class is dependent on another class or primitive variables then the dependency should be declared as a state(variable) of the class and the class should have a setter method for it.

For an example , lets say Employee class is dependent on Address class , Employee class should have a state variable and a setter method , like ,

Listing 1 : Class with a setter method

private Address address;
public void setAddress(Address address) {
        this.address = address;
}

The Spring IOC container should inject the address dependency using the setter method of Address. Whole dependency Injection is push method where a dependency value will be pushed and a client class should not bother about pulling the dependency back from anywhere. Lets learn to set setter dependency injection with following example.

Lets assume , we have a class relation like the following ,

Listing 2 : Class Relations

Employee has an Address and a Project

Look at the above class relations. Employee has an Address and Employee has a Project. Employee is dependent on both Address and Project classes directly. Using Spring IOC controller we can inject the dependency values to Employee class . Lets do it.

Spring IOC container needs a bean to be defined for all kind of classes whose object should be created for your application. For the above application we need instance of an Address class , Project Class and at last Employee class to get the employee data. Hence we need three beans to be declared. Beans should be declared in the application context xml file. The

 <bean> 

tag should define a bean with it’s properties and tag should contain multiple beans in it.

Address class has three properties , i.e , street , city and pincode. Hence the bean for the Address class is defined as follows ,

Listing 3 : Address Bean

<bean id="addressBean"
class="com.company.spring.injection.setter.model.Address">
        <property name="street">
            <value>Bagmane Tech park</value>
        </property>
        <property name="city">
            <value>Bangalore</value>
        </property>
        <property name="pincode">
            <value>566093</value>
        </property>
</bean>

Intention is to instantiate the Address class and populate it’s properties with respective values. Similar way , a bean definition for Project class could be as,

Listing 4 : Project Bean

<bean id="projectBean"
class="com.company.spring.injection.setter.model.Project">
        <property name="projectName">
            <value>iManager</value>
        </property>
        <property name="department">
            <value>ISM</value>
        </property>
        <property name="teamMemberCount">
            <value>10</value>
        </property>
        <property name="deliveryDate">
            <ref bean="dateBean"/>
        </property>
</bean>

Point to notice is that the bean id is a logical name which can be any user friendly and non-objectionable name. Look at these bean definition closely. Each bean has property and each property is populated with some value. But thing is different for deliveryDate bean in projectBean. There is a

<ref>

tag instead of

<value>

. Because deliveryDate property is of type java.util.Date in Project class so we need a java.util.Date reference to set it’s value. So we need another bean for date.

Listing 5 : Date Bean

<bean id="dateBean"
class="java.util.Date"/>

Now , lets have a look at the bean for the Employee class.

Listing 6 : Employee Bean

<bean id="employeeBean"
class="com.company.spring.injection.setter.model.Employee">
        <property name="name" value="Tapas Adhikary"></property>
        <property name="empId" value="88699"></property>
        <property name="address" ref="addressBean"></property>
        <property name="project" ref="projectBean"></property>
</bean>

See the last two properties of the employeeBean bean. We have injected the addressBean and projectBean as a reference to the properties names address and project respectively. So your client code ( Where we have decided to create and instance of Employee and call it’s getter methods) should not worry about setting all this values. Employee’s dependencies will be pushed by the Spring IOC container.

The client code should be like this ,

Listing 7 : Setter Injection Java file

public class SetterInjection {
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext(
          "resources/applicationContext.xml");
    BeanFactory factory = (BeanFactory) context;
    Employee employee = (Employee) factory.getBean("employeeBean");
    Address address = employee.getAddress();
    Project project = employee.getProject();
    System.out.println(employee.getName());
    System.out.println(employee.getEmpId());
    System.out.println(address.getCity());
    System.out.println(address.getStreet());
    System.out.println(address.getPincode());
    System.out.println(project.getProjectName());
    System.out.println(project.getDepartment());
    System.out.println(project.getTeamMemberCount());
    System.out.println(project.getDeliveryDate().toString());
   }
}

Lets assume the application context file name is applicationContext.xml and it’s under a folder called resources. An ApplicationContext object should be formed with the help of the xml file. The context object is type of the Bean Factory which uses the Factory Design Pattern concept to create the object. Once you get the factory , you need to query the bean using the bean name , i.e , employeeBean. Thats it. Your Employee class is instantiated. Now you can get all the Employee properties including Address and Project properties injected using the xml file and the setter method of Address , Person and Employee.

The attached source code has the full version of the xml and all java source files. Download the code and import into your favorite IDE.

I would like to conclude this post with one rule. A property name of a bean in the xml file should be equal to the setter method name of the attribute of the class without the word set at the beginning . Say if the property name of a bean in the application context xml file is departmentName then the corresponding class should have a setter method called

 public void setDepartmentName(String departMent){
     // Set the value
   }

Note : ‘D’ is in capital in the setter method after the word ’set’.