Spring im Einsatz

Inhalt

Vorwort

Danksagungen

Zu diesem Buch

Teil I: Der Kern von Spring

1 Spring ins kalte Wasser

1.1 Vereinfachte Java-Entwicklung

1.1.1 Die Kraft der POJOs entfesseln

1.1.2 Abhängigkeiten injizieren

1.1.3 Aspekte anwenden

1.1.4 Boilerplate-Code durch Vorlagen eliminieren

1.2 Beans im Container

1.2.1 Mit einem Anwendungskontext arbeiten

1.2.2 Ein Bohnenleben

1.3 Begutachtung der Spring-Landschaft

1.3.1 Die Spring-Module

1.3.2 Das Spring-Portfolio

1.4 Was ist neu?

1.4.1 Was ist neu bei Spring.2.5?

1.4.2 Was ist neu bei Spring.3.0?

1.4.3 Was ist neu im Spring-Portfolio?

1.5 Zusammenfassung

2 Verschalten von Beans

2.1 Deklarieren von Beans

2.1.1 Das Setup der Spring-Konfiguration

2.1.2 Eine einfache Bean deklarieren

2.1.3 Injektion über Konstruktoren

2.1.4 Geltungsbereiche für Beans

2.1.5 Beans initialisieren und zerstören

2.2 Injektion in Bean-Eigenschaften

2.2.1 Einfache Werte injizieren

2.2.2 Andere Beans referenzieren

2.2.3 Eigenschaften mit dem Spring-Namensraum p verschalten

2.2.4 Collections miteinander verschalten

2.2.5 Nichts (null) verschalten

2.3 Mit Ausdrücken verschalten

2.3.1 SpEL-Grundlagen

2.3.2 Operationen mit SpEL-Werten ausführen

2.3.3 Collections in SpEL

2.4 Zusammenfassung

3 Die XML-Konfiguration in Spring minimalisieren

3.1 Bean-Eigenschaften automatisch verschalten

3.1.1 Die vier Typen des Autowiring

3.1.2 Standard-Autowiring

3.1.3 Gemischter Einsatz von automatischer und expliziter Verschaltung

3.2 Verschalten mit Annotationen

3.2.1 Die Arbeit mit @Autowired

3.2.2 Auf Standards basierendes Autowiring mit @Inject

3.2.3 Annotationsinjektion und Expressions

3.3 Automatische Erkennung von Beans

3.3.1 Beans für Autodiscovery annotieren

3.3.2 Filtern mit component-scan

3.4 Die Java-basierte Konfiguration von Spring

3.4.1 Java-basierte Konfiguration einrichten

3.4.2 Eine Konfigurationsklasse definieren

3.4.3 Eine einfache Bean deklarieren

3.4.4 Injizieren mit der Java-basierten Konfiguration von Spring

3.5 Zusammenfassung

4 Aspektorientierung

4.1 Einführung in AOP

4.1.1 Die Terminologie zu AOP

4.1.2 Die AOP-Unterstützung in Spring

4.2 Joinpoints mit Pointcuts auswählen

4.2.1 Pointcuts schreiben

4.2.2 Der bean()-Bezeichner von Spring

4.3 Aspekte in XML deklarieren

4.3.1 Before- und After-Advice deklarieren

4.3.2 Around-Advice deklarieren

4.3.3 Parameter an Advices übergeben

4.3.4 Neue Funktionalitäten mit Aspekten

4.4 Aspekte annotieren

4.4.1 Around-Advices annotieren

4.4.2 Argumente an annotierte Advices übergeben

4.4.3 Introductions annotieren

4.5 AspectJ-Aspekte injizieren

4.6 Zusammenfassung

Teil II: Wesentliches über Spring-Anwendungen

5 Zugriff auf die Datenbank

5.1 Die Philosophie des Datenzugriffs in Spring

5.1.1 Die Exception-Hierarchie beim Datenzugriff in Spring

5.1.2 Datenzugriffsschablonen

5.1.3 Klassen für den DAO-Support

5.2 Datenquelle konfigurieren

5.2.1 JNDI-Datenquellen verwenden

5.2.2 Pooldatenquelle verwenden

5.2.3 Auf JDBC-Treiber basierende Datenquelle

5.3 JDBC und Spring gemeinsam verwenden

5.3.1 Wie man JDBC-Code in den Griff bekommt

5.3.2 Mit JDBC-Vorlagen arbeiten

5.4 Hibernate und Spring integrieren

5.4.1 Hibernate – ein Überblick

5.4.2 Wie man eine Hibernate-Session-Factory deklariert

5.4.3 Spring-freies Hibernate bauen

5.5 Spring und die Java Persistence API

5.5.1 Entity-Manager-Factory konfigurieren

5.5.2 DAO auf JPA-Basis erstellen

5.6 Zusammenfassung

6 Transaktionen verwalten

6.1 Grundlagen zu Transaktionen

6.1.1 Transaktionen – mit vier Wörtern erklärt

6.1.2 Spring-Support für die Transaktionsverwaltung

6.2 Auswahl eines Transaktionsmanagers

6.2.1 JDBC-Transaktionen

6.2.2 Hibernate-Transaktionen

6.2.3 JPA-Transaktionen

6.2.4 JTA-Transaktionen

6.3 Transaktionen in Spring programmieren

6.4 Transaktionen deklarieren

6.4.1 Transaktionsattribute definieren

6.4.2 Transaktionen in XML deklarieren

6.4.3 Annotationsgetriebene Transaktionen definieren

6.5 Zusammenfassung

7 Webapplikationen mit Spring MVC erstellen

7.1 Der Start mit Spring MVC

7.1.1 Einem Request durch Spring MVC folgen

7.1.2 Das Setup von Spring

7.2 Einen Basis-Controller schreiben

7.2.1 Konfiguration eines annotationsgetriebenen Spring MVC

7.2.2 Den Homepage-Controller definieren

7.2.3 Auflösung von Views

7.2.4 Definition der Homepage-View

7.2.5 Den Spring-Anwendungskontext vervollständigen

7.3 Controller-Input bearbeiten

7.3.1 Controller schreiben, der Input verarbeitet

7.3.2 Den View darstellen

7.4 Formulare verarbeiten

7.4.1 Das Registrierungsformular darstellen

7.4.2 Formulareingaben verarbeiten

7.4.3 Eingaben validieren

7.5 Der Umgang mit Datei-Uploads

7.5.1 Datei-Upload-Feld im Registrierungsformular

7.5.2 Hochgeladene Dateien empfangen

7.5.3 Spring für Datei-Uploads konfigurieren

7.6 Zusammenfassung

8 Die Arbeit mit Spring Web.Flow

8.1 Installieren von Spring Web.Flow

8.1.1 Konfigurieren von Web.Flow in Spring

8.2 Die Komponenten eines Flows

8.2.1 Zustände

8.2.2 Transitionen

8.2.3 Ablaufdaten

8.3 Zusammensetzen der Einzelteile: Der Pizza-Ablauf

8.3.1 Definieren des Basisablaufs

8.3.2 Kundeninformationen sammeln

8.3.3 Eine Bestellung bilden

8.3.4 Zahlungsannahme

8.4 Absichern von Web-Flows

8.5 Zusammenfassung

9 Spring absichern

9.1 Einführung in Spring Security

9.1.1 Der Start mit Spring Security

9.1.2 Der Konfigurationsnamensraum von Spring Security

9.2 Webanfragen absichern

9.2.1 Proxys für Servlet-Filter erstellen

9.2.2 Minimale Websicherheit konfigurieren

9.2.3 Requests abfangen

9.3 Die Absicherung von Elementen auf View-Ebene

9.3.1 Der Zugriff auf Authentifizierungsdetails

9.3.2 Darstellung nach jeweiliger Befugnis

9.4 Benutzer authentifizieren

9.4.1 Konfiguration eines speicherresidenten User-Repositorys

9.4.2 Authentifizierung gegenüber einer Datenbank

9.4.3 Authentifizierung gegenüber einem LDAP-Repository

9.4.4 Die Funktionalität „Auf diesem Computer merken“

9.5 Methoden sichern

9.5.1 Mit @Secured annotierte Methoden sichern

9.5.2 @RolesAllowed von JSR-250 verwenden

9.5.3 SpEL-Sicherheit mit Pre- und Post-Invocation

9.5.4 Sicherheits-Pointcuts auf Methodenebene deklarieren

9.6 Zusammenfassung

Teil III: Spring integrieren

10 Die Arbeit mit Remote-Diensten

10.1 Das Spring-Remoting im Überblick

10.2 Die Arbeit mit RMI

10.2.1 Einen RMI-Service exportieren

10.2.2 Einen RMI-Service verschalten

10.3 Remote-Services mit Hessian und Burlap veröffentlichen

10.3.1 Bean-Funktionalitäten mit Hessian und Burlap verfügbar machen

10.3.2 Zugriff auf Hessian-/Burlap-Services

10.4 Springs HTTP-Invoker verwenden

10.4.1 Beans als HTTP-Services verfügbar machen

10.4.2 Zugriff auf Services via HTTP

10.5 Webservices veröffentlichen und weiterverarbeiten

10.5.1 Spring-fähige JAX-WS-Endpunkte erstellen

10.5.2 JAX-WS-Services auf Client-Seite mit Proxy versehen

10.6 Zusammenfassung

11 Spring und REST

11.1 Representational State Transfer (REST)

11.1.1 Die Grundlagen von REST

11.1.2 Wie Spring REST unterstützt

11.2 Ressourcenorientierte Controller schreiben

11.2.1 Analyse eines nicht-REST-konformen Controllers

11.2.2 REST-konforme URLs bearbeiten

11.2.3 Die REST-Verben ausführen

11.3 Ressourcen repräsentieren

11.3.1 Die Repräsentation der Ressource verhandeln

11.3.2 Die Arbeit mit HTTP-Nachrichtenkonvertierern

11.4 REST-Clients schreiben

11.4.1 Die Operationen von RestTemplate

11.4.2 Ressourcen mit GET bekommen

11.4.3 Ressourcen mit PUT beziehen

11.4.4 Ressourcen mit DELETE löschen

11.4.5 Ressourcendaten mit POST zum Server bringen

11.4.6 Ressourcen austauschen

11.5 REST-konforme Formulare übermitteln

11.5.1 Versteckte Methodenfelder in JSP darstellen

11.5.2 Den echten Request demaskieren

11.6 Zusammenfassung

12 Messaging in Spring

12.1 Kurze Einführung in JMS

12.1.1 Die Architektur von JMS

12.1.2 Die Vorteile von JMS

12.2 Einen Message-Broker in Spring einrichten

12.2.1 Erstellen einer ConnectionFactory

12.2.2 Deklaration eines Nachrichtenendpunkts für ActiveMQ

12.3 Das JMS-Template von Spring

12.3.1 Umgang mit unübersichtlichem JMS-Code

12.3.2 Die Arbeit mit JMS-Templates

12.4 Erstellung nachrichtengetriebener POJOs

12.4.1 Erstellen eines Message-Listeners

12.4.2 Message-Listener konfigurieren

12.5 Die Arbeit mit nachrichtenbasierten RPCs

12.5.1 Die Arbeit mit nachrichtengetriebenen RPC in Spring

12.5.2 Asynchrones RPC mit Lingo

12.6 Zusammenfassung

13 Verwalten von Spring-Beans mit JMX

13.1 Spring-Beans als MBeans exportieren

13.1.1 Methoden über den Namen bereitstellen

13.1.2 Über Interfaces, die Operationen und Attribute von MBeans definieren

13.1.3 Die Arbeit mit von Annotierungen gesteuerten MBeans

13.1.4 Der Umgang mit MBean-Kollisionen

13.2 Remoting von MBeans

13.2.1 Exportieren von Remote-MBeans

13.2.2 Zugriff auf Remote-MBeans

13.2.3 Proxy für MBeans

13.3 Der Umgang mit Benachrichtigungen

13.3.1 Auf Benachrichtigungen lauschen

13.4 Zusammenfassung

14 Krimskrams

14.1 Die Konfiguration auslagern

14.1.1 Property-Placeholder ersetzen

14.1.2 Eigenschaften überschreiben

14.1.3 Externe Eigenschaften verschlüsseln

14.2 JNDI-Objekte verschalten

14.2.1 Die Arbeit mit konventionellem JNDI

14.2.2 Injektion von JNDI-Objekten

14.2.3 Verschaltung von EJBs in Spring

14.3 Der E-Mail-Versand

14.3.1 Konfiguration eines Mail-Senders

14.3.2 Konstruktion der E-Mail

14.4 Scheduling und Hintergrundaufgaben

14.4.1 Geplante Methoden deklarieren

14.4.2 Asynchrone Methoden deklarieren

14.5 Zusammenfassung

14.6 Das Ende …?

Register