Leichtgewichtige Architekturen mit Spring, JPA, Maven und Groovy

Thorsten Kamann ● thorsten.kamann@itemis.de 1

Ziele der Software-Entwicklung…

Gute Performante Coole
Software Software Software


Was ist „gute“ Software?

Software, die macht was sie soll

Qualitativ-hochwertige Software

Software, die den Kundenwünschen
entspricht


…und was man dafür braucht

Gute und flexible Einwandfreie techn.
Architektur Infrastruktur

Gute Gutes und
Projektorganisation motiviertes Team


Das Thema heute ist:

Gute und flexible Einwandfreie techn.
Architektur Infrastruktur

Gute Gutes und
Projektorganisation motiviertes Team


Technische Infrastruktur

Versionskontrolle

Buildumgebung

Entwicklungsumgebung

Testumgebung


Versionskontrolle
• OpenSource
• Knowhow verfügbar
• Erprobt
• Sehr guter Toolsupport
• Standardisierter Zugriff über WebDAV
(optional)


Buildumgebung
• OpenSource
• Leicht anpassbar
• Knowhow
• Transitive Abhängigkeiten und zentrale
Repositories
• Projekt Metainformationen
• Reporting
• Continous Integration


Entwicklungsumgebung
• Anpassbar
• Erweiterbar
• Knowhow
• Gute Integration der verwendeten
Komponenten
• Versionskontrolle, Build- und
Testumgebung
• Effektives Arbeiten


Testumgebung
• Integrationtests
• Produktionsähnliche Umgebung
• Parallele Tests
• Failure eines oder mehrerer Tests dürfen nicht zum
Ausfall der gesamten Testumgebung führen


Leichtgewichtige Architekturen?


Leichtgewichtige Architekturen
Geringe Abhängigkeit zur Ablaufumgebung

• Code kennt seinen Container nicht
• Deployment entscheidet über die
Ablaufumgebung
• Während der Entwicklungszeit schneller
Servlet-Container anstatt J2EE-Server


Modularisierung
• Komponenten ohne starke Abhängigkeiten
• Serviceschnittstellen
• POJO-Komponentenmodell
• Programmieren gegen Interfaces


Testbarkeit
• Geringe Abhängigkeiten verbessern
Testmöglichkeiten
• „Schnelle“ Tests motivieren zum Test-
Driven-Development
• Komplexe Komponenten einfach gegen
Dummies oder Mocks austauschbar


Beispiel: Das Domänenmodell


Beispiel: Komponenten



• Grundgerüst für Projekte
• Projekt-Gesundheit durch Reporting
• Löst Abhängigkeiten auf
• Build

Maven



• IOC-Container
• Dependency Injection
• Programmiermodell
• Abstrahierungen wichtiger Standards
(z.B. JPA, WS, JMX,…)

Spring


• Defacto Standard im Bereich OR-
Mapping
• Vorlage für den JPA-Standard
• Voll JPA-kompatibel

Hibernate



• Dynamische Sprache
• 100% Integration in die Java-VM
• Mächtige Sprachfeatures
• Bi-direktionale Nutzung mit Java-
Code
• Ideal für Unit-Testing

Groovy

Exkurs: Maven
Features
• Beschreibung eines Projekts mittels Metadaten
• Beschreibung des resultierenden Artefakts und dessen
Abhängigkeiten
• Support von SNAPSHOT-Versionen
• Projektabhängigkeiten
• Anpassung des Buildprozess mit PlugIns
• Reporting
• Convention Over Configuration
• Release Management


Exkurs: Maven - Repositories
Lokales Repository
• Befindet sich auf dem lokalen Rechner
• Mit „install“ werden Artefakte installiert
• Nicht shareable

Remote Repository
• Befindet sich auf einem entfernten Server
• Mit „deploy“ werden Artefakte deployed:
per ssh, webdav, file, ftp,…
• Shareable


Exkurs: Maven - Abhängigkeiten
<project>
<modelVersion>4.0.0</modelVersion>
Artefakt-Beschreibung
<groupId>spring2.jpa.basic</groupId>
<artifactId>spring2-jpa-basic-impl</artifactId>
SNAPSHOT!
<version>1.0.0-SNAPSHOT</version>
<dependencies>
<dependency>
Abhängigkeit liefert
<groupId>org.springframework</groupId>
alle benötigten
<artifactId>spring</artifactId>
<version>2.0.6</version> Bibliotheken
</dependency>
[…]
</dependencies>
[…]
</project>


Exkurs: Maven - PlugIns
<build>
PlugIn für
<plugins>
Eclipse-Projekte
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.4</version> Lädt
<configuration>
Source-JAR‘s
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
Lädt
<additionalProjectnatures/>
JavaDocs-JAR‘s
<additionalBuildcommands/>
</configuration>
Natures und
</plugin>
</plugins> Builders
</build>


Exkurs: Spring [Was ist Spring?]

Inversion
Ansammlung von
of
API's
Control

Programmier-
modell


Exkurs: Spring [Komponenten]

Spring Core
AOP
WEB
JEE
Spring AOP
Spring MVC
AspectJ-Integration JMX
Struts
JMS
ORM WebWork
DAO JCA
Tapestry
JPA Remoting
Spring JDBC JSF
Hibernate EJB's
Transaction- PDF
Toplink Email
Management Portlets
JDO


Exkurs: Spring [Spring-Module]
Spring
Spring Spring
WebService
WebFlow Security
Spring Spring
Spring LDAP
Rich Client Extensions
Spring
Spring IDE Spring OSGI
BeanDoc
Spring Spring
Spring .NET
JavaConfig Batch


Exkurs: Spring [Features]
Leichtgewichtiger Container
• Zentralisierte und automatisierte
Konfiguration und Verdrahtung
• Nicht invasiv
• Fügt lose gekoppelte Komponenten (POJO's)
zu komplexen Systemen zusammen
• Skalierbar
• Verbessert die Testbarkeit der Komponenten


Abstraktions Transaktions-Management

• Erweiterbares Transaktions-Management
• Deklarative Konfiguration der
Transaktionen
• 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 O/R-Mapper

• 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


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


Dynamische Sprachen

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



Abstraktionsschicht für JMS

• Unterstützt JMS 1.0.2 und 1.1
• Unterstützt synchrone und asynchrone Calls
• Bietet ein einfaches API mittels
JMSTemplate


Support für JMX
• MbeanExporter ermöglicht den Export
jedes SpringBeans als MBean
• Listener-Support
• Notification-Support
• Verschiedene Naming-Strategies


Exkurs: Java Persistence API


Konzept
• JSR 220
• Entities sind POJO‘s
• Oft Entities = Tabelle in DB
• Instanzen einer Entity sind Zeilen einer
DB-Tabelle
• Konfiguration per
• Annotations
• XML


Query Language
• Java Persistence Query Language
• Ähnelt SQL
• Arbeitet mit Entity-Instanzen anstatt
DB-Tabellen


Exkurs: Groovy
Features
• JSR 241
• Dynamische Sprache
• 100% Integration in die Java VM
• Mächtige Syntax
• Schnell erlernbar
• Support für Domain Specific Languages (DSL)
• Vereinfacht Unit-Testing (jUnit integriert)
• Mächtige XML-Verarbeitung
• Kompiliert zu Java Bytecode


Exkurs: Groovy
Closures
• Codeblöcke
• Können einen Wert/Objekt zurückgeben
• Referenzieren und verwenden Variablen
• call()(implizit/explizit) führt die Closure
aus
• Können an eine Variable gebunden werden
• Ähneln Java Inner Classes


Exkurs: Groovy
The Groovy Truth
Runtime type Evaluation criterion required for truth
Booleanwert muss true sein
Boolean
Matcher Der reguläre Ausdruck muss mindestens 1 Treffer haben
Collection Die Collection darf nicht leer sein
Map Die Map darf nicht leer sein
String Der String darf ebenfalls nicht leer sein
Number Muss ungleich 0 sein
Die Objektreferenz muss ungleich null sein
Alles andere


Exkurs: Groovy – Listen und Ranges
def list = [„item1“, „item2“, „item3“]
Eine Liste mit 3 Einträgen
assert list.size()

def emptyList = [] Eine leere Liste
assert !emptyList
Der ersten Liste wird ein
list << „item4“
Element hinzugefügt
assert list.size() == 4
Eine Range mit den Werten
def range = [1..4]
1, 2, 3, 4 wird erstellt
assert range.size() == 4

Eine Range mit den Werten
def range1 = [1..<4]
assert range1.size() == 3 1, 2, 3 wird erstellt


Exkurs: Groovy – Listen und Closures
def list = [„item1“, „item2“, „item3“]
Each-Closure
list.each{ print it+“ „}
> item1 item2 item3

Ein bestimmtes Element
assert list.find{it==„item2“}
finden
list = [„a1“, „a2“, „a3“, „i1“, „i2“]
Eine Anzahl an Elementen
assert list.findAll{
it.startsWith(„i“)}.size() == 3 aus der Liste finden


Exkurs: Groovy - Maps
def map = [key1: „value1“, key2: „value2“] Eine Map mit 2 Einträgen
assert map.size() == 2
wird erstellt
assert map.key1 == „value1“
Ein 3. Eintrag wird
map.key3 == „value3“
hinzugefügt
assert map.size() == 3

Alternative Zugriffsmethode
assert map[„key2“] == „value2“
assert map.get(„key2“) == „value2“ auf die Elemente der Map
def emptyMap = [:] Eine leere Map
assert !emptyMap
wird erstellt


Zum Beispiel: Projektstruktur
API

Implementierung

Integration

WebApp

Webservice


Zum Beispiel: Build
Build mit Maven
• Ein mvn install in dem Projekt
spring2-jpa-basic builded alle
Projekte
• Das Projekt spring2-jpa-
basic-m2 stellt eine
vollständige Maven
Installation zur Verfügung
• Zusätzlich gibt es Eclipse-
Launcher für die anfallenden
Tasks


Zum Beispiel: API-Rollen
Verantwortliche Rollen
• Architekten
• Designer
Beteiligte Rollen
• Entwickler
• Kunden
• Qualitätssicherung?


Zum Beispiel: API – Knowhow & Tools


Beispiel: API - Domänenmodell


Beispiel: API - Datenzugriff


Beispiel: API - Services


Zum Beispiel: Implementierung-Rollen
• Architekten
• Designer
• Entwickler
Beteiligte Rollen
• Kunden
• Qualitätssicherung?


Zum Beispiel: Impl – Knowhow & Tools


Zum Beispiel: Impl - Entities
@Entity(table=„CUSTOMERS“) Entity auf Tabelle
public class Customer{
CUSTOMERS mappen
@Id
@GeneratedValue(
Primary Key
strategy = GenerationType.AUTO)
private Long id;

@OneToOne(targetEntity = Address.class,
1-zu-1 Beziehung
cascade = { CascadeType.ALL})
private IAddress address;
@Column(length = 40) Konfiguration einer
private String firstName;
Column in der Tabelle
…
CUSTOMERS
}


Zum Beispiel: Impl – persistence.xml
<persistence …>
Eindeutiger Name der
<persistence-unit
name=quot;spring2-jpa-basic-persistence-unitquot;> Persistence-Unit
<properties>
<property
name=quot;hibernate.jdbc.batch_sizequot; Eigenschaften der
value=quot;0quot;/>
Persistence-Unit
<property
name=quot;hibernate.default_batch_fetch_sizequot;
value=quot;5quot;/>
[…]
</properties>
</persistence-unit>
</persistence>


Zum Beispiel: Impl – DAO‘s
@Repository
Sorgt für die
public class CustomerDao
Übersetzung
implements ICustomerDao {
von Exceptions
@PersistenceContext(
unitName = quot;spring2-jpa-basic-persistence-unitquot;)
protected EntityManager entityManager; Injection des
Entity-Managers
public List<ICustomer> findAll() {
über Spring
return entityManager
.createQuery(quot;from Customer cquot;)
.getResultList();
Plain Java
}
[…]
}


Zum Beispiel: Impl – Spring-Config
<bean
class=„PersistenceAnnotationBeanPostProcessorquot; />
<bean
class=„PersistenceExceptionTranslationPostProcessorquot; />

Excpetion Translation

Support der Annotations in den DAO‘s


<bean id=quot;entityManagerFactoryquot;
Kein JNDI
class=„LocalContainerEntityManagerFactoryBeanquot;>
<property name=quot;dataSourcequot; ref=quot;dataSourcequot; />
<property name=quot;jpaVendorAdapterquot;>
<bean
class=„HibernateJpaVendorAdapterquot;>
JPA-Vendor
<property name=quot;databasePlatformquot;
value=quot;${jpa.provider.databasePlatform}quot; />
<property name=quot;showSqlquot;
Eigenschaften des
value=quot;${jpa.provider.showSql}quot; />
<property name=quot;generateDdlquot;
JPA-Vendors
value=quot;${jpa.provider.generateDdl}quot; />
</bean>
</property>
</bean>


Zum Beispiel: Impl - Services
@Transactional
Dieser Service nimmt an
public class CustomerService
einer Transaction teil:
implements ICustomerService {
private ICustomerDao customerDao; -PROPAGATION_REQUIRED
private IAddressDao addressDao; -READWRITE
-ROLLBACKFOR:
[…]
-jede RuntimeException

Diese Methode hat nur
@Transactional(readOnly = true)
einen lesenden Zugriff
public List<ICustomer> findAllCustomers() {
return customerDao.findAll();
}
[…]
}


<bean id=quot;transactionManagerquot; JPA
class=„JpaTransactionManagerquot;>
Transaction-Manager
<property name=quot;entityManagerFactoryquot;
ref=quot;entityManagerFactoryquot; />
</bean> Transaktionen werden
per Annotations
<tx:annotation-driven
konfiguriert
transaction-manager=quot;transactionManagerquot; />


Zum Beispiel: Impl – Unit Testing


Warum Groovy?
• Leistungsfähigere Syntax
• Listen
• Maps
• Integriertes jUnit
• Closures
• Keine Mocks, stattdessen Maps mit Closures
def dao = [findById:{id->
new CustomerImpl(id:100L,firstName:“…“,…)}] as ICustomerDao
• SpringBuilder
• XML-Processing

public final void testChangeAddress() { Erzeugung einer neuen
IAddress expAddress = new Address( Instanz mit Constructor-
street: quot;s1quot;, city: quot;c1quot;, Enhancement
country: quot;c1quot;, zipCode: quot;z1quot;);
Implementierung des
def addressDao = [ IAddressDao
store:{entity -> expAddress}] as IAddressDao
Neue Instanz des
ICustomerService customerService =
new CustomerService(addressDao: addressDao) ICustomerService
def result = customerService
.changeAddress(expAddress); Ausführen und
assert expAddress == result Ergebnis vergleichen
}


Zum Beispiel: Integration-Rollen

• Entwickler
• Betrieb
Beteiligte Rollen
• Kunden
• Qualitätssicherung


Zum Beispiel: Integration – Knowhow


Zum Beispiel: Integration
Spring
• AbstractJpaTests:
• Dependency Injection in Tests ohne Konfiguration
• Zugriff auf EntityManager
• Zugriff auf Spring-Ressourcen
• tearDown macht einen RollBack
• SpringContext wird einmalig pro TestCase initialisiert
DBUnit
• Erzeugt eine initiale Datenbefüllung
• Integrierbar in Spring


Zum Beispiel: Webapp-Rollen
• Architekten
• Designer
• Entwickler
Beteiligte Rollen
• Kunden


Zum Beispiel: Webapp– Knowhow


Zum Beispiel: Webapp
Spring & JSF
• org.springframework.web.jsf.DelegatingVariableResolver
• Erlaubt Injection von Spring-Komponenten in
ManagedBeans
• Alternativ Spring-MVC
• Bessere Navigation mit Spring-Webflow
Grails
• Web-Framework basierend auf Groovy und Spring
• Anbindung an Backend-System problemlos möglich
• Keine JSF-Unterstützung


Zum Beispiel: Webservice - Rollen
• Architekten
• Designer
• Entwickler
Beteiligte Rollen
• Kunden


Zum Beispiel: Webservice – Knowhow


Zum Beispiel: Webservice
Spring Webservice
• Contract-First Ansatz
• XML-Schema = Contract
• Nur der Endpoint muss programmiert werden
• WSDL wird zur Laufzeit erstellt
• Support von JAXB, Castor, XMLBeans,…


Ausblick auf Spring 2.5
Voller Java 6 und JEE 5
Support

Dependency Injection mit
Annotations

Autodetection von annotierten
Klassen

Built-In Support von Load-
Time-Weaving

Neue XML-Namespaces für
„context“ und „jms“


Fazit
Fazit
• Einfaches und flexibles System
• Wenige Abhängigkeiten von Systemkomponenten
• Leicht testbar
• Für alle Tasks bietet Spring eine Lösung
• Annotations vereinfacht die Konfiguration
• Sehr guter Support für Integrationstest
• Maven bietet eine sehr leistungsfähige Projektverwaltung
• Unittests mit Groovy machen Spaß und sind sehr effektiv
erstellt


Fazit
Verbesserungen
• Code-Generatoren vereinfachen die Erstellung von
Klassen und deren Annotations

• Integration von Groovy in alle Testbereiche (Unit,
Integration, Webtest, Webservicetest) kann die
Qualität dramatisch erhöhen


Ressourcen: Links


Über den Referenten


Leichtgewichtige Architekturen mit Spring, JPA, Maven und Groovy

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (20)

Similar a Leichtgewichtige Architekturen mit Spring, JPA, Maven und Groovy

Similar a Leichtgewichtige Architekturen mit Spring, JPA, Maven und Groovy (20)

Más de Thorsten Kamann

Más de Thorsten Kamann (12)

Leichtgewichtige Architekturen mit Spring, JPA, Maven und Groovy