Integración de MyBatis con Spring en un proyecto Maven

Configuración de dependencias en pom.xml

Para integrar MyBatis con Spring en un proyecto Maven, es necesario agregar las dependencias adecuadas en el archivo pom.xml. A continuación se muestra un ejemplo de configuración con groupId y artifactId personalizados.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ejemplo</groupId>
    <artifactId>spring-mybatis-app</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>

    <dependencies>
        <!-- Dependencia para Servlet API -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>

        <!-- Dependencias de Spring Framework -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.10</version>
        </dependency>

        <!-- Dependencias para conexión a base de datos -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>

        <!-- Dependencias de MyBatis y su integración con Spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
            </plugin>
        </plugins>
    </build>
</project>

Configuración del contexto de Spring

El archivo de configuración de Spring (por ejemplo, applicationContext.xml) debe definir un origen de datos, la fábrica de sesiones de MyBatis y los componentes escaneados. Se utiliza un bean de tipo DruidDataSource para la conexión a la base de datos.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- Definición del origen de datos con conexión pooling -->
    <bean id="origenDatos" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="username" value="root"/>
        <property name="password" value="contraseña"/>
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/BasedeDatosPrueba?useSSL=false&amp;serverTimezone=UTC"/>
        <property name="initialSize" value="5"/>
        <property name="maxActive" value="50"/>
        <property name="maxWait" value="60000"/>
    </bean>

    <!-- Configuración de SqlSessionFactory para MyBatis -->
    <bean id="sesionSql" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="origenDatos"/>
        <property name="mapperLocations" value="classpath:com/ejemplo/mapeos/*.xml"/>
    </bean>

    <!-- Escaneo de interfaces DAO -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ejemplo.dao"/>
    </bean>

    <!-- Escaneo de componentes como servicios y controladores -->
    <context:component-scan base-package="com.ejemplo"/>

    <!-- Habilitación de anotaciones de Spring MVC -->
    <mvc:annotation-driven/>

    <!-- Configuración del gestor de transacciones -->
    <bean id="gestorTransacciones"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="origenDatos"/>
    </bean>
    <tx:annotation-driven transaction-manager="gestorTransacciones"/>

    <!-- Resolvedor de vistas para JSP -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/vistas/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

Configuración de web.xml

El descriptor de despligeue web define el servlet de Spring MVC, filtros para manejo de caracteres y otros parámetros de la aplicación web.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
             http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- Servlet de Spring MVC -->
    <servlet>
        <servlet-name>despachador</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>despachador</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- Filtro para codificación de caracteres -->
    <filter>
        <filter-name>filtroCodificacion</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>filtroCodificacion</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- Página de bienvenida -->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

Configuración de la base de datos

Se requiere una base de datos MySQL con una tabla para usuarios. A continuación se describe la estructura de ejemplo.

Nombre de la base de datos: BasedeDatosPrueba
Nombre de la tabla: uusarios
Campos: id_usuario (INT, PRIMARY KEY), nombre_usuario (VARCHAR), contrasena (VARCHAR), telefono (VARCHAR), correo (VARCHAR)
Datos de ejemplo: INSERT INTO usuariso VALUES (1, 'ejemplo_usuario', 'clave123', '123456789', 'ejemplo@correo.com')

Implementación del código

Estructura del proyecto

El paquete principal es com.ejemplo, con subpaquetes para modelo, dao, servicio y controlador.

Clase de entidad

La clase Usuario representa la tabla de la base de datos con campos en camelCase.

package com.ejemplo.modelo;

public class Usuario {
    private int idUsuario;
    private String nombreUsuario;
    private String contrasena;
    private String telefono;
    private String correo;

    // Getters y setters
    public int getIdUsuario() {
        return idUsuario;
    }

    public void setIdUsuario(int idUsuario) {
        this.idUsuario = idUsuario;
    }

    public String getNombreUsuario() {
        return nombreUsuario;
    }

    public void setNombreUsuario(String nombreUsuario) {
        this.nombreUsuario = nombreUsuario;
    }

    public String getContrasena() {
        return contrasena;
    }

    public void setContrasena(String contrasena) {
        this.contrasena = contrasena;
    }

    public String getTelefono() {
        return telefono;
    }

    public void setTelefono(String telefono) {
        this.telefono = telefono;
    }

    public String getCorreo() {
        return correo;
    }

    public void setCorreo(String correo) {
        this.correo = correo;
    }
}

Archivo de mapeo SQL

El archivo XML en el paquete com.ejemplo.mapeos define las consultas SQL para MyBatis.

<?xml version="1.0" encoding="UTF-8"?>

<mapper namespace="com.ejemplo.dao.UsuarioDao">
    <select id="obtenerUsuarioPorId" resultType="com.ejemplo.modelo.Usuario" parameterType="int">
        SELECT id_usuario AS idUsuario, nombre_usuario AS nombreUsuario,
               contrasena, telefono, correo
        FROM usuarios
        WHERE id_usuario = #{idUsuario}
    </select>
</mapper>

Interfaz DAO

La interfaz UsuarioDao define métodos para acceder a los datos.

package com.ejemplo.dao;

import com.ejemplo.modelo.Usuario;
import java.util.List;
import java.util.Map;

public interface UsuarioDao {
    Usuario obtenerUsuarioPorId(Map<String, Object> parametros);
}

Servicio

La interfaz y su implementación encapsulan la lógica de negocio.

package com.ejemplo.servicio;

import com.ejemplo.modelo.Usuario;
import java.util.Map;

public interface ServicioUsuario {
    Usuario buscarUsuarioPorId(Map<String, Object> parametros);
}

package com.ejemplo.servicio.impl;

import com.ejemplo.dao.UsuarioDao;
import com.ejemplo.modelo.Usuario;
import com.ejemplo.servicio.ServicioUsuario;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Map;

@Service
public class ServicioUsuarioImpl implements ServicioUsuario {

    @Resource
    private UsuarioDao usuarioDao;

    @Override
    public Usuario buscarUsuarioPorId(Map<String, Object> parametros) {
        return usuarioDao.obtenerUsuarioPorId(parametros);
    }
}

Controlador

El controlador maneja las solicitudes HTTP y retorna respuestas JSON.

package com.ejemplo.controlador;

import com.ejemplo.modelo.Usuario;
import com.ejemplo.servicio.ServicioUsuario;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

@Controller
@RequestMapping("/api/usuarios")
public class ControladorUsuario {

    @Resource
    private ServicioUsuario servicioUsuario;

    @RequestMapping("/{id}")
    @ResponseBody
    public Usuario obtenerUsuario(@PathVariable int id) {
        Map<String, Object> params = new HashMap<>();
        params.put("idUsuario", id);
        return servicioUsuario.buscarUsuarioPorId(params);
    }
}

Página de prueba

El archivo index.jsp incluye una solicitud AJAX para probar el endpoint.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Prueba de Integración</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    <script>
        function consultarUsuario() {
            $.ajax({
                url: "/spring-mybatis-app/api/usuarios/1",
                method: "GET",
                dataType: "json",
                success: function(data) {
                    console.log("Datos recibidos:", data);
                    alert("Usuario: " + data.nombreUsuario);
                },
                error: function(xhr, status, error) {
                    console.error("Error:", error);
                }
            });
        }
    </script>
</head>
<body>
    <button onclick="consultarUsuario()">Probar consulta</button>
</body>
</html>

Ejecución y verificación

Para ejecutar el proyecto, se puede usar el plugin de Maven para Tomcat. Al acceder a la página de prueba y hacer clic en el botón, se debe mostrar una alerta con el nombre del usuario consultado, confirmando la integración exitosa entre Spring, MyBatis y la base de datos.

Etiquetas: Spring MyBatis maven java Integración

Publicado el 7-8 05:20

Friki Work