Todo lo que necesitas saber sobre MyBatis en Java

1. Introducción

MyBatis es un marco de persistencia de código abierto que simplifica la implementación del acceso a bases de datos en aplicaciones Java. Proporciona soporte para SQL personalizado, procedimientos almacenados y diferentes tipos de relaciones de mapeo. En términos simples, es una alternativa a JDBC y Hibernate. En esta entrada, exploraremos cómo MyBatis puede optimizar la interacción con bases de datos en tus aplicaciones Java, mostrando desde la configuración inicial hasta características avanzadas como la generación de SQL dinámica.

2. Dependencias de Maven

Para utilizar MyBatis en tu proyecto Java, necesitas agregar la dependencia correspondiente a tu archivo pom.xml:

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.4</version>
</dependency>

La última versión de la dependencia se puede encontrar aquí.

3. APIs de Java

3.1. SQLSessionFactory

SQLSessionFactory es la clase central para cualquier aplicación MyBatis. Esta clase se instancia utilizando el método builder() de SQLSessionFactoryBuilder, que carga un archivo de configuración XML:

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SQLSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

El archivo de configuración de Java incluye configuraciones como la definición de la fuente de datos, detalles del gestor de transacciones y una lista de mapeadores que definen relaciones entre entidades, los cuales se utilizan para construir la instancia de SQLSessionFactory:

public static SqlSessionFactory buildSqlSessionFactory() {
    DataSource dataSource = new PooledDataSource(DRIVER, URL, USERNAME, PASSWORD);
    Environment environment = new Environment("Development", new JdbcTransactionFactory(), dataSource);
    
    Configuration configuration = new Configuration(environment);
    configuration.addMapper(PersonMapper.class);
    // ...

    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    return builder.build(configuration);
}

3.2. SQLSession

SQLSession contiene métodos para realizar operaciones en la base de datos, obtener mapeadores y gestionar transacciones. Se puede instanciar desde la clase SQLSessionFactory. Las instancias de esta clase no son seguras para múltiples hilos.

Después de realizar la operación en la base de datos, la sesión debe cerrarse. Como SqlSession implementa la interfaz AutoCloseable, podemos utilizar un bloque try-with-resources:

try (SqlSession session = sqlSessionFactory.openSession()) {
    // realizar trabajo
}

4. Mapeadores

Los mapeadores son interfaces de Java que mapean métodos a las correspondientes declaraciones SQL. MyBatis proporciona anotaciones para definir operaciones en la base de datos:

public interface PersonMapper {
    @Insert("Insert into person(name) values (#{name})")
    Integer save(Person person);
    
    @Select("Select personId, name from Person where personId=#{personId}")
    @Results(value = {
        @Result(property = "personId", column = "personId"),
        @Result(property = "name", column = "name"),
        @Result(property = "addresses", javaType = List.class,
                column = "personId", many = @Many(select = "getAddresses"))
    })
    Person getPersonById(Integer personId);
}

5. Anotaciones de MyBatis

Veamos algunas de las principales anotaciones proporcionadas por MyBatis:

• @Insert, @Select, @Update, @Delete: Estas anotaciones representan las declaraciones SQL que se ejecutan al llamar a métodos anotados:

@Insert("Insert into person(name) values (#{name})")
public Integer save(Person person);

@Update("Update Person set name= #{name} where personId=#{personId}")
public void updatePerson(Person person);

@Delete("Delete from Person where personId=#{personId}")
public void deletePersonById(Integer personId);

• @Results: Es una lista de mapeos de resultados que contiene los detalles de cómo las columnas de la base de datos se mapean a los atributos de las clases Java:

@Select("Select personId, name from Person where personId=#{personId}")
@Results(value = {
    @Result(property = "personId", column = "personId"),
    @Result(property = "name", column = "name"),
    @Result(property = "addresses", javaType = List.class)
})
public Person getPersonById(Integer personId);

• @Result: Representa una sola instancia de Result fuera de la lista de resultados recuperados de @Results.
• @Many: Especifica un mapeo de un objeto a una colección de otros objetos:

@Results(value = {
    @Result(property = "addresses", javaType = List.class,
            column = "personId", many = @Many(select = "getAddresses"))
})

• @MapKey: Se utiliza para convertir la lista de registros a un Map de registros con la clave definida por el atributo value:

@Select("select * from Person")
@MapKey("personId")
Map getAllPerson();

• @Options: Esta anotación especifica una amplia gama de conmutadores y configuraciones que se definen:

@Insert("Insert into address (streetAddress, personId) values(#{streetAddress}, #{personId})")
@Options(useGeneratedKeys = false, flushCache = true)
public Integer saveAddress(Address address);

6. SQL Dinámico

El SQL dinámico es una característica muy poderosa proporcionada por MyBatis, que permite estructurar SQL complejos con precisión. A diferencia del código JDBC tradicional, que requiere escribir sentencias SQL concatenando cadenas (lo que puede ser propenso a errores), MyBatis facilita la creación de SQL a través de clases:

@SelectProvider(type=MyBatisUtil.class, method="getPersonByName")
public Person getPersonByName(String name);

Aquí, hemos especificado una clase y un nombre de método que construyen y generan el SQL final:

public class MyBatisUtil {
    public String getPersonByName(String name) {
        return new SQL() {{
            SELECT("*");
            FROM("person");
            WHERE("name like #{name} || '%'");
        }}.toString();
    }
}

7. Soporte para Procedimientos Almacenados

MyBatis también permite ejecutar procedimientos almacenados utilizando la anotación @Select. Debemos pasar el nombre del procedimiento almacenado y la lista de parámetros, usando un CALL explícito a ese procedimiento:

@Select(value = "{CALL getPersonByProc(#{personId, mode=IN, jdbcType=INTEGER})}")
@Options(statementType = StatementType.CALLABLE)
public Person getPersonByProc(Integer personId);

8. iBATIS vs. MyBatis

MyBatis comenzó su andadura como iBATIS antes de ser renombrado. iBATIS simplificaba el mapeo SQL y reducía el código base de JDBC. En contraste, MyBatis introdujo anotaciones, mejoró el soporte para SQL dinámico y una mejor integración con marcos de Java modernos como Spring.

A continuación se presenta una tabla de comparación que resalta las diferencias clave entre iBATIS y MyBatis:

9. Conclusión

En este artículo, exploramos las características clave de MyBatis y cómo simplifica el desarrollo de aplicaciones de base de datos al reducir el código base y facilitar el mapeo SQL. También examinamos varias anotaciones que proporciona MyBatis, como @Select, @Insert y @Results, que ayudan a definir operaciones en la base de datos de manera más eficiente y legible.

MyBatis es una herramienta poderosa que permite a los desarrolladores de Java manejar el acceso a bases de datos de manera más efectiva. Con su fuerte soporte para SQL personalizado, mapeadores intuitivos y dinámicos, y un manejo mejorado de procedimientos almacenados, MyBatis se ha convertido en una opción preferida entre muchos desarrolladores.

Recuerda siempre realizar pruebas extensivas y manejar adecuadamente las configuraciones de conexión para asegurar la robustez y eficiencia de tus aplicaciones.