Spring 3.0 dependancy injection

Dependency Injection

rgupta.trainer@gmail.com

Dependency Injection
• Hello World DI
• Using setter, Constructor Injection
• Injecting Objects
• Inner Beans, Aliases
• Initializing Collections
• Understanding Bean Scopes
• Bean Autowiring
• Using ApplicationContextAware
• Bean Definition Inheritance
• Lifecycle Callbacks
• Method injections
• Lookup method injection
• …
• …


Introduction to DI


interface

Design as per interface


Car depends on Wheel


Most important :glue it all with XML


DI ?
• DI is how objects or bean using Spring are brought together by container
to accomplished the task

• It is AKA of IoC

• In most application and object is responsible for its own dependencies or
associated objects and this is mostly achieved using JNDI

• In DI approach we allow container to manages dependencies of object
creation and association

Hollywood ; don’t call me I will call you



How Spring Work?


• Any object outside
container get bean by
providing ref

• We know object requiring
bean contact to container ie
Application context that
refer SpringXML and create
a Spring managed bean and
that can be referred by
requesting object
outside/inside the
container


Spring Hello world example


Setter injection….Ex


Injecting Objects


Inner Beans
• Remove the definition of
Point bean and put into
triangle bean

• Remove the ref tag and put
definition inside.

• No performance adv.

• whenever a bean is used for
only one particular property,
it’s advise to declare it as an
inner bean

Aliases

• alias giving name
to same bean
• Use alias tag
• Now bean can be
referred by new
name


Spring bean scopes

• In Spring, bean scope is used to decide which
type of bean instance should be return from
Spring container back to the caller.

• In most cases, you may only deal with the
Spring’s core scope – singleton and prototype,
and the default scope is singleton.


Bean Scopes
Scope Description
Singleton (Default)Only one single instance will be
created

Prototype Creates any number of instances from a
single bean configuration

Request Scope of the bean instance will be limited to
the Request life cycle

Session Limited to session

Global session Limited to global session- Portlet context.

<bean name =“student” class =“Student” scope =“prototype”/>

Singleton scope
ctx.getBean(“student”)

Spring
Container Single student
instance


Output in case of
default bean scope


Prototype scope
ctx.getBean(“student”)

Spring
Container
Multiple Beans


Spring Collection
• What if member variable is collection
major collection types are supported in
Spring

List – <list/>
Set – <set/>
Map – <map/>
Properties – <props/>


Injecting list..


Auto Wiring

• Skip some of the configuration that we have
to do by intelligent guessing what ref is
• AKA shortcut.
• Type of auto wiring
– byName
– byType (for only one composite object)
– constructor


<?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="tringle" class="com.ex3.code.Tringle" autowire="byName">

</bean>

<bean id="pointA" class="com.ex3.code.Point">
<property name="x" value="0"/>
<property name="y" value="0"/>
</bean>

<bean id="pointB" class="com.ex3.code.Point">
</bean>

<bean id="pointC" class="com.ex3.code.Point">
<property name="x" value="-20"/>
</bean>

<alias name="tringle" alias="my-tringle"/>

</beans>


Aware interfaces..

• BeanName Aware interface
• Want to know the name of bean configured
• ApplicationContextAware
• Getting Application context
• We need to implements ApplicationContextAware

Container itself call setter related to aware interface
before creation of any bean.


Bean Definition Inheritance
• Lets say we have 100 bean definition in xml ,
lets we have common definition in each bean
definition aka template


<?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="parenttringle" class="com.ex3.code.Tringle">
<property name="pointA" ref="firstPoint"></property>
</bean>

<bean id="tringle" class="com.ex3.code.Tringle" parent="parenttringle">
<property name="pointC" ref="secPoint"></property>
<property name="pointC" ref="thirdPoint"></property>
</bean>

<bean id="firstPoint" class="com.ex3.code.Point">
</bean>

<bean id="secPoint" class="com.ex3.code.Point">
</bean>

<bean id="thirdPoint" class="com.ex3.code.Point">
<property name="x" value="-20"/>
</bean>

<alias name="tringle" alias="my-tringle"/>

</beans>


Lifecycle Callbacks
• Spring provide us call-back method for life cycle
of bean
• for initialization of bean
• for cleanup of bean

EX: Shut down hook
• closing app context for SE applications
• use class AbstractAppicationContext, when main finished

AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("springWithAutoWiring.xml");
ctx.registerShutdownHook();


cofig init and destroyed method
• Choice I
• implements InitializingBean,DisposableBean
• Choice II
• Dont want to bind to spring interface interfaces......

<bean id="tringle" class="com.ex3.code.Tringle" autowire="byName" init-method="myInit" destroy-
method="myDestroy">

What happens if both are there?
first spring then my method is called.


public class Tringle implements
public void setPointC(Point pointC) {
InitializingBean,DisposableBean{ this.pointC = pointC;
}
private Point pointA; public void draw() {
private Point pointB; System.out.println(pointA);
System.out.println(pointB);
private Point pointC; System.out.println(pointC);
}
public Point getPointA() {
@Override
return pointA; public void afterPropertiesSet() throws Exception {
// TODO Auto-generated method stub
} System.out.println("called after init of bean");
public void setPointA(Point pointA) { }
@Override
this.pointA = pointA; public void destroy() throws Exception {
System.out.println("called after destruction of bean");
} }

public Point getPointB() {
}
return pointB; }
}
public void setPointB(Point pointB) {
this.pointB = pointB;
}
public Point getPointC() {
return pointC;
}


Method Injection – Method Replace
class MobileStore{
public String buyMobile(){
return "Bought a Mobile Phone";
}}

class MobileStoreReplacer implements MethodReplacer{
public Object reimplement(Object obj, Method method, Object[] args)
throws Throwable{
return “Bought an iPhone”;

}
}

<bean id =“mobileStore” class =“MobileStore”>
<replace-method name =“buyMobile” replacer =“mobileStoreReplacer”/>
</bean>

<bean id =“mobileStoreReplacer” class =“MobileStoreReplacer”/>

Lookup Method Injection
public abstract class BookStore { public interface Book {
public String bookTitle();
public abstract Book orderBook(); }
}
Managed by Spring
public class StoryBook implements Book{ public class ProgrammingBook
public String bookTitle() { implements Book{
return "HarryPotter“; } public String bookTitle() {
} return "spring programming“; }
}

• The ability of the container to override methods on
container managed beans, to return the lookup
result for another named bean in the container.


Thanks !!!


Spring 3.0 dependancy injection

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Spring 3.0 dependancy injection

Ähnlich wie Spring 3.0 dependancy injection (20)

Mehr von Rajiv Gupta

Mehr von Rajiv Gupta (18)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Spring 3.0 dependancy injection