Cours CRUD MyBatis | Persistance Java | Gestion de base de données

Introduction

Dans ce projet, vous allez apprendre à effectuer des opérations CRUD (Create, Read, Update, Delete) sur une table de planning de cours à l'aide de MyBatis, un populaire framework de persistance Java.

👀 Aperçu

Aperçu de la table de planning de cours

🎯 Tâches

Dans ce projet, vous allez apprendre :

Comment configurer le projet et installer les dépendances nécessaires
Comment améliorer la classe d'entité Course en ajoutant des propriétés, des constructeurs, des méthodes setter/getter et autres éléments
Comment améliorer le fichier de configuration MyBatis mybatis-config.xml
Comment implémenter l'interface CourseMapper et ses méthodes correspondantes
Comment implémenter la carte SQL dans le fichier CourseMapper.xml
Comment implémenter les cas de test dans le fichier MyBatisTest.java

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

Utiliser MyBatis pour interagir avec une base de données MySQL
Définir des classes d'entité et configurer les fichiers de mappage MyBatis
Implémenter des opérations CRUD à l'aide de MyBatis
Écrire des tests unitaires pour vérifier la fonctionnalité de l'application

Configurer le projet

Dans cette étape, vous allez apprendre à configurer le projet et à installer les dépendances nécessaires.

Ouvrez le fichier pom.xml dans le projet MyBatisCourseDemo02.
Ajoutez les dépendances suivantes à la section <dependencies> :

<!-- MyBatis jar -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>

    <!-- MySQL database driver jar -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>

Ajoutez les propriétés suivantes à la section <properties> pour configurer l'encodage des caractères et la version de JDK :

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

Ajoutez la section <build> suivante pour inclure les fichiers de mappage XML dans le classpath :

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

Améliorer la classe d'entité

Dans cette étape, vous allez améliorer la classe d'entité Course en ajoutant des propriétés, des constructeurs, des méthodes setter/getter et autres éléments.

Ouvrez le fichier Course.java dans le répertoire /src/main/java/org/labex/pojo.
Ajoutez les propriétés suivantes à la classe Course :

    private int cNo;
    private String cName;
    private String teacher;

Ajoutez le constructeur suivant :

    public Course() {

    }

    public Course(int cNo, String cName, String teacher) {
        this.cNo = cNo;
        this.cName = cName;
        this.teacher = teacher;
    }

Ajoutez les méthodes getter et setter suivantes :

    public int getCNo() {
        return cNo;
    }

    public void setCNo(int cNo) {
        this.cNo = cNo;
    }

    public String getCName() {
        return cName;
    }

    public void setCName(String cName) {
        this.cName = cName;
    }

    public String getTeacher() {
        return teacher;
    }

    public void setTeacher(String teacher) {
        this.teacher = teacher;
    }

Ajoutez la méthode toString() suivante :

    @Override
    public String toString() {
        return "Course number: " + this.cNo + "\tCourse name: " + this.cName + "\tTeacher: " + this.teacher;
    }

Améliorer la configuration MyBatis

Dans cette étape, vous allez améliorer le fichier de configuration MyBatis mybatis-config.xml.

Ouvrez le fichier mybatis-config.xml dans le répertoire src/main/resources.
Ajoutez la section <typeAliases> suivante pour définir des alias pour les classes d'entité :

    <typeAliases>
        <package name="org.labex.pojo"/>
    </typeAliases>

Configurez l'environnement de la source de données dans la section <environments> :

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}" />
                <property name="url" value="${mysql.url}" />
                <property name="username" value="${mysql.username}" />
                <property name="password" value="${mysql.password}" />
            </dataSource>
        </environment>
    </environments>

Enregistrez le fichier de mappage SQL CourseMapper.xml dans la section <mappers> :

    <mappers>
        <package name="org.labex.mapper" />
    </mappers>

Implémenter l'interface CourseMapper

Dans cette étape, vous allez implémenter l'interface CourseMapper et ses méthodes correspondantes.

Ouvrez le fichier CourseMapper.java dans le package org.labex.mapper.
Ajoutez les méthodes suivantes à l'interface CourseMapper :

import java.util.List;

import org.labex.pojo.Course;

public interface CourseMapper {

    /**
     * Interroger toutes les informations sur les cours
     */
    public List<Course> queryAllCourse();

    /**
     * Insérer un nouveau cours
     * @param course
     */
    public int insertCourse(Course course);

    /**
     * Mettre à jour les informations d'un cours
     * @param course
     */
    public int updateCourse(Course course);

    /**
     * Supprimer les informations d'un cours par numéro de cours
     * @param course
     */
    public int deleteCourse(int cNo);
}

Implémenter la carte SQL

Dans cette étape, vous allez implémenter le mappage SQL dans le fichier CourseMapper.xml.

Ouvrez le fichier CourseMapper.xml dans le répertoire src/main/java/org/labex/mapper.
Ajoutez les instructions de mappage SQL suivantes :

    <!-- Récupérer toutes les informations sur les cours -->
    <select id="queryAllCourse" resultType="org.labex.pojo.Course">
        select * from course
    </select>

    <!-- Insérer un nouveau cours -->
    <insert id="insertCourse" parameterType="org.labex.pojo.Course">
        insert into course(cNo,cName,teacher)
        values(#{cNo},#{cName},#{teacher})
    </insert>

    <!-- Mettre à jour les informations sur un cours en fonction du numéro de cours -->
    <update id="updateCourse" parameterType="org.labex.pojo.Course">
        update course set cName=#{cName},teacher=#{teacher}
        where cNo=#{cNo}
    </update>

    <!-- Supprimer les informations sur un cours en fonction du numéro de cours -->
    <delete id="deleteCourse" parameterType="int">
        delete from course where cNo=#{cNo}
    </delete>

Implémenter les cas de test

Dans cette étape, vous allez implémenter les cas de test dans le fichier MyBatisTest.java.

Ouvrez le fichier MyBatisTest.java dans le répertoire /src/test/java/org/labex/test.
Ajoutez les méthodes de test suivantes :

import java.io.IOException;
import java.io.Reader;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
import org.labex.mapper.CourseMapper;
import org.labex.pojo.Course;

public class MyBatisTest {

    SqlSessionFactory sessionFactory = null;
    SqlSession session = null;

    @Before
    public void before() throws IOException{
        String resource = "mybatis-config.xml";
        // Charger le fichier de configuration MyBatis
        Reader reader = Resources.getResourceAsReader(resource);
        // Créer la factory SqlSession
        sessionFactory = new SqlSessionFactoryBuilder().build(reader);
        // Créer un objet SqlSession capable d'exécuter les instructions SQL dans les fichiers de mappage SQL
        session = sessionFactory.openSession();
    }

    @Test
    public void testSel() throws IOException{
        // Appeler la méthode getMapper() dans session pour retourner l'objet d'interface
        CourseMapper cMapper = session.getMapper(CourseMapper.class);
        // Effectuer une requête et retourner tous les objets Course
        List<Course> courses = cMapper.queryAllCourse();
        System.out.println(courses);
        session.close();
    }

    @Test
    public void testIns() throws IOException{
        // Appeler la méthode getMapper() dans session pour retourner l'objet d'interface
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

        Course course = new Course(8,"Artificial Intelligence","Tom");

        int i = cMapper.insertCourse(course);

        session.commit();

        System.out.println((i!=0? "Données ajoutées avec succès":"Échec de l'ajout des données"));

        session.close();
    }

    @Test
    public void testUpd() throws IOException{
        // Appeler la méthode getMapper() dans session pour retourner l'objet d'interface
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

        Course course = new Course(1,"Software Testing","Jack");

        int i = cMapper.updateCourse(course);

        session.commit();

        System.out.println((i!=0? "Données mises à jour avec succès":"Échec de la mise à jour des données"));

        session.close();
    }

    @Test
    public void testDEl() throws IOException{
        // Appeler la méthode getMapper() dans session pour retourner l'objet d'interface
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

        int i = cMapper.deleteCourse(7);

        session.commit();

        System.out.println((i!=0? "Données supprimées avec succès":"Échec de la suppression des données"));

        session.close();
    }
}

Après avoir effectué ces étapes, vous avez configuré avec succès le projet, amélioré la classe d'entité, configuré les paramètres MyBatis, implémenté l'interface CourseMapper et implémenté les cas de test. Vous pouvez maintenant exécuter les tests pour vérifier la fonctionnalité de l'application.

Exécution

Ensuite, compilez et exécutez dans le terminal, et utilisez Maven pour vérifier les fichiers de test :

cd MyBatisCourseDemo02
mvn test

Vous pouvez vous référer aux étapes suivantes pour vérifier les résultats du défi.

Image de cas de test non terminé

Résultats de l'exécution des tests

Résumé

Félicitations ! Vous avez terminé ce projet. Vous pouvez pratiquer plus de laboratoires sur LabEx pour améliorer vos compétences.

Gestion des opérations CRUD sur l'emploi du temps des cours avec MyBatis