Curso de CRUD con MyBatis | Persistencia Java | Gestión de Base de Datos

Introducción

En este proyecto, aprenderá a realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) en una tabla de horario de cursos utilizando MyBatis, un popular marco de persistencia Java.

👀 Vista previa

Vista previa de la tabla de horario de cursos

🎯 Tareas

En este proyecto, aprenderá:

Cómo configurar el proyecto y establecer las dependencias necesarias
Cómo mejorar la clase entidad Course agregando propiedades, constructores, métodos setter/getter y otros contenidos
Cómo mejorar el archivo de configuración de MyBatis mybatis-config.xml
Cómo implementar la interfaz CourseMapper y sus métodos correspondientes
Cómo implementar el mapeo SQL en el archivo CourseMapper.xml
Cómo implementar los casos de prueba en el archivo MyBatisTest.java

🏆 Logros

Después de completar este proyecto, podrá:

Utilizar MyBatis para interactuar con una base de datos MySQL
Definir clases entidades y configurar los archivos de mapeo de MyBatis
Implementar operaciones CRUD utilizando MyBatis
Escribir pruebas unitarias para verificar la funcionalidad de la aplicación

Configurar el proyecto

En este paso, aprenderá a configurar el proyecto y establecer las dependencias necesarias.

Abra el archivo pom.xml en el proyecto MyBatisCourseDemo02.
Agregue las siguientes dependencias a la sección <dependencies>:

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

    <!-- Jar del controlador de la base de datos MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>

Agregue las siguientes propiedades a la sección <properties> para configurar la codificación de caracteres y la versión 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>

Agregue la siguiente sección <build> para incluir los archivos de mapeo XML en el 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>

Mejorar la clase de entidad

En este paso, mejorará la clase entidad Course agregando propiedades, constructores, métodos setter/getter y otros contenidos.

Abra el archivo Course.java en el directorio /src/main/java/org/labex/pojo.
Agregue las siguientes propiedades a la clase Course:

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

Agregue el siguiente constructor:

    public Course() {

    }

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

Agregue los siguientes métodos getter y setter:

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

Agregue el siguiente método toString():

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

Mejorar la configuración de MyBatis

En este paso, mejorará el archivo de configuración de MyBatis mybatis-config.xml.

Abra el archivo mybatis-config.xml en el directorio src/main/resources.
Agregue la siguiente sección <typeAliases> para definir alias para las clases entidades:

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

Configure el entorno de origen de datos en la sección <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>

Registre el archivo de mapeo SQL CourseMapper.xml en la sección <mappers>:

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

Implementar la interfaz CourseMapper

En este paso, implementará la interfaz CourseMapper y sus métodos correspondientes.

Abra el archivo CourseMapper.java en el paquete org.labex.mapper.
Agregue los siguientes métodos a la interfaz CourseMapper:

import java.util.List;

import org.labex.pojo.Course;

public interface CourseMapper {

    /**
     * Consultar información de todos los cursos
     */
    public List<Course> queryAllCourse();

    /**
     * Insertar un nuevo curso
     * @param course
     */
    public int insertCourse(Course course);

    /**
     * Actualizar información de un curso
     * @param course
     */
    public int updateCourse(Course course);

    /**
     * Eliminar información de un curso por número de curso
     * @param course
     */
    public int deleteCourse(int cNo);
}

Implementar el mapeo SQL

En este paso, implementará el mapeo SQL en el archivo CourseMapper.xml.

Abra el archivo CourseMapper.xml en el directorio src/main/java/org/labex/mapper.
Agregue las siguientes declaraciones de mapeo SQL:

    <!-- Recuperar información de todos los cursos -->
    <select id="queryAllCourse" resultType="org.labex.pojo.Course">
        select * from course
    </select>

    <!-- Insertar un nuevo curso -->
    <insert id="insertCourse" parameterType="org.labex.pojo.Course">
        insert into course(cNo,cName,teacher)
        values(#{cNo},#{cName},#{teacher})
    </insert>

    <!-- Actualizar información de curso basado en el número de curso -->
    <update id="updateCourse" parameterType="org.labex.pojo.Course">
        update course set cName=#{cName},teacher=#{teacher}
        where cNo=#{cNo}
    </update>

    <!-- Eliminar información de curso basado en el número de curso -->
    <delete id="deleteCourse" parameterType="int">
        delete from course where cNo=#{cNo}
    </delete>

Implementar los casos de prueba

En este paso, implementará los casos de prueba en el archivo MyBatisTest.java.

Abra el archivo MyBatisTest.java en el directorio /src/test/java/org/labex/test.
Agregue los siguientes métodos de prueba:

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";
        // Cargar el archivo de configuración de MyBatis
        Reader reader = Resources.getResourceAsReader(resource);
        // Crear la fábrica de SqlSession
        sessionFactory = new SqlSessionFactoryBuilder().build(reader);
        // Crear un objeto SqlSession capaz de ejecutar instrucciones SQL en archivos de mapeo SQL
        session = sessionFactory.openSession();
    }

    @Test
    public void testSel() throws IOException{
        // Llamar al método getMapper() en session para devolver el objeto de interfaz
        CourseMapper cMapper = session.getMapper(CourseMapper.class);
        // Realizar la consulta y devolver todos los objetos Course
        List<Course> courses = cMapper.queryAllCourse();
        System.out.println(courses);
        session.close();
    }

    @Test
    public void testIns() throws IOException{
        // Llamar al método getMapper() en session para devolver el objeto de interfaz
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

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

        int i = cMapper.insertCourse(course);

        session.commit();

        System.out.println((i!=0? "Datos agregados exitosamente":"Error al agregar datos"));

        session.close();
    }

    @Test
    public void testUpd() throws IOException{
        // Llamar al método getMapper() en session para devolver el objeto de interfaz
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

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

        int i = cMapper.updateCourse(course);

        session.commit();

        System.out.println((i!=0? "Datos actualizados exitosamente":"Error al actualizar datos"));

        session.close();
    }

    @Test
    public void testDEl() throws IOException{
        // Llamar al método getMapper() en session para devolver el objeto de interfaz
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

        int i = cMapper.deleteCourse(7);

        session.commit();

        System.out.println((i!=0? "Datos eliminados exitosamente":"Error al eliminar datos"));

        session.close();
    }
}

Después de completar estos pasos, ha configurado con éxito el proyecto, mejorado la clase entidad, configurado la configuración de MyBatis, implementado la interfaz CourseMapper e implementado los casos de prueba. Ahora puede ejecutar las pruebas para verificar la funcionalidad de la aplicación.

Ejecución

A continuación, compile y ejecute en la terminal y use Maven para verificar los archivos de prueba:

cd MyBatisCourseDemo02
mvn test

Puede consultar los pasos siguientes para verificar los resultados del desafío.

Imagen de caso de prueba no terminado

Resultados de ejecución de la prueba

Resumen

¡Felicidades! Has completado este proyecto. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.

Registro de Horarios de Curso con MyBatis