Segundo o comunicado oficial, o trabalho de desenvolvimento do Spring3 foi concluído antes do advento do ibatis3, ou seja, do Mybatis3, portanto ainda não há suporte para o Mybatis3 no Spring3. Portanto, a comunidade Mybatis desenvolveu o próprio Mybatis-Spring para atender às necessidades dos usuários Mybatis de integração do Spring. A seguir será apresentada uma breve introdução ao uso da integração do Mybatis e Spring por meio do Mybatis-Spring.
MapperFactoryBean
Primeiro, precisamos baixar o pacote jar Mybatis-Spring do site oficial do Mybatis e adicioná-lo ao caminho de classe do nosso projeto. Claro, também precisamos adicionar o pacote jar relacionado do Mybatis e o pacote jar relacionado do Spring. Sabemos que todas as operações em Mybatis são baseadas em SqlSession, e SqlSession é gerado por SqlSessionFactory e SqlSessionFactory é gerado por SqlSessionFactoryBuilder. Mas Mybatis-Spring é baseado em SqlSessionFactoryBean. Ao usar o Mybatis-Spring, também precisamos do SqlSession, e esse SqlSession está incorporado no programa e geralmente não exige que o acessemos diretamente. SqlSession também é gerado por SqlSessionFactory, mas Mybatis-Spring encapsula um SqlSessionFactoryBean para nós. Neste bean, ainda usamos SqlSessionFactoryBuilder para estabelecer o SqlSessionFactory correspondente e, em seguida, obter o SqlSession correspondente. Através do SqlSessionFactoryBean podemos fornecer algumas informações de configuração do Mybatis especificando algumas propriedades nele. Em seguida, precisamos definir um SqlSessionFactoryBean no arquivo de configuração applicationContext do 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>
Ao definir SqlSessionFactoryBean, deve-se especificar o atributo dataSource, que representa a fonte de dados utilizada para conexão ao banco de dados. Claro, também podemos especificar alguns outros atributos.
mapperLocations: Indica o local onde nosso arquivo Mapper está armazenado. Quando nosso arquivo Mapper está no mesmo local da interface Mapper correspondente, não há necessidade de especificar o valor deste atributo.
configLocation: usado para especificar a localização do arquivo de configuração do Mybatis. Se esse atributo for especificado, o SqlSessionFactoryBuilder correspondente será construído usando o conteúdo do arquivo de configuração como informações de configuração, mas o conteúdo especificado pelos atributos subsequentes substituirá o conteúdo correspondente especificado no arquivo de configuração.
typeAliasesPackage: Geralmente corresponde ao pacote onde nossa classe de entidade está localizada. Neste momento, o nome da classe simples no pacote correspondente que não inclui o nome do pacote será automaticamente considerado o alias, incluindo o nome do pacote. Vários pacotes podem ser separados por vírgulas ou ponto e vírgula.
typeAliases: tipo de array, usado para especificar aliases. Após especificar este atributo, Mybatis utilizará o nome abreviado deste tipo como alias deste tipo, desde que a anotação @Alias não esteja marcada na classe, caso contrário o valor correspondente à anotação será utilizado 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 >
plugins: tipo array, usado para especificar o Interceptor do Mybatis.
typeHandlersPackage: usado para especificar o pacote onde o TypeHandler está localizado. Se este atributo for especificado, SqlSessionFactoryBean registrará automaticamente as classes no pacote como o TypeHandler correspondente. Vários pacotes podem ser separados por vírgulas ou ponto e vírgula.
typeHandlers: tipo array, representando TypeHandler.
O próximo passo é definir o MapperFactoryBean correspondente ao objeto Mapper que desejamos no arquivo applicationContext do Spring. O objeto Mapper que desejamos pode ser obtido através do MapperFactoryBean. MapperFactoryBean implementa a interface FactoryBean do Spring, então MapperFactoryBean obtém o objeto Mapper correspondente por meio do método getObject definido na interface FactoryBean. Ao definir um MapperFactoryBean, há duas propriedades que precisamos injetar. Uma é a sqlSessionFactory usada pelo Mybatis-Spring para gerar objetos SqlSessionTemplate que implementam a interface SqlSession e a outra é a interface Mapper correspondente que queremos retornar.
Depois de definir o MapperFactoryBean correspondente à interface Mapper correspondente, podemos injetar nossa interface Mapper correspondente no objeto bean gerenciado pelo Spring, como o objeto bean Service. Desta forma, quando precisarmos usar a interface Mapper correspondente, MapperFactoryBean obterá a interface Mapper correspondente de seu método getObject, e getObject internamente ainda chamará o método getMapper (interface Mapper) da interface SqlSession através das propriedades que injetamos para retornar o interface do mapeador correspondente. Desta forma, a integração do Mybatis e do Spring é alcançada entregando o SqlSessionFactory e a interface Mapper correspondente ao gerenciamento do Spring.
Arquivo de configuração applicationContext.xml do Spring:
Código 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"> <nome da propriedade="driverClassName" value="${jdbc.driver}" /> <nome da propriedade ="url" value="${jdbc.url}" /> <nome da propriedade="nome de usuário" value="${jdbc.username}" /> <nome da propriedade="senha" 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" /> </ feijão> feijão> </feijão> Arquivo BlogMapper.xml:
Código 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"> <!-- Adicionar novo registro--> <inserir id="insertBlog" parâmetroType="Blog" useGeneratedKeys="true" keyProperty="id"> insira em t_blog(title,content,owner) valores(#{title},#{content},#{owner}) </ insert> <!-- Consultar um único registro--> <select id="selectBlog" parâmetroType="int" resultMap="BlogResult"> select * from t_blog where id = #{id} </select> <!-- Modificar registro--> <update id="updateBlog" parâmetroType="Blog"> atualizar t_blog set title = #{title},content = #{content},owner = #{owner} onde id = #{id} </update> <!-- Consultar todos os registros--> <select id="selectAll" resultType="Blog"> select * from t_blog </select> <!-- Excluir registros--> <delete id="deleteBlog" parâmetroType="int"> excluir do t_blog onde id = #{id} </delete> </mapper> BlogMapper.java:
Código Java
pacote com.tiantian.mybatis.mapper; importar java.util.List; importar com.tiantian.mybatis.model.Blog; publicinterface BlogMapper {public Blog selectBlog(int idBlog); ); publicvoid deleteBlog(int id); public List<Blog> selectAll(); BlogServiceImpl.java:
Código Java
pacote com.tiantian.mybatis.service.impl; importar java.util.List; importar javax.annotation.Resource; 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) 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;MapperScannerConfigurer
Ao usar o método acima para integração, se tivermos um Mapper, precisamos definir um MapperFactoryBean correspondente. Quando temos relativamente poucos Mappers, tudo bem, mas quando temos muitos Mappers, definimos cada Mapper assim. o MapperFactoryBean correspondente parece ser mais lento. Para isso, Mybatis-Spring nos fornece uma classe chamada MapperScannerConfigurer. Através desta classe, Mybatis-Spring irá registrar automaticamente para nós o objeto MapperFactoryBean correspondente ao Mapper.
Se precisarmos usar o MapperScannerConfigurer para nos ajudar a verificar e registrar automaticamente a interface do Mapper, precisamos definir um bean correspondente ao MapperScannerConfigurer no arquivo de configuração applicationContext do Spring. Para MapperScannerConfigurer, há um atributo que devemos especificar: basePackage. basePackage é usado para especificar o pacote base onde o arquivo de interface do Mapper está localizado. As interfaces do Mapper neste pacote base ou todos os seus subpacotes serão pesquisadas. Vários pacotes base podem ser separados por vírgulas ou ponto e vírgula. A definição mais simples do MapperScannerConfigurer é especificar apenas um atributo basePackage, como:
Código XML
<bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> </bean>
Dessa forma, o MapperScannerConfigurer verificará todas as interfaces do pacote base especificado e as registrará como objetos MapperFactoryBean. Ao usar MapperScannerConfigurer e adicionar o atributo basePackage, o arquivo de configuração applicationContext em nosso exemplo acima ficará assim:
Código 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"> <nome da propriedade="driverClassName" value="${jdbc.driver}" /> <nome da propriedade ="url" value="${jdbc.url}" /> <nome da propriedade="nome de usuário" value="${jdbc.username}" /> <nome da propriedade="senha" 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>Às vezes, o pacote base que especificamos não contém todas as interfaces do Mapper que definimos. Por esse motivo, o MapperScannerConfigurer também nos fornece dois outros atributos que podem restringir o escopo de pesquisa e registro. Um é anotaçãoClass e o outro é marcadorInterface.
annotationClass: Quando annotationClass for especificado, o MapperScannerConfigurer registrará apenas interfaces marcadas com a anotação annotationClass.
marcadorInterface: marcadorInterface é usado para especificar uma interface Quando marcadorInterface é especificado, MapperScannerConfigurer registrará apenas a interface herdada de marcadorInterface.
Se ambas as propriedades acima forem especificadas, MapperScannerConfigurer usará sua união em vez de sua interseção. Mesmo que annotationClass seja usado para marcação ou a interface herdada de markerInterface será registrada como MapperFactoryBean.
Agora, supondo que nossa interface Mapper herde uma interface SuperMapper, podemos definir nosso MapperScannerConfigurer assim.
Código XML
<bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> <property name="markerInterface" value="com.tiantian.mybatis.mapper.SuperMapper"/> </bean>
Se a tag de anotação MybatisMapper for usada, então podemos definir nosso MapperScannerConfigurer assim.
Código XML
<bean> <property name="basePackage" value="com.tiantian.mybatis.mapper" /> <property name="annotationClass" value="com.tiantian.mybatis.annotation.MybatisMapper"/> </bean>
Além das propriedades usadas para restringir o escopo da interface registrada do Mapper, também podemos especificar algumas outras propriedades, como:
sqlSessionFactory: esta propriedade foi descontinuada. Quando usamos múltiplas fontes de dados, precisamos usar sqlSessionFactory para especificar o SqlSessionFactory que precisa ser usado ao registrar MapperFactoryBean, porque quando sqlSessionFactory não for especificado, um será automaticamente injetado no modo Autowired. Em outras palavras, quando utilizamos apenas uma fonte de dados, ou seja, quando definimos apenas um SqlSessionFactory, não precisamos especificar SqlSessionFactory para MapperScannerConfigurer.
sqlSessionFactoryBeanName: Sua função é igual a sqlSessionFactory, exceto que especifica o nome do bean correspondente ao SqlSessionFactory definido.
sqlSessionTemplate: este atributo foi descontinuado. Sua função também é equivalente a sqlSessionFactory, porque, como mencionado anteriormente, MapperFactoryBean usa o método getMapper de SqlSession para obter o objeto Mapper correspondente. Ele só precisa ser especificado quando vários SqlSessionTemplates são definidos. Para um MapperFactoryBean, apenas um de SqlSessionFactory e SqlSessionTemplate é necessário. Quando ambos forem especificados, SqlSessionFactory será ignorado.
sqlSessionTemplateBeanName: Especifique o nome do bean correspondente ao sqlSessionTemplate a ser usado.
Nota: Como o uso dos atributos sqlSessionFactory e sqlSessionTemplate fará com que algum conteúdo seja carregado antes do PropertyPlaceholderConfigurer, as informações de propriedade externa usadas no arquivo de configuração não podem ser substituídas a tempo e ocorrerão erros. As propriedades sqlSessionFactory e sqlSessionTemplate foram abandonadas em Mybatis-Spring. É recomendado que você use a propriedade sqlSessionFactoryBeanName e a propriedade sqlSessionTemplateBeanName.
Código 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>SqlSessionTemplate
Além de usar a interface Mapper diretamente após a integração acima, Mybatis-Spring também nos fornece uma maneira de usar SqlSession diretamente. Mybatis-Spring nos fornece uma classe SqlSessionTemplate que implementa a interface SqlSession. Ela é thread-safe e pode ser usada por vários Dao ao mesmo tempo. Ao mesmo tempo, ele também está associado à transação do Spring para garantir que o SqlSession usado atualmente seja aquele que foi vinculado à transação do Spring. E também pode gerenciar sozinho o envio e encerramento da Sessão. Quando o mecanismo de gerenciamento de transações do Spring é usado, o SqlSession também pode ser enviado e revertido junto com as transações do Spring.
Ao usar SqlSessionTemplate podemos defini-lo no arquivo de configuração applicationContext do Spring da seguinte forma:
<bean id="sqlSession"> <constructor-arg index="0" ref="sqlSessionFactory" /> </bean>
Desta forma, podemos usar SqlSessionTemplate diretamente para programar em Dao por meio da injeção de dependência do Spring. Neste momento, nosso Dao pode ficar assim:
Código Java
pacote com.tiantian.mybatis.dao; importar java.util.List; importar javax.annotation.Resource; importar org.mybatis.mybatis.model; Blog; @Repository publicclass BlogDaoImpl implementa BlogDao { private SqlSessionTemplate sqlSessionTemplate; 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 (SqlSessionTemplate) { returnsqlSessionTemplate; } @Resource publicvoid setSqlSessionTemplate (SqlSessionTemplate; sqlSessionTemplate) { this.sqlSessionTemplate = sqlSessionTemplate; Observação:
Este artigo foi escrito com base em Mybatis3.2.1, Mybatis-Spring1.1.0 e Spring3.1.
O texto acima é uma breve análise do processo de implementação da integração de mybatis e spring apresentado neste artigo. Espero que gostem. O próximo artigo apresentará o método de integração de spring e mybatis.