Index / Java / Ejemplo de operaciones CRUD con MyBatis 3

Ejemplo de operaciones CRUD con MyBatis 3

Autor jc mouse miércoles, septiembre 18, 2019

«MyBatis es una herramienta de persistencia Java que se encarga de mapear sentencias SQL y procedimientos almacenados con objetos a partir de ficheros XML o anotaciones». Santa Wikipedia

En este post realizaremos un ejemplo sencillo paso a paso de operaciones CRUD (create, read, update, delete) en java utilizando la herramienta de persistencia MyBatis.

¿Que necesitamos?

Conector JDBC MariaDB
Librerías de MyBatis o también puedes utilizar Maven
IDE Netbeans, o puedes usar el IDE de tu preferencia.
Sistema Gestor de base de datos XAMPP
java 8 o superior

Paso 1. Base de datos

Creamos una base de datos con el nombre «dbmybatis» y agregamos una tabla de la siguiente forma:

Agregamos 3 registros:

Paso 2. Estructura del proyecto

Creamos un nuevo proyecto java con el nombre de «CRUD MyBatis«, a continuación definimos la estructura de los directorios (packages), es decir:

No olvidemos agregar al proyecto la librería JDBC de MariaDB y los archivos de MyBatis y si utilizas Maven, pues añades las dependencias.

Paso 3. El modelo

En el paquete model agregamos la clase Persona

package org.example.model;
/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class Persona {

    private Integer id;
    private String nombre;
    private Integer edad;
    private String email;

    public Persona() {}

    public Persona(String nombre, Integer edad, String email) {
        this.nombre = nombre;
        this.edad = edad;
        this.email = email;
    }
    
    //GET and SET

    @Override
    public String toString() {
        return "Persona [" + "id=" + id + ", nombre=" + nombre
                + ", edad=" + edad + ", email=" + email + ']';
    }

}

Paso 4. Archivos de configuración

Creamos un archivo jdbc.properties en el paquete org.model.properties y agregamos los datos de conexión a nuestra base de datos:

jdbc.driverClassName=org.mariadb.jdbc.Driver
jdbc.url=jdbc:mariadb://localhost:3306/dbmybatis
jdbc.username=root
jdbc.password=

A continuación creamos un archivo XML en el paquete org.example.data con el nombre de mybatis-config.xml, el código

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
  PUBLIC '-//mybatis.org//DTD Config 3.0//EN'
  'http://mybatis.org/dtd/mybatis-3-config.dtd'>
<configuration>
    <!-- archivo properties donde estan los datos de conexion -->   
    <properties resource='org/example/properties/jdbc.properties'/>
    <typeAliases>
        <typeAlias type='org.example.model.Persona' alias='Persona'></typeAlias>
    </typeAliases>
    <!-- Datos de conexion -->
    <environments default='development'>
        <environment id='development'>
            <transactionManager type='JDBC'/>
            <dataSource type='POOLED'>    
                <property name='driver' value='${jdbc.driverClassName}'/>
                <property name='url' value='${jdbc.url}'/>
                <property name='username' value='${jdbc.username}'/>
                <property name='password' value='${jdbc.password}'/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!-- ruta al archivo XML con las operaciones CRUD -->
        <mapper resource='org/example/data/personaMapper.xml'/>
    </mappers>
</configuration>

Paso 5. Mapeadores

Agregamos en el paquete data una interface llamada PersonaMapper.java con los métodos CRUD que utilizaremos, es decir:

package org.example.data;
import java.util.List;
import org.example.model.Persona;
/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public interface PersonaMapper {

    public List<Persona> todasLasPersonas();
    
    //C: Insertar
    public void create(Persona persona);
    
    //R: Leer
    public Persona read(int id);
    
    //U: Actualizar
    public void update(Persona persona);
    
    //D: Eliminar
    public void delete(int id);
    
}

A continuación, en el mismo paquete añadimos un archivo XML llamado PersonaMapper.xml, es en este archivo donde se escriben las instrucciones SQL.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC '-//mybatis.org//DTD Mapper 3.0//EN'
  'http://mybatis.org/dtd/mybatis-3-mapper.dtd'>
<mapper namespace='org.example.data.PersonaMapper'>
    
    <resultMap type='Persona' id='PersonaList'>
        <id property='id' column='id'/>
        <result property='nombre' column='nombre'/>
        <result property='edad' column='edad'/>    
        <result property='email' column='email'/>    
    </resultMap>   
    <!-- Obtiene lista de personas -->   
    <select id='todasLasPersonas' resultMap='PersonaList'>
        SELECT * FROM persona
    </select>
    
    <!-- Crear registro -->
    <insert id='create' parameterType='org.example.model.Persona'>
        INSERT INTO persona(nombre, edad, email) 
        VALUES(#{nombre,jdbcType=VARCHAR}, #{edad,jdbcType=INTEGER}, #{email,jdbcType=VARCHAR})
    </insert>
    
    <!-- Leer registro dado su ID -->
    <select id='read' parameterType='int' resultType='org.example.model.Persona'>
        SELECT  * FROM persona WHERE id = #{id,jdbcType=INTEGER}
    </select>
    
    <!-- Actualizar registro -->
    <update id='update' parameterType='org.example.model.Persona'>
        UPDATE persona 
        SET
        nombre= #{nombre,jdbcType=VARCHAR},
        edad= #{edad,jdbcType=INTEGER},
        email= #{email,jdbcType=VARCHAR}        
        WHERE id = #{id,jdbcType=INTEGER}
    </update>
  
    <!-- Eliminar registro dado su ID -->
    <delete id='delete' parameterType='int'>
        DELETE FROM persona WHERE id = #{id,jdbcType=INTEGER}
    </delete>
  
</mapper>

Paso 6. Clase utilitaria

Creamos una nueva clase llamada MyBatisUtil.java en el paquete data, esta clase nos permite obtener SqlSessionFactory.

package org.example.data;
import java.io.IOException;
import java.io.Reader;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class MyBatisUtil {

    private static SqlSessionFactory factory;

    private MyBatisUtil() {}

    static {
        Reader reader = null;
        try {
            reader = Resources.getResourceAsReader("org/example/data/mybatis-config.xml");
        } catch (IOException e) {
            throw new RuntimeException(e.getMessage());
        }
        factory = new SqlSessionFactoryBuilder().build(reader);
    }

    public static SqlSessionFactory getSqlSessionFactory() {
        return factory;
    }
}

Paso 7. Servicios

En el paquete org.example.service creamos una clase con el nombre de PersonaService.java, esta clase contiene los métodos CRUD así como también se encarga de abrir y cerrar una conexión a la base de datos con cada operación.

package org.example.service;

import org.example.data.PersonaMapper;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.example.data.MyBatisUtil;
import org.example.model.Persona;
/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class PersonaService {

    public List<Persona> todasLasPersonas() {
        SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory().openSession();
        PersonaMapper personaMapper = sqlSession.getMapper(PersonaMapper.class);

        return personaMapper.todasLasPersonas();
    }

    public void create(Persona persona) {
        SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory().openSession();
        PersonaMapper personaMapper = sqlSession.getMapper(PersonaMapper.class);
        personaMapper.create(persona);
        sqlSession.commit();
        sqlSession.close();
    }

    public Persona read(Integer id) {
        SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory().openSession();
        PersonaMapper personaMapper = sqlSession.getMapper(PersonaMapper.class);

        return personaMapper.read(id);
    }

    public void update(Persona persona) {
        SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory().openSession();
        PersonaMapper personaMapper = sqlSession.getMapper(PersonaMapper.class);
        personaMapper.update(persona);
        sqlSession.commit();
        sqlSession.close();
    }

    public void delete(Integer id) {
        SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory().openSession();
        PersonaMapper personaMapper = sqlSession.getMapper(PersonaMapper.class);
        personaMapper.delete(id);
        sqlSession.commit();
        sqlSession.close();
    }

}

Hasta el momento debemos tener algo como esto:

Paso 8. Probando el CRUD

Para terminar ya solo nos resta probar las operaciones CRUD, implementaremos el código necesario en nuestra clase Main, es decir:

package org.example;

import java.util.List;
import org.example.model.Persona;
import org.example.service.PersonaService;

/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class Main {

    public static void main(String[] args) {
        
        PersonaService personaService = new PersonaService();
        
        System.out.println("> Todos los registros ");
        List<Persona> lista = personaService.todasLasPersonas();
        lista.forEach((p) -> {
            System.out.println(p);
        });
        
        System.out.println("> Lectura de registro id=1");
        Persona persona = personaService.read(1);
        System.out.println("> " +  persona);
        System.out.println("> Actualizando edad" );
        persona.setEdad(28);
        personaService.update(persona);
        
        System.out.println("> Eliminando registro id=2");
        personaService.delete(2);
        
        System.out.println("> creando nuevo registro ");
        personaService.create(new Persona("Mirella Baila Sola",18,"luch0n4@mail.com"));
        
        lista = personaService.todasLasPersonas();
        lista.forEach((p) -> {
            System.out.println(p);
        });
        
    }
    
}