Desde hace algun tiempo, varios colegas y amigos me han estado pidiendo un curso sobre MyBatis, y en especial sobre el MyBatis Generator con Spring MVC. Asi que me puse en la tarea.
Prerrequisitos: Tener instalado mysql y el jdk 6 de java.
Instalacion Eclipse Kepler
Lo primero que debemos hacer es descargar el Eclipse Kepler, en esta direccion
Eclipse Kepler podran encontrar la version para windows de 64 bit, una vez descargado el archivo, lo descomprimimos y en la ruta donde queramos de nuestra maquina, en mi caso lo pondre en la raiz, en mi disco "C:/" como muestro en las siguientes imagenes
En nuestro caso utilizamos 7Zip para descomprimir el archivo, que nos preguntara la ruta donde queremos descomprimirlo
Como pueden ver descomprimimos la carpeta en la raiz de nuestra maquina. Luego de descomprimirla debemos ejecutar el archivo eclipse.exe que se encuentra dentro de la carpeta que previamente descomprimimos.
Al ejecutarlo esta nos pedira que elijamos el workspace donde trabajaremos.
Instalacion MyBatis Generator Plugin
Despues de tener instalado el eclipse, debemos instalar el MyBatis Generator Plugin, dentro de nuestra distribucion eclipse kepler.
Para hacerlo debemos ir a "Help -> Install New Software...".
Se nos desplegara un wizard donde podremos instalar cualquier plugin disponible para eclipse, ya sea a traves de un zip que hayamos descargado previamente o a traves de una url. En nuestro caso es una url asi que apretamos en "Add".
El popup que nos sale nos pide la url del plugin y un nombre con el cual identificaremos nuestro plugin. El nombre puede ser cualquier cosa, lo importante es poner la siguiente url.
Eclipse recueperara la lista de los plugins o funcionalidades que va a instalar, y nos dara la oportunidad de elegir que queremos instalar. En nuestro caso instalamos todo y apretamos "Next".
Apretamos "Ok" y comenzara la instalacion de nuestro plugin. Luego el wizard nos preguntara si aceptamos la licencia. Para poder continuar aceptamos y apretamos "Finish".
Luego nos advertira que este plugin no esta firmado, simplemente le damos ok y seguimos con la instalacion.
Cuando el plugin haya sido instalado completamente, nos sugerira que reiniciemos el eclipse para que todo quede instalado correctamente. Asi que apretamos "Yes".
Cuando eclipse vuelva a cargar nosotros ya tendremos nuestro plugin correctamente instalado y listo para usarlo.
Creacion y ejecucion del proyecto Maven desde Eclipse
La distribucion kepler de eclipse ya cuenta con el plugin de maven instalado por defecto, asi que no ahondaremos en este tema. Sin embargo, si estan utilizando una version mas antigua de eclipse, el procedimiento de instalacion es el mismo que el que describimos anteriormente.
Lo primero que debemos hacer es crear un proyecto web con maven. Esto lo haremos dando click derecho sobre el panel izquierdo de nuestro ide, en "Project Explorer", vamos a "New -> Other".
Eclipse nos permite crear muchos tipos de proyectos, asi que filtraremos por la palabra "maven" en la ventana de los tipos de proyectos. Apenas hagamos esto se nos mostrara en la lista "Maven Project", elegimos este y damos "Next"
En la siguiente ventana simplemente apretamos "Next". ya que por ahora nada es relevante.
Luego el wizard nos de la opcion de seleccionar el Archetype del proyecto, en nuestro caso filtramos en el campo "Filter" con la palabra "web", y elegimos "maven-archetype-webapp" y apretamos "Next".
En la siguiente ventana nos pediran el nombre del proyecto. Nosotros lo llenamos asi y apretamos "Finish"
Finalmente nuestro proyecto maven quedara de la siguiente forma. No entraremos en detalle sobre la estructura de maven, ya que esto lo haremos en otro tutorial.
Una vez creado el proyecto debemos configurar el compilador de maven para que este cuando lo ejecutemos nos compile el proyecto(Esto se hace por que con maven dependiendo de los parametros se puede compilar, testear, instalar.etc) En nuestro caso configuraremos maven de forma que limpiemos y compilemos cada vez que lo necesitemos. Para esto hacemos click derecho sobre el archivo pom.xml vamos a "Run As -> Run Configurations..."
Se nos desplegara una pantalla donde podremos configurar las sentencias de ejecucion de aplicaciones y de algunos plugins. En nuestro caso damos click derecho sobre "Maven Build" y luego apretamos "New".
Despues configuramos nuestras rutina de ejecucion de maven, la idea de esto es hacerlo una vez y poder usarlo muchas veces. Entonces debemos definir.
- Nombre para la rutina de ejecucion: Nombramos nuestra instancia de ejecucion puede ser cualquier nombre en nuestro caso es "MGTestRun"
- JDK sobre el cual correra maven: Es importante que seleccionemos un JDK no un JRE, ya que estos ultimos carecen de algunas librerias que maven necesita.
- Proyecto sobre el cual se hara la ejecucion. Apretaremos en "Browse Workspace..." y seleccionaremos el proyecto que deseamos asociar con esta instancia de ejecucion de maven.
Seleccionamos el proyecto.
- Goals del proyecto: Definiremos los goals "clean compile", con esto le diremos a maven que cada vez que corramos esta instancia de ejecucion se ejecute maven para limpiar lo ya compilado y compilar todo de nuevo.
Por ultimo debemos tener nuestra ventana de configuracion mas o menos asi.
Apretamos "Run" para ejecutar lo que previamente configuramos, si todo sale bien nos debe salir un mensaje mas o menos asi.
Si todo sale bien lo que lograremos es que maven descargue todas las librerias que hicimos referencia desde nuestro archivo pom.xml, la evidencia la tendremos entrando al build path de java en la seccion de librerias. Esto lo podemos hacer dando click derecho sobre nuestro proyecto ir a "Properties" y en el panel izquierdo hacer click sobre "Java Build Path". En esta pagina ir a la pestaña de "Libraries" y expandir la libreria compartida "Maven dependencies".
Configuracion y ejecucion en Tomcat 6.
En este punto podemos ejecutar nuestra aplicacion por primera vez, simplemente le damos click derecho a nuestro proyecto y vamos a "Run As -> Run on Server"
Luego seleccionamos como servidor Tomcat 6 y apretamos "Next".
Si no tenemos un runtime de Tomcat 6 instalado con anterioridad lo tendremos que instalar a continuacion. Lo primero que debemos hacer es seleccionar nuestra distribucion de apache tomcat y dar "Next" como se muestra en la siguiente imagen.
En la siguiente pantalla nos preguntara que proyectos dentro de nuestro workspace deseamos desplegar, en nuestro caso seleccionamos MGTest y apretamos en "Add", por ultimo apretamos "Finish"
Si todo quedo bien configurado, nuestra aplicación se ejecutara y se mostrara la pagina de bienvenida por defecto.
Configuracion Spring MVC
Ahora lo siguiente que debemos hacer, es configurar nuestro proyecto para utilizar el modelo vista controlador con spring. Lo primero que debemos hacer es es crear un archivo de configuración xml. Este archivo sera interpretado por el contenedor java cada vez que subamos nuestra aplicación.
NOTA: La configuracion de Spring puede estar en uno o varios archivos xml.
Llamaremos a este archivo xml "applicationContext-servlet.xml" y lo pondremos dentro de la carpeta src/main/webapp/WEB-INF
El contenido de este archivo es el siguiente
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<context:component-scan base-package="com.tecnoratones.mgtest.controllers" />
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/views/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans>
Cuando nuestra aplicación sea ejecutada, se leera este archivo de configuracion y toda peticion que se haga a nuestro sitio web sera procesada por un controlador y renderizado a la vista que nosotros le indiquemos.Lo siguiente que debemos hacer es indicarle a nuestra aplicacion que lo primero que ejecute sea el archivo xml, esto lo haremos añadiendo al archivo web.xml el siguiente contenido.
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID"
version="2.5">
<display-name>Archetype Created Web Application</display-name>
<!-- Spring MVC -->
<servlet>
<servlet-name>applicationContext</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>applicationContext</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/applicationContext-servlet.xml
</param-value>
</context-param>
</web-app>
El contenido de este archivo le indica a nuestra aplicacion que toda peticion a la url "/" sera atendida por el servlet "org.springframework.web.servlet.DispatcherServlet".
<!-- Spring MVC -->
<servlet>
<servlet-name>applicationContext</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>applicationContext</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
Cuando este servlet procese las peticiones correspondientes lo que hara es cargar los archivos xml que le indicamos en el siguiente codigo.
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/applicationContext-servlet.xml
</param-value>
</context-param>
El servlet parseara los archivos xml y cargara todas las configuraciones que en este le indiquemos.
Luego debemos crear nuestro controlador, que es quien recibira nuestras peticiones a traves de una url predefinida. Para esto debemos acceder ir a "Java Resources -> src/main/java" crear un paquete que en nuestro caso seria "com.tecnoratones.mgtest.controllers". Dentro de este paquete crearemos una clase java standard.
Definimos el nombre de nuestra clase, en nuestro caso se llamara "MGTestController", luego apretamos "Finish"
Hasta este momento solo hemos creado una clase java standard. Ahora debemos adaptarla para que actue como nuestro controlador de ejemplo. Basicamente tendriamos que indicarle a la clase que es un controlador a traves de la anotacion
@Controller, e indicarle a cada metodo que procese una url unica a traves de la anotacion
@RequestMapping. El codigo de nuestra clase quedaria asi.
package com.tecnoratones.mgtest.controllers;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.tecnoratones.mgtest.model.Usuarios;
import com.tecnoratones.mgtest.service.UsuarioService;
@Controller
public class MGTestController {
@RequestMapping("/test")
public ModelAndView test(HttpServletRequest request, HttpServletResponse response) {
return new ModelAndView("test","mensaje","Mensaje para mostrar en la vista");
}
}
En la linea 17 le indicamos a nuestra aplicacion que el metodo test sera el encargado de procesar las peticiones que entren por la url
"/test". Y en la linea 19 indicamos a nuestro controlador que las respuestas las renderize a la vista "test" y envie el mensaje "Mensaje para mostrar en la vista" dentro de la variable "mensaje".
Ahora lo unico que nos falta es crear la vista "test" para que el controlador renderize la respuesta en el. Para esto debemos crear una carpeta
"views" dentro del WEB-INF donde procederemos a crear nuestra vista como se muestra a continuación.
Luego el wizard de creacion de JSPs nos pide el nombre de la vista y por ultimo apretamos "Finish".
Una vez creada nuestra vista, reemplazamos el codigo con el que fue creado nuestro jsp con
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Vista Test</title>
</head>
<body>
<h1>Mensaje: ${mensaje}</h1>
</body>
En la linea 10 es donde renderizamos el mensaje que enviamos desde el controlador, utilizando los caracteres ${}
En este punto solo seria ejecutar nuestra aplicacion como lo indicamos anteriormente. y accedemos a la url http://localhost:8080/MGTest/test y el resultado sera el siguiente.
Ya tenemos lista la configuracion de nuestra proyecto con Spring MVC. Ahora solo falta entrar en materia con la base de datos.
Configuracion y ejecucion del MyBatis Plugin en Eclipse
El plugin de mybatis generator se sirve de un archivo de configuracion xml en el que podemos configurar como vamos a generar nuestros Modelos y DAOs a partir de objetos desde la base de datos. Para esto debemos crear el archivo "mybatis-generator.xml" en la raiz de nuestra aplicacion.
Dentro de este archivo pondremos el siguiente codigo.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!-- Ubicación del JAR JDBC del gestor de Base de datos a usar, en este caso MySQL -->
<classPathEntry location="C:\Users\mioriente33\.m2\repository\mysql\mysql-connector-java\5.1.26\mysql-connector-java-5.1.26.jar" />
<!-- Generaremos para MyBatis versión 3 -->
<context id="Test" targetRuntime="MyBatis3">
<!-- No generamos los comentarios -->
<commentGenerator>
<property name="suppressAllComments" value="true"/>
</commentGenerator>
<!-- Parámetros de conexión a la bd -->
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/Test"
userId="root"
password="root">
</jdbcConnection>
<javaModelGenerator targetPackage="com.tecnoratones.mgtest.model" targetProject="MGTest">
<property name="enableSubPackages" value="true" />
</javaModelGenerator>
<sqlMapGenerator targetPackage="com.tecnoratones.mgtest.dao" targetProject="MGTest">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- También podríamos indicar el tipo ANNOTATEDMAPPER -->
<javaClientGenerator type="XMLMAPPER" targetPackage="com.tecnoratones.mgtest.dao" targetProject="MGTest">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<table schema="test" tableName="Usuarios" domainObjectName="Usuarios" >
<property name="useActualColumnNames" value="true"/>
<generatedKey column="ID" sqlStatement="SELECT LAST_INSERT_ID()" identity="true" />
</table>
</context>
</generatorConfiguration>
Como dijimos anteriormente en este xml configuramos lo que deseamos que haga el plugin de mybatis generator. Como por ejemplo en que paquetes va a crear los DAOs y los models, sobre que base de datos va a generar el codigo, que tablas de la base de datos seran generadas por nuestra aplicacion.etc.
En la linea 8, podemos ver que se hace referencia al jar del driver de la base de datos mysql. Debemos hacer esto ya que el plugin se conectara con la base de datos y necesitaremos el driver para poder hacer esto.
<classPathEntry location="C:\Users\mioriente33\.m2\repository\mysql\mysql-connector-java\5.1.26\mysql-connector-java-5.1.26.jar" />
Luego de la linea 19 a la 23 definimos el DataSource(Conexion con la base de datos) que utilizara el mybatis generator para conectarse con la base de datos.
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/Test"
userId="root"
password="root">
</jdbcConnection>
Desde la linea 26 a la 38 le decimos al plugin en que paquetes generar los modelos y los DAOs(XMLMappers) .
<javaModelGenerator targetPackage="com.tecnoratones.mgtest.model" targetProject="MGTest">
<property name="enableSubPackages" value="true" />
</javaModelGenerator>
<sqlMapGenerator targetPackage="com.tecnoratones.mgtest.dao" targetProject="MGTest">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- También podríamos indicar el tipo ANNOTATEDMAPPER -->
<javaClientGenerator type="XMLMAPPER" targetPackage="com.tecnoratones.mgtest.dao" targetProject="MGTest">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
Por ultimo de la linea 40 en adelante le indicamos a el plugin que tablas de la base de datos debe generar, ademas dentro de cada
indicamos como se deben generar las claves primarias. Esto es importante ya que dependiendo del proveedor de la base de datos varia un poco.
<table schema="test" tableName="Usuarios" domainObjectName="Usuarios" >
<property name="useActualColumnNames" value="true"/>
<generatedKey column="ID" sqlStatement="SELECT LAST_INSERT_ID()" identity="true" />
</table>
Una vez tengamos listo nuestro xml listo, debemos ejecutar el plugin y este generara sobre los paquetes que indicamos anteriormente todo el codigo necesario para insertar, actualizar, borrar y buscar datos en las tablas que tenemos mapeadas en nuestra aplicacion. Para ejecutar el plugin debemos hacer click derecho sobre el archivo xml, y seleccionar "Generate MyBatis/iBATIS Artifacts".
Si todo salio bien el plugin nos debio generar dentro de los paquetes "com.tecnoratones.mgtest.dao" y "com.tecnoratones.mgtest.model" las clases correspondientes a la tabla "Usuarios".
Mas adelante explicaremos que fue lo que genero exactamente el plugin. En este punto estamos listos para usar nuestras clases de bases de datos en nuestra aplicacion, pero antes debemos configurar spring para que pueda usar mybatis.
Configuracion MyBatis Spring
Para hacer que nuestra aplicacion se conecte automaticamente a la base de datos, lo unico que debemos hacer es añadir el archivo "applicationContext-dao.xml" a nuestro WEB-INF como lo hicimos con el "applicationContext-servlet.xml". Despues de crear el xml debemos añadirle el siguiente codigo.
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<!-- in-memory database and a datasource -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/Test"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- transaction manager, use JtaTransactionManager for global tx -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<!-- enable component scanning (beware that this does not enable mapper scanning!) -->
<context:component-scan base-package="com.tecnoratones.mgtest.service" />
<!-- enable autowire -->
<context:annotation-config />
<!-- enable transaction demarcation with annotations -->
<tx:annotation-driven />
<!-- define the SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="typeAliasesPackage" value="com.tecnoratones.mgtest.model" />
</bean>
<!-- scan for mappers and let them be autowired -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.tecnoratones.mgtest.dao" />
</bean>
</beans>
De la linea 15 a la 20 configuramos un datasource usando la api dbcp de apache. En aplicaciones empresariales normalmente se utilizan datasource alojados en el Application Server. En nuestro caso lo definiremos localmente.
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/Test"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
En la linea 29 le indicamos a spring que todos los paquetes que se encuentren en el paquete "com.tecnoratones.mgtest.service" que seran servicios que podran ser accedidos desde nuestras clases y en los cuales podremos inyectar nuestros DAOs.
<context:component-scan base-package="com.tecnoratones.mgtest.service" />
De la linea 33 a la 37 indicamos que los mappers y las transacciones tienen habilitados la inyeccion a traves de la anotacion Autowired.
<!-- enable autowire -->
<context:annotation-config />
<!-- enable transaction demarcation with annotations -->
<tx:annotation-driven />
Luego configuramos el sqlSessionFactory, que es el gestor de conexion de mybatis con la base de datos.
<!-- define the SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="typeAliasesPackage" value="com.tecnoratones.mgtest.model" />
</bean>
Y por ultimo de la linea 48 a 50 le indicamos a nuestra aplicacion donde estan nuestros DAO's (Mappers).
<!-- scan for mappers and let them be autowired -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.tecnoratones.mgtest.dao" />
</bean>
Despues de configurar spring para el uso de la base de datos debemos añadir a nuestro web.xml la referencia de este archivo.
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/applicationContext-servlet.xml
/WEB-INF/applicationContext-dao.xml
</param-value>
</context-param>
Ya tenemos todo configurado para poder usar las clases generadas por el plugin. Ahora lo unico que nos falta es utilizarlas a traves de nuestro controlador. Segun los estandares de java, siempre debemos construir un service que es el que contendra toda la logica de negocios de nuestra aplicacion y sera el encargado de llamara nuestros DAO's. Siguiendo este patron crearemos un paquete llamado "com.tecnoratones.mgtest.service" y en el crearemos una interfaz llamada "UsuarioService" que contendra los metodos de este servicio, la idea es implementar esta interfaz en la clase "UsuarioServiceImpl" y ahi llamar al DAO, o a los DAOs necesarios.
En la interfaz service debemos añadir el siguiente codigo.
package com.tecnoratones.mgtest.service;
import com.tecnoratones.mgtest.model.Usuarios;
public interface UsuarioService {
public void crearUsuario(Usuarios usuario) throws Exception;
}
Cuando la interfaz este lista debemos implementarla en nuestra clase "UsuarioServiceImpl"
package com.tecnoratones.mgtest.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.tecnoratones.mgtest.dao.UsuariosMapper;
import com.tecnoratones.mgtest.model.Usuarios;
@Service
public class UsuarioServiceImpl implements UsuarioService{
@Autowired
private UsuariosMapper usuarioMapper;
@Transactional
public void crearUsuario(Usuarios usuario) throws Exception {
usuarioMapper.insert(usuario);
}
}
En esta clase implementamos la funcion crearUsuario de la interfaz "UsuarioService", y ademas de esto inyectamos mediante la etiqueta @Autowired el Mapper o DAO que vamos a utilizar. Noten que encima del metodo crearUsuario tenemos la anotacion @Transactional, esto hara que nuestra funcion sea una transaccion.
Adentro de nuestra funcion, simplemente recibimos un modelo Usuario y mediante el metodo insert del mapper lo guardamos en nuestra base de datos. Noten ademas que encima de la declaracion de clase UsuarioServiceImpl tenemos la anotacion @Service, que indica a spring que esta clase es un servicio y que puede ser inyectado en un controlador mediante el la anotacion @Autowired
Apenas tengamos todo esto listo debemos inyectar este servicio en el controlador para poder guardar en la base de datos a partir de una llamada a un controlador. Entonces vamos a MGTestController y lo dejamos asi.
package com.tecnoratones.mgtest.controllers;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.tecnoratones.mgtest.model.Usuarios;
import com.tecnoratones.mgtest.service.UsuarioService;
@Controller
public class MGTestController {
@Autowired
private UsuarioService usuarioService;
@RequestMapping("/test")
public ModelAndView test(HttpServletRequest request, HttpServletResponse response) {
Usuarios usuario = new Usuarios();
usuario.setApellido("Ratones");
usuario.setEmail("rats@mail.com");
usuario.setNombre("Rat");
try {
usuarioService.crearUsuario(usuario);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return new ModelAndView("test","mensaje","Se guardo el nuevo registro");
}
}
En la linea 17 y 18 podemos ver como inyectan el servicio.
@Autowired
private UsuarioService usuarioService;
Ahora a partir de la linea 22 a la 31 llenamos el model de usuario y lo enviamos como parametro al servicio usuarioService, para que este lo guarde en la base de datos.
Usuarios usuario = new Usuarios();
usuario.setApellido("Ratones");
usuario.setEmail("rats@mail.com");
usuario.setNombre("Rat");
try {
usuarioService.crearUsuario(usuario);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Y por ultimo renderizamos la vista con un mensaje nuevo indicando que guardamos con exito el nuevo registro.
return new ModelAndView("test","mensaje","Se guardo el nuevo registro");
Una vez tengamos lista la codificacion solo volvemos a ejecutar nuestra aplicacion y accedemos a la url "http://localhost:8080/MGTest/test", al hacer esto la aplicacion nos debe mostrar la siguiente pantalla.
Verificamos nuestra tabla y en efecto el registro deberia quedar ingresado.
Bueno esto seria todo amigos. Les adjunto el codigo de ejemplo de la aplicacion para que la puedan descargar directamente desde el siguiente enlace
Codigo fuente MGTest.
En un proximo tutorial explicare mas afondo como funcionan las clases generadas con mybatis generator.
Saludos.
