spring ioc

Spring frameworkMotto: 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.

1Sunday 13 May 2012

https://github.com/dagi/spring-training

https://github.com/dagi/spring-training

http://creativecommons.org/licenses/by-sa/3.0/

http://creativecommons.org/licenses/by-sa/3.0/

IoC containerZáklady

2Sunday 13 May 2012

Proč vzniknul SpringSpring koncepce a organizaceCo spring nabízí a k čemu jej můžete použít

Agenda

• IoC obecně

• Chrakteristika

• XML

• Anotace

• Pokročilé techniky

• Čeho se vyvarovat

3Sunday 13 May 2012

Cvičení

4Sunday 13 May 2012

• 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

5Sunday 13 May 2012

- 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 }}

6Sunday 13 May 2012

Poznej svého nepřítelepublic class ReservationServiceImpl implements ReservationService{ private BookStoreDao bookStoreDao;

public ReservationServiceImpl() { init(); }

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


1 cesta ve zdrojovém kódu

2 konkrétní implementace

7Sunday 13 May 2012

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

Generalizace problému

• Kde najít

• Jak získat

• Jak zkonfigurovat

• Jak spojit dohromady

8Sunday 13 May 2012

- komponenty

Inversion of Control

9Sunday 13 May 2012

10Sunday 13 May 2012

Martin Fowler - Continuous Integration, Refactoring, Inversion of Control

Obrácená kontrola (řízení)

„…vychází z principu přenesení odpovědnosti za nalezení, konfiguraci a spojení komponent dohromady na

někoho třetího“11Sunday 13 May 2012

Dependency injection


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

Service locator


- komponenty si explicitne zadaji service locator

• Preferujte DI

• Žádné těsné vazby

• Transparentní

• No singleton hell

• Service locator

• body napojení

• Servlet/Controller aplikace

Service Locator vs. DI


Zrefaktorujme Váš kód


POJO

public class ReservationServiceImpl implements ReservationService{ private BookStoreDao bookStoreDao;

public ReservationServiceImpl() { }



Metadata@Componentpublic class ReservationServiceImpl implements ReservationService{ @Autowired private BookStoreDao bookStoreDao;

public ReservationServiceImpl() { }

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

@Componentpublic class FileSystemBookStoreDao implements BookStoreDao{

private File rootPath;

@Autowired public FileSystemBookStoreDao(File rootPath) { //kod vynechan }

}

<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>


http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

Kontejner


Test


Benefity

• 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


• Bean == managovaný objekt

• POJO

• žádný marker interface

• final třídy

• param. konstruktory

Neinvazivnost


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í27Sunday 13 May 2012

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ódu28Sunday 13 May 2012

- 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


Definice beany

• Jméno

• atribut id

• Typ

• atribut class

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


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

Reference(závislosti)

• Elm. property/constructor-arg

• Hodnota (value)

• Reference (name)

<bean id="" class=""> <property name="" ref=""/> <property name="" value="" /> <constructor-arg ref="" value=""></constructor-arg></bean>


- 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

• Prefixujte 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"/>


http://www.springframework.org/schema/p

http://www.springframework.org/schema/p

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

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

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


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.

import org.springframework.beans.factory.DisposableBean;import org.springframework.beans.factory.InitializingBean;

public class Bean implements InitializingBean, DisposableBean{ public Bean() {} public void setDepedencies(String foo) {} public void afterPropertiesSet() throws Exception {}

public void myInit() {} public void destroy() throws Exception {} public void myDestroy(){}}

<bean class="Bean" init-method="myInit" destroy-method="myDestroy"> <property name="depedencies" value="foo" /></bean>

1

2

3

4

5

6


- rozdilny lifecycle pro singleton a prototype

Poznámka na konto XML

• Občas ukecané Ale stále funkční ;-)

• Nejsilnější možnosti konfigurace

• DI (factory object|method delegation)

• Spring container customization

• Dědičnost

• Inner beany42Sunday 13 May 2012

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 konstruktor3.) FileSystemBookStoreDao dostane cestu pro čtení a ukládání knih settrem4.) 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é knihy6.) MemoryBookStoreDao bude mít metodu destroy, která vyčistí mapu7.) Zaveďte jednu knihu jako inner beanu do java.util.Map<Long, Book>, ktera se pouzije pro konfiguraci beany MemoryBookStoreDao8.) Do tridy Book pridejte factory metodou newBook()9.) Upravte definici inner beany Book, aby se vytvarela factory metodou10.) 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

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() { }}

Jak otestovat


Anotace


Definice 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

@Componentpublic 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

• Stále potřebujeme XML

• Aktivace anotací

• Kde hledat anotované třídy

<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>


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 definovat init metodu anotacemi

Poznámka na konto anotací

• + Méně ukecané • Definici beany

• Závislosti

• Transakce

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

• - magické díky autowiringu


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



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

Definice

• XML

• atribut scope

• Anotace

• @Scope(value="...")


1.) Upravte definici beany Book, aby mela scope prototype2.) Upravte definici beany java.util.Map<Long, Book>, aby pod dvema ruznymi klici referencovala beanu Book3.) Pripravte test, ktery overi, ze List skutecne obsahuje ruzne instance beany Book4.) Zmente scope prototype na singleton5.) Overte testem, ze List obsahuje jednu a tu samou instanci objektu Book


Java Config


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

public class MyService {

private final DaoInterface daoInterface;

public MyService(DaoInterface daoInterface) { super(); this.daoInterface = daoInterface; }}

<beans ...> <bean class="cz.sweb.pichlik.springioc.javaconfig.ConfigClass" />

<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean></beans>

@Configurationpublic class ConfigClass {

@Autowired private DataSource dataSource;

@Bean() public MyService configureMyservice(){ return new MyService(configureJdbcDao()); }

@Bean() public JdbcDao configureJdbcDao() { return new JdbcDao(dataSource); }

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

definice beany

zavedení configu

dependency injection


autowiring funguje viz DataSource beana

Jak to funguje• JavaConfig třídy jsou

dynamicky rozšířeny

• CGLIB

• volání configureJdbcDao jde přes proxy IoC kontejneru

• scopes

• postprocessing

• autowiring

@Configurationpublic class ConfigClass {

@Autowired private DataSource dataSource;

@Bean() public MyService configureMyservice(){ return new MyService(configureJdbcDao()); }

@Bean() public JdbcDao configureJdbcDao() { return new JdbcDao(dataSource); }

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


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 JavaConfig 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 MemoryBookStoreDao3.) Beanu reprezentujici java.util.Map<Long, Book> si nechte nainjectovat do bean JavaConfig pres setter



spring ioc

Documents

book book

kod vynechan

lze mnit v

zrefaktorujme v kdsunday

new filetmpdatabookstoredao

pro obe strany kontraktu

typy di constructor

legacy kod