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

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 dritte 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. Dies ist der dritte Teil des Artikels „Einführung in Maven, Spring, MySQL, Hibernate und die erste CRUD-Anwendung“. Frühere Teile können über die folgenden Links eingesehen werden:

• 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)

Inhalt:

• Erstellen und Anschließen einer Datenbank
• ORM und JPA
• Juristische Person
• Eigenschaften im Ruhezustand
• Konfiguration für den Ruhezustand
• Datenzugriffsschicht

Erstellen und Anschließen einer Datenbank

Nun ist es Zeit, mit der Arbeit an der Datenbank zu beginnen. Bevor wir Hibernate anbinden und darüber nachdenken, wie das alles dort funktionieren soll, werfen wir zunächst einen Blick auf die Datenbank selbst, d.h. Lassen Sie es uns erstellen, verbinden, herstellen und das Schild ausfüllen. Wir werden das DBMS (Database Management System) MySQL verwenden (natürlich müssen Sie es zuerst herunterladen und installieren). SQL (Structured Query Language) ist eine deklarative Programmiersprache, die zum Erstellen, Ändern und Bearbeiten von Daten in einer relationalen Datenbank verwendet wird. In solchen Datenbanken werden Daten in Form von Tabellen gespeichert. Wie kommuniziert die Anwendung mit der Datenbank (überträgt SQL-Abfragen an die Datenbank und gibt Ergebnisse zurück). Zu diesem Zweck verfügt Java über JDBC (Java DataBase Connectivity) , bei dem es sich vereinfacht gesagt um eine Reihe von Schnittstellen und Klassen für die Arbeit mit Datenbanken handelt. Um mit der Datenbank zu interagieren, müssen Sie eine Verbindung herstellen; dafür java.sqlverfügt das Paket über eine Klasse Connection. Es gibt mehrere Möglichkeiten, eine Verbindung herzustellen, Sie können beispielsweise die getConnectionKlassenmethode verwenden DriverManager. Die Interaktion mit der Datenbank erfolgt jedoch nicht direkt, da es viele Datenbanken gibt und diese unterschiedlich sind. Für jeden von ihnen gibt es also einen eigenen JDBC-Treiber. Über diesen Treiber wird eine Verbindung zur Datenbank hergestellt. Um später davon nicht abgelenkt zu werden, installieren wir daher zunächst den MySQL- Treiber . Fügen wir die pom.xmlfolgende Abhängigkeit hinzu:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>

Jetzt erstellen wir die Datenbank. Ansicht -> Werkzeugfenster -> Datenbank – das Datenbankfenster wird geöffnet. Neu (grünes +) -> Datenquelle -> MySQL – es öffnet sich ein Fenster, in dem Sie den Benutzernamen und das Passwort angeben müssen, wir legen sie bei der Installation von MySQL fest (im Beispiel habe ich root und root verwendet). Port (Standard für MySQL 3306), Name usw. lass es so wie es ist. Sie können die Verbindung über die Schaltfläche „ Verbindung testen “ testen. Klicken Sie auf OK und jetzt sind wir mit dem MySQL-Server verbunden. Als nächstes erstellen wir eine Datenbank. Dazu können Sie in der sich öffnenden Konsole ein Skript schreiben:

CREATE DATABASE test

Klicken Sie auf „Ausführen“ und die Datenbank ist bereit. Jetzt können Sie sie verbinden. Gehen Sie dazu zurück zu den Datenquelleneigenschaften und geben Sie den Datenbanknamen (Test) in das Feld „Datenbank“ ein. Geben Sie dann den Benutzernamen und das Passwort erneut ein und klicken Sie auf „OK“. Jetzt müssen wir einen Tisch machen. Sie können grafische Tools verwenden, aber zum ersten Mal lohnt es sich wahrscheinlich, ein Skript von Hand zu schreiben, um zu sehen, wie es aussieht:

USE test;

CREATE TABLE films
(
  id int(10) PRIMARY KEY AUTO_INCREMENT,
  title VARCHAR(100) NOT NULL,
  year int(4),
  genre VARCHAR(20),
  watched BIT DEFAULT false  NOT NULL
)
COLLATE='utf8_general_ci';
CREATE UNIQUE INDEX films_title_uindex ON films (title);

INSERT INTO `films` (`title`,`year`,`genre`, watched)
VALUES
  ("Inception", 2010, "sci-fi", 1),
  ("The Lord of the Rings: The Fellowship of the Ring", 2001, "fantasy", 1),
  ("Tag", 2018, "comedy", 0),
  ("Gunfight at the O.K. Corral", 1957, "western", 0),
  ("Die Hard", 1988, "action", 1);

Es wird eine Tabelle mit dem Namen filmsmit Spalten usw. erstellt id. titleFür jede Spalte wird der Typ angegeben (maximale Ausgabegröße in Klammern).

• PRIMARY KEY– Dies ist der Primärschlüssel, der zur eindeutigen Identifizierung eines Datensatzes in der Tabelle verwendet wird (was Eindeutigkeit impliziert).
• AUTO_INCREMENT— Der Wert wird automatisch generiert (natürlich ist er ungleich Null, Sie müssen ihn also nicht angeben)
• NOT NULL- auch hier ist alles klar, es darf nicht leer sein
• DEFAULT– Legen Sie den Standardwert fest
• COLLATE- Kodierung
• CREATE UNIQUE INDEX– Machen Sie das Feld einzigartig
• INSERT INTO– Fügen Sie der Tabelle einen Datensatz hinzu

Das Ergebnis ist ein Zeichen wie dieses: Vielleicht lohnt es sich, zunächst einmal getrennt von unserer Webanwendung eine Verbindung herzustellen. Sollten hierbei Probleme auftreten, werden wir diese umgehend beheben. Sonst verbinden wir später den Ruhezustand , machen etwas, konfigurieren, basteln, und wenn wir irgendwo einen Fehler machen, wissen wir zumindest, dass das Problem nicht hier liegt. Um die Verbindung zu überprüfen, erstellen wir mainvorübergehend eine Methode. Im Prinzip können Sie es überall platzieren, sogar in der Controller-Klasse, sogar im Modell oder in der Konfiguration, es spielt keine Rolle, Sie müssen es nur verwenden, um sicherzustellen, dass mit der Verbindung alles in Ordnung ist, und Sie können es löschen. Aber um vorsichtiger zu sein, erstellen wir eine separate Klasse dafür Main:

package testgroup.filmography;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/test";
        String username = "root";
        String password = "root";
        System.out.println("Connecting...");

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            System.out.println("Connection successful!");
        } catch (SQLException e) {
            System.out.println("Connection failed!");
            e.printStackTrace();
        }
    }
}

Hier ist alles einfach, wir stellen die Verbindungsparameter auf unsere Datenbank ein und versuchen, eine Verbindung herzustellen. Lassen Sie uns dieses starten mainund einen Blick darauf werfen. Ich habe also eine Ausnahme, einige Zeitzonenprobleme und eine andere Warnung zu SSL erhalten. Nachdem Sie im Internet gestöbert haben, können Sie feststellen, dass dies ein ziemlich häufiges Problem ist und bei Verwendung verschiedener Versionen des Treibers (MySQL-Connector-Java) unterschiedlich auftreten kann. Ich habe zum Beispiel experimentell herausgefunden, dass es bei der Verwendung der Version 5.1.47 keine Ausnahmen aufgrund der Zeitzone gibt, die Verbindung normal aufgebaut wird, die SSL-Warnung aber trotzdem auftaucht. Bei einigen anderen Versionen schien es eine Ausnahme bezüglich SSL zu geben und nicht nur eine Warnung. Okay, das ist nicht der Punkt. Sie können versuchen, dieses Problem separat zu behandeln, aber wir werden jetzt nicht darauf eingehen. Die Lösung hierfür ist ganz einfach: Sie müssen zusätzliche Parameter in der URL angeben , nämlich serverTimezoneob das Problem bei der Zeitzone liegt und useSSLob das Problem bei SSL liegt:

String url = "jdbc:mysql://localhost:3306/test?serverTimezone=Europe/Minsk&useSSL=false";

Jetzt haben wir die Zeitzone eingestellt und SSL deaktiviert. Wir starten es erneut mainund voilà – Verbindung erfolgreich! Na toll, wir haben herausgefunden, wie wir eine Verbindung herstellen können. Die Klasse Mainhat ihre Aufgabe grundsätzlich erledigt, Sie können sie löschen.

ORM und JPA

Zum besseren Verständnis ist es im positiven Sinne besser, sich von Anfang an mit den Datenbanken vertraut zu machen, ohne Ruhepausen und andere Dinge. Daher wäre es eine gute Idee, einige Anleitungen zu finden und zunächst zu versuchen, mit JDBC-Klassen zu arbeiten, SQL-Abfragen manuell zu schreiben usw. Kommen wir gleich zum ORM- Modell. Was bedeutet das? Natürlich ist es auch hier wieder ratsam, sich gesondert darüber zu informieren, aber ich werde versuchen, es kurz zu beschreiben. ORM (Object-Relational Mapping oder objektrelationales Mapping) ist eine Technologie zur Abbildung von Objekten in relationale Datenbankstrukturen, d. h. um unser Java-Objekt als Tabellenzeile darzustellen. Dank ORM müssen Sie sich nicht um das Schreiben von SQL-Skripten kümmern und können sich auf die Arbeit mit Objekten konzentrieren. Wie man es benutzt. Java hat noch eine weitere tolle Sache, JPA (Java Persistence API), die das ORM-Konzept implementiert. JPA ist eine solche Spezifikation; sie beschreibt die Anforderungen an Objekte, sie definiert verschiedene Schnittstellen und Annotationen für die Arbeit mit der Datenbank. JPA ist im Wesentlichen eine Beschreibung, ein Standard. Daher gibt es viele spezifische Implementierungen, von denen eine (und eine der beliebtesten) Hibernate ist, das die Essenz dieses Frameworks darstellt. Hibernate ist eine Implementierung der JPA-Spezifikation zur Lösung von ORM-Problemen (Object-Relational Mapping). Wir müssen das Ganze mit unserem Projekt verbinden. Damit unser Frühling nicht am Rande steht und auch an all dieser Bewegung mit Datenbanken teilnimmt, müssen wir außerdem noch ein paar Module verbinden, denn Alles, was wir von der Spring-WebMVC- Abhängigkeit erhalten haben , reicht dafür nicht mehr aus. Wir benötigen außerdem Spring-JDBC für die Arbeit mit der Datenbank, Spring-TX für die Unterstützung von Transaktionen und Spring-Orm für die Arbeit mit Hibernate. Fügen wir Abhängigkeiten hinzu zu pom.xml:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.1.1.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.3.7.Final</version>
</dependency>

Diese beiden Abhängigkeiten reichen aus. javax.persistence-apiwird zusammen mit hibernate-core und spring-jdbc und spring-tx zusammen mit spring-orm eintreffen .

Juristische Person

Wir möchten also, dass Klassenobjekte Filmin der Datenbank gespeichert werden können. Dazu muss die Klasse eine Reihe von Bedingungen erfüllen. In JPA gibt es dafür so etwas wie eine Entität . Eine Entitätsklasse ist eine gewöhnliche POJO- Klasse mit privaten Feldern und Gettern und Settern für diese. Es muss einen nicht-privaten Konstruktor ohne Parameter (oder einen Standardkonstruktor) und einen Primärschlüssel haben, d. h. etwas, das jeden Datensatz dieser Klasse in der Datenbank eindeutig identifiziert. Alle Voraussetzungen für einen solchen Kurs können Sie auch separat nachlesen. Machen wir unsere Klasse Filmmithilfe von JPA-Annotationen zu einer Entität:

package testgroup.filmography.model;

import javax.persistence.*;

@Entity
@Table(name = "films")
public class Film {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "title")
    private String title;

    @Column(name = "year")
    private int year;

    @Column(name = "genre")
    private String genre;

    @Column(name = "watched")
    private boolean watched;

    // + getters and setters
}

• @Entity– gibt an, dass diese Klasse eine Entität ist.
• @Table– zeigt auf eine bestimmte Tabelle, um diese Entität anzuzeigen.
• @Id– gibt an, dass es sich bei diesem Feld um einen Primärschlüssel handelt, d. h. Diese Eigenschaft wird verwendet, um jeden eindeutigen Eintrag zu identifizieren.
• @Column– verbindet ein Feld mit einer Tabellenspalte. Wenn die Feld- und Tabellenspaltennamen identisch sind, können Sie sie weglassen.
• @GeneratedValue— Die Eigenschaft wird automatisch generiert; Sie können in Klammern angeben, wie. Wir werden jetzt nicht verstehen, wie genau verschiedene Strategien funktionieren. Es genügt zu wissen, dass sich in diesem Fall jeder neue Wert gegenüber dem vorherigen um 1 erhöht.

Für jede Eigenschaft können Sie zusätzlich viele andere Dinge angeben, z. B. was ungleich Null oder eindeutig sein soll, den Standardwert, die maximale Größe usw. angeben. Dies ist nützlich, wenn Sie eine Tabelle basierend auf dieser Klasse generieren müssen; Hibernate verfügt über diese Option. Da wir die Tabelle aber bereits selbst erstellt und alle Eigenschaften konfiguriert haben, können wir darauf verzichten. Eine kleine Anmerkung.In der Hibernate-Dokumentation wird empfohlen, Annotationen nicht für Felder, sondern für Getter zu verwenden. Der Unterschied zwischen diesen Ansätzen ist jedoch recht subtil und wird in unserer einfachen Anwendung keine Auswirkungen haben. Außerdem platzieren die meisten Leute ohnehin Anmerkungen über den Feldern. Lassen wir es also so, es sieht ordentlicher aus.

Eigenschaften im Ruhezustand

Nun, beginnen wir mit der Einrichtung unseres Ruhezustands. Und zunächst einmal legen wir einige Informationen, wie Benutzername und Passwort, URL und etwas anderes, in einer separaten Datei ab. Sie können sie natürlich auch direkt in der Klasse als reguläre Zeile angeben, wie wir es bei der Überprüfung der Verbindung getan haben ( String username = "root";und diese dann an die Methode zum Erstellen der Verbindung übergeben haben). Aber noch richtiger ist es, solche statischen Daten in einer propertyDatei zu speichern. Und wenn Sie beispielsweise die Datenbank ändern müssen, müssen Sie nicht alle Klassen durchgehen und nach der Verwendung suchen; es reicht aus, den Wert in dieser Datei einmal zu ändern. Erstellen wir eine db.properties- Datei im Ressourcenverzeichnis :

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?serverTimezone=Europe/Minsk&useSSL=false
jdbc.username=root
jdbc.password=root

hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
hibernate.show_sql=true

Nun, von oben ist alles klar, Parameter für die Verbindung zur Datenbank, d.h. Name der Treiberklasse, URL, Benutzername und Passwort. hibernate.dialect– Diese Eigenschaft wird benötigt, um Hibernate anzugeben, welche bestimmte Version der SQL-Sprache verwendet wird. Tatsache ist, dass in jedem DBMS die Sprache normalerweise leicht modernisiert wird, um die Fähigkeiten zu erweitern, einige Funktionen hinzuzufügen oder etwas zu optimieren. Als Ergebnis stellt sich heraus, dass jedes DBMS seinen eigenen SQL-Dialekt hat. Es ist wie beim Englischen, die Sprache scheint dieselbe zu sein, aber in Australien, den USA oder Großbritannien wird sie etwas anders sein und einige Wörter können unterschiedliche Bedeutungen haben. Und um Verständnisprobleme zu vermeiden, müssen Sie Hibernate direkt mitteilen, womit es genau zu tun hat. hibernate.show_sql— Dank dieser Eigenschaft werden Abfragen an die Datenbank in der Konsole angezeigt. Dies ist nicht notwendig, aber mit diesem Ding können Sie zumindest sehen, was passiert, sonst könnte es so aussehen, als würde Hibernate eine Art Magie bewirken. Nun, natürlich wird es nicht ganz klar angezeigt, es ist besser, dafür eine Art Logger zu verwenden, aber das ist etwas für ein anderes Mal, denn jetzt reicht es.

Konfiguration für den Ruhezustand

Fahren wir mit dem Einrichten der Konfiguration fort. configLassen Sie uns eine Klasse im Paket erstellen HibernateConfig:

package testgroup.filmography.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@ComponentScan(basePackages = " testgroup.filmography")
@EnableTransactionManagement
@PropertySource(value = "classpath:db.properties")
public class HibernateConfig {
    private Environment environment;

    @Autowired
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    private Properties hibernateProperties() {
        Properties properties = new Properties();
        properties.put("hibernate.dialect", environment.getRequiredProperty("hibernate.dialect"));
        properties.put("hibernate.show_sql", environment.getRequiredProperty("hibernate.show_sql"));
        return properties;
    }

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(environment.getRequiredProperty("jdbc.driverClassName"));
        dataSource.setUrl(environment.getRequiredProperty("jdbc.url"));
        dataSource.setUsername(environment.getRequiredProperty("jdbc.username"));
        dataSource.setPassword(environment.getRequiredProperty("jdbc.password"));
        return dataSource;
    }

    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan("testgroup.filmography.model");
        sessionFactory.setHibernateProperties(hibernateProperties());
        return sessionFactory;
    }

    @Bean
    public HibernateTransactionManager transactionManager() {
        HibernateTransactionManager transactionManager = new HibernateTransactionManager();
        transactionManager.setSessionFactory(sessionFactory().getObject());
        return transactionManager;
    }
}

Hier gibt es ziemlich viel Neues, daher ist es am besten, zusätzlich in verschiedenen Quellen nach Informationen zu jedem Artikel zu suchen. Lassen Sie uns hier kurz darauf eingehen.

• Wir haben es @Configurationbereits @ComponentScanherausgefunden, als wir den Kurs gemacht haben WebConfig.
• @EnableTransactionManagement– ermöglicht Ihnen die TransactionManagerVerwaltung von Transaktionen. Hibernate arbeitet mit der Datenbank mithilfe von Transaktionen; sie werden benötigt, damit eine bestimmte Reihe von Vorgängen als Ganzes ausgeführt werden kann, d. h. Wenn die Methode bei einem Vorgang Probleme hat, werden alle anderen nicht ausgeführt, sodass es nicht wie im klassischen Beispiel mit der Geldüberweisung geschieht, wenn der Vorgang des Abhebens von Geld von einem Konto abgeschlossen wurde, sondern der Der Vorgang, an einen anderen zu schreiben, funktionierte nicht, infolgedessen verschwand das Geld.
• @PropertySource– Verbinden der Eigenschaftendatei, die wir kürzlich erstellt haben.
• Environment- um Eigenschaften aus propertyeiner Datei abzurufen.
• hibernateProperties– Diese Methode wird benötigt, um Hibernate-Eigenschaften als Properties-Objekt darzustellen
• DataSource– wird verwendet, um eine Verbindung zur Datenbank herzustellen. Dies ist eine Alternative zum DriverManager , den wir zuvor bei der Erstellung des verwendet haben main. In der Dokumentation heißt es, dass DataSourcedie Verwendung vorzuziehen ist. Das machen wir selbstverständlich und vergessen nicht, im Internet nachzulesen, was die Unterschiede und Vorteile sind. Ein besonderer Vorteil ist die Möglichkeit, einen Database Connection Pool (DBCP) zu erstellen.
• sessionFactory— um Sitzungen zu erstellen, mit deren Hilfe Operationen mit Entitätsobjekten ausgeführt werden. Hier legen wir die Datenquelle, die Hibernate-Eigenschaften und das Paket fest, in dem wir nach Entitätsklassen suchen müssen.
• transactionManager— um den Transaktionsmanager zu konfigurieren.

Eine kleine Anmerkung dazu DataSource. In der Dokumentation heißt es, dass die Verwendung der Standardimplementierung, nämlich DriverManagerDataSource, nicht empfohlen wird, weil Es ist lediglich ein Ersatz für das normale Verbindungspooling und eignet sich im Allgemeinen nur für Tests und dergleichen. Für eine normale Anwendung ist es vorzuziehen, eine Art DBCP-Bibliothek zu verwenden. Nun, für unsere Anwendung reicht natürlich das, was wir haben, aber um das Bild zu vervollständigen, verwenden wir vielleicht noch eine andere Implementierung, wie empfohlen. Fügen wir die pom.xmlfolgende Abhängigkeit hinzu:

<dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-dbcp</artifactId>
            <version>9.0.10</version>
</dependency>

Und in der dataSourceKlassenmethode HibernateConfigersetzen wir es DriverManagerDataSourcedurch BasicDataSourceeines aus dem Paket org.apache.tomcat.dbcp.dbcp2:

BasicDataSource dataSource = new BasicDataSource();

Nun, alles scheint fertig zu sein, die Konfiguration ist fertig, es bleibt nur noch, sie zu unserem AppInitializer hinzuzufügen :

protected Class<?>[] getRootConfigClasses() {
        return new Class[]{HibernateConfig.class};
    }

Datenzugriffsschicht

Es ist Zeit, endlich mit unserem DAO zu beginnen. Wir gehen in die Klasse FilmDAOImplund löschen dort zunächst die Probeliste, wir brauchen sie nicht mehr. Fügen wir eine Sitzungsfabrik hinzu und arbeiten wir sie durch.

private SessionFactory sessionFactory;

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

Zunächst erstellen wir eine Methode zum Anzeigen einer Seite mit einer Liste von Filmen, in der wir eine Sitzung empfangen und eine Anfrage an die Datenbank stellen (alle Datensätze herausziehen und eine Liste erstellen):

public List<Film> allFilms() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Film").list();
    }

Hier gibt es 2 Punkte. Zunächst wurde eine Warnung angezeigt. Dies liegt an der Tatsache, dass wir eine parametrisierte Methode erhalten möchten List<Film>, die Methode jedoch einfach deshalb zurückkehrt, Listweil zur Kompilierungszeit nicht bekannt ist, welchen Typ die Anforderung zurückgeben wird. Die Idee warnt uns also, dass wir eine unsichere Konvertierung durchführen, die zu Problemen führen kann. Es gibt mehrere korrektere Möglichkeiten, dies zu tun, damit sich eine solche Frage nicht stellt. Sie können im Internet nach Informationen suchen. Aber damit wollen wir uns jetzt nicht beschäftigen. Tatsache ist, dass wir genau wissen, welcher Typ zurückgegeben wird, sodass hier keine Probleme auftreten. Sie können die Warnung einfach ignorieren. Damit Ihre Augen jedoch nicht zur Schau gestellt werden, können Sie über der Methode eine Anmerkung anbringen @SupressWarning("unchecked"). Auf diese Weise sagen wir dem Compiler sozusagen: Danke, Kumpel, für deine Sorge, aber ich weiß, was ich tue, und habe alles unter Kontrolle, sodass du dich entspannen und dir über diese Methode keine Sorgen machen musst. Zweitens ist die Idee rot unterstrichen „ from Film“. Es handelt sich lediglich um eine HQL-Abfrage (Hibernate Query Language) und die Idee versteht nicht, ob alles korrekt ist oder ein Fehler vorliegt. Sie können in die Ideeneinstellungen gehen und alles manuell anpassen (schauen Sie bei Interesse im Internet nach). Oder Sie können einfach Unterstützung für das Hibernate-Framework hinzufügen. Klicken Sie dazu mit der rechten Maustaste auf das Projekt, wählen Sie Framework-Unterstützung hinzufügen , aktivieren Sie das Kontrollkästchen für Hibernate und klicken Sie auf OK. Danach werden höchstwahrscheinlich auch in der Entitätsklasse ( Film) viele Dinge rot unterstrichen sein, beispielsweise dort, wo die Annotation die Warnung Cannotsolve table 'films'@Table(name = "films") ausgibt . Auch hier ist nichts falsch, es handelt sich nicht um einen Designfehler, alles wird kompiliert und funktioniert. Die Idee wird betont, weil sie nichts über unsere Basis weiß. Um dies zu beheben, integrieren wir die Idee in die Datenbank. Ansicht -> Werkzeugfenster -> Persistenz (eine Registerkarte wird geöffnet) -> rechte Maustaste, Datenquellen zuweisen auswählen -> unter Datenquelle die Verbindung zur Datenbank angeben und auf OK klicken . Als das alles behoben war, war immer noch etwas übrig. Gehen wir auf eine höhere Ebene, zum Service. In der Klasse markieren wir die Spring-Methode mit einer Annotation , die angibt, dass die Methode in einer Transaktion ausgeführt werden soll (ohne diese Anmerkung wird Hibernate die Arbeit verweigern): FilmServiceImplallFilms@Transactional

@Transactional
public List<Film> allFilms() {
    return filmDAO.allFilms();
}

Hier ist also alles bereit, Sie müssen nichts am Controller berühren. Nun, es sieht so aus, als wäre der Moment der Wahrheit gekommen. Klicken Sie auf „Ausführen“ und sehen Sie, was passiert. Und hier ist es, unser Zeichen, und dieses Mal stammt es nicht aus einer Liste, die wir selbst direkt im Unterricht erstellt haben, sondern aus einer Datenbank. Super, alles scheint zu funktionieren. Jetzt führen wir alle anderen CRUD-Operationen auf die gleiche Weise mit Sitzungsmethoden durch. Die resultierende Klasse sieht folgendermaßen aus:

package testgroup.filmography.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import testgroup.filmography.model.Film;

import java.util.List;

@Repository
public class FilmDAOImpl implements FilmDAO {
    private SessionFactory sessionFactory;

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<Film> allFilms() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Film").list();
    }

    @Override
    public void add(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.persist(film);
    }

    @Override
    public void delete(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.delete(film);
    }

    @Override
    public void edit(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.update(film);
    }

    @Override
    public Film getById(int id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(Film.class, id);
    }
}

Jetzt müssen Sie nur noch nicht vergessen, zum Dienst zu gehen und den Methoden eine Anmerkung hinzuzufügen @Transactional. Das ist es, fertig. Sie können jetzt ausführen und prüfen. Klicken Sie auf Links und Schaltflächen und versuchen Sie, Einträge hinzuzufügen/zu löschen/zu bearbeiten. Wenn alles richtig gemacht ist, sollte es funktionieren. Dies ist nun eine vollwertige CRUD-Anwendung, die Hibernate, Spring und MySQL verwendet. 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)