Skip to main content

Spring : Core (IOC Container)

First we will understand what is IOC- Inversion of Control, The concept of IOC deals with Object Creation, Dependency Satisfaction & Life Cycle Management. The concept states that application programmers must only be concern with the use of Objects, they shouldn’t be concern with their creation and life cycle management. Application programmers should delegate these responsibilities to a Runtime Environment called IOC Container. Conventionally application programmers waste more than 50% of their efforts in object creation & their management as we can describe this situation by the following example.
Let's there be two classes named A & B. Class A has a dependency on Class B i.e. an Object of Class B is required by an Object of Class A to Perform its task.
The conventional approach does this thing as.
1. Application need an Object of Class A.
2. Object of Class A is created let ObjA.
3. Object of B class is created let ObjB.
4. Reference of ObjB is provided to ObjA.
5. ObjA is used.
Now IOC do the needful background work and it imposes the following solution to this problem.
1. Application request Object of Class A to IOC Container.
2. IOC Container Creates Object of Class A let ObjA.
3. IOC Container Creates Object of Class B let ObjB.
4. IOC Container pass the Reference of ObjB to ObjA.
5. Reference of ObjA is return back to application.
Now this will change the whole picture if Class A is depending on huge number of classes then all the work of Object creation and management will be done by IOC Container only.
Major Advantages of IOC (Inversion of Control Approach)
1. Productivity of the programmer is increased as they are responsible for the use of Object.
2. Reusability of the objects is increased because Objects are managed by Centralize party i.e.
IOC Container.
3. Maintenance of the application is simplifying because programmatic dependency of objects
is converted into declarative dependencies i.e. Dependency of Objects are expressed via a
Configuration file.
Read Here : Terminology and Components of Spring IOC
Example:
Let’s understand the whole scenario with an example. What we require.
1. An interface to provide the specification to the classes.
2. Two classes (At least) to show the dependency and relationship and conversion.
3. A user class to consume the objects.
4. Bean factory class to create the bean factory object.
5. Configuration file to provide the information to the bean factory class
Application Example:
1. Number.java
package com.jubilation.spring.user;
public interface Number {
public Number add(Number n);
public void display();
}
2. Complex.java
package com.jubilation.spring.user;
public class Complex implements Number {
private int real, img;
public Complex(int real, int img) {
this.real = real;
this.img = img;
}
@Override
public Number add(Number n) {
Complex c = (Complex) n;
int real = this.real + c.real;
int img = this.img + c.img;
return new Complex(real, img);
}
@Override
public void display() {
System.out.println("The Number is :" + real + "+" + img + "i");
}
}
3. Rational.java
package com.jubilation.spring.user;
public class Rational implements Number{
private int p, q;
public Rational(int p, int q) {
this.p = p;
this.q = q;
}
@Override
public Number add(Number n) {
Rational r = (Rational) n;
int p= this.p*r.q + this.q*r.p;
int q = this.p* r.q;
return new Rational(p, q);
}
@Override
public void display() {
System.out.println("The Number is :" + p + "/" + q);
}
}
4. IOCUser.java
package com.jubilation.spring.user;
import org.springframework.beans.factory.BeanFactory;
public class IOCUser {
public static void main(String[] args) {
// TODO code application logic here
BeanFactory factory = MyFactory.getBeanFactory();
Number n1 = (Number) factory.getBean("Complex1");
Number n2 = (Number) factory.getBean("Complex2");
Number n3 = n1.add(n2);
n3.display();
Number N1 = (Number) factory.getBean("Rational1");
Number N2 = (Number) factory.getBean("Rational2");
Number N3 = N1.add(N2);
N3.display();
}
}
5. MyFactory.java
package com.jubilation.spring.user;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class MyFactory {
private static BeanFactory factory;
static{
Resource resource=new ClassPathResource("beanscfg.xml");
factory=new XmlBeanFactory(resource);
}
public static BeanFactory getBeanFactory() {
return factory;
}
}
6. Beanscfg.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="Complex1" class="com.jubilation.spring.user.Complex">
<constructor-arg value="34"/>
<constructor-arg value="357"/>
</bean>
<bean id="Complex2" class="com.jubilation.spring.user.Complex">
<constructor-arg value="332"/>
<constructor-arg value="133"/>
</bean>
<bean id="Rational1" class="com.jubilation.spring.user.Rational">
<constructor-arg value="34"/>
<constructor-arg value="357"/>
</bean>
<bean id="Rational2" class="com.jubilation.spring.user.Rational">
<constructor-arg value="332"/>
<constructor-arg value="13"/>
</bean>
</beans>

Comments

Popular posts from this blog

Who is Peter Lynch and what is his philosophy in equity market investment? 25 Golden Rules of the most successful Fund Manager.

Peter Lynch (born January 19, 1944) is an American investor, mutual fund manager, and philanthropist. As the manager of the Magellan Fund at Fidelity Investments between 1977 and 1990, Lynch averaged a 29.2% annual return, consistently more than doubling the S&P 500 stock market index and making it the best-performing mutual fund in the world. During his 13 year tenure, assets under management increased from $18 million to $14 billion. He also co-authored a number of books and papers on investing and coined a number of well known mantras of modern individual investing strategies, such as Invest in what you know and ten bagger. Lynch is consistently described as a "legend" by the financial media for his performance record. Base on his career I have compiled his investing rules here. 25 GOLDEN RULES by @Peter Lynch 1: Nobody can predict interest rates, the future direction of the economy or the stock market. Dismiss all such forecasts & concentrate on what's actual

What is version checking in Hibernate ?

Version checking used in hibernate when more then one thread trying to access same data. For example : User A edit the row of the TABLE for update ( In the User Interface changing data This is user thinking time) and in the same time User B edit the same record for update and click the update. Then User A click the Update and update done. Change made by user B is gone. In hibernate you can prevent slate object updation using version checking. Check the version of the row when you are updating the row. Get the version of the row when you are fetching the row of the TABLE for update. On the time of updation just fetch the version number and match with your version number (on the time of fetching).

What are JEE Containers? What are their different types?

Containers are the interface between a component and the low-level, platform-specific functionality that supports the component. Before it can be executed, a web, enterprise bean, or application client component must be assembled into a Java EE module and deployed into its container. The assembly process involves specifying container settings for each component in the Java EE application and for the Java EE application itself. Container settings customize the underlying support provided by the Java EE server, including such services as security, transaction management, Java Naming and Directory Interface (JNDI) API lookups, and remote connectivity. Here are some of the highlights. The Java EE security model lets you configure a web component or enterprise bean so that system resources are accessed only by authorized users. The Java EE transaction model lets you specify relationships among methods that make up a single transaction so that all methods in one transaction are treated as a