sSPRING :

--------

* IT IS AN OPEN SOURCE,NON-INVERSIVE,LIGHT WEIGHT FRAMEWORK WHICH WORKS ON

THE PRINCIPLE OF
DEPENDENCY INJECTION AND INVERSION OF CONTROL USING WHICH WE CAN DEVELOPE LOOSLY
COUPLED APPLICATIONS.

* SPRING IS WIDELY USED FOR THE DEVELOPEMENT OF ENTERPRISE APPLICATION AND

WEB APPLICATIONS.

* FOLLOWING ARE THE DIFFERENT MODULES OF SPRING FRRAMEWORK

1)SPRING CORE
2)SPRING CONTEXT
3)SPRING ORM(OBJECT TELATIONAL MAPPING)
4)SPRING AOP(ASPECT ORIENTED PROGRAMING)
5)SPRING DAO(DATA ALTER OBJECT)
6)SPRING MVC(MODEL VIEW CONTROLLER)

* SPRING CAN ALSO BE CALLED AS FRAMEWORK OF FRAMEWORK'S AS IT SUPPORTS

FRAMEWORK'S LIKE
HIBERNATE,JPA,JDBC,etc.

* SPRING PROVIDES SOLUTION FOR VARIOUS TECHNICAL PROBLEMS THAT WE USED TO

FACE IN OTHER
FRAMEWORK.

-----------------------------------------------------------------------------------
----------------------------

ADVANTAGES OF SPRING FRAMEWORK :

--------------------------------

* IT IS AN OPEN SOURCE FRAMEWORK.

* IT IS A LIGHT WEIGHT FRAMEWORK BECAUSE OF ITS POJO IMPLEMENTATION.

* IT PROVIDES THE PREDEFINED TEMPLATES FOR JDBC, HIBERNATE, JPA, etc., USING
WHICH WE CAN
AVOID THE BASIC STEPS OF EXECUTION.

1) BY USING JDBC TEMPLATE WE CAN AVOID THE STEP LIKE LOAD AND REGISTER
THE DRIVER,
ESTABLISH THE CONNECTION BETWEEN JAVA APP AND DATABASE SERVER, CREATE A
STATEMENT OR
PLATFORM , CLOSE THE COSTLY RESOURCES WHIC WHERE SUPPOSED TO BE WRITTEN
BEFORE AND AFTER
THE EXECUTION OF QUERY.

2) BY USING THE HIBERNATE TEMPLATE WE CAN AVOID THE STEPS LIKE CREATING
THE CONFIGURATION
OBJECT,CREATING SESSIONFACTORY, CREATING SESSION, HANDLING TRANSACTION WHICH IS
SUPPOSED TO BE EXECUTED
BEFORE AND AFTER SAVING A RECORD.

* BY USING SPRING WE CAN DEVOLOPE LOOSELY COUPLED APPLICATIONS AS IT SUPPORTS

DEPENDENCY INJECTION.

* THE DEVELOPEMENT OF APPLICATION USING SPRING FRAMEWORK IS EASY AS IT

SUPPORTS DEPENDENCY INJECTION
OR INVERSION OF CONTROL.

* THIS SPRING APP ARE EASY TO TEST AS IT SUPPORTS DEPENDENCY INJECTION AND
INVERSION OF CONTROL.

* IT PROVIDES A POWER ABSTRACTION CALLED JEE SPECIFICATIONS LIKE

JTA,JMA,JMS,JPA,etc.,
-----------------------------------------------------------------------------------
--------------------------------

SPRING BEAN :
-------------

* IT IS AN OBJECT WHICH IS CREATED BY SPRING CONTAINER, INITIALISED BY THE

SPRING CONTAINER, MANAGED
BY SPRING CONTAINER AND DEPENDENCY WILL BE INJECTED BY SPRING CONTAINER.

-----------------------------------------------------------------------------------
--------------------------------

SPRING CONTAINER :
------------------

* IT IS THE FACTORY OF SPRING BEANS.

* SPRING CONTAINER WILL CREATE SPRING BEAN OBJECT ,INITIALISE SPRING BEAN
OBJECT , MANAGE THE
LIFE CYCLE SPRING BEAN , INJECT THE DEPENDENCY FOR SPRING BEAN.

NOTE :
------
* WE CAN PROVIDE THE INFORMATION FOR THE SPRING CONTAINER ABOUT THE OBJECT
THAT HAS TO BE CREATED,
INITIALISED,MANAGED AND THE DEPENDENCY TO THE INJECTED BY PROVIDING METADATA.

* WE CAN PROVIDE THE METADATA FOR THE SPRING CONTAINER IN THE FOLLOWING WAYS
1) BY USING XML
2) BY USING ANOTATION
3) BY JAVA CODE

POJO CLASSES
|
METADATA------------> | <--------SPRING
CONTAINER
| | | OBJ 1,OBJ 2,OBJ 3
XML ANNOTATION JAVACODE |
|
RUN APPLICATION

-----------------------------------------------------------------------------------
---------------------------------

BEAN SCOPE :
------------
 * IT IS USED TO SPECIFY THE NO.OF SPRING BEAN OBJECTS THAT HAS TO CREATED FOR
A POJO CLASS OR BEAN CLASS
IN A SPRING CONTAINER.

* FOLLOWING ARE THE DIFF BEAN SCOPES AVAILABLE

1)SINGLETON ===> ONLY ONE OBJECT WILL BE CREATED FOR A BEAN CLASS IN A
SPRING CONTAINER.

2)PROTOTYPE ===> A NEW OBJECT WILL BE CREATED EVERYTIME WE CALL

getBean()

3)REQUEST ===> A NEW OBJ WILL BE CREATED FOR EVERY HTTP REQUEST

4)SESSION ===> A NEW OBJ WILL BE CREATED FOR EVERY HTTP SESSION

-----------------------------------------------------------------------------------
--------------------------------

TYPES OF SPRING CONTAINERS :

----------------------------

* WE HAVE TWO TYOES OF SPRING CONTAINERS

1) IOC CONTAINER

2) MVC CONTAINER

IOC CONTAINER :
---------------

* IT IS A SPRING CONTAINER WHICH WORKS ON THAA PRINCIPLE OF INVERSION OF

CONTROL.
ITOC CONTAINER WILL CREATE SPRING BEANS, INITIALISE SPRING BEANS, MANAGE THE
LIFECYCLR OF
SPRING BEANS AND INJECT THE DEPENDENCIES OR RESOURCES.

* WE HAVE 2 TYPES OF IOC CONTAINERS

1) CORE CONTAINER (SPRING BEANFACTORY CONTAINER)
2) JEE CONTAINER (SPRING APPLICATIONCONTEXT CONTAINER)

1) BEAN FACTORY :
--------------

* IT IS AN INTERFACE PROVIDED BY SPRING FRAMEWORK.

* IT IS THE ROOT INTERFACE WHICH REPRESENTS THE SPRING CONTAINER.

* ALL THE SPRING CONTAINERS WILL IMPLEMENTS BEANFACTORY.

* IT SUPPORTS BASIC FUNCTIONALITIES USING WHICH WE CAN DEVELOPE STANDALONE

APPLICATIONS.

* BEANFACTORY CREATES SPRING BEANS ONLY ON DEMAND, SO IT CAN BE REFERRED AS

LAZY.

* BEANFACTORY SUPPORTS ONLY SINGLETON AND PROTOTYPE BEANSCOPES.

 * THE AUTOWIRING BY BEANFACTORY SHOULD BE ACHIEVED ONLY BY XML AND
ANNOTATIONS ARE NOT SUPPORTED.

2) APPLICATIONCONTEXT :
--------------------

* IT IS AN INTERFACE PROVIDED BY SPRING FRAMEWORK WHICH IS A CHILD OF

ListableBeanFactory WHICH IS A CHILD OF BEANFACTORY.

* IT WILL HAVE ALL THE FUNCTIONALITIES OF BEANFACTORY AND ALSO SOME ADVANCED
FUNCTIONALITIES

* USING APPLICATIONCONTEXT WE CAN DEVELOPE WEB APPLICATIONS AND ALSO

ENTERPRISE APPLICATIONS

* APPLICATIONSCONTEXT CREATES SPRING BEANS ON STARTUP ,SO IT CAN BE REFERRED

AS EAGER.

* APPLICATIONCONTEXT SUPPORT SUPPORTS ALL TYPES OF BEANSCOPES.

* THE AUTOWIRING BY APPLICATIONCONTEXT CAN BE ACHIEVED BY XML AND ALSO BY

ANNOTATIONS.

-----------------------------------------------------------------------------------
--------------------------------

DIFFERENTS BETWEEN BEAN FACTORY AND APPLICATIONCONTEXT :

--------------------------------------------------------

-----------------------------------------------------------------------------------
---------------------------
BEANFACTORY APPLICATIONCONTEXT
-----------------------------------------------------------------------------------
---------------------------
* IT PROVIDES THE BASIC FUNCTIONALITIES * IT WILL HAVE ALL THE
FUNCTIONALITIES OF BEANSFACTORY
AND ALSO SOME ADVANCED FUNCTIONALITIES

* IT SUPPORTS BASIC FUNCTIONALITIES USING * USING APPLICATIONCONTEXT WE CAN

DEVELOPE WEB APP
WHICH WE CAN DEVELOPE STANDALONE APP AND ALSO ENTERPRISE APP.

* IT CREATES SPRING BEANS ONLY ON DEMAND * APPLICATIONCONTEXT CREATES

SPRING BEANS ON STARTUP,
SO IT CAN BE REFERRED AS LAZY SO IT CAN BE REFERRED AS EAGER.

* IT SUPPORTS ONLY SINGLTON AND * IT SUPPORTS ALL TYPES OF

BEANSCOPES
PROTOTYPE BEANSCOPE

* THE AUTOWIRING BY BEANFACTORY SHOULD * THE AUTOWIRING BY

APPLICATIONCONTEXT CAN BE ACHIVED
BE ACHIEVED ONLY BY XML, AND ANNOTATIONS BY XML AND ALSO BY ANNOTATIONS
ARE NOT SUPPORTED

-----------------------------------------------------------------------------------
--------------------------------
org.springframework.core.io.resource :
--------------------------------------

* IT IS AN INTERFACE PROVIDED BY SPRING FRAMEWORK

* THIS INTERFACE REPRESENTS THE RESOURCE THAT HAS TO BE PROVIDED FOR THE
SPRING CONTAINER TO
MANAGE THE SPRING BEANS.

* FOLLOWING ARE THE IMPLEMENTATION CLASSES OF RESOURCE INTERFACE

1) ClassPathaResource
2) FileSystemResource

-----------------------------------------------------------------------------------
--------------------------------

XmlBeanFactory :
----------------

* IT IS A CLASS PROVIDED BY SPRING FRAMEWORK.

* IT IS PRESENT IN org.springframework.beans.factory.xml PACKAGE

* IT REPRESENTS THE SPRING CONTAINER WHICH SHOULD READ THE BEAN DEFINITION
FROM AN XML DOCUMENT.

* IT IS DEPRICATED FROM SPRING 3.1

* IT IS A IMPLEMENTATION CLASS OF BEANFACTORY INTERFACE

-----------------------------------------------------------------------------------
--------------------------------

getBean() :
-----------

* IT IS A FACTORY METHOD PRESENT IN BEAN FACTORY INTERFACE.

* THIS METHOD WILL RETURN THE SPRING BEAN OBJECTS.

* THIS METHOD IS OVERLOADED.

* FOLLOWING ARE THE DIFF OVERLOADED METHOD OF getBean()

----------------------------------------------------------------
METHOD SIGNATURE RETURN TYPE
----------------------------------------------------------------
* getBean(String) Object

* getBean(String,Class<T>) T

* getBean(Class<T>) T

-----------------------------------------------------------------------------------
--------------------------------

EXAMPLE PROGRAM TO CREATE A SPRINGBEAN BY USIN XML CONFIGURATION :

------------------------------------------------------------------
 Car.java:
---------
public class Car{
public void start(){
sop("Car has been started") } }

-----------------------------------------------------------------------------------
--------------------------------

Car.xml :
---------
<beans>
<bean id="mycar" class="org.jsp.springdemo.car"></bean>
</beans>

-----------------------------------------------------------------------------------
--------------------------------

TestCar.java :
--------------
public Class Teacher {
psvm() {
Resource r = new ClassPathResource("car.xml");
BeanFactory factory = new XmlBeanFactory(r);
Car c = factory.getBean("myCar",Car.class);
c.start();
}}}

-----------------------------------------------------------------------------------
--------------------------------

SPRING BEAN INITIALISATION :

* THE SPRING BEAN INITIALISATION USING XML CAN BE DONE IN 2 WAYS

1) BY USING SETTER
2) BY USING CONSTRUCTOR

-----------------------------------------------------------------------------------
--------------------------------

SPRING BEAN INITIALISATION BY XML USING SETTER :

* TO INITIALISE A SPRING BEAN BY XML USING SETTER WE HAVE TO USE <property/>

WHICH IS
IS THE SUB TAG OF <bean/>

-----------------------------------------------------------------------------------
--------------------------------

EXAMPLE PROGRAM TO UNDERSTAND SPRINGBEAN INITIALISTION BY XML USING SETTER :

---------------------------------------------------------------------------

PERSON.JAVA :
-------------

package org.jsp.sprigdemo;

public class person{

 private int age;
private String name;

public void display() {

System.out.println("Age:" + age);
System.out.println("Name:" + name);
}
}//GETTER AND SETTER

-----------------------------------------------------------------------------------
--------------------------------

XML CODE :
----------

<beans>
<bean id="myperson" class="org.jsp.springdemo.Person">
<property name="age"value="25"></property>
<property name="name"value="Sathish"></property>
</bean>
</beans>

-----------------------------------------------------------------------------------
-------------------------------

TEST.JAVA :
-----------

public class Test{

public static void main(String[] args) {
Resource r = new ClassPathResource("car.xml");
BeanFactory factory = new XmlBeanFactory(r);
Person p = factory.getBean("myperson",Person.class);
p.display();
}
}

-----------------------------------------------------------------------------------
-------------------------------

SPRING BEAN INITIALISATION BY XML USING CONSTRUCTOR :

------------------------------------------------------

* THE SPRING BEAN CAN BE INITIALISED BY XML USING COSTRUCTOR WITH THE HELP
OF <constructor-arg/> WHICH IS
A SUB TAG OF <BEAN/>.

-----------------------------------------------------------------------------------
-------------------------------

EXAMPLE PROGRAM TO INITIALISE THE SPRING BEAN BY XML USING CONSTRUCTOR :

------------------------------------------------------------------------

USER.JAVA:
----------

package.org.jsp.springdemo;
public class User{
private long phone;
peivate String password;

public User() {
System.out.println("No-ARg constructor from user class");
}

public void display() {

System.out.println("Phone Number:" + phone );
System.out.println("Password:" + password);
}
public User(long phone,String password) {
this.phone=phone;
this.password=password;
System.out.println("PARAMETERISED construrctor from User class")

}
}

-----------------------------------------------------------------------------------
-------------------------------

XML.CODE :
----------

<beans>
<bean id="myUser" class="org.jsp.springdemo.User">
<constructor-arg name="phone"value="2985465"/>
<constructor-arg name="password"value="abc123"/>
</bean>
</beans>

-----------------------------------------------------------------------------------
-------------------------------

TEST.JAVA :
-----------

public class TestUser{

public static void main(String[] args) {
Resource r = new ClassPathResource("car.xml");
BeanFactory factory = new XmlBeanFactory(r);
User u = factory.getBean("myUser",User.class);
u.display();
}
}

-----------------------------------------------------------------------------------
-------------------------------

APPLICATIONCONTEXT :
-------------------

* IT IS AN INTERFACE PRESENT IN SPRING FRAMEWORK

* FOLLOWING ARE THE IMPORTANT IMPLEMENTATION OF APPLICATION CONTEXT

1) ClassPathXmlApplicationContext
2) FileSystemXmlApplicationContext
 3) AnnotationConfigApplicationContext

-----------------------------------------------------------------------------------
-------------------------------

DEPENDENCY INJECTION USING XML :

--------------------------------

* THE DEPENDENCY INJECTION BY XML CAN BE ACHIEVED BY TWO WAYS

1) BY USING SETTER
2) BY USING CONSTRURCTOR

-----------------------------------------------------------------------------------
-------------------------------

DEPENDENCY INJECTION USING SETTER (SETTER INJECTION):

-----------------------------------------------------

* SETTER INJECTION CAN BE ACHIEVED BY USING <PROPERTY/> WHICH IS A SUB TAG

OF<BEAN/> TAG

-----------------------------------------------------------------------------------
-------------------------------

EXAMPLE PROGRAM TO UNDERSTAND SETTER INJECTION :

------------------------------------------------

ENGINE.JAVA :
-------------

public class Engine{

public void start(){
sop("Engine has been started");
}
}

-----------------------------------------------------------------------------------
-------------------------------

BIKE.JAVA:
----------

public class Bike{

private Engine e;
//public getter and setters
}

-----------------------------------------------------------------------------------
-------------------------------

BIKE.XML :
----------

<beans>
<bean id="myBike" class="org.jsp.springdemo.Bike">
<property name="e"ref="myEngine"></property>
</bean>
<bean id="myEngine"class="org.jsp.springdemo.Engine"></bean>
</beans>

-----------------------------------------------------------------------------------
-------------------------------

TEST BIKE.JAVA :
----------------

public class TestBike{

public static void main(String[] args) {
ApplicationContext context= new
ClassPathXmlApplicationContext("bike.xml");
Bike b = context.getBean("myBike,Bike.class");
b.getE().start();
}
}

-----------------------------------------------------------------------------------
-------------------------------

DEPENDENCY INJECTION BY XML USING CONSTRUCTOR (CONSTRUCTOR INJECTION) :

-----------------------------------------------------------------------

* CONSTRUCTOR INJECTION BY XML CAN BE ACHIEVED BY USING <constructor.org/>

WHICH IS THE SUB TAG OF<BEAN/> TAG

-----------------------------------------------------------------------------------
-------------------------------

EXAMPLE PROGRAM TO UNDERSTAND CONSTRUCTOR INJECTION :

-----------------------------------------------------

PANCARD.JAVA:
--------------------

pacakage org.jsp.springdemo;

public class panCard{

private String number;
private String name;

public void display() {

System.out.println("panCard Number:" + number);
System.out.println("Name:" + name);
}
}

-----------------------------------------------------------------------------------
-------------------------------

PANCARDHOLDER.JAVA:
--------------------

pacakage org.jsp.springdemo;

public class panCardHolder{

private panCard card;
 public PanCardHolder() {
}
public PanCardHolder(PanCard card) {
this.card=card;
}
}

-----------------------------------------------------------------------------------
-------------------------------

PANCARD.XML :
-------------

<beans>
<bean id="myPerson" class="org.jsp.springdemo.PanCardHolder">
<constructor-arg name="card"ref="myCard"></constructor-arg>
</bean>
<bean id="myCard" class="org.jsp.springdemo.PanCard">
<property name="name" value="sdkvjgsiu"></property>
<property name="number" value="sd654545siu"></property>
</bean>
</beans>

-----------------------------------------------------------------------------------
-------------------------------

TEST.JAVA :
-----------

public class Test2{

public static void main(String[] args) {
ApplicationContext context= new
ClassPathXmlApplicationContext("Pancard.xml");
PanCardHolder holder =
ncontext.getBean("myPerson,PanCardHolder.class");
holder.getCard().display();
}
}

-----------------------------------------------------------------------------------
-------------------------------

COLLECTION INJECTION :
----------------------

* THE PROCESS OF INJECTING A COLLECTION TO THE SPRING BEAN IS CALLED AS

COLLECTION INJECTION.

* THE COLLECTION INJECTION CAN BE ACHIEVED BY USING THE TAGS LIKE

<LIST></LIST>, <SET></SET>, <MAP></MAP>,
ETC, WHICH AE SUB TAGS OF <PROPERTY/> .

-----------------------------------------------------------------------------------
-------------------------------
EXAMPLE PROGRAM TO UNDERSTAND COLLECTION INJECTION :
----------------------------------------------------

DEPARTMENT.JAVA :
-----------------

package org.jsp.SpringDemo;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Department {

private List<String> names;
private Set<Integer> ids;
private Map<Integer,String> details;

-----------------------------------------------------------------------------------
-------------------------------

DEPARTMENT.XML :
----------------

<beans>
<bean id="dept" class="org.jsp.springdemo.Department">
<property name="names">
<List>
<value>Virat</value>
<value>MSD</value>
<value>Rohit</value>
</List>
</property>
<property name="ids">
<Set>
<value>75</value>
<value>100</value>
<value>50</value>
</Set>
</property>
<property name="details">
<Map>
<entry Key='75' value='Virat'></entry>
<entry Key='100' value='MSD'></entry>
<entry Key='50' value='Rohit'></entry>
</Map>
</property>
</bean>
</beans>

-----------------------------------------------------------------------------------
-------------------------------

TEST3.JAVA:
-----------

package org.jsp.SpringDemo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {

public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("dept.xml");
Department d=context.getBean("dept",Department.class);
System.out.println(d.getNames());
System.out.println(d.getIds());
System.out.println(d.getDetails());
}
}

-----------------------------------------------------------------------------------
-------------------------------

VEHICLE.JAVA BIKE.JAVA , CAR.JAVA

RIDE.XML :
----------

<beans>
<bean id="RIDE" class="org.jsp.springdemo.di.Ride">
<property name="v" ref="myBike"></property>
</bean>
<bean id="myBike" class="org.jsp.springdemo.di.Bike"> </bean>
<bean id="myCar" class="org.jsp.springdemo.di.Car"> </bean>
</beans>

-----------------------------------------------------------------------------------
-------------------------------

TEST.JAVA :
-----------

package org.jsp.SpringDemo;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("ride.xml");
Ride r=context.getBean("ride",Ride.class);
r.getv().start();
}}

-----------------------------------------------------------------------------------
-------------------------------

AUTOWIRING :
------------

* THE PROCESS OF ENABILING IMPLECITE DEPENDENCY INJECTION WITHOUT WRITING THE

CODE EXPLICITLY TO
ACHIEVE DEPENDENCY INJECTION IS CALLED AS AUTOWIRING.
 * THE AUTOWIRING BY XML CAN BE ACHIEVED BY USING AN ATTRIBUTE autowire WHICH
IS PRESENT IN <BEAN> TAG

* FOLLOWING ARE THE DIFFERENT AUTOWIRING MODE

1)byType :
IN THIS MODE OF AUTOWIRING SPRING CONTAINER WILL SEARCH FOR A
QUALIFIED BEAN WHOSE
TYPE IS SAME AS REFERENCE TYPE.

2) byName :
IN THIS MODE OF AUTOWIRING SPRING CONTAINER WILL SEARCH FOR A
QUALIFIED BEAN WHOSE
NAME IS SAME AS REFERENCE NAME.

3) CONSTRUCTOR :
IN THIS MODE OF AUTOWIRING SPRING CONTAINER WILL CALL A
CONSTRUCTOR WITH MOST NUMBER OF
PARAMETER TO INJECT THE DEPENDENCY.

4) NO :
IT WILL DISABLE AUTOWIRING .

-----------------------------------------------------------------------------------
-------------------------------

NOTE :
------ 0

* WHENEVER WE HAVE MORE THEN ONE QUALIFIED BEAN FOR A REFERENCE TYPE IN
AUTOWIRING WE CAN SPECIFY
THE QUALIFYING BEAN OR PRIMARY BEAN BY USIN AN ATTRIBUTE
PRIMARY="true" WHICH IS PRESENT IN<BEAN/>

-----------------------------------------------------------------------------------
-------------------------------

ICECREAM.JAVA :
---------------

package org.jsp.SpringAutowiring;

public interface IceCream {

void eat();
}

-----------------------------------------------------------------------------------
-------------------------------

VANILLA.JAVA :
--------------

package org.jsp.SpringAutowiring;

public class Vanilla implements IceCream{

public void eat() {
System.out.println("Baby is eating vanilla icecream");
}
}

-----------------------------------------------------------------------------------
-------------------------------

CHOCOLATE.JAVA :
----------------

package org.jsp.SpringAutowiring;

public class Chocolate implements IceCream {

public void eat() {
System.out.println("Baby is eating chocolate icecream");
}
}

-----------------------------------------------------------------------------------
-------------------------------

BABY.JAVA :
-----------

package org.jsp.SpringAutowiring;

public class Baby {

private IceCream icecream;

public IceCream getIcecream() {

return icecream;
}

public void setIcecream(IceCream icecream) {

this.icecream = icecream;
}
}

-----------------------------------------------------------------------------------
-------------------------------

BABY.XML :
----------

<bean id="baby" class=" org.jsp.SpringAutowiring.Baby" autowire="byType"></bean>

<bean id="vanilla" class=" org.jsp.SpringAutowiring.Vanilla" primary="true"></bean>
<bean id="chocolate" class=" org.jsp.SpringAutowiring.Chocolate"></bean>

TEST.JAVA :

package org.jsp.SpringAutowiring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

public static void main(String[] args) {
ApplicationContext context =new
ClassPathXmlApplicationContext("baby.xml");
Baby b =context.getBean("baby",Baby.class);
b.getIcecream().eat();
 }
}

-----------------------------------------------------------------------------------
-------------------------------