CSC/ECE 517 Fall 2010/ch5 5e dr

Dependency Injection

Overview

Every enterprise application involves handful number of objects that work together to achieve some purpose. These objects are coupled with each other and work in collaboration, making the classes highly dependent. However, creating such code involving highly coupled classes defeats an important tenet of Object oriented design- ‘loose coupling’. Loose coupling means that objects should have the minimum number of dependencies, which makes the code easy to understand, modify and debug. It also allows for greater code reusability and improves the maintainability. http://www.codeproject.com/KB/architecture/DependencyInjection.aspx This drive to decouple the code from its highly dependent objects leads to the concept of Dependency Injection.

Definition

The basic concept of Dependency Injection (DI) is that you do not create the objects themselves, but describe how they should be created. It is one of the more popular design paradigms known today, by which the objects define their dependencies, i.e. the objects or classes they work with. DI pattern provides better a software design that makes the code cleaner, since the object doesn’t need to look for other components it works with, or know their location and class. http://www.springframework.net/doc-latest/reference/html/objects.html#objects-factory-collaborators It facilitates the design of applications, using a framework that links the components, instead of the components linking themselves.

In other words, Dependency Injection, also known as Inversion Of Control (IoC), transfers the responsibility to locate and create the objects to the framework or the container which supports plug-n-play implementation, by injecting the dependencies into your code.

Features of Dependency Injection Main features of Dependency Injection Framework are:

• Better Design Pattern - Supports good Object-Oriented Design.
• Clean Code- Eliminates the need of looking up code from the application.
• Reuse - Promotes better code reusability.
• Loose Coupling- Objects are loosely coupled using DI
• Simple- It is very simple to implement, just need to inject the dependencies of any object.
• Maintainable- It is very easy to reconfigure and maintain in case of any future changes.

Dependency Injection Frameworks

Dependency Injection requires a framework that helps the developer to declare the dependencies, to locate, instantiate, and initialize the components or the objects. A developer has many available frameworks to him:

• Spring Framework – A light weight container, most widely used for DI and very large framework, which includes a lot many other features like Aspect Oriented, framework, container, etc. along with Dependency Injection.
• XWork - It is a standalone framework and mostly works in conjunction with Webworks. It is highly effective command pattern framework that provides a lot of features for DI.
• Apache Avalon- This is also a container framework which supports the dependency injection design pattern. This frameworks is now divided into sub-frameworks.
• PicoContainer - It is highly focused DI framework available.
• Hivelogic – Another DI framework to inject dependencies.

Example of Dependency Injection Framework

Let us take a simple example to understand the basic idea of DI. Suppose we have an Employee class which depends on the Department object, and we need some Assembler (DI Framework) to instantiate the Department field of Employee class, rather than Employee creates this object for itself. It will delegate this process of instantiation to any of the framework selected to do this job by using any form of configuration files, which are mostly .xml files. We will see comprehensive example using the framework in the next section.

 Employee.java
package myPackage;
public class Employee
 {

//dependent object ‘dept’ private Department dept;

        public void Employee( )
          {  
          }

setDepartment(dept)

          {

this.dept=dept; }

  }

Department.java
 package myPackage;
 public class Department
  {
     private String name; 
     public String getName()
      {

return name;

      }
     public void setName(String name)
      {
         this.name=name;
      }
   }

Now, it is the framework (any one of the selected frameworks mentioned above) which will instantiate the Department object by looking into the configuration file for any existing dependencies of Employee object, and thus forms Employee object with Department instance. For example, in Spring Framework, the configuration file will be ApplicationContext.xml, where this binding of beans is done as:

ApplicationContext.xml
<beans>
   <bean id="employee" class=" myPackage .Employee.java">
    	   <property name="name " ref="yetAnotherBean"/>
     </bean>
    <bean id="department" class=" myPackage .Department.java">     	
 	<property name="name" value="Java"/>      
     </bean>
</beans>

thereby creating the dependency diagram as: