Spring IOC step-by-steps

1.     IOC

Inversion of Control or IoC is one of the techniques used to wire services or components to an application program. By definition, IoC is “A software design pattern and set of associated programming techniques in which the flow of control of a system is inverted in comparison to the traditional interaction mode.” Simply stated, in IoC, instead of an application calling the framework, it is the framework that calls the components specified by the application.

This approach is similar to the one that Hollywood agents adopt with their clients. It is sometimes known as “Don’t call me, I will call you.” This is why IoC is also known as the Hollywood approach.
However, IOC is a broad and generic term. The aspect of IoC that the Spring Framework uses is "Injection of required resources or dependency at Run-time into the dependent resource," which is also known as Dependency Injection. Hence, the service provided by the IoC container of Spring is Dependency Injection. Therefore, I will be using the terms IoC and Dependency Injection in a lax way.
There are three forms or styles of Dependency Injection. They are:

1.      Constructor Injection

2.      Setter Injection

3.      Interface Injection

Of these, the Spring Framework directly supports the first and second forms whereas the third form is supported indirectly. Between the first and the second, the Spring Framework prefers the use of second rather than the first. Here are the details.

1.1  Constructor Injection: In Constructor Injection, an IoC container uses the constructor to inject the dependency. All the dependencies, whether they are simple values or references to other objects, are declared in the constructor. One of the advantages of Constructor Injection is that all the dependencies are declared in one go. This also helps in understanding whether the class depends on too many services.

   <constructor-arg index="0" type="java.lang.String" value="MyName"/>

The above code is an example for how to pass dependency arguments to the constructor. Index attribute is useful when you have multiple arguments with the same type, you can inform the IOC container about the order of the arguments. You can pass bean reference using the ref element.

Employee.java

package javabeat.net.spring.ioc;

/**
 * Source : http://www.javabeat.net
 */
public class Employee {
    private String name;
    private String empId;
    private Address address;
    public Employee(String name, String empId, Address address){
        this.name = name;
        this.empId = empId;
        this.address = address;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
    public String getEmpId() {
        return empId;
    }
    public void setEmpId(String empId) {
        this.empId = empId;
    }

    public String getName() {
        return name;
    }

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

Address.java

package javabeat.net.spring.ioc;
/**
 * Source : http://www.javabeat.net
 */

public class Address {
    public Address(){

    }
    private String street;
    private String city;
    private String pincode;

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getPincode() {
        return pincode;
    }

    public void setPincode(String pincode) {
        this.pincode = pincode;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }
}

ConstructorInjection.java

package javabeat.net.spring.ioc;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

/**
 * source : www.javabeat.net
 */
public class ConstructorInjection {
    public static void main(String args[]){
        Resource xmlResource = new FileSystemResource("applicationContext.xml");
        BeanFactory factory = new XmlBeanFactory(xmlResource);
        Employee employee = (Employee)factory.getBean("employeeBean");
        Address address = employee.getAddress();
        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());       
    }}

applicationContext.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:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <bean id="addressBean" class="javabeat.net.spring.ioc.Address">
        <property name="street">
            <value>Street</value>
        </property>
        <property name="city">
            <value>Bangalore</value>
        </property>
        <property name="pincode">
            <value>567456</value>
        </property>
    </bean>
    <bean id="employeeBean" class="javabeat.net.spring.ioc.Employee">
        <constructor-arg index="0" type="java.lang.String" value="MyName"/>
        <constructor-arg index="1" type="java.lang.String" value="001"/>
        <constructor-arg index="2">
            <ref bean="addressBean"/>
        </constructor-arg>
    </bean>
</beans>

1.2   Setter Injection: This form of Dependency Injection uses Setters, also known as mutators (because they change the value of the corresponding instance variables), to inject the required resources or dependencies. In other words, each of the objects that the class depends upon will have a setter and the IOC container will use the setters to provide the resource at run-time.

The main difference between Constructor Injection and Setter Injection is that in Constructor Injection, the handing over of the dependencies takes place during instantiation of the dependent object, whereas with Setter Injection, it takes place after the dependent object is instantiated. The Spring Framework favors Setter Injection over Constructor Injection.

Employee.java

package javabeat.net.spring.ioc;

/**
 * Source : http://www.javabeat.net
 */

public class Employee {
    private String name;
    private String empId;
    private Address address;
    public Employee(){
    }

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

    public String getEmpId() {
        return empId;
    }

    public void setEmpId(String empId) {
        this.empId = empId;
    }

    public String getName() {
        return name;
    }

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

Address.java

package javabeat.net.spring.ioc;
/**
 * Source : http://www.javabeat.net
 */

public class Address {
    public Address(){

    }
    private String street;
    private String city;
    private String pincode;

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getPincode() {
        return pincode;
    }

    public void setPincode(String pincode) {
        this.pincode = pincode;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

}

ConstructorInjection.java

package javabeat.net.spring.ioc;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

/**
 * source : www.javabeat.net
 */
public class ConstructorInjection {
    public static void main(String args[]){
        Resource xmlResource = new FileSystemResource("applicationContext.xml");
        BeanFactory factory = new XmlBeanFactory(xmlResource);
        Employee employee = (Employee)factory.getBean("employeeBean");
        Address address = employee.getAddress();
        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());       
    }}

applicationContext.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:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <bean id="addressBean" class="javabeat.net.spring.ioc.Address">
        <property name="street">
            <value>Street</value>
        </property>
        <property name="city">
            <value>Bangalore</value>
        </property>
        <property name="pincode">
            <value>567456</value>
        </property>
    </bean>
    <bean id="employeeBean" class="javabeat.net.spring.ioc.Employee">
        <property name="name" value="MyName"/>
        <property name="empId"  value="001"/>
        <property name="address" ref="addressBean"/>
    </bean>
</beans>

Note: 

The Following Jar files are needed to run the Above Code:

1.       commons-logging-1.0.4.jar

2.       org.springframework.beans-3.0.1.jar

3.       org.springframework.core-3.0.1.jar

1.3  Interface Injection:

Interface Injection provides the concrete implementations of an interface to the dependent object according to the configuration. The main difference between Interface Injection and the previous two is that in Interface Injection, any of the implementations of the interface can be injected, whereas with the other two, the object of the class specified is injected.

Note: Spring does not provide direct support for Interface Injection, Instead of that we can  use Auto Wiring.