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
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.
Der Service der Fahrerverwaltung (© Frank Rahn)
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> </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:
Die Erfolgsmeldung von JUnit (© Frank Rahn)
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.
- 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
- Die folgenden typischen Anpassungen an Git wurden an allen Projekten durchgeführt.
.directory
gelöscht.gitignore
hinzugefügtREADME.md
hinzugefügtCOPYRIGHT.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.
- Aktualisierung des OpenJDK auf die Version 1.7.0.
- Aktualisierung der Entwicklungsumgebung Eclipse auf die Version 4.2.1.
Die benötigten Plugins aus dem Eclipse Marketplace: - 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 jeweiligenpom.xml
auf GitHub entnehmen.
- Wer ist der optimale Java Bean Mapper? - Freitag, 22. September 2023
- Spring Boot Webanwendung: Die ersten Schritte (Tutorial) - Montag, 28. März 2016
- Mainframe-Zugriff via Java - Sonntag, 04. Mai 2014
Hinterlasse einen Kommentar
An der Diskussion beteiligen?Hinterlasse uns deinen Kommentar!