etechGuide . . . » Spring

Spring 3.0 – Java Annotation based Dependency Injection(DI)

admin — Tue, 19 Jan 2010 11:51:56 +0000

If you have been using Spring Framework for sometime , you will be aware that the Spring Framework has undergone several major changes in the latest Spring version 3.x. Spring Framework is now based on Java 5 and Java 6 fully supported. It has incorporated all the important features of Java latest versions. Spring version 3.0 encourages the developers to use Java Annotations instead of the configuration xml. This post will talk on the Annotation based Dependency Injection mechanism using Spring 3.0.

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.

Spring DAO – JDBC Support

admin — Tue, 15 Dec 2009 11:05:35 +0000

Introduction

Spring framework has a full-fledge support for the Database Access Objects(DAO). Spring’s support of DAO is not limited with the relational database like MySQL , Oracle , etc . It has support for Object Relational Databases like , HSQL , JDO etc. Whan I talk about suppot it means a lot of things.

Before going into the details , let us ask a question to ourselves .What is the real problem in coding a JDBC without a framework support ?

All of us , who are JDBC programmers know these clearly :

DBC is redundant .
Lots of Coding to be done .
Lots of Coding to be repeated (Yes , even after following all the OO academic theories !!).
Extra headache of Opening a connection and Closing a connection .
Maintaining a Connection Pool .
You find yourself doing the same things over and over again .
Yes , you must have to propagate the exception and handle it .
You have to handle transactions .
You have to write statements .
You have to execute the statements .
You have to get the results after executing the statement and iterate through it.

Waoh !! So many things to take care. Isn’t it ? What do the framework like Spring do then ? How does it help ?
Here is the list of what it does (We will see the HOW shortly) :

Define connection parameters .
Open the connection .
Specify the statement . – Work of an Application Developer.
Prepare and execute the statement .
Set up the loop to iterate through the results (if any) .
Do the work for each iteration . - Work of an Application Developer.
Process any exception .
Handle transactions .
Close the connection .

In the above list , Except specifying the statement and writing the business logic for each iteration , all other services are taken care by the SPRING Framework. Isn’t it cool ? You don’t have to worry about many things that would have taken most of your development time otherwise.

Know the Spring DAO Module :

Packages

The Spring Framework’s JDBC abstraction framework consists of four different packages, namely core, datasource, object, and support. Spring community documentation helps you with number of options for selecting an approach to form the basis for your JDBC database access.

JdbcTemplate – this is the classic Spring JDBC approach and the most widely used. Works well in a JDK 1.4 and higher environment.
NamedParameterJdbcTemplate – wraps a JdbcTemplate to provide more convenient usage with named parameters instead of the traditional JDBC “?” place holders. This provides better documentation and ease of use when you have multiple parameters for an SQL statement. Works with JDK 1.4 and up.

SimpleJdbcTemplate – this class combines the most frequently used features of both JdbcTemplate and NamedParameterJdbcTemplate plus it adds additional convenience by taking advantage of some Java 5 features like varargs, autoboxing and generics to provide an easier to use API. Requires JDK 5 or higher.
SimpleJdbcInsert and SimpleJdbcCall – designed to take advantage of database metadata to limit the amount of configuration needed. This will simplify the coding to a point where you only need to provide the name of the table or procedure and provide a Map of parameters matching the column names. Designed to work together with the SimpleJdbcTemplate. Requires JDK 5 or higher and a database that provides adequate metadata.
RDBMS Objects including MappingSqlQuery, SqlUpdate and StoredProcedure – an approach where you create reusable and thread safe objects during initialization of your data access layer. This approach is modeled after JDO Query where you define your query string, declare parameters and compile the query. Once that is done any execute methods can be called multiple times with various parameter values passed in. Works with JDK 1.4 and higher.

Lets see one example to learn and understand Spring-jdbc configuration. We will use jdbcTemplate style of JDBC approach. Reader of this post is expected to try other approaches as well.

Setup Details

DataBase used : MySQL 5
IDE Used : Eclipse 3.3.1
Jar files needed : Please inclusde the followings jar into project classpath.

commons-dbcp.jar – For DataSource Support.
commons-pool.jar – For Connection Pool Support.
mysql-connector-java-5.1.5.jar – Java Connector for MYSQL.
ojdbc14.jar – Query Support
spring.jar – The core framework library

All the above jar files should be found under lib/ and dist/ directory of the Spring Distribution with Dependencies.

Lsts take an example of a table called User which is created under the data base called demo. The description of the demo.User table is as follows,

describe table

Let us create a domain class called User which is a POJO(Plain old java object) class having the properties and setter / getters for the properties. A User.java look like ,

Listing 1 : User.java

public class User {

          private Integer uid;
          private String userName;
          private String password;

          public User() {

          }
          public User(Integer uid, String userName, String password) {
                  this.uid = uid;
                  this.userName = userName;
                  this.password = password;
          }
          public Integer getUid() {
                  return uid;
          }
          public void setUid(Integer uid) {
              this.uid = uid;
          }
          public String getUserName() {
             return userName;
          }
          public void setUserName(String userName) {
            this.userName = userName;
          }
          public String getPassword() {
              return password;
          }
          public void setPassword(String password) {
                   this.password = password;
          }

         public String toString(){
              StringBuilder sb = new StringBuilder();
              sb.append("User ID :"+getUid()+"\n");
              sb.append("User Name :"+getUserName());
              return sb.toString();
         }

    }

As the design pattern teaches us, we should do all the programming to interfaces and not to implementation . let us create an interface called UserDAO which will declare all the methods to be implemented for a User database operation.

Listing 2 : UserDAO.java

public interface UserDAO {
    public boolean insertUser(User userRecord);
    public boolean updateUser(User userRecord);
    public boolean deleteUser(int uid);
    public User selectUser(int uid);
}

Before going to the implementation of UserDAO interface , we should know the following :
– Spring Framework will provide a mechanism to inject TransactionManager and DataSource instance to our implementation class.
– A Datasource can contain information like, driverClassName,url,username,password etc and all this information (parameters) will be injected by container to the implementation class.
We will achieve these by coding our ApplicationContext.xml . Here it is .

Listing 3 : ApplicationContext.xml

Look at the last bean , userDao. This bean instantiate UserDaoImpl which is an implementation os UserDAO interface. As per the setter injection logic , UserDaoImpl.java should have a setter method for the reference property transactionManager. Now , have a look at the transactionManager bean. This is a type of (say , instance of) class org.springframework.jdbc.datasource.DataSourceTransactionManager . This is a class provided by the Spring Framework to the application developer. This class has a public setDataSource(DataSource dataSource) method. Hence you have the scope to inject dataSource object as a refrence to the transactionManager bean.

The dataSource bean is of type org.apache.commons.dbcp.BasicDataSource which has setter for all the properties defined under the bean. Additionaly , the bean described theat close() method will be called as a destroy-method to close the connection.

The Sequence is like this ,
- Get a TransactionManager instance,
- Get a DataSource from TransactionManager.
- Form a jdbcTemplate from the Datasource instance.
- Specify the Query.

All the above steps are taken care in the UserDaoImpl.java class. Have a look.

Listing 4 : UserDaoImpl.java


import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import user.DAO.UserDao;
import user.Domain.User;

public class UserDaoImpl implements UserDao {

    private JdbcTemplate jdbcTemplate;

    // Setter Injection happens here
    public void setTransactionManager(
            DataSourceTransactionManager transactionManager) {
        DataSource dataSource= transactionManager.getDataSource();
        jdbcTemplate = new JdbcTemplate(dataSource);
    }

    @Override
    public boolean deleteUser(int uid) {
        String sql = "delete from demo.user where UID=?";
        Object[] params = new Object[]{uid};
        int deleted = jdbcTemplate.update(sql,params);
        if(deleted > 0){
            return true;
        }else{
            return false;
        }
    }

    @Override
    public boolean insertUser(User userRecord) {

		String sql = "insert into demo.user(UID,USERNAME,PASSWORD)"
				+ " values(?,?,?)";
		Object[] params = new Object[] { userRecord.getUid(),
				userRecord.getUserName(), userRecord.getPassword() };
		int[] types = new int[] { Types.INTEGER, Types.VARCHAR,
                            Types.VARCHAR };
		int inserted = jdbcTemplate.update(sql, params, types);
		if (inserted > 0)
			return true;
		else
			return false;
    }

    @Override
    public User selectUser(int uid) {
        String sql = "select UID,USERNAME from demo.user where UID=?";
        Object[] params = new Object[]{uid};
        final User user = new User();

        jdbcTemplate.query(sql,params,new RowCallbackHandler(){

            @Override
            public void processRow(ResultSet rs) throws SQLException {
                user.setUid(new Integer(rs.getInt("UID")));
                user.setUserName(rs.getString("USERNAME"));
            }
        });
        return user;
    }

    @Override
    public boolean updateUser(User userRecord) {
        // You Implement
        return false;
    }

}

Inspect the public void setTransactionManager(DataSourceTransactionManager transactionManager) method . The Dependency Injection takes place here. TransactionManager instance will be injected by Spring IOC container using the setter injection methodology. Once the TransactionManager is populated , a datasource instance can be created as ,
DataSource dataSource= transactionManager.getDataSource();
and a jdbcTemplate can be created as,
jdbcTemplate = new JdbcTemplate(dataSource);

This jdbcTemplate should be used for all type of query execution. To understand different types of query execution , please refer to the Spring Source Doc on JDO (from section 11.2) after running the above program successfully.

Integrate any J2EE-based web application with Spring

admin — Thu, 03 Dec 2009 09:53:38 +0000

Spring is a very good modular framework. Each module of the framework can be used depending on the various need in an application. Lets take an example of a J2EE-based web application which can use Spring-DAO module for it’s data base layer or Spring-MVC to make the navigation between Model-View-Controller more modular and testable.

These factors decides which component of the Spring can be used with the J2EE-based web application. If you are using Spring-MVC for your web application , Spring provides a front-controller in form of DispatcherServlet which does loading of of application context , instantiating your beans etc.

But , there might be a situation where Spring-MVC is not your need , rather you would like to take advantage of Spring-DAO module along with normal servlets and jsps. In this scenario , DispatchServlet(the front-controller) is not at all there in picture. But the challenge remain the same. Your application context must be loaded and all the beans should be instantiated.

This post talks on integrating the Spring framework with a J2EE-based web application which has normal servlets and jsps.

Two areas of your web application should be modified to integrate with Spring framework.

web.xml file – Where you need to specify the path of the Spring’s application context file and register some listeners.
Your servlet – where you need make changes to get the instance of your bean to call bean’s methods.

Lets assume , we have an application context which declares the beans for configuring and connecting to the Database. The application context file will look like this ,

Listing 1 : Application Context Xml – databaseAppConfig.xml

Next , add these tags to the top of web.xml

A context-param tag with the param-name contextConfigLocation and it’s value. contextConfigLocation is the location of Spring’s application context file. you can define multiple application context files and declare them in space separated manner.



   contextConfigLocation
   /WEB-INF/databaseAppConfig.xml

A listener which would load all these context files and pass it to Spring framework for instantiating the beans defined in the application conext xml file.


  
    org.springframework.web.context.ContextLoaderListener

Once you are done with this step , use your servlet to get the instance of the bean created for you. If you look closely to the databaseAppConfig.xml file in the Listing 1 , you have a bean named bookDao which is the bean for the class file , com.etechguide.library.client.dao.BookDaoImpl. Lets assume , BookDaoImpl implements the interface BookDao.java and has definition of the methods like getBookDetails(), updateBook() deleteBook() etc. Hence you have to get the instance of BookDaoImpl if you would like to call the methods.

Have look at the following code ,


public class BookDetailsSrvlet extends
      javax.servlet.http.HttpServlet implements
		javax.servlet.Servlet {

	private ServletConfig servletConfig = null;
	private ServletContext servletContext = null;
	private String state = null;
	private BookDao bookDao = null;

	protected ApplicationContext applicationContext;

	@Override
	public void init(ServletConfig config) throws ServletException {

		super.init(config);
		this.servletConfig = config;
		servletContext = this.servletConfig.getServletContext();
		if (applicationContext == null) {
			applicationContext = WebApplicationContextUtils
					.getWebApplicationContext(servletContext);
		}
		bookDao = (BookDao) applicationContext.getBean("bookDao");
	}
 .....
 .....
 // Other codes
 .....
 .....
}

The above code is from a servlet which makes use of the servletContext to get the ApplicationContext object and then called the getBean() method passing the bean name to get the instance of BookDaoImpl which is a type of BookDao interface.

Setter Injection – Type of Dependency Injection

admin — Wed, 02 Dec 2009 05:25:21 +0000

I have discussed on the concept of Dependency Injection in my last post . This post is about a specific type of Dependency Injection adopted by Spring. It is called Setter Injection. In Java POJO(Plain old java object) world , setters and getters are very common terms. A setter which sets an attribute value of a class. A getter which return the attribute value of a class.

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

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


        
            Bagmane Tech park
        
        
            Bangalore
        
        
            566093

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

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

tag instead of

. 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

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

Listing 6 : Employee 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’.

Dependency Injection Concept

admin — Mon, 30 Nov 2009 05:38:49 +0000

Java classes and objects should be as much as possible loosely coupled with other java classes and objects. The loosely-coupled behavior allows a Java code to be re-usable ,test-worthy , modular and well maintained. Often , A class depends on another class and arise the coupling .

Say a class FetchUserDataFromDB depends on a class called DataBaseAccess, so it is obvious that , one would try to make a coupling by creating an instance of DataBaseAccess class in FetchUserDataFromDB class and call it’s methods. Here , we introduce a tight coupling and a strong dependency.

Look at the following scenarios :

Scenario 1 : Tight Coupling

Tight Coupling

Step 1 : Get me a database connection object from the pool.
Step 2 : Take the database connection object conn.
Step 3 : Thanks you , get me the User’s data whose id is 007.
Step 4 : Here it is , His name is James Bond .
Step 5 : Enough , Don’t want the conn anymore. Close it.
Step 6 : Ok , closed and conn is taken back to pool.

Scenario 2 : Loose Coupling

Loose Coupling

Step 1 : Oh , you need a connection ? Injecting a connection conn from the Connection Pool.
Step 2 : Fine , you need the user’s Information whose id is 007 ? Injecting the information ; He is James Bond.
Step 3 : Look like you are not using the conn anymore. Injecting a service to close the connection and get the conn back to the pool.

Now the million dollar question is , which of these scenarios you would like to see in your code/project. Undoubtedly the scenario 2 where you do not have the burden of keeping a reference to the databaseaccess object and your client class is no more tightly coupled .
Scenario 2 is the depiction of the Dependency Injection. Where the container injects the dependencies to the client classes and takes care of a full life cycle.

There are several advantages of dependency injection.

Your code is modular.
Classes are not having any strong reference to another class.
You are able to test your code independently.

The container which supports this dependency injection concept is called the IOC (Inversion of control) Container. Spring uses the concept of IOC and dependency injection to locate and inject services for you. Spring allows you to write your classes without having any dependency code .

There are three different ways dependencies can be injected.

Constructor Injection (CI) - Dependencies (say , other class references) can be injected as a parameter to the constructor of a class. Hence no hard code object creation of the Dependent class is needed.
Setter Injection (SI) - Inject the dependency as a setter method of the class
Interface Injection (II) – interface injection, in which the exported module provides an interface that its users must implement in order to get the dependencies at runtime.

A design based on independent classes / components increases the re-usability and possibility to test the software. For example if a class A expects a Dao (Data Access object) for receiving the data from a database you can easily create another test object which mocks the database connection and inject this object into A to test A without having an actual database connection.

Have look at the Bean dependency in detail Here .