Spring Core

BY
PUSHAN BHATTACHARYA
Its time for
1
Pushan Bhattacharya

Agenda – what to do in this Spring
Dependency Injection
Overview of Spring Framework
Various injections and their usages in detail
Bean scope
Bean wiring
Inner bean
Bean properties
Bean life cycle
Bean auto wiring
Spring Annotation
2
Pushan Bhattacharya

High Dependency = High Responsibility
public class Tiger {
public void eat() {
System.out.println(“Do not
disturb”);
}
}
public class MainClass {
public static void main(String…
args) {
Tiger t = new Tiger();
t.eat();
}
}
3
o Requirement: Change Tiger to
Lion.
o Me: Urggghhh. Too many
changes.
1. Standalone Lion class
2. Change the object
declaration to Lion
3. Change the reference
4. Compile again
5. Test
Pushan Bhattacharya

A bit less dependency
public interface Animal {
void eat();
}
public class Tiger implements Animal {
@Override
public void eat() {
System.out.println(“Do not disturb”);
}
}
public static void main(String… args) {
Animal a = new Tiger();
a.eat();
}
}
4
Lion.
o Me: Ufff. Again some changes.
1. Lion implements Animal
2. Change the object
declaration to Lion
4. Compile again
5. Test
Pushan Bhattacharya

Dependency Injection
public interface Animal {
void eat();
}
public class Tiger implements Animal {
@Override
public void eat() {
System.out.println(“Do not disturb”);
}
}
ApplicationContext aC = new ClassPathXmlApplicationContext(“wildLife.xml”);
Animal a = (Animal) aC.getBean(“animal”);
a.eat();
}
}
wildLife.xml
<bean id = “animal” class = “Tiger” />
5
Lion.
o Me: Ok. Small change.
1. Lion implements Animal
2. Change bean class to Lion
4. Compile again
5. Test
Pushan Bhattacharya

So what is Spring?
IoC container
Lightweight framework
Fully modularized (High decoupling)
Considered an alternative / replacement for the
Enterprise JavaBean (EJB) model
Flexible
 Programmers decide how to program
Not exclusive to Java (e.g. .NET)
Solutions to typical coding busywork
 JDBC
 LDAP
 Web Services
6
Pushan Bhattacharya

What Spring offers?
Dependency Injection (DI)
 DI is implemented through IoC (Inversion of Control)
Aspect Oriented Programming
 Runtime injection-based
Portable Service Abstractions
 The rest of spring
 ORM, DAO, Web MVC, Web, etc.
 Allows access to these without knowing how they actually work
Easily testable
7
Pushan Bhattacharya

What is a bean?
A Bean is a class that has only state but no behavior
A Bean must contain a no-argument constructor
A Bean should be serialized
8
Class Bean
Pushan Bhattacharya

Spring Framework Architecture
9
Pushan Bhattacharya
SPRING CORE CONTAINER
T
E
S
T
BeansCore Context
Expression
Language
DATA ACCESS
INTEGRATION
Spring ORM
Spring DAO
WEB LAYER
Spring WEB
Services
SPRING WEB
MVC
FRAMEWORK
SPRING
AOP

Spring Bean Configuration
10
Pushan Bhattacharya
<?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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd“ >
<bean id = “animal” class = “com.pushan.spring.beans.Tiger“ >
<property name = “msg” value = “Eating now“ />
</bean>

</beans>

Spring IoC Container
11
Pushan Bhattacharya
Bean / POJO /
Application Class
Bean Configuration
Metadata
Completely Configured
Application
Ready to Use
Spring IoC
Container
Registered
Input
Output
1
2
3

Spring IoC Container contd…
12
BeanFactory ApplicationContext
The simplest factory, mainly for DI The advanced and more complex factory
Used when resources are limited, e.g., mobile,
applets etc.
Used elsewhere and has the below features,
1> Enterprise aware functions
2> Publish application events to listeners
3> Wire and dispose beans on request
org.springframework.beans.factory.BeanFactory org.springframework.context.ApplicationContext
XmlBeanFactory factory = new
XmlBeanFactory (new
ClassPathResource(“wildLife.xml"));
ApplicationContext aC = new
ClassPathXmlApplicationContext(“wildLi
fe.xml”);
Pushan Bhattacharya

Injection Methods
Setter Injection
 Pass dependencies in via property setters (e.g., Spring)
Constructor Injection
 Pass dependencies in via constructor (e.g., Spring)
Interface Injection
 Pass dependencies in via interfaces (e.g., Avalon)
13
public static void main(String…
args) {
ClassPathXmlApplicationContext(“wild
Life.xml”);
Animal a = (Animal)
aC.getBean(“animal”);
a.eat();
wildLife.xml
<bean id = “animal” class
= “Tiger” />
Pushan Bhattacharya

Setter Injection
In the <bean>, Specify <property> tag.
14
public class College {
private String collegeId;
private int totalStudents;
public String getCollegeId() {
return collegeId;
}
public void setCollegeId(String
collegeId) {
this.collegeId = collegeId;
}
public int getTotalStudents() {
return totalStudents;
}
public void setTotalStudents(int
totalStudents) {
this.totalStudents =
totalStudents;
}
public class MyClass {
private static final String MY_COLLEGE =
"myCollege";
public static void main(String... args) {
ApplicationContext ctx = new
ClassPathXmlApplicationContext("springConfig.xml"
College col = (College) ctx.getBean(MY_COLLEGE);
System.out.println("College Id: " +
col.getCollegeId());
System.out.println("Total Students: " +
col.getTotalStudents());
}
}
<bean id="myCollege"
class="com.pushan.study.spring.beans.College"
>
<property name="collegeId"
value="123Abc"/>
<property name="totalStudents"
Pushan Bhattacharya

Constructor Injection
15
In the <bean>, Specify <constructor-arg>
private int
totalStudents;
public void College (int
tS, String cI) {
this.totalStudents = tS;
this.collegeId = cI;
}
public String
getCollegeId(){
return collegeId;
}
public int
getTotalStudents() {
return totalStudents;
public class MyClass {
private static final String MY_COLLEGE =
"myCollege";
public static void main(String... args) {
ClassPathXmlApplicationContext("springConfig.xml
");
College col = (College) ctx.getBean(MY_COLLEGE);
System.out.println("College Id: " +
col.getCollegeId());
System.out.println("Total Students: " +
col.getTotalStudents());
}
}
<bean id="myCollege"
class="com.pushan.study.spring.beans.College"
>
<constructor-arg type=“int” value=“500”/>
<constructor-arg type=“java.lang.String”
value=“123Abc”/>
Pushan Bhattacharya

Constructor Injection Illustrated
The ‘value’ attribute is mandatory and rest are
optional, e.g., ‘type’
Constructor Injection can automatically cast the
value to the desired ‘known’ type
By default the ‘type’ of the ‘value’ is ‘java.lang.String’
(if not specified explicitly)
Constructor injection does not interpret ordering of
the arguments specified
16
Pushan Bhattacharya

Constructor Injection Ambiguity 1
17
<bean id="myCollege" class="com.pushan.College">
<constructor-arg value=“500”/>
<constructor-arg value=“123Abc”/>
</bean>
private String collegeAdd;
public College (int totalStudents, String collegeId){
this.totalStudents = totalStudents;
}
public College (String collegeAdd, String collegeId){
this.collegeAdd = collegeAdd;
}
}
Which constructor will be called?
Pushan Bhattacharya

Constructor Injection Ambiguity 1 Solution
18
<constructor-arg value=“500” type=“int”/>
<constructor-arg value=“123Abc” type=“java.lang.String”/>
</bean>
The ‘type’ of the value is specified
}
public College (String collegeAdd, String collegeId){
this.collegeAdd = collegeAdd;
}
}
Pushan Bhattacharya

Constructor Injection Ambiguity 2
19
<constructor-arg value=“500” type=“int”/>
<constructor-arg value=“123Abc” type=“java.lang.String”/>
</bean>
}
public College (String collegeAdd, int totalStudents){
this. collegeAdd = collegeAdd;
}
}
Which constructor will be called?
Pushan Bhattacharya

Constructor Injection Ambiguity 2 Solution
20
The ‘index’ of the value is specified
<constructor-arg value=“500” type=“int” index=“0”/>
<constructor-arg value=“123Abc” type=“java.lang.String” index=“1”/>
</bean>
}
public College (String collegeAdd, int totalStudents){
this. collegeAdd = collegeAdd;
}
}
Pushan Bhattacharya

Bean Scope 1 – Object Type (Part I)
Pushan Bhattacharya
21
Bean Scope Description
singleton Single instance of bean in every getBean() call [Default]
prototype New instance of bean in every getBean() call
request Single instance of bean per HTTP request
session Single instance of bean per HTTP session
global-session Single instance of bean per global HTTP session
thread Single instance of bean per thread
custom Customized scope
Valid in the context of
web-aware
ApplicationContext
Added in Spring 3.0
We will look into
‘singleton’ and
‘prototype’ scopes
only

Bean Scope 1 – Object Type (Part II)
Mainly bean can be of two types, viz.,
1. Singleton (e.g., <bean scope=“singleton” … />)
2. Prototype (e.g., <bean scope=“prototype” … />)
A ‘singleton’ bean is created once in the Spring container.
This ‘singleton’ bean is given every time when referred. It is
garbage collected when the container shuts down.
A ‘prototype’ bean means a new object in every request. It is
garbage collected in the normal way, i.e., when there is no
reference for this object.
By default every bean is singleton if not specified explicitly.
22
Pushan Bhattacharya

Bean Scope 2 - Inheritance
23
<bean id="a" class=“A” >
<property name="msg1" value="Tiger runs" />
<property name="msg2" value="Tiger eats" />
</bean>
<bean id="b" class="B" parent="a">
<property name="msg1" value="Lion runs" />
<property name="msg3" value="Lion sleeps" />
</bean>
public class A {
private String msg1;
// getters and setters ...
}
public class B {
}
.
Write a testclass andcheck theoutput
<bean id="a" abstract=“true”>
<property name="msg1" value="Tiger runs" />
<property name="msg2" value="Tiger eats" />
</bean>
Pushan Bhattacharya

Bean Reference (wiring)
Through setter or constructor injection we can refer to
another bean which has its own separate definition.
24
public class Person{
// ...
}
public class Location{
private String city;
public Location (String c){
this.city = c;
}
// ...
}
public class A {
private String msg;
private Person owner;
private Location address;
}
<bean id="person"
class="Person" /> <bean id="location"
class="Location">
<constructor-arg
value="Kolkata"
type="java.lang.String" />
</bean>
<bean id="a" class="A">
<property name="msg" value="hello"/>
<property name="owner" ref="person"/>
<property name="address">
<ref bean="location" />
</property>
</bean>
Pushan Bhattacharya

Circular Dependency
25
Bean A Bean B
public class A {
private B b;
public A (B b) {
this.b = b;
}
}
public class B {
private A a;
public B (A a) {
this.a = a;
}
}
<bean id=“a” class=“A”>
<constructor-arg ref=“b” />
</bean>
<bean id=“b” class=“B”>
<constructor-arg ref=“a” />
</bean>
Pushan Bhattacharya

Inner Bean
Inner bean is also a bean reference.
A bean defined within another bean.
The inner bean is fully local to the outer bean.
The inner bean has prototype scope.
26
<bean id=“a” class=“A”>
<property name=“address”>
<bean class=“Location”>
<property name=“city” value=“Kolkata”/>
<property name=“zip” value=“700006”/>
</bean>
</property>
</bean>
public class A {
// getters and setters …
}
public class Location {
private String city, zip;
// getters and setters …
}
Pushan Bhattacharya

Injecting Collection
27
Tag Name
Inner Tag
Name
Java Collection
Type
Specification
<list> <value> java.util.List<E>
Allows duplicate
entries
<map> <entry> java.util.Map<K, V>
Key-Value pair of
any object type
<set> <value> java.util.Set<E>
Does not allow
duplicate entries
<props> <prop> java.util.Properties
Key-Value pair of
type ‘String’
Pushan Bhattacharya

So, lets inject some collection then …
28
<bean id=“animalCollection" class=“AnimalCollection">
<property name=“animalList">
<list>
<value>Tiger</value>
<value>Lion</value>
</list>
</property>
<property name=“animalSet">
<set>
<value>Lion</value>
<value>Lion</value>
</set>
</property>
<property name="animalMap">
<map>
<entry key="1" value=“Tiger"/>
<entry key="2" value=“Lion"/>
<entry key="3" value=“Tiger"/>
</map>
</property>
<property name="animalProp">
<props>
<prop key="one">Lion</prop>
<prop key="two">Tiger</prop>
<prop key="three">Lion</prop>
</props>
</property>
</bean>
public class AnimalCollection {
List<String> animalList;
Set<String> animalSet;
Map<String, String> animalMap;
Properties animalProp;
}
ClassPathXmlApplicationContext(“wildLife.xml”);
AnimalCollection aC =(AnimalCollection)
ctx.getBean("animalCollection");
System.out.println(“animalList :” + aC.getAnimalList());
System.out.println(“animalSet:” + aC.getAnimalSet());
System.out.println(“animalMap:” + aC.getAnimalMap());
System.out.println(“animalProp:” + aC.getAnimalProp());
}
}
animalList :[Tiger, Lion, Tiger]
animalSet :[Lion, Tiger]
animalMap :{1=Tiger, 2=Lion, 3=Tiger}
animalProp :{one=Lion, two=Tiger, three=Lion}
Bean
definition
for DI
Bean
Test class
Output
Pushan Bhattacharya

Constructor v/s Setter Injection
Setter injection gets preference over constructor
injection when both are specified
Constructor injection cannot partially initialize values
Circular dependency can be achieved by setter
injection
Security is lesser in setter injection as it can be
overridden
Constructor injection fully ensures dependency
injection but setter injection does not
Setter injection is more readable
29
Pushan Bhattacharya

Bean Properties
30
Tag Name Description Example
id Unique Id <bean id=“person” … />
name Unique Name <bean name=“lion” … />
class Fully qualified Java class name <bean class=“a.b.C” … />
scope Bean object type <bean scope=“singleton” … />
constructor-arg Constructor injection <constructor-arg value=“a” />
property Setter injection <property name=“a” … />
autowire Automatic Bean referencing <bean autowire=“byName” … />
lazy-init Create a bean lazily (at its first request) <bean lazy-init=“true” … />
init-method
A callback method just after bean
creation
<bean init-method=“log” … />
destroy-method A callback just before bean destruction <bean destroy-method=“log” … />
Pushan Bhattacharya

Bean Life Cycle Callbacks
31
org.springframework.beans.factory.InitializingBean
void afterPropertiesSet () throws Exception;
public class MyBean implements
InitializingBean {
public void afterPropertiesSet () {
// Initialization work
}
}
<bean id=“myBean"
class=“MyBean" init-method="init"/>
public class MyBean {
public void init () {
// Initialization work
}
}
org.springframework.beans.factory.DisposableBean
void destroy () throws Exception;
public class MyBean implements
DisposableBean {
public void destroy () {
// Destruction work
}
}
<bean id=“myBean"
class=“MyBean" destroy-method=“des"/>
public class MyBean {
public void des () {
// Destruction work
}
}
Pushan Bhattacharya

Beans Auto-Wiring
32
Mode Description Example
no No auto wiring of beans Default
byName Auto wire beans by property name <bean autowire=“byName” … />
byType Auto wire beans by property type <bean autowire=“byType” … />
constructor Auto wire beans by constructor <bean autowire=“constructor” … />
autodetect First try by constructor, then by type <bean autowire=“autodetect” … />
Spring container can auto wire beans
In this case, there is no need to specify <property/> and/or
<constructor-arg/> tags
It decreases the amount of xml configuration
Pushan Bhattacharya
Removed
in Spring
3.0

Auto wire by Name
33
public class Person {
// ...
}
public Location (String city) {
this.city = city;
}
// ...
}
public class A {
private String msg;
private Person person;
private Location location;
}
<bean id="person"
class="Person" />
<bean id="location"
class="Location">
<constructor-arg value="Kolkata"
</bean>
<bean id="a" class="A“ autowire=“byName”>
<property name="msg" value="hello" />
</bean>
Pushan Bhattacharya

Auto wire by Type
34
// ...
}
this.city = city;
}
// ...
}
public class A {
private String msg;
}
<bean id="person"
class="Person" />
<bean id="location"
class="Location">
</bean>
<bean id="a" class="A“ autowire=“byType”>
</bean>
Pushan Bhattacharya

<bean id=“person2" class=“Person”/>

Auto wire by Constructor
35
// ...
}
this.city = city;
}
// ...
}
public class A {
private String msg;
public A (String m, Person o, Location a){
…
}
}
<bean id="person"
class="Person" />
<bean id="location"
class="Location">
</bean>
<bean id="a" class="A“ autowire=“constructor”>
</bean>
Pushan Bhattacharya

Spring Auto-wiring Bottleneck
36
Disadvantage Description
Overriding beans configuration
If the bean configuration is specified explicitly then it overrides
the bean auto wiring configuration
Unable to wire primitive types
Auto wiring is applicable only for beans and not for simple
properties like primitives, String etc.
Auto wiring has confusing nature
Explicit wiring or manual wiring of beans is easier to
understand than auto wiring. It is preferred to use explicit
wiring if possible.
Partial wiring is not possible
Auto wiring will always try to wire all the beans through setter
or constructor. It cannot be used for partial wiring.
Spring auto wiring has certain disadvantages or limitations,
given below.
Pushan Bhattacharya

@Spring (annotation = start)
Evolved in Spring 2.0 (@Required).
Developed and became famous from Spring 2.5
“Old wine in new bottle” - an alternative of the xml
configuration for bean wiring
Not enabled by default (need explicit enabling)
XML overrides annotation for bean configuration
Sometimes gets treated as an anti-pattern since change
of annotation configuration needs compilation of code
IDE support
37
Pushan Bhattacharya

Enabling Spring Annotation
38
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd“ >
<context:annotation-config/>

</beans>
Pushan Bhattacharya

@Required
39
• Applicable to only setter methods. • Values by name.
• Strict checking.
public class Boy {
private String name;
private int age;
@Required
public void setName(String name){
this.name = name;
}
@Required
public void setAge(int age){
this.age = age;
}
// getters ...
}
<bean id=“boy” class=“Boy”>
<property name=“name” value=“Rony”/>
<property name=“age” value=“10”/>
</bean>
</bean>
Property 'age' is required for bean
'boy'
Pushan Bhattacharya

@Autowired
40
• Applicable to methods, fields and
constructors
• Wiring by type.
• ‘required’ attribute
public class Boy {
private int age;
}
</bean>
@Autowired
private Boy student;
public void setCollegeId(String cI){
}
// getters ...
}
<bean id=“college” class=“College”>
<property name=“collegeId” value=“1A”/>
</bean>
@Autowired(required=false)
// ...
}
No setter
needed for
autowiring
on field
‘student’
auto wiring
becomes
optional
Pushan Bhattacharya

@Qualifier
41
• Solution to @Autowired for type ambiguity
public class Boy {
private int age;
}
@Autowired
public void setCollegeId(String cI){
}
// getters ...
}
<bean id=“boy1” class=“Boy”>
<qualifier value=“rony”/>
</bean>
</bean>
<qualifier value=“tony”/>
<property name=“name” value=“Tony”/>
</bean>
@Qualifier(value=“tony”)
Qualifier
value
• If <qualifier/> is not configured, then searches
with bean id/name. But if specified, it will
always search with qualifier only.
Pushan Bhattacharya

@Resource, @PostConstruct, @PreDestroy
 @PostConstruct is an alternative of the init-method.
 @PreDestroy is an alternative of the destroy-method.
 @Resource(name=“<beanName>”) is used for auto wiring by name.
 @Resource can be applied in field, argument and methods.
 If no ‘name’ attribute is specified in @Resource, then the name is derived from
the field, setter method etc.
42
</bean>
</bean>
<property name=“name” value=“Tony”/>
</bean>
@Resource(name=“boy1”)
}
Pushan Bhattacharya

@Configuration & @Bean (Part I)
43
@Configuration
public class AnimalConfig{
@Bean
public Lion lion(){
return new Lion();
}
@Bean
public Tiger tiger(){
Tiger t = new Tiger();
t.doInit();
return t;
}
}
<bean id=“lion” class=“Lion” />
<bean id=“tiger” class=“Tiger”
init-method=“doInit” />
public class MainTest{
public static void main(String[] a){
AnnotationConfigApplicationContext(An
imalConfig.class);
Tiger t = aC.getBean(Tiger.class);
Lion l = aC.getBean(Lion.class);
// ...
}
}
Pushan Bhattacharya

@Configuration & @Bean (Part II)
44
@Configuration
public class LionConfig{
@Bean(destroyMethod=“clear”)
public Lion lion(){
return new Lion();
}
}
@Configuration
public class TigerConfig{
@Bean(initMethod=“doInit”)
return new Tiger();
}
}
<bean id=“lion” class=“Lion”
destroy-method=“clear” />
<bean id=“tiger” class=“Tiger”
init-method=“doInit” />
public class MainTest{
public static void main(String[] a){
AnnotationConfigApplicationContext();
aC.register(LionConfig.class,
TigerConfig.class);
aC.refresh();
// ...
}
}
Pushan Bhattacharya

@Configuration & @Bean (Part III)
45
Pushan Bhattacharya
@Configuration
@Bean
return new Tiger();
}
}
@Configuration
@Import(TigerConfig.class)
public class LionConfig{
@Bean
public Lion lion(){
return new Lion();
}
}
@Configuration
@Bean(name=“cat”)
@Scope(“prototype”)
return new Tiger();
}
}
<bean id=“cat”
class=“Tiger”
scope=“prototype” />

Try Yourself
Are ‘Dependency Injection’ and ‘Inversion of Control’
same? Give reason for the answer.
How to achieve circular dependency via both setter and
constructor injection?
How to declare the <property> of the bean together with
the bean definition in a single line?
Why does an inner bean have the default scope as
‘prototype’?
46
Pushan Bhattacharya

Helping Resources
Spring source documentation
(http://www.springsource.org/documentation)
Tutorials Point tutorial
(http://www.tutorialspoint.com/spring)
Mkyong tutorial
(http://www.mkyong.com/tutorials/spring-
tutorials)
DZone (http://java.dzone.com/articles/case-spring-
inner-beans)
47
Pushan Bhattacharya

Please Review and Comment
48
- Pushan
Bhattacharya
Pushan Bhattacharya

Spring Core

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (9)

Similar to Spring Core

Similar to Spring Core (20)

Recently uploaded

Recently uploaded (20)

Spring Core