Scribd
Upload
29 views14 pages

Spring 1

The IoC container is responsible for instantiating, configuring, and assembling objects in a Spring application, utilizing information from an XML file. There are two types of IoC containers: BeanFactory and ApplicationContext, with ApplicationContext offering additional features such as AOP integration and event propagation. Dependency Injection (DI) is a design pattern used to reduce coupling in code, allowing for easier management and testing, and can be implemented in Spring through constructor or setter methods.

Uploaded by

Candy Man
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
29 views14 pages

Spring 1

The IoC container is responsible for instantiating, configuring, and assembling objects in a Spring application, utilizing information from an XML file. There are two types of IoC containers: BeanFactory and ApplicationContext, with ApplicationContext offering additional features such as AOP integration and event propagation. Dependency Injection (DI) is a design pattern used to reduce coupling in code, allowing for easier management and testing, and can be implemented in Spring through constructor or setter methods.

Uploaded by

Candy Man
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 14

IoC Container

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 (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


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 com.javatpoint;

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="com.javatpoint.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 com.javatpoint;

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();

}
}
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="com.javatpoint.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="com.javatpoint.Employee"
>
<constructor-
arg value="Sonoo"></constructor-arg>
</bean>
....
Output:0 Sonoo
You may pass integer literal and string both as following
....
<bean id="e" class="com.javatpoint.Employee">
<constructor-arg value="10" type="int" ></constructor-arg>
<constructor-arg value="Sonoo"></constructor-arg>
</bean>
....
Output:10 Sonoo

You might also like