Introduction à Maven, Spring, MySQL, Hibernate et à la première application CRUD (partie 3)

Bon après-midi. Dans cet article, j'aimerais partager ma première rencontre avec des éléments comme Maven, Spring, Hibernate, MySQL et Tomcat en train de créer une application CRUD simple. Il s'agit de la troisième partie de 4. L'article est principalement destiné à ceux qui ont déjà terminé 30 à 40 niveaux ici, mais qui ne se sont pas encore aventurés au-delà du Java pur et qui commencent tout juste (ou sont sur le point de commencer) à entrer dans le monde ouvert avec toutes ces technologies, frameworks et autres mots inconnus. Ceci est la troisième partie de l'article "Introduction à Maven, Spring, MySQL, Hibernate et la première application CRUD". Les parties précédentes peuvent être consultées en suivant les liens :

• Introduction à Maven, Spring, MySQL, Hibernate et la première application CRUD (partie 1)
• Introduction à Maven, Spring, MySQL, Hibernate et la première application CRUD (partie 2)

Contenu:

• Création et connexion d'une base de données
• ORM et JPA
• Entité
• Propriétés de mise en veille prolongée
• Configuration de mise en veille prolongée
• Couche d'accès aux données

Création et connexion d'une base de données

Eh bien, il est temps de commencer à travailler sur la base de données. Avant de connecter Hibernate et de réfléchir à la manière dont tout cela devrait fonctionner, examinons d'abord la base de données elle-même, c'est-à-dire Créons-le, connectons-le, réalisons-le et remplissons le panneau. Nous utiliserons le SGBD (Database Management System) MySQL (bien sûr, vous devez d'abord le télécharger et l'installer). SQL (Structured Query Language) est un langage de programmation déclaratif utilisé pour créer, modifier et manipuler des données dans une base de données relationnelle. Dans ces bases de données, les données sont stockées sous forme de tableaux. Comment l'application communique-t-elle avec la base de données (transmission des requêtes SQL à la base de données et renvoi des résultats). Pour cela, Java dispose d'un système tel que JDBC (Java DataBase Connectivity) , qui, en termes simples, est un ensemble d'interfaces et de classes permettant de travailler avec des bases de données. Pour interagir avec la base de données, vous devez créer une connexion ; pour cela, le package java.sqldispose d'une classe Connection. Il existe plusieurs façons d'établir une connexion, par exemple vous pouvez utiliser la méthode getConnectionde classe DriverManager. Cependant, l'interaction avec la base de données ne s'effectue pas directement, car il existe de nombreuses bases de données, et elles sont différentes. Ainsi, pour chacun d'eux, il existe son propre pilote JDBC. Grâce à ce pilote, une connexion à la base de données est établie. Par conséquent, tout d’abord, pour ne pas nous laisser distraire par cela plus tard, installons le pilote MySQL . Ajoutons la pom.xmldépendance suivante :

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

Créons maintenant la base de données. Affichage -> Fenêtres d'outils -> Base de données - le panneau de base de données s'ouvrira. Nouveau (vert +) -> Source de données -> MySQL - une fenêtre s'ouvrira dans laquelle vous devrez spécifier le nom d'utilisateur et le mot de passe, nous les avons définis lors de l'installation de MySQL (pour l'exemple, j'ai utilisé root et root). Port (par défaut pour MySQL 3306), nom, etc. laissez-le tel quel. Vous pouvez tester la connexion à l'aide du bouton « Test Connection ». Cliquez sur OK et nous sommes maintenant connectés au serveur MySQL. Ensuite, créons une base de données. Pour ce faire, vous pouvez écrire un script dans la console qui s'ouvre :

CREATE DATABASE test

Cliquez sur Exécuter et la base de données est prête, vous pouvez maintenant la connecter. Pour ce faire, revenez aux propriétés de la source de données et saisissez le nom de la base de données (test) dans le champ Base de données, puis saisissez à nouveau le nom d'utilisateur et le mot de passe et cliquez sur OK. Maintenant, nous devons faire un tableau. Vous pouvez utiliser des outils graphiques, mais pour la première fois, cela vaut probablement la peine d’écrire un script à la main pour voir à quoi il ressemble :

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

Une table est créée avec le nom filmsavec des colonnes id, titleetc. Pour chaque colonne, le type est indiqué (taille maximale de sortie entre parenthèses).

• PRIMARY KEY- c'est la clé primaire, utilisée pour identifier de manière unique un enregistrement dans la table (ce qui implique l'unicité)
• AUTO_INCREMENT— la valeur sera générée automatiquement (bien sûr elle sera différente de zéro, vous n'avez donc pas besoin de le préciser)
• NOT NULL- ici tout est aussi évident, ça ne peut pas être vide
• DEFAULT— définir la valeur par défaut
• COLLATE- encodage
• CREATE UNIQUE INDEX— rendre le domaine unique
• INSERT INTO— ajouter un enregistrement à la table

Le résultat est un signe comme celui-ci : Peut-être que cela vaut la peine d'essayer de s'y connecter, pour l'instant, séparément de notre application Web. Et si des problèmes surviennent, nous les réglerons immédiatement. Sinon, plus tard, nous connecterons Hibernate , ferons quelque chose, configurerons, bricolerons, et si nous nous trompons quelque part, nous saurons au moins que le problème n'est pas là. Eh bien, pour vérifier la connexion, créons maintemporairement une méthode. En principe, vous pouvez le mettre n'importe où, même dans la classe du contrôleur, même dans le modèle ou la configuration, peu importe, il vous suffit de l'utiliser pour vous assurer que tout va bien avec la connexion et vous pouvez le supprimer. Mais pour être plus prudent, créons une classe distincte pour cela 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();
        }
    }
}

Tout est simple ici, nous définissons les paramètres de connexion à notre base de données et essayons de créer une connexion. Lançons celui-ci mainet jetons un oeil. J'ai donc eu une exception, des problèmes de fuseau horaire et un autre avertissement concernant SSL. Après avoir navigué sur Internet, vous découvrirez qu'il s'agit d'un problème assez courant, et lors de l'utilisation de différentes versions du pilote (mysql-connector-java), il peut jurer différemment. Par exemple, j'ai découvert expérimentalement que lors de l'utilisation de la version 5.1.47, il n'y a aucune exception due au fuseau horaire, la connexion est créée normalement, mais l'avertissement SSL apparaît toujours. Avec d'autres versions, il semblait y avoir une exception concernant SSL, et pas seulement un avertissement. D'accord, ce n'est pas le sujet. Vous pouvez essayer de traiter ce problème séparément, mais nous n’y reviendrons pas maintenant. La solution à tout cela est assez simple, vous devez spécifier des paramètres supplémentaires dans l'url , à savoir serverTimezonesi le problème vient du fuseau horaire et useSSLsi le problème vient de SSL :

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

Nous avons maintenant défini le fuseau horaire et désactivé SSL. On le relance mainet voilà - Connexion réussie ! Eh bien, super, nous avons trouvé comment créer une connexion. La classe Maina pratiquement terminé sa tâche, vous pouvez la supprimer.

ORM et JPA

Dans le bon sens, pour une meilleure compréhension, il est préférable de commencer à se familiariser avec les bases de données dans l'ordre, dès le début, sans mise en veille prolongée ni autres. Par conséquent, ce serait une bonne idée de trouver des guides et d'essayer d'abord de travailler avec les classes JDBC, d'écrire des requêtes SQL manuellement, etc. Eh bien, passons tout de suite au modèle ORM . Qu'est-ce que cela signifie? Bien sûr, il est encore une fois conseillé de lire cela séparément, mais je vais essayer de le décrire brièvement. ORM (Object-Relational Mapping ou mappage objet-relationnel) est une technologie permettant de mapper des objets dans des structures de bases de données relationnelles, c'est-à-dire pour représenter notre objet Java sous forme de ligne de tableau. Grâce à ORM, vous n'avez pas à vous soucier de l'écriture de scripts SQL et vous concentrez sur le travail avec des objets. Comment l'utiliser. Java a une autre grande chose, JPA (Java Persistence API), qui implémente le concept ORM. JPA est une telle spécification : elle décrit les exigences relatives aux objets, elle définit diverses interfaces et annotations pour travailler avec la base de données. JPA est essentiellement une description, un standard. Par conséquent, il existe de nombreuses implémentations spécifiques, dont l’une (et l’une des plus populaires) est Hibernate, qui est l’essence même de ce framework. Hibernate est une implémentation de la spécification JPA conçue pour résoudre les problèmes de mappage objet-relationnel (ORM). Nous devons connecter tout cela à notre projet. De plus, pour que notre Spring ne reste pas à l'écart et participe également à tout ce mouvement avec les bases de données, nous devons connecter quelques modules supplémentaires, car tout ce que nous avons obtenu de la dépendance spring-webmvc ne suffit plus pour cela. Nous aurons également besoin de spring-jdbc pour travailler avec la base de données, spring-tx pour prendre en charge les transactions et spring-orm pour travailler avec Hibernate. Ajoutons des dépendances à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>

Ces deux dépendances suffisent. javax.persistence-apiarrivera avec hibernate-core , et spring-jdbc et spring-tx avec spring-orm .

Entité

Nous voulons donc que les objets de classe Filmpuissent être stockés dans la base de données. Pour ce faire, la classe doit remplir un certain nombre de conditions. Dans JPA, il existe une entité pour cela . Une classe d'entité est une classe POJO ordinaire , avec des champs privés et des getters et setters pour elles. Il doit avoir un constructeur non privé sans paramètres (ou un constructeur par défaut), et il doit avoir une clé primaire, c'est-à-dire quelque chose qui identifiera de manière unique chaque enregistrement de cette classe dans la base de données. Vous pouvez également lire séparément toutes les exigences pour une telle classe. Faisons de notre classe Filmune entité en utilisant les annotations 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- indique que cette classe est une entité.
• @Table- pointe vers une table spécifique pour afficher cette entité.
• @Id— indique que ce champ est une clé primaire, c'est-à-dire cette propriété sera utilisée pour identifier chaque entrée unique.
• @Column— connecte un champ à une colonne de table. Si les noms des champs et des colonnes de la table sont identiques, vous pouvez les omettre.
• @GeneratedValue— la propriété sera générée automatiquement ; vous pouvez préciser comment entre parenthèses. Nous ne comprendrons pas maintenant comment fonctionnent exactement les différentes stratégies. Il suffit de savoir que dans ce cas chaque nouvelle valeur augmentera de 1 par rapport à la précédente.

Pour chaque propriété, vous pouvez en outre spécifier de nombreuses autres choses, par exemple ce qui doit être différent de zéro ou unique, spécifier la valeur par défaut, la taille maximale, etc. Cela sera utile si vous devez générer une table basée sur cette classe ; Hibernate a cette option. Mais nous avons déjà créé la table nous-mêmes et configuré toutes les propriétés, nous pouvons donc nous en passer. Une petite remarque.La documentation Hibernate recommande d'utiliser les annotations non pas sur les champs, mais sur les getters. Cependant, la différence entre ces approches est assez subtile et dans notre simple application, cela n’aura aucun impact. De plus, la plupart des gens placent de toute façon des annotations au-dessus des champs. Par conséquent, laissons les choses comme ça, ça a l'air plus soigné.

Propriétés de mise en veille prolongée

Eh bien, commençons à configurer notre mise en veille prolongée. Et tout d'abord, mettons certaines informations, telles que le nom d'utilisateur et le mot de passe, l'URL et autre chose, dans un fichier séparé. Vous pouvez bien sûr les spécifier sous forme de ligne normale directement dans la classe, comme nous l'avons fait lorsque nous avons vérifié la connexion ( String username = "root";puis l'avons transmise à la méthode de création de connexion). Mais il est encore plus correct de stocker ces données statiques dans un propertyfichier. Et si, par exemple, vous devez modifier la base de données, vous n'aurez pas besoin de parcourir toutes les classes et de chercher où elle est utilisée, il suffira de modifier une fois la valeur de ce fichier. Créons un fichier db.properties dans le répertoire resources :

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

Eh bien, tout est clair d'en haut, les paramètres de connexion à la base de données, c'est-à-dire nom de classe de pilote, URL, nom d'utilisateur et mot de passe. hibernate.dialect- cette propriété est nécessaire pour indiquer à Hibernate quelle version particulière du langage SQL est utilisée. Le fait est que dans chaque SGBD, afin d'étendre les capacités, d'ajouter des fonctionnalités ou d'optimiser quelque chose, ils modernisent généralement légèrement le langage. En conséquence, il s'avère que chaque SGBD possède son propre dialecte SQL. C'est comme avec l'anglais, il semble que la langue soit la même, mais en Australie, aux États-Unis ou en Grande-Bretagne, ce sera légèrement différent et certains mots peuvent avoir des significations différentes. Et afin d'éviter tout problème de compréhension, vous devez indiquer directement à Hibernate à quoi il doit faire exactement. hibernate.show_sql— grâce à cette propriété, les requêtes vers la base de données seront affichées dans la console. Ce n'est pas nécessaire, mais avec cette chose, vous pouvez au moins regarder ce qui se passe, sinon il peut sembler qu'Hibernate fasse une sorte de magie. Eh bien, bien sûr, ce ne sera pas tout à fait clair à afficher ; il est préférable d'utiliser une sorte d'enregistreur pour cela, mais c'est quelque chose pour une autre fois, pour l'instant ça fera l'affaire.

Configuration de mise en veille prolongée

Passons à la mise en place de la configuration. configCréons une classe dans le package 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;
    }
}

Il y a beaucoup de nouveautés ici, il est donc préférable de rechercher également des informations sur chaque élément dans différentes sources. Examinons-le brièvement ici.

• Nous l' avons @Configurationdéjà @ComponentScancompris lorsque nous avons suivi le cours WebConfig.
• @EnableTransactionManagement— vous permet de l'utiliser TransactionManagerpour gérer les transactions. Hibernate fonctionne avec la base de données à l'aide de transactions ; elles sont nécessaires pour qu'un certain ensemble d'opérations soit effectué dans son ensemble, c'est-à-dire si la méthode rencontre des problèmes avec une opération, alors toutes les autres ne seront pas exécutées, de sorte que cela ne se produit pas comme dans l'exemple classique du transfert d'argent, lorsque l'opération de retrait d'argent d'un compte est terminée, mais le L'opération d'écriture à un autre n'a pas fonctionné, du coup l'argent a disparu.
• @PropertySource— connectant le fichier de propriétés que nous avons récemment créé.
• Environment- afin d'obtenir les propriétés d' propertyun fichier.
• hibernateProperties- cette méthode est nécessaire pour représenter les propriétés Hibernate en tant qu'objet Propriétés
• DataSource— utilisé pour créer une connexion à la base de données. Il s'agit d'une alternative à DriverManager , que nous avons utilisée précédemment lors de la création du fichier main. La documentation indique qu'il DataSourceest préférable d'utiliser. C’est ce que nous ferons bien sûr, sans oublier de lire sur Internet quelles sont les différences et les avantages. Un avantage en particulier est la possibilité de créer un pool de connexions à la base de données (DBCP).
• sessionFactory— créer des sessions à l'aide desquelles des opérations avec des objets entités sont effectuées. Ici, nous définissons la source de données, les propriétés Hibernate et le package dans lequel nous devons rechercher les classes d'entités.
• transactionManager— pour configurer le gestionnaire de transactions.

Une petite note à propos de DataSource. La documentation indique que l'utilisation de l'implémentation standard, à savoir DriverManagerDataSource, n'est pas recommandée, car il ne s'agit que d'un remplacement pour le pooling de connexions normal et ne convient généralement qu'aux tests et autres. Pour une application normale, il est préférable d'utiliser une sorte de bibliothèque DBCP. Eh bien, pour notre application, bien sûr, ce que nous avons est suffisant, mais pour compléter le tableau, nous utiliserons peut-être encore une autre implémentation comme conseillé. Ajoutons la pom.xmldépendance suivante :

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

Et dans la méthode dataSourcede classe HibernateConfig, nous le remplaçons DriverManagerDataSourcepar BasicDataSourcecelui du packageorg.apache.tomcat.dbcp.dbcp2 :

BasicDataSource dataSource = new BasicDataSource();

Bon, tout semble prêt, la configuration est prête, il ne reste plus qu'à l'ajouter à notre AppInitializer :

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

Couche d'accès aux données

Il est temps de commencer enfin avec notre DAO. Nous allons en classe FilmDAOImplet tout d'abord nous supprimons la liste d'essais, nous n'en avons plus besoin. Ajoutons une fabrique de sessions et travaillons dessus.

private SessionFactory sessionFactory;

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

Tout d'abord, créons une méthode pour afficher une page avec une liste de films, dans laquelle nous recevrons une session et ferons une requête à la base de données (retirons tous les enregistrements et créons une liste) :

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

Il y a 2 points ici. Tout d’abord, un avertissement s’est affiché. Cela est dû au fait que nous voulons recevoir un paramètre paramétré List<Film>, mais la méthode renvoie simplement Listparce qu'au moment de la compilation, on ne sait pas quel type la requête renverra. L’idée nous avertit donc que nous effectuons une conversion dangereuse, ce qui pourrait entraîner des problèmes. Il existe plusieurs autres façons correctes de procéder afin qu'une telle question ne se pose pas. Vous pouvez rechercher des informations sur Internet. Mais ne nous embêtons pas avec ça maintenant. Le fait est que nous savons exactement quel type sera renvoyé, donc aucun problème ne surviendra ici, vous pouvez simplement ignorer l'avertissement. Mais, pour que vos yeux ne soient pas une horreur, vous pouvez accrocher une annotation au-dessus de la méthode @SupressWarning("unchecked"). En faisant cela, nous disons en quelque sorte au compilateur, merci, mon pote, pour votre inquiétude, mais je sais ce que je fais et j'ai tout sous contrôle, donc vous pouvez vous détendre et ne pas vous soucier de cette méthode. Deuxièmement, l'idée est soulignée en rouge " from Film". C'est juste une requête HQL (Hibernate Query Language) et l'idée ne comprend pas si tout est correct ou s'il y a une erreur. Vous pouvez accéder aux paramètres de l'idée et tout régler manuellement (regardez sur Internet si vous êtes intéressé). Ou vous pouvez simplement ajouter la prise en charge du framework Hibernate, pour ce faire, faites un clic droit sur le projet, sélectionnez Add Framework Support , cochez la case Hibernate et cliquez sur OK. Après cela, très probablement, dans la classe d'entité ( Film), beaucoup de choses seront également soulignées en rouge, par exemple, là où l'annotation @Table(name = "films")émettra l'avertissement Cannot solve table 'films' . Encore une fois, il n’y a rien de mal ici, ce n’est pas une erreur de conception, tout se compilera et fonctionnera. L'idée est soulignée car elle ne sait rien de notre base. Pour résoudre ce problème, intégrons l'idée à la base de données. Affichage -> Fenêtres d'outils -> Persistense (un onglet s'ouvrira) -> bouton droit de la souris, sélectionnez Attribuer des sources de données -> dans Source de données, spécifiez la connexion à la base de données et cliquez sur OK . Une fois tout cela réglé, il restait encore quelque chose. Passons à un niveau supérieur, au service. Dans la classe, FilmServiceImplnous marquons la allFilmsméthode spring avec une annotation @Transactional, qui indiquera que la méthode doit être exécutée dans une transaction (sans cela, Hibernate refusera de fonctionner) :

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

Donc, tout est prêt ici, vous n’avez besoin de toucher à rien dans le contrôleur. Eh bien, il semble que le moment de vérité soit arrivé, cliquez sur Exécuter et voyez ce qui se passe. Et le voici, notre signe, et cette fois il a été obtenu non pas à partir d'une liste que nous avons nous-mêmes dressée en classe, mais à partir d'une base de données. Super, tout semble fonctionner. Nous effectuons maintenant toutes les autres opérations CRUD de la même manière en utilisant les méthodes de session. La classe résultante ressemble à ceci :

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

Il ne reste plus qu'à oublier d'aller sur le service et d'ajouter une annotation aux méthodes @Transactional. Voilà, prêt. Vous pouvez maintenant exécuter et vérifier. Cliquez sur les liens et les boutons, essayez d'ajouter/supprimer/modifier des entrées. Si tout est fait correctement, cela devrait fonctionner. Il s'agit désormais d'une application CRUD à part entière utilisant Hibernate, Spring, MySQL. A suivre... Présentation de Maven, Spring, MySQL, Hibernate et de la première application CRUD (partie 1) Présentation de Maven, Spring, MySQL, Hibernate et de la première application CRUD (partie 2) Présentation de Maven, Spring, MySQL, Hibernate et de première application CRUD (partie 3) Introduction à Maven, Spring, MySQL, Hibernate et la première application CRUD (partie 4)