Navigace

Spring

První verze Springu je od Roda Johnsona a vyšla zároveň s knihou Expert One-on-One J2EE Design and Development, která popisuje základní filosofii Springu.

Pozor! Spring má jedinou implementaci a tak se obecně moc nerozlišují pojmy model a framework. Protože se všude mluví o Springu, jako o frameworku, můžeme říct že "Spring model = Spring framework". Mějte však na paměti, že framework je implementace modelu.

Spring Framework

Spring se skládá z tříd a metod, které jsou rozděleny do 20ti modulů. Tyto moduly se slučují do částí Data Access/Integration, Web, AOP (Aspect Oriented Programming), Instrumentation, Core Container a Test, jak je vidět na obrázku níže

Stručně o jednotlivých modulech:

Core Container: jádro frameworku, které pak používají ostatní moduly. Obsahuje IoC a Dependency Injection, Application context a další.
Data Access/Integration: moduly poskytující přístup k datům z DB, XML a dalších.
Web: moduly poskytující dodatečné služby při vývoji webových aplikací.
AOP a Instrumentation: podpora aspektově orientovaného programování, včetně implementace Alliance-compliant aspect-oriented programming.
Test: podpora JUnit ? testů.

Pro více informací k jednotlivým modulům se můžete podívat na dokumentaci Springu.

Základ Springu

Základem je konfigurační Springový soubor. Jde o klasický XML soubor, který však používá jmenný prostor Springu. Hlavička takového XML vypadá následovně:

 
<?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-2.0.xsd" />
</beans>

Obsahem takového souboru jsou beany, které vznikají při vytvoření kontextu. Kontext vytvoříme následovně:

ApplicationContext ctx = new ClassPathXmlApplicationContext("cz/zcu/kiv/project/beanDefinition.xml");

Pak už můžeme od kontextu požadovat potřebné beany.

Beans

Bean je ve světě Springu to samé, co objekt. Beany jsou objekty popsané v konfiguračním souboru Springu jako elementy.

 
<beans>
  <bean id="foo" class="x.y.Foo"/>
</beans>

Dependency Injection a Inversion of Control

Spring podporuje DI dvěma hlavními způsoby – DI konstruktoru a DI setteru.

Mějme třídu:

 
package x.y;

public class Foo {
    private Baz baz;

    public Foo(Bar bar) {
        // ...
    }

    public void setBaz(Baz baz) {
      this.baz=baz;
    }
}

DI pak nastavíme ve Springovém XML konfiguračním souboru:

 
<beans>
    <bean id="foo" class="x.y.Foo">
        <constructor-arg ref="bar"/>
        <property name="baz" ref="baz"/>
    </bean>

    <bean id="bar" class="x.y.Bar"/>
    <bean id="baz" class="x.y.Baz"/>

</beans>

Spring pak při vytváření volá konstruktor s parametry, které jsou v <construtor-arg>. Následně zavolá metody setName(hodnota), které jsou v <property>, přičemž setter se musí jmenovat dle hodnoty name a jako hodnota se vkládá buď přímo pomocí atributu value, nebo jako reference na objekt pomocí atributu ref.

Komponenta a rozhraní komponenty

Ve Springu je komponenta abstraktní a pro začátečníka je rozdíl mezi objektem, beanou a komponentou prakticky nulový. Odlišnost je pouze v pohledu na věc (beanu) a její použití.

Ukažme si tedy jak vypadá komponenta ve Springu:

Mějme třídu x.y.Foo, která implementuje rozhraní x.y.IFoo?. Tato třída nechť je komponentou a implementované rozhraní je rozhraním této komponenty.
V následující části XML konfiguračního souboru si ukážeme vytvoření komponenty x.y.Foo a její následné získání další komponentou x.z.Fuu.

<beans>
    <bean id="foo" class="x.y.Foo"/>

    <bean id="fuu" class="x.z.Fuu">
        <constructor-arg type="x.y.IFoo">
            <ref bean="foo"/>
        </constructor-arg>
    </bean>
</beans>

Jak je vidět v ukázce výše, tak jsme komponentu injektovali do konstruktoru. Samozřejmě ji můžeme i získat z kontextu někde v těle komponenty x.z.Fuu.

Poznámka: Při psaní tohoto úvodu jsem narazil v dokumentaci Springu na několik odkazů na komponentu – notace @component ve zdrojovém kódu nad jménem třídy. Či v XML konfiguračním souboru jako <component>. Nepodařilo se mi však najít žádné uchopitelné informace, které by mi pomohly zjistit k čemu tyto notace slouží.

Shrnutí

Řekli jsme si, že se u Springu nerozlišují důsledně pojmy model a framework. My však víme, že model je specifikace a popis. Framework je implementací dané specifikace.

Komponentou je pak ve Springu beana, která implementuje alespoň jedno rozhraní. Co komponenta poskytuje, pak mohou být tato implementovaná rozhraní, a co komponenta potřebuje, mohou být atributy konstruktoru. Zde je velice důležité slovíčko mohou, protože stejně jako v OSGi i zde mohu získat komponenty z kontextu za běhu programu. Ovšem narozdíl od OSGi zde nemám žádné metainformace, které by mi řekly, co budu za běhu potřebovat.

Praktická část

V těchto návodech pracuji s SpringSource Tool Suite, které je trochu odlišné od Eclipsu. Většina věcí je však stejná.

TutoriálSpring pro vytvoření nového projektu pro práci se Springem.

HelloWorldSpring využívající Springového kontextu. Výsledná implementace: Attach:HelloWorldSpring

Příklad MessagePrinterSpring pak dokumentuje jen technologicky specifické problémy. Výsledná implementace: Attach:MessagePrinterSpring

Příklad ParkovisteSpring pak dokumentuje jen technologicky specifické problémy. Výsledná implementace: Attach:ParkovisteSpring

UvodDoKomponent: Spring