Spring 2.0

Thorsten Kamann ● thorsten.kamann@itemis.de 1

Inhalt
Einführung

Konfiguration

AOP

Transaktionen

Spring Web MVC

Sonstiges

Zusammenfassung


Einführung: Was ist Spring?


Einführung: Was ist Spring?

IoC Ansammlung
(Dependency
von API‘s
Injection)

Programmiermodell


Einführung: Spring Komponenten
Spring Core
The IoC Container

AOP Web
JEE
Spring AOP Spring Web MVC
JMX
AspectJ Integration Struts
JMS
WebWork
JCA
Tapestry
Remoting
DAO ORM JSF
EJB‘s
Spring JDBC Hibernate PDF
Email
Transaction JPA Jasper Reports
Management TopLink Excel
JDO Spring Portlet MVC


Einführung: Features
Leichtgewichtiger Container
• Zentralisierte und automatisierte Konfiguration
und Verdrahtung der Anwendungsobjekte
• Nicht invasiv
• Fügt lose gekoppelte Komponenten (POJO's) zu
komplexen Systemen zusammen
• Skalierbar
• Verbessert die Testbarkeit der Komponenten,
indem sie zuerst unabhängig von der
Serverinfrastruktur getestet werden können


Abstraktionsschicht für Transaktions-
Management

• Erweiterbares Transaktions-Management
• Deklarative Konfiguration der Transaktionen,
ohne tief in das entsprechende Framework
einzusteigen
• Im Gegensatz zu reinem JTA oder EJB CMP ist
dieses Transaktions-Management nicht auf
J2EE-Umgebungen beschränkt


Abstraktionsschicht für reines JDBC

• Reduziert den Code für auf JDBC-basierte
Anwendungen
• Vereinfacht die Fehlerbehandlung
• Bietet eine aussagekräftige Exception-
Hierarchie (herstellerunabhängig)
• Exceptions basieren auf der DAO-Exception-
Hierarchie


Integration von populären O/R-Mappern

• Unterstützung von Hibernate, Toplink, JDO
und iBATIS SQL Maps
• Vereinfacht die Entwicklung mit diesen O/R-
Mappern
• Unterstützung von Transaktionen
• Unterstützung des DAO-Patterns



AOP Funktionalität
• Basiert auf AspectJ
• Vollständig integriert in das Spring
Konfigurations-Management
• Transaktions-Management basiert auf AOP
• Jedes Objekt in Spring kann mittels AOP
gemanaged werden


Flexibles MVC-Webapplication
Framework
• Benutzt die Spring-Core Funktionalitäten
• Sehr konfigurierbar durch verschiedene
Strategie-Interfaces
• Kombinierbar mit den verschiedensten
Viewtechnologien:
• JSP, Velocity, Tiles, iText, POI


Konfiguration


Konfiguration: XML-Schema

Konfiguration per XML-Schema

• Spring Konfigurationen basieren auf XML-
Schema
• Durch XML-Schema ist eine direktere
Konfiguration möglich
• Dadurch kürzere und eindeutigere
Konfigurationen


Konfiguration: XML-Schema
Alt:
• <bean id=“bean1quot; class=“a.b.Beanquot;>
<property name=“prop1“ value=“value1quot;/>
</bean>

Neu:
• <bean id=„bean1“ class=„a.b.Bean“
p.prop1=„value1“/>


Konfiguration: Modularisierung
Konfiguration besteht aus verschiedenen
Schemata
• Beans - Konfiguration von Spring-Beans
• Utils - Utilities wie Maps, Lists, Static Fields
• JEE - J2EE Konfiguration, wie EJB, JNDI
• Lang - Scriptsprachen (Groovy, JRuby, BeanShell)
• Tx - Transaktionen
• Aop - Aspekte
• Tool - 3rd Party Erweiterungen


Konfiguration: Erweiterungen
Erweiterbare Konfiguration

• 3rd Party Erweiterungen
• Domänen-spezifische Konfigurationsdialekte
• Tools-Schema unterstützt die Erstellung von
Erweiterungen
• Einfaches Deployment mittels JAR


Konfiguration: XML
• <beans>
<bean id=„marge“ class=„Person“ p:name=„marge“>
<property name=„husband“>
<bean class=„Person“ p:name=„homer“ p:age=„45“>
<property name=„props“>
<props>
<prop key=„overweight“>true</prop>
<prop key=„height“>1.8m</prop>
</props>
</property>
</bean>
</property>
<property name=„children“><list>…</list></property>
</bean>
<bean id=„bart“ …/>
<bean id=„lisa“ …/>
</beans>


Konfiguration: Java
• @Configuration
public class MyConfig {
@Bean
public Person marge() {
Person marge = new Person();
Person husband = new Person();
marge.setName(„marge“);
marge.setHusband(husband);
marge.addCildren(bart);
return marge;
}

@Bean
public Person bart () {
Person bart = new Person();
return bart;
}
}


Konfiguration: GroovyBuilder
• bb.beans {
marge(Person.class) {
name = quot;marge„
husband = { Person p ->
name = quot;homer„
age = 45
props = [overweight:true,
height:quot;1.8mquot;] }
children = [bart, lisa]
}
bart(Person.class) {}
lisa(Person.class) {}
}


Konfiguration: Bean Scopes
5 Bean Scopes
• Singleton
• Prototype
• *Request (Web)
• *Session (Web)
• *Global Session (Portlets)


AOP


AOP: Allgemein
SpringAOP vs AspectJ
• SpringAOP ist einfacher und kann mit
einfachen Beans arbeiten
• SpringAOP unterstützt zur Zeit nur Methoden-
basierte Join Points

• AspectJ wird vollständig unterstützt und kann
auch auf nicht-SpringBeans angewandt werden


AOP: Konfiguration
Konfigurationsoptionen
• Annotations (@AspectJ) oder XML-basiert
• Aktivierung von @AspectJ mit <aop:aspectj-
autoproxy/>
• Pointcut-Definition mit AspectJ Expression-
Sprache
• AOP-Autoproxies (default) oder CGLIB-
Proxies


AOP: Beispiel (Java-Code)
public class SimpleProfiler {
public Object profile(ProceedingJoinPoint call)
throws Throwable {
StopWatch clock = new StopWatch(
quot;Profiling for 'quot; + call.toShortString() + quot;'quot;);
try {
clock.start(call.toShortString());
return call.proceed();
} finally {
clock.stop();
System.out.println(clock.prettyPrint());
}
}
}


AOP: Beispiel (Konfig. mit Schema)
<bean id=quot;profiler“ class=„d.it.s2.test.aop.SimpleProfilerquot; />

<aop:config>
<aop:aspect ref=quot;profilerquot;>
<aop:pointcut id=quot;daoCreatequot;
expression=quot;execution(* d.i.s.dao.*.create*(..))quot; />
<aop:around pointcut-ref=quot;daoCreatequot; method=quot;profilequot; />
</aop:aspect>
<aop:aspect ref=quot;profilerquot;>
<aop:pointcut id=quot;daoSavequot;
expression=quot;execution(* d.i.s2.dao.*.save*(..))quot; />
<aop:around pointcut-ref=quot;daoSavequot; method=quot;profilequot; />
</aop:aspect>
</aop:config>


AOP: Beispiel (Annotations)
@Aspect
public class SimpleProfilerAnnotated {

@Pointcut
execution(* de.itemis.spring2.dao..create*(..))
public void create(){};

@Around(„create()“)
public Object profile(ProceedingJoinPoint call)
throws Throwable {
[…]
}
}


AOP: Beispiel (Konfig. mit @AspectJ)

<bean id=quot;profiler“
class=„d.i.s2.test.aop.SimpleProfilerAnnotatedquot; />
<aop:aspectj-autoproxy/>


Transaktionen


Transaktionen:Übersicht

In: Create Transaction
Out: Commit/Rollback

AOP- Transaction- Custom
Caller Target
Proxy Advisor Advisor(s)

Vor oder nach Business-
Proxy dem Transaction- Logik
anstatt des Ziels Advisor


Transaktionen:Konfiguration
Konfiguration
• XML-Schema (tx-Namensraum)
• Annotations
• Programmatisch
• Intern wird AOP verwendet
• Durch Verwendung von AspectJ Ausweitung
auf nicht-Spring-Objekte möglich


Transaktionen: Konfiguration (XML-Schema)

<bean id=„txManager“/>
<tx:advice id=„txAdvice“ transaction-manager=„txManager“>
<tx:attributes>
<tx:method name=„get*“ read-only=„true“/>
<tx:method name=„*“/>
</tx:attributes>
</tx:advice>

<aop:config>
<aop:pointcut id=„pid“ expression=„…“/>
<aop:advisor advice-ref=„txAdvice“ pointcut-ref=„pid“/>
</aop:config>


Transaktionen: Konfiguration (Annotations)

@Transactional(readOnly = true)
public class DefaultFooService implements FooService {

public Foo getFoo(String fooName) {
}

@Transactional(readOnly = false,
propagation = Propagation.REQUIRES_NEW)
public void updateFoo(Foo foo) {
}
}


Transaktionen: Konfiguration (Annotations)

<tx:annotation-driven transaction-manager=quot;txManagerquot;/>

<bean id=quot;txManagerquot;
class=„o.s.jdbc.datasource.DataSourceTransactionManager„
p:dataSource-ref=„dataSource“/>


Spring Web MVC


Spring Web MVC: Übersicht
Features
• Trennung von Rollen
(Controller, Validator, Command Object, Form
Object, Model,…)
• Convention over Configuration
• Unterstützung sämtlicher Spring Features
• Eigene TagLibrary
• Unterstützung einer großen Anzahl von Web-
Frameworks
(JSP, JSF, Struts, Tapestry, WebWork, Velocity)


Spring Web MVC
Convention over Configuration

• URL  Controller
/welcome/*  WelcomeController
• Automatische Übergabe von Modellelementen
an die View: de.itemis.modell.User ist als
user in der View bekannt
• URL View
/welcome.jsp 
/WEB-INF/jsps/welcome.jsp


Spring Web MVC
Form TagLibrary
• Seit Spring 2.0
• Ermöglicht den direkten Zugriff auf Controller
und Command-Objekte
• Vereinfacht die JSP‘s
<form:form commandName=quot;userquot;>
<form:input path=„firstName“/>
</form:form>


Sonstiges


Sonstiges: JPA
JPA
• Abstraktionsschicht für JPA
• JPATemplate und JPADaoSupport arbeiten
gegen die „Plain JPA-API“
• Einfache Arbeit mit verschiedenen JPA-
Implementierungen


Sonstiges: JDBC
JDBC
• NamedParameterJdbcTemplate
String sql =
„SELECT * FROM C WHERE c.fn = :firstName“

anstatt

String sql =
„SELECT * FROM C WHERE c.fn = ?“

• SimpleJdbcTemplate
• Autoboxing
• varargs


Sonstiges: Dynamische Sprachen
Dynamische Sprachen
• Groovy, JRuby, BeanShell
• Eigener Namespace für jede Sprache
• lang:groovy, lang:jruby, lang:bsh
• Autom. Reloading
• refresh-check-delay=quot;TIME_IN_MSECquot;
• Inline-Scripts
• Grails ist eine Spring Web MVC Anwendung


Sonstiges: JMX
JMX

• Notification Mechanismus
• NotificationListener
• NotificationPublisher
• Kontrolle des Verhaltens bei der
Registrierung im MbeanServer
• REGISTRATION_FAIL_ON_EXISTING
• REGISTRATION_IGNORE_EXISTING
• REGISTRATION_REPLACE_EXISTING


Sonstiges: Task Scheduler
Task Scheduler
• Abstraktionsschicht für das Konzept der
Executors (Thread Pools in Java 5)
• Verfügbar auch für Java 1.3 und Java 1.4
• Synchrone, asynchrone, zeitgesteuerte Tasks
• Konfiguration über Beandefinitionen
<bean id=quot;tEquot;
class=quot;o.s.ThreadPoolTaskExecutor“/>
<bean ...>
<constructor-arg ref=quot;tEquot; />
</bean>


Sonstiges: Java5-Support
Java5-Support
• Annotations
• AOP, Transaktionen, Konfiguration
• Verlagert die Konfiguration von XML nach
Java Vor- oder Nachteil?
• Beispiele:
<tx:annotation-driven
transaction-manager=quot;txManagerquot;/>
<aop:aspectj-autoproxy/>
• Generics


Sonstiges: Portlet MVC Framework
Portlet MVC Framework
• Basiert auf den gleichen Konzepten wie das
Spring Web MVC
• JSR-168 The Java Portlet Specification
• Unterstützt Spring Webflow


Spring im
Entwicklungsprozess


Agiles und iteratives Vorgehen
Agil
• Agiles Vorgehen wird im Sinne von Flexibilität
unterstützt
• Hohe Modularisierung möglich
• Flexible Anpassung von Konfigurationen

Iterativ
• Die Konfiguration wächst mit der Software
• Zusätzliche Features brauchen erst konfiguriert
werden, wenn die Implementierung existiert


Modellgetriebene Entwicklung
MDSD

• Konfigurationen sind einfach zu generieren
• Annotations verringern die Menge an
generierten Codezeilen
• Modularisierung ermöglicht manuelle
Anpassung des Generats
• Erzeugung von Testhelpern und –stubs
beschleunigen die Erstellung von Tests


Unit-Test
Software-Tests

• Dependency Injection fördert die Testbarkeit
von Systemen
• Austauschbare Konfiguration ermöglicht
angepasste Konfiguration für Tests
• Integrationstests werden unterstützt
• Tests selber können mit Spring konfiguriert
werden


Zusammenfassung


Zusammenfassung
Fazit
• Spring2 bietet viele sinnvolle Verbesserungen
und Erweiterungen
• Die fast 100% Abwärtskompatibilität
vereinfacht die Migration bestehender
Anwendungen
• Durch die vollständige Integration von AOP
lässt sich sehr bequem Funktionalität zu
bestehendem Code hinzufügen
• Der Scriptsupport ermöglicht es, sehr
dynamische Software zu bauen


Zusammenfassung
Ausblick
• Spring befindet sich auf dem Weg zu einer
noch besseren Modularisierung
• Teile werden in Spring-Modules ausgelagert
• Einbindung in 3rd-Party Produkte ist heute
schon problemlos möglich (z.B. Celtix – ein
OS ESB)
• Spring Web MVC und Spring Portlet
Framework bieten eine sehr gute Basis für
Webanwendungen (siehe Grails)


Links


Links
• Springframework Webseite
http://www.springframework.org
• Spring IDE (Eclipse Plugin)
http://www.springide.org
• Grails
http://www.grails.org/
• Thorsten Kamann
http://www.thorsten-kamann.de
• Beispielprojekt mit Spring2, Hibernate und AOP
http://thorque.wiki.com/Spring_2.0


Spring 2.0

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Destacado

Destacado (20)

Similar a Spring 2.0

Similar a Spring 2.0 (20)

Más de Thorsten Kamann

Más de Thorsten Kamann (12)

Spring 2.0