Einführung in Maven, Spring, MySQL, Hibernate und die erste CRUD-Anwendung (Teil 1)

Guten Tag. In diesem Artikel möchte ich meine erste Begegnung mit Dingen wie Maven, Spring, Hibernate, MySQL und Tomcat beim Erstellen einer einfachen CRUD-Anwendung teilen. Dies ist der erste Teil von 4. Der Artikel richtet sich in erster Linie an diejenigen, die hier bereits 30–40 Level abgeschlossen haben, sich aber noch nicht über reines Java hinausgewagt haben und gerade erst anfangen (oder dabei sind), in die offene Welt einzusteigen all diese Technologien, Frameworks und andere unbekannte Wörter.

Inhalt:

• Einführung
• Ein Projekt erstellen
• Spring MVC-Verbindung
• Seiten und Controller erstellen
• Aufbau
• Modell
• Model View Controller

Einführung

Ich begann, mich mit für mich neuen Technologien und Frameworks vertraut zu machen, indem ich verschiedene Beispiele studierte, in denen sie verwendet wurden, denn normalerweise verstehe ich etwas am besten, wenn ich es am Beispiel einer vollwertigen Anwendung in Aktion sehe. Typischerweise handelt es sich bei solchen Beispielen um CRUD- Anwendungen ( Erstellen , Lesen , Aktualisieren , Löschen ). Das Internet ist voll von solchen Beispielen unterschiedlicher Komplexität. Das Problem ist, dass sie normalerweise nicht im Detail erklären, wie, was und warum dort gemacht wurde, warum diese oder jene Abhängigkeit hinzugefügt wurde, warum diese oder jene Klasse benötigt wird usw. In den meisten Fällen nehmen sie eine vollständig fertige Bewerbung mit einer endgültigen POM-Datei und endgültigen Klassenversionen und gehen einfach jede einzelne durch, ohne sich auf die kleinen Dinge zu konzentrieren, die für eine erfahrene Person wahrscheinlich offensichtlich erscheinen. Ich habe mir viele solcher Beispiele angesehen und es ist normalerweise klar, wie alles funktioniert, aber wie es dazu kam, ist nicht ganz klar. Daher habe ich entschieden, dass ein solches Beispiel nicht aus der Sicht eines erfahrenen Entwicklers nützlich sein würde, sondern aus der Sicht eines Anfängers, der sich noch nie mit Spring, Hibernate und anderen Dingen beschäftigt hat. Ich werde versuchen, meinen gesamten Weg zur Erstellung einer CRUD-Anwendung so detailliert wie möglich zu beschreiben (soweit es mein Verständnis zulässt), beginnend mit etwas auf der einfachsten Hello World-Ebene. Zuallererst mache ich das für mich selbst, denn wenn man versucht, etwas zu beschreiben, zu erzählen, zu erklären, wird es viel besser in den Kopf aufgenommen und organisiert. Aber wenn das jemandem nützlich ist und ihm hilft, etwas herauszufinden, würde ich mich sehr freuen. Versuchen wir in diesem Beispiel, eine einfache CRUD-Anwendung mit Maven , Tomcat , Spring , Hibernate und MySQL zu erstellen . Vorbereitende Schritte wie die Installation von Maven , MySQL , die Verwendung der Ultimate- Version der Idee usw. Ich denke, es ist nicht nötig, es im Detail zu beschreiben, es sollte damit keine Probleme geben. Es ist erwähnenswert, dass in diesem Beispiel die Konfiguration mithilfe von Java-Klassen (JavaConfig genannt) ohne Verwendung von XML konfiguriert wird.

Ein Projekt erstellen

Da ich also ein Neuling bin, werden wir keine obskuren Archetypen verwenden. Spring initializr klingt immer noch zu gruselig. Daher werden wir das gewöhnlichste einfache Maven-Projekt erstellen. Ich habe keinen Domainnamen, also schreibe ich in „groupid“ einfach testgroupund in „artifactid“ schreibe ich zum Beispiel den Namen filmography(das wird eine Liste von Filmen sein). Wir erstellen ein Projekt und wählen aus Enable auto-import, wann die Idee dies nahelegt. Dadurch wird jedes Mal, wenn wir Änderungen an der POM-Datei (Project Object Model, diese Datei beschreibt die gesamte Struktur des Maven-Projekts) vornehmen, alles sofort automatisch auf das Projekt angewendet. Die Bibliotheken werden aus unserem lokalen Repository übernommen, wenn wir sie bereits haben, oder wenn wir einige neue Abhängigkeiten verwenden, mit denen wir uns vorher noch nicht befasst haben, lädt Maven sie einfach über das Internet aus dem zentralen Repository herunter. Maven verfügt außerdem über eine Funktion zum Herunterladen von Quellen und Dokumentation (Download Sources and/or Documentation). Es ist auch sehr praktisch: Wenn bei einer Klasse oder Methode etwas nicht klar ist, können Sie zum Quellcode gehen und sehen, wie alles darin funktioniert. Lassen Sie uns ein paar Details hinzufügen. Dies wird eine Webanwendung sein und wir werden Tomcat verwenden . Um eine Anwendung auf Tomcat bereitzustellen, müssen Sie sie in Form eines War-Archivs (Web Application Resource, ein spezielles Format für Webanwendungen) dorthin übertragen. Fügen Sie dazu der POM-Datei die folgende Zeile hinzu, damit die Anwendung in ein War-Archiv kompiliert wird:

<packaging>war</packaging>

Nun, Sie benötigen auch ein spezielles Verzeichnis für Webquellen, in unserem Fall gibt es JSP- Seiten und einige Webressourcen. mainLassen Sie uns ein Verzeichnis erstellen webapp. mainEs sollte genau so heißen und sich genauso befinden wie java, resourcesda dies die Standard-Maven-Verzeichnisstruktur ist. Sobald wir das Paket installiert warund somit festgestellt haben, dass es sich um ein Webprojekt handelt, webappwird das Verzeichnis automatisch als Webanwendungsquellen markiert (es wird ein blauer Punkt darauf angezeigt) und alles, was mit dem Web zu tun hat, wird in diesem Ordner durchsucht. Und einen Moment. Standardmäßig verwendet Maven die Sprachversion 1.5, aber ich möchte beispielsweise Version 1.8 verwenden – Java 8 (Sie können 10 oder 11 nehmen, aber es gibt immer noch keine Pläne, irgendwelche Funktionen von dort zu verwenden, also lassen Sie es 8 sein ). Das lässt sich ganz einfach lösen, wir schreiben in Google so etwas wie „Maven Java 8“ und schauen, was zur POM-Datei hinzugefügt werden muss, damit Maven unsere Klassen für die benötigte Version kompiliert. Als Ergebnis haben wir Folgendes:

Spring MVC-Verbindung

Irgendwo muss man anfangen. Laut Plan werden wir die Datenbank verbinden und den Ruhezustand nutzen, aber das klingt im Moment alles etwas zu beängstigend. Wir müssen zuerst etwas Einfacheres tun. Spring MVC, das ist schon besser, das MVC-Muster kennen wir schon lange, es wurde in der Hälfte der großen Aufgaben des Kurses verwendet. Von hier aus beginnen wir zu tanzen. Um eine Webanwendung mit Spring MVC zu erstellen, benötigen wir außerdem eine Servlet-API, d.h. das Ding, mit dessen Hilfe die Anfrage-Antwort-Interaktion stattfindet. Versuchen wir, dies zu verbinden. Wir gehen zu Google, suchen im Maven-Repository nach den notwendigen Abhängigkeiten und fügen sie dem hinzu pom.xml. Im Abschnitt „Externe Bibliotheken“ können Sie sehen, dass nicht nur spring-webmvc geladen wurde , sondern auch eine Reihe anderer Dinge. Diese. Wir müssen keine zusätzlichen Abhängigkeiten für Spring Core , Context , Beans usw. einschließen. Was wir brauchen, alles, was wir brauchten, wurde zusammen mit spring-webmvc abgerufen . Noch eine Anmerkung. Was bedeutet providedabhängig javax.servlet-api? Der Bereich ist der Umfang der Abhängigkeit, providedwas bedeutet, dass die Abhängigkeit in der Phase des Kompilierens und Testens der Anwendung verfügbar ist, aber nicht archiviert wird. Tatsache ist, dass wir zum Bereitstellen der Anwendung einen Servlet-Container, Tomcat, verwenden werden, der bereits über solche Bibliotheken verfügt, sodass keine Notwendigkeit besteht, sie dorthin zu übertragen und das Archiv mit unnötiger Last zu belasten. Aus dem gleichen Grund werden wir in Zukunft auf die übliche Methode verzichten main, da diese bereits in Tomcat vorhanden ist.

Seiten und Controller erstellen

Versuchen wir jetzt, etwas Einfaches zu kochen. Erstellen wir zunächst webappbeispielsweise ein zusätzliches Verzeichnis, pagesin dem unsere Ansichten gespeichert werden, d. h. JSP-Seiten und erstellen Sie ein paar Seiten. Wir benötigen eine Seite, auf der in Zukunft beispielsweise eine Liste mit Filmen angezeigt wird, films.jspund vielleicht können wir eine separate Seite für die Bearbeitung erstellen, sei es so editPage.jsp. Wir werden sie vorerst nicht mit ernsthaften Informationen füllen; nur zum Testen werden wir auf einer Seite einen Link zu einer anderen erstellen. Jetzt brauchen wir eine Klasse, die Anfragen verarbeitet, d.h. Regler. Fügen wir ein neues Paket hinzu controllerund erstellen darin eine Klasse FilmController(im Allgemeinen ist es nicht notwendig, alles in verschiedene Pakete zu packen, diese Anwendung wird sehr klein und einfach sein, aber in einem normalen Projekt kann es viele Controller, Konfigurationsklassen und Modelle geben usw., also ist es besser, sich auch bei kleinen Projekten sofort daran zu gewöhnen, alles geordnet und strukturiert zu erledigen, damit kein Durcheinander entsteht. In dieser Klasse erstellen wir Methoden, die unsere Ansichten als Antwort auf Anfragen zurückgeben.

package testgroup.filmography.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class FilmController {

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public ModelAndView allFilms() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("films");
        return modelAndView;
    }

    @RequestMapping(value = "/edit", method = RequestMethod.GET)
    public ModelAndView editPage() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("editPage");
        return modelAndView;
    }
}

Was ist der Punkt? Spring MVC hat eine Sache namens DispatcherServlet. Dies ist wie der Hauptcontroller, alle eingehenden Anfragen werden durch ihn geleitet und dann an einen bestimmten Controller weitergeleitet. Die Annotation @Controllerteilt Spring MVC lediglich mit, dass es sich bei dieser Klasse um einen Controller handelt (also im Allgemeinen logisch). Der Dispatcher überprüft die Annotationen, @RequestMappingum die entsprechende Methode aufzurufen. Mit der Annotation @RequestMappingkönnen Sie Adressen für Controller-Methoden festlegen, über die diese im Client (Browser) verfügbar sind. Es kann auch auf die Controller-Klasse angewendet werden, um sozusagen die Root-Adresse für alle Methoden festzulegen. allFilms()Der Parameter für die Methode valueist auf „ “ gesetzt /, sodass sie sofort aufgerufen wird, wenn die Kombination http://host:port/ im Browser eingegeben wird (d. h. standardmäßig http ://localhost:8080/ oder http ://127.0 .0.1:8080/ ). Der Parameter methodgibt an, welche Art von Anfrage unterstützt wird (GET, POST, PUT usw.). Da wir hier nur Daten empfangen, kommt GET zum Einsatz. Wenn später Methoden zum Hinzufügen und Bearbeiten erscheinen, wird es bereits POST-Anfragen geben. (Übrigens können Sie anstelle einer Annotation , die eine Methode angibt, annotations usw. äquivalent @RequestMappingverwenden .)) In unseren Methoden erstellen wir ein Objekt und legen den Namen der Ansicht fest, die zurückgegeben werden muss. @GetMapping@PostMapping@GetMapping@RequestMapping(method = RequestMethod.GETModelAndView

Aufbau

Fahren wir mit dem Einrichten der Konfiguration fort. configLassen Sie uns eine Klasse im Paket erstellen WebConfig. Es gibt nur eine Methode, die ein Objekt vom Typ zurückgibt ViewResolver. Dies ist die Schnittstelle, die erforderlich ist, um eine Darstellung anhand des Namens zu finden.

package testgroup.filmography.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "testgroup.filmography")
public class WebConfig {

    @Bean
    ViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/pages/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
}

@Configurationteilt Spring mit, dass diese Klasse eine Konfigurationsklasse ist und die Definitionen und Abhängigkeiten beander Komponenten enthält. Beans sind Objekte, die von Spring verwaltet werden. Die Annotation wird zum Definieren einer Bean verwendet @Bean. @EnableWebMvcermöglicht Ihnen den Import der Spring MVC-Konfiguration aus der WebMvcConfigurationSupport. Sie können beispielsweise auch eine Schnittstelle implementieren, WebMvcConfigurerdie über eine ganze Reihe von Methoden verfügt, und alles nach Ihren Wünschen anpassen, aber darauf müssen wir noch nicht eingehen, die Standardeinstellungen reichen aus. @ComponentScanteilt Spring mit, wo es nach den Komponenten suchen soll, die es verwalten soll, d. h. Klassen, die mit einer Annotation @Componentoder deren Ableitungen wie @Controller, @Repository, markiert sind @Service. Diese Annotationen definieren automatisch die Klassen-Bean. In der Methode viewResolver()erstellen wir ihre Implementierung und bestimmen, wo genau nach Darstellungen gesucht werden soll webapp. Wenn wir also in der Controller-Methode den Namen „ films“ festlegen, wird die Ansicht als „ /pages/films.jsp“ gefunden. Wir haben also eine Konfigurationsklasse, aber im Moment ist es nur eine Art separate Klasse, sie hat keinerlei Auswirkungen auf unsere Anwendung . Wir müssen diese Konfiguration im Spring-Kontext registrieren. Dafür benötigen Sie eine Klasse AbstractAnnotationConfigDispatcherServletInitializer. Im Paket configerstellen wir seinen Nachfolger, beispielsweise AppInitializer , und implementieren seine Methoden.

package testgroup.filmography.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

Die letzte Methode registriert Adressen und es gibt zwei weitere Methoden zum Registrieren von Konfigurationsklassen. Webkonfigurationen, in denen ViewResolver's und dergleichen definiert sind, werden in platziert getServletConfigClasses(). Es ist besser, all dies in der Dokumentation und in verschiedenen Handbüchern nachzulesen, aber in unserem Fall ist es noch nicht notwendig, sich damit zu befassen. Bei uns können Sie WebConfigim Prinzip RootClassesbeides definieren, Sie können sogar beide gleichzeitig definieren, es wird trotzdem funktionieren . Eine Sache noch. Es kann zu Problemen bei der Kodierung kommen, wenn beim Senden von Werten mit russischen Zeichen aus dem Formular Kritzeleien entstehen. Um dieses Problem zu lösen, werden wir einen Filter hinzufügen, der Anfragen vorverarbeitet. Wir gehen zur AppInitializer- Klasse und überschreiben die Methode getServletFilters, in der wir die gewünschte Kodierung angeben, sie sollte natürlich die gleiche sein wie überall sonst, wie auf den Seiten und in der Datenbank:

protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceEncoding(true);
        return new Filter[] {characterEncodingFilter};
    }

Nun, alles scheint eingerichtet zu sein. Sie können versuchen, es auszuführen und zu sehen, was passiert. Ausführen -> Ausführen -> Konfigurationen bearbeiten -> Neue Konfiguration hinzufügen -> Tomcat-Server -> Lokal Als nächstes müssen Sie ein Artefakt zum Bereitstellen auswählen. Die Idee selbst gibt einen Hinweis : Warnung: Keine Artefakte zur Bereitstellung markiert . Klicken Sie auf die Schaltfläche „Reparieren“ und wählen Sie ...: Krieg explodiert . Oder Sie können zu Bereitstellung -> Hinzufügen -> Artefakt -> ...: war explodiert gehen . Außerdem müssen Sie zu „Bereitstellung“ gehen und das Applecation-Kontextfeld (dies ist Teil der URL-Adresse, unter der die Anwendung im Browser verfügbar ist) auf „ /“ setzen. Dann ist unsere Anwendung sofort unter http://localhost:8080/ verfügbar (Sie können dort aber auch etwas angeben, z. B. „ “, und dann müssen Sie dies nur noch zu allen Adressen hinzufügen, d. h. es wird z. B. Nr „http://localhost:8080/edit“ , aber es wird „http://localhost:8080/filmography/edit“ sein . Klicken Sie auf „Ausführen“ und warten Sie, bis es startet. Folgendes habe ich erhalten: Alles scheint in Ordnung zu sein, aber es gibt eine Einschränkung. Fakt ist, dass unsere Seiten nun öffentlich zugänglich sind und durch Eingabe des Pfades in die Adressleiste direkt aufgerufen werden können. Wir geben http://localhost:8080/pages/films.jsp ein und haben nun unsere Seite ohne Wissen des Verantwortlichen erhalten. Irgendwie ist das nicht ganz korrekt, deshalb erstellen wir ein spezielles Verzeichnis . Der Inhalt bleibt der Öffentlichkeit verborgen und kann nur über einen Controller abgerufen werden. Wir platzieren das Verzeichnis mit unseren Ansichten ( ) in und fügen es entsprechend dem Präfix hinzu: /filmographywebappWEB-INFpagesWEB-INFViewResolver

viewResolver.setPrefix("/WEB-INF/pages/");

Jetzt erhalten wir unsere Seite unter http://localhost:8080 , aber wenn wir direkt versuchen , http://localhost:8080/WEB-INF/pages/films.jsp aufzurufen, erhalten wir einen 404-Fehler. Na gut, wir haben das einfachste Webanwendung, Hello World, wie sie sagen. Die Projektstruktur sieht derzeit so aus:

Modell

Wir haben bereits Ansichten und einen Controller, aber in MVC gibt es auch einen dritten Buchstaben, daher werden wir zur Vervollständigung des Bildes auch ein Modell hinzufügen. modelErstellen wir im Paket Filmbeispielsweise eine Klasse mit den folgenden Feldern: int id, String title(Titel), int year(Erscheinungsjahr), String genre(Genre) und boolean watched(d. h. haben Sie diesen Film bereits gesehen oder nicht).

package testgroup.filmography.model;

public class Film {
    private int id;
    private String title;
    private int year;
    private String genre;
    private boolean watched;
// + Getters and setters
}

Nichts Besonderes, nur eine gewöhnliche Klasse, private Felder, Getter und Setter. Objekte solcher Klassen werden auch POJO(Plain Old Java Object) genannt, also d.h. „einfaches Java-Objekt“. Versuchen wir nun, ein solches Objekt zu erstellen und auf der Seite anzuzeigen. Im Moment machen wir uns keine allzu großen Gedanken darüber, wie man es erstellt und initialisiert. Um es auszuprobieren, erstellen wir es einfach dummerweise direkt im Controller, zum Beispiel so:

public class FilmController {
    private static Film film;

    static {
        film = new Film();
        film.setTitle("Inception");
        film.setYear(2010);
        film.setGenre("sci-fi");
        film.setWatched(true);
    }

ModelAndViewUnd fügen Sie dieses Objekt mit der Methode zu unserem hinzu addObject:

@RequestMapping(method = RequestMethod.GET)
    public ModelAndView allFilms() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("films");
        modelAndView.addObject("film", film);
        return modelAndView;
    }

Jetzt können wir dieses Objekt auf unserer Seite anzeigen. Anstelle films.jspvon Hello World schreiben wir ${film}und das Objekt, das dem Attributnamen „ film“ entspricht, wird hier ersetzt. Versuchen wir, es auszuführen und zu sehen, was passiert ist (für eine klare Ausgabe des Objekts Filmwurde die Klasse neu definiert toString()):

Model View Controller

Zu diesem Zeitpunkt scheinen wir bereits über eine vollwertige Spring MVC-Anwendung zu verfügen. Bevor wir fortfahren, wäre es gut, sich alles noch einmal anzusehen und herauszufinden, wie alles funktioniert. Im Internet findet man viele Bilder und Diagramme dazu, mir gefällt dieses hier: Wenn wir eine Anfrage in die Browserzeile schreiben, wird sie akzeptiert Dispatcher Servletund dann wird ein geeigneter Controller gefunden, mit dem diese Anfrage verarbeitet werden kann HandlerMapping(dies ist eine Schnittstelle zur Auswahl eines Controllers, prüft, welcher der verfügbaren Controller über eine Methode verfügt, die eine solche Adresse akzeptiert). , ruft eine geeignete Methode auf und Controllergibt Informationen über die Ansicht zurück, dann findet der Dispatcher mit ViewResolver'a die gewünschte Ansicht anhand des Namens, woraufhin die Modelldaten in diese Ansicht übertragen werden und wir unsere Seite als Ausgabe erhalten. Irgendwie so. Fortsetzung folgt... Einführung in Maven, Spring, MySQL, Hibernate und die erste CRUD-Anwendung (Teil 1) Einführung in Maven, Spring, MySQL, Hibernate und die erste CRUD-Anwendung (Teil 2) Einführung in Maven, Spring, MySQL, Hibernate und die erste CRUD-Anwendung (Teil 3) Einführung in Maven, Spring, MySQL, Hibernate und die erste CRUD-Anwendung (Teil 4)