♠ Posted by
Java Tutorials
Page 1|2|3|4
IoC Container
- IoC
Container
- Using
BeanFactory
- Using
ApplicationContext
The IoC container is responsible to instantiate, configure and
assemble the objects. The IoC container gets informations from the XML file and
works accordingly. The main tasks performed by IoC container are:
·
to instantiate the application class
·
to configure the object
·
to assemble the dependencies between the objects
There are two types of IoC containers. They are:
- BeanFactory
- ApplicationContext
Difference between BeanFactory
and the ApplicationContext
The
org.springframework.beans.factory.BeanFactory and the org.springframework.context.ApplicationContext interfaces acts as the IoC container. The ApplicationContext
interface is built on top of the BeanFactory interface. It adds some extra
functionality than BeanFactory such as simple integration with Spring's AOP,
message resource handling (for I18N), event propagation, application layer
specific context (e.g. WebApplicationContext) for web application. So it is better
to use ApplicationContext than BeanFactory.
Using BeanFactory
The XmlBeanFactory is the implementation class for the BeanFactory
interface. To use the BeanFactory, we need to create the instance of
XmlBeanFactory class as given below:
Resource resource=new ClassPathResource("applicationContext.xml");
BeanFactory factory=new XmlBeanFactory(resource);
The constructor of XmlBeanFactory class receives the Resource
object so we need to pass the resource object to create the object of
BeanFactory.
Using ApplicationContext
The ClassPathXmlApplicationContext class is the implementation
class of ApplicationContext interface. We need to instantiate the
ClassPathXmlApplicationContext class to use the ApplicationContext as given
below:
ApplicationContext context =
new ClassPathXmlApplicationContext("applicationContext.xml");
The constructor of ClassPathXmlApplicationContext class receives
string, so we can pass the name of the xml file to create the instance of
ApplicationContext.
Dependency Injection in Spring
- Dependency
Injection in Spring
- Dependency
Lookup
- Dependency
Injection
Dependency Injection (DI) is a design pattern that removes the
dependency from the programming code so that it can be easy to manage and test
the application. Dependency Injection makes our programming code loosely
coupled. To understand the DI better, Let's understand the Dependency Lookup
(DL) first:
Dependency Lookup
The
Dependency Lookup is an approach where we get the resource after demand. There
can be various ways to get the resource for example:
A obj = new AImpl();
In such
way, we get the resource(instance of A class) directly by new keyword. Another
way is factory method:
A obj = A.getA();
This
way, we get the resource (instance of A class) by calling the static factory
method getA().
Alternatively,
we can get the resource by JNDI (Java Naming Directory Interface) as:
Context ctx = new InitialContext();
Context environmentCtx = (Context) ctx.lookup("java:comp/env");
A obj = (A)environmentCtx.lookup("A");
There
can be various ways to get the resource to obtain the resource. Let's see the
problem in this approach.
Problems of Dependency Lookup
There
are mainly two problems of dependency lookup.
·
tight coupling The dependency lookup approach makes the code tightly coupled. If
resource is changed, we need to perform a lot of modification in the code.
·
Not easy for
testing This
approach creates a lot of problems while testing the application especially in
black box testing.
Dependency Injection
·
The Dependency Injection is a design pattern that removes the
dependency of the programs. In such case we provide the information from the
external source such as XML file. It makes our code loosely coupled and easier
for testing. In such case we write the code as:
class Employee{
Address address;
Employee(Address address){
this.address=address;
}
public void setAddress(Address address){
this.address=address;
}
}
In such case, instance of
Address class is provided by external souce such as XML file either by
constructor or setter method.
Two ways to perform Dependency Injection in Spring framework
Spring
framework provides two ways to inject dependency
- By Constructor
- By Setter method
Dependency Injection by Constructor Example
- Dependency
Injection by constructor
- Injecting
primitive and string-based values
We can inject the dependency by
constructor. The<constructor-arg> subelement of <bean> is used for constructor
injection. Here we are going to inject
·
primitive and String-based values
·
Dependent object (contained object)
·
Collection values etc.
Injecting primitive and string-based values
Let's see the simple example to inject primitive and
string-based values. We have created three files here:
- Employee.java
- applicationContext.xml
- Test.java
Employee.java
It is a simple class containing two fields id and name. There
are four constructors and one method in this class.
package org.sample;
public class Employee {
private int id;
private String name;
public Employee() {System.out.println("def cons");}
public Employee(int id) {this.id = id;}
public Employee(String name) {
this.name = name;
}
public Employee(int id, String name) {
this.id = id;
this.name = name;
}
void show(){
System.out.println(id+" "+name);
}
}
applicationContext.xml
We are providing the information into the bean by this file.
The constructor-arg element invokes the constructor. In such case,
parameterized constructor of int type will be invoked. The value attribute of
constructor-arg element will assign the specified value. The type attribute
specifies that int parameter constructor will be invoked.
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="e" class="org.sample.Employee">
<constructor-arg value="10" type="int"></constructor-arg></bean></beans>
Test.java
This class gets the bean from the applicationContext.xml file
and calls the show method.
package org.sample;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.*;
public class Test {
public static void main(String[] args) {
Resource r=new ClassPathResource("applicationContext.xml");
BeanFactory factory=new XmlBeanFactory(r);
Employee s=(Employee)factory.getBean("e");
s.show();
}
}
Output:10 null
Injecting string-based values
If you don't specify the type
attribute in the constructor-arg element, by default string type constructor
will be invoked.
....
<bean id="e" class="org.sample.Employee">
<constructor-arg value="10"></constructor-arg>
</bean>
....
If you change the bean element
as given above, string parameter constructor will be invoked and the output
will be 0 10.
Output:0 10
You may also pass the string
literal as following:
....
<bean id="e" class="org.sample.Employee">
<constructor-arg value="Venkat"></constructor-arg>
</bean>
....
Output:0 Venkat
You may pass integer literal
and string both as following
....
<bean id="e" class="org.sample.Employee">
<constructor-arg value="10" type="int" ></constructor-arg>
<constructor-arg value="venkat"></constructor-arg>
</bean>
....
Output:10 venkat
