SPRING
Link:
http://static.springsource.org/spring/docs/2.5.4/reference/index.html
Packages to remember:
BeanFactory:
org.springframework.beans.factory.BeanFactory Interface.
XmlBeanFactory:
org.springframework.beans.factory.xml.XmlBeanFactory Class.
It implements BeanFactory Interface.
Application Context: org.springframework.context.ApplicationContext Interface.
It is a sub interface of BeanFactory.
ClassPathXmlApplicationContext:
org.springframework.context.support.ClassPathXmlApplicationContext class.

BeanFactory

ClassPathXmlApplicationContext
XmlBeanFactory
ApplicationContext

implements extends

implements

Spring Core Container:
Spring core container is an IOC implementation in java.
IOC is an architectural pattern describing to have an external entity to wire the objects.
Here the wiring is done using dependency injection.
IOC pattern describes to have an external entity to perform DI.
IOC – Inversion of Control DI – Dependency Injection.
Dependency Injection is a mechanism of making the dependencies available to the object.
The other 2 approaches to do the same are,

1. Creating the dependencies 2. Pulling the dependencies.
In Dependency Injection mechanism the dependencies are pushed into the object.
This approach helps us in creating the object more cleanly, as the code for creating or pulling the dependencies is excluded from the object.
However identifying the objects in which the DI is to be implemented is a difficult task and further implementing those objects is complex.
IOC describes a solution for this problem.
As per this solution we want to create a special entity only for this responsibility, such entity is generally considered/referred as IOC container.
The spring framework implements this pattern for managing java objects; this implementation of IOC is named as Spring Core Container.
Initializing the Spring Core Container:
To initialize a spring core container we just need to create a BeanFactory Object.
Spring Core Container can be started on any java platform such as directly on JRE, Applet Container, Web Container and EJB Container.
Spring Framework includes few implementations for Bean Factory that can allow us to create, to initialize Spring Core Container such as XmlBeanFactory, AutoProxyBeanFactory etc.
The Spring Framework includes a sub-type for Bean Factory which supports additional functionality over the Bean Factory.
The application context interface is the sub-type of Bean Factory interface.
Bean Factory takes less time to start compared to Application Context, as the Bean Factory will initialize the resources on request instead at start-up.
Using Bean Factory To Initialize Container:
BeanFactory beans = new XmlBeanFactory(new FileSystemResource (“mybeans.xml”));
FileSystemResource – FileInputStream or any input reading mechanism.
Using Application Context:
ApplicationContext ac = new ClassPathXmlApplicationContext (“mybeans.xml’);
This ClassPathXmlApplicationContext supports to specify multiple xml documents. new ClassPathXmlApplicationContext(new String[] {“mybeans1.xml”, “mybeans2.xml”});
Types of Dependency Injection:
The most common approaches to push the dependencies are, 1. Constructor injection 2. Setter method injection
Constructor Injection:
The process of pushing the dependency into an object through its constructor argument is referred as Constructor Injection.
The dependency that is mandatory for the object to exist is recommended to be injected through constructor.
If our dependency is to be injected only once into the object and need not be changed throughout the lifetime of this object, we are recommended to use constructor injection.
Setter Method Injection:
In this case we inject the dependency through the method argument of the object. In general these methods are setXXX methods.
This approach supports us to inject the dependencies into an object later after the object is instantiated.
This supports to change the dependency of an object for multiple times within the lifetime of the object.
Spring Beans Xml configuration document:
From Spring 2.0 the spring beans xml document elements are defined using xml schema.
The basic set of tags that can be used to create this document are described into spring beans xml schema document.
This schema definition is accessed using the following namespace, http://www.springframework.org/schema/beans <beans> tag:
This is the root element for the spring beans xml document.
This supports to define spring beans, import other spring beans documents and define aliases for spring beans.
The following 3 tags are supported as child tags, 1. import 2. alias 3. bean
In addition this tag supports few attributes for configuring default values of the respective parameter for all the spring beans defined in this document.
<bean> tag:
This tag is used to define a spring bean.
Managing spring bean includes 1. instantiating 2. initializing 3. manage the lifetime for the object.
Spring Container supports to instantiate a java object for a spring bean in 3 styles, 1. using class constructor 2. using static factory method 3. using non-static factory method using class constructor to instantiate spring bean: package com.acc.spring; public class TestBean{…..} config in xml file as follows for above bean:
<bean id= “tb” class= “com.acc.spring.TestBean”/>
To describe the spring container to instantiate spring bean using the class constructor we use class attribute.
The class attribute takes a qualified name of the class whose constructor is to be used for instantiating a spring bean.
We can define multiple spring bean’s in the context, thus we may want to describe a unique identity for the spring bean in the context.
We use “id” attribute to specify a unique identity for spring bean. package com.acc.spring; public class TestBean
{
Public TestBean(String s) { }
}
Config as follows:
<bean id= “tb” class= “com.acc.spring.TestBean”>
<constructor-arg><value>Hello</value></constructor-arg>
</bean>
How to describe to use argumented constructor ?
We use constructor-arg tag to describe an argument of the constructor to use for instantiating this spring bean.
Child tags of <constructor-arg>:
The <constructor-arg> tag supports the following child tags that can be used to describe the value for this constructor argument. 1. <value>
The value tag supports text as child content. Value tag supports one attribute named type. The type attribute specifies the type to which the enclosed string based value is to be converted.
Eg:
<value type= “int”>10</value> 2. <ref>
It describes a spring bean reference. It is an empty tag. It supports 3 attributes. 1. Local 2. Bean 3. Parent
Local:
Used to refer a spring bean using the id of spring bean.
Eg:
public class TestBean1{……} public class TestBean2
{
public TestBean2(TestBean1 tb1) {}
}

<bean id= “tb1” class= “com.acc.spring.TestBean1”/>
<bean id= “tb2” class= “com.acc.spring.TestBean2”> <constructor-arg><ref local= “tb1”/></constructor-arg>
</bean>
3. <null>
Eg:
<bean id= “tb2” class= “TestBean2”> <constructor-arg><null/></constructor-arg>
</bean>
4. <list>
To describe any array or java.util.List type of object.
Supports 0 or more child elements.
The list tag supports the following as child tags i. <value> ii. <ref> iii. <null> iv. <list> v. <set> vi. <map> vii. <props> viii. <bean>

All of these can occur for zero or more times in any order
Each child tag in this tag describes one element of this list or array
Eg:
Public class TestBean { Public TestBean(String s[]){} } <bean id= “tb” class= “com/acc.spring.TestBean”> <constructor-arg> <list> <value>v1</value> <value>10</value> </list> </constructor-arg> </bean> 5. <set>

It is used to describe java.util.set type of object. this supports the same child tags as list.

6. <map>
The map tag is used to describe java.util.map type of object
This tag supports zero or more entry tags, the entry tag supports 2 child tags. 1.key 2.can be any of the following <value> <ref> <null> <list> <set> <map> <props> <bean>

the key tag supports any one of the above listed tags as the child tags. eg: <map> <entry> <key><value>k1</value></key> <value>v1</value> </entry> <entry> <key><value>k1</value></key> <value>v1</value> </entry> </map> 7. <props>
It is used to describe java.util.Properties object where the key and value are considered as String. The props tag supports 0 or more prop tag.
Eg:
<props> <prop key= “k1”>v1</prop> <prop key= “k2”>v2</prop>
</props>
8. <bean>
Eg:
class TestBean2
{
TestBean2(TestBean1 t1) { }
}
<bean id= “t2” class= “TestBean2”> <constructor-arg> <bean class= “TestBean1”/> <constructor-arg>
</bean>

Spring Web MVC
This part of spring frame work implements infrastructure that is required for creating web based MVC applications in java.
The spring web MVC infrastructure is built on top of the Servlet API so that it can be integrated into any java web application server
This uses the spring IOC container to access the various framework and application objects