Según el comunicado oficial, el trabajo de desarrollo de Spring3 se completó antes de la llegada de ibatis3, es decir, Mybatis3, por lo que todavía no hay soporte para Mybatis3 en Spring3. Por lo tanto, la comunidad Mybatis desarrolló Mybatis-Spring para satisfacer las necesidades de los usuarios de Mybatis de integrar Spring. A continuación se dará una breve introducción al uso de la integración de Mybatis y Spring a través de Mybatis-Spring.
MapperFactoryBean
Primero, debemos descargar el paquete jar Mybatis-Spring del sitio web oficial de Mybatis y agregarlo a la ruta de clase de nuestro proyecto. Por supuesto, también necesitamos agregar el paquete jar relacionado de Mybatis y el paquete jar relacionado de Spring. Sabemos que todas las operaciones en Mybatis se basan en SqlSession, y SqlSession es generado por SqlSessionFactory y SqlSessionFactory es generado por SqlSessionFactoryBuilder. Pero Mybatis-Spring se basa en SqlSessionFactoryBean. Cuando usamos Mybatis-Spring, también necesitamos SqlSession, y este SqlSession está integrado en el programa y generalmente no requiere que accedamos a él directamente. SqlSession también es generado por SqlSessionFactory, pero Mybatis-Spring encapsula un SqlSessionFactoryBean para nosotros. En este bean, todavía usamos SqlSessionFactoryBuilder para establecer el SqlSessionFactory correspondiente y luego obtener el SqlSession correspondiente. A través de SqlSessionFactoryBean podemos proporcionar información de configuración de Mybatis especificando algunas propiedades en él. Entonces, a continuación necesitamos definir un SqlSessionFactoryBean en el archivo de configuración applicationContext de Spring.
código xml
<bean id="sqlSessionFactory"> <property name="dataSource" ref="dataSource" /> <property name="mapperLocations" value="classpath:com/tiantian/ckeditor/mybatis/mappers/*Mapper.xml" / > <property name="typeAliasesPackage" value="com.tiantian.ckeditor.model" /> </bean>
Al definir SqlSessionFactoryBean, se debe especificar el atributo dataSource, que representa la fuente de datos utilizada para conectarse a la base de datos. Por supuesto, también podemos especificar algunos otros atributos. Aquí hay algunos:
mapperLocations: Indica la ubicación donde está almacenado nuestro archivo Mapper. Cuando nuestro archivo Mapper está en la misma ubicación que la interfaz Mapper correspondiente, no es necesario especificar el valor de este atributo.
configLocation: se utiliza para especificar la ubicación del archivo de configuración de Mybatis. Si se especifica este atributo, el SqlSessionFactoryBuilder correspondiente se construirá utilizando el contenido del archivo de configuración como información de configuración, pero el contenido especificado por los atributos posteriores sobrescribirá el contenido correspondiente especificado en el archivo de configuración.
typeAliasesPackage: generalmente corresponde al paquete donde se encuentra nuestra clase de entidad. En este momento, el nombre de clase simple en el paquete correspondiente que no incluye el nombre del paquete se tomará automáticamente como el alias que incluye el nombre del paquete. Se pueden separar varios paquetes mediante comas o punto y coma.
typeAliases: tipo de matriz, utilizado para especificar alias. Después de especificar este atributo, Mybatis usará el nombre corto de este tipo como alias de este tipo, siempre que la anotación @Alias no esté marcada en la clase; de lo contrario, el valor correspondiente a la anotación se usará como alias de este tipo.
código xml
<property name="typeAliases"> <array> <value>com.tiantian.mybatis.model.Blog</value> <value>com.tiantian.mybatis.model.Comment</value> </array> </property >
complementos: tipo de matriz, utilizado para especificar el interceptor de Mybatis.
typeHandlersPackage: se utiliza para especificar el paquete donde se encuentra TypeHandler. Si se especifica este atributo, SqlSessionFactoryBean registrará automáticamente las clases en el paquete como el TypeHandler correspondiente. Se pueden separar varios paquetes mediante comas o punto y coma.
typeHandlers: tipo de matriz, que representa TypeHandler.
El siguiente paso es definir el MapperFactoryBean correspondiente al objeto Mapper que queremos en el archivo applicationContext de Spring. El objeto Mapper que queremos se puede obtener a través de MapperFactoryBean. MapperFactoryBean implementa la interfaz FactoryBean de Spring, por lo que MapperFactoryBean obtiene el objeto Mapper correspondiente a través del método getObject definido en la interfaz FactoryBean. Al definir un MapperFactoryBean, hay dos propiedades que debemos inyectar. Una es sqlSessionFactory utilizada por Mybatis-Spring para generar objetos SqlSessionTemplate que implementan la interfaz SqlSession y la otra es la interfaz Mapper correspondiente que queremos devolver.
Después de definir el MapperFactoryBean correspondiente a la interfaz Mapper correspondiente, podemos inyectar nuestra interfaz Mapper correspondiente en el objeto bean administrado por Spring, como el objeto Service bean. De esta manera, cuando necesitemos usar la interfaz Mapper correspondiente, MapperFactoryBean obtendrá la interfaz Mapper correspondiente de su método getObject, e internamente getObject seguirá llamando al método getMapper (interfaz Mapper) de la interfaz SqlSession a través de las propiedades que inyectamos para devolver. la interfaz del asignador correspondiente. De esta manera, la integración de Mybatis y Spring se logra entregando SqlSessionFactory y la interfaz Mapper correspondiente a la administración de Spring.
Archivo de configuración applicationContext.xml de Spring:
código xml
<?xml versión="1.0" codificación="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:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans /spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring- mvc-3.0.xsd"> <context:component-scan base-package="com.tiantian.mybatis"/> <context:property-placeholder ubicación="classpath:config/jdbc.properties"/> <bean id="dataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driver}" /> <nombre de propiedad ="url" valor="${jdbc.url}" /> <nombre de propiedad="nombre de usuario" valor="${jdbc.username}" /> <nombre de propiedad="contraseña" value="${jdbc.password}" /> </bean> <bean id="sqlSessionFactory"> <property name="dataSource" ref="dataSource" /> <property name="mapperLocations" value="classpath: com/tiantian/mybatis/mapper/*.xml"/> <property name="typeAliasesPackage" value="com.tiantian.mybatis.model" /> </bean> <bean id="blogMapper"> <property name="mapperInterface" value="com.tiantian.mybatis.mapper.BlogMapper" /> <property name="sqlSessionFactory" ref="sqlSessionFactory" /> </ frijol> frijol> </frijol> Archivo BlogMapper.xml:
código xml
<?xml versión="1.0" codificación="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis -3-mapper.dtd"> <mapper namespace="com.tiantian.mybatis.mapper.BlogMapper"> <!-- Agregar nuevo registro--> <insertar id="insertBlog" parámetroType="Blog" useGeneratedKeys="true" keyProperty="id"> insertar en t_blog(title,content,owner) valores(#{title},#{content},#{owner}) </ insertar> <!-- Consultar un solo registro--> <select id="selectBlog" parámetroType="int" resultMap="BlogResult"> seleccione * de t_blog donde id = #{id} </select> <!-- Modificar registro--> <update id="updateBlog" parámetroType="Blog"> actualizar t_blog set title = #{title},content = #{content},owner = #{owner} donde id = #{id} </update> <!-- Consultar todos los registros--> <select id="selectAll" resultType="Blog"> select * from t_blog </select> <!-- Eliminar registros--> <delete id="deleteBlog" parámetroType="int"> eliminar de t_blog donde id = #{id} </delete> </mapper> BlogMapper.java:
código java
paquete com.tiantian.mybatis.mapper; importar java.util.List; importar com.tiantian.mybatis.model.Blog; publicinterface BlogMapper { blog público selectBlog (int id publicvoid); ); publicvoid eliminarBlog(int id); Lista pública<Blog> selectAll(); BlogServiceImpl.java:
código java
paquete com.tiantian.mybatis.service.impl; importar java.util.List; importar javax.annotation.Resource; importar org.springframework.stereotype.Service; mybatis.model.Blog; importar com.tiantian.mybatis.service.BlogService; @Service publicclass BlogServiceImpl implementa BlogService { privado BlogMapper blogMapper; publicvoid deleteBlog(int id) { blogMapper.deleteBlog(id); public Blog find(int id) { returnblogMapper.selectBlog(id } lista pública<Blog> find() { returnblogMapper.selectAll(); publicvoid insertBlog (blog del blog) { blogMapper.insertBlog (blog) publicvoid updateBlog (blog del blog) { blogMapper.updateBlog(blog); } BlogMapper público getBlogMapper() { returnblogMapper } @Resource publicvoid setBlogMapper(BlogMapper blogMapper) { this.blogMapper = blogMapper;MapperScannerConfigurador
Cuando usamos el método anterior para la integración, si tenemos un Mapper, necesitamos definir un MapperFactoryBean correspondiente. Cuando tenemos relativamente pocos Mappers, esto está bien, pero cuando tenemos bastantes Mappers, definimos cada Mapper de esta manera. El MapperFactoryBean correspondiente parece ser más lento. Para ello, Mybatis-Spring nos proporciona una clase llamada MapperScannerConfigurer. A través de esta clase, Mybatis-Spring registrará automáticamente el objeto MapperFactoryBean correspondiente a Mapper.
Si necesitamos usar MapperScannerConfigurer para ayudarnos a escanear y registrar automáticamente la interfaz Mapper, debemos definir un bean correspondiente a MapperScannerConfigurer en el archivo de configuración applicationContext de Spring. Para MapperScannerConfigurer, hay un atributo que debemos especificar y es basePackage. basePackage se utiliza para especificar el paquete base donde se encuentra el archivo de interfaz del Mapper. Se buscarán las interfaces del Mapper en este paquete base o en todos sus subpaquetes. Se pueden separar varios paquetes base mediante comas o punto y coma. La definición más simple de MapperScannerConfigurer es especificar solo un atributo basePackage, como por ejemplo:
código xml
<bean> <nombre de propiedad="basePackage" valor="com.tiantian.mybatis.mapper" /> </bean>
De esta manera, MapperScannerConfigurer escaneará todas las interfaces bajo el paquete base especificado y las registrará como objetos MapperFactoryBean. Al usar MapperScannerConfigurer y agregar el atributo basePackage, el archivo de configuración applicationContext en nuestro ejemplo anterior quedará así:
código xml
<?xml versión="1.0" codificación="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:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans /spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring- mvc-3.0.xsd"> <context:component-scan base-package="com.tiantian.mybatis" /> <context:property-placeholder ubicación="classpath:config/jdbc.properties" /> <bean id="dataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driver}" /> <nombre de propiedad ="url" valor="${jdbc.url}" /> <nombre de propiedad="nombre de usuario" valor="${jdbc.username}" /> <nombre de propiedad="contraseña" value="${jdbc.password}" /> </bean> <bean id="sqlSessionFactory"> <property name="dataSource" ref="dataSource" /> <property name="mapperLocations" value="classpath: com/tiantian/mybatis/mapper/*.xml" /> <property name="typeAliasesPackage" value="com.tiantian.mybatis.model" /> </bean> <bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> </bean> </beans>A veces, el paquete base que especificamos no son todas las interfaces de Mapper que definimos. Por esta razón, MapperScannerConfigurer también nos proporciona otros dos atributos que pueden limitar el alcance de la búsqueda y el registro. Uno es annotationClass y el otro es MarkerInterface.
annotationClass: cuando se especifica annotationClass, MapperScannerConfigurer solo registrará las interfaces marcadas con la anotación annotationClass.
MarkerInterface: MarkerInterface se utiliza para especificar una interfaz. Cuando se especifica MarkerInterface, MapperScannerConfigurer solo registrará la interfaz heredada de MarkerInterface.
Si se especifican las dos propiedades anteriores, MapperScannerConfigurer tomará su unión en lugar de su intersección. Incluso si se usa annotationClass para marcar o la interfaz heredada de MarkerInterface se registrará como MapperFactoryBean.
Ahora, suponiendo que nuestra interfaz Mapper hereda una interfaz SuperMapper, podemos definir nuestro MapperScannerConfigurer de esta manera.
código xml
<bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> <property name="markerInterface" value="com.tiantian.mybatis.mapper.SuperMapper"/> </bean>
Si se utiliza la etiqueta de anotación MybatisMapper, entonces podemos definir nuestro MapperScannerConfigurer de esta manera.
código xml
<bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> <property name="annotationClass" value="com.tiantian.mybatis.annotation.MybatisMapper"/> </bean>
Además de las propiedades utilizadas para limitar el alcance de la interfaz Mapper registrada, también podemos especificar algunas otras propiedades, como por ejemplo:
sqlSessionFactory: esta propiedad ha quedado obsoleta. Cuando usamos múltiples fuentes de datos, necesitamos usar sqlSessionFactory para especificar el SqlSessionFactory que debe usarse al registrar MapperFactoryBean, porque cuando no se especifica sqlSessionFactory, uno se inyectará automáticamente en forma Autowired. En otras palabras, cuando solo usamos una fuente de datos, es decir, cuando solo definimos una SqlSessionFactory, no necesitamos especificar SqlSessionFactory para MapperScannerConfigurer.
sqlSessionFactoryBeanName: su función es la misma que sqlSessionFactory, excepto que especifica el nombre del bean correspondiente al SqlSessionFactory definido.
sqlSessionTemplate: este atributo ha quedado obsoleto. Su función también es equivalente a sqlSessionFactory, porque como se mencionó anteriormente, MapperFactoryBean finalmente usa el método getMapper de SqlSession para obtener el objeto Mapper correspondiente. Solo es necesario especificarlo cuando se definen varios SqlSessionTemplates. Para un MapperFactoryBean, solo se requiere uno de SqlSessionFactory y SqlSessionTemplate. Cuando se especifican ambos, se ignorará SqlSessionFactory.
sqlSessionTemplateBeanName: especifique el nombre del bean correspondiente al sqlSessionTemplate que se utilizará.
Nota: Dado que el uso de las propiedades sqlSessionFactory y sqlSessionTemplate hará que parte del contenido se cargue antes que PropertyPlaceholderConfigurer, la información de propiedades externas utilizada en el archivo de configuración no se puede reemplazar a tiempo y se producirán errores. Las propiedades sqlSessionFactory y sqlSessionTemplate se han abandonado en Mybatis-Spring. Se recomienda utilizar la propiedad sqlSessionFactoryBeanName y la propiedad sqlSessionTemplateBeanName.
código xml
<?xml versión="1.0" codificación="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:mvc="http://www.springframework.org/schema/mvc" xmlns:mybatis="http://www.mybatis.org/schema/mybatis" xsi:schemaLocation="http://www.springframework .org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.mybatis.org/schema/mybatis http:/ /www.mybatis.org/schema/mybatis/mybatis-spring.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"> <context:component-scan base-package="com.tiantian.mybatis" /> <context:property-placeholder ubicación= "classpath:config/jdbc.properties" /> <bean id="dataSource" destroy-method="close"> <property name="driverClassName" valor="${jdbc.driver}" /> <nombre de propiedad="url" valor="${jdbc.url}" /> <nombre de propiedad="nombre de usuario" valor="${jdbc.nombre de usuario}" /> <property name="contraseña" value="${jdbc.password}" /> </bean> <bean id="sqlSessionFactory"> <property name="dataSource" ref="dataSource" /> <property name="mapperLocations" value="classpath:com/tiantian/mybatis/mapper/*.xml" /> <property name="typeAliasesPackage" value="com.tiantian.mybatis.model" /> </bean> <bean> <nombre de propiedad="basePackage" valor="com.tiantian.mybatis.mapper" /> <nombre de propiedad="markerInterface" value="com.tiantian.mybatis.mapper.SuperMapper"/> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> </bean> </beans>Plantilla de sesión Sql
Además de usar la interfaz Mapper directamente después de la integración anterior, Mybatis-Spring también nos proporciona una forma de usar SqlSession directamente. Mybatis-Spring nos proporciona una clase SqlSessionTemplate que implementa la interfaz SqlSession. Es segura para subprocesos y puede ser utilizada por varios Dao al mismo tiempo. Al mismo tiempo, también está asociado con la transacción de Spring para garantizar que la SqlSession utilizada actualmente sea una que haya estado vinculada a la transacción de Spring. Y también puede gestionar el envío y cierre de la sesión por sí mismo. Cuando se utiliza el mecanismo de gestión de transacciones de Spring, SqlSession también se puede enviar y revertir junto con las transacciones de Spring.
Cuando usamos SqlSessionTemplate podemos definirlo en el archivo de configuración applicationContext de Spring de la siguiente manera:
<bean id="sqlSession"> <constructor-arg index="0" ref="sqlSessionFactory" /> </bean>
De esta manera, podemos usar SqlSessionTemplate directamente para programar en Dao mediante la inyección de dependencia de Spring. En este momento, nuestro Dao puede verse así:
código java
paquete com.tiantian.mybatis.dao; importar java.util.List; importar javax.annotation.Resource; importar org.mybatis.spring.SqlSessionTemplate; importar org.springframework.stereotype.Repository; Blog; @Repository publicclass BlogDaoImpl implementa BlogDao {private SqlSessionTemplate sqlSessionTemplate; publicvoid deleteBlog(int id) { sqlSessionTemplate.delete("com.tiantian.mybatis.mapper.BlogMapper.deleteBlog", id } public Blog find(int id) { returnsqlSessionTemplate.selectOne("com.tiantian.mybatis. mapper.BlogMapper.selectBlog", identificación); } lista pública<Blog> find() { returnthis.sqlSessionTemplate.selectList("com.tiantian.mybatis.mapper.BlogMapper.selectAll"); } publicvoid insertBlog(blog del blog) { this.sqlSessionTemplate.insert("com.tiantian. mybatis.mapper.BlogMapper.insertBlog", blog); } publicvoid updateBlog(Blog blog) { this.sqlSessionTemplate.update("com.tiantian.mybatis.mapper.BlogMapper.updateBlog", blog); public SqlSessionTemplate getSqlSessionTemplate() { returnsqlSessionTemplate } @Resource publicvoid setSqlSessionTemplate(SqlSessionTemplate; sqlSessionTemplate) { this.sqlSessionTemplate = sqlSessionTemplate; Nota:
Este artículo está escrito en base a Mybatis3.2.1, Mybatis-Spring1.1.0 y Spring3.1.
Lo anterior es un breve análisis del proceso de implementación de la integración de mybatis y spring presentado en este artículo. Espero que les guste. El próximo artículo les presentará el método de integración de spring y mybatis.