Spring 3

Spring 3
Java-Framework
Autor
Stephan Metzler
Version 2.1
© 2011
Spring 3 >> Java Framework >>
Nachmittag
Vormittag
Nachmittag
Vormittag
MileStones
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Java Community
Verteilte Systeme
Java EE
Spring Framework
Spring Container
Dependency Injection
Spring AOP
Testen
ORM
Transaktionen
Messaging
Remoting
Spring MVC
Spring Security
Trends
Referenzen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 2 >> total: 160 Seiten
Seite
5
15
18
25
38
48
62
72
81
102
118
126
131
147
155
159
Spring 3 >> Java Framework >>
A
Java Community
Lerninhalte
Technologie Übersicht
Entwicklungtools
Paradigmatrends
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 3 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
1
Java Plattform
Die Java Plattform ist in drei Editionen aufgeteilt
JME
JSE
Micro Edition
Standard Edition
JEE
Enterprise Edition
- Umgebung
- Inhalt
- Definition
- robust
- flexible
- JRE
- APIs
- VM
- Standard (Framework)
- Multi-User
- Multi-Tier
- Enterprise Appl.
- Ziel-Applikationen
- embedded devices
- Mobil-Telefone
- PDAs
- Inhalt
- VM
- Standard Java APIs
- Kommunikationsprozesse
1.1
- JDK
- JRE
- Compiler
- Debugger
Basis für JEE
- Inhalt
- Dienstleistungen
- Zugriff
- transparente Lösungen
- Verhalten
OOA / OOD
hilfreiche und wichtige Neuerungen im Java-Standard (seit JDK 1.5)
- Annotations (Metadaten im Source)
- Generics (parametrischer Polymorphie)
Tools im Umgang mit JEE Technologien
- Maven (Build-Management-Tool der Apache Software Foundation)
- Log4J
- Junit
- Mock
state of the Art Implementierung ► siehe: Trends
- Software-Paradigmen
- Agil Don't Repeat Yourself
- DSL (Domain Specific Language)
- NoSQL
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 4 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
1.1.1
Annotationen
wiki
Annotation bedeutet "Anmerkung",
"Anmerkung", "Beifügung", "Hinzufügung". In diesem Sinn
haben Annotationen bei Stichworten,
Stichworten, Begriffsklärungen oder ausführlichen Texten
den Charakter der Erklärung beziehungsweise Ergänzung.
In der Softwareentwicklung dienen Annotationen dazu, Metadaten in den Quelltext
eines Programms einzubinden. Diese haben keine direkte Auswirkung auf die
Übersetzung des Quelltextes, bieten aber zusätzliche Möglichkeiten im Vergleich
zu einfachen Kommentaren.
Kommentaren.
Eigenschaften
Metadaten direkt im Sourcecode (zentral)
XML- oder Property-Dateien entfallen (mehrere Dateien sein z.T. umständlich)
werden von Codegenerierungstools ausgelesen (Controlle bei der Entwicklung)
werden zur Laufzeit per Reflection abgefragt (zur dynamischen Verwendung in
Frameworks)
- Zuordnung zum Sourcecode ersichtlich (als Entwickler Vorteil)
-
Verwendung von Annotations
- Annotations werden im Sourcecode vor dem zu markierenden Element eingefügt
- @ als Kennzeichnung vorangestellt (Leerzeichen sind erlaubt)
- Parameter als Name-Wert-Paar in Klammern an den Annotationsnamen angehängt
@MyAnnotation(parameter1 = "hello", parameter2 = "spring")
-
Reihenfolge der Parameter spielt keine Rolle
hat die Annotation nur einen Parameter, kann der Name weggelassen werden
bei parameterlosen Annotations ist die Angabe der Klammern optional
Annotations können sich auf folgende Java-Elemente beziehen:
- Packages, Klassen, Interfaces, Enumerations, Methoden, Variablen, Methodenparameter
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 5 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
Annotations in der Java JSE 5.0
- definiert sieben Annotations
- Standard Annotation (normale Verwendung beim Programmieren)
- Meta Annotation (Definition neuer Annotationstypen)
Standard Annotations
- @Deprecated
- kennzeichnet Methoden und Klassen, die nicht mehr verwendet werden sollen
- @Override
- der Compiler stellt sicher, dass die Methode der Basisklasse überschrieben wird
- @SuppressWarnings
- unterdrückt Compilerwarnungen. Warnungen werden als Parameter angegeben
Beispiel @Deprecated / @Override
public class HelloWorld {
@Deprecated
public String sayHello() {
return "Hello World";
}
@Override
public String toString() {
return "Hello World";
}
}
- sayHello() ist veraltet und erzeugt Compilerwarnung
- toString() mit @Override stellt sicher, dass toString() aus Object überschrieben wird
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 6 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
Meta Annotations
- @Documented
- zur Erzeugung der Dokumentation bei Javadoc
- @Inherited
- Annotation-Typ wird vererbt, auch rekursiv, falls keine Annotation in der aktuellen Klasse gefunden
wird.
- @Retention
- Definiert wie lange die Annotation verfügbar ist
- SOURCE
- nur bis zur Compilerzeit zur Verfügung
- CLASS (DEFAULT)
- werden in den Class-Dateien abgespeichert, aber nicht von der VM geladen
- RUNTIME
- werden in der Class-Datei abgelegt und von der VM geladen und stehen somit zur
Auswertung per Reflection zur Verfügung
- @Target
- definiert Elemente (Klasse, Methode, Parameter etc.) denen eine Annotation zugeordnet werden kann
Beispiel selbst definierter Annotation
public enum Datentyp {TEXT, NUMMER, DATUM }
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Datenfeld {
String bezeichnung() default "";
Datentyp datentyp() default Datentyp.TEXT;
}
- @Retention(RetentionPolicy.RUNTIME) definiert die Verfügbarkeit
- RUNTIME : Auswertung zur Laufzeit
- @Target({ElementType.FIELD}) definiert wo die Annotation eingesetzt werden kann
- FIELD : für Attribute
- @interface definiert das annotierte API Element "Datenfeld"
- Parameter : Bezeichnung und Datentyp (sind optional und mit Default-Werten)
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 7 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
Anwendung:
Anwendung: Klasse Person annotiert Attribute als Datenfelder
public class Person implements java.io.Serializable {
@Datenfeld(bezeichnung = "Nummer", datentyp = Datentyp.NUMMER)
private int nr;
@Datenfeld(bezeichnung = "Name", datentyp = Datentyp.TEXT)
private String name;
@Datenfeld
private String beschreibung;
}
Auslesen der Annotationen
Person p = new Person();
Field[] fields = p.getClass().getDeclaredFields();
for (Field field : fields) {
Datenfeld datenfeld = field.getAnnotation(Datenfeld.class);
...
1.1.2
Generics
wiki
In der Informatik sind Generische Typen Datentypen mit der Möglichkeit
Möglichkeit zur
Angabe von Typparametern. Man spricht auch von parametrischer Polymorphie.
Polymorphie.
Ein generischer Typ erlaubt es, Datentypen zu erzeugen, die von den zu Grunde
liegenden Typen abstrahieren. So würden eine Liste von Zahlen, eine Liste von
Zeichen und eine
eine Liste von Datumsangaben im Grunde auf dieselbe Weise
programmiert werden. Die Algorithmen zum Einfügen, Suchen und Löschen
würden stets gleich ablaufen. Es ist daher wünschenswert, die Implementierung
der Liste unabhängig von diesen Typen vorzunehmen
Eigenschaften
-
erlauben die Abstraktion von Typen
erlaubt Wiederverwendbarkeit von Funktionalitäten
defineren generische Klassen und Methoden, unabhängig von einem konkreten Typ
definieren parametrische Polymorphie
Generics verbessert die Lesbarkeit und hilft
hilft durch die erhöhte
Typsicherheit die Zuverlässigkeit des Codes zu erhöhen.
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 8 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
normale Collections
List v = new Vector();
v.add(new Double(1.0));
Double d = (Double)v.get(0);
- Cast auf Double ist notwendig, denn der Rückgabewert von get(...) ist Objekt
- erlaubt inkompatible Typen in die Liste einzuführen
generische
generische Collections
List<Double> v = new Vector<Double>();
v.add(new Double(1.0));
Double d = v.get(0);
- v ist eine Liste von (nur) Double
- Typ in spitzen Klammern definiert den konkreten Typparameter
- Verwendung wird durch Compiler sichergestellt und zur Compilezeit erkannt
- Casts entfallen, da Rückgabewert von get(...) nur Double ist
- mehrere Typparameter werden durch Komma getrennt (z. B. Hashtable<Long, String>)
Wildcards und Bounds
- unabhängiger Code
- Implementierung von Such- oder Sortieralgorithmen
- Wildcardzeichen ist ?
- Vector<?> steht für einen Vector mit beliebigem Inhalt
- Bounds als Angabe von Schranken
- extends limitiert auf den angegebenen oder abgeleiteten Typ
- super limitiert auf den angegebenen oder vererbten Typ
Beispiel parametriesierter Polymorphie
Vector<?> v1;
Vector<String> v2 = new Vector<String>();
v1 = v2;
// nur String
List<? extends Number> aList;
// Number oder Subtyp
List<? super String> anotherList // String oder Supertyp
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 9 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
generische Typen
- Generics sind nicht auf die Verwendung bestehender Klassen beschränkt
- eigene generische Typen können definiert werden
Definition der generischen Klasse MyGeneric
- Enthält zwei Typparameter (T und U)
- die Typparameter können wie normale Typen bei der Definition der Klasse verwendet werden
public class MyGeneric<T, U> {
private T key;
private U value;
public MyGeneric(T key, U value) {
this.key = key;
this.value = value;
}
public T getKey() {
return key;
}
public U getValue() {
return value;
}
}
Generische Methoden
- Definition von generischen Methoden
- Definition der generischen Methode sayHello(...), die zwei Typparameter enthält
public class GenericMethod {
public static <E, T> void sayHello(E pre, T post) {
System.out.println(pre.toString() + " hello "
+ post.toString());
}
public static void main(String[] args) {
sayHello("generic", new StringBuffer("world"));
}
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 10 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
1.1.3
Maven
wiki
Maven ist ein BuildBuild-ManagementManagement-Tool der Apache Software Foundation und
basiert auf Java.
Java. Mit ihm kann man insbesondere JavaJava-Programme standardisiert
erstellen und verwalten.
Eigenscha
Eigenschaften
- bildet "Convention over Configuration" für gesamten Zyklus der Softwareerstellung ab
- automatisiert die Prozesse der Entwicklung
-
Kompilieren
Testen
Packen
Deployen
- definiert vorgegebene Standards
- braucht wenige Konfigurationseinstellungen
- vereinfacht Aufgaben des Build-Managements
- bildet den Lebenszyklus eines Softwareprojekts ab
Lebenszyklus - Softwareentwicklung (mit Maven) folgt einem Zyklus:
- validate (Validieren)
- prüft ob die Projektstruktur gültig und vollständig ist
- compile (Kompilieren)
- kompiliert den Quellcode
- test (Testen)
- testet den kompilierten Code mit einem passenden Testframework (z.B. JUnit)
- package (Verpacken)
- der kompilierte Code wird mit anderen nichtkompilierbaren Dateien zur Weitergabe verpackt (z.B. JAR)
- integration-test (Test der Integrationsmöglichkeit)
- Softwarepaket wird auf eine Umgebung (z.B. Server) geladen und seine Funktionsfähigkeit geprüft
- verify (Gültigkeitsprüfung des Software-Pakets)
- prüfen ob das Softwarepaket eine gültige Struktur und bestimmte Qualitätskriterien erfüllt
- install (Installieren im lokalen Maven-Repository)
- installiert das Softwarepaket in dem lokalen Maven-Repository (z.B. für modulare Projekte)
- deploy (Installieren im entfernten Maven-Repository)
- installiert das Softwarepaket auf einem entfernten Maven-Repository (Wiederverwendbarkeit)
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 11 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
Konfigurationsdatei http://maven.apache.org/pom.html
- als XML-Datei mit dem Dateinamen pom.xml (für Project Object Model)
- enthält alle Informationen zum Softwareprojekt
- standardisiertes Format <?xml version="1.0" encoding="UTF-8"?>
- src
- alle Eingabedateien
- target
- alle erzeugten Dateien
<project xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="
http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>org.springframework</groupId>
<artifactId>spring-utility</artifactId>
<version>1.0.0.CI-SNAPSHOT</version>
<name>Spring Utility</name>
<url>http://www.springframework.org</url>
<properties>
<spring.framework.version>
3.0.2.RELEASE
</spring.framework.version>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.4</version>
<scope>test</scope>
</dependency>
StandardStandard-Verzeichnisstruktur
- vereinfacht die zentrale Konfigurationsdatei pom.xml
- Softwareprojekt soll sich an folgende Struktur halten
- src/main
- Eingabedateien für Erstellung des eigentlichen Produkts
- src/main/java
- Java-Quelltext
- src/main/resources
- Dateien für die Übersetzung oder zur Laufzeit
z.B. Properties-Dateien
- src/test
- Eingabedateien für automatisierte Testläufe
- src/test/java
- JUnit-Testfälle für automatisierte Tests
- target/classes
- kompilierte Java-Klassen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 12 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
Auflösung von Abhängigkeiten
als zentrale Repositories
- in der pom.xml werden Softwareabhängigkeiten angegeben
- diese Abhängigkeiten werden aufgelöst
- Maven ermittelt ob die benötigten Dateien in einem lokalen Verzeichnis bereits vorhanden sind
- oder Maven versucht sich mit einem konfigurierten Maven-Repository im Intranet zu verbinden
- oder Maven versucht sich mit einem konfigurierten Maven-Repository im Internet zu verbinden
- Abhängigkeiten werden in das lokale Repository kopiert
- Bekannte öffentliche Maven-Repositories http://mvnrepository.com/
-
Apache
Ibiblio
Codehouse
Java.Net
- Firmenweite Maven-Repositories stellen Bibliotheken und Frameworks zur Verfügung
- Archiva, Artifactory, Proximity
- Codehaus Maven Proxy
- Dead Simple Maven Proxy
1.1.4
-
Log4J
populäre JAVA Logging-API http://logging.apache.org/log4j
Vererbung von Loggern
Logger Hierarchien erlauben feingranulare Kontrolle über Logausgaben
Log-Anweisungen lassen sich durch Konfigurationsdateien ein- und ausschalten
Komponenten
- Loggers
- Layouts
- Appenders
Loggers
- benannte Entitäten (Case sensitive) und
folgen einer hierarchischen Namenskonvention
- Root-Logger (z.B. org) ist oberste Instanz
- org.apache.log4j
- Einem Logger kann ein Level zugeordnet werden
- DEBUG < INFO < WARN < ERROR < FATAL
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 13 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
Layouts
- erlauben das Formatieren der Loggermeldungen mit Pattern
org.apache.log4j
Pattern Zweck
c
Category: Kategorie = Name org.apache
C
Class = Klassennamen
d
Date. Beispiel: %d{HH:mm:ss,SSS}
F
Filename
l
Location. Aufrufende Methode, Quelle, Dateiname und Zeilennummer
L
Line number
m
Meldung selbst
M
Methodennamen
n
Line-Separator (Plattformabhängig)
p
Priority: INFO, WARN, ERROR etc.
r
Anzahl der Millisekunden seit dem Start der VM
Appenders
- Destinationen für Logger Meldungen
-
Konsolen
Dateien (klassische Logger-Dateien)
GUI-Komponenten
Remote Socket-Server (Stichwort zentrale Überwachung)
JMS (Java Message Server)
NT Event Logger
Unix Syslog Deamon
Appender Additivity
Logger
Appender Target
root
org
org.apache
org.apache.log4j
A1
B1, B2
none
C1
Vererbte Appenders
A1
A1, B1, B2
org und root
A1, B1, B2
org und root
A1, B1, B2, C1 org.apache.log4j, org und root
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 14 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
Konfiguration
Konfiguration
- mittels XML oder mit Properties-Dateien
# der Root-Logger hat den Level DEBUG
log4j.rootLogger=DEBUG, stdout, file
# Appender mit der Destionation Konsole
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
# Layout Für diesen Appender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# Datum im ISO-Format ISO-8601 anzeigen
log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# allen Klassen des Packages org.springframework den Level [INFO | DEBUG | ERROR] zuweisen
log4j.logger.org.springframework=ERROR
# Konfiguration der Log-Datei
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=../log4j.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%p %t %c - %m%n
log4j.appender.file.MaxFileSize=100KB
# Eine Backup-Datei behalten
log4j.appender.file.MaxBackupIndex=1
# weitere Categorien
log4j.category.org.apache.activemq=ERROR
log4j.category.org.springframework.batch=DEBUG
log4j.category.org.springframework.transaction=INFO
# Persistenz
log4j.category.org.hibernate.SQL=DEBUG
for debugging datasource initialization
log4j.category.test.jdbc=DEBUG
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 15 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java Plattform
B
Verteilte Systeme
Lerninhalte
Technologien
Corba
DCOM
.NET
EJB
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 16 >> total: 160 Seiten
Spring 3 >> Java Framework >> Verteilte Systeme
2
Verteilte Systeme
- mehreren Prozessen
- kommunizieren mittels Nachrichtenaustausch
Eigenschaften
- gemeinsame Nutzung von Ressourcen
- zuverlässige und konstante Zugriffszeit
- Offenheit
-
Client Server Architektur
Erweiterbarkeit des Systems (Hardware, Software)
Standardisierung von Schnittstellen
Interprozesskommunikation
heterogene HW- und SW- Komponenten
- Skalierbarkeit
- ohne Änderungen der System- oder Anwendungssoftware
- Fehlertoleranz
- Hardwareredundanz
- Softwareredundanz
2.1
Technologien für Verteilte Systeme
CORBA
► Common Object Request Broker Architecture
- plattform- und sprachunabhängig
- nur "basic distribution"
DCOM
► Distributed Component Object Model
Dienste zur Kommunikation zwischen Prozessen
- Microsoft
- CORBA-DCOM Bridge
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 17 >> total: 160 Seiten
Peer-to-Peer Architektur
Spring 3 >> Java Framework >> Verteilte Systeme
.NET (Microsoft) http://de.wiki.org/wiki/.NET
-
sprach- und (plattform-) unabhängig
löst Component Object Model ab
fokussiert auf Client (Services)
auch PDA (Personal Digital Assistant)
seit Januar 2008 OpenSouce
CLR ist die Laufzeitumgebung
- CLR = Common Language Runtime
- Interpreter für den standardisierten
Zwischencode
- CLI ist der Zwischencode
- CLI = Common Intermediate Language
EJB (Enterprise Java Beans) http://de.wiki.org/wiki/Enterprise_JavaBeans
-
nur JAVA http://java.sun.com/javaee
entwickelt für Geschäftsprozesse
intgegriete Verbindungslogik
standardisierte Komponenten
vereinfachte Entwicklung
- Sicherheit
- Transaktionen
- Kommunikation
- synchron
- asynchron
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 18 >> total: 160 Seiten
Spring 3 >> Java Framework >> Verteilte Systeme
C
Java EE
Lerninhalte
Spezifikation
Einsatzgebiete
Komponenten
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 19 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java EE Plattform
3
Java EE Plattform
http://java.sun.com/javaee/5/docs/tutorial/doc/
Spezifikation
- JEE ist die Spezifikation einer Softwarearchitektur
- JEE bezeichnet ein Applikationsframework, ausgelegt auf
- Performance
- Skalierbarkeit
- Plattformunabhängigkeit
Eigenschaften
- sauber implementierte Trennung
zwischen Tiers
- dadurch weitgehende
Unabhängigkeit
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 20 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java EE Plattform
3.1
wiki
Application Server
Ein Anwendungsserver ist ein Server in einem
Computernetzwerk,
Computernetzwerk, auf dem AnwendungsAnwendungsprogramme ausgeführt werden.
Im engeren Sinne bezeichnet der Begriff eine
Software,
Software, die spezielle Dienste
Dienste zur Verfügung
stellt, wie beispielsweise Transaktionen,
Transaktionen,
Authentifizierung
Authentifizierung oder den Zugriff auf
Verzeichnisdienste und Datenbanken
über definierte Schnittstellen.
Schnittstellen.
JEE Anwendungserver beinhaltet
- Components
- Applets, Servlets, Enterprise Java Beans
- Containers
- Web Browsers, Servlet Engines, EJB Containers
- Resources
- SQL Datenquellen, Nachrichtensysteme, Mailsysteme
3.2
History
History der Java Enterprise Edition
http://de.wikipedia.org/wiki/Java_Platform,_Enterprise_Edition
Robustheit
J2EE 1.3
J2EE 1.2
JPE Project
Java
Plattform for
the Enterprise
1998
Servlet /JSP
EJB 1.0
JMS 1.1
JTA 1.0
JAAS 1.0
JNDI
RMI/IIOP
1999
EJB 2.0
2001
Web Services
J2EE 1.4
EJB 2.1
JSS 2.4
JSP 2.0
WS 1.0
JavaMail 1.2
JAXP 1.2
JCA 1.5
2003
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 21 >> total: 160 Seiten
SOA
Java EE 5
EJB 3.0
JPA 1.0
JSS 2.5
JSP 2.1
JSF 1.2
WS 1.2
JavaMail 1.4
JAXB 2.0
JAXP 1.3
JAX-WS 2.0
StAX 1.0
JSTL 1.2
Java EE 6
2006
2010
EJB 3.1
JPA 2.0
JSS 3.0
JSF 2.0
Bean
Validation
Spring 3 >> Java Framework >> Java EE Plattform
3.3
Features
- neue XML/Web Services
-
JAX-B (JSR-222) - Java Architecture for XML Binding
JAX-WS (JSR-224) - Java API for XML - Web Services
StAX (JSR-173) - Streaming API for XML
Web Services Metadata (JSR-181)
- neue Web Technologien
- JSP Standard Tag Library (JSR-52)
- Java Server Faces (JSR-252)
- neue EoD (Ease Of Development = Entwicklungserleichterung)
- EJB 3.0 und Java Persistence API (JSR-220)
- Common Annotations (JSR-250)
- Security Änderungen
- Gleichsetzung der Security Permissions von Web und EJBContainer
Deployment Deskriptoren
wiki
Ein Deployment Descriptor (frei übersetzt "Einsatzbeschreibung")
"Einsatzbeschreibung") ist eine
Konfigurationsdatei im Format XML.
XML. Im Umfeld der Java Platform, Enterprise
Edition,
Edition, beschreibt diese Konfigurationsdatei den spezifischen BereitstellungsBereitstellungsprozess (englisch deployment)
deployment) und dazu benötigte Informationen.
Informationen.
-
sind eine der Stärken von J2EE
Grundlage: J2EE Rollenverständnis: Comp.Developer, Assembler, Deployer
Idee nachträglich Settings/Verhalten anpassen zu können
jedoch grössere Komplexität
nur durch Tools (IDEs, Xdoclet) beherrschbar
Migrationshindernis
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 22 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java EE Plattform
3.4
Einsatzgebiete
In den folgenden Gebieten finden JEE Applikationen ihren Schwerpunkt:
-
Datenbankzugriff
dynamische Internetseiten
Enterprise JavaBeans
Middle-Tier Server
plattformenabhängige Kommunikation
Sicherheit
Trennung der Anwenderschwerpunkte
verteilte Systeme
Web-Server-Einsatz
3.5
Architektur
Funktionelle Einheiten werden als Komponenten bezeichnet und zu einer KomponentenArchitektur zusammengefasst.
Dabei dominieren die folgenden "Core Technologies":
- JNDI (Java Naming and Directory Interface)
- Zugriff auf "naming" und "directory" Systeme wie LDAP, DNS, etc.
- JTA (Java Transaktion API)
- Zugriff auf Transaction Systeme wie BEA Tuxedo, etc.
- JDBC (Java DataBase Connectivity)
ORACLE
- Zugriff zu relationalen Datenbanken
- JMS (Java Messaging Service )
- Zugriff zu Message Orientated
Middleware, z.B. iBus ,IBM MQSeries
DB2
JDBC
BEATuxedo
JTA
JEE
JMS
IBM MQSeries
iBus
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 23 >> total: 160 Seiten
JNDI
LDAP
DNS
COS
Spring 3 >> Java Framework >> Java EE Plattform
3.6
wiki
Konventionen
Eine Konvention (lat.
(lat. conventio „Übereinkunft, Zusammenkunft“) ist eine nicht
formal festgeschriebene Regel,
Regel, die von einer Gruppe von Menschen aufgrund
eines Konsens eingehalten wird.
- Namenskonventionen mit JSR 220 nicht mehr so dominant
- orientieren sich am Namensmodell von SUN™
Ansatz basierend auf dem HelloWorld
HelloWorld EJB
Item
Syntax
Enterprise Bean Name (DD)
<name>Bean
EJB JAR Display Name (DD)
<name>JAR
Enterprise Bean Class
<name>Bean
Business
<name>
Business / Remote Interface
Local Business / Remote Interface <name>Local
Abstract Schema (DD)
<name>
3.7
wiki
Beispiel
HelloWorldBean
HelloWorldJAR
HelloWorldBean
HelloWorld
HelloWorldLocal
HelloWorld
Komponenten
Eine SoftwareSoftware-Komponente ist ein SoftwareSoftware-Element, das konform zu einem
Komponentenmodell ist
ist und gemäss einem CompositionComposition-Standard ohne
Änderungen mit anderen Komponenten verknüpft und ausgeführt werden kann.
also eine funktionierende Software Einheit
-
wird über einen JEE-Server verschiedenen Clients zur Verfügung gestellt
ist Bestandteil einer JEE-Anwendung
als *.ear Datei (e
enterprise archive)
gepackt
ar
bestehend aus folgenden (optionalen) Komponenten
- Enterprise Beans
- eine oder mehrere Enterprise Beans in einer *.jar Datei (java archive)
- WEB-Anwendungen
- HTML-Seiten, Servlets, JSP, gif- und jpg-Bilder in einer *.war Datei (web application archive)
- Client-Anwendungen
- Stand-Alone Java Applikation in einer *.jar Datei (java archive)
- Deployment Descriptors
- XML-Dokumente zur Integrationsbeschreibung
(sind optionale Bestandteile jeder EAR Komponente)
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 24 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java EE Plattform
3.8
Enterprise Archive
- folgt standardisierter Struktur
- ermöglicht dem Applikationsserver das Entpacken der Komponenten
- erlaubt das Deployen der JEE Applikation
3.9
Verteilte Multi-Tier Applikationen
- das Verteilen der Applikation definiert der "separation of concern" Aspekt der OOA
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 25 >> total: 160 Seiten
Spring 3 >> Java Framework >> Java EE Plattform
D
Spring Framework
Lerninhalte
Motivation
Core Technologien
Module
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 26 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Framework
4
Spring Framework
- Open-Source-Framework (Rod Johnson, Buch: J2EE Design and Development)
- Entwicklung von Unternehmensanwendungen soll weniger komplex werden
- JavaBeans als Serverkomponenten ohne Server vs. EJBs
LightweightLightweight-Container/Container/-Framework mit Dependency Injection
Injection und
Aspektorientierung als vollwertiger Java EE / J2EEJ2EE-Applikationstack,
der durch Qualität, Effizienz und Einfachheit glänzt.
http://www.springsource.org/
We aim that:
- Spring should be a pleasure to use
- Your application code should not depend on Spring APIs
- Spring should not compete with good existing solutions, but should foster integration.
(For example, JDO, Toplink, and Hibernate are great O/R mapping solutions. We don't
need to develop another one.)
4.1
neue Features in Spring 3
- SpEL Spring Expression Language
- Ausdrücke werden zur Laufzeit ausgewertet
- ermöglicht dynamische Elemente im System
- als XML-Konfiguration oder innerhalb von Annotationen
- komfortabler Umgang mit Annotationen
- mit Annotationen konfigurieren, ohne die Implementierungsklassen anzupassen
- Meta-Annotationen
- eigene Annotations definieren
- an zentraler Stelle die Annotationen zusammenstellen und diese in eigenen Klassen verwenden
- REST-Unterstützung (Representational State Transfer) im MVC-Framework
- Softwarearchitekturstil für verteilte Hypermedia-Informationssysteme
- Ressourcen werden mit eigenen URI angesprochen
- Spring3 erweitert das enthaltene MVC-Framework um REST-Fähigkeiten
- Konfiguration erfolgt mit Annotationen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 27 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Framework
4.2
Motivation
Bereiche zu versorgen, die von anderen Frameworks nicht erreicht werden:
- Integration in eine umfassende Architektur kann zu hohem Aufwand führen
- Spring bietet ganzheitliche Lösung an
- leichte Anpassung
- ein Framework soll klare Schichten bieten
- Best-Practices leicht anwenden
- Minimierung des Aufwands für bewährte Techniken mit grösstmöglicher Freiheit beim Design
- keine Abhängigkeit
- IoC und AOP als Schlüsseltechnologien, um Abhängigkeiten zu vermeiden
- konsistente Konfiguration
- mit einheitlichem Stil für alle Schichten der Applikation
- leichte Testbarkeit
- Einsatz von Mock-Objekten klar und geradlinig
- Erweiterbarkeit erlauben
- erweiterbares Framework soll auf Interfaces basieren
4.3
Spring Technologien
Die Spring Core Technologien sind:
- Lightweight Container Framework
- DI / IoC
- AOP
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 28 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Framework
4.4
Lightweight
- Framework ist klein
- erfordert wenig
(Entwickler-)Aufwand
- kleine Prozessorbelastung
- keine Abhängigkeiten von
spezifischen Klassen
- baut auf POJOs auf
Graph
- pom.xml für Beispiele
- Not exactly lightweight
- http://javathreads.de/2009/02/leichtgewichtigkeit-von-jee-oder-spring/
4.5
wiki
Dependency Injection
A
Dependency Injection (DI) ist ein Entwurfsmuster und
dient in einem objektorientierten System dazu, die
Abhängigkeiten
Abhängigkeiten zwischen Komponenten oder Objekten
zu minimieren.
Dependency Injection ist eine Anwendung des
<<creates>>
Prinzips der Inversion of Control (IoC), bezieht sich
aber nur auf die Erzeugung und Initialisierung von Objekten.
Sie kann als Verallgemeinerung der
der Fabrikmethoden verstanden werden.
Die Funktionalität bleibt trotz dieser Kontrollumkehr als
Einfügung enthalten. Dadurch ist es einfach möglich,
Abhängigkeiten zu erkennen.
A
IB
B
IB
- fördert lose Kopplung
- Objekte erhalten ihre Abhängigkeiten passiv
<<injects>>
IoC
-deps
-config
-lifec.
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 29 >> total: 160 Seiten
B
Spring 3 >> Java Framework >> Spring Framework
4.6
wiki
Aspektorientierung
Aspektorientierte Programmierung (AOP) ist ein
Programmierparadigma, eine Methode der ComputerComputerprogrammentwicklung, die anstrebt, verschiedene
logische Aspekte eines Anwendungsprogramms
(kurz Anwendung)
Anwendung) getrennt voneinander zu entwerfen,
entwerfen,
zu entwickeln und zu testen.
Die getrennt entwickelten Aspekte werden dann zur
endgültigen Anwendung zusammengefügt.
A
SECURITY
B
LOGGING
- erlaubt kohäsive (zusammenhängende) Entwicklung
- Separation of Concern
- trennt Business-Logik von Systemservices
A
- Logging
- Auditing
- Transaktionsverwaltung
AOP
SECURITY
B
LOGGING
4.7
Spring Features
Konfiguration und Zusammenstellung komplexer Anwendungen
- deklarativ (in der Regel als XML-Datei)
- zunehmende Konfiguration durch Annotations
- umfassende Infrastrukturfunktionalität
- Transaktionsverwaltung
- Integration in Persistenz-Frameworks
- Java Persistence API http://java.sun.com/javaee/technologies/persistence.jsp
- Hibernate www.hibernate.org
- TopLink http://www.oracle.com/technology/products/ias/toplink/index.html
- iBatis http://ibatis.apache.org/
- etc.
4.7.1
Container
- verantwortlich für Anwendungsobjekte
- Verwaltung
- Konfiguration
- Lebenszyklus
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 30 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Framework
4.8
Spring Module
- Programmbausteine lassen sich in Enterprise-Anwendungen koppeln
- ohne explizite Abhängigkeiten
- definieren konsequente Verwendung von Schnittstellen
Spring Core Container
- zentraler Bestandteil
- lightweight Container
- Inversion of Control
- Dependency Incetion
Verantwortlichkeiten
- Beans / Core
- Objektrelation
- Context
- Objektdefinition
- Expression Language
- Objektmanipulation
4.8.1
Module ► Data Access/Integration
- JDBC
- Layer der JDBC codieren und DBMS Fehler parsen abstrahiert
- ORM
- Layer um populäre O/R-Mapper zu integrieren (JPA, JDO, Hibernate, TopLink, iBatis, etc.)
- OXM
- Layer für Object/XMl Mapping zu integrieren (JAXB, Castor, XMLBeans, JiBX and XStream, etc.)
- JMS
- Layer zur Integration des
asynchronen Kommunikationsmodell
- Transaction
- Layer für deklaratives und
programmatisches Transaktionsmanagement
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 31 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Framework
4.8.2
Module ► Web – MVC / Remoting
- Web
- Layer zur Integration von web-orientierten Features
- multipart file-upload
- servlet listeners
- web-oriented application context
- remoting support
- Web-Servlet
- Layer mit der Spring MVC Implementation
- Web-Struts
- Layer zur Integration von Struts (deprecated)
- Web-Portlet
- Layer zur Portlet Integration
- spiegelt die Funktionen des Web-Servlet Modul
4.8.3
Module ► AOP / Instrumentated Spring
- AOP
- Layer zur Integration eine AOP Alliance kompatiblen aspektorientierten Programmierung
- Methoden Interceptoren
- Cross Cutting Funktionalität
- AspectJ Integration
- Instrumentation
- unterstützt statisches AOP
►compile-time woven version of Spring AOP
- Web Services
- Web Flow
- Security JARs
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 32 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Framework
4.8.4
Module ► Test
- Test
- Layer zur Unterstützung von Testframeworks
- JUnit
- TestNG
- etc.
- synchronisiert und cached den Spring Applikationkontext
- unterstütz isoliertes Mock testen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 33 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Framework
4.9
Spring Szenarios
typische vollumfängliche Webapplikation
Spring Middle-Tier mit Integration zu einem third-party Web-Framework
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 34 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Framework
Remoting
EJBs – bestehende POJOs anbinden
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 35 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring ins kalte Wasser
5
Spring ins kalte Wasser
Aufbau, Installieren und Betreiben einer Spring Applikation
Voraussetzungen
Voraussetzungen
- JSDK: Java Software Development Kit
- Spring Framework http://www.springsource.org/
- Entwicklungsumgebung
- STS Springsource Toolsuite http://www.springsource.com/products/sts
- Maven
Umgebungsvariablen
- Benutzer- oder Systemvariablen definieren / ergänzen
C:\>set
...
JAVA_HOME=C:\Programme\Java\jdk1.6.0_21
MAVEN_HOME=C:\springsource\maven-2.2.1.RELEASE
Path=%PATH%;C:\springsource\maven-2.2.1.RELEASE/bin
- Maven ausführen
C:\springsource\maven-2.2.1.RELEASE\bin\mvn.bat
5.1
Hello Spring Projekt
- Projekt mit STS als neues Spring Template Projekt erzeugen
- File New Spring Template Project
Simp
Simple Spring Utility Project
Next
- Project name : hello_spring
- top-level package : module.spring.hello
Finish
generierte Spring Deklaration
Deklaration appapp-context.xml
context.xml
<?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.5.xsd">
<description>Example configuration to get you started.</description>
<bean id="service" class="module.spring.hello.ExampleService" />
</beans>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 36 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring ins kalte Wasser
generierte Klassen
- generiertes Service Interface Service.java
package org.springframework.integration;
public interface Service {
String getMessage();
}
- generierte Service Implementierung ExampleService.java
package org.springframework.integration;
public class ExampleService implements Service {
public String getMessage() {
return "Hello world!";
}
}
- generierte Testklasse ExampleConfigurationTests.java
@ContextConfiguration
@RunWith(SpringJUnit4ClassRunner.class)
public class ExampleConfigurationTests {
@Autowired
private Service service;
@Test public void testSimpleProperties() throws Exception {
assertNotNull(service);
}
}
- generierte Testklasse ExampleServiceTests.java
public class ExampleServiceTests extends TestCase {
private ExampleService service = new ExampleService();
public void testReadOnce() throws Exception {
assertEquals("Hello World", service.getMessage());
}
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 37 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring ins kalte Wasser
Übung Spring Container instanziiert Bean durch Setter
- Ergänzen Sie die Spring Deklaration app-context.xml mit der Property message
<bean id="service" class="module.spring.hello.ExampleService" >
<property name="message" value="Hello Spring" />
</bean>
- Ergänzen Sie die ExampleService Klasse durch die entsprechenden getter / setter
public class ExampleService implements Service {
private String
message;
public String getMessage() {
return this.message;
}
public void setMessage(String message) {
this.message = message;
}
}
- Testen Sie die Applikation mit entsprechenden TestCases
@Test
public void testProperty() throws Exception {
assertEquals("Hello Spring", service.getMessage());
}
Übung Spring Container instanziiert Bean durch Argumentenkonstruktor
- Ergänzen Sie die Spring Deklaration app-context.xml mit einem Konstruktor Argument
<bean id="service" class="module.spring.hello.ExampleService" >
<constructor-arg value="Hello Spring" />
</bean>
- Ergänzen Sie die ExampleService Klasse durch den entsprechenden Konstruktor
- Testen Sie die Applikation mit entsprechenden TestCases
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 38 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring ins kalte Wasser
E
Spring Container
Lerninhalte
Containertypen
Spring Context
SpEL Spring Expression Language
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 39 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
6
Spring Container
- Komponentenverwaltung
-
Injizieren von Konstruktoren und Änderungsmethoden
Verschalten von Beans
Erstellen und Zerstören von Beans
Erstellen von Assoziationen
Wiederverwenbarkeit ermöglichen
6.1
Spring Containertypen
IoC Container
- org.springframework.beans.factory.BeanFactory
- verantwortlich für Lebenszyklus und Verwaltung
Anwendungskontext
- org.springframework.context.ApplicationContext
- verantwortlich für weiterführende Container-Aufgaben
- Spring AOP Features
- z.B. Transaktionen
- Message Resource Handling
- z.B. Internationalization
- Event Publication
- z.B. Listener
- Application-Layer Kontext
- z.B. für Web Applikationen
- Validierung
- z.B. Nachweis von Gültigkeit, Typ, Bereich, Sinn und Zweck, etc.
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 40 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
6.2
wiki
Bean Factory
Der Begriff Fabrikmethode (englisch
(englisch Factory Method)
Method) bezeichnet ein
Entwurfsmuster aus dem Bereich der Softwareentwicklung.
Softwareentwicklung. Das Muster
beschreibt, wie ein Objekt durch Aufruf einer Methode anstatt durch direkten
Aufruf eines Konstruktors erzeugt
erzeugt wird. Es gehört somit zur Kategorie der
Erzeugungsmuster.
Erzeugungsmuster.
- Beans erstellen und verwalten
- erstellen von Assoziationen zwischen kollaborierenden Objekten (Beans)
- steuert den Lebenszyklus einer Bean
- falls benutzerdefinierte Initialisierungsmethoden und Zerstörungsmethoden definiert sind
- BeanFactory Interface ist zentrales IoC Container Interface
- verantwortlich für Instanziierung, Konfiguration und Abhängigkeiten
- verschiedene Implementationen des BeanFactory Interface
- out-of-the-Spring-box
- meist wird XmlBeanFactory verwendet
- basiert auf Deklaration durch XML Datei
Aufgaben der BeanFactory
leeren Konstruktor aufrufen
Definition
Autowiring
setter Methoden aufrufen
Abhängigkeiten prüfen
setBeanFactory() aufrufen
afterPropertiesSet() aufrufen
init Methoden aufrufen
Verknüpfungen
definiert
JA
Initialisierung
Clients können über den
ApplicationContext
ApplicationContext zugreifen
Bereitstellung
Zerstörung
Zerstörung
destroy Methoden aufrufen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 41 >> total: 160 Seiten
NEIN
Spring 3 >> Java Framework >> Spring Container
verschiedene RessourceImplementierungen sind vorhanden
org.springframework.core.io.*
ResourceResource-Implementierung
ByteArrayResource
ClassPathResource
DescriptiveResource
FileSystemResource
InputStreamResource
UrlResource
Zweck
Ressource mit Bytearray definiert
Ressource mit Klassenpfad definiert
Ressource mit Beschreibung (keine lesbare) definiert
Ressource mit Informationen aus dem Dateisystem
definiert
Ressource mit Informationen aus einem Datenstrom
definiert
Ressource durch URL definiert
org.springframework.web.portlet.*
ResourceResource-Implementierung
PortletContextResource
ServletContextResource
Zweck
Ressource mit Portlet-Kontext definiert
Ressource mit Servlet-Kontext definiert
XML basierte Container Metadata Konfiguration
<bean id="..." class="...">

</bean>
<bean id="..." class="...">

</bean>

© 2011 >> Stephan Metzler >> V 2.1 >> Seite 42 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
Beispiel Container Instanziierung
- Lesen der Bean Definition aus XML-Datei aus Dateisystem
- Container verwendet Lazy Loading
- Factory lädt die Beschreibung der Bean
- Bean wird erst bei Bedarf instanziiert
einige Beispiele
BeanFactory factory = new XmlBeanFactory(
new FileSystemResource("c:/beans.xml"));
oder
Resource resource = new FileSystemResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
oder
ClassPathResource resource = new ClassPathResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
Übung Spring Factory
- Ergänzen Sie die testReadOnce() Methode in der ExampleServiceTests.java Klasse
- Starten Sie die Spring BeanFactory mit der Spring Konfigurationsdatei
public void testReadOnce() throws Exception {
ClassPathResource res = new ClassPathResource(
"META-INF/spring/app-context.xml");
BeanFactory factory = new XmlBeanFactory(res);
service = (ExampleService) factory.getBean("service");
assertEquals("Hello Spring", service.getMessage());
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 43 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
6.3
Anwendungskontext
Erweitert den Handlungs- / Einsatzbereich des Containers
- ermöglicht das Auflösen von Textnachrichten
- Anwendung: Internationalisierung
- universelle Möglichkeit, um Dateiressourcen zu laden
- Anwendung: Bilder
- können Ereignisse für Beans veröffentlichen
- Anwendung: Listener
- validieren von Inhalten
- Anwendung: Nachweis von Gültigkeit, Typ, Bereich, Sinn und Zweck, etc.
häufig verwendete Implementierungen des Applikations
Applikationsk
tionskontext
org.springframework.core.io.
ApplicationContextApplicationContext-Implementierung
ClassPathXmlApplicationContext
FileSystemXmlApplicationContext
XmlWebApplicationContext
Zweck
XML Datei im KlassenPfad
XML Datei aus File System
XML Datei aus WEB-Anwendung
Beispiel
- lesen des Applikationskontext
aus XML-Datei des Dateisystems
ApplicationContext context = new
FileSystemXmlApplicationContext("c:/application.xml");
Klassendiagramm
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 44 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
6.3.1
Zugriff auf Ressourcen
- der Applikationskontext bietet Unterstützung beim Lesen von Ressourcen
- Zugriff auf die Ressourcen über einen ResourceLoader
org.springframework.core.io.Resource
Methoden
getInputStream()
getFile()
6.3.2
Zweck
liefert InputStream der Ressourcen
liefert File der Ressourcen
Events des Applikationskontext
- der Applikationskontext implementiert das Observer Pattern
- Zusandsänderungen andere Spring Beans werden erkannt
org.springframework.core.io.ApplicationEventPulisher
Events
ContextRefreshEvent
ContextClosedEvent
ContextClosedEvent
RequestHandleEvent
Zweck
wenn der Applikationkontext neu geladen/erzeugt wird
wenn der Applikationkontext geschlossen wird
um den HTTP Request zu lesen
Übung Applikationskontext
- Ergänzen Sie die ExampleServiceTests.java Klasse
- testen Sie den ClassPathXmlApplicationContext
- testen Sie den FileSystemXmlApplicationContext
public void testApplicationContext() throws Exception {
ApplicationContext appContext =
new ClassPathXmlApplicationContext(
"META-INF/spring/app-context.xml");
service = (ExampleService) appContext.getBean("service");
assertEquals("Hello Spring", service.getMessage());
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 45 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
6.3.3
Internationalisierung
- bietet Codeunabhängigkeit für Benutzersprachen
- Java offeriert Locale (Kombination aus Sprache und Land en_US)
- Spring bietet einfache Schnittstelle MessageSource (als Konvention)
Suchschlüssel
appContext.getMessage("welcome",
new Object[] {"Spring"}, "Hello {0}", Locale.ENGLISH));
Stellvertreter
Default
Suchkriterium:
_de.properties
Argument
Übung Internationalisierung
- erstellen Sie entsprechende Propertydateien für Begrüssungstexte / Errortexte
► rescources/messages_de.properties ► Konvention
- ergänzen Sie die Springkonfiguration app-context.xml durch eine messageSource
- erstellen Sie entsprechende Testfunktionen
messages
messages_de.properties
welcome=Willkommen zu Spring
appapp-context.xml
<bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<property name="basenames">
<list>
<value>messages</value>
// 'messages_' + LOCALE + '.properties'
<value>errors</value>
// 'errors_' + LOCALE + '.properties'
</list>
</property>
</bean>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 46 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
6.4
Nachbearbeitung
Basis zu AOP (Aspekt Orientiertem Programmieren ) Weaving
- Spring stellt die Schnittstelle zur Verfügung BeanPostProcessor
- mit den Methoden
- postProcessBeforeInitialisation()
- postProcessAfterInitialisation()
- Beispiel RequiredAnnotationBeanPostProcessor
- prüft die Abhängigkeiten der Bean Exception
ÜBUNG Bean nachbearbeiten Abhängigkeiten prüfen
- ergänzen Sie die Setter Methode der Bean Property mit der @Required Annotation
und die Spring Bean Konfiguration durch das entsprechende Interface
<bean class="org.springframework.beans.factory.
annotation.RequiredAnnotationBeanPostProcessor"
/>
6.5
SpEL Spring Expression Langauge
EL erlaubt den Zugriff auf Variablen und definiert entsprechende Operatoren
- Auswerten von Ausdrücken zur Laufzeit
- Parameter berechnen lassen
- ermöglicht flexiblen Code
Syntax
#{bean}
// gibt das Objekt 'bean' zurück
#{bean.var}
// ist 'bean' ein Object wird das Attribut var gelesen
ist 'bean' eine Map oder Property wird der Wert zum
Key 'var' gelesen
#{1+3}
// wertet den Ausdruck aus
SpEL ermöglicht es,
es, dynamisch zu konfigurieren.
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 47 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
ÜBUNG SpEL
-
erweitern Sie die Attribute des ExampleService
- setzen Sie diese Attribute durch die Setter Injection
<property name="text" value="#{prop.text}" />
<property name="sprache" value="#{ systemProperties['user.language'] }" />
<property name="zahl" value="#{1+2}" />
- Propertry Objekt aus Property Datei erstellen
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd">
<util:properties id="prop" location="welcome.properties" />
- ergänzen Sie die Maven Dependencies
- Version 3.0.2.RELEASE (neuste Version)
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 48 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Container
F
Dependency Injection
Lerninhalte
Bean Ressourcen
Lebenszyklus
Namespace
Annotations
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 49 >> total: 160 Seiten
Spring 3 >> Java Framework >> Lebenszyklus
7
Lebenszyklus
- Bean (Lebenszyklus) wird durch BeanFactory-Container verwaltet
- ohne Referenz Garbage Collector
Spring Container Prozess
does not exist
DestroyDestroy-Methoden
Methoden
Disposa
DisposableBean.destroy()
bleBean.destroy()
exists
Client Prozess
Geschäftsfall
Spring Container
Container Prozess
1 BeanNameAware.setBeanName()
2 BeanFactoryAware.setBeanFacrory()
3 ResourceLoaderAware.setRescourceLoader()
4 ApplicationEventPublisherAware.
setApplicationEventPublisher()
5 MessageSourceAware.setMessageSource()
6 ApplicationContextAware.
setApplicationContext()
7 ServletContextAware.setServletContext()
8 BeanPostProcessor.
postProcessorBeforeInitialisation()
9 InitializigBean.afterPropertySet()
InitializigBean.afterPropertySet()
10 InitInit-Methoden
11 BeanPostProcessor.
afterProcessorBeforeInitialisation()
Spring Bean LifeCycle
Schritt Phase
1
2
3
4
5
6
7
8
9
10
11
Beschreibung
bekommt den eigenen Namen zur späteren
Referenzierung
bekommt eine Referenz auf die Bean Factory
Zufgriff auf die lädt Resourcen Bean Abhängigkeiten
Umgebung
kann Events verschicken vorgestellten Verfahren
kann internationalisierte Texte auslesen
bekommt Referenz auf den Applikationskontext
bekommt den Servletkontext referenziert
Bean verändern ruft die konfigurierten Post-Processoren auf
eigene
Abhängigkeiten überprüfen
Initialisierung
init Methode wird aufgerufen
ruft die konfigurierten Post-Processoren zur
Bean verändern
Nachbearbeitung auf
Bean ist einsatzbereit für die Anwendung
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 50 >> total: 160 Seiten
Spring 3 >> Java Framework >> Lebenszyklus
8
Bean Ressourcen definieren
- Laden von externen Bean Definitionen durch die XML Konfiguration
<beans>
<import resource="services.xml"/>
<import resource="resources/messageSource.xml"/>
<import resource="resources/themeSource.xml"/>
<bean id="bean1" class="..."/>
<bean id="bean2" class="..."/>
</beans>
- Laden von externen Bean Definitionen durch Annotation @Resource
- nur auf Attributen und set-Methoden
@Resource // inject bean named 'dataSource'
private DataSource dataSource;
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 51 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
8.1
Dependency Injection per XML
durch Dependency Injection
- Abhängigkeiten werden einem Objekt injiziert
- Objekte
- Datenquellen
- ein Objekt muss das abhängige Objekt nicht selbst erzeugen
- durch JNDI Referenz
- durch Referenzieren
- durch Instanziieren aus Factory
- Abhängigkeiten werden durch den Lebenszyklus beeinflusst
<bean id="lesen"
class="Lesen"
depends-on="schreiben" />
<bean id="schreiben"
class="Schreiben" />
8.1.1
Setter Injection
- Setter basierte DI
- Spring instanziert Bean mit Hilfe der Settermethode
- Settermethode muss existieren
public class SimpleMovieLister {
// the SimpleMovieLister has a dependency on the MovieFinder
private MovieFinder movieFinder;
// a setter method so that the Spring container can 'inject'
// a MovieFinder
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
// business logic that actually 'uses' the injected MovieFinder
// is omitted...
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 52 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
8.1.2
Konstruktor Injection
- Konstrukter basierte DI
- Spring instanziert Bean mit Hilfe des Konstruktors
- Konstruktor mit entsprechender Signature muss existieren
public class SimpleMovieLister {
// the SimpleMovieLister has a dependency on the MovieFinder
private MovieFinder movieFinder;
// Spring container can 'inject' a MovieFinder
public SimpleMovieLister(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
// business logic 'uses' the injected MovieFinder is omitted...
}
8.1.3
Konstruktor vs. Setter Dependency Injection
Pro Konstruktor DI
- Konstruktorinjektion erzwingt starke Abhängigkeitsregeln
- Bean kann nicht instanziiert werden, ohne all ihre Abhängigkeiten zu erhalten
- Änderungsmethoden sind nicht erforderlich, da Abhängigkeiten über Konstruktor
festgelegt
- versehentliche Modifikationen des Konstruktors wird ausgeschlossen
Pro Setter DI
-
Parameterliste des Konstruktors kann recht umfangreich werden
eindeutige Konstruktoren zu formulieren kann schwierig sein
mehrere Parameter desselben Typs macht (Zweck-) Unterscheidung schwerer
Konstruktorinjektion ist zur Vererbung eher ungeeignet
Parameter an super() übergeben
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 53 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
Beispiel www.springsource
www.springsource.org
source.org
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) {
<bean id="exampleBean" class="examples.ExampleBean">
this.i = i;

}
public void doSomething() { <property name="beanOne">
this.beanOne.doSomething(); <ref bean="anotherExampleBean"/>
</property>
}

}
<property name="beanTwo" ref="yetAnotherBean"/>
<property name="integerProperty" value="1"/>
</bean>
<bean id="anotherExampleBean"
class="examples.AnotherBean"/>
<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
8.1.4
Collections
- Injection von Abhängigkeiten über Collections
- Best Praxis ► Collection der MVC oder O/R Implementation verwenden
Collection
Element
<list>
<set>
<map>
<props>
Package
java.util.List
java.util.Set
java.util.Map
java.util.Properties
Verwendung
Liste von (auch duplikaten) Werten
Liste von duplikatfreien Werten
beliebige Namen-Werte-Paare
String Namen-Werte-Paare
Beispiel mit <list> Collection
public class ExampleBean {
private Collection<Instrument> instruments;
public void setInstruments(
Collection<Instrument> instruments) {
this.instruments = instruments;
}
}
<bean id="exampleBean"
class="examples.ExampleBean">
<property name="instruments">
<list>
<ref bean="guitar"/>
<ref bean="violin"/>
<ref bean="piano"/>
</list>
</property>
</bean>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 54 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
Beispiel mit <map> Collection
public class ExampleBean {
private Map<String, Instrument> instruments;
public void setInstruments(Map<String, Instrument> instruments) {
this.instruments = instruments;
}
}
<bean id="exampleBean" class="examples.ExampleBean">
<property name="instruments">
<map>
<entry key="Gitarre" value-ref="guitar"/>
<entry key="Geige" value-ref="violin"/>
<entry key="Klavier" value-ref="piano"/>
</map>
</property>
</bean>
8.1.5
Leerer Inhalt als Property zuweisen
- Eigenschaft auf NULL setzen
- mit DI zuweisen
- als NULL Referenzierung
Beispiel mit <null> Referenzierung
<property name="instruments"> <null> </property>
► null ist als Tag definiert
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 55 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
8.1.6
Autowiring
- Beanelemente <bean> automatisch zuweisen
- durch Spring Container
Autowiring
Typ
byName
byType
Beschreibung
Übereinstimmung von ID
oder Name der Eigenschaft
oder Bean-Eigenschaft bleibt leer
Übereinstimmung des Typs der Eigenschaft
oder Bean-Eigenschaft bleibt leer
oder Exception bei mehrfachem Aufkommen
org.springframework.beans.factory.UnsatisfiedDependencyException
gesucht wird eine identische Signature der Konstruktoren
constructor oder Exception bei keiner Eindeutigkeit
org.springframework.beans.factory.UnsatisfiedDependencyException
autodetect
8.1.7
-
gesucht wird nach constructor dann nach byType
Init- und Destory-Methoden
init- und destroy-Methoden festlegen
um Bean nach ihrer Erzeugung zu initialisieren
wenn Bean vor ihrer Zerstörung noch Aktionen vorzunehmen hat
optional und einzeln einsetzbar
Beispiel
public class ExampleBean {
<bean id="exampleBean"
class="examples.ExampleBean"
init-method="init"
destroy-method="cleanup"/>
public void init() {
...
}
public void cleanup() {
...
}
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 56 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
8.1.8
Geltungsbereich für Beans
- steuert, wie viele Instanzen einer Bean erstellt werden
singletonsingleton-Beans
- durch Spring erzeugte Beans werden als statische Objekte behandelt
- als Eigenschaft anderen Beans als eine Instanz (Singleton) erzeugt und zugewiesen
- und an jeder Stelle, wo die Bean referenziert wird, verwendet
- eine Bean Instanz wird erzeugt
- als gemeinsame Instanz allen referenzierten Objekten injiziert
prototyperototype-Beans
- durch Spring erzeugte Beans
- als Eigenschaft anderen Beans zugewiesen
- und als eigene Instanz erzeugt
- für jede Referenzierung wird eine neue Bean Instanz erzeugt
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 57 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
Geltungsbereich für Beans
scope
Geltungsbereich
Beschreibung
singleton
Bean wird nur einmal erzeugt und bei jeder Referenz die gleiche
Bean verwendet (Default)
prototype
bei jeder Referenz wird eine neue Instanz der Bean erzeugt und
verwendet
request
für jeden Request (Web-Kontext) wird eine neue Instanz erzeugt
session
für jede Session (Web-Kontext) wird eine neue Instanz erzeugt
globalSession
für jede Global HTTP Session (Portlet-Kontext) wird eine Bean
erzeugt
8.1.9
Attribute der Beandefinition
<bean> Tag
Name
Beschreibung
class
id
name
scope
lazylazy-init
initinit-method
destroydestroy-method
dependencydependency-check
autowiring
autowireautowire-candidate
factoryfactory-bean
factoryfactory-method
abstract
parent
vollqualifizierter Klassenname zur Instanziierung
Zeichenfolge zum Referenzieren auf Bean oder Klassennamen als ID
als Alias auch mehrere; durch Strichpunkt getrennt
definiert den Geltungsbereich der Bean
lazy = träge, lädt die Bean erst bei der ersten Anfrage
Initialisierungs-Methode, die nach dem Laden aufgerufen wird
Destroy-Methode, die in der Zerstörungsphase aufgerufen wird
überprüft, ob alle Bean-Abhängigkeiten korrekt aufgelöst wurden
konfiguriert das automatische Verknüpfen
definiert autowiring Modus für die Bean
definiert Factory Bean für das Erstellen der Bean
definiert Factory Methode für das Erstellen der Bean
definiert Bean als abstract
definiert parent Bean für das Erstellen der Bean
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 58 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
8.2
Context Namespace
- erlaubt Applikationcontext spezifische Konfigurationen
- Unterstüzung für Annotationen
- verwalten von Domänenobjekten
Context Namespace
Name
<context:annotationcontext:annotation-config>
<context:component<context:component-scan>
<context:exclude
<context:excludetext:exclude-filter>
<context:include<context:include-filter>
<context:load<context:load-timetime-weaver>
<context:mbean<context:mbean-export>
export>
<context:mbean<context:mbean-server>
<context:property<context:property-placeholder>
<context:spring<context:spring-configured>
8.3
Beschreibung
erlaubt Annationen basierte Konfiguration in Spring Beans
scannt und registriert Packages nach Beans
schliesst Klasse von der Registrierung als Springbean aus
schliesst Klasse in der Registrierung als Sprinbean ein
registriert einen AspectJ load-time weaver
exportiert Bean als JMX MBean (Jave Management Extension)
startet ein MBean (Server Aufgabe) im Sringcontext
ermöglicht externe Konfiguration per Propertydatei
ermöglicht Dependenci Injection in Nicht-Spring-Verwaltete
Objekte
Util Namespace
- erlaubt Applikationcontext spezifische Typen
- Unterstüzung von Collections
- Unterstüzung von Nicht-Spring Objekte
Util Namespace
Name
Beschreibung
<util:constant>
<util:list>
<util:map>
<util:properties>
<util:set>
<util:property<util:property-path>
registriert ein static Feld als Typ, stellt dessen Wert als Bean zur Verfügung
macht eine Liste von Werten oder Referenzen als Spring Bean bekannt
macht eine Map als Spring Bean bekannt
erzeugt eine java.util.Property als Spring Bean von einer Propertydatei
macht ein Set als Spring Bean bekannt
referenziert eine Bean Property und stellt diese als Spring Bean zur Verfügung
- <util:constant> erzeugt eine Referenz zur Konstante MY_CONST der Klasse MyClass
<util:constant id=”myconst” static-field=”MyClass.MY_CONST” />
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 59 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
ÜBUNG Dependency Injection per XML
- erstellen Sie Spring Beans wie folgt
- testen Sie die XML Attribute der Dependency Injection
public class Bean1 {
private Bean2 bean2;
private float property;
private Logger logger = Logger.getLogger("spring");
public Bean1() {
logger.info("Bean1 Konstruktor");
}
// getter und setter analog
}
Lösungsansatz:
<bean id="bean2"
class="module.spring.di.xml.Bean2"
scope="prototype"
init-method="init"
destroy-method="destroy">
<property name="message">
<value>Hallo Spring</value>
</property>
</bean>
public class Bean2 {
private String message;
// Konstruktor, getter und setter analog
8.4
Dependency Injection per Annotation
- als Alternative zu XML
8.4.1
Context Configuration Annotation
- benötigt <context:annotation-config /> in der Spring Konfiguration
Context Configuration Annotation
Annotation
Einsatz Beschreibung
@Autowired
@Configurable
@Order
@Qualifier
@Rescource
@Required
@Scope
@Value
K F M entspricht autowire="byType", muss nicht public sein
CT
TMF
FPTA
FM
M
T
FM
für Domänenobjekte die nicht durch Spring erzeugt wurden
im Zusammenhang mit <context:annotation-config />
Sortiermöglichkeit
für Autowiring zusätzlich zu "byType", sucht auch nach dem Qualifier
für Autowiring zusätzlich zu "byType", sucht auch nach der Ressource
erzwingt Abhängigkeit
definiert den Scope
für Autowiring zusätzlich zu "byType", sucht auch nach dem EL-Ausdruck
A = Annotationtype, C = Klasse, F = Field, K = Konstruktor, M = Setter, P = Parameter,
Parameter, T = Typ
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 60 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
ÜBUNG Dependency Injection per Annotation Context Configuration
- erstellen Sie Spring Bean ConfigImpl und das entsprechende Interface Config
public class ConfigImpl implements Config {
private Map<String, String> prefs = new HashMap<String, String>();
public String getValue(String key) {
return this.prefs.get(key);
}
public void setValue(String key, String value) {
this.prefs.put(key, value);
}
}
- erstellen Sie einen Write- und einen ReadController
- testen Sie die Annotation, z.B. @Autowired durch entsprechende ControllerTests
public class WriteController {
@Autowired private Config config;
// Config-Objekt wird von Spring injiziert
public WriteController() {}
public void write(String key, String value) { this.config.setValue(key, value); }
}
8.4.2
Stereotyping Annotations
- Klassen werden als Spring Beans erkannt und konfiguriert
- reduziert die XML Konfiguration
- benötigt <context:component-scan base-package=”…” /> in der Spring Konfiguration
Stereotyping Annotations
Annotation
Einsatz Beschreibung
@Component
@Controller
@Repository
@Service
Type
Type
Type
Type
generische durch Spring kontrollierte Komponente
stereotypisiert Komponenten als Spring MVC Kontroller
deklariert Klasse als Repository / transferiert SQL- zu DataAccessExceptions
stereotypisiert Komponenten als Service
Selbstdefinierte @Component Annotation
@Target( { ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface MyComponent { String value() default ""; }
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 61 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
ÜBUNG Dependency Injection per Annotation Stereotyping
- verwenden Sie die @MyComponent Annotation, um die Kontroller Spring zu übergeben
@MyComponent("reader")
public class ReadController {
@Autowired
private Config config;
- analog die ConfigImpl
@MyComponent("config")
public class ConfigImpl implements Config {
- und entsprechende Tests
wc = (WriteController) ac.getBean("writer");
rc = (ReadController) ac.getBean("reader");
ci = (ConfigImpl) ac.getBean("config");
wc.write("Hallo","Spring");
assertEquals("ConfigImpl.getValue", "Spring", rc.read("Hallo"));
8.5
XML vs. Annotaions Dependency Injection
Spring offeriert zwei unterschiedliche Ansätze zur Konfiguration der Beans
- XML
- Komplexität durch verschiedene Versionen
- Annotationen
- ergänzt durch XML Basis Konfiguration
Pro XML Dependency Inj
Injection
- Konfiguration ausserhalb der Domänenlogik
- bereits existierenden Klassen müssen nicht angepasst / erweitert werden
- Klassen bleiben unabhängig von Spring
Pro Annotation Dependency Injection
- Abhängigkeiten sind im Code ersichtlich
- kein XML notwendig
- keine überladene, unübersichtliche XML Konfiguration
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 62 >> total: 160 Seiten
Spring 3 >> Java Framework >> Bean Ressourcen definieren
G
Spring AOP
Lerninhalte
Begriffe
Spring AOP
Framework
Annotations
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 63 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
9
Aspektorientiertes
Aspektorientiertes Programmieren
- Aspektorientierung kapselt sich wiederholende Aufgaben
- Aufgabe einmal programmiert
- an mehreren Stellen ausgeführt
- AOP trennt Businesslogik von Services
- Logging
- Transaktions-Management
- Sicherheits-Managment
- AOP verwaltet zentrale Aufgaben wiederverwendbar
- Datenbank-Zugriffe
- Caching
- Authentisierung
Crossross-Cutting Concern
- querschnittliche Belange einer Software
- erlauben keine Modularisierung
► AOP bietet Lösungsansatz
9.1
Begriffe des AOP
- Advice
- Cross-Cutting Concern
- Softwarecode, der zur Ausführung kommt
- Logging
- Transaktionsmanagement
- JoinPoint
- PointCut
Advice
JoinPoints
- eingrenzendes Muster vorhandener JoinPoints
- als Klassenfilter und Methodenmatcher
- definierte Use Cases
- ServiceMethoden
Use Case
- DAO Funktionalitäten
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 64 >> total: 160 Seiten
PointCut
- impliziert gegebene Ausführungspunkte für Advise
- vor Methodenaufruf
- nach Methodenaufruf
- bei Exception
- etc.
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
Begriffe in der Aspektorientierten Programmierung
AOP
Begriff
Beschreibung
Aspect
Aufgabe, die an verschiedenen Stellen im Programm benötigt wird, z.B. Logging
Joinpoint
Punkt im Programmfluss, an dem der Aspect eingreift
(z.B. Methoden, Exceptions, etc. Spring erlaubt nur Methoden als Joinpoints)
Advice
Aktion eines Aspekts am Joinpoint, also der Aspect, der am Joinpoint ausgeführt wird
Pointcut
Muster, das den Aspect eingrenzt (als Klassenfilter und Methodenmatcher)
Target
Objekt, das Joinpoints zur Verfügung steht (z.B. Parameter der Signature)
Proxy
Proxy-Objekt wird aus dem Target erstellt
Weaving
Weaving beschreibt den Vorgang, aus Targets Proxys zu erstellen
- beim Kompilieren (statisches AOP)
- zur Laufzeit (dynamisches AOP)
Introduction
ermöglicht einem Target zusätzlich (dynamische) Funktionalität
z.B. erkennt das Interface Modifiable Änderungen innerhalb des Targets
9.2
Spring AOP
Definieren von AOP per:
- @AspectJ
- Spring XML
- Spring Annotations
Weaving
- Weaving wird bei Spring zur Laufzeit durchgeführt
- verwendet Ansatz des dynamischen AOP
- im Gegensatz zu statischem AOP wie beim AspectJ
- AspectJ ist eine Spracherweiterung, die der Javasyntax Befehle hinzufügt
- AspectJ hat seinen eigenen Compiler
- Advices sind damit (statisch) im Java-Bytecode des AspectJ-Compilers enthalten
Dynamisches AOP (weaving zur Laufzeit) hat grundsätzlich schlechtere
Performance gegenüber statischem AOP (weaving zur Compilezeit), bietet
jedoch mehr Flexibilität.
Flexibilität.
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 65 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
9.3
Spring AOP Framework
- bietet zahlreiche Vorteile
- ist in dem IoC-Container integriert
- kann als Library leicht in jede Applikation eingebunden werden
- Maven org.springframework : spring-aop : ${spring.framework.version}
aspectj : aspectjrt : 1.5.4
aspectj : aspectjweaver : 1.5.4
- enthält bereits vorgefertigte Aspekte
- z.B. Transaktionsverhalten
- ist unabhängig vom verwendeten Compiler und Classloader
- kann leicht zwischen Applikationsservern portiert werden
- implementiert Interfaces der AOP-Alliance
- dadurch entsprechende Unabhängigkeit
Ablauf
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 66 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
9.3.1
Aspect
- kann in Spring eine normale Java-Klasse (Spring Bean) sein
- wird mit dem XML-Element <aop:aspect/> definiert und referenziert eine Bean
- referenzierte Bean stellt die Implementierung der Funktionalität dar
- referenzierte Bean ist ein Cross-Cutting Concern
- Logging, Transaktions-Management, Security, etc.
- Spring stellt Aspekte für deklarative Enterprise Services bereit
- deklaratives Transaktions-Management
- Definition eigener Aspekte
- Geschäftsprozess abfangen, überwachen, manipulieren, etc.
<aop:config>
<aop:aspect id="myAspect" ref="aBean">
...
</aop:aspect>
</aop:config>
<bean id="aBean" class="..."/>
9.3.2
Joinpoint
Ein Joinpoint ist eine Stelle im Programm, an der ein Aspect eingesetzt wird.
- ein Joinponit fügt der Anwendung neues Verhalten hinzu
- neue Methode wird aufgerufen
- Exception-Handling
- ändern einer Klassenvariable
Spring AOP stellt
stellt nur
nur Methoden als Joinpoints zur Ausführung.
Ausführung.
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 67 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
9.3.3
Advice
Advices werden an Joinpoints der Anwendung hinzugefügt.
- Advice sagt, an welcher Stelle ein Aspect an einem Joinpoint was tun soll
- verschiedene Advice-Typen sind möglich
Advice in Spring
Advice
Beschreibung
AfterReturningAdvice
Aspect nach Ausführung der Methode (wenn keine Exception geworfen
wird)
MethodBeforeAdvice
Aspect vor Ausführung der Methode (wenn Aspect keine Exception wirft)
MethodInterceptor
Aspect vor und nach dem Methodenaufruf
ThrowsAdvice
Aspect nach einer Exception
Klassenhie
Klassenhierarchie
9.3.4
Pointcut
bestimmt, an welchen Joinpoints ein Advice hinzugefügt wird
- ein Advice ist mit einen Pointcut verbunden
- ein Advice wird an jedem Joinpoint ausgeführt, der dem Pointcut-Ausdruck entspricht
- ein Pointcut kann innerhalb eines Aspektes definiert werden und steht dann nur für diesen zur
Verfügung
Um Joinpoints in einem Pointcut zu beschreiben, benutzt Spring die
AspectJ Pointcut Language http://www.eclipse.org/aspectj
<aop:config>
<aop:aspect id="myAspect" ref="aBean">
<aop:pointcut id="businessService"
expression="execution(* *.perform(..))"/>
...
</aop:aspect>
</aop:config>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 68 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
AspectJ Pointcuts
für jedes Packages für jede Klasse
Methode perform()
execution(* *.*.perform(..))
Ausführungs-Muster
bei jedem
Rückgabetyp
mit beliebigen Typen
und Parametern ..
Klassendiagramm
9.3.5
Advice definieren
- Spring definiert AOP Namespace
- erlaubt, Aspekte, Pointcuts und Advices
in einem Spring Kontext zu definieren
- gibt auch Unterstüzung
für @AspectJ Annotationen
Spring definiert folgende Arten von Advices
- bestimmen, wie der Advice ausgeführt wird
AOP Namespace
Begriff
Beschreibung
<aop:before
<aop:before>
before>
Advice wird vor dem PointCut ausgeführt
<aop:after
<aop:after>
after>
Advice wird nach dem PointCut ausgeführt
<aop:after<aop:after-returning> Advice wird nach dem PointCut ausgeführt (ohne Exception)
<aop:after
<aop:afterafter-throwing>
throwing> Advice wird ausgeführt, wenn der Pointcut eine Exception wirft
<aop:around
<aop:around>
around>
Advice wrapt den Pointcut
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 69 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
weitere Elemente im AOP Namespace
Begriff
Beschreibung
<aop:advisor>
definiert einen AOP Advise
<aop:aspect>
definiert einen AOP Aspect
<aop:aspect<aop:aspectautoproxy>
erlaubt Aspektdeklaration mittels AspectJ
<aop:config>
das parent Element im AOP Namespace
<aop:declare<aop:declare-parents>
definiert eine AOP Introduction AOP Funktionalität ergänzen
<aop:include>
definiert optionale AspectJ Proxys
<aop:pointcut>
deklariert einen Pointcut um einen Advice hinzuzufügen
Beispiel
<aop:config>
<aop:pointcut id=”myPointcut” expression=”execution(* *.*service(..))" />
<aop:aspect ref=”myAspect”>
<aop:before pointcut-ref=”myPointcut” method=”invokeBefore” />
</aop:aspect>
</aop:config>
Advice mit einem Pointcut verbinden
<aop:aspect id="aroundExample" ref="aBean">
<aop:after-throwing method="trace"
throwing="ex"
pointcut="execution(void test.Process.doIt(bo.VO))" />
</aop:aspect>
<aop:aspect id="aroundExample" ref="aBean">
<aop:pointcut id="service" expression="execution(* *.do*(..))" />
<aop:around pointcut-ref="service" method="invoke"/>
</aop:aspect>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 70 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
mögliche Implementation der invoke Methode
public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
// vor dem Methodenaufruf
Object retVal = invocation.proceed();
// nach dem Methodenaufruf
return retVal;
}
oder
public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
Object[] args = invocation.getArgs();
try {
rval = invocation.proceed();
} catch (Throwable t) {
throw t;
} finally {
return rval;
}
// (Client-) Parameter auslesen
// Target aufrufen
// Exceptions loggen / weitergeben
}
ÜBUNG AOP per XML
- erstellen Sie eine Fassaden- und eine Serviceklasse
- implementieren Sie eine Interceptorklasse
- konfigurieren und testen Sie die Beans
<bean id="myService" class="module.spring.aop.MyService" />
<bean id="myFacade" class="module.spring.aop.MyFacade" />
<bean id="myAspect" class="module.spring.aop.Interceptor" />
<aop:config>
<aop:aspect ref="myAspect">
<aop:pointcut id="publicFacade"
expression="execution(* module.spring.aop.*Facade.do*(..))" />
<aop:pointcut id="serviceMethods" expression="execution(* *.do*(..))" />
<aop:before method="logBefore" pointcut-ref="publicFacade" />
<aop:after method="logAfter" pointcut-ref="publicFacade" />
<aop:around method="invoke" pointcut-ref="serviceMethods" />
</aop:aspect>
</aop:config>
<aop:aspectj-autoproxy />
- benötigt CGLIB zur dynamischen Kapselung von Klassen
- Maven cglib : cglib-nodep : 2.1_3
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 71 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
9.4
AOP per Annotation
- Spring unterstützt AspectJ Annotations
AOP Annotations
Annotation
Einsatz
Beschreibung
@Aspect
@After
@AfterReturning
Type
Method
Method
deklariert eine Klasse als Aspect
@AfterThrowing
Method
deklariert die Methode für einen Pointcut, der eine Exception wirft
@Around
Method
deklariert die Methode, um einen Pointcut zu umschliessen
@Before
Method
deklariert die Methode vor einem Pointcut
@DeclareParent
s
@Pointcut
deklariert die Methode nach einem Pointcut
deklariert die Methode für einen erfolgreichen Pointcut
Static Field deklariert Parent Objekt für Introductions zusätzliche
Funktionalität
Method
deklariert einen leeren Methoden-Body als Pointcut Platzhalter
ÜBUNG AOP per Annotation
- modifizieren Sie die AOP Übung
- eliminieren Sie die XML Deklarationen
- ergänzen Sie eine Pointcut Methode und annotieren Sie die Advices
- annotieren Sie die Interceptorklasse als Aspect
@Aspect
public class Interceptor {
@Pointcut("execution(* module.spring.aop.*.*(..))")
public void debugPointcut() {
}
@Before("debugPointcut()")
public void logBefore() {
}
@After("debugPointcut()")
public void logAfter() {
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 72 >> total: 160 Seiten
Spring 3 >> Java Framework >> Aspektorientiertes Programmieren
H
Testen
Lerninhalte
Testarten
TDD TestDrivenDevelopment
Unit Testing
Mock Objekte
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 73 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
10
Testen
wiki
Ein Softwaretest
Softwaretest ist ein Test während der Softwareentwicklung,
Softwareentwicklung, um die
Funktionalität einer Software an den Anforderungen und ihre Qualität zu messen
und Softwarefehler zu ermitteln.
10.1
Testarten
- Unit-Test
- Units sind einzelne Objekte
- isoliertes Verhalten wird getestet
- Integrationstest
- mehrere Objekte bilden ein Workflow
- deren Interaktion wird getestet
- Lasttest
- Skalierbarkeit des Workflows
- grosse Anzahl von Requests wird getestet
- Akzeptanztest
- Anforderungen an die Applikation
- Grundlage zur Abnahme
Testverfahren
die Praxis beschreibt eine Kombination von Testverfahren
- ZIEL: aussagekräftiges Ergebnis
-
Review – prüft das Ergebnis (Ziel)
Audit – prüft die Vorgehensweise und den Ablauf (Weg ins Ziel)
BlackBlack-BoxBox-Test – prüft definierte Schnittstellen (Funktionalität)
WhiteWhite-Box-Test – prüft die Details der Logik (Codereview)
- Durchführung
- Testprotokoll (wer, wozu, wie, was wird getestet)
- Programm (Test-Case beschreibt Testfall)
die Praxis verlangt Automatisierung der Testverfahren
wiki
iki
Vor allem bei testgetriebener Entwicklung
Entwicklung ist die Testautomatisierung besonders
wichtig. Tests werden im Idealfall nach jeder Änderung ausgeführt. Bei nicht
automatisierten Tests ist der Aufwand so gross, dass häufig auf die Tests
verzichtet wird.
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 74 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
10.2
funktional vs. nicht-funktional
funktionale Tests
Tests
► Benutzeranforderungen
- gemäss Anforderungen
- was macht das Programm
- beschrieben durch Use Case
nichtnicht-funktionale Tests
► Qualitätsanforderungen
- Integration
- Zusammenarbeit der einzelnen Teile,
z.B. Server, DB, etc.
- Belastung
- Multi-User Verhalten
- Akzeptanz
- Kunde, Benutzer, etc.
Softwaretests steigern Qualität der Software
eXtreme Programming
- alternativer Ansatz
- senkt Softwareentwicklungskosten
- orientiert an Bedürfnissen der Kunden
Der Kunde bekommt das,
was er braucht,
und dann,
wenn er es braucht.
- xP baut auf
- Kommunikation ►Auftraggeber
- Einfachheit ► klare Schnittstellen
- Feedback ► Testen (TDD)
- Courage
►
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 75 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
10.3
Test Driven Development
TDD ist Aspekt von Extreme Programming
- einfache Entwicklung in der Erstellung von Software
- komplexe Softwaresysteme in kleinen und einfachen Schritten entstehen lassen
-
Tests des Designs und der Implementierung stehen im Vordergrund
definiert Test, der die Funktion eines kleinen Teils des Systems beschreibt
Treffen von Design-Entscheidungen sind nicht in der Startphase erforderlich
Code muss nicht von Anfang an richtig sein, dieser wird kontinuierlich refaktoriert
- Ausführung mit Hilfe von (Software)-Tools
- z.B: JUnit (http://junit.org/) meist verbreitet
- durch Assertion (Engl: Aussage, Behauptung)
- asserts(), assertNotNull(), assertEquals(), etc.
// SYNTAX : Assertion
< Assertion> ( <testen> <Kriterium> <gegeben> )
// Beispiel
assert( 1 + 2 == 3 )
gegeben : 3
Kriterium : EQUALS
testen : 1 + 2
TDD Konzept definiert Unittests und Refaktorierungen
- erstellen (Logik schreiben)
- Test beschreibt, wie sich ein kleiner Teil der Software
(Unit) verhalten soll
- testen (erfolgreiche Tests definieren)
- Design des Codes ist zweitrangig
- wichtig, dass der Test erfolgreich läuft
- aufräumen (schöneren Code schreiben)
- mittels Refaktorierung (Umorganisation)
überarbeiten, bis der Test wieder fehlerfrei läuft
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 76 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
10.4
wiki
JUnit
JUnit ist ein Framework zum Testen von JavaJava-Programmen, das besonders für
automatisierte UnitUnit-Tests einzelner Units (meist Klassen oder Methoden)
Methoden) geeignet
ist. Es basiert auf Konzepten, die ursprünglich unter dem Namen SUnit für
Smalltalk entwickelt
entwickelt wurden.
ist Framework ► www.junit.org
- unterstützt das Testen von Programmen
- ein einfacher Test definiert
public class BasicTest extends TestCase {
public void setUp() { ... }
public void testFirstThing() {
assert...(...);
}
public void testSecondThing() {
assert...(...);
}
public void tearDown() { ... }
}
Aufbau
- die Methode setUp() initialisiert den Testcase
- die Test-Methoden (Testcase) fangen mit test an
- testFristThing()
- testSecondThing()
- die Methode tearDown() finalisiert den TestCase
- Assertions überprüfen die Test-Methoden
- Erfüllen von Anforderungen
- Einhalten von Bedingungen
- Exceptions sollten nicht gefangen (catch) werden
- Test-Methoden Exceptions soll Exception werfen
- JUnit-Framework kann dann passend darauf reagieren
- Ausführen von Tests
- Testklasse in Eclipse ausführen ► Run As ►JUnit Test
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 77 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
10.5
wik
Mock Testing
MockMock-Objekte werden in der testgetriebenen Softwareentwicklung DummyDummyObjekte oder Attrappen genannt, die als Platzhalter für echte Objekte innerhalb
von UnitUnit-Tests verwendet werden.
isoliertes Testen ist oft nicht möglich
- Interaktion eines Objektes mit dessen Umgebung muss überprüft werden
- Umgebung nicht vorhanden
- oder sehr zeitaufwändig
- Mock-Objekte implementieren Schnittstelle
- Mock-Objekt liefert keine Echtdaten
- nur festgelegte Testdaten
- sinnvolle Mock-Objekte
- Objekt liefert keine deterministische Ergebnisse
- z. B. aktuelle Uhrzeit, aktuelle Temperatur
- Objekt basiert nicht auf Interaktion
- z. B. Testen von Benutzungsoberflächen
Ablauf
- Mock Objekt eines Interfaces bzw. einer zu simulierenden Klasse erzeugen
- erwartetes Verhalten aufzeichnen
- auf Wiedergabe umstellen (replay)
- Ablauf Verifizieren (verify)
@Test
public void testErfolgreicheBestellung() throws Exception {
EasyMock.expect(kundeDAOMock.getByID(42)).andReturn(kunde);
Kunde kundeNeu = new Kunde("Eberhard", "Wolff", 22.0);
kundeNeu.setId(42);
kundeDAOMock.update(kundeNeu);
initWareMock();
EasyMock.expect(bestellungDAOMock.save(isA(Bestellung.class)))
.andReturn(new Bestellung());
EasyMock.replay(kundeDAOMock, wareDAOMock, bestellungDAOMock);
Einkaufswagen einkaufswagen = new Einkaufswagen(kunde.getId());
einkaufswagen.add(ware.getId(), 1);
bestellung.bestellen(einkaufswagen);
EasyMock.verify(kundeDAOMock, wareDAOMock, bestellungDAOMock);
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 78 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
10.6
UnitTests mit Spring
Spring bietet den Vorteil der Abstraktion
- stellt Schnittstellen zur Integration zur Verfügung
- benötigt ein Framework zum Testen JUnit
- Klasse mit @Test annotierter Methode wird als Testklasse interpretiert
- @Before annotierte Methoden bieten Möglichkeit zum Einrichten des Tests
- @After annotierte Methoden bieten Möglichkeit zum Aufräumen nach dem Test
Ziel: jede Klasse in Isolation testen TD
TDD
In der Praxis lassen sich Klassen oft nicht isoliert testen
Lösungsansätze
Begriff
Beschreibung
Stub
fragmentale Implementierung als Stellvertreter
Dummy
Ersatzklasse, um das Verhalten zu testen
Mock
dynamisches Dummy (konfigurierbar)
10.7
wiki
Mocks
MockMock-Objekte werden in der Testgetriebenen Softwareentwicklung DummyDummyObjekte oder Attrappen genannt, die als Platzhalter
Platzhalter für echte Objekte innerhalb
von Unit
Unit-Tests verwendet werden.
- dem zu testenden Objekt wird ein Stellvertreter (Mock) zugewiesen
- einfaches Szenario mit Spring
- Spring verwendet Setter Methode
- referenzierte Objekte lassen sich einfach ersetzen
Vorteile
Vorteile
- einzelne Klassen können isoliert getestet werden
- alle referenzierten Klassen werden durch Mocks ersetzt
- Tests sind performant
- keine Datenbanken notwendig
- keine Verteilten Ressourcen notwendig
- Fehler können leicht provoziert werden
- z.B. HostNotFoundException
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 79 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
10.8
-
Integrationstest
@RunWith Annotation erlaubt das Erkennen der Abhängigkeiten z.B. @Autowired
@ContextConfiguration definiert Spring Konfiguration
@Transactional definiert, dass Test in einer Transaktion läuft
@Test(expected= …) definiert das Mockverhalten
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("META-INF/spring/app-context.xml")
@Transactional
public class IntegrationTests {
@Autowired private Service service;
@Test public void testSimpleProperties() throws Exception {
assertNotNull(service);
}
@Test(expected = PropertyException.class)
public void testPropertyException() throws PropertyException {
}
}
transiente Daten
- Spring bietet einfache Konfiguration für Speicher-Datenbank (InMemoryDatenBank)
- erzeugt eine HSQL-Datenbank
- auch H2 und Derby unterstützt
- führt init.sql aus auch classpath:init.sql
<jdbc:embedded-database id="dataSource" type="HSQL">
<jdbc:script location="init.sql" />
</jdbc:embedded-database>
wiki
HSQL ist eine freie vollständig in Java programmierte
programmierte relationale SQLSQL-Datenbank
(RDBMS)
RDBMS) und steht unter einer freien Lizenz nach dem Muster der BSDBSD-Lizenz.
Lizenz.
- bereits bestehende DataSource anbinden
<jdbc:initialize-database data-source="dataSource">
<jdbc:script location="init.sql" />
</jdbc:initialize-database>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 80 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
10.9
Funktionale Tests
- in der Paxis etablieren sich Werkzeuge
- Fit (Framework for Integrated Test) http://fit.c2.com/
- Bedingungen als HTML
- FitNesse http://www.fitnesse.org/
- Bedingungen in wiki
- Testbedingungen werden formuliert und die Resultate auf einem Browser ausgegeben
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 81 >> total: 160 Seiten
Spring 3 >> Java Framework >> Testen
I
ORM
Lerninhalte
Architektur
DAO Template
Hibernate
JPA Java Persitenz API
Entity Lebenszyklus
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 82 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
11
ORM ObjectObject-RelationRelation-Mapping
- ORM bietet grundsätzlich folgende Vorteile
-
Produktivität – Vereinfachung und Objektorientierung des Datenzugriffs
- Wartbarkeit – weniger Codezeilen
- Nachvollziehbarkeit – serverseitiger Cache
- Performance – automatisierte Erstellung der SQL Statements
- Unabhängigkeit – abstrahierter Datenbankzugriff
Spring nutzt das DAO-Pattern zum ORM
wiki
11.1
Data Access Object (DAO, deutsch: "Datenzugriffsobjekt") ist ein Entwurfsmuster,
Entwurfsmuster,
das den Zugriff auf unterschiedliche Arten von Datenquellen (z. B. Datenbanken,
Dateisystem, etc.) so kapselt, dass die angesprochene Datenquelle ausgetauscht
werden kann, ohne
ohne dass der aufrufende Code geändert werden muss. Dadurch
soll die eigentliche Programmlogik von technischen Details der Datenspeicherung
befreit werden und flexibler einsetzbar sein. DAO ist also ein Muster für die
Gestaltung von Programmierschnittstellen (APIs).
Architektur
- Spring stellt Vorlagen zur Verfügung
- DAO Template
- JDBC
- Hibernate
- JPA
- iBatis
Verantwortlichkeit
Spring
Entwickler Beschreibung
Verbindungsparameter
Verbindung erstellen
SQL Statement (SQL Parameter) definieren
SQL Statement ausführen und Loop für Resultset vorbereiten
Durch das Resultset iterieren
Exception- und Transactionshandling
Resultset, Statement und Connection schliessen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 83 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
11.2
DAO Template
Schnittstelle Java / DB
- arbeitet auf der Relation
- SQL als Abfragesprache
- ORM spezifische Querysprache, z.B. Hibernate, JPA, etc
Spring nutzt das Template-Pattern zur DB Integration
wiki
Die Schablonenmethode (engl. template method)
method) ist ein in der
Softwareentwicklung eingesetztes Entwurfsmuster,
Entwurfsmuster, mit dem Teilschritte
Teilschritte eines
Algorithmus variabel gehalten werden können. Es gehört zur Kategorie der
Verhaltensmuster (behavorial
(behavorial patterns).
patterns).
spezifische JDBC Templates
Template
Beschreibung
JdbcTemplate
dbcTemplate
Vereinfachung zur Verwaltung der Ressourcen
NamedParameterJ
NamedParameterJdbcTempl
dbcTemplate
Template Vereinfachung im Umgang mit benannten Parametern
SimpleJdbcTemplate
11.3
Vereinfachung im Umgang mit dynamischen Parametern
JDBCTemplate erzeugen
- JDBC-Template mit Referenz auf Datasource resp. DS Connection
@Resource(name="jdbc/myDB") DataSource ds;
JdbcTemplate template = new JdbcTemplate(ds);
Class.forName("org.gjt.mm.mysql.Driver");
Connection con = DriverManager.getConnection(
"jdbc:mysql://<IP>/myDB", "root", "");
JdbcTemplate template = new JdbcTemplate(new
SingleConnectionDataSource(con, true));
- JDBCTemplate von JdbcDaoSupport erben
public class MyDAO extends JdbcDaoSupport {
@Override
protected JdbcTemplate createJdbcTemplate(DataSource dataSource) {
return super.createJdbcTemplate(dataSource); }}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 84 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
- JDBCTemplate durch Dependency Injection
<bean id="verlagDAO" class="module.spring.jdbc.xml.VerlagDAO">
<property name="jdbcTemplate" ref="template" />
</bean>
<bean id="template" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${db.driverClassName}" />
<property name="url" value="${db.url}" />
<property name="username" value="${db.username}" />
<property name="password" value="${db.password}" />
</bean>
Spring proklamiert die Verwendung seiner DAO Implementierung in Umgang mit JDBC
- einfacher in der Handhabung
- weniger fehleranfällig SQLException
Methoden des JdbcTemplate
Methoden
Beschreibung
execute()
führt das SQL Statement aus ohne Ergebnis
query()
führt das SQL Statement aus kann ein Ergebnis zurückgeben
update()
führt das SQL Statement aus gibt Anzahl der geänderten Rows zurück
batchUpdate() führt mehrere SQL Statements aus z.B. String Array definiert
- Methoden sind mit unterschiedlichen Signaturen vorhanden
- lassen den Verwendungszweck optimieren
- JdbcTemplate erzeugt eine Datenbankverbindung
- führt die Anfrage aus und räumt die Ressourcen auf
public List getByName(String name) {
return getJdbcTemplate().query(
"SELECT ID, NAME, KONTOSTAND FROM KUNDE WHERE NAME=?",
new Object[] { name }, new KundeResultSetRowMapper());
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 85 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
11.3.1
Query auswerten
- verschiede Callbacks für das Resultset stehen zur Vefügung
Resultset Callbacks
Callback
Beschreibung
ResultSetExtractor
Iteration über das Resultset erzeugt Mapperobjekte
RowCallbackHandle
zeilenweises Mapping in Collections
r
RowMapper
übersetzt jede Zeile in ein Objekt
- mögliche RowMapper Implementation der vorgängigen getJdbcTemplate().query
private class KundeResultSetRowMapper implements RowMapper<Kunde> {
public Kunde mapRow(ResultSet rs, int rowNum) throws SQLException {
Kunde kunde = new Kunde(rs.getString(2), rs.getDouble(3));
kunde.setId(rs.getInt(1));
return kunde;
}
}
ÜBUNG JDBC
- CRUD für VerlagVO als Entityobjekt
- erstellen Sie das Entityobjekt Verlag
- erstellen Sie die entsprechenden DAO Klassen
- VerlagDAO und VerlagDAOImpl
- erstellen Sie die Spring Konfiguration
<bean id="verlagID"
class="module.spring.di.xml.VerlagDAOImpl"
init-method="initMethod"
scope="singleton">
<property name="jdbcTemplate"
ref="jdbcTemplateID" />
</bean>
<bean id="jdbcTemplateID"
class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource"
ref="dataSourceID" />
</bean>
- testen Sie die JDBC Persistenzanbindung mit entsprechenden Unit-Tests
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 86 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
11.4
Hibernate
- Open-Source-Persistenz- und ORM-Framework für Java www.hibernate.org
- speichert POJOs mit Attributen und Methoden in relationalen Datenbanken
- synchronisiert DB Relationen mit Objekten
Vorteile
- Abstraktion der verwendeten DB
- dadurch DB Unabhängigkeit
- nicht intrusiv
- keine Ableitung eigener Klassen von
Hibernate-Klassen erforderlich
- keine Voraussetzungen an
die Laufzeitumgebung
- verwendbar in managed und non-managed Umgebungen
- Generierung von sehr effizientem SQL
Nachteil
- exponentieller Komplexitätsgrad
11.4.1
Hibernatesession
der Hibernate Lebenszyklus basiert auf der Hibernatesession
- Transient
- mittels <new> erzeugt
- noch keinem Persistenzkontext zugeordnet
- keine Repräsentation innerhalb der Datenbank
- Pesistent
- besitzt entsprechende Repräsentation innerhalb der Datenbank
- Instanz ist einem Persistenzkontext zugeordnet
- wird von der HibernateSession verwaltet
- Detached
- hat eine Repräsentation innerhalb der Datenbank
- ist keinem Persistenzkontext zugeordnet
- infolge eines Commits geschlossen
- per Remote Aufruf in einer anderen VM
- Removed
- hat eine Repräsentation innerhalb der Datenbank
- ist einem Persistenz Kontext zugeordnet
- ist zum Löschen freigegeben
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 87 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
- Hibernate Session verwenden
public class VerlagDAO implements IVerlagDAO {
private SessionFactory sessionFactory;
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public void insert(Verlag verlag) {
sessionFactory.getCurrentSession().save(verlag);
}
- Alternative ► HibernateTemplate verwenden
public class VerlagDAO extends HibernateDaoSupport implements IVerlagDAO {
public void insert(Verlag verlag) {
getHibernateTemplate().save(verlag);
}
Deklaration einer HibernateSession
<bean id="verlagDAO" class="module.spring.hibernate.xml.KundeDAO">
<property name="sessionFactory" ref="hibernateSessionFactory" />
</bean>
<bean id="hibernateSessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="mappingResources">
<list>
<value>module.spring.hibernate.xml.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">create</prop>
</props>
</property>
<property name="dataSource" ref="dataSource" />
</bean>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 88 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
Deklaration des Hibernate Mapping hbm.xml
<hibernate-mapping auto-import="true">
<class name="module.spring.hibernate.xml.Verlag" table="verlag_table">
<id name="id" unsaved-value="0">
<generator class="native" />
</id>
<property name="name" />
<property name="plz" />
<property name="ort" />
</class>
</hibernate-mapping>
ÜBUNG Hibernate
- Ergänzen Sie die Mappingeigenschaften der hbm.xml Datei

<property name="name" />
- Implementieren Sie die Persistenzschicht mit Hibernate
- finder Methode, z.B. findByName(String name)
- Ansatz ► getHibernateTemplate() .find ("from Verlag v where v.name=?", name)
- distributive Aggregat Funktionen, z.B. count()
- mit der HibernateSession
- mit dem HibernateTemplate
public List<Verlag> findByName(String name) {
return ...
}
public long count() {
return ...
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 89 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
11.5
JPA
- spezifiziert durch JSR 220
- spezifiziert Persistenz Framework
- (Definition) aus Hibernate, TopLink und JDO entstanden
- nicht auf den Einsatz unter Java EE begrenzt
- lauffähig unter Java SE
- als normale Java Anwendungen
- ausserhalb eines Java EE Containers
- Darstellung der Entitäten durch POJOs (Plain old Java Objects)
- Definition der Metadaten durch Annotationen
- XML (Deployment) Deskriptor-Dateien zur Angabe der Metadaten als Alternative
- orm.xml (Deployment) Deskriptor-Dateien überschreiben Annotationen
Ziel
- Java EE zu vereinfachen
11.6
Persistenz Provider
JPA erfordert einen Persistenz Provider, dieser definiert
- Entity
- Java Repräsentation eines persistenten Datensatzes
- Entity Klasse
- serialisierbar / Default Konstruktor /private Attribute
- Getter / Setter Methoden
- Persistence Unit
- Beschreibung von Entity-Klassen
- Data-Source und entspechende Abbildungsinformationen
- Entity Manager
- JPA Standard Interface
- synchronisiert mit der Datenbank
- Persistenzkontext
- Menge aller Entitäten einer Transaktion
- First Level Cache
- Datenbank-Transaktion
- garantiert ACID Verhalten der Datenbank
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 90 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
Persistezp
Persistezprovider
JPA Standard
synchronisiert mit DB
Datenbank
Transaktion
Entity
Manager
garantiert ACID der DB
lädt / speichert
arbeitet
Objekt RepräsenRepräsentation eines Tupel
Entity
Instanz
POJO
- serialisierbar
- Default Konstruktor
- private Attribute
Attribute
- getter / setter
11.6.1
assoziiert mit
Persistence
Context
umfasst
von
bezieht sich
Entity
Klasse
Persistence
Unit
umfasst
Entities
- leichtgewichtige, persistente Objekte als POJOs
- zentraler Teil der Java Persistence API
-
abstrakte wie auch konkrete Java-Klassen werden verwendet
Vererbung, polymorphe Assoziationen und polymorphe Abfragen sind unterstützt
nicht von einer bestimmten Basisklasse abgeleitet
eigene Vererbungshierarchie kann verwendet werden
- Bedingungen
-
Menge aller
Entitäten einer
Transaktion
FirstFirst-LevelLevel-Cache
muss einen parameterlosen Konstruktor enthalten public oder protected
muss eine Top-Level-Klasse sein nicht final
Methoden oder persistente Attribute dürfen nicht final sein
implementiert Serializable falls Instanzen "by-value" übertragen werden sollen
muss einen Primärschlüssel enthalten
- Deklaration
- mit Annotation @Entity
- per XML orm.xml
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 91 >> total: 160 Seiten
- Entityklassen
- Datasource
- Abbildungsinfos
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
Deklaration einer Entity mit Annotations
- entweder Markierung der Klassenattribute
- oder Markierung der Getter-Methoden
@Entity
@Table(name="verlag_table")
public class Verlag implements Serializable {
@Id @GeneratedValue private long
id;
private String name;
private int
plz;
private String ort;
public Verlag() {
}
// Relationen in Beziehung stehende Entities
// getter und setter
// hashcode und equals überschreiben
Deklaration einer Entity per orm.xml
-
Schemadefinitionen Tabellenname, Spaltennamen, etc.
Relationen One:One, One:Many, Many:One, Many:Many
Vererbungsstrategien Single Table, Table per Class, Joined
Ladestrategien Objekte, Attribute
Generatorstrategien für den Primarykey Sequence, Table, Hi-Lo Algorithm, etc.
</entity-mappings>
<entity class="Verlag">
<table name="verlag_table" />
<attributes>
<id name="id">
<generated-value strategy="AUTO" />
</id>
<basic name="name" />
<basic name="ort" />
</attributes>
</entity>
</entity-mappings>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 92 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
11.6.2
Persistenzunit
- erzeugt EntityManager Factory
- definiert durch persistence.xml
Defini
Definition der
der Persistenzunit
Persistenzunit
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
version="1.0">
<persistence-unit name="Spring">
<jta-data-source>java:jdbc/spring</jta-data-source>
<properties> 
<property name="hibernate.hbm2ddl.auto"
value="create-drop" />
</properties>
</persistence-unit>
</persistence>
11.6.3
Entitymanager
- verwaltet die Entities
- ist genau einem Persistenzkontext zugeordnet
- Container-Managed Entity Manager
- Application-Managed Entity Manager
ContainerContainer-Managed Entity Manager
- innerhalb eines Java EE Containers
- erzeugt und schliesst den Entity Managers
- verwaltet JTA (Java Transaction API) Transaktionen
- definiert durch Dependency Injection
- JNDI Java Naming and Directory Interface
ApplicationApplication-Managed Entity Manager
- wird von der Anwendung selbst verwaltet
- aus EntityManagerFactory
- Transaktionen durch
- JTA (Java Transaction API) Spring durch AOP
- lokale Transaktion (z. B. JDBC Transaktion)
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 93 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
Methoden der EntityManager API (Ausschnitt)
public void persist(Object entity);
- Übergang zu managed Entity Instanz:
- commit() oder flush() persistiert Objekt in der Datensource
- ist entity eine neue Entity, wird diese zur managed Entity
- ist entity eine removed Entity, wird diese zur managed Entity
- ist entity eine detached Entity, wird eine IllegalArgumentException geworfen
- gilt auch für relationale Felder von entity, die mit CascadeType.PERSIST annotiert sind
public void remove(Object entity);
- Übergang zu removed Entity Instanz
- commit() oder flush() löscht Objekt in der Datensource
- ist entity eine neue Entity, so wird nichts geschehen
- ist entity eine bestehende managed Entity, so wird diese gelöscht
- ist entity eine detached Entity, wird eine IllegalArgumentException geworfen
- gilt auch für relationale Felder von entity, die mit CascadeType.REMOVE annotiert sind
public void refresh(Object entity);
- synchronisiert die Entity Instanz mit der Datensource
- Änderungen innerhalb der Entity werden dabei überschrieben
-
ist entity eine neue Entity, wird eine IllegalArgumentException geworfen
ist entity eine bestehende managed Entity, so wird diese mit der Datensource synchronisiert
ist entity eine removed Entity, wird eine IllegalArgumentException geworfen
ist entity eine detached Entity, wird eine IllegalArgumentException geworfen
gilt auch für relationale Felder von entity, die mit CascadeType.REFRESH annotiert sind
public <T> T merge(Object entity);
- Übergang von einer detached Entity zu einer managed Entity Instanz
- ist entity eine detached Entity, wird diese in die existierende managed Instanz von entity kopiert
- oder eine neue Kopie einer managed entity Instanz erstellt
- ist entity eine neue Entity, so wird eine neue managed Instanz entity* als Kopie erstellt
- ist entity eine removed Entity, wird eine IllegalArgumentException geworfen
- gilt auch für relationale Felder von entity, die mit CascadeType.MERGE annotiert sind
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 94 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
public void lock(Object entity, LockModeType mode);
- sperrt die Entity Instanz
- LockModeType.READ
- andere Transaktionen können das Objekt lesen, aber nicht ändern
- LockModeType.WRITE
- andere Transaktionen können das Objekt weder lesen noch schreiben
public <T> T find(Class<T> entity, Object primaryKey);
- sucht ein Objekt
- lädt entity aus Datenbank identifiziert durch Primärschlüssel
- liefert null falls keine Entity gefunden wurde
public <T> T getReference(Class<T> entity, Object primaryKey);
- lädt ein Proxy (bzw. eine Referenz) einer Entity
- identifiziert durch Primärschlüssel
- übrige Felder der Entity können zu einem späteren Zeitpunkt nachgeladen werden
- sinnvoll, wenn entity referenziert wird, ohne deren Inhalt zu laden
public void detach(Object entity);
- Übergang zu einer detached Entity Instanz
-
ist entity eine bestehende managed Entity so wird diese zu einer detached Entity
ist entity eine detached Entity so wird nichts geschehen
gilt auch für relationale Felder von entity die mit CascadeType.DETACH annotiert sind
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 95 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
11.6.4
Persistenzkontext
- Menge aller Entitäten einer Transaktion
- Use Case
- Cache
- First Level Cache definiert durch Framework z.B. Hibernate
@Entity
@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
public class Verlag extends BusinessObject{ ...
- Second Level Cache als fremde APIs JPA 2.0 Cache APIs
Second Level Cache provider
Cache Provider
Read-Only
Read-Write Nonstrict R-W
Transactional
EHCache
OSCache ► Opensymphony
Opensymphony
JBossCache ► JBoss
- Gültigkeitsdauer
- transaction-scoped
- entspricht der Dauer einer Transaktion
- nach Abschluss der Transaktion wird der Persistenzkontext geschlossen
- extended
- ist unabhängig von einer Transaktion
- kann mehrere Transaktionen umfassen
- der Persistenzkontext muss manuell (Entity Manager) geschlossen werden
// emf = EntityManagerFactory ist Application Managed
EntityManager em = emf.createEntityManager();
// Transaktion starten (begin) und beenden (commit)
em.getTransaction().begin();
Verlag myVerlag = em.find(Verlag.class, new Long(1));
myVerlag.setName("dpunkt.verlag");
Verlag mySecondVerlag = new Verlag();
mySecondVerlag.setId(2);
mySecondVerlag.setName("entwickler.press");
em.persist(mySecondVerlag);
em.getTransaction().commit();
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 96 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
11.7
Lebenszyklus
- der Persistence Provider verwaltet die Zustände eines persistenten Objektes
transparent
- JPA definiert transparentes O/R-Mapping Framework
- Entities ist ihr eigener Zustand nicht bekannt
- es ist nicht direkt möglich, eine Entity nach ihrem aktuellen Zustand zu fragen
Objektzustände
Objektzustände
eine Entity definiert vier verschiedene Zustände
- New
- neue Entity vorübergehend, flüchtig
- Removed
- gelöschte Relation gelöscht
- Persistent
- synchronisierte Relation persistent, nicht flüchtig
- Detached
- unsynchronisierte Relation gelöst
new()
Entity
Lifecycle
garbage
New
remove()
garbage
refresh()
persist()
Removed
refresh()
merge()**
find()
getReference()
getResultList()
getSingleResult()
persist()
remove()
Managed
- JPA Objekt Zustandsdiagramm
persist()
refresh()
merge()
- Zustandsänderung durch
Operationen des Persistenzkontext
- Methoden der EntityManager-Instanz
- Methoden der Query-Instanz
refresh()
merge()
detach()
close()*
clear()*
lock()
merge()**
Detached
* betrifft alle Instanzen des Persistenzkontext
** erzeugt persistente Instanz, Originalobjekt bleibt erhalten
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 97 >> total: 160 Seiten
garbage
persist()
remove()
refresh()
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
New
-
durch new erzeugtes Entity-Objekt als normales Java-Objekt POJO
keine Verbindung zwischen der Entity und Entity Manager
Zustand der Entity nicht persistent abgespeichert
Garbage Collector entsorgt Objekte ohne Referenz
keine Repräsentation der Entity innerhalb der Datenbank
alle Daten der Entity sind flüchtig und gehen verloren (Garbage Collector)
Entities sind transient, nicht Teil einer Transaktion
Rollback nicht anwendbar (in Transaktion)
Primärschlüsselfelder, durch den Persistenz-Manger erzeugt, sind noch nicht gesetzt
Übergang von New zu Managed mit:
- persist()
- merge()
- Referenzierung durch persistente Entity
- abhängig von Kaskadierungseinstellungen der Assoziation
Managed
-
Entity wird von einem Entity Manager verwaltet
Entity hat einen Primärschlüssel zugewiesen
(auch ohne) Repräsentation innerhalb der Datenbank
persist() veranlasst keine Datenbankaufrufe
Entities im persistenten Zustand sind Teil einer Transaktion
Änderungen können durch Rollback rückgängig gemacht werden
Änderung von Attributen wird erkannt
- SQL UPDATE
- SQL INSERT
- find() – erzeugt persistente Entity
- ohne Übergang von New nach Managed
Übergang von Managed zu Removed:
- remove()
remove() löscht die Daten der Entity innerhalb der Datenbank,
JavaJava-Objekt bleibt verfügbar, vorausgesetzt,
vorausgesetzt, es wird noch referenziert
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 98 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
Detached
Detached
-
schliessen des Managers mit close(...)
Zuordnung der Entities zum Manager endet
Entities sind nicht mehr Teil einer Transaktion
Änderungen werden nicht mehr mit Datenbank synchronisiert
Java-Objekte enthalten trotzdem (veraltete) persistente Daten
durch Serialisieren (und Übertragen) einer Entity in einen anderen Prozess
- Transferieren des POJO in eine Remote-Anwendung Client-Request
- als Transfer-Objekte zwischen Präsentationsschicht und Datenbankschicht
Übergang von Detached zu Managed:
- merge()
- Kopie der Entity wird wieder in Persistenzkontext aufgenommen
- lock()
- unveränderte Entity wird wieder in Persistenzkontext aufgenommen
- Parameter lockMode definiert verschiedene Lock-Modi in Verbindung mit Transaktionen
Removed
- Entity-Objekt für das Löschen markiert
- wird am Ende der laufenden Transaktion gelöscht
- z.B. mit flush()
- kann wieder in den managed Zustand aufgenommen werden
- mit persist()
Übergang von Removed zu Managed mit
- persist()
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 99 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
ÜBUNG JPA
Implementieren Sie die Persistenzschicht mit JPA
- EntityManager durch den PersistenceContext JSR 220
@PersistenceContext(name="spring")
private EntityManager em;
- EntityManger durch das JpaTemplate durch Ableiten von JpaDaoSupport
public class VerlagDAO extends JpaDaoSupport implements IVerlagDAO {
public List getByName(String name) {
return getJpaTemplate().find("FROM Verlag v WHERE v.name=?1", name);
}
ÜBUNG JPA (annotiert)
- definieren Sie die Verlags Entity durch JPA Annotationen
@Entity
@Table(name="t_verlag")
public class Verlag implements Serializable{
@Id
@GeneratedValue
private long
id;
private String name;
private int
plz;
private String ort;
...
- laden Sie die Konfigurationen als Spring Beans
<context:property-placeholder location="jdbc.properties" />
<context:component-scan base-package="module.spring.jpa.annotation" />
<bean class="module.spring.jpa.annotation.VerlagDao" />
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 100 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
- definieren Sie die Bean-Konfigurationen
@Configuration
public class BeanConfiguration {
@Value("${driver}")
private String
@Value("${url}")
private String
@Value("${user}")
private String
@Value("${password}") private String
driver;
url;
user;
password;
@Bean(destroyMethod = "close") protected DataSource dataSource() {
BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName(driver);
...
return dataSource;
}
@Bean protected EntityManagerFactory entityManagerFactory() { ... }
@Bean public JpaVendorAdapter jpaVendorAdapter() { ... }
@Bean public PlatformTransactionManager transactionManager() { ... }
@Bean public IVerlagDao verlagDAO() { return new VerlagDao(); }
11.8
Datenbank Exceptions
Spring verwendet eine eigene Exception Hierarchie und mappt die DB Exceptions
- unabhängig von der verwendeten API
- Abstaktion der DB
Unterklassen der DataAccessException
Callback
Beschreibung
ConcurrencyFailureException
Ausnahmen bei parallelen DB Zugriffen
DataAccessResourceFailureEx
DataAccessResourceFailureException
Ausnahmen beim Zugriff auf DB Rescourcen
DataRetrievalException
Ausnahmen beim Lesen von Daten
InvalidDataAccessResourceUsageExceptio
InvalidDataAccessResourceUsageExceptio
Ausnahmen bei falscher Query Syntax
n
try { ...
} catch (EmptyResultDataAccessException ex) {
return null;
// definiert Unabhängikkeit der Persitenzschicht
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 101 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
ÜBUNG Datenbank Exception
- mappen Sie die DB Exception auf eine (sinnvolle) Spring Exception
public Verlag getByID(int id) {
try {
return (Verlag) getNamedParameterJdbcTemplate().queryForObject(
"SELECT NAME, FROM VERLAG V WHERE ID=:id",
new MapSqlParameterSource("id", id), new VerlagRowMapper());
} catch (EmptyResultDataAccessException ex) {
return null;
}
}
J
Transaktionen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 102 >> total: 160 Seiten
Spring 3 >> Java Framework >> ORM Object-Relation-Mapping
Lerninhalte
Transaktions-Steuerung
Transaktions-Management
Transaktions-Eigenschaften
Transaktions-Annotationen
12
Transaktionsmanagement
wiki
Als Transaktion (von lat. trans „über“, actio
actio zu agere „(durch)führen“) bezeichnet
man in der Informatik eine Folge von Operationen, die als eine logische Einheit
betrachtet werden. Insbesondere wird für Transaktionen gefordert, dass sie
Atomarität).
entweder vollständig oder überhaupt nicht ausgeführt werden ((A
tomarität).
Transaktionen werden von Transaktionssystemen verarbeitet; diese erzeugen
dabei aus mehreren Transaktionen eine Historie. Transaktionen kommen meist bei
Datenbanksystemen zum Einsatz.
12.1
-
Transaktion
logisch zusammenhängende Folge von Operationen einer Datenbank
wird von einem konsistenten in einen weiteren konsistenten Zustand überführt
kleinster, unteilbar abzuarbeitender Prozess einer Anwendung
werden vollständig oder gar nicht abgearbeitet
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 103 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
12.1.1
Transaktionskonzepte
- ACID-Eigenschaften
- Atomic (atomar) ► eher Up-Quark, Neutrino oder Myon, etc.
- eine Transaktion ist Reihe von "primitiven" unteilbaren Operationen
- es werden entweder alle Operationen ausgeführt oder gar keine
- Consistent (konsistent)
- Transaktionen hinterlassen die Datenbank in einem konsistenten Zustand
- Isolated (isoliert)
- gleichzeitige Transaktionen beeinflussen sich nicht
- Durable (dauerhaft)
- abgeschlossene Transaktionen sind dauerhaft
12.1.2
Transaktionsverhalten
- commit
- erfolgreiche Beendigung einer Transaktion
- die Änderungen sind dauerhaft in der Datenbank abgespeichert
- für alle (User) sichtbar
- rollback
- Transaktionsabbruch führt Änderungen am Datenbestand zum letzten konsistenten Zustand
12.1.3
Lokale und verteilte Transaktionen
- lokale Transaktion (local transaction)
- nur lokale Daten betroffen
- nicht mehrere (Daten)-Ressourcen sind Teil der Transaktion
- verteilte Transaktion (distributed transaction)
- betreffen mehrere Daten, die auf Verteilten Systemen liegen
- müssen in Teiltransaktionen aufgeteilt werden
Transaktionsablauf
-
Business Prozess startet Transaktion 1
Business Prozess startet Transaktion 2
Transaktion 1 wird mit commit beendet
Transaktion 2 wird mit commit beendet
► inkonsistente Zustände sind möglich
- zweite Commit-Anweisung fällt aus
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 104 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
Zwei Phasen Commit
2PC definiert erweitertes Protokoll mit 2 Phasen
- Erste Phase
- "Prepare-to-Commit" auf allen Knoten
- teure Operation
- Zweite Phase
- sendet ein Commit an die Knoten
- billige Operation
12.1.4 Isolationsebenen
wiki
In der Informatik bezeichnet der Begriff Isolation die Trennung von Transaktionen
ablaufen-auf eine Weise, dass eine laufende Transaktion nicht von einer parallel ablaufen
den Transaktion durch Änderung der benutzten Daten in einen undefinierten
Zustand gebracht werden kann. Die Isolation ist eine der vier ACIDACID-Eigenschaften.
- komplette Serialisierung der transaktionalen Operationen
- sicher, aber teuer
- Isolierung ist eine Einschränkung im Vergleich zu idealen ACID Transaktionen
- nach ANSI-92 SQL
Isolationsebenen
Level
Beschreibung
NONE
keine Transaktion möglich
READ_UNCOMMITTED alle Transaktionen sehen die Änderungen von anderen Transaktionen
READ_COMMITTED
nicht abgeschlossene Transaktionen sind unsichtbar für andere Transaktionen
REPEATABLE_READ
eine Transaktion sieht nur Daten, die vor ihrem Startzeitpunkt vorhanden waren
SERIALIZABLE
alle Transaktionen verhalten sich, als würden sie hintereinander abgearbeitet
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 105 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
12.1.5
Probleme bei parallelen Datenbankoperationen
- Multi-User Applikationen definieren folgende Problem-Szenarien
Dirty Read
-
innerhalb einer Transaktion T1 wird ein Datensatz Z verändert
dieser veränderte Datensatz wird innerhalb einer zweiten Transaktion T2 gelesen
Transaktion T1 mit einem Rollback abgebrochen
die Transaktion T2 arbeitet mit einem ungültigen Wert
- Dirty Read
dirty read
User T1
Daten Z
User T2
1
10
Transaktionsablauf
2
3
4
UPDATE
ROLLBACK
11
11
10
SELECT
5
10
SELECT
Non Repeatable Read
-
innerhalb einer Transaktion T1 wird ein Datensatz Z gelesen
die zweite Transaktion T2 ändert diesen Datensatz Z
die Transaktion T2 wird commited
erneutes Lesen von Z durch die Transaktion T1 ergibt einem ungültigen Wert
- Non-Repeatable Read
nonrepeatable
read
User T1
Daten Z
User T2
Transaktionsablauf
1
2
10
SELECT
10
3
11
UPDATE
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 106 >> total: 160 Seiten
4
11
COMMIT
5
SELECT
11
Spring 3 >> Java Framework >> Transaktionsmanagement
Phantom Read
-
die Transaktion T1 liest die Ergebnismenge der Daten Z (count = 2)
die Transaktion T2 verändert die Anzahl Datensätze mit Insert / Delete
die Transaktion T2 wird committed
erneutes Lesen von Z durch die Transaktion T1 ergibt eine ungültige Ergebnismenge
- Phantom Read
phantom
read
User T1
Daten Z
User T2
1
10,11
Transaktionsablauf
2
3
4
SELECT
10,11
11,11,12 11,11,12
INSERT
COMMIT
5
SELECT
10,11,12
Lost Update
Update
-
innerhalb einer Transaktion T1 wird ein Datensatz Z gelesen
die zweite Transaktion T2 liest denselben Datensatz Z
die Transaktion T1 wird commited
die Transaktion T2 wird commited
erneutes Lesen von Z durch die Transaktion T1 ergibt einem ungültigen Wert
- Lost Update
lost
update
Transaktionsablauf
1
User T1
SELECT
Daten Z
10
User T2
2
3
4
COMMIT
10
11
SELECT
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 107 >> total: 160 Seiten
5
SELECT
12
COMMIT
12
Spring 3 >> Java Framework >> Transaktionsmanagement
mögliche Vorkommen bei Isolationsebenen
Isolationsebenen
mögliche Reads
Isolationsebene
Dirty Read
Non Repeatable Read
Phantom Read
Read
Read Uncommitted
Read Committed
Repeatable Read
Serializable
- mit zunehmendem Isolationsgrad
- sicherere Transaktion
- schlechtere Performance, da mehr Sperren innerhalb der Datenbank
12.2
Transaktionssteuerung
- Transaktion ist im Code versteckter Aspekt
- Spring abstrahiert den Kontakt mit dem Transaktionsmanagement
- Spring selbst bietet keinen Transaktionsdienst an
- Spring versucht bestehende Technologien bestmöglich zu integrieren
programmatisches Transaktionsmanagement
- Beanlogik steuert / überwacht Transaktionsbalauf
transactionManager.rollback(transactionStatus);
deklaratives Transaktionsmanagement
- Springcontainer steuert / überwacht Transaktionsablauf
<tx:advice id="txAdvice" transaction-manager="transactionManager">
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 108 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
Transaktionsmanager
Transaktionsmanager
- dient als Fassade zu einer spezifischen Implementierung
wiki
Facade Pattern definiert eine einheitliche Schnittstelle zu einer Menge von
Schnittstellen eines Subsystems. Die Facadenklasse definiert eine abstrakte
Schnittstelle, welche die Benutzung
Benutzung des Subsystems vereinfacht.
Spring Transaktionsmanagment
TransactionManager
Beschreibung
DataSourceTransactionManager
verwaltet Transaktionen von einfachen JDBC Verbindungen
HibernateTransactionManager
verwaltet Transaktionen mit Hibernate als Persistenzmechanismus
JdoTransactionManager
verwaltet Transaktionen mit JDO als Persistenzmechanismus
TopLinkTransactionManager
verwaltet Transaktionen mit TopLink als Persistenzmechanismus
PersistenceBrokerTransactionManager
verwaltet Transaktionen mit ORM
JmsTransactionManager
verwaltet Transaktionen mit JMS für asynchrone Kommnikation
12.2.1
TransactionManager per XML
- als AOP Aspekt
- Interceptor fängt Methodenaufrufe ab
- Interceptor startet / beendet Transaktionen
- Konfiguration über TransactionAttributeSource
JDBC (Java Database Connectivity)
Connectivity)
- Unterstützung durch Connection Objekt
<bean id="txManager" class="...jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="order*" propagation="REQUIRED" rollback-for="OrderException" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:advisor pointcut="execution(* module.spring.jdbc.xml.Facade.*(..))"
advice-ref="txAdvice" />
</aop:config>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 109 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
ORM Framework (Object(Object-RelationRelation-Mapping)
- Unterstützung durch eigene Transaktionsmanager
- 1st und 2nd Level Cache Unterstützung
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="hibernateSessionFactory" />
</bean>
<bean id="hibernateSessionFactory"
class=" org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="mappingResources">
<list>
<value>module.spring.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MYSQLDialect</prop>
<prop key="hibernate.hbm2ddl.auto">create</prop>
</props>
</property>
<property name="dataSource" ref="dataSource" />
</bean>
JMS
JMS (Java Messaging Services) für asynchrone Kommunikationsmodelle
- Gruppieren von JMS Messages

<bean id="jmsTransactionManager"
class="org.springframework.jms.connection.JmsTransactionManager">
<property name="connectionFactory" ref="jmsConnectionFactory"/>
</bean>

<bean id="activemq" class="org.apache.activemq.comand.ActiveMQQueue">
<property name="connectionFactory" ref="jmsConnectionFactory"/>

<property name="transacted" value="true"/>
<property name="transactionManager" ref="jmsTransactionManager"/>
</bean>

<bean id="jmsConnectionFactory"
class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value=" tcp://localhost:61616 "/>
</bean>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 110 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
JPA (Java Persistence API)
API)
- definiert durch Spezifikation
- JSR 220 ► Enterprise JavaBeans 3.0
- JSR 317 / 318 ► Java Persistence API 2.0 / Enterprise JavaBeans 3.1
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<bean id="entityManagerFactory"
class="...orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="persistenceUnitName" value="spring" />
<property name="jpaVendorAdapter">
<bean class="...orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="generateDdl" value="true" />
<property name="database">
<util:constant static-field="...orm.jpa.vendor.Database.MYSQL" />
</property>
</bean>
</property>
</bean>
JTA (Java Transaction API) für distributed Transaktionssysteme
- Unterstützung durch Applikations-Server, Messaging-System, etc.
<bean id="transactionManager"
class="org.springframework.transaction.jta.JtaTransactionManager" />
<jms:listener-container connection-factory="myConnectionFactory"
task-executor="myTaskExecutor"
destination-resolver="myDestinationResolver"
transaction-manager="myTransactionManager"
concurrency="10">
<jms:listener destination="queue.confirmations"
ref="confirmationLogger" method="log" />
</jms:listener-container>
12.2.2
TransactionManager per Annotation
@Resource
UserTransaction userTransaction;
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 111 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
12.3
Transaktionsmanagement
programmatisches
programmatisches Transaktionsmanagement
- logische Kontrolle über Transaktionsverhalten
- nicht effizient
- Unabhängigkeit (Technologie) geht verloren
- codeabhängig
public void addVerlag() {
transactionTemplate.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus ts) {
try {
// Verlag anlegen und Medien dem Verlag hinzufügen
} catch (Exception e) {
ts.setRollbackOnly();
}
return null;
}
}
}
deklaratives
deklaratives Transaktionsmanagement
- AOP Transaktionen
- Transaktionsmanagement als Aspekt
- persistenzabhängiger TransactionManager als Advice
- Transaktionseigenschaften als Pointcut auf bestimmte Methoden von Beans
- Spring übernimmt die Verantwortung des Transaktionsmanagement
- (Neu-) Starten und Weiterführen einer Transaktion
<tx:advice id="txAdvice" transaction-manager="jpaTransactionManager">
<tx:attributes>
<tx:method name="add*" propagation="SUPPORTS"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:advisor pointcut="execution(* *.ServiceFacade.*(..))"
advice-ref="txAdvice" />
</aop:config>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 112 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
TX Namespace
Element
Beschreibung
<tx:advice>
deklariert Transaktionsadvice
<tx:annotation-driven>
erwartet @Transactional Annotation
<tx:attribute>
deklariert Transaktionsregeln
<tx:jta-transaction-manager>
konfiguriert JTA Transaktionsmanager ► JPA
<tx:methode>
deklariert Transaktionsregel für Methodensignatur
- TX Namespace erfordert XSD Schema
<beans xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
annotiertes
annotiertes Transaktionsmanagement
- annotierter Spring Aspect
@Transactional(propagation = Propagation.REQUIRED,
rollbackFor = VerlagException.class)
public void exceptionTx(Verlag verlag) throws VerlagException {
verlagDAO.insert(verlag);
throw new VerlagException("Erwartete Test-Exception");
}
- Transaktionsmanager als UserTransaction
- im Einsatz mit JEE Server
- unabhängig von Technologie
@Resource
UserTransaction userTransaction;
TX Annotations
Annotation
Einsatz
@Transactional
Method, Type
// Dependency Injection (JSR-250)
Beschreibung
deklariert Transaktionsgrenze und Transaktionsregeln
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 113 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
12.4
PlatformTransactionManager
- bietet implementationsunabhängige Schnittstelle
- Abstraktion zum Persistenzmechanismus
- definiert Unabhängigkeit
- von Transaktionsmanager
- jedoch nicht von Spring!
- unterstützt 2PC Protokoll ► distributed Transaktion
public interface PlattformTransactionManager {
TransactionStatus getTransaction(TransactionDefinition definition)
throws TransactionException;
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
}
Um transaktionsfähig zu sein,
sein, muss Spring
Spring die Persistenz kontrollieren !
Nutzung des PlatformTransactionManager
- erster Aufruf an das API startet Transaktion
- erzeugt TransactionStatus
- kann durch den Code manipuliert werden
- wird nach Beenden dem PlatformTransactionManager übergeben
- beendet die Transaktion mit commit oder rollback
private PlatformTransactionManager tm;
// per Dependency Injection
public void setTransactionManager(PlatformTransactionManager tm) {
this.tm = tm;
}
public void cannotInsertVerlag(Verlag verlag) {
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionStatus ts = tm.getTransaction(def);
verlagDAO.insert(verlag);
tm.rollback(ts);
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 114 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
12.5
Transaktionseigenschaften
Transaktionsregeln für ein AOP Pointcut ► Methode
- Propagation
- Isolationslevel
- Read-only
- Transaktionstimeout
Transaktionsattribute definieren
Transaktionsattribute
Attribut
Zweck
isolation
definiert die Isolationsebene
no-rollback-for
legt Exceptions fest, die kein Rollback zur Folge haben
propagation
definiert die Propagationsregeln für die Transaktion
read-only
legt fest, dass eine Transaktion nur liest und nicht schreibt
rollback-for
legt Exceptions fest, die ein Rollback zur Folge haben
Timeout
definiert Timeout für eine länger dauernde Transaktion
Propagation
wiki
Unter Propagation oder Propagierung (von Lateinisch propagare „ausdehnen“)
versteht man im weitesten Sinne eine Ausdehnung.
Ausdehnung.
Propagations in Spring
Bezeichnung
Verhalten
PROPAGATION_MANDATORY
erfordert eine laufende Transaktion ► Exception
PROPAGATION_NESTED
erfordert eine eigenständige Transaktion
PROPAGATION_NEVER
erlaubt keine offene Transaktion ► Exception
PROPAGATION_NOT_SUPPORTED unterbricht eine offene Transaktion
PROPAGATION_REQUIRED
startet eine neue oder übernimmt eine bestehende Transaktion
PROPAGATION_REQUIRES_NEW
startet eine neue Transaktion
PROPAGATION_SUPPORTS
übernimmt eine geöffnete Transaktion
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 115 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
Transaktionspropagation
Bezeichnung
aufrufende Methode
weiterführende Methode
NotSupported, Supports, Never
Required, RequiresNew
Mandatory
NotSupported
Supports, Required, Mandatory
RequiresNew, Nested
Never
12.6
Spring Transaktion als AOP Aspekt - Zusammenfassung
- Spring Transaktion ist AOP Aspekt
- Transaktionssteuerung erfolgt als AOP Proxy
- durch TransactionInterceptor
- und entsprechenden PlatformTransactionManager
- transaktionaler Advice ist über Meta-Data definiert
- deklarativ
- annotiert
- erfolgt über Method-Invocation als Pointcut
AOP delegiert Calleraufruf an Proxy Object
AOP startet Transaktion
AOP beendet Transaktion (commit / rollback)
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 116 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
ÜBUNG JDBC Transaktion per XML Deklaration
- die Deklaration des TransactionManager benötigt
- Target ► txFacade
- Transaktionsmanager ► txManager
- Transaktionseigenschaften ► txAdvice
<bean id="txFacade" class="module.spring.jdbc.xml.TxFacadeImpl">
<property name="verlagDAO" ref="verlagID" />
<property name="transactionManager" ref="txManager" />
</bean>
<bean id="txManager" class="...jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="insert*" propagation="REQUIRED" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:advisor pointcut="execution(* *.TxFacadeImpl.*(..))" advice-ref="txAdvice" />
</aop:config>
ÜBUNG User JDBC Transaktion per PlatformTransactionManager
- provozieren Sie einen Rollback
public void rollbackTx(Verlag verlag) {
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionStatus ts = tm.getTransaction(def);
verlagDAO.insert(verlag);
ts.setRollbackOnly();
}
- notwendige XML Deklaration

<bean id="txFacade" class="module.spring.jdbc.xml.TxFacadeImpl">
<property name="verlagDAO" ref="verlagID" />
<property name="transactionManager" ref="txManager" />
</bean>

<bean id="txManager" class="...jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 117 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
ÜBUNG annotierte JPA Transaktion
- annotieren Sie die Transaktionen für einen JPA Transaktionsmanager
@Transactional
public void insertTx(Verlag verlag) {
...
}
@Transactional(propagation = Propagation.REQUIRED)
public void rollbackTx(Verlag verlag) {
...
if (null != TransactionAspectSupport.currentTransactionStatus())
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
@Transactional(propagation = Propagation.REQUIRED,
rollbackFor = VerlagException.class)
public void exceptionTx(Verlag verlag) {
if (...){
verlagDAO.insert(verlag);
} else throw new RuntimeException("Erwartete Test-Exception"); }
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 118 >> total: 160 Seiten
Spring 3 >> Java Framework >> Transaktionsmanagement
K
Messaging
Lerninhalte
JMS API
Spring Messaging
ListenerKontainer
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 119 >> total: 160 Seiten
Spring 3 >> Java Framework >> Messaging
13
Messaging
synchron
- unterstützt asynchrone Kommunkationsmodelle
- Point-To-Point ► Queue
- Publish / Subscribe ► Topic
P1
P2
asynchron
P1
P2
BROKER
- unterstützt Entkoppelung
- Verteilungsaspekt
13.1
JMS API Java Messaging Service
- API für den Zugang zu Messaging-Systemen
- definiert Schnittstelle
- als Factory
- Message als
- Text
- Bytes
- Streams
- Objects
- Maps
Nachrichten erzeugen mit
mit der JMS API
Das Erzeugen und Absenden einer Nachricht über JMS erfolgt in sechs Schritten:
1.
Treiber lokalisieren
2.
Verbindung erzeugen
3.
Session erzeugen
4.
Destination lokalisieren
5.
Consumers
oder
Producers
erzeugen
6.
Nachricht senden
oder
Nachricht empfangen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 120 >> total: 160 Seiten
Spring 3 >> Java Framework >> Messaging
Lokalisieren des JMSJMS-Treibers
- Treiber für das verwendete JMS-Produkt laden ► Maven
- lookup(CONNECTION_FACTORY)
- CONNECTION_FACTORY ist JNDI-Name des Treibers
- implementiert die Schnittstelle ConnectionFactory
Erzeugen der JMSJMS-Verbindung
Verbindung
- aktive Verbindung zu einem JMS-Provider erzeugen
- kapselt die Netzwerk-Kommunikation
- Analog zu JDBC wird der Treiber verwendet, um eine Connection anzufordern
- TopicConnection
- QueueConnection
Erzeugen einer JMS Session
Session
- JMS Session ist ein Hilfsobjekt, um Nachrichten zu senden oder zu empfangen
- legt die Eigenschaften des Nachrichtenaustauschs fest
- integriert den Nachrichtenaustausch in eine Transaktion
- TopicSession
- QueueSession
Lokalisieren einer JMS Destination
Destination
- JMS Destination ist ein Kommunikationskanal
- sendet Nachrichten
- empfängt Nachrichten
- die Auswahl des Kanals erfolgt über ein lookup(CHANNEL)
- CHANNEL ist JNDI-Name des Kanals
- wird meist durch Applikationserver zur Verfügung gestellt
Erzeugen eines JMS Consumers oder eines JMS Producers
Producers
- Empfänger oder Sender
Senden oder Empfangen der Nachricht
- Typen von Nachrichten
- Text, Bytes, Streams, Objects oder Maps
- Nachricht wird instantiiert
- Nachricht wird über den Producer gesendet
- Nachricht wird über den Consumer empfangen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 121 >> total: 160 Seiten
Spring 3 >> Java Framework >> Messaging
jedes Interface hat zwei Ausprägungen,
Ausprägungen, analog zu den
den beiden Kommunikationsmodellen
JMS API
Interface
PointPublishPoint-ToTo-Point
Publish-Subscribe
Subscribe
ConnectionFactory
QueueConnectionFactory
TopicConnectionFactory
Connection
Queue Connection
TopicConnection
Destination
Queue
Topic
Session
QueueSession
TopicSession
MessageProducer
QueueSender
TopicPublisher
MessageConsumer
QueueReceiver, -Browser
TopicSubscriber
13.2
JMS in Spring implementiert
- Spring offeriert Template zur Integration
- JmsTemplate
- JmsTemplate02
►für JMS 1.1
► für JMS 1.2
JMSTemplate / ConnectionFactory
// Apache ActiveMQ ► http://activemq.apache.org/
<bean id="connectionFactory"
class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="closeTimeout" value="100" />
<property name="brokerURL" value="tcp://localhost:61616" />
</bean>
<bean id="jmsTemplate"
class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="connectionFactory" />
<property name="defaultDestinationName" value="..." />
<property name="messageConverter">
<bean class="...jms.support.converter.SimpleMessageConverter"/>
</property>
</bean>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 122 >> total: 160 Seiten
Spring 3 >> Java Framework >> Messaging
13.3
Nachricht senden
durch MessageCreato
MessageCreator Intefac
Inteface
jmsTemplate.send(destination, new MessageCreator() {
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage();
textMessage.setText("send this as a message");
return textMessage;
}});
durch MessageConverter Interface
jmsTemplate.convertAndSend("send one more message");
Messageh
Messageheader definieren durch MessagePostProcessor
jmsTemplate.convertAndSend( msg, new MessagePostProcessor() {
public Message postProcessMessage(Message msg) throws JMSException {
msg.setIntProperty("MessageID", 1234);
return message;
}});
13.4
Nachricht empfangen
- durch Methode jmsTemplate.receive()
- durch Methode jmsTemplate.receiveAndConvert() ► als konfigurierbares Object
MessageListener ► ruft die Methode onMessage() auf
public class MyMessageListener implements SessionAwareMessageListener {
public void onMessage(Message message, Session session) throws JMSException {
synchronized (MyMessageListener.class) { MyMessageListener.class.notifyAll();}
}
<bean id="messageListener" class="module.spring.jms.xml.MyMessageListener" />
<bean class="org.springframework.jms.listener.SimpleMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="queue" />
<property name="messageListener" ref="messageListener" />
</bean>
<bean id="queue" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg index="0" value="myqueue" />
</bean>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 123 >> total: 160 Seiten
Spring 3 >> Java Framework >> Messaging
Recei
ReceiverAdapter
- delegiert Messages an die Receiverklasse ► MessageReceiver
- definiert die Listener Methode ►logMessage
<bean class="org.springframework.jms.listener.SimpleMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="queue" />
<property name="messageListener" ref="recieverAdapter" />
</bean>
<bean id="receiverAdapter" class="...jms.listener.adapter.MessageListenerAdapter">
<property name="delegate" ref="receiver" />
<property name="defaultListenerMethod" value="logMessage" />
</bean>
<bean id="receiver" class="module.spring.jms.xml.MessageReceiver" />
public class MessageReceiver {
public void logMessage(String message) {...}
}
ÜBUNG JMS mit Spring
- erstellen Sie einen MessageSender
- ein MessageReceiver als MessageListener
- ein MessageReceiver als ReceiverAdapter
<bean id="sender" class="module.spring.jms.xml.MessageSender">
<property name="jmsTemplate" ref="jmsTemplate" />
<property name="destination" ref="queue" />
</bean>
- Testen Sie mit ActiveMQ von Apache ► http://activemq.apache.org/
@Test // <property name="messageListener" ref="receiverAdapter" />
public void testReceiverAdapter() throws Exception {
sender.send(message);
assertEquals(message, receiver.getMessage());
}
@Test // <property name="messageListener" ref="messageListener" />
public void testMessageListener() throws Exception {
sender.sendEasy("a message");
synchronized (MyMessageListener.class) { MyMessageListener.class.wait(100);}
assertTrue(myMessageListener.isCalled());
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 124 >> total: 160 Seiten
Spring 3 >> Java Framework >> Messaging
13.5
MessageListenerContainer
- für grössere Anzahl von Messages
- halten Messages für längere Zeit
- erlauben parallele Verarbeitung
- durch Infrastruktur zur Verfügung gestellt
- Skalierbarkeit
- Ausfallsicherheit
<jms:listener-container container-type="simple" concurrency="5">
<jms:listener destination="myqueue" ref="messageHandler" method="handleMessage" />
</jms:listener-container>
<bean id="messageHandler" class="module.spring.jms.xml.MessageHandler" />
public class MessageHandler {
public void handleMessage(String message) {
synchronized (MessageHandler.class) {
MessageHandler.class.notifyAll();
}
}}
13.6
ListenerContainer
- Implementierungen variieren durch Skalierbarkeit
- Attribute concurrency definiert Parallelität
JMS Namespace
Element
Beschreibung
<jms:jca-listener-container>
konfiguriert einen Container als JCA-JMS Destination
Listener ► verteillte Host Systeme
<jms:listener-container>
konfiguriert einen Container als JMS Destination Listener
<jms:listener>
deklariert einen Listener für JMS-POJO
- TX Namespace erfordert XSD Schema
<beans xmlns:tx="http://www.springframework.org/schema/jms"
xsi:schemaLocation="
http://www.springframework.org/schema/jms
http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 125 >> total: 160 Seiten
Spring 3 >> Java Framework >> Messaging
ÜBUNG JMS mit Spring ListenerContainer
ListenerContainer
- definieren Sie einen MessageHandler für einen ListenerContainer
<bean id="messageHandler" class="module.spring.jms.xml.MessageHandler" />
public class MessageHandler {
private static boolean called = false;
public static boolean isCalled() {
return called;
}
public void handleMessage(String message) {
called = true;
synchronized (MessageHandler.class) { MessageHandler.class.notifyAll(); }
}}
@Test public void testListenerContainer() throws InterruptedException {
assertFalse(MessageHandler.isCalled());
jmsTemplate.convertAndSend("one more message");
synchronized (MessageHandler.class) { MessageHandler.class.wait(100);}
assertTrue(MessageHandler.isCalled());
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 126 >> total: 160 Seiten
Spring 3 >> Java Framework >> Messaging
L
Remoting
Lerninhalte
Architektur
HTTP-Invoker
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 127 >> total: 160 Seiten
Spring 3 >> Java Framework >> Remoting
14
Remoting
Spring offeriert Support für verschiedene Protokolle
- RMI Remote Method Invocation
- verteilte Aufrufe
- implementiert das Exporter Pattern
- HTTP Hyper Text Transfer Protocol
- HttpInvoker (Austausch serialisierter Objekte über HTTP)
- SOAP ursprünglich für Simple Object Access Protocol
- SOAP Spring WebService
- EJB Enterprise JavaBeans
- JSR 220 konform
Remoting basiert auf dem Exporter Pattern
<bean class="org.springframework.remoting.rmi.RmiServiceExporter">
<property name="serviceName" value="RemoteServerName" />
<property name="service" ref="server" />
<property name="serviceInterface" value="...RemoteService" />
</bean>
14.1
Architektur
- gleicher Ansatz für alle Remote Modelle
- Service als Spring Bean konfiguriert
Remote Service
- Applicationkontext erzeugt Service
- als Singleton
- steht im Netzwerk zur Verfügung
Client Zugriff
- durch ein Proxyobjekt unterstützt
- stellt clientseitiges Gegenstück
zum Serviceexporter dar
- bietet Hilfestellung beim Decodieren
der empfangenen Daten
- Client wird gegen Interface programmiert
- implementiert das ursprüngliche Serviceobjekt
- Übertragung ist transparent
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 128 >> total: 160 Seiten
Spring 3 >> Java Framework >> Remoting
Remoting
Architektur
RMI
Beschreibung
RMI (Remote Method Invocation) erlaubt den Austausch von Objekten in Verteilten
Applikationen.
Spring reduziert Codeaufwand
Spring bietet Integration von JNDI ► CORBA Services
JAXRPC (Java API for XML-based Remote Procedure Calls)
bietet Schnittstelle für Zugriff und die Bereitstellung von RPC-Style SOAP Webservices
JAXRPC
Spring bietet einfache Erstellungsmöglichkeiten von JAXRPC Client Anwendungen
Spring bietet servletbasierte Services durch JAXRPC-Implementierung ►z.B. Apache
Axis
HTTP Invoker
Hessian
Burlap
HTTP Invoker unterstützt Austausch von serialisierten Objekten über HTTP
Spring bietet Serialisierungstechniken
Hessian und Burlap sind Serialisierungsprotokolle von Caucho
► www.caucho.com
Hessian serialisiert binär
Burlap basiert auf XML
ÜBUNG RMI mit Spring
- erstellen Sie einen Remote Service
public interface RemoteService {
public String getMessage();
public void setMessage(String message);
}
- testen Sie einen entsprechenden RMI Client
@Before public void setUp() throws InterruptedException {
server = (RemoteService) ac.getBean("server");
}
@Test public void testRmiClient() throws Exception {
RemoteService client = (RemoteService) ac.getBean("client");
msg = "test Message";
client.setMessage(msg);
server.setMessage(server.getMessage().toUpperCase());
assertEquals(msg.toUpperCase(),client.getMessage());
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 129 >> total: 160 Seiten
Spring 3 >> Java Framework >> Remoting
14.2
wiki
wiki
Spring über HTTP
Das Hypertext Transfer Protocol (HTTP
(HTTP,
HTTP, dt. HypertextHypertext-Übertragungsprotokoll
Übertragungsprotokoll)
ertragungsprotokoll) ist
ein Protokoll zur Übertragung von Daten über ein Netzwerk.
Netzwerk. Es wird eingesetzt,
um Webseiten aus dem World Wide Web (WWW) in einen Webbrowser zu laden.
- erlaubt Administration
- WebServer, BuildTools, etc. ►Maven
- erlaubt Tuning
- Sicherheit / Ausfallsicherheit / Clustering / Skalierbarkeit / Lastverteilung
- Spring bietet modularisierte ContextLoaderListener
- initialisiert Spring Beans im Webkontext ► WEB-INF/web.xml
- Spring Beans haben Zugriff auf Servlets ► MVC
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
HttpInvokerProxy
ttpInvokerProxy
- Enterprise Application basieren mehrheitlich auf HTTP
- Senden und Empfangen von serialierten (Java-) Objekten
- Service als TO (Transferobject)
- ServiceImpl auf WebServer deployed
- JU Testklasse als Client
- SpringClient sendet Request via HttpInvoker
- SpringClient empfängt Request via HttpInvoker
- HttpInvokerProxyFactoryBean ist Proxy
- serialisiert Objekte
- übergibt serialisierte Objekte an Server
<bean id="httpService"
class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
<property name="serviceUrl" value="http://localhost:8080/remoting/http.service" />
<property name="serviceInterface" value="module.spring.httpinvoker.HttpService" />
</bean>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 130 >> total: 160 Seiten
Spring 3 >> Java Framework >> Remoting
HttpInvokerServiceExporter
HttpInvokerServiceExporter
- empfängt und deserialisiert TO
<bean id="proxyService" class="...remoting.httpinvoker.HttpInvokerServiceExporter">
<property name="service" ref="serviceImpl" />
<property name="serviceInterface" value="module.spring.httpinvoker.HttpService" />
</bean>
<bean id="serviceImpl" class="module.spring.httpinvoker.HttpServiceImpl"></bean>
<bean id="urlMapping" class="...web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props><prop key="/http.service">proxyService</prop></props>
</property>
</bean>
<servlet>
<servlet-name>invoke</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>invoke</servlet-name><url-pattern>*.service</url-pattern>
</servlet-mapping>
ÜBUNG HttpInvoker
HttpInvoker
- erstellen Sie einen Service den Sie das HttpInvokerProxy ansprechen
@Test
public void testInvoker() throws Exception {
Service service = new Service("myService");
httpService.setService(service);
assertEquals(service.getName(), httpService.getService().getName());
}
<bean id="httpService" class="...remoting.httpinvoker.HttpInvokerProxyFactoryBean">
<property name="serviceUrl" value="http://localhost:8080/invoke/http.service" />
<property name="serviceInterface" value="module.spring.httpinvoker.HttpService" />
</bean>
- Project dem Webserver zur Verfügung stellen
<Context
docBase="...\spring_httpInvoker\src\main\webapp"
path="/invoke"
reloadable="true"/>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 131 >> total: 160 Seiten
Spring 3 >> Java Framework >> Remoting
M
Spring MVC
Lerninhalte
Spring MVC
DispatcherServlet
Controller
Validierung
View Technologien
Handler Mapping
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 132 >> total: 160 Seiten
Spring 3 >> Java Framework >> MVC
15
MVC
Verteilte Anwendungen haben meist Webinterface ► MVC, MVC2
wiki
Model View Controller (MVC
(MVC,
MVC, Modell/Präsentation/Steuerung) ist ein
Architekturmuster zur Strukturierung von SoftwareSoftware-Entwicklung in die drei
Einheiten Datenmodell,
Datenmodell, Präsentation und Programmsteuerung.
Programmsteuerung. Ziel des Musters
ist ein flexibler Programmentwurf,
Programmentwurf, der eine spätere Änderung oder Erweiterung
erleichtert und eine Wiederverwendbarkeit der einzelnen Komponenten ermöglicht.
- Modell
- enthält Daten, geschäftsfallrelevante Informationen
- wird mit Objekten abgebildet
- View
- entscheidet, wie das Modell dargestellt wird
- entscheidet über die Darstellungssprache, meistens HTML
- Controller
- ist für die Verarbeitung der Anfrage zuständig
- ist für das Zusammenstellen des Modells zuständig
- ist für die Weitergabe an den Client zuständig
Modelodel-Viewiew-Control
- modularisierte Logik
- Requestsparsing ► HandlerMapper
- Businessprozess ►SpringController
- Respondsrendering ► ViewResolver
- erleichtert Weiterentwicklung
- isolierte Module
Web Tier
Request
Erstellung
Controller
Client
Response
Weiterleiten
View
Modell
Service
Fassade
Verwendung
Verwendung
DBMS
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 133 >> total: 160 Seiten
Spring 3 >> Java Framework >> MVC
15.1
Spring MVC
Dispatcher Servlet
- Springs zentraler MVC-Bestandteil
- unterstützt mehrere Protokolle
- HTTP, Hessian, Burlap, etc.
- nimmt Request entgegen
- POST, GET, etc.
- leitet Request weiter ► dispatch
- Controller
- HandlerMapping
- ViewResolver
- Interceptoren
Arbeitsweise
- DispatcherServlet erhält einen HTTP-Request
- leitet diesen an einen Controller weiter
- welcher Controller den Request bekommt, bestimmt das HandlerMapping
- das HandlerMapping bildet URLs auf Controller ab
- im Controller läuft die Logik ab
- Datenstruktur und View wird in einem Objekt ModelAndView an das DispatcherServlet zurückgegeben
- die View rendert den HTTP-Response (Umsetzung)
- der ViewResoler mapped den logischen Namen auf eine View Komponente
- das DispatcherServlet gibt den Response an den Client zurück
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 134 >> total: 160 Seiten
Spring 3 >> Java Framework >> MVC
ÜBUNG MVC
Erstellen Sie eine MVC Template Anwendung
- ► File ►New ► Spring Template Project ► Spring MVC Project
- deployen Sie das MVC Project auf dem SpringSource tc Server
- erzeugen Sie einen eigenen Controller
@Controller
@RequestMapping
public class MyController
@RequestMapping(value =
public void a() {
}
@RequestMapping(value =
public String b() {
return "myView";
}
@RequestMapping(value =
index.jsp
public void index() {
}
}
{
"/a")
// url = /a -> rendert die View a.jsp
"/b")
// url = /b rendert die View myView.jsp
"/index") // url = /index rendert die View
Rendering Requests
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 135 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
16
Inside Spring MVC
Request Object State Diagram
16.1
Dispatcher Servlet
DispatcherServlet dient als Front-Controller
- ist ein Servlet
- definiert durch web.xml der Webanwendung
- handelt URI (Uniform Resource Identifier)
- spezialisert durch servlet-mapping
- z.B. nur die HTML Seiten
- bildet URI auf ein Spring-Bean ab
- z.B. auf einen Controller
- durch Handlermapper
<servlet>
<servlet-name>invoke</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>invoke</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 136 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
16.2
Controller
- implementiert das Controller Interface
- hat nur eine Methode ► handleRequest
- In: HTTPRequest, HTTPResponds
- Out: ModelAndView
- Bearbeitung der HTTP-Requests
- gibt View und Models zurück
- definiert Minimum eines Controllers
public interface Controller {
// Process the request and return a ModelAndView object which
// the DispatcherServlet will render.
ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception;
}
Controller
Klasse
AbstractController
MultiActionController
Beschreibung
um eigene Controller zu implementieren
enthält Basisfunktionalität für die Abarbeitung ►z.B. Caching
erlaubt mehrere Aktionen innerhalb eines Controllers zu sammeln
HTTP-Requests werden auf Methoden des Controllers gemappt
sinnvoll bei modularen Logik mit ähnlicher Funktionalität
AbstractFormController
um eigene Command-Controller zu implementieren
für Erstellung von JavaBeans durch Request Parameter
nützlich für die Validierung von Eingabedaten
unterstützt WebForms ► für Abarbeitung von Client Formularen
SimpleFormController
bietet zusätzliche Funktionalität zu Commands und Views
AbstractCommandController
AbstractWizardFormController
ThrowawayController
erlaubt es, Eingaben auf mehrere Formulare aufzuteilen
nützlich für mehrere Eingabeschritte ► z.B. Wizards
zur Abarbeitung der Request als Commands ► z.B. WebWorkActions
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 137 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
16.2.1
AbstractController
- flexible Entwicklung eines Controllers
- Aktivieren / Deaktivieren von POST / GET Requests
- Unterstützung von Caching
public class ShowBooksController extends AbstractController {
private BookService bookService;
public void setBookService(BookService bookService) {
this.bookService = bookService;
}
protected ModelAndView handleRequestInternal(
HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse) throws Exception {
return new ModelAndView("showBooks", "bookList", bookService.getAllBooks());
}
}
- handleRequestInternal ist zentrale Methode
- implementiert die Abarbeitung des Requests
- enthält Logik oder Delegation
- Returnwert ist Instanz der Klasse ModelAndView
- View ("showBooks") / Modell ("bookList") / Modellobjekt (bookService.getAllBooks())
16.2.2
MultiActionController
- mehrere Controller in einer Implementaion
- abgeleitete Klasse übernimmt HttpRequest / HttpResponse / HttpSession
- gibt ModelAndView zurück
- Property methodNameResolver definiert Methode, die ausgeführt wird
- z.B. internalPathMethodNameResolver extrahiert Methode aus URI
- http://<host>:<port>/module.spring.mvc/Book/showAll ► ruft showAll() der Bean /Book auf
- HttpParameter action definiert Methode, die ausgeführt wird
- z.B. durch ParameterMethodNameResolver
- action="module/spring/mvc/Book"
<form action="module/spring/mvc/Book" method="POST">
<input type="submit" value="show all Books" />
</form>
<a href="module/spring/mvc/Book?action=showBooks">show All Books"</a>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 138 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
Konfiguration
Konfiguration Controller / HandlerMapping / ViewResolver
<beans>

<bean name="createUserForm" class="...Controller">
...
</bean>

<bean id="urlMapping" class="...HandlerMapping">
...
</bean>

<bean id="viewResolver" class="...ViewResolver">
...
</bean>
</beans>
annotierter Controller
- Controller erben Funktionalität oder implementieren ein (Controller-)Interface
- Alternative mit @Controller
- Klasse wird als SpringBean instanziiert
- @RequestMapping wird durch URI aufgerufen
- auf Klasse
- auf Methode
@Controller
public class SimpleBookListController {
@Autowired
private IBookDAO bookDAO;
@RequestMapping("/showBooks.html")
protected @ModelAttribute("bookList")
List<Book> handleRequestInternal() {
return bookDAO.getAll();
}
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 139 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
Formular
Formularbearbeitung
ularbearbeitung
- Daten in Formular eingeben und durch Controller verarbeiten
- User erhält Formular per GET Request und füllt Formular aus
- Formulardaten werden per POST Request an gleichen URI gesandt
@Controller
@RequestMapping(value = "/DeleteByName")
public class BookDeleteByNameController {
@Autowired private IBookDAO bookDAO;
@RequestMapping(method = RequestMethod.GET)
protected ModelAndView showForm() {
return new ModelAndView("nameForm", "name", "");
}
@RequestMapping(method = RequestMethod.POST)
protected String handlePost(@RequestParam("name") String name) {
bookDAO.deleteByName(name);
return "success";
}
}
weitere Unterstützung der Formularbearbeitung durch:
MVC Annotations
Annotation
Einsatz Beschreibung
@Controller
@InitBinder
@ModelAttribute
@RequestMapping
@RequestParam
@SessionAttributes
Type
Method
deklariert eine Klasse als Spring MVC Controller
benutzerdefiniertes Databinding
Parameter bindet ein Modell Attribut an den Parameter
Method
bindet Returnwert der Methode an das Modell
Method
bindet ein URL Muster und/oder eine HTTP Methode an die Methode
Type
bindet ein URL Muster und/oder eine HTTP Methode an den
Controller
Parameter bindet einen Requestparameter an einen Methodenparameter
Type
bindet ein Modellattribut an eine Session

<context:component-scan base-package="module.spring.mvc" />

<mvc:annotation-driven />
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 140 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
ÜBUNG FormForm-Handling Controller
- erzeugen und testen Sie einen Controller, um ein Buch hinzuzufügen
@Controller @RequestMapping("/addBook.htm")
public class AddBookFormController {
@Autowired IBookDAO bookDAO;
@RequestMapping(method = RequestMethod.GET)
public String setupForm(ModelMap model) {
return "addBook";
}
@ModelAttribute("book")
public Book setupBook() {
Book book = new Book();
return book;
}
@RequestMapping(method = RequestMethod.POST)
protected String addBook(@ModelAttribute("book") Book book) {
bookDAO.addBook(book);
return "bookAdded";
}
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 141 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
16.3
wiki
Validierung
In der Softwaretechnik bezeichnet Validierung die Kontrolle eines konkreten
Wertes darauf, ob er zu einem bestimmten Datentyp gehört oder
oder in einem
vorgegebenen Wertebereich oder einer vorgegebenen Wertemenge liegt.
- Gültigkeit
- können die Daten weiter verarbeitet werden
- z.B. Kompatibilität zu Datenbank (Zahl oder Text)
- Typ
- entsprechen die Daten der notwendigen Deklaration
- z.B. Datums-, Zeitwert (TT.MM.YY HH:MM:SS)
- Bereich
- sind die Daten im nutzbaren Bereich
- z.B. innerhalb von nutzbaren Grenzen (Tage: 1 ... 31)
- Sinn und Zweck
- entsprechen die Daten dem Verarbeitungszweck
- z.B. Sonderzeichen bei Email-Adressen ([email protected])
annotationbasierter Controller ist einfach und flexibel anzuwenden ► JSR 303
vordefinierte Annotation zur Validation von Bean Attributen
Annotation
Typen
Beschreibung
@NotNull / @Null
@Min / @Max
@Digits
@Size
@Future / @Past
@Pattern
@Valid
alle
BigDecimal, BigInteger,
byte, short, int, long,
Wrapperklassen
String, Collection, Map, Array
Date, Calendar
String
Objektreferenzen
Attribute muss / Attribute darf nicht gesetzt sein
Ober- und Untergrenze für numerische Werte
Vor- und Nachkommastellen für einen
numerischen Wert
definiert die Grösse von Collections
definert die Gültigkeit für einen Datumswert
definiert eine Regex für ein Attribut
refernzierte Elemente werden [auch] validiert
Validation der ISBN
@NotNull
@Size(min = 10, max = 10)
@IsISBN
// selbstdefinierte Validierung
@Pattern(regexp = "^ISBN\\s(?=[-0-9xX ]{13}$)(?:[0-9]+[- ]){3}[0-9]*[xX0-9]$")
private String ISBN;
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 142 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
selbstdefinierte Validierung
@Target( { ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = { IsISBNValidator.class })
public @interface IsISBN {
String message() default "no ISBN";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
public class IsISBNValidator implements ConstraintValidator<IsISBN, String> {
public void initialize(IsISBN constraintAnnotation) { }
public boolean isValid(String isbn, ConstraintValidatorContext context) {
return (isbn.length() == 10);
}
}
- Validation-Payload
- erlaubt die Zuordnung beliebiger Metadaten zu einem Constraint
Payload zur
zur metadatenbasierten Validierung
- Constraint Annotationen müssen ein Payload-Element definieren
- Default Wert muss ein leeres Array sein
Class<? extends Payload>[] payload() default {};
Anwendungsbeispiel
public static class Info implements Payload {};
public static class Error implements Payload {};
public class Address {
@NotNull(message="keine Adresse",payload=Severity.Info.class)
public String getZipCode() {...}
@NotNull(message="ungültiger Ort", payload=Severity.Error.class)
String getCity() {...}
}
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 143 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
16.4
View Technologien
- JSP View (Java Server Pages)
- Unterstützung durch Spring Tag Library
- XSLT View (Extensible Stylesheet Language Transformation)
- übersetzt XML in andere Dokumentform, z.B. XML-HTML
- Excel View
- erstellt Excel Datasheets
public class BookListExcelView extends AbstractExcelView {
protected void buildExcelDocument(Map model, HSSFWorkbook workbook,
HttpServletRequest request, HttpServletResponse response) { ...
- PDF View (Portable Document Format)
- für Weitergabe von Information
- Druckindustrie
public class BookListPdfView extends AbstractPdfView {
protected void buildPdfDocument(Map model, Document document, PdfWriter writer,
HttpServletRequest request,HttpServletResponse response) throws Exception { ...
weitere View Technologoien
- JasperReports
- generiert Reports
- Liste von Datenbeständen
- Tiles
- View aus einzelnen Komponenten zusammensetzen
- Velocity, Freemaker, etc.
- Template für dynamische Inhalte
- Atom, RSS, etc.
- Feeds in Form von News, Blogs, etc.
- Document Views
- PDF
- Excel
- JSON Mapping
- JavaScript Object Notation
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 144 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
16.4.1
ViewResolver
Views werden anhand des Namens spezifiziert
- ModelAndView enthält logischen Namen der View-Komponente
- z.B: "showBooks"
- Views sind Klassen, die das Interface View implementieren
- erhalten Methoden, z.B. render
- um die Daten aus dem Modell dem Client zu präsentieren
- View-Resolving mapped logischer Name zur passenden View
- Dispatcher Servlet gibt View Komponente an Request
- wird kein Name angegeben
- DefaultRequestToViewNameTranslator bildet URL auf den Namen der View ab
- z.B. http://www.localhost:8080/library/FindAllBooks ►FindAllBooks
<bean id="viewnameTranslator" class="...DefaultRequestToViewNameTranslator">
<property name="stripExtension" value="false" />
<property name="stripLeadingSlash" value="fasle" />
</bean>
Spring offeriert zusätzlich unterschiedliche Implementierungen
Implementierungen
Controller
Klasse
Beschreibung
InternalResourceViewResolver
löst die logischen Viewnamen in View-Objekte auf, die
durch Template-Files gerendert werden
(wie JSP oder Velocity-Templates)
BeanNameViewResolver
sucht in der Konfiguration des Dispatcherservlets nach
Beans mit der passenden ID
ResourceBundleViewResolver
löst logische Namen durch Schlüssel in einem
ResourceBundle auf
XmlViewResolver
sucht in einem XML-File nach Beans mit der
passenden ID
AbstractViewResolver
abstrakter ViewResolver mit Unterstützung für das
Cachen von Views
UrlBasedViewResolver
übersetzt den Namen einer View in eine URL
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 145 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
Beispiel InternalResourceViewResolver
- JSP als View Element verwendet die Klasse InternalResourceViewResolver
- definiert durch die XML Konfiguration des DispatcherServlet
<bean id="viewResolver" class="...web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<property name="prefix" value="WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
- InternalResourceViewResolver sucht nach einem File im Webpfad
- zusammengesetzt aus dem logischen Namen und den Properties prefix und suffix
- z.B. /WEB-INF/jsp/showBooks.jsp
- Request wird an die Klasse JstlView weitergeleitet
- mitgeliefert wird JSTL (JavaServer Pages Standard Tag Library)
- um Jakarta Tiles in die View einer Spring-MVC-Anwendung zu integrieren
- erstelltes View-Objekt wird vom ViewResolver dem DispatcherServlet zurückgeliefert
- DispatcherServlet ruft dann die View zur Darstellung des Models auf
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 146 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
16.5
HandlerMapping
HandlerMapping steuert das Weiterleiten des Requests
- DispatcherServlet sucht nach Implementierungen des Interface HandlerMapping
HandlerMapping
Klasse
Beschreibung
BeanNameUrlHandlerMapper
implementiert direkte Abbildung von URLs auf Beans
SimpleUrlHandlerMapping
konfigurierbare Abbildung von URLs auf Beans
DefaultAnnotationHandlerMapping unterstützt annotierte Controller, Nachteil ► URL im Source
<bean id="urlMapping" class="...web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="/createBook.htm">createBookForm</prop>
<prop key="/deleteBook.htm">deleteBookForm</prop>
<prop key="/showBooks.htm">showBooksController</prop>
</props>
</property>
</bean>
HandlerInterceptor
- definiert Interceptor für einen Handler
HandlerInterceptorMethoden
Methode
Beschreibung
preHandle()
wird aufgerufen vor der Ausführung des Handlers
postHandle()
postHandle()
wird aufgerufen nach der Ausführung des Handlers
afterCompletition()
wird aufgerufen nach Fertigstellung des Requests
- Beispile für den Anwendungsbereich
HandlerInterceptor
Methode
Beschreibung
UserRoleAuthorizationInterc
UserRoleAuthorizationInterceptor
überprüft die Rolle des Benutzers
OpenSessionViewInterc
OpenSessionViewInterceptor
bindet [Hibernate]-Session an HTTP Thread
LocaleChangeInterc
LocaleChangeInterceptor
ermöglicht, Locale zu manipulieren (Land, Sprache)
TimeChangeInterc
TimeChangeInterceptor
ermöglicht, Time zu manipulieren
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 147 >> total: 160 Seiten
Spring 3 >> Java Framework >> Inside Spring MVC
N
Spring Security
Lerninhalte
Servlet Filter
Autorisierung
Programatische Security
Spring Security Namespace
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 148 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Security
17
Spring Security
Spring lässt Sicherheitsartefakte einfach integrieren
-
Authentifizierung
Web Autorisierung
Methoden Autorisierung
Security Expressions
Spring Security Framework
org.springframework.security.
JAR
Zweck
spring-security
-core
Authentication und Access-Contol, Remoting Support
-web
Filters, Web-Security Infrastructure mit Servlet API Abhängigkeit
-config
Namespace Parsing
-ldap
LDAP Authentication
-acl
Domain Object ACL (Access Control List) Implementation
Spring Security's CAS (Central Authentication Service) Client
Integration
OpenID Web Authentication Support
-cas-client
-openid
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 149 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Security
17.1
Authentifizierung
- Prozess zur Behauptung und/oder Erbringen des Nachweis zur Idenfikation
- z.B. Username / Passwort
- Spring bietet umfangreichen Support zur Realm Authentifizierung
- Databanken
- LDAP ► Lightweight Directory Access Protocol
- OpenID ► dezentrales Authentifizierungssystem für Webseiten
- CAS ► (Microsoft) Code Access Security
Beispiel: JDBC User Service
<authentication-manager>
<authentication-provider>
<jdbc-user-service data-source-ref=”dataSource” />
</authentication-provider>
</authentication-manager>
17.2
Autorisierung
- Spring erleichert durch Expression Language die Autorisierung
- die Expression beinhaltet und nimmt Bezug auf
- den Benutzer
- die Rolle
- den Status der Authentifizierung
User Based Expressions
Expression
Beschreibung
authentication
SecurityContext Objekt der Benutzer Authentifizierung
principal
Authentifizierungs Objekt des momentanen Benutzers
User Based Expressions in Web Context
Expression
Beschreibung
request
referenziert HttpServletRequest
hasIpAddress(ipAddr) referenziert IpAdresse ► nach IP/Netmask Notation
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 150 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Security
Expressions für den Authentifizierungsstatus
Authentifizierungsstatus und die Benutzerrollen
SecurityExpressionRoot
Expression
Beschreibung
permitAll
immer true
denyAll
immer false
isAnonymous()
anonymer Benutzer
isAutehticated()
nicht-anonymer Benutzer
isRememberMe()
authentifizierter Benutzer durch RemenberMe
weder "nicht-anonymer"
noch "RemenberMe" Benutzer
Benutzer mit definierter Rolle
isFullyAutehticated()
hasRole(role)
hasAnyRole(r1, r2, ...) Benutzer mit einer der definierten Rollen
17.2.1
Web-Autorisierung
- Autorisierung definert Zugriffskontrolle auf Resourcen
- per URL
- per URL/HTTP
URL Autorisierung durch Expression ermöglichen
<http auto-config=”true” use-expressions=”true”>
<intercept-url> Tag
Tag
Beschreibung
pattern
URL Pattern ► ANT -und/oder Regex Syntax
method
HTTP Methode als zusätzlicher Filter
access
zusätzliches Filterkriterium ► Regex
filters
"none" unterbindet die Spring Security Filter Kette
requires-channel
"http" oder "https"
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 151 >> total: 160 Seiten
Required
Spring 3 >> Java Framework >> Spring Security
Beispiele ► Web Security Expressions
<http use-expressions="true">

<intercept-url pattern="/admin*"
access="hasRole('admin') and hasIpAddress('192.168.1.0/24')"/>
</http>

<intercept-url pattern=”/images/**” filters=”none” />

<intercept-url pattern=”/home” method=”GET” access=”permitAll” />

<intercept-url pattern=”/users” method=”POST”
access=”isAnonymous()”/>
17.2.2
HTTP Autorisierung über URL-Patterns ► Frontend
- durch URL Interceptor
<http auto-config="true">
<intercept-url pattern="/app/**" access="ROLE_USER" />
<intercept-url pattern="/admin/**" method="POST"
requires-channel="https" access="ROLE_ADMIN" />
</http>
<authentication-provider>
<user-service>
<user name="user" password="spring" authorities="ROLE_USER" />
<user name="admin" password="geheim" authorities="ROLE_USER, ROLE_ADMIN" />
</user-service>
</authentication-provider>
<http use-expressions="true">
<intercept-url pattern="/secure/**"
access="hasRole('admin) and hasIpAddress('192.168.1.0/24')" />
</http>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 152 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Security
Interceptor Varianten
- für Service Bean
<beans:bean id="myService" class="module.security.BookServiceImpl">
<intercept-methods>
<protect method="create*" access="ROLE_ADMIN" />
</intercept-methods>
</beans:bean>
- als globaler PointCut ►AspectJ
<global-method-security>
<protect-pointcut
expression="execution(* module.spring.security.*Service.*(..))"
access="ROLE_USER,ROLE_ADMIN" />
</global-method-security>
17.3
Servlet Filter
- durch DelegatingFilterProxy
- deligiert URL an springSecurityFilterChain
<filter>
<filter-name>springSecurityFilterChain</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
<filter-name>springSecurityFilterChain</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
- einfache Abbildung auf Views
- z.B. /app/showBooks ► /showBooks
<filter>
<filter-name>UrlRewriteFilter</filter-name>
<filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>UrlRewriteFilter</filter-name>
<url-pattern>
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 153 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Security
17.4
Autorisierung auf Methodenebene ► Service Layer
- Annotations ► Framework-spezifische / JSR 250 (EJB 3)
- AOP Alliance Interceptor ► Proxy-basierter Ansatz
- AspectJ Interceptor ► Proxy-basierter Ansatz
Autorisierung durch Annotations
- ermöglicht Autorisierung durch Annotations ► global-method-security
<global-method-security pre-post-annotations="enabled"/>
<global-method-security secured-annotations="enabled"
jsr250-annotations="disabled" />
Autorisierung über Annotations auf Methoden oder Klassen/Interfaces
public interface BookService {
@Secured( { "ROLE_USER" })
public void createBook();
}
- überprüft die Rolle vor der Ausführung
@PreAuthorize("hasPermission('PERMISSION_CREATE')")
@RequestMapping(value = "/createBook")
public void createBook() {...
- überprüft die Berechtigung durch einen PermissionEvaluator
- z.B. erlaut dem "admin" Bücher zu löschen
@PreAuthorize("hasPermission(#book, 'admin')")
@RequestMapping(value = "/deleteBook")
public void deleteBook(Book book, Permission permission) {...
- erlaubt einen Benutzer "seine" Bücher zu löschen
@PreAuthorize("#book.owner == principal.name)")
@RequestMapping(value = "/deleteBook")
public void deleteBook(Book book) {
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 154 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Security
- Filtert die Methode beim Verlassen
-
durch @PostFilter Annotation
Spring iteriert durch zurückgegebene Collection
entfernt alle Elemente, für welche die Expression <false> ist
filterObject referenziert das aktuelle Objekt in der Collection
@PreAuthorize("hasRole('ROLE_USER')")
@PostFilter("hasPermission(filterObject, 'read') or hasPermission(filterObject, 'admin')")
public List getAllBooks() {
17.5
Programmatische Security
- SecurityContextHolder
- hält einen SecurityContext ► das aktuelle Authentication Objekt
- ThreadLocal (Standard), InheritableThread-Local, Global oder benutzerdefinierte Klasse
- UserDetails
- beschreibt einen Benutzer als Prinzipal
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
UserDetails ud = (UserDetails) auth.getPrincipal();
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 155 >> total: 160 Seiten
Spring 3 >> Java Framework >> Spring Security
O
Trends
Lerninhalte
Agil
Groovy
DSL – Domain Specifi Languages
NoSQL – Not Only SQL
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 156 >> total: 160 Seiten
Spring 3 >> Java Framework >> Programmierparadigma
18
Programmierparadigma
Lat: <Paradigma
Paradigma>
Paradigma = begreiflich machen, (para = neben) und (digma = zeigen)
wiki
Ein Programmierparadigma
Programmierparadigma ist das einer Programmiersprache oder
Programmiertechnik zugrunde liegende Prinzip.
Prinzip.
(einige) bekannte (Programmier)-Paradigmen
Struktur
- Strukturiert (WIE)
- Imperativ (lineare Folge von Befehlen)
- Prozedural (in Teilaufgaben zerlegt)
- Modular (Module als logische Einheiten, Funktion und Daten)
Deklaration
- Deklarativ (WAS)
- Funktional (ergebnisorientiert)
- Logisch (logikbasiert)
- Orientiert (WOZU)
Orientation
- Objekt (Kommunikation, polymorph – mehrere Formen)
- Komponenten (abstrakt)
- Aspekt (orthogonal freie Kombinierbarkeit unabhängiger Konzepte)
- Agil (DRY Don't Repeat Yourself)
18.1
Agilität
Agiles Programmieren
Lat: <agilis
agilis>
agilis = flink, beweglich (Agile Softwareentwicklung reduziert Aufwand und Regeln)
Skript- vs. Programmiersprachen
Ziel
Einsatz
Ausführung
Skriptsprache
Kombination bestehender
Bausteine (Shell-Skript),
Bibliotheken (Perl, Python)
spezifisch:
GUI (JavaScript),
Reporting (Perl)
interpretiert oder Bytecode
Typisierung schwach, flexibel, dynamisch
schnelle Entwicklung (Python),
Vorteile
Prototypen (Shell-Skript),
kleine Systeme (Perl)
Programmiersprache
Neuentwicklungen (C, C++)
allgemein
kompilierter Maschinencode
streng, flexibel
effiziente Anbindung,
Ausnutzung von Ressourcen
(C++, Java)
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 157 >> total: 160 Seiten
Spring 3 >> Java Framework >> Programmierparadigma
Historie der Skriptsprachen
JCL 1963
(Job Control Language)
AWK 1977
1977
Sh 1978
1978
(Aho Weinberger Kernighan)
(Bourne Shell)
Perl 1987
(Practical
(Practical Extraction and Report Language)
Tcl 1988
1988
Python 1990
1990
(Tool Command Language)
Language)
(Monthy Python)
Python)
PHP 1995
1995
Ruby 1995
1995
JavaScript 1995
1995
(Personal Home Page)
Page)
(Eng: Rubin)
Rubin)
(ECMA 262)
Groovy 2003
(JSR 241)
241)
18.2
wiki
Groovy
dynamisch typisierte ProgrammierProgrammier- und Skriptsprache für die Java VM
verbindet JavaJava-Syntax mit den Konzepten von Ruby.
Ruby.
Groovy
Groovy ermöglicht:
-
pragmatisches (selbsterklärend)
extremes (code a little, test a little)
agiles (YWGWYS)
funktionales (funktionale Abhängigkeiten)
objektorientiertes (alles sind Objekte)
abstrahiertes (wieder verwendbarer Code)
effizientes (weniger Codeumfang)
einfaches (Syntax)
Programmieren.
Paradigmen
objektorientiert,
Skriptsprache,
teilweise deklarativ
Erscheinungsjahr 2003
Entwickler
The Codehaus
Aktuelle Version 1.7 (2010)
Typisierung
stark, statisch, dynamisch
Betriebssystem
plattformunabhängig
Lizenz
Open Source,
Apache Software License 2.0
Groovy. Codehaus
http://groovy.codehaus.org/
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 158 >> total: 160 Seiten
Spring 3 >> Java Framework >> Programmierparadigma
18.3
wiki
DSL Domain Specific Language
Eine domänenspezifische Sprache (engl. domaindomain-specific language,
language, DSL) ist eine
formale Sprache,
Sprache, die speziell für ein bestimmtes Problemfeld (die Domäne)
Domäne)
entworfen und implementiert wird. Beim Entwurf einer DSL wird man bemüht
sein, einen hohen Grad an Problemspezifität zu erreichen: die Sprache soll alle
Probleme der Domäne darstellen können und nichts darstellen können, was
auss
ausserhalb
sserhalb der Domäne liegt. Dadurch ist sie durch Domänenspezialisten ohne
besonderes Zusatzwissen bedienbar.
Idee
-
weniger Redundanz
deklarative Beschreibung eines Sachverhaltes
HTTP
bessere Lesbarkeit
weniger technischer Code
domänenspezifische, statische Validierung
leichte Erlernbarkeit, aufgrund des beschränkten Umfangs
DSL
18.4
wiki
Domain
DSL
http
Deamon
SQL
DBMS
Domain
NoSQL (Not only SQL)
NoSQL is a movement promoting a loosely defined class of nonnon-relational data
stores that break with a long history of relational databases. These data stores
may not require fixed table schemas,
schemas, usually avoid join operations and typically
scale horizontally.
horizontally.
im Web 2.0 sind schreibende Zugriffe wichtig (nicht nur lesende)
- für Anwendungen, bei denen endgültige Konsistenz der Daten gewährleistet sein muss
- Twitter
- Facebook
- traditionell: RDBMS
-
Constraints
Transaktionen
Locking
SQL
- RDBMS haben Probleme mit der Verarbeitung und Skalierung grosser Datenmengen
- neuer Ansatz
- NoSQL z.B. "Key/Value" Storage
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 159 >> total: 160 Seiten
Spring 3 >> Java Framework >> Programmierparadigma
P
Referenzen
Lerninhalte
Bücher
Referenzen
© 2011 >> Stephan Metzler >> V 2.1 >> Seite 160 >> total: 160 Seiten
Spring 3 >> Java Framework >> Anhang
19
Anhang
Bücher
ISBN
Titel
978-3-89864-572-0
Spring3
978-3-446-41240-8
Spring im Einsatz
987-3-89864-431-0
EJB 3 professionell
0-13-142246-4
Core J2EE Patterns, Best Practices and Design Strategies
1-932394-88-5
978-3-939084-24-2
3-935042-96-5
Java Persistence with Hibernate
Java EE 5 Architekturen
Hibernate und das Java Persistence API
Online Referenzen
URL
http://www.springsource.com
Inhalt
Spring Framework