Eroberungs-Frühlingsstiefel

Guten Tag, lieber Leser! Und es ist schön, Sie kennenzulernen, auch wenn der pompöse Name der Hauptgrund war, sich mit dem bescheidenen Thema der ersten Bekanntschaft mit der Spring Boot-Entwicklung zu befassen. Ich möchte meine Erfahrungen beim Abschluss der Einführungsaufgabe für ein Praktikum auf dem JavaRush-Portal teilen und einen Überblick aus der Sicht eines ganz normalen technischen Universitätsstudenten geben, der die Stärke seines gesammelten Wissens testen möchte. Ich leugne keineswegs das mögliche Vorhandensein von Unhöflichkeit im beigefügten Code oder in der Denkweise und begrüße konstruktive Kritik, denn nur durch „Stöße und blaue Flecken“ ist es möglich, sich in eine professionelle Richtung zu entwickeln. Darüber hinaus behaupte ich keineswegs, ein „Allheilmittel“ bei der Lösung der gegebenen Probleme zu sein, und lasse bewusst einzelne Fragmente des Programms weg, um die zentrale Bedeutung des Einstiegs in ein relativ komplexes Thema ohne die geringsten Konsequenzen für das Nervensystem zu belassen. Es ist wahr, es ist leichtsinnig, das Offensichtliche zu leugnen: Es war schwer für mich und bis zu einem bestimmten Moment war absolut nichts klar. Und wenn Sie beim ersten Treffen mit der Aufgabe ähnliche Gefühle verspüren, dann „Willkommen!“ Schreiben wir eine Webanwendung in Spring Boot unter Verwendung einer vereinfachten Analogie eines Praktikumsaufnahmetests unter Verwendung einer Vorlagen-Engine Thymeleafund queryAbfragen an einen lokalen MySQL-Server, um das eingehende Informationsarray zu filtern. Also lasst uns anfangen!

Frühlingsstiefel. Was ist das für ein Tier und wie wird es zubereitet?

Kurz und prägnant: Es handelt sich um ein hervorragendes Tool von Pivotel , mit dem Sie beim Erstellen einer Anwendung wertvolle Zeit sparen können, indem Sie die direkte Anbindung von Bibliotheken von Drittanbietern und das Schreiben eines eindrucksvollen Mapping-Canvas und von Servlets überflüssig machen. Es reicht aus, den Spring Initializr- Builder zu verwenden , der in IntelliJ IDEA Ultimate Edition integriert ist (Datei – Neu – Projekt … – Spring Initializr) oder sich im Webdienst start.spring.io befindet und Pakete aus einer breiten Palette angibt, die einbezogen werden sollen bietet an. Den vorgelegten technischen Spezifikationen folgend, verwenden wir den Gentleman’s Set-Standard für die Erstellung einer einfachen Webanwendung unter Verwendung der MySQL- Datenbank :

• WEB ist die Hauptkomponente für die Entwicklung einer Webanwendung, einschließlich eines lokalen Apache Tomcat-Servers unter der Standardadresse localhost:8080 und des universellen Spring MVC-Frameworks.


• DevTools – wird verwendet, um eine Anwendung in einer heißen JVM schnell neu zu starten, wenn Änderungen im kompilierten Code oder in den Vorlagen erkannt werden; Darüber hinaus erspart es Thymeleaf das Leeren des Caches, wenn die ausgewählte Engine im Projekt enthalten ist.


• JPA ist eine Technologie, die für die Arbeit mit Datenbanken erforderlich ist und eine objektrelationale Zuordnung von Java-Objekten sowie eine API ( in unserem Fall Hibernate ) zum Verwalten, Speichern und Abrufen von Entitäten bereitstellt.


• Thymeleaf (Mustache, AngularJS, Vaadin und darüber hinaus) – Vorlagen-Engine für die Anwendungsvisualisierung; Aufgrund meiner relativen Vertrautheit mit den Prinzipien von HTML entschied ich mich für Thymeleaf, das die Sprache zum Grundstein der Welt machte.


• MySQL – verbindet Java Database Connectivity-Treiber, um SQL-Abfragen an die Datenbank auszuführen.

Nach der endgültigen Auswahl der Komponenten und der Erstellung erhalten wir eine gewöhnliche Webanwendungsarchitektur mit Verzeichnissen, die zur weiteren Befüllung bereitstehen. Fragmente für die Interaktion mit dem visuellen Teil, sei es CSS-Grafikstile, Standard-HTML-Seiten oder JavaScript-Funktionalität, sollten sich in „Ressourcen“ befinden, und die Back-End-Komponente soll dementsprechend in „Java“ platziert werden. Wir sollten auch auf die Datei pom.xml im Stammbereich achten, in der die Projektstruktur und die Abhängigkeiten zwischen Komponenten gespeichert sind. Wenn Sie die Funktionalität durch zusätzliche Pakete weiter erweitern oder unnötige Dinge entfernen möchten, sollten Sie Manipulationen zwischen Tags <dependencies></dependencies>nach einer ähnlichen Methode durchführen.

Erste Schritte in eine große Zukunft

Als nächstes stellt sich eine ziemlich interessante und durchaus logische Frage: „Was ist jetzt zu tun?“ Wie wird das funktionieren? Das Programm basiert auf den Prinzipien des Model-View-Controllers: Es organisiert das Lesen von Entitäten aus der verbundenen Datenbank (Model) und wird in der Benutzeroberfläche mit Steuerelementen angezeigt (View); Die Kommunikation zwischen den Komponenten und die Ausführung von Aktionen gemäß übermittelten Anforderungen erfolgt dank des Controllers. Es ist die Schaffung von Schlüsselelementen, die als Bezugspunkt für die weitere Entwicklung dienen. Um ein Abrutschen zu vermeiden und den Respekt Ihrer Kollegen im Arbeitsfeld zu wahren, sollten Sie die Komponenten in den entsprechenden Verzeichnissen ablegen (z. B. die Controller-Datei im Controller-Ordner im Zweig „Java“ ablegen) und sorgfältig aufbewahren Ordnung am Arbeitsplatz.

Die Essenz ist ein kleiner Teil eines großen Mechanismus

Oder mit anderen Worten: Unser Modell richtet sich nach den im Problem festgelegten Bedingungen. Wenn wir vom Diskussionsthema abgehen und zum Einführungsprojekt zurückkehren, können wir mit Sicherheit behaupten, dass es minimale Unterschiede zwischen den Aufgaben gibt und uns bei der weiteren Überprüfung an das durchschnittliche Konzept halten. Nehmen wir an, Notizen in einem Notizbuch, darunter:

• Identifikationsnummer zur Standortbestimmung im allgemeinen Ablauf;
• Eine Textnachricht mit einer bestimmten Anzahl von Zeichen;
• Das Datum, an dem der Benutzer es zur allgemeinen Liste hinzugefügt hat;
• Eine boolesche Variable zur Bestimmung von „Erledigt oder nicht erledigt“ („Lesen oder nicht gelesen“).

Erstellen wir daher eine Note-Klasse in einem Verzeichnis namens „entity“ und fügen die entsprechenden Felder hinzu:

@Entity
public class Note {

   @Id
   @GeneratedValue
   private int id;
   private String message;
   private Date date;
   private boolean done;

   public Note() {
   }

   public Note(String message) {
       this.message = message;
       this.date = new Date();
       this.done = false;
   }
}

Eine weitere Abweichung vom Diskussionsthema für ein besseres Verständnis des Geschehens aus theoretischer Sicht. Die Verbindung zwischen Komponenten in Spring wird durch Annotationen spezifiziert – spezielle Zeiger vor Objekten, von denen jedes eine bestimmte Rolle im Mechanismus spielt und mit dem „@“-Symbol beginnt. Die @Entity-Annotation zeigt Spring Boot an, dass nachfolgende Klassendaten zur „Entity“ gehören, und @Id und @GeneratedValue geben das ausgewählte Feld als Bezeichner mit automatischer Generierung eines Iterators bei der Verarbeitung eines Informationsarrays an. Ich verzichte bewusst auf das Hinzufügen von Standard-Getter und -Setter, um die Kompaktheit des visuellen Formats zu erhöhen. Als nächstes gehen wir unter Berücksichtigung der Verwendung einer Datenbank zum Speichern von Datensätzen zum nächsten Schritt in der Anwendungsentwicklung über: Wir erstellen die NoteRepository-Schnittstelle im Verzeichnis „repository“, einem verbindenden Element in der Austauschkette, und erben am meisten geeignetes Repository für weitere Arbeiten, unter Angabe der gespeicherten Entität und des Integer-Iterators, auf den zugegriffen werden soll.

public interface NoteRepository extends JpaRepository<Note, Integer> {
}

Eigentlich ist das alles. Kurz und prägnant. Jetzt verwendet Spring Boot die erstellte Komponente, um Interaktionen mit der Datenbank zu organisieren. Es gibt relativ viele Arten von Legacy-Repositories mit unterschiedlichem Handlungspotenzial. JpaRepository steht ganz oben auf der Leiter und verfügt über das größte Potenzial, einschließlich der darunter liegenden CrudRepository und PageAndSortingRepository. Wir gehen nicht weiter und weichen vom Thema ab, denn einige Feinheiten sind auf der Pivotel-Website in der technischen Dokumentation zu finden. Nachdem Sie nun das Datenabbild implementiert und Kommunikationsmethoden auf der Anwendungsseite festgelegt haben, müssen Sie darauf achten, eine MySQL-Datenbank in der entsprechenden externen Umgebung „MySQL Workbench“ zu erstellen, die in einer Assembly des offiziellen Entwicklers auf der Desktop-Plattform vorinstalliert ist mit zusätzlichen Paketen zum Erstellen eines lokalen Servers: Als nächstes folgen wir den Anweisungen der Umgebung, nachdem wir im Hauptfenster auf das Symbol mit dem aktuellen lokalen Server geklickt haben, erstellen ein Tabellendiagramm entsprechend den Feldern unserer Entität (Hinweis) und füllen es mit den entsprechenden Daten. Es ist notwendig, die Feinheiten des MySQL-Dialekts, die dringend Aufmerksamkeit erfordern, um das gewünschte Ergebnis erfolgreich zu erzielen, gesondert zu klären:

• Es gibt keinen separaten booleschen Typ als solchen. Alle Aktionen zur Anforderungsverarbeitung wandeln „wahr“ oder „falsch“ in den Bitwert „1“ bzw. „0“ um.
• Das Datum wird vollständig im Typ Timestamp gespeichert. Wenn Sie das im Kern bekannte Datum verwenden, müssen Sie sich nur auf die Position im Kalender beschränken.

Nach Abschluss der vorbereitenden Schritte geben wir „MySQL Workbench“ an, um Daten an den lokalen Server zu senden, indem wir auf das „Blitz“-Symbol in der Symbolleiste klicken. Wenn das Hinzufügen der Informationen nun korrekt abgeschlossen wurde, können wir getrost zu unserer nativen IDE zurückkehren, um mit der Entwicklung fortzufahren, indem wir die aktuelle Datenbankkonfiguration zu application.properties hinzufügen (normalerweise im Verzeichnis „resources“):

spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

Und schließlich wird die Note-Entität mithilfe von Anmerkungen an MySQL gebunden. @Table gibt die Verwendung einer Tabelle mit dem ausgewählten Namen und Schema an, und @Column gibt an, dass die Variablen zu einem bestimmten Feld gehören.

@Entity
@Table(name = "test", schema = "test", catalog = "")
public class Note {

   @Id
   @GeneratedValue
   private int id;
   @Column(name = "message")
   private String message;
   @Column(name = "date")
   private Date date;
   @Column(name = "done")
   private boolean done;

   public Note() {
   }

   public Note(String message) {
       this.message = message;
       this.date = new Date();
       this.done = false;
   }
}

Ansicht oder Benutzeroberfläche

Leider können wir mit Sicherheit Folgendes sagen: „Die Visualisierung der Anwendung wird ohne das geringste theoretische oder praktische Wissen zum größten Stolperstein.“ Ehrlich gesagt hat die Frontend-Komponente einen erstaunlichen Teil der Gesamtarbeit in Anspruch genommen und meine Nerven über einen langen Zeitraum souverän strapaziert. Dank der erstaunlichen Einfachheit von Thymeleaf gelang es jedoch, nach einer Reihe bezaubernder Niederlagen einen geeigneten Kompromiss zu finden. Die weitere Diskussion wird sich mit den Feinheiten der Verwendung der ausgewählten Engine befassen, obwohl das allgemeine Konzept einer ähnlichen Position folgt. Die Haupttechnik besteht darin, reinstes HTML zu verwenden und die endgültige Anzeige aus einzelnen Fragmenten zusammenzusetzen, um mehrfache Wiederholungen identischer Abschnitte zu vermeiden. Nehmen wir an, die UI-Architektur besteht aus einer Hauptseite, die aus einer Navigationsleiste mit Steuerelementen (Hinzufügen eines neuen Eintrags, Zurückkehren zur Hauptseite) und einer dynamischen Tabelle zur Anzeige von Entitäten besteht, sortiert nach dem Zeitpunkt, zu dem die Notiz hinzugefügt wurde, in aufsteigender Reihenfolge (ASC). oder dekrementierende (DESC) Richtung. Bedeutungen. Nehmen wir als Standardposition die Anzeige aller Datensätze in aufsteigender Reihenfolge. Gemäß der hierarchischen Richtlinie der ausgewählten Vorlagen-Engine sollten sich die Komponentenvisualisierungselemente im Zweig „templates“ im Verzeichnis „resources“ befinden. Folglich berücksichtigen weitere Manipulationen an Komponenten die aufgestellten Bedingungen. Lassen Sie uns eine Hauptseite mit dem Namen „index“ (oder einem anderen Namen je nach persönlicher Vorliebe) auf einer HTML5-Vorlage erstellen. Zum Beispiel:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/head :: head"></head>
<body>
<div class="container">
   <div th:replace="fragments/header :: header"></div>
   <div th:if="${not #lists.isEmpty(notes)}">
       <div th:replace="operations/list :: notebook"></div>
   </div>
   <div th:replace="fragments/footer :: footer"></div>
</div>
</body>
</html>

Lassen Sie uns also die Schlüsselkomponenten der endgültigen Anwendung aufschlüsseln. Thymeleaf verwendet eine separate Syntax, um die Verwendung von Prozeduren anzuzeigen, und beginnt mit dem Schlüsselwort „th:“, dem Link zur Bibliothek, der unbedingt im öffnenden <html>-Tag enthalten sein muss.

<div th:if="${not #lists.isEmpty(notes)}">

Die „Wenn“-Operation unterscheidet sich überhaupt nicht von der üblichen Vorgehensweise und prüft das eingehende „Notizen“-Attribut auf das Vorhandensein von Objekten zur weiteren Anzeige. Es lohnt sich, die Überschneidung des Themas mit der Verwendung von Controller gesondert zu erwähnen, wobei dessen Verwendung zur Organisation der Interaktion zwischen Modell und Visualisierung berücksichtigt wird. Viele vage Momente nehmen in der Zukunft Gestalt an, gehen Sie einfach zurück, wenn Sie möchten.

<head th:replace="operations/list :: notebook"></head>

Die Operation „Ersetzen“ bezeichnet das Ersetzen eines „Stubs“ oder eines aktiven Blocks durch ein ausgewähltes Fragment aus der aktuellen oder separaten Seite – letzterer Fall ist im Beispiel deutlich zu beobachten. Wir kopieren das Fragment namens „notebook“ aus „list.html“ des Verzeichnisses „operations“ in das <div></div> der Datei „index“ und ersetzen so den Inhalt im endgültigen Ziel vollständig. Der ausgehende hat folgenden Inhalt:

<!DOCTYPE html>
<!--suppress ALL -->
<html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:th="http://www.thymeleaf.org">

<div th:fragment="notebook">
   <table class="table table-bordered table-hover horizontal-align">
       <thead>
       <tr>
           <th style="width: 5%">#</th>
           <th style="width: 60%">Message</th>
           <th class="dropdown" style="width: 20%">Date
               <a th:href="@{'/sort/{sortDate}' (sortDate = 'ASC')}"><i class="fa fa-chevron-circle-up"></i></a>
               <a th:href="@{'/sort/{sortDate}' (sortDate = 'DESC')}"><i class="fa fa-chevron-circle-down"></i></a>
           </th>
           <th style="width: 5%">Done</th>
           <th style="width: 5%">Edit</th>
           <th style="width: 5%">Delete</th>
       </tr>
       </thead>
       <tbody>
       <tr th:each="note : ${notes}">
           <td th:text="${note.id}" style="text-align: center">#</td>
           <td th:text="${note.message}">Message</td>
           <td th:text="${#dates.format(note.date, 'EEE, d MMM yyyy HH:mm')}" style="text-align: center">Date</td>
           <td style="text-align: center">
               <i th:if="${note.done} == true" class="fa fa-plus-square-o" style="font-size:20px;color:#337ab7"></i>
               <i th:if="${note.done} == false" class="fa fa-minus-square-o" style="font-size:20px;color:#337ab7"></i>
           </td>
           <td style="text-align: center"><a th:href="@{'/edit/{id}'(id=${note.id})}"><i class="fa fa-edit" style="font-size:20px"></i></a></td>
           <td style="text-align: center"><a th:href="@{'/delete/{id}'(id=${note.id})}"><i class="fa fa-trash" style="font-size:20px"></i></a></td>
       </tr>
       </tbody>
   </table>
</div>
</html>

Kehren wir zur konstruktiven Übersicht zurück und gehen die verwendeten Thymeleaf-Funktionen der Reihe nach durch, wobei wir die standardmäßige HTML-Syntax oder die verwendeten Grafikstile weglassen und uns speziell auf das Verständnis des Mechanismus der Template-Engine konzentrieren.

<div th:fragment="notebook">

Die Operation „Fragment“ gibt den Namen des Fragments an und ermöglicht es, den Inhalt des Blocks für den Befehl „Ersetzen“ zu verwenden. Darüber hinaus! Mehrfachverwendungen innerhalb einer einzelnen Seite sind keineswegs ausgeschlossen, was wiederum die Analogie zu Prozeduren oder Funktionen in Programmiersprachen hervorhebt.

<a th:href="@{'/sort/{sortDate}' (sortDate = 'ASC')}">

Im Controller wird ein Aufruf der Annotation @PostMapping mit der Zuordnung „/sort/{sortDate}“ verwendet, wobei {sortDate} das ausgehende Sortierrichtungsattribut ist. Etwas Ähnliches ist im folgenden Block zu sehen, der abhängig von der Position des vom Benutzer ausgewählten Elements in der Iterationsschleife eine dynamische Änderung hinzufügt:

<a th:href="@{'/edit/{id}'(id=${note.id})}">

<tr th:each="note : ${notes}">

Das Aufzählen von Werten ist der bekannten Verwendung eines for-Blocks in der Java-Syntax sehr ähnlich: Die Variable „note“ übernimmt das aktuelle Element aus dem Eingabeattribut-Array ${notes} – einem Array von Entitäten – und wird zum Ändern der Werte verwendet ​​später. Um ehrlich zu sein, könnten wir der Auflistung der vielfältigen Thymeleaf-Funktionen mit Beispielen für die praktische Anwendung einen eigenen Artikel widmen – die Template-Engine ist äußerst einfach und erfordert überhaupt kein Erlernen einer beeindruckenden Menge zusätzlicher Syntax. Die oben beschriebenen Funktionen sind in der technischen Dokumentation auf der offiziellen Website der Entwickler beschrieben und von zentraler Bedeutung für die Organisation der Kommunikation mit dem Backend. Daher können Sie getrost mit dem nächsten und letzten Teil fortfahren. Natürlich durch Anhängen der restlichen Komponenten der Visualisierung in einem Link zur fertigen Anwendung am Ende des Artikels.

Controller, Administrator in einem kleinen Unternehmen

„Der Grundstein in der Architektur einer Webanwendung“ – vielleicht gibt es keine genauere Beschreibung der Bedeutung der Controller-Komponente für die Organisation der Arbeit des Programms: Die meisten Operationen werden genau durch das Verbindungselement zwischen den ausgeführt Modell und die Ansicht. Dank der Aktionsmechanik von Spring Boot können Sie problemlos Zuordnungs- und GET/POST-Anfragemethoden verwenden und das Daten-Repository automatisch verbinden. Lassen Sie uns die NoteController-Klasse in einer separaten Datei im Verzeichnis „controllers“ erstellen und dabei erneut auf die Verwendung der entsprechenden Annotation verweisen:

@Controller
public class NoteController {

   private NoteService service;

   @Autowired
   public void setNoteService(NoteService service) {
       this.service = service;
   }

   @GetMapping("/")
   public String list(Model model) {
       return "index";
   }
}

Bei aufmerksamem Auge fällt möglicherweise eine wichtige Änderung im Design der Anwendungsarchitektur auf, die mit der Hinzufügung eines Dienstes zur Isolierung der Geschäftslogik von der Arbeit mit dem Datenbankverwaltungsdienst verbunden ist. Die abgeschlossenen Maßnahmen sind erforderlich, um die Vielseitigkeit des fertigen Produkts zu erhöhen und einen breiten Spielraum für die Änderung der Funktionalität der Benutzeroberfläche zu bieten, ohne dass Änderungen bei den Kommunikationsmethoden mit der Datenbank erforderlich sind. Die Standarddarstellung sticht in keiner Weise aus der Masse ähnlicher Darstellungen heraus: Die Schnittstelle befindet sich in einem separaten Verzeichnis und wird von einer Klasse mit der Annotation @Service zur Spring Boot-Erkennung implementiert:

public interface NoteService {
   Note getNoteById(Integer id);
   void saveNote(Note note);
   void updateNote(Integer id, String message, boolean done);
   void deleteNote(Integer id);
   List<Note> findAll();
}

@Service
public class NoteServiceImpl implements NoteService{

   private NoteRepository repository;

   @Autowired
   public void setProductRepository(NoteRepository repository) {
       this.repository = repository;
   }

   @Override
   public Note getNoteById(Integer id) {
       return repository.findOne(id);
   }

   @Override
   public void saveNote(Note note) {
       repository.save(note);
   }

   @Override
   public void updateNote(Integer id, String message, boolean done) {
       Note updated = repository.findOne(id);
       updated.setDone(done);
       updated.setMessage(message);
       repository.save(updated);
   }

   @Override
   public void deleteNote(Integer id) {
       repository.delete(id);
   }

   @Override
   public List<Note> findAll() {
       return repository.findAll();
   }
}

Kehren wir zur Überprüfung des Controllers zurück und schauen wir uns die Feinheiten der Arbeitsorganisation mithilfe von Spring Boot-Methoden an. Die Annotation @Autowired weist auf die Notwendigkeit hin, einen Dienst automatisch an eine angegebene Variable des entsprechenden Typs zu binden und eine Verbindung mit der Datenbank herzustellen. Der Art und Weise, wie die Ansicht kommuniziert, sollte mehr Aufmerksamkeit gewidmet werden, was durch die Annotation @GetMapping("/") angezeigt wird, die eine Seite mit dem Namen „index“ zurückgibt, wenn ein Aufruf von localhost:8080 empfangen wird. Sie können einen anderen Ansatz verwenden, indem Sie die erweiterte Beschreibung @RequestMapping(value = "/", method = RequestMethod.GET) angeben oder den Rückgabetyp durch ein vorgefertigtes ModelAndView ersetzen. Nach dem aktuellen Erfahrungsstand in der praktischen Anwendung bemerke ich jedoch keine grundsätzlichen Unterschiede im Endergebnis und verwende die übliche Möglichkeit. Erweitern wir den Controller, indem wir über eine zusätzliche Registerkarte neue Elemente hinzufügen. Nachdem der Benutzer auf ein Navigationsleistenelement geklickt hat, wird @GetMapping("/new") aufgerufen und auf die „neue“ Seite aus dem „operations“-Verzeichnis umgeleitet, wobei beim Bestätigen der eingegebenen Daten über die Schaltfläche ein Parameter namens „message“ zurückgegeben wird und Weiterleitung zum Hauptblock. Besonders hervorzuheben ist die Notwendigkeit einer vollständigen Übereinstimmung des Variablennamens im Eingabefenster mit dem Namen des übergebenen Werts.

<input type="text" class="form-control" id="message" th:name="message" placeholder="Enter your note." maxlength="100"/>

@GetMapping("/new")
public String newNote() {
   return "operations/new";
}

@PostMapping("/save")
public String updateNote(@RequestParam String message) {
   service.saveNote(new Note(message));
   return "redirect:/";
}

Eine ähnliche Technik wird zum Aktualisieren eines Datensatzes verwendet. Nach einem Klick auf das Control wird das Mapping @GetMapping("/edit/{id}") aufgerufen und der Identifier aus dem URL-String übernommen, das Attribut „note“ mit einem Eintrag zur weiteren Bearbeitung ergänzt. @RequestParam(value = "done", required = false) boolean done) Die Angabe eines bestimmten Werts spielt eine Schlüsselrolle bei der Verwendung des Kontrollkästchens bei Verwendung der Thymeleaf-Template-Engine und ist standardmäßig auf „false“ gesetzt.

@GetMapping("/edit/{id}")
public String edit(@PathVariable Integer id, Model model) {
   Note note = service.getNoteById(id);
   model.addAttribute("note", note);
   return "operations/edit";
}

@PostMapping("/update")
public String saveNote(@RequestParam Integer id, @RequestParam String message,
                      @RequestParam(value = "done", required = false) boolean done) {
   service.updateNote(id, message, done);
   return "redirect:/";
}

Das Entfernen von Elementen aus der Datenbank ist äußerst einfach und erfordert keine nennenswerten Eingriffe, indem die entsprechende Dienstfunktion mit dem übergebenen Wert aufgerufen wird:

@GetMapping("/delete/{id}")
public String delete(@PathVariable Integer id) {
   service.deleteNote(id);
   return "redirect:/";
}

Nehmen wir nun kleine Anpassungen an den fertigen Fragmenten vor und gehen wir zur spannenden Kommunikation mit MySQL über Abfrageabfragen in Spring Data JPA über, wobei wir vor dem Schließen des Controllers separat eine Funktion zur Verwaltung einfacher Filterung hinzufügen.

@Controller
public class NoteController {

   private String sortDateMethod = "ASC";

   @GetMapping("/")
   public String list(Model model) {
       List<Note> notebook = filterAndSort();
       model.addAttribute("notes", notebook);
       model.addAttribute("sort", sortDateMethod);
       return "index";
   }

private List<Note> filterAndSort() {
   List<Note> notebook = null;
   switch (sortDateMethod) {
       case "ASC":
           notebook = service.findAllByOrderByDateAsc();
           break;
       case "DESC":
           notebook = service.findAllByOrderByDateDesc();
           break;
   }
   return notebook;
}

So kleine, aber so wichtige Anfrage.

Es ist peinlich zuzugeben, dass sich das Filtern von Werten wider Erwarten als ein weiterer Stolperstein bei der Erfüllung der technischen Aufgabe herausstellte und souverän die durch die Paginierung festgelegte Komplexitätsschwelle überwunden hat – das Aufteilen des Datenarrays in separate Seiten einer bestimmten Größe zur weiteren Anzeige. Höchstwahrscheinlich forderte die angesammelte Müdigkeit ihren Tribut, aber ... die Inspiration kam nach einer völlig zufälligen Begegnung mit Query-Abfragen.

public interface NoteRepository extends JpaRepository<Note, Integer> {
   List<Note> findAllByOrderByDateAsc();
   List<Note> findAllByOrderByDateDesc();
}

Spring Data JPA bietet die Möglichkeit, hochgranulare Datenbankabfragen zu erstellen, die das Sortieren von Informationen nach dem Empfang überflüssig machen und ein breites Anwendungspotenzial bieten. Zum Beispiel:

List<Note> findAllByOrderByDateAsc();

Die Methode wird in eine SQL-Abfrage umgewandelt und zeigt alle Datensätze (findAll) sortiert (byOrder) nach Datum (byDate) in aufsteigender Reihenfolge (Asc) an. Darüber hinaus können Sie mit einer einzigen Anforderung komplexe Kombinationen und Stichproben aus vielen Bereichen erstellen. Angenommen, Sie wählen alle (findAll) abgeschlossenen (byDoneTrue) Datensätze in der Reihenfolge (byOrder) absteigend (Decs) nach Datumswert (byDate) aus:

Page<Note> findAllByDoneTrueOrderByDateDesc(Pageable pageable);

Fazit oder ein anderes Geständnis eines unerfahrenen Programmierers

Alle! Sie können die Webanwendung sicher mit der Kombination Umschalt+F10 oder durch Klicken auf das entsprechende Symbol starten. Spring Boot erstellt das Programm auf Apache Maven und installiert einen lokalen Apache Tomcat-Server unter localhost:8080. Jetzt müssen Sie nur noch dem Link in einem beliebigen Browser folgen. Und natürlich entwickeln Sie eine Methodik, um andere Geschäftsanforderungen zu erfüllen. Das Potenzial der Anwendung wird durch den Aufwand, den Einfallsreichtum und die Vorstellungskraft des Entwicklers begrenzt. Wenn ich offen bin und auf den eingeschlagenen Weg achte, bin ich immer wieder von der Richtigkeit der eingeschlagenen Richtung überzeugt und erkenne die Vorteile des Studiums auf dem Bildungsportal JavaRush. Dank vielfältiger praktischer Aufgaben gelang es, das verlockende Interesse am Erlernen des Programmierens wiederherzustellen, das im veralteten und überraschend langweiligen Programm einer Hochschule ähnlicher Ausrichtung völlig unterdrückt worden war. Vier Monate aktives Studium des Materials im Back-End-Technologie-Stack investierten viel mehr Wissen im Vergleich zu ganzen Jahren des Besuchs von Vorlesungen und Laborkursen. Glaub es oder nicht. Ich wünsche Ihnen, dass Sie den Schwierigkeiten beim Einstieg in komplexe Materie nicht nachgeben, denn durch die Überwindung von Hindernissen werden wir besser und entwickeln uns beruflich und persönlich weiter. Ich hoffe, diese kleine Geschichte hat mir geholfen, einige neue Ideen für die Verwendung des erstaunlichen Tools namens SpringBoot zu entdecken. PS Github .