Introduzione a Maven, Spring, MySQL, Hibernate e alla prima applicazione CRUD (parte 3)

Buon pomeriggio. In questo articolo vorrei condividere il mio primo incontro con cose come Maven, Spring, Hibernate, MySQL e Tomcat nel processo di creazione di una semplice applicazione CRUD. Questa è la terza parte di 4. L'articolo è destinato principalmente a coloro che hanno già completato 30-40 livelli qui, ma non si sono ancora avventurati oltre Java puro e stanno appena iniziando (o stanno per iniziare) ad entrare nel mondo aperto con tutte queste tecnologie, strutture e altre parole sconosciute. Questa è la terza parte dell'articolo "Introduzione a Maven, Spring, MySQL, Hibernate e alla prima applicazione CRUD". Le parti precedenti possono essere visualizzate seguendo i link:

• Introduzione a Maven, Spring, MySQL, Hibernate e alla prima applicazione CRUD (parte 1)
• Introduzione a Maven, Spring, MySQL, Hibernate e alla prima applicazione CRUD (parte 2)

Contenuto:

• Creazione e connessione di un database
• ORM e APP
• Entità
• Proprietà di ibernazione
• Configurazione di ibernazione
• Livello di accesso ai dati

Creazione e connessione di un database

Bene, è ora di iniziare a lavorare sul database. Prima di connettere Hibernate e pensare a come dovrebbe funzionare tutto lì, diamo un'occhiata al database stesso, ad es. Creiamolo, colleghiamolo, realizziamolo e compiliamo il segno. Utilizzeremo il DBMS (Database Management System) MySQL (ovviamente è necessario prima scaricarlo e installarlo). SQL (Structured Query Language) è un linguaggio di programmazione dichiarativo utilizzato per creare, modificare e manipolare dati in un database relazionale. In tali database, i dati vengono archiviati sotto forma di tabelle. In che modo l'applicazione comunica con il database (trasmettendo query SQL al database e restituendo risultati). Per questo, Java ha qualcosa come JDBC (Java DataBase Connectivity) , che, in poche parole, è un insieme di interfacce e classi per lavorare con i database. Per interagire con il database è necessario creare una connessione; per questo il pacchetto java.sqldispone di una classe Connection. Esistono diversi modi per stabilire una connessione, ad esempio puoi utilizzare il metodo getConnectionclass DriverManager. Tuttavia, l'interazione con il database non viene effettuata direttamente, poiché esistono molti database e sono diversi. Quindi per ognuno di essi esiste il proprio driver JDBC con il quale viene stabilita la connessione al database. Quindi, prima di tutto, per non farci distrarre da questo in seguito, installiamo il driver MySQL . Aggiungiamo la pom.xmlseguente dipendenza:

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

Ora creiamo il database. Visualizza -> Finestra degli strumenti -> Database : si aprirà il pannello del database. Nuovo (verde +) -> Origine dati -> MySQL : si aprirà una finestra in cui è necessario specificare nome utente e password, li impostiamo durante l'installazione di MySQL (ad esempio, ho usato root e root). Porta (predefinita per MySQL 3306), nome, ecc. lascialo così com'è. È possibile testare la connessione utilizzando il pulsante " Test connessione ". Fai clic su OK e ora siamo connessi al server MySQL. Successivamente, creiamo un database. Per fare ciò, puoi scrivere uno script nella console che si apre:

CREATE DATABASE test

Fare clic su Esegui e il database è pronto, ora puoi collegarlo. Per fare ciò, torna a Proprietà origine dati e inserisci il nome del database (test) nel campo Database, quindi inserisci nuovamente nome utente e password e fai clic su OK. Ora dobbiamo creare una tabella. Puoi utilizzare strumenti grafici, ma per la prima volta probabilmente vale la pena scrivere uno script a mano per vedere come appare:

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

Viene creata una tabella con il nome filmscon colonne id, titleecc. Per ogni colonna è indicata la tipologia (dimensione massima dell'output tra parentesi).

• PRIMARY KEY- questa è la chiave primaria, utilizzata per identificare univocamente un record nella tabella (che implica unicità)
• AUTO_INCREMENT— il valore verrà generato automaticamente (ovviamente sarà diverso da zero, quindi non è necessario specificarlo)
• NOT NULL- anche qui tutto è ovvio, non può essere vuoto
• DEFAULT— imposta il valore predefinito
• COLLATE- codifica
• CREATE UNIQUE INDEX— rendere il campo unico
• INSERT INTO- aggiungi un record alla tabella

Il risultato è un segnale come questo: Forse vale la pena provare a collegarsi ad esso, solo per ora, separatamente dalla nostra applicazione web. E se sorgessero dei problemi con questo, allora lo risolveremo subito. Altrimenti, in seguito collegheremo Hibernate , faremo qualcosa, configureremo, armeggeremo e se sbaglieremo da qualche parte, almeno sapremo che il problema non è qui. Bene, per verificare la connessione, creiamo maintemporaneamente un metodo. In linea di principio puoi metterlo ovunque, anche nella classe controller, anche nel modello o nella configurazione, non importa, devi solo usarlo per assicurarti che tutto vada bene con la connessione e puoi cancellarlo. Ma per essere più attenti, creiamo una classe separata per questo 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();
        }
    }
}

Qui tutto è semplice, impostiamo i parametri di connessione al nostro database e proviamo a creare una connessione. Lanciamo questo maine diamo un'occhiata. Quindi, ho ricevuto un'eccezione, alcuni problemi di fuso orario e qualche altro avviso su SSL. Dopo aver navigato in Internet, puoi scoprire che questo è un problema abbastanza comune e quando si utilizzano versioni diverse del driver (mysql-connector-java), può giurare in modo diverso. Ad esempio, ho scoperto sperimentalmente che quando si utilizza la versione 5.1.47 non ci sono eccezioni dovute al fuso orario, la connessione viene creata normalmente, ma viene comunque visualizzato l'avviso SSL. Con alcune altre versioni sembrava che ci fosse un'eccezione riguardante SSL e non solo un avviso. Ok, non è questo il punto. Puoi provare ad affrontare questo problema separatamente, ma non lo approfondiremo ora. La soluzione a tutto questo è abbastanza semplice, è necessario specificare parametri aggiuntivi nell'URL , ovvero serverTimezonese il problema riguarda il fuso orario e useSSLse il problema riguarda SSL:

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

Ora abbiamo impostato il fuso orario e disabilitato SSL. Lo lanciamo di nuovo maine voilà: connessione riuscita! Bene, fantastico, abbiamo capito come creare una connessione. La classe Mainha praticamente completato il suo compito, puoi eliminarla.

ORM e APP

In senso buono, per una migliore comprensione, è meglio iniziare a conoscere i database in ordine, fin dall'inizio, senza ibernazioni e altre cose. Pertanto, sarebbe una buona idea trovare alcune guide e provare prima a lavorare con le classi JDBC, scrivere manualmente query SQL e così via. Bene, passiamo subito al modello ORM . Cosa significa questo? Naturalmente, è ancora una volta consigliabile leggerlo separatamente, ma proverò a descriverlo brevemente. ORM (Object-Relational Mapping o mappatura relazionale di oggetti) è una tecnologia per mappare oggetti in strutture di database relazionali, ad es. per rappresentare il nostro oggetto Java come una riga di tabella. Grazie a ORM, non devi preoccuparti di scrivere script SQL e concentrarti sul lavoro con gli oggetti. Come usarlo. Java ha un'altra cosa fantastica, JPA (Java Persistence API), che implementa il concetto ORM. JPA è una specifica di questo tipo; descrive i requisiti per gli oggetti, definisce varie interfacce e annotazioni per lavorare con il database. JPA è essenzialmente una descrizione, uno standard. Pertanto, esistono molte implementazioni specifiche, una delle quali (e una delle più popolari) è Hibernate, che rappresenta l'essenza di questo framework. Hibernate è un'implementazione della specifica JPA progettata per risolvere problemi di mappatura relazionale degli oggetti (ORM). Dobbiamo collegare tutto questo al nostro progetto. Inoltre, affinché la nostra Primavera non rimanga in disparte e partecipi anche a tutto questo movimento con i database, dobbiamo collegare un paio di moduli in più, perché tutto ciò che abbiamo ottenuto dalla dipendenza spring-webmvc non è più sufficiente per questo. Avremo anche bisogno di spring-jdbc per funzionare con il database, spring-tx per supportare le transazioni e spring-orm per funzionare con Hibernate. Aggiungiamo le dipendenze a 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>

Queste due dipendenze sono sufficienti. javax.persistence-apiarriverà insieme a hibernate-core e spring-jdbc e spring-tx insieme a spring-orm .

Entità

Quindi vogliamo che gli oggetti della classe Filmpossano essere archiviati nel database. Per fare ciò, la classe deve soddisfare una serie di condizioni. Nell'APP esiste qualcosa come un'entità per questo . Una classe di entità è una normale classe POJO , con campi privati ​​e getter e setter per essi. Deve avere un costruttore non privato senza parametri (o un costruttore predefinito) e deve avere una chiave primaria, ad es. qualcosa che identificherà in modo univoco ogni record di questa classe nel database. Puoi anche leggere separatamente tutti i requisiti per tale classe. Rendiamo la nostra classe Filmun'entità utilizzando le annotazioni JPA:

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- indica che questa classe è un'entità.
• @Table- punta a una tabella specifica per visualizzare questa entità.
• @Id— indica che questo campo è una chiave primaria, ovvero questa proprietà verrà utilizzata per identificare ogni voce univoca.
• @Column— collega un campo a una colonna della tabella. Se i nomi delle colonne del campo e della tabella sono gli stessi, puoi ometterli.
• @GeneratedValue— la proprietà verrà generata automaticamente; puoi specificare come tra parentesi. Non capiremo ora come funzionano esattamente le diverse strategie. Basti sapere che in questo caso ogni nuovo valore aumenterà di 1 rispetto al precedente.

Per ciascuna proprietà, puoi inoltre specificare molte altre cose, ad esempio cosa dovrebbe essere diverso da zero o univoco, specificare il valore predefinito, la dimensione massima, ecc. Questo sarà utile se hai bisogno di generare una tabella basata su questa classe; Hibernate ha questa opzione. Ma abbiamo già creato noi stessi la tabella e configurato tutte le proprietà, quindi possiamo farne a meno. Una piccola nota.La documentazione di Hibernate consiglia di utilizzare le annotazioni non sui campi, ma sui getter. Tuttavia, la differenza tra questi approcci è piuttosto sottile e nella nostra semplice applicazione ciò non avrà alcun impatto. Inoltre, la maggior parte delle persone inserisce comunque annotazioni sopra i campi. Quindi lasciamolo così, sembra più ordinato.

Proprietà di ibernazione

Bene, iniziamo a configurare la nostra ibernazione. E prima di tutto, inseriamo alcune informazioni, come nome utente e password, URL e qualcos'altro in un file separato. Ovviamente puoi specificarli come una linea regolare direttamente nella classe, come abbiamo fatto quando abbiamo controllato la connessione ( String username = "root";e poi l'abbiamo passata al metodo per creare la connessione). Ma è ancora più corretto memorizzare tali dati statici in qualche propertyfile. E se, ad esempio, devi cambiare il database, non dovrai passare attraverso tutte le classi e cercare dove viene utilizzato, sarà sufficiente modificare il valore in questo file una volta. Creiamo un file db.properties nella directory delle risorse :

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

Bene, tutto è chiaro dall'alto, i parametri per la connessione al database, ad es. nome della classe del conducente, URL, nome utente e password. hibernate.dialect- questa proprietà è necessaria per indicare a Hibernate quale particolare versione del linguaggio SQL viene utilizzata. Il fatto è che in ogni DBMS, per espandere le capacità, aggiungere alcune funzionalità o ottimizzare qualcosa, di solito modernizzano leggermente il linguaggio. Di conseguenza, risulta che ogni DBMS ha il proprio dialetto SQL. È come con l’inglese, sembra che la lingua sia la stessa, ma in Australia, negli Stati Uniti o in Gran Bretagna sarà leggermente diversa e alcune parole potrebbero avere significati diversi. E per evitare problemi di comprensione, è necessario dire direttamente a Hibernate con cosa deve occuparsi esattamente. hibernate.show_sql— grazie a questa proprietà, le query al database verranno visualizzate nella console. Questo non è necessario, ma con questo puoi almeno guardare cosa sta succedendo, altrimenti potrebbe sembrare che Hibernate stia facendo una sorta di magia. Beh, ovviamente non sarà del tutto chiaro da visualizzare; è meglio usare una sorta di logger per questo, ma è qualcosa per un'altra volta, per ora va bene.

Configurazione di ibernazione

Passiamo all'impostazione della configurazione. configCreiamo una classe nel pacchetto 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;
    }
}

Ci sono molte novità qui, quindi è meglio cercare ulteriori informazioni su ciascun articolo in diverse fonti. Esaminiamolo brevemente qui.

• L'abbiamo @Configurationgià @ComponentScancapito quando abbiamo fatto la lezione WebConfig.
• @EnableTransactionManagement- ti consente di usarlo TransactionManagerper gestire le transazioni. Hibernate funziona con il database utilizzando le transazioni; sono necessarie affinché un determinato insieme di operazioni venga eseguito come un unico insieme, ad es. se il metodo ha problemi con una qualsiasi operazione, tutte le altre non verranno eseguite, quindi non avviene come nel classico esempio con il trasferimento di denaro, quando è stata completata l'operazione di prelievo di denaro da un conto, ma il l'operazione di scrittura a un altro non ha funzionato, di conseguenza i soldi sono scomparsi.
• @PropertySource- collegando il file delle proprietà che abbiamo creato di recente.
• Environment- per ottenere proprietà da propertyun file.
• hibernateProperties- questo metodo è necessario per rappresentare le proprietà di Hibernate come oggetto Properties
• DataSource- utilizzato per creare una connessione al database. Questa è un'alternativa a DriverManager , che abbiamo utilizzato in precedenza quando abbiamo creato il file main. La documentazione dice quale DataSourceè preferibile utilizzare. Questo è quello che faremo, ovviamente, senza dimenticare di leggere su Internet quali sono la differenza e i vantaggi. Un vantaggio in particolare è la possibilità di creare un database Connection Pool (DBCP).
• sessionFactory— creare sessioni con l'aiuto delle quali vengono eseguite operazioni con oggetti entità. Qui impostiamo l'origine dati, le proprietà di Hibernate e in quale pacchetto dobbiamo cercare le classi di entità.
• transactionManager— per configurare il gestore delle transazioni.

Una piccola nota su DataSource. La documentazione dice che l'utilizzo dell'implementazione standard, vale a dire DriverManagerDataSource, non è raccomandato, perché è solo un sostituto del normale pool di connessioni ed è generalmente adatto solo per test e simili. Per un'applicazione normale è preferibile utilizzare qualche tipo di libreria DBCP. Bene, per la nostra applicazione, ovviamente, quello che abbiamo è sufficiente, ma per completare il quadro forse utilizzeremo ancora un'altra implementazione come consigliato. Aggiungiamo la pom.xmlseguente dipendenza:

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

E nel metodo dataSourceclass HibernateConfiglo sostituiamo DriverManagerDataSourcecon BasicDataSourceuno dal pacchetto org.apache.tomcat.dbcp.dbcp2:

BasicDataSource dataSource = new BasicDataSource();

Bene, sembra essere tutto pronto, la configurazione è pronta, non resta che aggiungerla al nostro AppInitializer :

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

Livello di accesso ai dati

È ora di iniziare finalmente con il nostro DAO. Andiamo in classe FilmDAOImple prima di tutto cancelliamo da lì l'elenco delle prove, non ci serve più. Aggiungiamo una session factory e lavoriamoci sopra.

private SessionFactory sessionFactory;

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

Per cominciare, creeremo un metodo per visualizzare una pagina con un elenco di film, in essa riceveremo una sessione e faremo una richiesta al database (estraendo tutti i record e formando un elenco):

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

Ci sono 2 punti qui. Innanzitutto è stato visualizzato un avviso. Ciò è dovuto al fatto che vogliamo ricevere un parametrizzato List<Film>, ma il metodo restituisce semplicemente Listperché in fase di compilazione non è noto quale tipo restituirà la richiesta. Quindi l’idea ci avverte che stiamo effettuando una conversione non sicura, che potrebbe causare problemi. Esistono molti modi più corretti per farlo in modo che una domanda del genere non sorga. È possibile cercare informazioni su Internet. Ma non occupiamoci di questo adesso. Il fatto è che sappiamo esattamente quale tipo verrà restituito, quindi qui non sorgeranno problemi, puoi semplicemente ignorare l'avviso. Ma affinché i tuoi occhi non siano un pugno nell'occhio, puoi appendere un'annotazione sopra il metodo @SupressWarning("unchecked"). In questo modo, diciamo al compilatore, grazie, amico, per la tua preoccupazione, ma so cosa sto facendo e ho tutto sotto controllo, quindi puoi rilassarti e non preoccuparti di questo metodo. In secondo luogo, l'idea è sottolineata in rosso " from Film". È solo una query HQL (Hibernate Query Language) e l'idea non capisce se è tutto corretto o c'è un errore. Puoi andare alle impostazioni dell'idea e regolare manualmente tutto (cerca su Internet se interessato). Oppure puoi semplicemente aggiungere il supporto per il framework Hibernate, per fare ciò, fai clic con il pulsante destro del mouse sul progetto, seleziona Aggiungi supporto framework , seleziona la casella Hibernate e fai clic su OK. Dopodiché, molto probabilmente nella classe di entità ( Film) molte cose verranno sottolineate in rosso, ad esempio, dove l'annotazione @Table(name = "films")emetterà l'avviso Impossibile risolvere la tabella 'film' . Ancora una volta, non c'è niente di sbagliato qui, non si tratta di un errore di progettazione, tutto verrà compilato e funzionerà. L'idea è enfatizzata perché non sa nulla della nostra base. Per risolvere questo problema, integriamo l'idea con il database. Visualizza -> Strumenti Finestre -> Persistense (si aprirà una scheda) -> tasto destro del mouse, seleziona Assegna origini dati -> in Origine dati, specificare la connessione al database e fare clic su OK . Una volta sistemato tutto questo, rimaneva ancora qualcosa. Andiamo a un livello superiore, al servizio. Nella classe FilmServiceImplcontrassegniamo il allFilmsmetodo spring con un'annotazione @Transactional, che indicherà che il metodo deve essere eseguito in una transazione (senza di essa Hibernate si rifiuterà di funzionare):

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

Quindi, qui è tutto pronto, non è necessario toccare nulla nel controller. Bene, sembra che sia arrivato il momento della verità, fai clic su Esegui e guarda cosa succede. Ed eccolo qui, il nostro segno, e questa volta è stato ottenuto non da un elenco che noi stessi abbiamo compilato proprio in classe, ma da un database. Ottimo, sembra che tutto funzioni. Ora eseguiamo tutte le altre operazioni CRUD allo stesso modo utilizzando i metodi di sessione. La classe risultante è simile alla seguente:

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);
    }
}

Adesso non resta che non dimenticare di andare al servizio e aggiungere un'annotazione ai metodi @Transactional. Questo è tutto, pronto. Ora puoi eseguire e controllare. Fare clic su collegamenti e pulsanti, provare ad aggiungere/eliminare/modificare voci. Se tutto è fatto correttamente dovrebbe funzionare. Ora questa è un'applicazione CRUD a tutti gli effetti che utilizza Hibernate, Spring, MySQL. Continua... Presentazione di Maven, Spring, MySQL, Hibernate e la prima applicazione CRUD (parte 1) Presentazione di Maven, Spring, MySQL, Hibernate e la prima applicazione CRUD (parte 2) Presentazione di Maven, Spring, MySQL, Hibernate e la prima applicazione CRUD (parte 3) Introduzione a Maven, Spring, MySQL, Hibernate e alla prima applicazione CRUD (parte 4)