Spring Framework -I

of 49© People Strategists www.peoplestrategists.com
Spring Framework -I

Objectives
In this session, you will learn to:
Introduce the Spring framework
Explore the Spring architecture
Explore Spring core container and beans
Manage application object
Introduce bean factory
Introduce application context
Identify XML based configuration
Identify annotation driven configuration

Spring Framework:
Is a popular non-standard open-source framework developed by
Interface21 Inc.
Aims to overcome the application problems by enabling the use of
simple JavaBeans (POJOs) to implement the business logic.
Enables the developers to create and test applications easily.
Aims to minimize the dependency of application code on its
framework.
Enables the use of simplicity and ease of testability in standalone
applications.
Introducing Spring Framework

Introducing Spring Framework (Contd.)
Features of
Pluggability
Dependency
Injection (DI)
Aspect
-Oriented
Programming
(AOP)
Container
Lightweight

Pluggability:
It allows you to associate and remove business layer objects with each other
with the help of configuration files.
Spring requires you to make changes in the XML configuration file and run the
application again to take effect.
Dependency Injection (DI):
It allows you to loose coupling by creating the business layer objects based on
the description in spring configuration file.
As a result, it eases the maintenance and the testing of an application.
Aspect-Oriented Programming (AOP):
Aspect is defined as modularization of the system-wide concerns, such as
transaction management and security.
These system-level concerns are called cross-cutting concerns as they cut
across a wide range of objects within the application.

AOP is used to modularize and separate these concerns in the form of
aspects.
Container:
The Spring framework is a container that holds all the application
objects.
It is responsible for managing the life cycle and configuration of all the
application objects.
The container creates objects, which are defined in configuration files,
and associate them together.
Lightweight:
Spring is a lightweight framework that makes it easy to configure and
create complex applications.
It consists of several well-defined modules, built upon the concept of DI
and AOP.

Exploring the Spring Architecture
The Spring framework has a layered architecture made up of the
following seven well-defined modules, as shown in the following
figure.
The Layered Architecture of the Spring Framework
Core
ORM Web Context
MVC
Application
Context
DAO
AOP

Exploring the Spring Architecture (Contd.)
Core
Provides the fundamental
functionality of the Spring
framework.
Contains the most important
component of the Spring
framework, the bean factory
container.
Applies DI to separate the
object initialization, creation,
and access from the actual
application code.
Requires you to use the
org.springframework.core
package within your Web
application.

Aims to standardize data
access work through
technologies, such as
Hibernate, JDO, or JDBC.
Enables you to write simple
database code without
worrying about database
related tasks.
Provides an exception
hierarchy for managing
database connections and
handling exceptions.
org.springframework.dao
application.
DAO

Enables developers to
integrate the Spring
framework with several other
ORM tools.
Is built upon the DAO module
to provide an easy way to
build DAOs for the ORM tool.
Is supported by the declarative
transaction management
services of the Spring
framework.
org.springframework.orm
application.
ORM

Enables Spring to provide
support for implementing
aspects within your Web
application.
Supports loose coupling of
the application objects.
Enables you to separate the
application logic from the
system-level services called
cross-cutting concerns.
org.springframework.aop
application.
AOP

Provides a flexible Model
-View-Controller
implementation for creating
Web applications.
Enables you to separate the
model and application logic
from the view or the
application UI.
Enables you to integrate
several other MVC
frameworks, such as Struts,
and WebWorks.
org.springframework.web
application.
MVC

Is built on top of the core
module and provides you
with the ability to obtain
application resources.
Provides support for
internationalization of
messages, application lifecycle
events, and validations.
Provides various enterprise
level services, such as JNDI
access, EJB integration, email,
remoting, and scheduling.
org.springframework.cont
ext package within your Web
application.
Application
Context

Is a part of its Web
application development
stack, which also includes the
MVC module.
Is built on top of the
application context module
and provides the context for
creating Web-based
applications.
Supports integration of the
Spring framework with various
frameworks, such as Struts,
WebWorks, and JSF.
org.springframework.web
application.
Web
Context

The Spring framework provides the following types of containers:
Bean factory:
 Is a simple container that provides support for DI.
 Is defined by the org.springframework.beans.factory.BeanFactory
interface.
Application context:
 Is built upon the concept of the bean factory container and provides other
functionalities, such as easy integration with Spring AOP features and support
for internationalization.
 Is defined by the org.springframework.cotext.ApplicationContext
interface.
Managing Application Object

The objects created by the bean factory are fully configured, ready to
use, and aware of their relationships with the other application
objects.
The bean factory is involved in managing the life cycle of objects that
have been created.
It is represented by the
org.springframework.beans.factory.BeanFactory interface.
The most commonly used bean factory is the XML bean factory
represented by the
org.springframework.beans.factory.xml.XmlBeanFactory
interface.
Introducing Bean Factory

Introducing Bean Factory (Contd.)
XML Bean
Factory
Bean configuration file
<?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-3.0.xsd">
...
</beans>
Syntax of a bean configuration file:

In a bean configuration file, each bean is defined by using the
<bean> tag within the <beans> tag.
A bean definition contains the basic information about a bean
that a container must know, such as the process for creating a
bean, details about the bean life cycle, and the various
dependencies for that bean.
Attributes of <bean> tags are:
id
Used to uniquely
identify a bean in
the Spring
container.
name
Used to specify an
alias name for the
bean.
scope
Used to define the
scope of the bean
being defined.
class
Used to specify the
fully-qualified
(package name +
class name) name of
the bean class.

Following code snippet is an example of bean declaration:
Following code snippet displays the class declaration:
<?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-3.0.xsd">
<bean id="Beckham" class="Sport.LAGalaxy"/>
</beans>
package Sport;
public class LAGalaxy implements FootballTeam{
private int squadStrength = 16;
public LAGalaxy(){}
public LAGalaxy (int squadStrength) {
this.squadStrength = squadStrength;
}
public void squadSize(){
System.out.println("LAGalaxy has"+ squadStrength + "players in
its team");
}
}

To instantiate a bean factory in your Web application, you first need to
load the bean configuration file.
This can be done by using the Resource object, defined by the
org.springframework.core.io.Resource interface.
The following table lists the several implementations of the Resource
interface.
Resource Implementation Function
org.springframework.core.io.ByteAr
rayResource
It is used for defining a resource whose content is
represented as an array of bytes.
org.springframework.core.io.ClassP
athResource
It is used for defining a resource, retrieved from the
specified class path.
org.springframework.core.io.FileSy
stemResource
specified file system.
org.springframework.core.io.InputS
treamResource
It is used for defining a resource, retrieved from an
input stream.
org.springframework.web.context.su
pport.ServletContextResource
It is used for defining a resource, available inside the
servlet context.
org.springframework.core.io.UrlRes
ource
given URL.

The following code snippet loads the bean configuration file,
Spring-Config.xml into the Resource object, res:
You can control the number of instances of a particular bean to be
created - whether one instance for the entire application or one
instance per request.
This is done by defining the scope for the beans.
Bean factory supports the following types of bean scopes:
Singleton: It provides a shared instance of the bean with a particular
name and places it in the factory.
Prototype: It provides a single instance of a bean and guarantees that a
user request will result in the creation of an independent bean for a single
user only.
Resource res =
new ClassPathResource("Sport/Spring-Config.xml");
BeanFactory factory = new XmlBeanFactory(res);

Instantiating a bean:
You can retrieve an instance of a bean registered under a given name
from the bean factory by using the getBean()method.
This method takes the ID of the bean as a string value, as shown in the
following code snippet:
When the getBean()method is called, the bean factory container
instantiates the bean and set its properties through DI.
After this, the life of the bean begins inside the Spring container.
LAGalaxy team = (LAGalaxy)
factory.getBean("Beckham");
team.squadSize();

Lifecycle of a bean inside the bean factory:

Introducing Application Context
Application Context:
Provides a means for resolving text messages, including support for
internationalization of those messages.
Provides a generic way to load file resources, such as images.
Publishes events to beans, which are registered as listeners.
The following table lists the implementations of the application
context container provided by the Spring framework.
Resource Implementation Function
ClassPathXmlApplicationContext It is used to load the bean configuration file located
at the specified class path.
FileSystemXmlApplicationContext It is used to load the bean configuration file available
in the specified file system.
XmlWebApplicationContext It is used to load the bean configuration file from the
location specified by the contextConfigLocation
context parameter in web.xml. By default, it loads
applicationContext.xml stored in the WEB-INF
folder of the Web application.

Introducing Application Context (Contd.)
Loading Application Context:
You can load a application context using any of the three
ApplicationContext implementations.
Example: ClassPathXmlApplicationContext
Example: FileSystemXmlApplicationContext
Example: XmlWebApplicationContext
ApplicationContext appContext = new
FileSystemXmlApplicationContext("c:/Sport/Spring-
Config.xml");
ApplicationContext appContext = new
ClassPathXmlApplicationContext("Sport/Spring-Config.xml");
XmlWebApplicationContext appContext = new
XmlWebApplicationContext();

Introducing Application Context (Contd.)
Life cycle of a bean inside application context:

Task: Creating a Spring Application
Let us see how to create a
Spring application.

Sandy has been assigned a task to create the login module for a
Web application that can be used to keep track of the product
inventory and the orders of the customers. He has to create a
Web application by using a framework that makes the business
logic components of the application loosely coupled with each
other.
Help Sandy in the creation of the Web application structure using
an appropriate framework.
Activity: Creating a Web Application with Login

The process of creating and managing
association among application objects forms
the core of DI and is commonly referred to
as wiring.
To inject dependencies into the application
objects, you need to configure them in an
XML-based configuration file.
In this file, you should first give a definition
for the bean for which the dependency is to
be created.
Injecting Application Objects
Order
Customer
ProductInjected into
Injected into
Bean wiring
Explicit wiring Autowiring

Applying explicit wiring:
You can explicitly wire the beans by declaring their dependencies in the
configuration file.
While declaring the beans in the configuration file, you can also wire its
properties.
You can explicitly wire the bean properties in the configuration file by
using:
Injecting Application Objects (Contd.)
Setter injection Constructor injection

Using setter injection:
Setter injection is a bean wiring technique in which the JavaBean setter
methods are used for supplying the bean properties to the objects that
need them.
You can wire the bean properties in a Spring-enabled application by
declaring a <property> element for the bean in the configuration file
within the <bean> tag.
The <property> element can inject dependencies using the setter
methods of the property in the following ways:
Injecting
simple values
Referencing
other beans

Injecting simple values:
You can use the value attribute of the <property> element to inject a
string value into a bean property.
The value attribute can also take on values of the other types, such as
integer, floating point, and boolean.
Consider an example of Player interface:
The following code snippet declares the FootballBoots interface:
package SetterInject;
public interface FootballBoots
{
void wearBoots();
}
public interface Player
{
void play();
}

The following code snippet implements the Player interface:
public class FootballPlayer implements Player{
public FootballPlayer() {}
@Override
public void play() {
System.out.println("I am playing with " + football +
" football.");
}
private String football;
public void setFootball(String football){
this.football = football;
}
private FootballBoots boots;
public void setBoots(FootballBoots boots){
this.boots = boots;
}
}

The following code snippet does the bean wiring:
<bean id="Kaka"
class="SetterInject.FootballPlayer">
<property name="football" value="Adidas"/>
</bean>
<bean id="Forlan"
<property name="football" value="Nike"/>
</bean>

Referencing other beans:
To wire beans with each other, you have to specify bean references in the
bean configuration file.
You can specify a bean reference for a bean property by using the ref
attribute of the <property> element.
The ref attribute sets the value of the specified property of the bean by
passing to it a reference of another bean.
Consider the following code snippet:
public class Predator implements FootballBoots {
public Predator () {}
public void wearBoots () {
System.out.println("I am wearing Adidas predator
boots.");
}
}

The following code configures the bean:
The following code snippet does the bean wiring:
In the preceding code snippet, the bean uses the predator bean by
referencing it.
<bean id="predator" class="SetterInject.Predator"/>
<bean id="Kaka"
<property name="football" value="Adidas" />
<property name="boots" ref="predator" />
</bean>
<bean id="Forlan"
<property name="football" value="Nike" />
<property name="boots" ref="predator" />
</bean>

Using constructor injection:
It is a bean wiring technique, where an object is provided its dependencies
via its own constructors.
The dependencies are passed as arguments of the constructors with each
representing a property or a collaborator object.
In this method, each object declares a constructor or a set of constructors
that take object dependencies as arguments.
Consider the previous example of the Player interface and
FootballPlayer class.

The FootballPlayer class can be modified as shown in the following
code snippet:
public class FootballPlayer implements Player{
private int shirtNumber;
public FootballPlayer() {}
public FootballPlayer(int shirtNumber){
this.shirtNumber= shirtNumber;
}
@Override
System.out.println("I am playing with shirt number " +
shirtNumber +".");
}
}

The following code snippet wires a bean:
In the preceding code snippet, values are passed as constructor parameter
by making use of the constructor-arg element.
<bean id="Kaka"
<constructor-arg value="7"/>
</bean>
<bean id="Forlan"
<constructor-arg value="21"/>
</bean>

Applying autowiring:
The property name or the constructor argument is not declared within the
configuration file.
The Spring container itself finds the type and name of the property and
matches the property type and name with other beans in the container
based on their specified type or name.
In this method, each object declares a constructor or a set of constructors
that take object dependencies as arguments.
Wiring is achieved by setting the autowire property of the beans.
Values of the autowire property are:
 byName: Bean is matched whose name matches the name of the property
being wired.
 byType: Bean is matched whose type matches the type of the property being
wired.
 constructor: Bean is matched based on the parameters of the constructors of
the bean that is being wired.

 autoDetect: Bean is matched first by using constructor, and then byType, if
there is a default constructor with no arguments.
Autowiring by name:
 If the name of a property matches the name of the bean that has to be wired
into that property, the Spring framework can automatically wire that bean into
the property.
 The following code snippet configures the bean:
 The following code snippet wires the bean:
 The following code snippet defines the autowiring by name:
<bean id="boots" class="SetterInject.Predator"/>
<bean id="Kaka"
class="SetterInject.FootballPlayer" autowire="byName">
</bean>
<bean id="Kaka" class="SetterInject.FootballPlayer">
<property name="football" value="Adidas"/>
<property name="boots" ref="predator"/>
</bean>

Autowiring by type:
 Spring attempts to find a bean whose type is compatible with the property
type.
 The following code snippet defines the autowiring by type:
<bean id="boots" class="SetterInject.Predator">
</bean>
<bean id="Kaka" class="SetterInject.FootballPlayer"
autowire="byType">
</bean>

Autowiring by constructor:
 Is achieved by setting the autowire property to constructor.
 Spring automatically selects constructor arguments from the beans, defined in
the configuration file.
 Consider the declarartion of RugbyPlayer and RublyBoots classes:
// code for RugbyPlayer class
package AutowireInject;
public class RugbyPlayer implements Player{
private RugbyBoots rugbyboots;
private int shirtNumber;
public RugbyPlayer(RugbyBoots rugbyboots) {
this.rugbyboots=rugbyboots;
}
public int getShirtNumber() {
return shirtNumber;
}
public void setShirtNumber(int shirtNumber) {
this.shirtNumber = shirtNumber;
}
@Override

 The following code snippet does the bean wiring:
System.out.println("I am playing with shirt number " +
shirtNumber + " and " + rugbyboots.getBoots() +" rugby
boots.");
}}
// code for RugbyBoots class
package AutowireInject;
public class RugbyBoots{
private String boots;
public String getBoots() {
return boots;
}
public void setBoots(String boots) {
this.boots = boots;
}
}
<bean id="Wilkinson"
class="AutowireInject.RugbyPlayer" autowire="constructor">
<property name="shirtNumber" value="7"/>
</bean>
<bean id="NikeBoots" class="AutowireInject.RugbyBoots">
<property name="boots" value="Nike"/>
</bean>

Summary
In this session, you learned that:
Spring aims to minimize the dependency of application code on its
framework.
Spring is a modular framework that has the following features:
 Pluggability
 DI
 AOP
 Container
 Lightweight
The Spring framework has a layered architecture that supports the business
logic of a Web application.
Spring is a comprehensive framework that provides you the functionality of
several J2EE technologies, such as Struts MVC and EJB, in a single framework.
The Spring framework has a layered architecture made up of seven well-
defined modules.

Summary (Contd.)
The seven modules in the Spring framework are:
 Spring core module
 Spring application context module
 Spring Data Access Object (DAO) module
 Spring ORM module
 Spring AOP module
 Spring Web context module
 Spring Web MVC module
The core module provides the fundamental functionality of the Spring
framework. It contains the most important component of the Spring
framework, the bean factory container.
The DAO module of the Spring framework aims to standardize data access
work through technologies, such as Hibernate, JDO, or JDBC.
The ORM module enables developers to integrate the Spring framework with
several other ORM tools, such as Hibernate, iBatis, and JDO, as required for
the application.

Summary (Contd.)
The AOP module enables Spring to provide support for implementing aspects
within your Web application.
The MVC module provides a flexible Model-View-Controller implementation
for creating Web applications.
The application context module of the Spring framework is built on top of the
core module. This module makes Spring a framework and provides you with
the ability to obtain application resources for the application objects through
a consistent Spring API.
The Web context module of the Spring framework is a part of its Web
application development stack, which also includes the MVC module.
The Spring container is based on the concept of DI for managing the
application objects.

Summary (Contd.)
The Spring framework provides the following types of containers:
 Bean factory
 Application context
The bean factory container is used to instantiate, configure, and manage objects
(beans) for your application.
It is represented by the org.springframework.beans.factory.BeanFactory
interface.
The XML bean factory loads the beans on the basis of the bean definitions given in
an XML file. This XML file is also called bean configuration file.
The <bean> tag contains the following attributes to define the bean:
 id
 name
 class
 scope

Summary (Contd.)
Bean factory supports the following types of bean scopes:
 Singleton
 Prototype
You can retrieve an instance of a bean registered under a given name from the
bean factory by using the getBean() method.
The Spring framework provides the following commonly used implementations of
the application context container:
 ClassPathXmlApplicationContext
 FileSystemXmlApplicationContext
 XmlWebApplicationContext
Bean wiring can be done in following ways:
 Explicit wiring
 Autowiring

Spring Framework -I

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Spring Framework -I (20)

More from People Strategists (20)

Recently uploaded (20)

Spring Framework -I