Tech Talk Spring Framework

Spring Framework

Jens Rühmkorf Tech Talk, DLR Köln-Porz, 17. März 2009

Folie 2Spring Framework > J. Rühmkorf > 17. März 2009

Inhalt

Überblick und EinführungGrundlegende PrinzipienFunktionsweise eines DI-Frameworks am BeispielBeans & ihre Konfiguration in Spring

Überblick und Einführung


Spring FrameworkGeschichte

Begonnen 2002/2003 von Rod Johnson und Jürgen HöllerSpring 1.0: März 2004Spring 1.2.6: Jolt Productivity Award 2006 (Dr. Dobb‘s Journal)Spring 2.5: November 2007, aktuell 2.5.6

Grundlagen und Prinzipien erschienen in Rod Johnsons Buch „Expert One-on-One J2EE Design and Development“Auslöser für die Entwicklung: Hohe Komplexität von Enterprise JavaBeans (EJB bis v2.0)


Spring FrameworkAnforderungen an die Systemumgebung

Spring 2.5 läuft auf JavaSE 6 und JavaEE 5Für bestimmte Konfigurationsmechanismen JavaSE 5 nötig (alles alternativ auch ohne JavaSE 5 konfigurierbar)Abwärtskompatibel zu Java 1.4 bzw. Java EE 1.3Spring-IDE 2.1 unterstützt Eclipse 3.4 (Ganymede)


Übersicht des Spring Frameworkshttp://static.springframework.org/spring/docs/2.5.x/reference/

http://static.springframework.org/spring/docs/2.5.x/reference/


Spring Hello (1)Hello World!

public class HelloWorld {

private String message;

public void setMessage(String message) {

this.message = message;

}

public void hello() {

System.out.println("Hello! " + message);

}

}

class HelloWorld

HelloW orld

- message: String

+ hello() : void+ setMessage(String) : void

Main

+ main(String[]) : void


Spring Hello (2)Main

import org.springframework.context.ApplicationContext;import org.springframework.context.support.\

ClassPathXmlApplicationContext;

public class Main {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");

helloWorld.hello();}

}


Spring Hello (3)The Glue

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="[...]" xmlns:schemaLocation="[...]">

<bean id="helloWorld"class="de.dlr.spring101.hello.HelloWorld">

<property name="message" value="TechTalk Time!"/>

</bean>

</beans>


Spring Hello (4)Ausgabe17.03.2009 15:06:45 org.springframework.context.support.AbstractApplicationContext

prepareRefreshINFO: Refreshing

org.springframework.context.support.ClassPathXmlApplicationContext@ab50cd: display name[org.springframework.context.support.ClassPathXmlApplicationContext@ab50cd]; startup date [Tue Mar 17 15:06:45 CET 2009]; root of context hierarchy

17.03.2009 15:06:45 org.springframework.beans.factory.xml.XmlBeanDefinitionReaderloadBeanDefinitions

INFO: Loading XML bean definitions from class path resource [beans.xml]17.03.2009 15:06:46 org.springframework.context.support.AbstractApplicationContext

obtainFreshBeanFactoryINFO: Bean factory for application context

[org.springframework.context.support.ClassPathXmlApplicationContext@ab50cd]: org.springframework.beans.factory.support.DefaultListableBeanFactory@2ce908

17.03.2009 15:06:46 org.springframework.beans.factory.support.DefaultListableBeanFactorypreInstantiateSingletons

INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@2ce908: defining beans [helloWorld]; root of factory hierarchy

Hello! TechTalk Time!

Grundlegende Prinzipien

„Separation of Concerns“(Dijkstra, 1974)


Inversion of Control (1)Don‘t call us, we‘ll call you!

Hollywood-Prinzip: „Don‘t call us, we‘ll call you!“

(R.E. Sweet, SIGPLAN Notices, 1985)

IoC-Ansatz ist typisch für Frameworks:„Frameworks […] emphasize design reuse over code reuse […leading to] an inversion of control between the application and thesoftware on which it‘s based.“„When you use a toolkit […] you call the […] code you want to reuse.“„When you use a framework, you […] write the code it calls.“

(Gang of Four, Design Patterns, 1994)


Inversion of Control (2)Verwendung in Frameworks

Anwendungsentwickler:implementiert Callback-Methodendefiniert was zu tun ist

Framework:übernimmt die Verantwortungsteuert zeitliche Abfolge definiert wann etwas zu tun ist


Inversion of Control (3)Bekannte Beispiele

Interface ActionListener in SwingZu implementieren: Methode void actionPerformed(ActionEvent e)

Die Java-Runtime ruft die Methode auf bei Eintreten von Event

Interface Runnable bei ThreadsZu implementieren:Methode public void run()

Java-Runtime entscheidet, wann run() aufgerufen wird


Inversion of Control (4)Typische Einsatzgebiete

BenutzeroberflächenNetzwerkdiensteSystemdienste, die System- bzw. Hardwareereignisse überwachen


Inversion of Control (5)Konzeptuelle Unterscheidung

Dependency Lookup (aktiv)Komponente akquiriert aktiv Referenz „Dependency“ wird durch Lookup-Mechanismus nachgeschlagen

Dependency Injection (passiv)Komponente stellt Methoden zur Injektion bereitDer IoC-Container injiziert die „Dependency“ buchstäblichkurz: DI

BemerkungFowler benutzt DI synonym zu IoChttp://www.martinfowler.com/articles/injection.htmlHier wird DI als Spezialfall von IoC aufgefasst, vgl. http://www.picocontainer.org/inversion-of-control-history.html

http://www.martinfowler.com/articles/injection.html

http://www.picocontainer.org/inversion-of-control-history.html


Inversion of Control (5)Elementare Begrifflichkeiten

Komponente = Objekt bzw. Teil einer Software, dessen Ressourcen verwaltet wird von einem:Container = Teil einer Software, der Komponenten überwacht


Dependency Lookup (1)Dependency Pull

Bekannteste Form von IoCLese Abhängigkeiten von einer (zentralen) Registry


public void start(BundleContext context) {this.context = context;

}public String getCustomerName(long id) {

ServiceReference ref = context.getServiceReference(ILookupService.class.getName());

if(ref != null) {ILookupService lookup = (ILookupService)

context.getService(ref);if(lookup != null) {

Customer customer = lookup.findById(id);context.ungetService(ref);return customer.getName();

}}return null;

}

Dependency Lookup (2)Dependency Pull am Beispiel von OSGi

zur Kommunikation mit zentraler „Service Registry“

verwende Service

schlage Service nach


Dependency Lookup (3)Contextualized Dependency Lookup (CDL)

Keine zentrale RegistryLookup geschieht mittels eines ContainersContainer „enthält“ die Ressource / AbhängigkeitJede interessierte Komponente implementiert ein Interface

public interface ManagedComponent {

public void performLookup(Container container);

}


Dependency Lookup (4)Contextualized Dependency Lookup (CDL)

Abhängigkeit ändert sich im Container Container ruft component.performLookup(this) aufKomponente liest und verarbeitet Abhängigkeit selbst

public class ContextualizedDependencyLookup implementsManagedComponent {

private Dependency dep;

public void performLookup(Container container) {

this.dep = (Dependency) container.getDependency("myDependency");

}

}

Aufruf durch Container


Dependency Lookup (5)CDL = Interface Injection = Type 1 IoC

Alternative Bezeichungen für CDLInterface InjectionType 1 IoC

CDL hat NachteileJede Komponente muss ein Interface implementierenDas Interface wird vom Container festgelegtVerwendung der Komponente in anderem Kontext nicht möglich

Diese Art der Injizierung wird „intrusive“ genannt(intrusive meint hier eindringend, stark eingreifend)


Dependency Injection (1)Setter Injection (= Type 2 IoC)

Abhängigkeiten werden über Setter injiziertKomponente definiert set-Methoden mit Abhängigkeiten als Parameter

public class SetterInjection {


public void setMyDependency(Dependency dep) {

this.dep = dep;

}

}


Dependency Injection (2)Constructor Injection (= Type 3 IoC)

Abhängigkeiten werden über Konstruktor injiziertKomponente definiert Konstruktor(en) mit Abhängigkeiten als Parameter

public class ConstructorInjection {


public ConstructorInjection(Dependency dep) {

this.dep = dep;

}

}

Funktionsweise eines DI-Frameworks am Beispiel


Arbeitsweise des FrameworksBeispiel: ein Reportgenerator

Aufgabe: erzeuge Reports in HTML oder PDFSepariere Schnittstelle und Implementierung über ein InterfaceDienst wird über einen ReportService bereitgestellt

class Übersicht

HtmlReportGenerator

+ generate(String[][]) : void

PdfReportGenerator


«interface»ReportGenerator


ReportServ ice

+ generateAnnualReport(int) : void+ generateDailyReport(int, int, int) : void+ generateMonthlyReport(int, int) : void


Reportgenerator (1)Problem: Abhängig von Implementierung

Problem: Klasse ReportService besitzt interne Abhängigkeit auf Implementierungsklassen (HTML, PDF)

public class ReportService {

private ReportGenerator reportGenerator = newPdfReportGenerator();

public void generateAnnualReport(int year) {

String[][] statistics = null;

// Erzeuge Statistiken fuer das Jahr

reportGenerator.generate(statistics);

}

// Rest weggelassen

}


Reportgenerator (2)Schritt 1: Führe Container ein (UML)

Entkopplung, Schritt 1: Führe Container-Klasse ein. Diese Klasse hat (Quelltext-)Abhängigkeiten auf alle Komponenten, die sie überwacht

class Introduce Container

Containe r

+ getComponent(String) : Object

HtmlReportGenerator


PdfReportGenerator




ReportServ ice



public class Container {

public static Container instance;

private Map<String, Object> components;

public Container() {

components = new HashMap<String, Object>();

instance = this;

components.put("reportGenerator", new PdfReportGenerator());

components.put("reportService", new ReportService());

}

public Object getComponent(String id) {

return components.get(id);

}

}

Reportgenerator (3)Schritt 1: Führe Container ein (cont‘d)


Reportgenerator (4)Schritt 2: Verwende Service-Locator Pattern (UML)

Entkopplung, Schritt 2: Verwende Service-Locator Pattern. Liegt OSGizugrunde, Bestandteil von Suns Core J2EE Pattern Catalog.

class Serv iceLocator Pattern

Containe r

+ Container()+ getComponent(String) : Object

HtmlReportGenerator


PdfReportGenerator




ReportServ ice


Serv iceLocator

+ getReportGenerator() : ReportGenerator


public class ServiceLocator {

private static Container container = Container.instance;

public static ReportGenerator getReportGenerator() {

return (ReportGenerator) container.getComponent("reportGenerator");

}

}

public class ReportService {

private ReportGenerator reportGenerator = ServiceLocator.getReportGenerator();

// Rest weggelassen

}

Reportgenerator (5)Schritt 2: Verwende Service-Locator Pattern (cont‘d)


Reportgenerator (6)Schritt 3: Realisiere DI via Reflection (UML)

Entkopplung, Schritt 3: Verwende Konfigurationsdatei um Abhängigkeiten von außen zu definieren. Instanziiere JavaBeans via Reflection.

class DI v ia Reflection

Containe r

+ Container()+ getComponent(String) : Object- processEntry(String, String) : void

HtmlReportGenerator


PdfReportGenerator




ReportServ ice



public class Container { // Ausschnitt!

private void processEntry(String key, String value) throws Exception {

String[] parts = key.split("\\.");

if (parts.length == 1) { // erzeuge Komponente

Object component = Class.forName(value).newInstance();

components.put(parts[0], component);

} else { // injiziere Dependency

Object component = components.get(parts[0]);

Object reference = components.get(value);

PropertyUtils.setProperty(component, parts[1], reference);

}

}

}

Reportgenerator (7)Schritt 3: Realisiere DI via Reflection (cont‘d)


# Definiere neue Komponente "reportGenerator"

reportGenerator=de.dlr.spring101.report.step03.\HtmlReportGenerator

# Definiere neue Komponente "reportService"

reportService=de.dlr.spring101.report.step03.ReportService

# Injiziere die Komponente "reportGenerator"

# in das Attribut "reportGenerator"

reportService.reportGenerator=reportGenerator

Reportgenerator (8)Schritt 3: Realisiere DI via Reflection (cont‘d)

Konfigurationsdatei: configuration.propertiesVerwendet BeanUtils aus Apache Commons


Reportgenerator (9)Schritt 4: Konfiguration mit Spring Beans (UML)

Entkopplung, Schritt 4: Verwende Spring Beans

class DI thru Spring

HtmlReportGenerator


PdfReportGenerator




ReportServ ice



import org.springframework.context.ApplicationContext;

import org.springframework.context.support.\ClassPathXmlApplicationContext;

public class Main {

public static void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

ReportService reportService = (ReportService) context.getBean("reportService");

reportService.generateAnnualReport(2008);

}

}

Reportgenerator (10)Schritt 4: Konfiguration mit Spring Beans (cont‘d)


Reportgenerator (10)Schritt 4: Konfiguration mit Spring Beans (cont‘d)

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="defaultGenerator"class="de.dlr.spring101.report.step04.PdfReportGenerator"/>

<bean id="reportService"class="de.dlr.spring101.report.step04.ReportService">

<property name="reportGenerator">

<ref local="defaultGenerator"/>

</property>

</bean>

</beans>

Beans & ihre Konfiguration in Spring


Begrifflichkeiten Spring und J2EEPOJO vs. JavaBean vs. (Spring) Bean

POJO (= Plain Old Java Object). Ein POJO ist ein „simples“ Java Objekt, das:

1. Keine vorgegebenen Klassen erweitert, 2. keine vorgegebenen Interfaces implementiert, 3. keine vorgegebenen Annotations enthält.

JavaBean (J2EE Kontext): Ein JavaBean ist ein POJO das:1. Öffentlichen Standardkonstruktor besitzt,2. serialisierbar ist,3. öffentliche Getter/Setter-Methoden besitzt.

Spring Beans:Komponenten heißen in Spring Beans.Beans == POJOs.


Bean == POJO mit eindeutiger IDUnterscheidung zweier Typen anhand des scope(= Gültigkeitsbereich)

singletonEine Instanz wird angelegt & referenziert bei jedem Zugriff

prototype (nicht-singleton)neue Bean wird jedes Mal erzeugtanalog zu new KlassenName()

Weiter Typen bei Web- und Portal-Applikationen (ab Spring 2.x):request, session, globalSessionSpring legt Beans i.d.R. so spät wie möglich an

Komponenten in SpringSpring Beans


Bean Definition (1)Bekanntmachen von Komponenten

Eine Bean Definition macht Spring Komponenten bekanntSchlüsseleigenschaften:

class (required): Java Klassenname (fully qualified, d.h. mit Package)id: eindeutiger Bezeichner für dieses BeanKonfigurationsparameter (scope, init-method etc.)constructor-arg: An den Konstruktor zu übergebende Argumenteproperty: An die Setter bei Erzeugung (durch Spring) zu übergebende ArgumenteReferenzen: andere (durch Spring verwaltete) Beans können in Konstruktor oder Setter-Methode referenziert werden

Bean typischerweise in einer XML-Datei definiert


<bean id="exampleBean" class="org.example.ExampleBean">

<property name="beanOne">

<ref bean="anotherBean" />

</property>

<property name="beanTwo">

<ref bean="yetAnotherBean" />

</property>

<property name="integerProperty">

<value>1</value>

</property>

</bean>

Bean Definition (2)Beispiel einer XML-Konfiguration


Bean-Definition (3)Zum Beispiel gehörige Klassendefinition

public class ExampleBean {private AnotherBean beanOne;private YetAnotherBean beanTwo;private int i;

public void setBeanOne(AnotherBean beanOne) {this.beanOne = beanOne;

}public void setBeanTwo(YetAnotherBean beanTwo) {

this.beanTwo = beanTwo;}public void setIntegerProperty(int i) {

this.i = i;}

}


Konfiguration des Spring IoC-ContainersBeanFactory vs. Application Context

Konfiguration des IoC-Containers via XMLProperty-DateienDirekter Zugriff auf die Spring-API

BeanFactory und ApplicationContext sind zwei abstrakte InterfacesApplicationContext erweitert BeanFactory (und weitere Interfaces)Ist für die meisten Anwendungsfälle zu bevorzugen


Initialisierung des Spring IoC-ContainersLokalisieren, Erzeugen und Verwalten von Beans

Spring verwendet eine BeanFactory (!= FactoryBean) um Beanszu lokalisieren, zu erzeugen und zu verwaltenTypischerweise verwendet man eine XML-BeanFactory:ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");


Erzeugung von Beans (1)Ablauf

Ausgehend von Definitionen legt Spring Abhängigkeits-Digraphen anTopologische Sortierung des Graphen (falls kreisfrei) bestimmt Reihenfolge

Typischerweise werden Beans erzeugt bei Laden der DefinitionÄndere dies durch Attribut lazy-init:<bean class="className" lazy-init="true"/>

Graph darf Kreise enthalten, ABER:Initialisierungsreihenfolge dann abhängig von der Auflösung der Kreise, nicht mehr transparent für den NutzerAuch zirkuläre Referenzen möglich, sofern die Beans per Constructor und nicht durch eigene Factories initialisert werden (sog. FactoryBean)Vgl. http://jira.springframework.org/browse/SPR-689

http://jira.springframework.org/browse/SPR-689


Erzeugung von Beans (2)Zeitpunkt der Initialisierung

Scope singleton – werden bei Start des Containers angelegtLazy via lazy-init – initialisiere erst, wenn die abhängige Beanangelegt wird„Very lazy“ – wird erst bei Zugriff auf Bean (via Container) im Quelltext angelegt. Dazu FactoryBean:LazyBean bean = (LazyBean) context.getBean("myBean");


Injizierung von BeansAblauf

Ausgangslage ist wieder der AbhängigkeitsgraphBeans werden durch Konstructoren oder Nutzer-spezifizierte Factory-Methoden erzeugtAbhängigkeiten, die nicht bereits durch den Konstruktor angegebenwurde, werden via Setter-Methoden injiziertAuch direktes injizieren via Annotation möglich(dann kein Setter oder Constructor notwendig)Beispiel:@Resource(name = "someOtherBean")

private OtherBean otherBean;


Setzen von Bean-AttributenBean Properties

Häufigste Methode von DI: Injizierung via PropertiesInjiziert werden kann eine andere Bean, ein Wert (primitiver Datentyp, String), eine Collection<bean id="exampleBean"class="de.dlr.spring101.example.ExampleBean"><property name="anotherBean"><ref bean="someOtherBean" />

</property></bean>

Kurzschreibweise:<bean id="exampleBean"class="de.dlr.spring101.example.ExampleBean"><property name="anotherBean" ref="someOtherBean" />

</bean>


JavaBean AntipatternÜberprüfen von gesetzten Attributen via Spring

Beim Arbeiten mit JavaBeans wird ein „leeres“ Objekt initialisiert, das über Setter „befüllt“ wirdZustand ist erst valide nach Aufruf aller oder mindestens einiger SetterÜberprüfung per Konfiguration:none*, simple, objects, allAnnotation der Setter-Methoden mit @Resource: (einschalten via <context:annotation-config/>)@Requiredpublic void setMessage(String message) {this.message = message;

}@Requiredpublic void setValue(int value) {this.value = value;

}


Lifecycle-Management von Beansvia Interface

Implementiere InitializingBean oder OtherBean:public class LifeCycle implements InitializingBean,

DisposableBean {@Overridepublic void afterPropertiesSet() throws Exception {openResource();

}

@Overridepublic void destroy() throws Exception {closeResource();

}}


Lifecycle-Management von Beansvia Konfiguration oder Annotation

Konfiguration:<bean id="lifeCycleBean"class="de.dlr.spring101.scratchbook.LifeCycle"init-method="openResource"destroy-method="closeResource"><property name="message" value="TechTalk Time!" />

</bean>Annotation:@PreDestroyprivate void closeResource() {System.out.println("close resource");

}@PostConstructprivate void openResource() {System.out.println("open resource");

}

Zusammenfassung & Ressourcen


Spring Core (DI)Alternativen

GoogleGuice: http://code.google.com/p/google-guice/unterstützt DI via Annotationsviel „Autowiring“klein & schnellkeine Unterstützung von Lifecycles (dazu: GuiceyFruit)

PicoContainer: http://www.picocontainer.org/unterstützt DI von Typ 2+3 sowie unterstützt DI mittels AnnotationsUnterstützung von Lifecyclesklein: ~260K, etabliert

Weitere Frameworks: Java-Source.nethttp://java-source.net/open-source/containers

http://code.google.com/p/google-guice/

http://www.picocontainer.org/

http://java-source.net/open-source/containers


Spring FrameworkPros and Cons

Für Dependency Injection andere starke Frameworks verfügbarSpring bietet viele Module für J2EE-Kontext („Plumbing“)Neue Konfigurationskonzepte seit Spring 2.5:

Annotations (Java SE 5) Autowiring: finde passende Komponenten „automagisch“

Spring-Konfiguration üblicherweise sehr explizit (autowiring möglich)Macht das Nachvollziehen (auch für nicht-Experten) einfacher


LiteraturWebressourcen & Artikel

[Tarr et al. 1999]Peri Tarr, Harold Ossher, William Harrison, and Stanley M. Sutton, Jr.N Degrees of Separation: Multi-dimensional Separation of ConcernsIntl. Conf. on Software Engineering (ICSE-11, 1999)http://dx.doi.org/10.1145/302405.302457

[Foote, and Yoder 1997]Brian Foote, and Joseph YoderBig Ball of Mud4th Conf. on Patterns Languages of Programs (PLoP ’97)http://www.laputan.org/mud/

[Fowler 2004] Martin FowlerInversion of Control Containers and the Dependency Injection Patternmartinfowler.com, Januar 2004http://www.martinfowler.com/articles/injection.html

[Weiskotten 2006] Jeremy WeiskottenDependency Injection & Testable ObjectsDr. Dobbs Journal, April 2006http://www.ddj.com/185300375

http://dx.doi.org/10.1145/302405.302457

http://www.laputan.org/mud/

http://www.martinfowler.com/articles/injection.html

http://www.ddj.com/185300375


LiteraturBücher zum Thema

[Gamma et al. 1994] Erich Gamma et al. (Gang of Four)Design PatternsAddison Wesley, November 1994

[Mak 2008] Gary MakSpring RecipesApress, Juni 2008

Vielen Dank.

Technology

Tech Talk Spring Framework