Spring mit einer Webanwendung mit JPA und Validierung (Tutorial)

Dieser Beitrag ist Teil einer (Tutorial-) Serie über die Einführung in das Spring Framework und beschreibt das Erstellen einer Webanwendung mit der Verwendung von JPA und Validierung im Spring Framework.

Die Struktur des Projektes

Dieses Beispiel baut auf dem vorherigem Beispiel Spring mit einer einfachen Webanwendung und dem Beispiel Spring mit JPA und Hibernate jeweils in der Version 1.x auf. Die verwendeten Frameworks und Werkzeuge sind hier beschrieben. In diesem Beispiel werden die folgenden Technologien des Spring Frameworks vorgestellt:

• Die Validierung mit dem JSR 303.
• Einen eigenen Validator mit Meldungen erstellen.
• Formulare mit Spring Framework MVC erstellen.
• Das Erstellen eines JUnit Test mit Spring Test, Hamcrest und Mockito.

In der folgenden Bildergalerie sind die benötigten Bibliotheken pro Eclipse Projekt dargestellt und die Erweiterung, die am Web Projekt nötig sind.

Die Literaturempfehlungen für dieses Beispiel

• Referenzdokumentation des Spring Framework’s
• Spring 3: Framework für die Java-Entwicklung (*)

Die Verbindung zwischen den Modulen herstellen

Zwischen dem Web Projekt und dem Projekt mit dem Service der Fahrerverwaltung muss eine Verbindung geschaffen werden. Dazu muss in der Konfiguration des Web-Projektes die Verweise auf die Konfiguration der fachlichen Spring Beans erweitert werden.

    <!-- Die projektspezifischen Konfigurationen laden -->
    <import resource="classpath:/META-INF/spring/db.xml" />
    <import resource="classpath:/de/rahn/validation/validation.xml" />
    <import resource="classpath:/de/rahn/services/drivers/drivers.xml" />

Die Anpassungen an der Fahrerverwaltung

Zusätzlich wird noch in der XML Konfiguration für die Datenbankeinstellungen ein Transformer (Spring Bean Post Prozessor) für die Ausnahme javax.persistence.PersistenceException definiert. Dieser Transformer wandelt die JPA-spezifischen Ausnahmen zu Spring Framework Ausnahmen vom Typ org.springframework.dao.DataAccessException um.

    <!-- Die Transformation der Ausnahmen -->
    <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"
        p:proxyTargetClass="true" />

Die Änderung am generischen DAO

Im Initialisierer des AbstractGenericDAO<Entity, PrimaryKey> werden die parametrisierten Typen der generischen Klasse ausgewertet. Wurde aber durch Spezialisierung die Anzahl der parametrisierten Typen reduziert, dann muss die Methode getClass().getGenericSuperclass() nicht unbedingt einen ParameterizedType zurück liefern. Daher muss die Vererbungshierarchie durchgegangen werden, bis wieder zwei parametrisierte Typen vorhanden sind.

    {
        Class<?> clazz = getClass();
        ParameterizedType parameterizedType = null;
        while (parameterizedType == null
            || parameterizedType.getActualTypeArguments().length < 2) {
            Type type = clazz.getGenericSuperclass();

            if (type instanceof ParameterizedType) {
                parameterizedType = (ParameterizedType) type;
                type = parameterizedType.getRawType();
            }

            if (type instanceof Class) {
                clazz = (Class<?>) type;
            }
        }
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();

        @SuppressWarnings("unchecked")
        Class<Entity> entityClass = (Class<entity>) actualTypeArguments[0];
        this.entityClass = entityClass;

        @SuppressWarnings("unchecked")
        Class<PrimaryKey> primaryKey =
            (Class<PrimaryKey>) actualTypeArguments[1];
        this.primaryKeyClass = primaryKey;
    }

Die Validierung mit JSR 303

Der Service der Fahrerverwaltung soll um eine Validierung nach dem Standard Bean Validation JSR 303 erweitert werden. Zunächst wird eine eigene Erweiterung der Validierung vorgenommen. Dazu wird die Annotation @NotNullOrBlank im Eclipse-Projekt test-spring-jpa definiert.

• In der Zeile 27 wird der Validierer definiert, der die eigentlichen Überprüfungen vornimmt.
• In der Zeile 29 wird die Standardmeldung definiert. Die Meldung selber ist in einer Properties-Datei ausgelagert.

/**
 * Validiere String Felder, die nicht <code>null</code> oder aus einem
 * Leerstring bestehen.
 * @author Frank W. Rahn
 */
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = { NotNullOrBlankValidator.class })
public @interface NotNullOrBlank {
    String message() default "{de.rahn.validation.NotNullOrBlank.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

Die Properties-Dateien für die englischen und deutsche Meldungen.

de.rahn.validation.NotNullOrBlank.message=may not be null or empty

de.rahn.validation.NotNullOrBlank.message=kann nicht null oder leer sein

Die folgende Klasse definiert den eigentlichen Validierer, der die Überprüfung durchführt.

• In der Zeile 20 wird der Validierer initialisiert und in der Zeile 30 befindet sich die Überprüfung.

/**
 * Der Validator zur Annotation.
 * @author Frank W. Rahn
 */
public class NotNullOrBlankValidator implements
    ConstraintValidator<NotNullOrBlank, String> {

    /**
     * {@inheritDoc}
     * @see ConstraintValidator#initialize(java.lang.annotation.Annotation)
     */
    @Override
    public void initialize(NotNullOrBlank constraintAnnotation) {
        // Leer
    }

    /**
     * {@inheritDoc}
     * @see ConstraintValidator#isValid(Object, ConstraintValidatorContext)
     */
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        return value != null && value.trim().length() > 0;
    }

}

Nun muss noch die Validierung nach dem JSR 303 unter dem Spring Framework aktiviert werden. Dazu wird eine XML Konfiguration für die zentrale Validation erstellt.

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
    ">

    <description>
        Dieses ist die zentrale Konfiguration für die Validation.
    </description>

    <!-- Definieren den Validator -->
    <bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean" />

    <!-- Scanne das Package nach den Validatoren -->
    <context:component-scan base-package="de.rahn.validation" />

</beans>

Die Validierung soll für die Entität Fahrer im Services der Fahrerverwaltung verwendet werden.

• In den Zeilen 45 und 51 an den Attributen werden die Annotationen bzw. Anweisungen für die Validierung angegeben.

    /** Der Identifizierer des Fahrers. */
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "DriverSEQ")
    @SequenceGenerator(name = "DriverSEQ", sequenceName = "DriverSEQ",
        schema = "rahn")
    @Basic(optional = false)
    @NotNull
    private Long id;

    /** Der Name des Fahrers. */
    @Basic(optional = false)
    @Column(nullable = false, unique = true)
    @NotNullOrBlank
    private String name;

Der vollständige Service der Fahrerverwaltung

Im folgenden Bild wird der vollständige Service in einem UML-Klassendiagramm dargestellt.

Die Anpassungen an der Webanwendung

Das Eclipse-Projekt test-spring-web muss, um die Oberfläche für die Fahrerverwaltung erweitert werden. Dazu wird in der Startseite ein zusätzlicher Link auf den Fahrerverwaltung hinzugefügt.

            <li><a href="info">Inhalt des ApplicationContext von Spring</a></li>
            <li><a href="drivers">Fahrerverwaltung</a></li>

Die erste Maske der Fahrerverwaltung listet alle Fahrer auf.

• In den Zeilen 12 bis 18 werden mögliche Hinweise oder Fehler angezeigt.
• In den Zeilen 26 bis 28 wird für jeden Fahrer ein Links mit der Id des Fahrers auf die Bearbeitungsseite erzeugt und in Zeile 33 verwendet.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Fahrerverwaltung | Frank w. Rahn</title>
    </head>
    <body>
        <h1>Fahrerverwaltung</h1>
        <c:if test="${not empty statusMessage}">
            <fieldset>
                <legend>Hinweis/Fehler</legend>
                <div style="color: red;">${statusMessage}</div>
            </fieldset>
            <br/>
        </c:if>
        <table border="1" cellpadding="0" cellspacing="0">
            <tr>
                <th>Vorname</th>
                <th>Name</th>
                <th>&nbsp;</th>
            </tr>
            <c:forEach var="driver" items="${drivers}">
                <c:url var="editUrl" value="/drivers/edit">
                    <c:param name="id" value="${driver.id}" />
                </c:url>
            <tr>
                <td>${driver.firstname}</td>
                <td>${driver.name}</td>
                <td>
                    <a href="${editUrl}">Bearbeiten</a>
                </td>
            </tr>
            </c:forEach>
        </table>
        <c:url var="createUrl" value="/drivers/edit" />
        <p><a href="${createUrl}">Erzeuge einen Fahrer</a></p>
    </body>
</html>

Die folgende Oberfläche ist für die Bearbeitung bzw. Erzeugung eines Fahrer zuständig – Bearbeitungsmaske.

• In der Zeile 14 wird das Formular definiert. Das Attribut commandName verweist dabei auf ein Model.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Bearbeite bzw. Anlegen eines Fahrer | Frank W. Rahn</title>
    </head>
    <body>
        <h1>Bearbeite bzw. Anlegen eines Fahrer</h1>
        <c:url var="url" value="../drivers" />
        <form:form action="${url}" commandName="driver">
            <form:hidden path="id" />
            <fieldset>
                <p><label for="firstname">Vorname: </label><form:input path="firstname" /></p>
                <p><label for="name">Name: </label><form:input path="name" /></p>
                <input name="submit" type="submit" value="Speichern" />
            </fieldset>
        </form:form>
    </body>
</html>

Für die Oberfläche der Fahrerverwaltung wird ein Controller erstellt.

• In der Zeile 42 wird eine Bearbeitungsmethode erstellt, die bei jedem Request durchgeführt wird und sicherstellt, das eine Instanz des Fahrer geladen oder erzeugt wird.

/**
 * Der Controller für den Service Drivers.
 * @author Frank W. Rahn
 */
@Controller
@RequestMapping("/drivers")
public class DriversController {

    private static final Logger logger = getLogger(DriversController.class);

    @Autowired
    private Drivers drivers;

    /**
     * Diese Methode wird vor jedem Request aufgerufen.
     * @param id die Id eines Fahrers oder <code>null</code>
     * @return der existierende oder ein neuer Fahrer
     */
    @ModelAttribute("driver")
    public Driver handleRequest(@RequestParam(required = false) Long id) {
        logger
            .info(
                "Die Methode DriversController.handleRequest() wurde aufgerufen. id={}",
                id);

        if (id != null) {
            return drivers.getDriver(id);
        }

        return new Driver();
    }

    /**
     * Liste alle Fahrer auf.
     * @return die Liste der Fahrer
     */
    @RequestMapping(method = RequestMethod.GET)
    @ModelAttribute("drivers")
    public List<Driver> listDriver() {
        logger
            .info("Die Methode DriversController.listDriver() wurde aufgerufen.");

        return drivers.getDrivers();
    }

    /**
     * Bereite die View für das Bearbeiten bzw. Anlegen des Fahrer vor.
     * @param driver der aktuelle Fahrer
     * @return der Namen der View (default ist: "drivers/edit")
     */
    @RequestMapping(value = "/edit", method = RequestMethod.GET)
    public String editDriver(Driver driver) {
        logger
            .info(
                "Die Methode DriversController.editDriver() wurde aufgerufen. driver={}",
                driver);
        return "edit";
    }

    /**
     * Speichere einen Fahrer.
     * @param driver der aktuelle Fahrer
     * @param model das Modell
     * @return die Liste der Fahrer
     */
    @RequestMapping(method = RequestMethod.POST)
    @ModelAttribute("drivers")
    public List<Driver> saveDriver(@Valid Driver driver, Model model) {
        logger
            .info(
                "Die Methode DriversController.saveDriver() wurde mit aufgerufen. driver={}",
                driver);

        if (driver.getId() == null) {
            drivers.create(driver);
        } else {
            drivers.save(driver);
        }

        model.addAttribute("statusMessage",
            "Der Fahrer mit der Id " + driver.getId()
                + " wurde gespeichert.<br />Anzahl Autos des Fahrers "
                + driver.getCars().size() + ".");
        return drivers.getDrivers();
    }

    /**
     * Mit dieser Methode werden die Fehler angezeigt.
     * @param exception die Ausnahme zum Fehler
     * @return die Kombination aus Anzeige (View) und Daten (Model)
     */
    @ExceptionHandler
    public ModelAndView handleException(Exception exception) {
        StringWriter writer = new StringWriter();
        exception.printStackTrace(new PrintWriter(writer));
        ModelAndView modelAndView = new ModelAndView("error");
        modelAndView.addObject("message", exception.getMessage());
        modelAndView.addObject("stackTrace", writer.toString());
        return modelAndView;
    }

}

Die XML Konfiguration des Spring Servlets wird um einen Interceptor auf die Fahrerverwaltung erweitert. Dieser Interceptor sorgt dafür, das im DriversController in Zeile 105 die Autos lazy geladen werden können. Normalerweise wird der EntityManager beim Commit, auf die Transaktion, geschlossen und beim Zugriff auf Attribute der Entität, die Lazy geladen werden, wird die Ausnahme org.hibernate.LazyInitializationException geworfen. Dieser Interceptor hält den EntityManager offen solange bis der Request abgearbeitet ist.

    <!-- Diese Interceptoren werden auf die Request-Handler angewendet -->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/drivers" />
            <mvc:mapping path="/drivers/edit" />
            <bean p:entityManagerFactory-ref="entityManagerFactory"
                class="org.springframework.orm.jpa.support.OpenEntityManagerInViewInterceptor" />
            </mvc:interceptor>
    </mvc:interceptors>

Die neuen Masken

In folgender Bildgalerie werden die neuen Masken im Browser dargestellt.

Der Unit Test

Für den DriversController wird ein JUnit Test DriversControllerTest erstellt. Dazu muss zunächst eine XML Konfiguration erstellt werden.

• In Zeile 15 wird der Fahrerservice über das Mocking-Framework Mockito erzeugt.

<?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.xsd
    ">

    <description>
        Dieses ist die Test-Konfiguration für den DriversController.
    </description>

    <!-- Die Testbeans -->
    <bean id="drivers" class="org.mockito.Mockito" factory-method="mock">
        <constructor-arg value="de.rahn.services.drivers.Drivers" />
    </bean>
    <bean class="de.rahn.web.spring.DriversController" />

</beans>

Als nächstes wird der eigentliche Test erstellt.

• In den Zeilen 68, 81, 92 und 113 bis 115 werden über das Mocking Framework given(drivers.methode()) die Rückgaben .willReturn(object) des Fahrerservices bestimmt.
• In den Zeilen 123 und 132 wird die Anzahl der Aufrufe der Methode drivers.getDrivers() überprüft.

/**
 * Der Test für den Controller der Fahrerverwaltung.
 * @author Frank W. Rahn
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class DriversControllerTest {

    @Autowired
    private DriversController controller;

    @Autowired
    private Drivers drivers;

    private Driver driver;

    private List<Driver> listDriver;

    /**
     * Diese Methode wird vor jedem Unit Test aufgerufen.
     */
    @Before
    public void setUp() {
        driver = new Driver();
        driver.setId(0L);
        driver.setFirstname("Frank");
        driver.setName("Rahn");

        listDriver = new ArrayList<>();
        listDriver.add(driver);
    }

    /**
     * Test method for {@link DriversController#handleRequest(Long)}.
     */
    @Test
    public void testHandleRequestWithoutId() {
        given(drivers.getDriver(driver.getId())).willReturn(driver);

        Driver testDriver = controller.handleRequest(null);
        assertThat("Kein Fahrer geliefert", testDriver, notNullValue());
        assertThat("Dieser Fahrer darf keine Id haben", testDriver.getId(),
            nullValue());
    }

    /**
     * Test method for {@link DriversController#handleRequest(Long)}.
     */
    @Test
    public void testHandleRequestWithId() {
        given(drivers.getDriver(driver.getId())).willReturn(driver);

        Driver testDriver = controller.handleRequest(driver.getId());
        assertThat(testDriver, sameInstance(driver));
    }

    /**
     * Test method for {@link DriversController#listDriver()}.
     */
    @Test
    public void testListDriver() {
        given(drivers.getDrivers()).willReturn(listDriver);

        List<Driver> testDrivers = controller.listDriver();
        assertThat("Der Controller hat ein falsches Ergebnis geliefert",
            testDrivers, sameInstance(listDriver));
    }

    /**
     * Test method for {@link DriversController#editDriver(Driver)}.
     */
    @Test
    public void testEditDriver() {
        String model = controller.editDriver(driver);
        assertThat("Der Name der View ist nicht richtig", model, is("edit"));
    }

    /**
     * Test method for {@link DriversController#saveDriver(Driver, Model)}.
     */
    @Test
    public void testSaveDriver() {
        given(drivers.save(driver)).willReturn(driver);
        given(drivers.create(driver)).willReturn(1L);
        given(drivers.getDrivers()).willReturn(listDriver);

        // Ruft save() und getDrivers() auf
        Model model = new ExtendedModelMap();
        List<Driver> testDrivers = controller.saveDriver(driver, model);
        assertThat(testDrivers, sameInstance(listDriver));
        assertThat("Die Variable für die Oberfläche ist nicht gefüllt",
            model.asMap(), hasKey("statusMessage"));
        verify(drivers, times(2)).getDrivers();

        // Ruft create() und getDrivers() auf
        driver.setId(null);
        model = new ExtendedModelMap();
        testDrivers = controller.saveDriver(driver, model);
        assertThat(testDrivers, sameInstance(listDriver));
        assertThat("Die Variable für die Oberfläche ist nicht gefüllt",
            model.asMap(), hasKey("statusMessage"));
        verify(drivers, times(3)).getDrivers();
    }

    /**
     * Test method for {@link DriversController#handleException(Exception)}.
     */
    @SuppressWarnings("unchecked")
    @Test
    public void testHandleException() {
        NullPointerException exception = new NullPointerException("Test");
        exception.fillInStackTrace();

        ModelAndView modelAndView = controller.handleException(exception);
        assertThat("Kein Model und View geliefert", modelAndView,
            notNullValue());
        assertThat("Viewname ist nicht richtig", modelAndView.getViewName(),
            is("error"));
        assertThat("Die Attribute sind nicht richtig",
            modelAndView.getModelMap(),
            allOf(hasEntry("message", (Object) "Test"), hasKey("stackTrace")));
    }

}

In Eclipse sieht das Ergebnis des JUnit Tests wie folgt aus:

Der Quellcode und Download des Beispiels

Den Quellcode ansehen bei GitHub:
Spring mit JPA und Hibernate
Spring mit einer einfachen Webanwendung

Der Download einer ZIP-Datei von GitHub:
Spring mit JPA und Hibernate
Spring mit einer einfachen Webanwendung

Update am 28.09.2012

Es wurden folgende Änderungen an allen Projekten vorgenommen.

1. Die Projekte wurden aus meinem lokalen Apache Subversion Repository in meine öffentlichen GitHub Repositories verschoben.
   • Projekt test-spring-simple
   • Projekt test-spring-jpa
   • Projekt test-spring-web
2. Die folgenden typischen Anpassungen an Git wurden an allen Projekten durchgeführt.
   • .directory gelöscht
   • .gitignore hinzugefügt
   • README.md hinzugefügt
   • COPYRIGHT.md hinzugefügt
   • In jedem Repository wurde für jeden Beitrag der Serie ein Branch angelegt.
     • develop-spring-an-einem-einfachen-beispiel
     • develop-spring-mit-aop
     • develop-spring-mit-jpa-und-hibernate
     • develop-spring-mit-einer-einfachen-webanwendung
     • develop-spring-mit-einer-webanwendung-mit-jpa-und-validierung
     • develop-spring-security-mit-einer-webanwendung
     • develop-spring-mit-restful-webservice

Updates von 06.10.2012 bis zum 14.10.2012

Es wurden folgende Änderungen an allen Projekten vorgenommen.

1. Aktualisierung des OpenJDK auf die Version 1.7.0.
2. Aktualisierung der Entwicklungsumgebung Eclipse auf die Version 4.2.1.
   Die benötigten Plugins aus dem Eclipse Marketplace:
   • EGit – Git Team Provider, Version 2.1.0
   • GitHub Mylyn Connector, Version 2.0
   • Eclipse m2e – Maven support in Eclipse IDE
   • Spring IDE, Version 3.0.0.RELEASE
   • AspectJ Development Tools (AJDT), Version 2.2.0
   • Markdown Text Editor, Version 0.9.0
3. Aktualisierung der Datei pom.xml:
   • Anpassungen an die OpenJDK Version
   • GitHub Einträge (SCM und URL) hinzugefügt
   • Aktualisierung der Libraries auf aktuellerer Versionen (z. B. Spring Version 3.1.2.RELEASE, Hibernate Version 4.1.7.Final, JUnit Version 4.10, mockito Version 1.9.0, …)
     Die genaueren Versionen bitte aus den jeweiligen pom.xml auf GitHub entnehmen.