Spring ioc

Spring framework
Motto: Musíte rozbít vejce když chcete udělat omeletu

Spring framework training materials by Roman Pichlík is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.

Sunday 13 May 2012 1

IoC container
Základy


Proč vzniknul Spring
Spring koncepce a organizace
Co spring nabízí a k čemu jej můžete použít

Agenda
• IoC obecně
• Chrakteristika
• XML
• Anotace
• Pokročilé techniky
• Čeho se vyvarovat

Cvičení


• Příklad Rezervace knih

• Mějme rozhraní ReservationService, které slouží k
rezervaci knih

• Mějme rozhraní BookStoreDao, které slouží k načítání
informací o knihách

• Implementa ReservationService používá BookStoreDao
pro čtení a ukládání knih z disku

• Existuje implementace FileSystemBookStoreDao

• Naimplementujte tyto třídy, aby prošel
ReservationServiceTest


- predpripraveny projekt sandbox
- implementace BookService, knihy mohou byt v souboru viz trida Helper

Typický kód

public class ReservationServiceImpl implements ReservationService{
private BookStoreDao bookStoreDao;

public ReservationServiceImpl() {
init();
}

private void init() {
File dataDirectory = new File("/tmp/data");
bookStoreDao = new FileSystemBookStoreDao(dataDirectory);
}

public boolean reserveBook(Long bookId) {
Book book = bookStoreDao.getBook(bookId);
//kod pro rezervaci vynechan
}
}


Poznej svého nepřítele


}
init();
1 cesta ve zdrojovém kódu
private void init() {
File dataDirectory = new File("/tmp/data");
bookStoreDao = new FileSystemBookStoreDao(dataDirectory);
}

2 konkrétní implementace
}
}


- konkretni implementace BookStore (WS, Database)
- nutno vedet jakym zpusobem nainicializovat
- cesta na tvrdo

Generalizace problému

• Kde najít

• Jak získat

• Jak zkonﬁgurovat

• Jak spojit
dohromady


- komponenty

Inversion of Control



Martin Fowler - Continuous Integration, Refactoring, Inversion of Control

Obrácená
kontrola
(řízení)
„…vychází z principu přenesení
odpovědnosti za nalezení, konﬁguraci
a spojení komponent dohromady na
někoho třetího“

Dependency injection


- komponenty nevi (nemusi pokud nechteji) o tom, ze je nekdo managuje
- HOLLYWOOD princip

Service locator


- komponenty si explicitne zadaji service locator

Service Locator vs. DI
• Preferujte DI
• Žádné těsné vazby
• Transparentní
• No singleton hell
• Service locator
• body napojení
• Servlet/Controller aplikace

Zrefaktorujme Váš kód


POJO


}

}
}


Metadata
@Component @Component
public class ReservationServiceImpl implements public class FileSystemBookStoreDao implements BookStoreDao{
ReservationService{
@Autowired private File rootPath;
@Autowired
public ReservationServiceImpl() { public FileSystemBookStoreDao(File rootPath) {
} //kod vynechan
}
Book book = bookStoreDao.getBook(bookId); }
return false;
}
}
<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/>
<context:component-scan base-package="cz.sweb.pichlik.impl"/>
<bean class="java.io.File">
<constructor-arg value="/mnt/data" />
</bean>
</beans>

Kontejner


Test


Beneﬁty

• Indirekce == volné vazby
• Znovupoužitelnost
• Lepší testovatelnost
• Extensibilita


- komponenty na sobe nezavisi primo, vetsi volnost pro obe strany kontraktu, nezavisle
zmeny
- komponenta v ruznem kontextu, testovani v izolaci
- dvě možné impementace

IoC kontejner


• Neinvazivnost

• Typy DI

• Metadata

• Reference mezi komponentami

• Řízení vzniku komponent

• Životní cyklus komponent

• Jednoduchá testovatelnost


základní charakteristika Spring IoC kontejneru

Programy před zavedením IoC


Programy po zavedení IoC


Neinvazivnost

• Bean == managovaný objekt
• POJO
• žádný marker interface
• ﬁnal třídy
• param. konstruktory


Typy DI
• Constructor injection
• + Bezpečnější, Přehlednější

• - Nepovinné závislosti

• - Cyklické závislosti

• Setter injection
• + Nepovinné, velké množství závislosti

• - Chybějící závislosti

• Field injection
• + jednoduchý zápis

• - netrasparentní

Pro ruzné situace se hodi různé typy DI

Metadata pro popis
komponent
• Anotace
• + Jednoduchý zápis

• - Zapečené v kódu

• XML
• + Lze měnit v deploy time

• - Ukecané /

• Java kód
• + Flexibilní, refactor friendly

• - Zapečené v kódu

- v aplikace obvykle zastoupeny oba dva
typy

Reference mezi komponentami

• Typem
• Bezpečnější (teoreticky)
• Symbolickým jménem
• Více instancí stejného typu
• Variabilnější skládání


Řízení vzniku komponent
• Uvnitř kontextu
• Delegace
• Factory, Factory method
• Mimo kontext
• Deserializace komponenty
• Web či ORM framework


Legacy kod, 3rd party knihovny

XML


Deﬁnice beany

<bean id="" class=""></bean>

• Jméno
• atribut id
• Typ
• atribut class


- jeden typ Nkrát
- jméno automaticky generovane
- id hlidane parserem

Reference(závislosti)
<bean id="" class="">
<property name="" ref=""/>
<property name="" value="" />
<constructor-arg ref="" value=""></constructor-arg>
</bean>

• Elm. property/constructor-arg
• Hodnota (value)
• Reference (name)


- v pripade value -Property Editor
- property/constructor-arg mozno kombinovat dohromady
- ridi kontejner

java util collections

<bean>
<property name="map">
<map>
<entry key="" value=""></entry>
<entry key-ref="" value-ref=""></entry>
</map>
</property>
<property name="list">
<list>
<value></value>
<ref bean=""/>
</list>
</property>
</bean>


- array, set

Good practice
• Jméno beany obsahuje jméno classy

• FooHooBar třída == fooHooBar beana

• Preﬁxujte jmena bean jejich typem či určením

• dao.FooHooBar, integration.FooHooBar

• V případě refaktoru názvu používejte alias

• Buďte defenzivní

• Inner beans


Méně ukecané XML

xmlns:p="http://www.springframework.org/schema/p"

<bean
id="myBean"
class="cz.sweb.MyBean"
p:dependencyA-ref="dependencyA"/>


Delegace vytváření instancí

• Factory
• Beana, která slouží k vyrábění
jiných bean
• Factory method
• Beana se statickou metodou,
která vyrábí instance sebe sama


Factory

<bean id="factory" class="Factory" />

<bean id="beanB"
factory-bean="factory"
factory-method="newInstance" />

public class Factory {
public MyBeanB newInstance() {
return new MyBeanB();
}
}

Factory method
<bean
id="myBeanA"
class="MyBeanA"
factory-method="newInstance"/>

public class MyBeanA {

public static MyBeanA newInstance() {
return new MyBeanA();
}
}

- factory method musi byt staticka

Init, Destroy, Lazy atd.
<bean class="Bean" init-method="myInit" destroy-method="myDestroy">
<property name="depedencies" value="foo" />
</bean>
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Bean implements InitializingBean, DisposableBean{

public Bean() {} 1

public void setDepedencies(String foo) {} 2

public void afterPropertiesSet() throws Exception {} 3

public void myInit() {} 4

public void destroy() throws Exception {} 5

public void myDestroy(){} 6

}

- rozdilny lifecycle pro singleton a prototype

Poznámka na konto XML
• Občas ukecané Ale stále funkční ;-)
• Nejsilnější možnosti konﬁgurace
• DI (factory object|method
delegation)
• Spring container customization
• Dědičnost
• Inner beany

ukecanost - DI, transaction demarcation

Praktické cvičení


1.) Implementaci ReservationService a FileSystemBookStoreDao zaveďte jako
beany v XML.
2.) ReservationService dostane BookStoreDao implementaci
(FileSystemBookStoreDao) skrze konstruktor
3.) FileSystemBookStoreDao dostane cestu pro čtení a ukládání knih settrem
4.) Připravte in-memory implementaci BookStoreDao (MemoryBookStoreDao),
která bude číst/zapisovat do paměti resp. bude naimplementovaná nad
java.util.Map<Long, Book>. Mapa bude obsahovat jako klíč Long a jako
hodnotu Book. Mapu bude mozne nastavit do MemoryBookStoreDao settrem.
Pripravte test, ktery overi, ze metody getBook a saveBook.
5.) MemoryBookStoreDao bude mít init metodu, která vypíše předpřipravené
knihy
6.) MemoryBookStoreDao bude mít metodu destroy, která vyčistí mapu
7.) Zaveďte jednu knihu jako inner beanu do java.util.Map<Long, Book>,
ktera se pouzije pro konﬁguraci beany MemoryBookStoreDao
8.) Do tridy Book pridejte factory metodou newBook()
9.) Upravte deﬁnici inner beany Book, aby se vytvarela factory metodou
10.) Priprave Factory, ktera bude vytvaret java.util.Map<Long, Book>
nahradte touto faktory puvodni beanu. Zachovejte vytvareni Book beany pres
jeji factory metodu newBook().

V kazdem kroku validujte vas postup testem ReservationServiceTest, ktery musi
prochazet.

- pokracovat v sandboxu, odkomentovat dependence

Jak otestovat
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath*:META-INF/<context-file-name>.xml"})
public class MyTest {

@Autowired
private MyBean bean;

@Test
public void testXXX() {

}
}


Anotace


Deﬁnice beany
• Základní anotace na třídě
• @Component
• @Controller
• @Service
• @Repository
• nepovinný atribut value (id)


- component (genericka), controller (web), service (business logika), repository (DAO)
- Repository, automaticky preklad vyjimek pokud pracujeme primo JDBC, Session atd.

Reference(závislosti)

• Základní anotace
• @Autowired
• field, metoda, konstruktor
• @Qualifier
• jemný výběr např. jménem


- narozdil od XML a settrum moznost definovat na libovolne metode
- @Autowired definuje required attribute pro volitelne zavislosti
- @Autowired nelze pouzit pro injectovani generickych typu, @Resourc anotace musi byt
pouzita namisto ni

@Component
public class Bean {

@Autowired(required=false)
private OtherBean something;

private final Hoo hoo;

@Autowired
public Bean(@Qualifier(value="hoo") Hoo hoo) {
this.hoo = hoo;
}

@Autowired
public void setX(String x) {

}
}


Component scanning
<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/>
<context:component-scan base-package="cz.sweb.pichlik"/>
</beans>

• Stále potřebujeme XML
• Aktivace anotací
• Kde hledat anotované třídy


Autowiring

• Skládání objektů podle jejich
závislostí
• @Autowired
• Řízený typem (volitelně jménem)


- autowiring funguje rovnez v XML

Co je potřeba vzít v potaz


- autowiring funguje typem by default

Předcházíme problémům

• Buďte defenzivní
• @Autowired + @Qualifier
• Použití specifičtějšího typu


- pouziti specifickeho typu muze selhat ve chvili proxy modu napr. anotace

JSR 250 & JSR 330

• JSR 250
• @Resource , @PostConstruct,
@PreDestroy
• JSR 330
• @Inject...


JSR 250 - jediny zpusob jak deﬁnovat init metodu anotacemi

Poznámka na konto anotací
• + Méně ukecané
• Deﬁnici beany

• Závislosti

• Transakce

• - pouze jedna instance od každé
třídy
• - magické díky autowiringu


1.) Beany ReservationService a MemoryBookStoreDao zavedte pomoci
anotaci
2.) Pouijte anotace pro volani init a destroy metody na
MemoryBookStoreDao
3.) java.util.Map<Long, Book> zavedte jmenem a pomoci anotace
Resource (Autowired nebude fungovat)
4.) Upravte deﬁnici ReservationService, aby se vzdy pouzila
implementace MemoryBookStoreDao

V kazdem kroku validujte vas postup testem ReservationServiceTest,
ktery musi prochazet.


Pokročilá témata


neznamená méně důležitá

Životní cyklus komponent

• Jedna instance komponenty
• Nová instance komponenty
• Konverzační instance komponenty


Singleton


Prototype


Request, Session

Proxy Singleton


- zmena scope je vzdy problem (singleton vs. scope)
- http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-factory-
method-injection

Deﬁnice

• XML
• atribut scope
• Anotace
• @Scope(value="...")


1.) Upravte deﬁnici beany Book, aby mela scope prototype
2.) Upravte deﬁnici beany java.util.Map<Long, Book>, aby pod dvema
ruznymi klici referencovala beanu Book
3.) Pripravte test, ktery overi, ze List skutecne obsahuje ruzne instance
beany Book
4.) Zmente scope prototype na singleton
5.) Overte testem, ze List obsahuje jednu a tu samou instanci objektu Book


Java Conﬁg


Java Based Config
• Mix anotací a Java kódu
• Alternativa k XML
• @Configuration
• @Bean
• name, init, destroy, autowire
• @Import


- lze kombinovat XML, Anotace i Java Based config
- vhodné pro případy kdy v XML máme pouze deployment specifické beany a zbytek chceme
mít v kódu
- k init, destroy lze používat jako alternativu JSR-250 anotace

<beans ...>
<bean class="cz.sweb.pichlik.springioc.javaconfig.ConfigClass" /> zavedení conﬁgu
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="url" value="${jdbc.url}"/> @Configuration
<property name="username" value="${jdbc.username}"/> public class ConfigClass {
<property name="password" value="${jdbc.password}"/>
</bean>
</beans> @Autowired
private DataSource dataSource;

deﬁnice beany @Bean()
public MyService configureMyservice(){
return new MyService(configureJdbcDao());
}
dependency
injection
public class MyService {
@Bean()
public JdbcDao configureJdbcDao() {
private final DaoInterface daoInterface;
return new JdbcDao(dataSource);
}
public MyService(DaoInterface daoInterface) {
super();
@Bean()
this.daoInterface = daoInterface;
public HibernateDao configureHiberDao() {
}
return new HibernateDao(dataSource);
}
}
}


autowiring funguje viz DataSource beana

Jak to funguje
@Configuration
• JavaConﬁg třídy jsou public class ConfigClass {
dynamicky rozšířeny
@Autowired
private DataSource dataSource;

• CGLIB @Bean()
public MyService configureMyservice(){
return new MyService(configureJdbcDao());
}
• volání
@Bean()
configureJdbcDao jde public JdbcDao configureJdbcDao() {
přes proxy IoC kontejneru return new JdbcDao(dataSource);
}

@Bean()
• scopes public HibernateDao configureHiberDao() {
return new HibernateDao(dataSource);
}
}
• postprocessing

• autowiring


Zavedení JavaConfig tříd

• Třídy anotované @Configuration
• Tři způsoby zavedení JavaConfigu
• Klasická beana v XML
• Beana na scanované classpath
• Programově
• new AnnotationConfigApplicationContext(ConfigClass.class)


1.) Pripravte JavaConﬁg beanu pomoci anotaci, ktery bude zavadet
beanu MemoryBookStoreDao. Z tridy MemoryBookStoreDao
odstrante vsechny anotace.
2.) Zajistete deklarativne volani (nevolejte primo) init a destroy metody
na MemoryBookStoreDao
3.) Beanu reprezentujici java.util.Map<Long, Book> si nechte
nainjectovat do bean JavaConﬁg pres setter

V kazdem kroku validujte vas postup testem ReservationServiceTest,
ktery musi prochazet.


Spring ioc

Recomendados

Recomendados

Más contenido relacionado

Más de Roman Pichlík

Más de Roman Pichlík (8)

Spring ioc