[@

@]

[@

@]

 [@

@]

 [=

 [=

[@

@]

package x.y;

public class Foo {

    private Baz baz;

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

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

}

Container = new CompositionContainer?(

                new AggregateCatalog?(
                    new AssemblyCatalog?( Assembly.GetExecutingAssembly?() ) ,
                    new AssemblyCatalog?( Assembly.LoadFrom?( @"MEFVisualizer?.Exe" ) )
                    ) );

            Container.Compose( batch );

            var meftoDgml = new MEFToDGML?( Container){ IsNamespaceGrouping? = true };   // The Visualizer

           meftoDgml.WriteToDGMLFile?();   // Write to DGML file

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.

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.

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ží.

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

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

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 Foo a její následné získání další komponentou Fuu.

=code [=

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

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

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ží.

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

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

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

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

• AOP a Instrumentation: podpora aspektově orientovaného programování, včetně implementace Alliance-compliant aspect-oriented programming.

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

Základem je konfigurační Springový soubor. Jde o klasický XML soubor, který však používá jmenný prostor Springu.

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

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.

• Data Access/Integration: moduly poskytující přístup k datům z DB, XML a dalších.

Základem je konfigurační Springový soubor. Jde o klasický XML soubor, který však používá namespacy Springu.

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

V následujícím XML konfiguračním útržku si ukážeme vytvoření takové komponenty a její následné získání další komponentou.

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ží.

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

Spring

Spring Framework

Komponenta a rozhranní komponenty

Ve Springu je komponenta abstraktní a pro začátečníka je hranice mezi objektem, beanou a komponentou prakticky nulová. Rozdíl 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 rozhranní x.y.IFoo?. Tato třída nechť je komponentou a implementovaný interface je interfacem této komponenty.
V následujícím xml konfiguračním útržku si ukážeme vytvoření takové komponenty a její následné získání další komponentou.

<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ží.

Komponentou je pak ve Springu beana, která implementuje alespoň jedno rozhranní. Co komponenta poskytuje pak mohou být tyto implementované rozhranní 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.

Shrnutí

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

Pojem

Obsahem takového souboru jsou beany, které se vytvářejí 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 contextu chtít beany, které potřebujeme.

Základ Springu

Základem je konfigurační springový soubor. Jde o klasický xml soubor, který však používá namespacy 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é se vytvářejí při spuštění aplikace.

Beans

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

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

Spring je J2EE? lightweight kontejner. Jeho hlavním účelem je ulehčení vývoje enterprise aplikací.

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 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á kontruktor s parametry, které jsou v <construtor-arg> a 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".

Dependency Injection a Inversion of Control

• 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 and Instrumentation: podpora aspektově orientovaného programování, včetně implementace Alliance-compliant aspect-oriented programming.
• Test: podpora JUnit? testů.

Stručně o jednotlivých modulech:

• Core Container: obsahuje základy frameworku

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, budu v této části definovat "Spring model = Spring framework". Mějte však na paměti, že framework je samotná implementace modelu.

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

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

spring-overview.png

Spring

Praktická část

Spring Framework

Spring is an open source framework created to adress the complexity of enterprise application development. One of the main advantages of the Spring framework is its layered architecture, which allows you to be selective about which of its parts you use. The Spring framework consists of seven well-defined modules. The Spring modules are built on top of the core container, which defines how beans are created, configured, and managed, as shown in Figure 1.

http://www.bauml.cz/content/spring_framework.gif

Each of the modules that comprise the Spring framework can stand on its own or be implemented jointly with one or more of the others. The functionality of each component is as follows:

• The core container: The core container provides the essential functionality of the Spring framework. A primary component of the core container is the BeanFactory?, an implementation of the Factory pattern. The BeanFactory? applies the Inversion of Control (IOC) pattern to separate an application's configuration and dependency specification from the actual application code.
• Spring context: The Spring context is a configuration file that provides context information to the Spring framework. The Spring context includes enterprise services such as JNDI, EJB, e-mail, internalization, validation, and scheduling functionality.
• Spring AOP: The Spring AOP module integrates aspect-oriented programming functionality directly into the Spring framework, through its configuration management feature.
• Spring DAO: The Spring JDBC DAO abstraction layer offers a meaningful exception hierarchy for managing the exception handling and error messages thrown by different database vendors.
• Spring ORM: The Spring framework plugs into several ORM frameworks to provide its Object Relational tool, including JDO, Hibernate, and iBatis SQL Maps. All of these comply to Spring's generic transaction and DAO exception hierarchies.
• Spring Web module: The Web context module builds on top of the application context module, providing contexts for Web-based applications. As a result, the Spring framework supports integration with Jakarta Struts. The Web module also eases the tasks of handling multi-part requests and binding request parameters to domain objects.
• Spring MVC framework: The Model-View-Controller (MVC) framework is a full-featured MVC implementation for building Web applications.

Spring framework functionality can be used in any J2EE? server and most of it also is adaptable to non-managed environments. A central focus of Spring is to allow for reusable business and data-access objects that are not tied to specific J2EE? services. Such objects can be reused across J2EE? environments (Web or EJB), standalone applications, test environments, and so on, without any hassle.

Spring (IoC) Beans

One of most important feature of Spring core container is IoC container.

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

HelloWorldSpring využívající springového contextu. Výsledná implementace: Attach:HelloSpring Δ

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

HelloWorldSpring využívající springového contextu. Výsledná implementace: Attach:HelloSpring.zip Δ

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

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

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

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

Spring framework

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 contextu. Výsledná implementace: Soubor:HelloSpring.zip?

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

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