Selon le communiqué officiel, les travaux de développement de Spring3 ont été terminés avant l'avènement d'ibatis3, c'est-à-dire Mybatis3, il n'y a donc toujours pas de support pour Mybatis3 dans Spring3. Par conséquent, la communauté Mybatis a elle-même développé Mybatis-Spring pour répondre aux besoins des utilisateurs de Mybatis d'intégrer Spring. Ce qui suit donnera une brève introduction à l'utilisation de l'intégration de Mybatis et Spring via Mybatis-Spring.
MapperFactoryBean
Tout d'abord, nous devons télécharger le package jar Mybatis-Spring depuis le site officiel de Mybatis et l'ajouter au chemin de classe de notre projet. Bien sûr, nous devons également ajouter le package jar associé de Mybatis et le package jar associé de Spring. Nous savons que toutes les opérations dans Mybatis sont basées sur une SqlSession, que SqlSession est générée par SqlSessionFactory et que SqlSessionFactory est générée par SqlSessionFactoryBuilder. Mais Mybatis-Spring est basé sur SqlSessionFactoryBean. Lorsque nous utilisons Mybatis-Spring, nous avons également besoin de SqlSession, et cette SqlSession est intégrée au programme et ne nous oblige généralement pas à y accéder directement. SqlSession est également généré par SqlSessionFactory, mais Mybatis-Spring encapsule un SqlSessionFactoryBean pour nous. Dans ce bean, nous utilisons toujours SqlSessionFactoryBuilder pour établir le SqlSessionFactory correspondant, puis obtenons le SqlSession correspondant. Grâce à SqlSessionFactoryBean, nous pouvons fournir des informations de configuration de Mybatis en spécifiant certaines propriétés. Nous devons donc ensuite définir un SqlSessionFactoryBean dans le fichier de configuration applicationContext de Spring.
Code 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>
Lors de la définition de SqlSessionFactoryBean, l'attribut dataSource doit être spécifié, qui représente la source de données utilisée pour se connecter à la base de données. Bien entendu, nous pouvons également spécifier d’autres attributs. En voici quelques-uns :
mapperLocations : Il indique l'emplacement où est stocké notre fichier Mapper. Lorsque notre fichier Mapper se trouve au même emplacement que l'interface Mapper correspondante, il n'est pas nécessaire de spécifier la valeur de cet attribut.
configLocation : utilisé pour spécifier l'emplacement du fichier de configuration de Mybatis. Si cet attribut est spécifié, le SqlSessionFactoryBuilder correspondant sera construit en utilisant le contenu du fichier de configuration comme informations de configuration, mais le contenu spécifié par les attributs suivants écrasera le contenu correspondant spécifié dans le fichier de configuration.
typeAliasesPackage : Il correspond généralement au package où se trouve notre classe d'entité. À ce stade, le nom de classe simple dans le package correspondant qui n'inclut pas le nom du package sera automatiquement pris comme alias incluant le nom du package. Plusieurs packages peuvent être séparés par des virgules ou des points-virgules.
typeAliases : type de tableau, utilisé pour spécifier des alias. Après avoir spécifié cet attribut, Mybatis utilisera le nom court de ce type comme alias de ce type, à condition que l'annotation @Alias ne soit pas marquée sur la classe, sinon la valeur correspondant à l'annotation sera utilisée comme alias de ce genre.
Code XML
<property name="typeAliases"> <array> <value>com.tiantian.mybatis.model.Blog</value> <value>com.tiantian.mybatis.model.Comment</value> </array> </property >
plugins : type array, utilisé pour spécifier l'Interceptor de Mybatis.
typeHandlersPackage : utilisé pour spécifier le package où se trouve le TypeHandler. Si cet attribut est spécifié, SqlSessionFactoryBean enregistrera automatiquement les classes sous le package en tant que TypeHandler correspondant. Plusieurs packages peuvent être séparés par des virgules ou des points-virgules.
typeHandlers : type de tableau, représentant TypeHandler.
L'étape suivante consiste à définir le MapperFactoryBean correspondant à l'objet Mapper que nous voulons dans le fichier applicationContext de Spring. L'objet Mapper que nous voulons peut être obtenu via MapperFactoryBean. MapperFactoryBean implémente l'interface FactoryBean de Spring, donc MapperFactoryBean obtient l'objet Mapper correspondant via la méthode getObject définie dans l'interface FactoryBean. Lors de la définition d'un MapperFactoryBean, nous devons injecter deux propriétés. L'une est la sqlSessionFactory utilisée par Mybatis-Spring pour générer des objets SqlSessionTemplate qui implémentent l'interface SqlSession ;
Après avoir défini le MapperFactoryBean correspondant à l'interface Mapper correspondante, nous pouvons injecter notre interface Mapper correspondante dans l'objet bean géré par Spring, comme l'objet bean Service. De cette façon, lorsque nous aurons besoin d'utiliser l'interface Mapper correspondante, MapperFactoryBean obtiendra l'interface Mapper correspondante à partir de sa méthode getObject, et en interne getObject appelle toujours la méthode getMapper (interface Mapper) de l'interface SqlSession via les propriétés que nous avons injectées pour renvoyer le Interface du mappeur correspondante. De cette manière, l'intégration de Mybatis et Spring est réalisée en confiant SqlSessionFactory et l'interface Mapper correspondante à la gestion Spring.
Fichier de configuration applicationContext.xml de Spring :
Code XML
<?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: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 location="classpath:config/jdbc.properties"/> <bean id="dataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driver}" /> <nom de la propriété ="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" 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" /> </ haricot> haricots> </beans> Fichier BlogMapper.xml :
Code XML
<?xml version="1.0" encoding="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"> <!-- Ajouter un nouvel enregistrement--> <insérer id="insertBlog" ParameterType="Blog" useGeneratedKeys="true" keyProperty="id"> insérer dans les valeurs de t_blog(title,content,owner) (#{title},#{content},#{owner}) </ insert> <!-- Interroger un seul enregistrement--> <select id="selectBlog" ParameterType="int" resultMap="BlogResult"> select * from t_blog où id = #{id} </select> <!-- Modifier l'enregistrement--> <update id="updateBlog" ParameterType="Blog"> update t_blog set title = #{title},content = #{content},owner = #{owner} où id = #{id} </update> <!-- Interroger tous les enregistrements--> <select id="selectAll" resultType="Blog"> select * from t_blog </select> <!-- Supprimer les enregistrements--> <delete id="deleteBlog" ParameterType="int"> supprimer de t_blog où id = #{id} </delete> </mapper> BlogMapper.java :
Code Java
package com.tiantian.mybatis.mapper ; importer java.util.List ; importer com.tiantian.mybatis.model.Blog ; publicinterface BlogMapper { public Blog selectBlog(int id); ); publicvoid deleteBlog(int id); public List<Blog> selectAll( ); BlogServiceImpl.java :
Code Java
package com.tiantian.mybatis.service.impl ; importer java.util.List ; importer javax.annotation.Resource ; importer org.springframework.stereotype.Service ; importer com.tiantian.mybatis.mapper.BlogMapper ; mybatis.model.Blog; importer com.tiantian.mybatis.service.BlogService; @Service publicclass BlogServiceImpl implémente BlogService {privé BlogMapper blogMapper; publicvoid deleteBlog(int id) { blogMapper.deleteBlog(id); } public Blog find(int id) { returnblogMapper.selectBlog(id); } public List<Blog> find() { returnblogMapper.selectAll( ); publicvoid insertBlog(Blog blog) { blogMapper.insertBlog(blog); } publicvoid updateBlog(Blog blog) { blogMapper.updateBlog(blog); } public BlogMapper getBlogMapper() { returnblogMapper; } @Resource publicvoid setBlogMapper(BlogMapper blogMapper) { this.blogMapper = blogMapper;MapperScannerConfigurateur
Lorsque nous utilisons la méthode d'intégration ci-dessus, si nous avons un Mapper, nous devons définir un MapperFactoryBean correspondant. Lorsque nous avons relativement peu de Mappers, ce n'est pas grave, mais lorsque nous avons beaucoup de Mappers, nous définissons chaque Mapper comme ceci. MapperFactoryBean correspondant semble être plus lent. Pour cela, Mybatis-Spring nous fournit une classe appelée MapperScannerConfigurer. Grâce à cette classe, Mybatis-Spring enregistrera automatiquement pour nous l'objet MapperFactoryBean correspondant à Mapper.
Si nous devons utiliser MapperScannerConfigurer pour nous aider à analyser et enregistrer automatiquement l'interface Mapper, nous devons définir un bean correspondant à MapperScannerConfigurer dans le fichier de configuration applicationContext de Spring. Pour MapperScannerConfigurer, il y a un attribut que nous devons spécifier, et c'est basePackage. basePackage est utilisé pour spécifier le package de base où se trouve le fichier d'interface Mapper. Les interfaces Mapper sous ce package de base ou tous ses sous-packages seront recherchées. Plusieurs packages de base peuvent être séparés par des virgules ou des points-virgules. La définition la plus simple de MapperScannerConfigurer consiste à spécifier un seul attribut basePackage, tel que :
Code XML
<bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> </bean>
De cette façon, MapperScannerConfigurer analysera toutes les interfaces sous le package de base spécifié et les enregistrera en tant qu'objets MapperFactoryBean. Lorsque vous utilisez MapperScannerConfigurer et ajoutez l'attribut basePackage, le fichier de configuration applicationContext dans notre exemple ci-dessus ressemblera à ceci :
Code XML
<?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: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 location="classpath:config/jdbc.properties" /> <bean id="dataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driver}" /> <nom de la propriété ="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" 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>Parfois, le package de base que nous spécifions ne correspond pas à toutes les interfaces Mapper que nous avons définies. Pour cette raison, MapperScannerConfigurer nous fournit également deux autres attributs qui peuvent restreindre la portée de la recherche et de l'enregistrement. L’un est annotationClass et l’autre est MarkerInterface.
annotationClass : lorsque annotationClass est spécifié, MapperScannerConfigurer enregistrera uniquement les interfaces marquées avec l'annotation annotationClass.
MarkerInterface : MarkerInterface est utilisé pour spécifier une interface. Lorsque MarkerInterface est spécifié, MapperScannerConfigurer enregistrera uniquement l'interface héritée de MarkerInterface.
Si les deux propriétés ci-dessus sont spécifiées, MapperScannerConfigurer prendra leur union au lieu de leur intersection. Même si annotationClass est utilisé pour le marquage ou si l'interface héritée de MarkerInterface sera enregistrée en tant que MapperFactoryBean.
En supposant maintenant que notre interface Mapper hérite d'une interface SuperMapper, nous pouvons alors définir notre MapperScannerConfigurer comme ceci.
Code XML
<bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> <property name="markerInterface" value="com.tiantian.mybatis.mapper.SuperMapper"/> </bean>
Si la balise d'annotation MybatisMapper est utilisée, alors nous pouvons définir notre MapperScannerConfigurer comme ceci.
Code XML
<bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> <property name="annotationClass" value="com.tiantian.mybatis.annotation.MybatisMapper"/> </bean>
En plus des propriétés utilisées pour restreindre la portée de l'interface Mapper enregistrée, nous pouvons également spécifier d'autres propriétés, telles que :
sqlSessionFactory : cette propriété est obsolète. Lorsque nous utilisons plusieurs sources de données, nous devons utiliser sqlSessionFactory pour spécifier la SqlSessionFactory qui doit être utilisée lors de l'enregistrement de MapperFactoryBean, car lorsque sqlSessionFactory n'est pas spécifié, une sera automatiquement injectée de manière Autowired. En d'autres termes, lorsque nous n'utilisons qu'une seule source de données, c'est-à-dire lorsque nous définissons une seule SqlSessionFactory, nous n'avons pas besoin de spécifier SqlSessionFactory pour MapperScannerConfigurer.
sqlSessionFactoryBeanName : Sa fonction est la même que sqlSessionFactory, sauf qu'il spécifie le nom du bean correspondant au SqlSessionFactory défini.
sqlSessionTemplate : cet attribut est obsolète. Sa fonction est également équivalente à sqlSessionFactory, car comme mentionné précédemment, MapperFactoryBean utilise finalement la méthode getMapper de SqlSession pour obtenir l'objet Mapper correspondant. Il ne doit être spécifié que lorsque plusieurs SqlSessionTemplates sont définis. Pour un MapperFactoryBean, un seul parmi SqlSessionFactory et SqlSessionTemplate est requis. Lorsque les deux sont spécifiés, SqlSessionFactory sera ignoré.
sqlSessionTemplateBeanName : Spécifiez le nom du bean correspondant au sqlSessionTemplate à utiliser.
Remarque : étant donné que l'utilisation des attributs sqlSessionFactory et sqlSessionTemplate entraînera le chargement d'une partie du contenu avant PropertyPlaceholderConfigurer, les informations de propriété externes utilisées dans le fichier de configuration ne pourront pas être remplacées à temps et des erreurs se produiront. Les propriétés sqlSessionFactory et sqlSessionTemplate ont été abandonnées dans Mybatis-Spring. Il est recommandé d'utiliser la propriété sqlSessionFactoryBeanName et la propriété sqlSessionTemplateBeanName.
Code XML
<?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: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 location= "classpath:config/jdbc.properties" /> <bean id="dataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driver}" /> <property name="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" 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" /> <property name="markerInterface" value="com.tiantian.mybatis.mapper.SuperMapper"/> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> </bean> </beans>Modèle de session SQL
En plus d'utiliser l'interface Mapper directement après l'intégration ci-dessus, Mybatis-Spring nous fournit également un moyen d'utiliser directement SqlSession. Mybatis-Spring nous fournit une classe SqlSessionTemplate qui implémente l'interface SqlSession. Elle est thread-safe et peut être utilisée par plusieurs Dao en même temps. Dans le même temps, il est également associé à la transaction de Spring pour garantir que la SqlSession actuellement utilisée est celle qui a été liée à la transaction de Spring. Et il peut également gérer lui-même la soumission et la clôture de la session. Lorsque le mécanisme de gestion des transactions de Spring est utilisé, SqlSession peut également être soumis et annulé avec les transactions de Spring.
Lorsque nous utilisons SqlSessionTemplate, nous pouvons le définir dans le fichier de configuration applicationContext de Spring comme suit :
<bean id="sqlSession"> <constructor-arg index="0" ref="sqlSessionFactory" /> </bean>
De cette façon, nous pouvons utiliser directement SqlSessionTemplate pour programmer en Dao via l'injection de dépendances de Spring. À ce stade, notre Dao peut ressembler à ceci :
Code Java
package com.tiantian.mybatis.dao ; importer java.util.List ; importer javax.annotation.Resource ; importer org.mybatis.spring.SqlSessionTemplate ; importer org.springframework.stereotype.Repository ; Blog ; @Repository publicclass BlogDaoImpl implémente 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", id); } public List<Blog> find() { returnthis.sqlSessionTemplate.selectList("com.tiantian.mybatis.mapper.BlogMapper.selectAll"); } publicvoid insertBlog(Blog 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; Note:
Cet article est écrit sur la base de Mybatis3.2.1, Mybatis-Spring1.1.0 et Spring3.1.
Ce qui précède est une brève analyse du processus de mise en œuvre de l'intégration de mybatis et spring présenté dans cet article. J'espère que vous l'aimerez. Le prochain article vous présentera la méthode d'intégration de spring et mybatis.