Schreiben einer einfachen Webanwendung mit Spring MVC, Spring Data JPA und Hibernate

Hallo habr Ich präsentiere Ihnen die Übersetzung des Leitfadens „Spring MVC + Spring Data JPA + Hibernate - CRUD Example“ von Nam Ha Minh.

In diesem Spring Java-Lernprogramm erfahren Sie, wie Sie eine Spring MVC-Anwendung für die Arbeit mit Spring Data JPA einrichten, indem Sie eine einfache Webanwendung entwickeln, mit der Sie Clientinformationen verwalten können.

Nach Abschluss dieses Lernprogramms können Sie eine Java-Webanwendung erstellen, die auf den Spring MVC- und Spring Data JPA-Technologien basiert.


Die in diesem Handbuch verwendeten Programme und Technologien sind: Java 8, Apache Tomcat 9, MySQL Server 5.7, Eclipse IDE 4.7 (Oxygen), Spring Framework 5.1, Hibernate 5.4, Spring Data JPA 2.1.5 und Servlet 3.1.

Beginnen wir mit der Erstellung einer Datenbank.

1. Eine Datenbank erstellen

Wir werden MySQL verwenden. In unserem Beispiel arbeiten wir mit Daten in der Kundentabelle , die sich im Schema sales befindet . Die Kundentabelle enthält 4 Felder: ID , Name , E-Mail- Adresse und Adresse :


Sie können das folgende MySQL-Skript ausführen, um das Schema und die Tabelle zu erstellen:

CREATE DATABASE `sales`; CREATE TABLE `customer` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(45) NOT NULL, `email` varchar(45) NOT NULL, `address` varchar(45) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 

2. Erstellen eines Projekts in Eclipse

Erstellen Sie ein dynamisches Webprojekt in Eclipse und konvertieren Sie es in ein Maven-Projekt. Klicken Sie dazu mit der rechten Maustaste auf das Projekt und wählen Sie Konfigurieren> In Maven-Projekt konvertieren . Geben Sie im daraufhin angezeigten Dialogfeld " Neuen POM erstellen" die folgenden Informationen ein:

- Gruppen- net.codejava : net.codejava
- Artefakt-ID: CustomerManager

Stellen Sie außerdem sicher, dass die JRE-Version für das Java-Projekt 8 oder höher ist.

Öffnen Sie dann pom.xml (die Maven-Datei), um die Abhängigkeiten für dieses Projekt zu konfigurieren. Deklarieren Sie die Versionseigenschaften für Spring und Hibernate Frameworks:

 <properties> <spring.version>5.1.5.RELEASE</spring.version> <hibernate.version>5.4.1.Final</hibernate.version> </properties> 

Geben Sie die Abhängigkeit für Spring Framework an:

 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> 

So erstellen Sie Spring MVC-Webanwendungen:

 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency> 

So verwenden Sie Spring Data JPA:

 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-jpa</artifactId> <version>2.1.5.RELEASE</version> </dependency> 

Wir verwenden Hibernate als JPA-Implementierung, fügen Sie also die folgende Abhängigkeit hinzu:

 <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>${hibernate.version}</version> </dependency> 

Damit die Anwendung mit MySQL funktioniert, benötigen wir eine Abhängigkeit für den MySQL-JDBC-Treiber:

 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.14</version> <scope>runtime</scope> </dependency> 

Und jetzt die Abhängigkeiten für Java Servlet, JSP und JSTL:

 <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>javax.servlet.jsp-api</artifactId> <version>2.3.1</version> <scope>provided</scope> </dependency> <dependency> <groupId>jstl</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> 

Erstellen Sie zwei Java-Pakete im Stammverzeichnis des Projekts:
- net.codejava.config : für Konfigurationsklassen.
- net.codejava.customer : für Anwendungsklassen.

3. Erstellen einer JPA-Konfigurationsdatei

Da wir JPA verwenden, müssen wir die Eigenschaften für die Verbindung zur Datenbank in der Datei persistence.xml und nicht in hibernate.cfg.xml . Erstellen Sie ein neues Verzeichnis mit dem Namen META-INF im META-INF des Projekts, um die Datei persistence.xml abzulegen:


Und geben Sie den folgenden Code in diese Datei ein:

 <?xml version="1.0" encoding="UTF-8"?> <persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd" version="2.1"> <persistence-unit name="SalesDB"> <properties> <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/sales" /> <property name="javax.persistence.jdbc.user" value="root" /> <property name="javax.persistence.jdbc.password" value="(password)" /> <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" /> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.format_sql" value="true" /> </properties> </persistence-unit> </persistence> 

Wie Sie sehen, geben wir Eigenschaften für die Verbindung zur Datenbank an, z. B. URL, Benutzer, Kennwort und die JDBC-Treiberklasse. Beachten Sie auch, dass der Name SalesDB von uns im Konfigurationscode verwendet wird.

4. Erstellen einer Modellklasse

Erstellen Sie eine Customer , die der Kundentabelle in der Datenbank wie folgt zugeordnet ist:

 package net.codejava.customer; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @Entity public class Customer { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String email; private String address; protected Customer() { } protected Customer(String name, String email, String address) { this.name = name; this.email = email; this.address = address; } //       .       IDE,  . } 

Wie Sie sehen, verwenden wir die Annotation @Entity , um diese Klasse der @Entity zuzuordnen (der Klassenname entspricht dem Tabellennamen). Alle Klassenfeldnamen sind identisch mit den Feldnamen in der Tabelle. Das id Feld hat die Anmerkungen @Id und @GeneratedValue um anzuzeigen, dass dieses Feld ein Primärschlüssel ist und sein Wert automatisch generiert wird.

5. Konfiguration von Spring MVC und Spring Data JPA

Als Nächstes schreiben wir Java-Code, um Spring MVC und Spring Data JPA zu konfigurieren. Wir werden die Java-basierte Konfiguration verwenden, da diese einfacher als XML ist.

Konfigurieren Sie das Spring Dispatcher-Servlet

Um Spring MVC in unserer Anwendung zu verwenden, müssen Sie das Spring Dispatcher-Servlet registrieren, wenn Sie die Anwendung starten, indem Sie die folgende Klasse schreiben:

 package net.codejava.config; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.ServletRegistration; import org.springframework.web.WebApplicationInitializer; import org.springframework.web.context.support.AnnotationConfigWebApplicationContext; import org.springframework.web.servlet.DispatcherServlet; public class WebAppInitializer implements WebApplicationInitializer { @Override public void onStartup(ServletContext servletContext) throws ServletException { AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext(); appContext.register(WebMvcConfig.class); ServletRegistration.Dynamic dispatcher = servletContext.addServlet( "SpringDispatcher", new DispatcherServlet(appContext)); dispatcher.setLoadOnStartup(1); dispatcher.addMapping("/"); } } 

Die Methode onStartup() dieser Klasse wird vom Servlet beim onStartup() der Anwendung automatisch aufgerufen. Das Spring Dispatcher-Servlet verarbeitet alle Anforderungen, indem es mit der URL "/" übereinstimmt, und sucht nach der Konfiguration in der WebMvcConfig Klasse, die im Folgenden beschrieben wird.

Konfigurieren Sie Spring MVC

Erstellen Sie die WebMvcConfig Klasse im Paket net.codejava.config , das den folgenden Code enthält:

 package net.codejava.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.view.InternalResourceViewResolver; @Configuration @ComponentScan("net.codejava ") public class WebMvcConfig { @Bean(name = "viewResolver") public InternalResourceViewResolver getViewResolver() { InternalResourceViewResolver viewResolver = new InternalResourceViewResolver(); viewResolver.setPrefix("/WEB-INF/views/"); viewResolver.setSuffix(".jsp"); return viewResolver; } } 

Diese Klasse ist mit der Anmerkung @Configuration gekennzeichnet, die @Configuration mitteilt, dass es sich um eine Konfigurationsdatei handelt. @ComponentScan weist Spring an, nach Konfigurationsklassen im net.codejava Paket zu suchen.

In dieser Klasse erstellen wir ein Bean, das Ansichten erkennt, indem wir ein Präfix und ein Suffix für diese Ansichten angeben. Erstellen Sie daher das Verzeichnis views Verzeichnis WebContent/WEB-INF , um JSP-Dateien zu speichern.

Hier können Sie weitere Spring MVC-Konfigurationen hinzufügen.

Konfigurieren von Spring Data JPA

Um mit Spring Data JPA zu arbeiten, müssen zwei Beans-Komponenten erstellt werden: EntityManagerFactory und JpaTransactionManager . Daher erstellen wir eine weitere Konfigurationsklasse JpaConfig :

 package net.codejava.config; import javax.persistence.EntityManagerFactory; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.jpa.repository.config.EnableJpaRepositories; import org.springframework.orm.jpa.JpaTransactionManager; import org.springframework.orm.jpa.LocalEntityManagerFactoryBean; import org.springframework.transaction.annotation.EnableTransactionManagement; @Configuration @EnableJpaRepositories(basePackages = {"net.codejava.customer"}) @EnableTransactionManagement public class JpaConfig { @Bean public LocalEntityManagerFactoryBean entityManagerFactory() { LocalEntityManagerFactoryBean factoryBean = new LocalEntityManagerFactoryBean(); factoryBean.setPersistenceUnitName("SalesDB"); return factoryBean; } @Bean public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory); return transactionManager; } } 

Hier verwenden wir zwei wichtige Anmerkungen:

• @EnableJpaRepositories : @EnableJpaRepositories Spring Data JPA an, nach Repository-Klassen im angegebenen Paket (net.codejava) zu suchen, um den entsprechenden Code zur Laufzeit einzufügen.
• @EnableTransactionManagement : @EnableTransactionManagement Spring Data JPA an, Code zum Verwalten von Transaktionen zur Laufzeit zu generieren.

In dieser Klasse erstellt die erste Methode eine Instanz von EntityManagerFactory , um die Persistence Unit unserer SalesDB (dieser Name wird in der SalesDB persistence.xml oben angegeben).

Die letzte Methode erstellt eine Instanz von JpaTransactionManager für EntityManagerFactory , die zuvor von der Methode erstellt wurde.

Dies ist die Mindestkonfiguration, die für die Verwendung von Spring Data JPA erforderlich ist.

Erstellen einer Repository-Schnittstelle

Erstellen Sie eine CustomerRepository Schnittstelle, die die in Spring Data JPA definierte CrudRepository Schnittstelle erweitert:

 package net.codejava.customer; import java.util.List; import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.query.Param; public interface CustomerRepository extends CrudRepository<Customer, Long> {    } 

Dies ist fast der gesamte Code, den wir für den Zugriff auf die Daten benötigen. Einfach zustimmen? Mit Spring Data JPA müssen wir keinen DAO-Code (Java Data Acces Object) schreiben. CrudRepository einfach eine Schnittstelle, die die CrudRepository Schnittstelle erweitert und CRUD-Methoden wie save() , findAll() , findById() , deleteById() usw. definiert. Zur Laufzeit generiert Spring Data JPA automatisch Code.

Beachten Sie, dass wir beim Erweitern von CrudRepository den Typ der Modellklasse und den Typ des Primärschlüsselfelds CrudRepository : CrudRepository<Customer, Long> .

7. Erstellen einer Serviceklasse

Erstellen Sie als Nächstes die CustomerService Klasse:

 package net.codejava.customer; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service @Transactional public class CustomerService { @Autowired CustomerRepository repo; public void save(Customer customer) { repo.save(customer); } public List<Customer> listAll() { return (List<Customer>) repo.findAll(); } public Customer get(Long id) { return repo.findById(id).get(); } public void delete(Long id) { repo.deleteById(id); } } 

Beachten Sie die @Transactional Annotation, @Transactional unsere Klasse @Transactional . Dies bedeutet, dass alle Methoden dieser Klasse von Spring Data JPA für die Transaktionsverwaltung abgefangen werden. Die CustomerRepository Schnittstelleninstanz wird in diese Klasse eingebettet:

 @Autowired CustomerRepository repo; 

Dies scheint magisch, da wir keinen DAO-Code schreiben, Spring Data JPA jedoch zur Laufzeit automatisch eine Implementierung erstellt.

Wie Sie sehen, sind alle Methoden in dieser Klasse für CRUD-Operationen vorgesehen. Es delegiert einfach den gesamten Aufruf an das CustomerRepository Objekt. Möglicherweise ist diese Klasse redundant, es ist jedoch erforderlich, die Geschäfts- / Service-Ebene von der Repository- / DAO-Ebene zu trennen.

8. Erstellen eines Spring MVC Controllers

Erstellen Sie eine Klasse CustomerContoroller , um alle Anfragen von Kunden zu bearbeiten:

 package net.codejava.customer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; @Controller public class CustomerController { @Autowired private CustomerService customerService; //     } 

Dies ist eine typische Spring MVC Controller-Klasse, die mithilfe von @Controller Anmerkungen @Controller . Sie können sehen, dass die CustomerService Instanz mit der Anmerkung @Autowired in dieses Objekt @Autowired .

Wir werden die Verarbeitungsmethoden in den folgenden Abschnitten beschreiben.

9. Hinzufügen einer Kundenliste

Alle Kunden werden auf der Startseite unserer Anwendung angezeigt. Fügen Sie dazu unserer CustomerController Klasse die entsprechende Verarbeitungsmethode hinzu:

 @RequestMapping("/") public ModelAndView home() { List<Customer> listCustomer = customerService.listAll(); ModelAndView mav = new ModelAndView("index"); mav.addObject("listCustomer", listCustomer); return mav; } 

Die Browsing-Homepage ( index.jsp ) sollte folgendermaßen aussehen:

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Customer Manager</title> </head> <body> <div align="center"> <h2>Customer Manager</h2> <form method="get" action="search"> <input type="text" name="keyword" />  <input type="submit" value="Search" /> </form> <h3><a href="/new">New Customer</a></h3> <table border="1" cellpadding="5"> <tr> <th>ID</th> <th>Name</th> <th>E-mail</th> <th>Address</th> <th>Action</th> </tr> <c:forEach items="${listCustomer}" var="customer"> <tr> <td>${customer.id}</td> <td>${customer.name}</td> <td>${customer.email}</td> <td>${customer.address}</td> <td> <a href="/edit?id=${customer.id}">Edit</a>   <a href="/delete?id=${customer.id}">Delete</a> </td> </tr> </c:forEach> </table> </div> </body> </html> 

Jetzt können Sie die Webanwendung starten. Fügen Sie der Kundentabelle ein paar Zeilen hinzu und rufen Sie http://localhost:8080/CustomerManager/ und Sie werden etwas Ähnliches sehen:

10. Hinzufügen eines neuen Benutzers

Um die Funktion zum Erstellen eines neuen Clients zu implementieren, müssen zwei Handler-Methoden geschrieben werden. Im ersten wird ein neues Formular zum Hinzufügen eines Kunden angezeigt:

 @RequestMapping("/new") public String newCustomerForm(Map<String, Object> model) { Customer customer = new Customer(); model.put("customer", customer); return "new_customer"; } 

Lassen Sie uns das JSP-Formular selbst mit dem Namen new_customer.jsp :

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1"    pageEncoding="ISO-8859-1"%> <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>     <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"    "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>New Customer</title> </head> <body>    <div align="center">        <h2>New Customer</h2>        <form:form action="save" method="post" modelAttribute="customer">            <table border="0" cellpadding="5">                <tr>                    <td>Name: </td>                    <td><form:input path="name" /></td>                </tr>                <tr>                    <td>Email: </td>                    <td><form:input path="email" /></td>                </tr>                <tr>                    <td>Address: </td>                    <td><form:input path="address" /></td>                </tr>                   <tr>                    <td colspan="2"><input type="submit" value="Save"></td>                </tr>                               </table>        </form:form>    </div> </body> </html> 

Jetzt sehen Sie auf der Hauptseite den Link Neuer Kunde . Wenn Sie darauf klicken, sehen Sie ein neues Formular:


Die Second-Handler-Methode verarbeitet die Schaltfläche Speichern in der folgenden Form:

 @RequestMapping(value = "/save", method = RequestMethod.POST) public String saveCustomer(@ModelAttribute("customer") Customer customer) { customerService.save(customer); return "redirect:/"; } 

Wie Sie sehen, wird der Client nach dem erfolgreichen Speichern des Benutzers auf die Homepage umgeleitet.

11. Benutzerdaten ändern

Fügen Sie der CustomerController Klasse die folgende Handlermethode hinzu, um die Clientbearbeitungsfunktion zu implementieren:

 @RequestMapping("/edit") public ModelAndView editCustomerForm(@RequestParam long id) {    ModelAndView mav = new ModelAndView("edit_customer");    Customer customer = customerService.get(id);    mav.addObject("customer", customer);    return mav; } 

Schreiben edit_customer.jsp Formular edit_customer.jsp , das von dieser Methode aufgerufen wird:

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Edit Customer</title> </head> <body> <div align="center"> <h2>Edit Customer</h2> <form:form action="save" method="post" modelAttribute="customer"> <table border="0" cellpadding="5"> <tr> <td>ID: </td> <td>${customer.id} <form:hidden path="id"/> </td> </tr> <tr> <td>Name: </td> <td><form:input path="name" /></td> </tr> <tr> <td>Email: </td> <td><form:input path="email" /></td> </tr> <tr> <td>Address: </td> <td><form:input path="address" /></td> </tr> <tr> <td colspan="2"><input type="submit" value="Save"></td> </tr> </table> </form:form> </div> </body> </html> 

Klicken Sie auf der Startseite auf den Hyperlink Bearbeiten neben dem Client. Das Client-Bearbeitungsformular wird aufgerufen und sieht ungefähr so ​​aus:



Die Handlermethode verarbeitet weiterhin die Schaltfläche Speichern .

12. Client entfernen

Um die Löschfunktion zu implementieren, schreiben Sie die folgende Handlermethode in die CustomerController Klasse:

 @RequestMapping("/delete") public String deleteCustomerForm(@RequestParam long id) { customerService.delete(id); return "redirect:/"; } 

Klicken Sie auf der Hauptseite neben dem Client auf den Hyperlink Löschen . Der Client wird gelöscht und die Liste aktualisiert.

13. Suche nach Kunden

Zuletzt implementieren wir eine Suchfunktion, mit der der Benutzer nach Kunden suchen kann, indem er ein Schlüsselwort eingibt. Die Suchfunktion sucht nach Schlüsselwörtern in drei Feldern: Name, E-Mail und Adresse, für die wir unsere eigene Methode in die CustomerRepository Oberfläche schreiben müssen:

 package net.codejava.customer; import java.util.List; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.query.Param; public interface CustomerRepository extends CrudRepository<Customer, Long> { @Query(value = "SELECT c FROM Customer c WHERE c.name LIKE '%' || :keyword || '%'" + " OR c.email LIKE '%' || :keyword || '%'" + " OR c.address LIKE '%' || :keyword || '%'") public List<Customer> search(@Param("keyword") String keyword); } 

Die search() -Methode ist nur eine abstrakte Methode, die mit @Query . Die Suchabfrage ist eine JPA-Abfrage.

Fügen Sie dann die Methode der CustomerService Klasse hinzu:

 public List<Customer> search(String keyword) { return repo.search(keyword); } 

Fügen Sie nun der CustomerController Klasse eine Handlermethode hinzu:

 @RequestMapping("/search") public ModelAndView search(@RequestParam String keyword) { List<Customer> result = customerService.search(keyword); ModelAndView mav = new ModelAndView("search"); mav.addObject("result", result); return mav; } 

Und erstelle eine search.jsp Suchergebnisseite:

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Search Result</title> </head> <body> <div align="center"> <h2>Search Result</h2> <table border="1" cellpadding="5"> <tr> <th>ID</th> <th>Name</th> <th>E-mail</th> <th>Address</th> </tr> <c:forEach items="${result}" var="customer"> <tr> <td>${customer.id}</td> <td>${customer.name}</td> <td>${customer.email}</td> <td>${customer.address}</td> </tr> </c:forEach> </table> </div> </body> </html> 

Geben Sie zum Testen der Suchfunktion ein Schlüsselwort in das Suchfeld auf der Homepage ein und drücken Sie die Eingabetaste. Sie sehen die Suchergebnisseite:

Schlussfolgerungen

In diesem Handbuch haben Sie gelernt, wie Sie mit Spring Data JPA eine Spring MVC-Webanwendung entwickeln, um auf Daten zuzugreifen. Wie Sie sehen, reduziert und vereinfacht Spring Data JPA den Code, den wir schreiben müssen, erheblich.

Zum Vergleich hier die Projektstruktur in der Eclipse-IDE:


Danke fürs Lesen!