Primeros pasos con MyBatis

En este breve tutorial, veremos como iniciarse con MyBatis.
Vamos a mostrar un breve ejemplo muy sencillo de cómo configurar MyBatis
a través de anotaciones.

Índice de contenidos

• 1. Introducción
• 2. Entorno
• 3. Configuración
• 4. Interfaz de Mapeo
  • 4.1. Implementación del modelo de datos
  • 4.2. Implementación de la interfaz de mapeo
• 5. Contexto de Spring
• 6. Conclusiones
• 7. Referencias

1. Introducción

MyBatis (anteriormente iBatis) es un framework de persistencia que soporta SQL.
Este framework simplifica la programación frente al uso de JDBC. MyBatis puede
configurarse con XML o anotaciones.

En este caso vamos a ver un breve ejemplo de la configuración mediante
anotaciones, ya que en este portal podemos encontrar este tutorial
de la configuración de MyBatis mediante XML.

2. Entorno

El tutorial está escrito usando el siguiente entorno:

• Hardware: Portátil MacBook Pro 15′ (2,2 Ghz Intel Core i7, 8GB DDR3).
• Sistema Operativo: Mac OS High Sierra 10.13.2
• Entorno de desarrollo: Eclipse Oxygen
• Apache Maven 3.5.2
• Spring 5.0.2.RELEASE
• MyBatis 3.2.4
• MySql 5.1.34

3. Configuración

En primer lugar, vamos a añadir las dependencias necesarias en el pom.xml para poder
comenzar con nuestro ejemplo.

pom.xml

	<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.0.2.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			 <version>5.0.2.RELEASE</version>
		</dependency>
		<!-- MyBatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.4</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.0</version>
		</dependency>
		<!-- JDBC -->
		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    			<version>5.0.2.RELEASE</version>
		</dependency>
		<!-- Mysql -->
		 <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
      </dependency>
	

Una vez introducidas las dependencias en el fichero pom.xml, vamos a continuar
con la configuración de MyBatis a través de anotaciones.

Creamos una clase, que en este ejemplo la denominaremos AppConfig.java. En esta
clase vamos a configurar tanto MyBatis, como la conexión con la base de datos.
En primer lugar esta clase tendra la anotación de @Configuration, esta anotación
indica que esta clase declara uno o más métodos @Bean
y puede ser procesada por el contenedor de Spring. La anotación @Bean indica que
ese método produce un bean.

A continuación, para indicar donde se encuentra la interfaz donde MyBatis va a
realizar el mapeo con las sentencias SQL, utilizamos la anotación @MapperScan.
En este caso en vez de Mapper (nombre más común en la configuración con XML,
hemos utilizado el nombre de Repository).

AppConfig.java

import javax.sql.DataSource;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.SimpleDriverDataSource;

@Configuration
@MapperScan("com.tutorialMyBatis.Repository")
public class AppConfig {

	@Bean
	public DataSource dataSource() {
		SimpleDriverDataSource sdds = new SimpleDriverDataSource();
		sdds.setDriverClass(com.mysql.jdbc.Driver.class);
		sdds.setUrl("jdbc:mysql://127.0.0.1:3306/ejemplo");
		sdds.setUsername("root");
		sdds.setPassword("password");
		return sdds;
	}

	@Bean
	public DataSourceTransactionManager transactionManager() {
		return new DataSourceTransactionManager(dataSource());
	}

	@Bean
	public SqlSessionFactoryBean sqlSessionFactory() throws Exception {
		SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
		sessionFactory.setDataSource(dataSource());
		return sessionFactory;
	}
}

Como podemos observar, en el primer método denominado con el nombre dataSource()
se establece la conexión con la base de datos, en este ejemplo se decide utilizar
MySql.

En el segundo método denominado transactionManager(), utiliza la conexión obtenida
del DataSource para gestionar la transacción.

El tercer método sqlSessionFactory() es el encargado de crear la sesión con MyBatis,
como estamos utilizando Spring se usa SqlSessionFactoryBean para crear la sesión.

4. Interfaz de Mapeo

Como hemos mencionado anteriormente, en esta interfaz es donde se van a mapear
las sentencias SQL gracias a MyBatis, es aquí donde podemos apreciar la simplificación
de código respecto a JDBC.

4.1. Definición del modelo de datos

En primer lugar definimos la clase Footballer, que será el modelo de datos o
POJO (Plain Old Java Object) a introducir en la base de datos.

Footballer.java

	public class Footballer {
		private int id;
		private int number;
		private String name;
		private String surname;

		public Footballer() {

		}

		public Footballer(int number, String name, String surname) {
			this.number = number;
			this.name = name;
			this.surname = surname;
		}

		public int getId() {
			return id;
		}

		public void setId(int id) {
			this.id = id;
		}

		public int getNumber() {
			return number;
		}

		public void setNumber(int number) {
			this.number = number;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public String getSurname() {
			return surname;
		}

		public void setSurname(String surname) {
			this.surname = surname;
		}

		public String toString() {
			return "Footballer: " + this.name + " " + this.surname + "\nNumber: " + this.number;
		}

	}

4.2. Definición de la interfaz de mapeo

Ahora sí procedemos a la definición de nuestra interfaz de mapeo, en este ejemplo
solo hemos definido una operación de inserción y una operación
de búsqueda en la base de datos.

FootballerRepository.java

import java.util.List;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

import com.tutorialMyBatis.Model.Footballer;

@Repository
public interface FootballerRepository {
	@Insert("INSERT INTO footballer (id,number,name,surname) VALUES (#{id},#{number},#{name},#{surname})")
	void addFootballer (Footballer footballer);

	@Select("SELECT * FROM footballer")
	List selectFootballers();

}

Como se ha mencionado anteriormente la palabra Mapper es mas utilizada a la hora
de realizar la configuración con XML, por eso en nuestro caso hemos decidido utilizar
la palabra Repository.

Resulta llamativo la notación #{id} por ejemplo, a la hora de realizar la inserción de un
elemento en la base de datos. Con JDBC este parámetro iría identificado con ?
en el PreparedStatement.

Pero en este caso con esta notación, se indica a MyBatis que cree un parámetro
PreparedStatement, de forma que resulta mucho más sencillo, ya que requiere menos
código y menos esfuerzo a la hora de instanciar los objetos.

Por último, vamos a comentar la anotación @Repository, con esta anotación se indica
que la clase, en este caso la interfaz, es un componente al igual que se hace con @Service, @Controller y el padre de todos @Component, indicando a Spring que es un bean a incluir en su contexto para poder ser instanciable en otros componentes.

5. Contexto de Spring

Para terminar con nuestro ejemplo vamos a levantar el contexto de Spring, para
ello vamos a utilizar la clase AnnotationConfigApplicationContext, que va a
identificar todas las anotaciones mencionadas anteriormente.

App.java

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.tutorialMyBatis.Model.Footballer;
import com.tutorialMyBatis.Repository.FootballerRepository;


public class App
{
    public static void main( String[] args ){
    		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

    		FootballerRepository footballerRepository = context.getBean(FootballerRepository.class);

    		Footballer footballer = new Footballer(4,"Sergio","Ramos Garcia");
    		footballerRepository.addFootballer(footballer);

    		for(Footballer footballer1 : footballerRepository.selectFootballers()) {
    			System.out.println(footballer1.toString());
    		}
    }
}

Una vez levantado el contexto de Spring con la configuración definida en la clase
AppConfig, se instancia el Mapper donde se mapean las sentencias SQL con
MyBatis (FootballerRepository.java) y se procede a la inserción y búsqueda en
la base de datos para terminar con el ejemplo.

Un aspecto que me gustaría destacar de cara a futuras aplicaciones, a la hora de crear un
controlador o una capa de servicios, para inyectar la interfaz de mapeo se utiliza
la anotación @Autowired en la definición del atributo que corresponda a la interfaz
de mapeo.

	@Autowired
	FootballerRepository footballerRepository;

6. Conclusiones

Como hemos podido apreciar, el framework MyBatis nos permite realizar operaciones
de persistencia mediante una forma sencilla, ya que nos permite simplificar
nuestro código respecto a JDBC.

7. Referencias

• http://www.mybatis.org/spring/es/index.html
• http://www.mybatis.org/spring/apidocs/reference/org/mybatis/spring/SqlSessionFactoryBean.html