`
923080512
  • 浏览: 190819 次
  • 性别: Icon_minigender_1
  • 来自: 商丘
社区版块
存档分类
最新评论

基于注解的mybatis和spring整合

mybatis注解 
阅读更多
基于注解的mybatis和spring整合
ibatis改名为mybatis已经将近一年了，mybatis3也发布了，但是相关的开发文档却很少，查阅了官方的使用指南，也是说的模糊不清，一笔 带过，尤其是注解部分，只是列举了注解种类，却没有对应的例子，因此可能会给某些兄弟使用mybatis注解带来困惑，我想就我微薄的知识想对 mybatis注解的使用以及和spring整合谈谈自己的看法，也希望大家猛烈的指正我的错误。

首先当然得下载mybatis-3.0.5.jar和mybatis-spring-1.0.1.jar两个JAR包，并放在WEB-INF的 lib目录下(如果你使用maven，则jar会根据你的pom配置的依赖自动下载，并存放在你指定的maven本地库中，默认是~/.m2 /repository)，前一个是mybatis核心包，后一个是和spring整合的包。

使用mybatis，必须有个全局配置文件configuration.xml，来配置mybatis的缓存，延迟加载等等一系列属性，该配置文件示例如下：
Java代码 收藏代码
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3. PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
  4. "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
  5. <configuration>
  6. <settings>
  7. <!-- 全局映射器启用缓存 -->
  8. <setting name="cacheEnabled" value="true" />
  9. <!-- 查询时，关闭关联对象即时加载以提高性能 -->
  10. <setting name="lazyLoadingEnabled" value="true" />
  11. <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->
  12. <setting name="aggressiveLazyLoading" value="false" />
  13. <!-- 对于未知的SQL查询，允许返回不同的结果集以达到通用的效果 -->
  14. <setting name="multipleResultSetsEnabled" value="true" />
  15. <!-- 允许使用列标签代替列名 -->
  16. <setting name="useColumnLabel" value="true" />
  17. <!-- 允许使用自定义的主键值(比如由程序生成的UUID 32位编码作为键值)，数据表的PK生成策略将被覆盖 -->
  18. <setting name="useGeneratedKeys" value="true" />
  19. <!-- 给予被嵌套的resultMap以字段-属性的映射支持 -->
  20. <setting name="autoMappingBehavior" value="FULL" />
  21. <!-- 对于批量更新操作缓存SQL以提高性能 -->
  22. <setting name="defaultExecutorType" value="BATCH" />
  23. <!-- 数据库超过25000秒仍未响应则超时 -->
  24. <setting name="defaultStatementTimeout" value="25000" />
  25. </settings>
  26. <!-- 全局别名设置，在映射文件中只需写别名，而不必写出整个类路径 -->
  27. <typeAliases>
  28. <typeAlias alias="TestBean"
  29. type="com.wotao.taotao.persist.test.dataobject.TestBean" />
  30. </typeAliases>
  31. <!-- 非注解的sql映射文件配置，如果使用mybatis注解，该mapper无需配置，但是如果mybatis注解中包含@resultMap注解，则mapper必须配置，给resultMap注解使用 -->
  32. <mappers>
  33. <mapper resource="persist/test/orm/test.xml" />
  34. </mappers>
  35. </configuration> 
<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE configuration      
    PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"      
    "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
<configuration>
	<settings>
                <!-- 全局映射器启用缓存 -->
		<setting name="cacheEnabled" value="true" />
                <!-- 查询时，关闭关联对象即时加载以提高性能 -->
		<setting name="lazyLoadingEnabled" value="true" />
                <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指              定)，不会加载关联表的所有字段，以提高性能 -->
		<setting name="aggressiveLazyLoading" value="false" />
                <!-- 对于未知的SQL查询，允许返回不同的结果集以达到通用的效果 -->
		<setting name="multipleResultSetsEnabled" value="true" />
                <!-- 允许使用列标签代替列名 -->
		<setting name="useColumnLabel" value="true" />
                <!-- 允许使用自定义的主键值(比如由程序生成的UUID 32位编码作为键值)，数据表的PK生成策略将被覆盖 -->
		<setting name="useGeneratedKeys" value="true" />
                <!-- 给予被嵌套的resultMap以字段-属性的映射支持 -->
		<setting name="autoMappingBehavior" value="FULL" />
                <!-- 对于批量更新操作缓存SQL以提高性能  -->
		<setting name="defaultExecutorType" value="BATCH" />
                <!-- 数据库超过25000秒仍未响应则超时 -->
		<setting name="defaultStatementTimeout" value="25000" />
	</settings>
        <!-- 全局别名设置，在映射文件中只需写别名，而不必写出整个类路径  -->
	<typeAliases>
	     <typeAlias alias="TestBean"
		type="com.wotao.taotao.persist.test.dataobject.TestBean" />
	</typeAliases>
        <!-- 非注解的sql映射文件配置，如果使用mybatis注解，该mapper无需配置，但是如果mybatis注解中包含@resultMap注解，则mapper必须配置，给resultMap注解使用 -->
	<mappers>
		<mapper resource="persist/test/orm/test.xml" />
	</mappers>
</configuration>

该文件放在资源文件的任意classpath目录下，假设这里就直接放在资源根目录，等会spring需要引用该文件。

查看ibatis-3-config.dtd发现除了settings和typeAliases还有其他众多元素，比如 properties,objectFactory,environments等等，这些元素基本上都包含着一些环境配置，数据源定义，数据库事务等等， 在单独使用mybatis的时候非常重要，比如通过以构造参数的形式去实例化一个sqlsessionFactory，就像这样：
Java代码 收藏代码
  1. SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader);
  2. SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, properties);
  3. SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment, properties); 
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader);
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, properties);
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment, properties);

而typeHandlers则用来自定义映射规则，如你可以自定义将Character映射为varchar，plugins元素则放了一些拦截器接口，你可以继承他们并做一些切面的事情，至于每个元素的细节和使用，你参考mybatis用户指南即可。

现在我们用的是spring，因此除settings和typeAliases元素之外，其他元素将会失效，故不在此配置，spring会覆盖这些元素的配置，比如在spring配置文件中指定c3p0数据源定义如下：
Java代码 收藏代码
  1. <!-- c3p0 connection pool configuration -->
  2. <bean id="testDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
  3. destroy-method="close">
  4. <!-- 数据库驱动 -->
  5. <property name="driverClass" value="${db.driver.class}" />
  6. <!-- 连接URL串 -->
  7. <property name="jdbcUrl" value="${db.url}" />
  8. <!-- 连接用户名 -->
  9. <property name="user" value="${db.username}" />
  10. <!-- 连接密码 -->
  11. <property name="password" value="${db.password}" />
  12. <!-- 初始化连接池时连接数量为5个 -->
  13. <property name="initialPoolSize" value="5" />
  14. <!-- 允许最小连接数量为5个 -->
  15. <property name="minPoolSize" value="5" />
  16. <!-- 允许最大连接数量为20个 -->
  17. <property name="maxPoolSize" value="20" />
  18. <!-- 允许连接池最大生成100个PreparedStatement对象 -->
  19. <property name="maxStatements" value="100" />
  20. <!-- 连接有效时间，连接超过3600秒未使用，则该连接丢弃 -->
  21. <property name="maxIdleTime" value="3600" />
  22. <!-- 连接用完时，一次产生的新连接步进值为2 -->
  23. <property name="acquireIncrement" value="2" />
  24. <!-- 获取连接失败后再尝试10次，再失败则返回DAOException异常 -->
  25. <property name="acquireRetryAttempts" value="10" />
  26. <!-- 获取下一次连接时最短间隔600毫秒，有助于提高性能 -->
  27. <property name="acquireRetryDelay" value="600" />
  28. <!-- 检查连接的有效性，此处小弟不是很懂什么意思 -->
  29. <property name="testConnectionOnCheckin" value="true" />
  30. <!-- 每个1200秒检查连接对象状态 -->
  31. <property name="idleConnectionTestPeriod" value="1200" />
  32. <!-- 获取新连接的超时时间为10000毫秒 -->
  33. <property name="checkoutTimeout" value="10000" />
  34. </bean> 
<!-- c3p0 connection pool configuration -->
	<bean id="testDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
                <!-- 数据库驱动 -->
		<property name="driverClass" value="${db.driver.class}" />
                <!-- 连接URL串 -->
		<property name="jdbcUrl" value="${db.url}" />
                <!-- 连接用户名 -->
		<property name="user" value="${db.username}" />
                <!-- 连接密码 -->
		<property name="password" value="${db.password}" />
                <!-- 初始化连接池时连接数量为5个 -->
		<property name="initialPoolSize" value="5" />
                <!-- 允许最小连接数量为5个 -->
		<property name="minPoolSize" value="5" />
                <!-- 允许最大连接数量为20个 -->
		<property name="maxPoolSize" value="20" />
                <!-- 允许连接池最大生成100个PreparedStatement对象 -->
		<property name="maxStatements" value="100" />
                <!-- 连接有效时间，连接超过3600秒未使用，则该连接丢弃 -->
		<property name="maxIdleTime" value="3600" />
                <!-- 连接用完时，一次产生的新连接步进值为2 -->
		<property name="acquireIncrement" value="2" />
                <!-- 获取连接失败后再尝试10次，再失败则返回DAOException异常 -->
		<property name="acquireRetryAttempts" value="10" />
                <!-- 获取下一次连接时最短间隔600毫秒，有助于提高性能 -->
		<property name="acquireRetryDelay" value="600" />
                <!-- 检查连接的有效性，此处小弟不是很懂什么意思 -->
		<property name="testConnectionOnCheckin" value="true" />
                <!-- 每个1200秒检查连接对象状态 -->
		<property name="idleConnectionTestPeriod" value="1200" />
                <!-- 获取新连接的超时时间为10000毫秒 -->
		<property name="checkoutTimeout" value="10000" />
	</bean>

配置中的${}都是占位符，在你指定数据库驱动打war时会自动替换，替换的值在你的父pom中配置，至于c3p0连接池的各种属性详细信息和用 法，你自行参考c3p0的官方文档，这里要说明的是checkoutTimeout元素，记得千万要设大一点，单位是毫秒，假如设置太小，有可能会导致没 等数据库响应就直接超时了，小弟在这里吃了不少苦头，还是基本功太差。

数据源配置妥当之后，我们就要开始非常重要的sessionFactory配置了，无论是hibernate还是mybatis，都需要一个sessionFactory来生成session，sessionFactory配置如下：
Java代码 收藏代码
  1. <bean id="testSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  2. <property name="configLocation" value="classpath:configuration.xml" />
  3. <property name="dataSource" ref="testDataSource" />
  4. </bean> 
	<bean id="testSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:configuration.xml" />
		<property name="dataSource" ref="testDataSource" />
	</bean>

testSqlSessionFactory有两处注入，一个就是前面提到的mybatis全局设置文件configuration.xml，另 一个就是上面定义的数据源了（注：hibernate的sessionFactory只需注入hibernate.cfg.xml，数据源定义已经包含在 该文件中），好了，sessionFactory已经产生了，由于我们用的mybatis3的注解，因此spring的 sqlSessionTemplate也不用配置了，sqlSessionTemplate也不用注入到我们的BaseDAO中了，相应的，我们需要配置 一个映射器接口来对应sqlSessionTemplate，该映射器接口定义了你自己的接口方法，具体实现不用关心，代码如下：
Java代码 收藏代码
  1. <!-- data OR mapping interface -->
  2. <bean id="testMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  3. <property name="sqlSessionFactory" ref="testSqlSessionFactory" />
  4. <property name="mapperInterface" value="com.wotao.taotao.persist.test.mapper.TestMapper" />
  5. </bean> 
	<!-- data OR mapping interface -->
	<bean id="testMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
		<property name="sqlSessionFactory" ref="testSqlSessionFactory" />
		<property name="mapperInterface" value="com.wotao.taotao.persist.test.mapper.TestMapper" />
	</bean>

对应于sqlSessionTemplate，testMapper同样需要testSqlSessionFactory注入，另外一个注入就是 你自己定义的Mapper接口，该接口定义了操作数据库的方法和SQL语句以及很多的注解，稍后我会讲到。到此，mybatis和spring整合的文件 配置就算OK了（注：如果你需要开通spring对普通类的代理功能，那么你需要在spring配置文件中加入<aop:aspectj- autoproxy />），至于其他的如事务配置，AOP切面注解等内容不在本文范围内，不作累述。

至此，一个完整的myabtis整合spring的配置文件看起来应该如下所示：

Java代码 收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4. xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  6. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  7. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
  8. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  10. <!-- c3p0 connection pool configuration -->
  11. <bean id="testDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
  12. destroy-method="close">
  13. <property name="driverClass" value="${db.driver.class}" />
  14. <property name="jdbcUrl" value="${db.url}" />
  15. <property name="user" value="${db.username}" />
  16. <property name="password" value="${db.password}" />
  17. <property name="initialPoolSize" value="5" />
  18. <property name="minPoolSize" value="5" />
  19. <property name="maxPoolSize" value="20" />
  20. <property name="maxStatements" value="100" />
  21. <property name="maxIdleTime" value="3600" />
  22. <property name="acquireIncrement" value="2" />
  23. <property name="acquireRetryAttempts" value="10" />
  24. <property name="acquireRetryDelay" value="600" />
  25. <property name="testConnectionOnCheckin" value="true" />
  26. <property name="idleConnectionTestPeriod" value="1200" />
  27. <property name="checkoutTimeout" value="10000" />
  28. </bean>
  29. <bean id="testSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  30. <property name="configLocation" value="classpath:configuration.xml" />
  31. <property name="dataSource" ref="testDataSource" />
  32. </bean>
  33. <!-- data OR mapping interface -->
  34. <bean id="testMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  35. <property name="sqlSessionFactory" ref="testSqlSessionFactory" />
  36. <property name="mapperInterface" value="com.wotao.taotao.persist.test.mapper.TestMapper" />
  37. </bean>
  39. <!-- add your own Mapper here -->
  41. <!-- comment here, using annotation -->
  42. <!-- <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate"> -->
  43. <!-- <constructor-arg index="0" ref="sqlSessionFactory" /> -->
  44. <!-- </bean> -->
  45. <!-- base DAO class, for module business, extend this class in DAO -->
  46. <!-- <bean id="testBaseDAO" class="com.test.dao.TestBaseDAO"> -->
  47. <!-- <property name="sqlSessionTemplate" ref="sqlSessionTemplate" /> -->
  48. <!-- </bean> -->
  49. <!-- <bean id="testDAO" class="com.test.dao.impl.TestDAOImpl" /> -->
  51. <!-- you can DI Bean if you don't like use annotation -->
  53. </beans> 
<?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:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd 
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

	<!-- c3p0 connection pool configuration -->
	<bean id="testDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="${db.driver.class}" />
		<property name="jdbcUrl" value="${db.url}" />
		<property name="user" value="${db.username}" />
		<property name="password" value="${db.password}" />
		<property name="initialPoolSize" value="5" />
		<property name="minPoolSize" value="5" />
		<property name="maxPoolSize" value="20" />
		<property name="maxStatements" value="100" />
		<property name="maxIdleTime" value="3600" />
		<property name="acquireIncrement" value="2" />
		<property name="acquireRetryAttempts" value="10" />
		<property name="acquireRetryDelay" value="600" />
		<property name="testConnectionOnCheckin" value="true" />
		<property name="idleConnectionTestPeriod" value="1200" />
		<property name="checkoutTimeout" value="10000" />
	</bean>
	<bean id="testSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:configuration.xml" />
		<property name="dataSource" ref="testDataSource" />
	</bean>
	<!-- data OR mapping interface -->
	<bean id="testMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
		<property name="sqlSessionFactory" ref="testSqlSessionFactory" />
		<property name="mapperInterface" value="com.wotao.taotao.persist.test.mapper.TestMapper" />
	</bean>

	<!-- add your own Mapper here -->

	<!-- comment here, using annotation -->
	<!-- <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate"> -->
	<!-- <constructor-arg index="0" ref="sqlSessionFactory" /> -->
	<!-- </bean> -->
	<!-- base DAO class, for module business, extend this class in DAO -->
	<!-- <bean id="testBaseDAO" class="com.test.dao.TestBaseDAO"> -->
	<!-- <property name="sqlSessionTemplate" ref="sqlSessionTemplate" /> -->
	<!-- </bean> -->
	<!-- <bean id="testDAO" class="com.test.dao.impl.TestDAOImpl" /> -->

	<!-- you can DI Bean if you don't like use annotation -->

</beans>


到此为止，我们只讲了mybatis和spring的整合，还没有真正触及mybatis的核心：使用mybatis注解代替映射文件编程（不过 官方文档也说了，如果真正想发挥mybatis功能，还是需要用到映射文件，看来myabtis自己都对mybatis注解没信心，呵呵），通过上述内 容，我们知道配置搞定，但是testMapper还没有被实现，而注解的使用，全部集中在这个testMapper上，是mybatis注解的核心所在， 先来看一下这个testMapper接口是个什么样的：
Java代码 收藏代码
  1. /**
  2. * The test Mapper interface.
  3. *
  4. * @author HuangMin <a href="mailto:minhuang@hengtiansoft.com>send email</a>
  5. *
  6. * @since 1.6
  7. * @version 1.0
  8. *
  9. * #~TestMapper.java 2011-9-23 : afternoon 10:51:40
  10. */
  11. @CacheNamespace(size = 512)
  12. public interface TestMapper {
  14. /**
  15. * get test bean by UID.
  16. *
  17. * @param id
  18. * @return
  19. */
  20. @SelectProvider(type = TestSqlProvider.class, method = "getSql")
  21. @Options(useCache = true, flushCache = false, timeout = 10000)
  22. @Results(value = {
  23. @Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
  24. @Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) })
  25. public TestBean get(@Param("id") String id);
  27. /**
  28. * get all tests.
  29. *
  30. * @return
  31. */
  32. @SelectProvider(type = TestSqlProvider.class, method = "getAllSql")
  33. @Options(useCache = true, flushCache = false, timeout = 10000)
  34. @Results(value = {
  35. @Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
  36. @Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) })
  37. public List<TestBean> getAll();
  39. /**
  40. * get tests by test text.
  41. *
  42. * @param testText
  43. * @return
  44. */
  45. @SelectProvider(type = TestSqlProvider.class, method = "getByTestTextSql")
  46. @Options(useCache = true, flushCache = false, timeout = 10000)
  47. @ResultMap(value = "getByTestText")
  48. public List<TestBean> getByTestText(@Param("testText") String testText);
  50. /**
  51. * insert a test bean into database.
  52. *
  53. * @param testBean
  54. */
  55. @InsertProvider(type = TestSqlProvider.class, method = "insertSql")
  56. @Options(flushCache = true, timeout = 20000)
  57. public void insert(@Param("testBean") TestBean testBean);
  59. /**
  60. * update a test bean with database.
  61. *
  62. * @param testBean
  63. */
  64. @UpdateProvider(type = TestSqlProvider.class, method = "updateSql")
  65. @Options(flushCache = true, timeout = 20000)
  66. public void update(@Param("testBean") TestBean testBean);
  68. /**
  69. * delete a test by UID.
  70. *
  71. * @param id
  72. */
  73. @DeleteProvider(type = TestSqlProvider.class, method = "deleteSql")
  74. @Options(flushCache = true, timeout = 20000)
  75. public void delete(@Param("id") String id);
  76. } 
/**
 * The test Mapper interface.
 * 
 * @author HuangMin <a href="mailto:minhuang@hengtiansoft.com>send email</a>
 * 
 * @since 1.6
 * @version 1.0
 * 
 *          #~TestMapper.java 2011-9-23 : afternoon 10:51:40
 */
@CacheNamespace(size = 512)
public interface TestMapper {

	/**
	 * get test bean by UID.
	 * 
	 * @param id
	 * @return
	 */
	@SelectProvider(type = TestSqlProvider.class, method = "getSql")
	@Options(useCache = true, flushCache = false, timeout = 10000)
	@Results(value = {
			@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
			@Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) })
	public TestBean get(@Param("id") String id);

	/**
	 * get all tests.
	 * 
	 * @return
	 */
	@SelectProvider(type = TestSqlProvider.class, method = "getAllSql")
	@Options(useCache = true, flushCache = false, timeout = 10000)
	@Results(value = {
			@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
			@Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) })
	public List<TestBean> getAll();

	/**
	 * get tests by test text.
	 * 
	 * @param testText
	 * @return
	 */
	@SelectProvider(type = TestSqlProvider.class, method = "getByTestTextSql")
	@Options(useCache = true, flushCache = false, timeout = 10000)
	@ResultMap(value = "getByTestText")
	public List<TestBean> getByTestText(@Param("testText") String testText);

	/**
	 * insert a test bean into database.
	 * 
	 * @param testBean
	 */
	@InsertProvider(type = TestSqlProvider.class, method = "insertSql")
	@Options(flushCache = true, timeout = 20000)
	public void insert(@Param("testBean") TestBean testBean);

	/**
	 * update a test bean with database.
	 * 
	 * @param testBean
	 */
	@UpdateProvider(type = TestSqlProvider.class, method = "updateSql")
	@Options(flushCache = true, timeout = 20000)
	public void update(@Param("testBean") TestBean testBean);

	/**
	 * delete a test by UID.
	 * 
	 * @param id
	 */
	@DeleteProvider(type = TestSqlProvider.class, method = "deleteSql")
	@Options(flushCache = true, timeout = 20000)
	public void delete(@Param("id") String id);
}

下面逐个对里面的注解进行分析：
@CacheNamespace(size = 512) ： 定义在该命名空间内允许使用内置缓存，最大值为512个对象引用，读写默认是开启的，缓存内省刷新时间为默认3600000毫秒，写策略是拷贝整个对象镜 像到全新堆（如同CopyOnWriteList）因此线程安全。

@SelectProvider(type = TestSqlProvider.class, method = "getSql") ： 提供查询的SQL语句，如果你不用这个注解，你也可以直接使用@Select("select * from ....")注解，把查询SQL抽取到一个类里面，方便管理，同时复杂的SQL也容易操作，type = TestSqlProvider.class就是存放SQL语句的类，而method = "getSql"表示get接口方法需要到TestSqlProvider类的getSql方法中获取SQL语句。

@Options(useCache = true, flushCache = false, timeout = 10000) ： 一些查询的选项开关，比如useCache = true表示本次查询结果被缓存以提高下次查询速度，flushCache = false表示下次查询时不刷新缓存，timeout = 10000表示查询结果缓存10000秒。

@Results(value = {
@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
@Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) }) ： 表示sql查询返回的结果集，@Results是以@Result为元素的数组，@Result表示单条属性-字段的映射关系，如：@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR)可以简写为：@Result(id = true, property = "id", column = "test_id")，id = true表示这个test_id字段是个PK，查询时mybatis会给予必要的优化，应该说数组中所有的@Result组成了单个记录的映射关系，而 @Results则单个记录的集合。另外还有一个非常重要的注解@ResultMap也和@Results差不多，到时会讲到。

@Param("id") ：全局限定别名，定义查询参数在sql语句中的位置不再是顺序下标0,1,2,3....的形式，而是对应名称，该名称就在这里定义。

@ResultMap(value = "getByTestText") ：重要的注解，可以解决复杂的映射关系，包括resultMap嵌套，鉴别器discriminator等等。注意一旦你启用该注解，你将不得不在你的映 射文件中配置你的resultMap，而value = "getByTestText"即为映射文件中的resultMap ID(注意此处的value = "getByTestText"，必须是在映射文件中指定命名空间路径)。@ResultMap在某些简单场合可以用@Results代替，但是复杂查 询，比如联合、嵌套查询@ResultMap就会显得解耦方便更容易管理。
一个映射文件如下所示：
Java代码 收藏代码
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3. PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"
  4. "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">
  6. <mapper namespace="com.wotao.taotao.persist.test.mapper.TestMapper">
  7. <resultMap id="getByTestText" type="TestBean">
  8. <id property="id" column="test_id" javaType="string" jdbcType="VARCHAR" />
  9. <result property="testText" column="test_text" javaType="string" jdbcType="VARCHAR" />
  10. </resultMap>
  11. </mapper> 
<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper  
PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"  
"http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">

<mapper namespace="com.wotao.taotao.persist.test.mapper.TestMapper">
	<resultMap id="getByTestText" type="TestBean">
		<id property="id" column="test_id" javaType="string" jdbcType="VARCHAR" />
		<result property="testText" column="test_text" javaType="string" jdbcType="VARCHAR" />
	</resultMap>
</mapper>

注意文件中的namespace路径必须是使用@resultMap的类路径，此处是TestMapper，文件中 id="getByTestText"必须和@resultMap中的value = "getByTestText"保持一致。

@InsertProvider(type = TestSqlProvider.class, method = "insertSql") ：用法和含义@SelectProvider一样，只不过是用来插入数据库而用的。

@Options(flushCache = true, timeout = 20000) ：对于需要更新数据库的操作，需要重新刷新缓存flushCache = true使缓存同步。

@UpdateProvider(type = TestSqlProvider.class, method = "updateSql") ：用法和含义@SelectProvider一样，只不过是用来更新数据库而用的。

@Param("testBean") ：是一个自定义的对象，指定了sql语句中的表现形式，如果要在sql中引用对象里面的属性，只要使用testBean.id，testBean.textText即可，mybatis会通过反射找到这些属性值。

@DeleteProvider(type = TestSqlProvider.class, method = "deleteSql") ：用法和含义@SelectProvider一样，只不过是用来删除数据而用的。

现在mybatis注解基本已经讲完了，接下来我们就要开始写SQL语句了，因为我们不再使用映射文件编写SQL，那么就不得不在java类里面 写，就像上面提到的，我们不得不在TestSqlProvider这个类里面写SQL，虽然已经把所有sql语句集中到了一个类里面去管理，但听起来似乎 仍然有点恶心，幸好mybatis提供SelectBuilder和SqlBuilder这2个小工具来帮助我们生成SQL语 句，SelectBuilder专门用来生成select语句，而SqlBuilder则是一般性的工具，可以生成任何SQL语句，我这里选择了 SqlBuilder来生成，TestSqlProvider代码如下：
Java代码 收藏代码
  1. /*
  2. * #~ test-afternoon10:51:40
  3. */
  4. package com.wotao.taotao.persist.test.sqlprovider;
  6. import static org.apache.ibatis.jdbc.SqlBuilder.BEGIN;
  7. import static org.apache.ibatis.jdbc.SqlBuilder.FROM;
  8. import static org.apache.ibatis.jdbc.SqlBuilder.SELECT;
  9. import static org.apache.ibatis.jdbc.SqlBuilder.SQL;
  10. import static org.apache.ibatis.jdbc.SqlBuilder.WHERE;
  11. import static org.apache.ibatis.jdbc.SqlBuilder.DELETE_FROM;
  12. import static org.apache.ibatis.jdbc.SqlBuilder.INSERT_INTO;
  13. import static org.apache.ibatis.jdbc.SqlBuilder.SET;
  14. import static org.apache.ibatis.jdbc.SqlBuilder.UPDATE;
  15. import static org.apache.ibatis.jdbc.SqlBuilder.VALUES;
  17. import java.util.Map;
  19. /**
  20. * The test sql Provider,define the sql script for mapping.
  21. *
  22. * @author HuangMin <a href="mailto:minhuang@hengtiansoft.com>send email</a>
  23. *
  24. * @since 1.6
  25. * @version 1.0
  26. *
  27. * #~TestSqlProvider.java 2011-9-23 : afternoon 10:51:40
  28. */
  29. public class TestSqlProvider {
  31. /** table name, here is test */
  32. private static final String TABLE_NAME = "test";
  34. /**
  35. * get test by id sql script.
  36. *
  37. * @param parameters
  38. * @return
  39. */
  40. public String getSql(Map<String, Object> parameters) {
  41. String uid = (String) parameters.get("id");
  42. BEGIN();
  43. SELECT("test_id, test_text");
  44. FROM(TABLE_NAME);
  45. if (uid != null) {
  46. WHERE("test_id = #{id,javaType=string,jdbcType=VARCHAR}");
  47. }
  48. return SQL();
  49. }
  51. /**
  52. * get all tests sql script.
  53. *
  54. * @return
  55. */
  56. public String getAllSql() {
  57. BEGIN();
  58. SELECT("test_id, test_text");
  59. FROM(TABLE_NAME);
  60. return SQL();
  61. }
  63. /**
  64. * get test by test text sql script.
  65. *
  66. * @param parameters
  67. * @return
  68. */
  69. public String getByTestTextSql(Map<String, Object> parameters) {
  70. String tText = (String) parameters.get("testText");
  71. BEGIN();
  72. SELECT("test_id, test_text");
  73. FROM(TABLE_NAME);
  74. if (tText != null) {
  75. WHERE("test_text like #{testText,javaType=string,jdbcType=VARCHAR}");
  76. }
  77. return SQL();
  78. }
  80. /**
  81. * insert a test sql script.
  82. *
  83. * @return
  84. */
  85. public String insertSql() {
  86. BEGIN();
  87. INSERT_INTO(TABLE_NAME);
  88. VALUES("test_id", "#{testBean.id,javaType=string,jdbcType=VARCHAR}");
  89. VALUES("test_text", "#{testBean.testText,javaType=string,jdbcType=VARCHAR}");
  90. return SQL();
  91. }
  93. /**
  94. * update a test sql script.
  95. *
  96. * @return
  97. */
  98. public String updateSql() {
  99. BEGIN();
  100. UPDATE(TABLE_NAME);
  101. SET("test_text = #{testBean.testText,javaType=string,jdbcType=VARCHAR}");
  102. WHERE("test_id = #{testBean.id,javaType=string,jdbcType=VARCHAR}");
  103. return SQL();
  104. }
  106. /**
  107. * delete a test sql script.
  108. *
  109. * @return
  110. */
  111. public String deleteSql() {
  112. BEGIN();
  113. DELETE_FROM(TABLE_NAME);
  114. WHERE("test_id = #{id,javaType=string,jdbcType=VARCHAR}");
  115. return SQL();
  116. }
  117. } 
/*
 * #~ test-afternoon10:51:40 
 */
package com.wotao.taotao.persist.test.sqlprovider;

import static org.apache.ibatis.jdbc.SqlBuilder.BEGIN;
import static org.apache.ibatis.jdbc.SqlBuilder.FROM;
import static org.apache.ibatis.jdbc.SqlBuilder.SELECT;
import static org.apache.ibatis.jdbc.SqlBuilder.SQL;
import static org.apache.ibatis.jdbc.SqlBuilder.WHERE;
import static org.apache.ibatis.jdbc.SqlBuilder.DELETE_FROM;
import static org.apache.ibatis.jdbc.SqlBuilder.INSERT_INTO;
import static org.apache.ibatis.jdbc.SqlBuilder.SET;
import static org.apache.ibatis.jdbc.SqlBuilder.UPDATE;
import static org.apache.ibatis.jdbc.SqlBuilder.VALUES;

import java.util.Map;

/**
 * The test sql Provider,define the sql script for mapping.
 * 
 * @author HuangMin <a href="mailto:minhuang@hengtiansoft.com>send email</a>
 * 
 * @since 1.6
 * @version 1.0
 * 
 *          #~TestSqlProvider.java 2011-9-23 : afternoon 10:51:40
 */
public class TestSqlProvider {

	/** table name, here is test */
	private static final String TABLE_NAME = "test";

	/**
	 * get test by id sql script.
	 * 
	 * @param parameters
	 * @return
	 */
	public String getSql(Map<String, Object> parameters) {
		String uid = (String) parameters.get("id");
		BEGIN();
		SELECT("test_id, test_text");
		FROM(TABLE_NAME);
		if (uid != null) {
			WHERE("test_id = #{id,javaType=string,jdbcType=VARCHAR}");
		}
		return SQL();
	}

	/**
	 * get all tests sql script.
	 * 
	 * @return
	 */
	public String getAllSql() {
		BEGIN();
		SELECT("test_id, test_text");
		FROM(TABLE_NAME);
		return SQL();
	}

	/**
	 * get test by test text sql script.
	 * 
	 * @param parameters
	 * @return
	 */
	public String getByTestTextSql(Map<String, Object> parameters) {
		String tText = (String) parameters.get("testText");
		BEGIN();
		SELECT("test_id, test_text");
		FROM(TABLE_NAME);
		if (tText != null) {
			WHERE("test_text like #{testText,javaType=string,jdbcType=VARCHAR}");
		}
		return SQL();
	}

	/**
	 * insert a test sql script.
	 * 
	 * @return
	 */
	public String insertSql() {
		BEGIN();
		INSERT_INTO(TABLE_NAME);
		VALUES("test_id", "#{testBean.id,javaType=string,jdbcType=VARCHAR}");
		VALUES("test_text", "#{testBean.testText,javaType=string,jdbcType=VARCHAR}");
		return SQL();
	}

	/**
	 * update a test sql script.
	 * 
	 * @return
	 */
	public String updateSql() {
		BEGIN();
		UPDATE(TABLE_NAME);
		SET("test_text = #{testBean.testText,javaType=string,jdbcType=VARCHAR}");
		WHERE("test_id = #{testBean.id,javaType=string,jdbcType=VARCHAR}");
		return SQL();
	}

	/**
	 * delete a test sql script.
	 * 
	 * @return
	 */
	public String deleteSql() {
		BEGIN();
		DELETE_FROM(TABLE_NAME);
		WHERE("test_id = #{id,javaType=string,jdbcType=VARCHAR}");
		return SQL();
	}
}

BEGIN();表示刷新本地线程，某些变量为了线程安全，会先在本地存放变量，此处需要刷新。
SELECT，FROM，WHERE等等都是sqlbuilder定义的公用静态方法，用来组成你的sql字符串。如果你在testMapper 中调用该方法的某个接口方法已经定义了参数@Param()，那么该方法的参数Map<String, Object> parameters即组装了@Param()定义的参数，比如testMapper接口方法中定义参数为 @Param("testId"),@Param("testText")，那么parameters的形态就是： [key="testId",value=object1],[key="testText",value=object2]，如果接口方法没有定义 @Param()，那么parameters的key就是参数的顺序小标：[key=0,value=object1], [key=1,value=object2]，SQL()将返回最终append结束的字符串，sql语句中的形如
#{id,javaType=string,jdbcType=VARCHAR}完全可简写为#{id}，我只是为了规整如此写而已。另外，对于 复杂查询还有很多标签可用，比如：JOIN，INNER_JOIN，GROUP_BY，ORDER_BY等等，具体使用详情，你可以查看源码。

最后记得把你的Mapper接口注入到你的DAO类中，在DAO中引用Mapper接口方法即可。我在BaseDAO中的注解注入如下：
Java代码 收藏代码
  1. ......
  2. @Repository("testBaseDAO")
  3. public class TestBaseDAO {
  4. ...... 
......
@Repository("testBaseDAO")
public class TestBaseDAO {
......


Java代码 收藏代码
  1. ......
  2. /**
  3. * @param testMapper
  4. * the testMapper to set
  5. */
  6. @Autowired
  7. public void setTestMapper(@Qualifier("testMapper") TestMapper testMapper) {
  8. this.testMapper = testMapper;
  9. }
  10. ...... 
......
	/**
	 * @param testMapper
	 *            the testMapper to set
	 */
	@Autowired
	public void setTestMapper(@Qualifier("testMapper") TestMapper testMapper) {
		this.testMapper = testMapper;
	}
......


好了，写得累死了，休息一下，吃个饭什么的，别忘了给我猛烈的指出错误啊。
分享到：
| MyBatis3 通用CRUD的研究[二]
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    mybatis和spring整合方式-带注解

    ### MyBatis与Spring整合方式详解：基于注解的实现 #### 一、概述 在实际的软件开发过程中，为了更好地实现项目的模块化管理和提高代码的可维护性，通常会将MyBatis与Spring框架进行整合。这种方式不仅能够简化...

    mybatis与spring整合全部jar包

    这个“mybatis与spring整合全部jar包”包含了这三个框架整合所需的所有依赖库，使得开发者可以快速搭建SSM项目。 首先，让我们深入了解一下这三个组件： 1. **Spring**：Spring 是一个全面的Java企业级应用开发...

    mybatis和spring整合jar包

    标题中的"mybatis和spring整合jar包"表明我们要讨论的是如何将两个流行的Java框架——MyBatis和Spring——集成在一起，以便在同一个项目中利用它们各自的优势。MyBatis是一个轻量级的持久层框架，它允许开发者用SQL...

    mybatis-spring整合项目

    【正文】 《mybatis-spring整合项目》是GitHub上官方提供的一个示例...通过深入研究和实践《mybatis-spring整合项目》，开发者不仅可以熟练掌握MyBatis和Spring的集成技巧，还能提升在实际项目中运用这些技术的能力。

    MyBatis整合Spring中间件jar包 mybatis-spring-1.3.0.jar

    MyBatis-Spring是MyBatis与Spring框架的整合组件，其主要目的是简化在Spring应用中集成MyBatis的过程，使两者能够无缝协作。mybatis-spring-1.3.0.jar是这个中间件的特定版本，包含了实现这种集成所需的所有类和资源...

    mybatis-spring-1.31.jar

    首先，MyBatis-Spring通过自动配置，可以将MyBatis的数据源、SqlSessionFactory和Mapper接口与Spring的bean容器集成。这使得我们可以在Spring配置文件中声明式地管理MyBatis的相关组件，避免了手动创建和管理...

    mybatis-spring-1.3.1.jar下载

    MyBatis-Spring 1.3.1 是一个重要的Java库，它为MyBatis持久层框架和Spring框架提供了一座桥梁，使得两个强大的库能够无缝集成。这个版本的jar文件是开发者在使用MyBatis与Spring进行项目开发时必不可少的组件。下面...

    mybatis和spring的整合包（完整版）.rar

    MyBatis和Spring的整合是Java开发中常见的一种技术栈，被称为SSM（Spring、SpringMVC、MyBatis）框架。这个整合包提供了一整套的库文件，使得开发者可以快速搭建基于MyBatis与Spring的Web应用程序。在本文中，我们将...

    mybatis和spring整合jar

    MyBatis和Spring的整合是Java开发中常见的一种技术组合，尤其在企业级应用中，它们的集成可以提供强大的持久层支持。MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射，而Spring作为一款全能...

    mybatis-spring-1.3.0.jar 下载

    在Java开发领域，MyBatis和Spring框架的结合使用是常见的实践，它们的整合使得数据访问层的构建更为便捷和灵活。本篇文章将围绕"mybatis-spring-1.3.0.jar"这一组件展开，详细讲解其在实际项目中的作用、功能以及...

    mybatis-Spring整合jar包

    通过这些知识点，我们可以理解MyBatis-Spring整合的核心原理和使用方法，从而在实际项目中更有效地利用这两个强大的框架。这个整合jar包提供了一站式的解决方案，让开发者无需关注底层的细节，更专注于业务逻辑的...

    mybatis-spring整合jar包

    总的来说，MyBatis-Spring整合简化了在Spring应用中使用MyBatis的过程，提高了开发效率，并且提供了良好的事务管理和依赖注入功能。通过正确配置和使用，可以构建出稳定、高效的Java Web应用程序。

    mybatis-spring-1.3.3.jar官方下载

    MyBatis-Spring 是一个将 MyBatis ORM 框架与 Spring 框架集成的库，使得在 Spring 应用中使用 MyBatis 变得...mybatis-spring-1.3.3.jar 的下载和使用，可以帮助开发者快速构建基于 MyBatis 和 Spring 的企业级应用。

    mybatis-spring整合开发jar包.zip

    【标题】"mybatis-spring整合开发jar包.zip"中包含的是Mybatis、Spring和Mybatis-Spring整合的jar文件，这些是Java开发中的关键组件，尤其在构建基于MVC架构的Web应用时。Mybatis是一个优秀的持久层框架，它支持定制...

    MyBatis_Spring整合jar包（全部jar包）

    MyBatis_Spring整合是Java开发中常见的数据访问层解决方案，它将MyBatis的灵活映射机制与Spring的依赖注入和事务管理相结合，提供了一种高效、便捷的数据操作方式。这个压缩包包含了进行MyBatis与Spring整合所需的...

    MyBatis-Spring整合示例

    《MyBatis-Spring整合详解》 在Java开发中，MyBatis和Spring是两个非常重要的框架，它们各自在持久层和应用层有着广泛的应用。MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射，而Spring...

    mybatis与spring整合全部jar包(包括springmvc

    在标题提到的“mybatis与spring整合全部jar包(包括springmvc)”中，我们关注的重点是这两个框架的集成以及可能包含的Spring MVC部分，这通常涉及到以下几个关键知识点： 1. **MyBatis**：MyBatis是一个优秀的持久层...

    spring_mybatis 整合jar包

    在与Spring整合后，可以通过Spring的ApplicationContext来管理SqlSessionFactory和Mapper接口，实现事务的统一管理和DAO的自动注入。 在压缩包子文件的文件名称列表中，虽然只列出了"lib"，但我们可以推测，这个...

    MyBatis和Spring整合jar：mybatis-3.2.7.jar等

    MyBatis和Spring的整合是Java开发中常见的一种技术组合，它们可以无缝集成，使得数据库操作更为便捷。这里提到的两个jar包——mybatis-3.2.7.jar和mybatis-spring-1.2.2.jar，是实现这种整合的关键组件。 1. **...

    mybatis-spring集成

    下面将详细阐述MyBatis-Spring集成的关键知识点，以及如何在实际项目中实现XML配置和增删改查功能。 1. **MyBatis-Spring的作用**： MyBatis-Spring是两个框架之间的粘合剂，它提供了将MyBatis的SqlSession和...

Magicbox
Global site tag (gtag.js) - Google Analytics