碼上快樂

相關內容    簡體    繁體

Mybatis緩存 緩存配置文件 good

本文轉載自   查看原文   2016-08-25 08:56   5273    Mybatis 緩存 二級緩存

一、MyBatis緩存介紹

　　正如大多數持久層框架一樣，MyBatis 同樣提供了一級緩存和二級緩存的支持

  1. 一級緩存: 基於PerpetualCache 的 HashMap本地緩存，其存儲作用域為 Session，當 Session flush 或 close 之后，該Session中的所有 Cache 就將清空。

　　2. 二級緩存與一級緩存其機制相同，默認也是采用 PerpetualCache，HashMap存儲，不同在於其存儲作用域為 Mapper(Namespace)，並且可自定義存儲源，如 Ehcache。

　　3. 對於緩存數據更新機制，當某一個作用域(一級緩存Session/二級緩存Namespaces)的進行了 C/U/D 操作后，默認該作用域下所有 select 中的緩存將被clear。

1.1、Mybatis一級緩存測試

復制代碼 
 1 package me.gacl.test;
 2 
 3 import me.gacl.domain.User;
 4 import me.gacl.util.MyBatisUtil;
 5 import org.apache.ibatis.session.SqlSession;
 6 import org.junit.Test;
 7 
 8 /**
 9  * @author gacl
10  * 測試一級緩存
11  */
12 public class TestOneLevelCache {
13     
14     /*
15      * 一級緩存: 也就Session級的緩存(默認開啟)
16      */
17     @Test
18     public void testCache1() {
19         SqlSession session = MyBatisUtil.getSqlSession();
20         String statement = "me.gacl.mapping.userMapper.getUser";
21         User user = session.selectOne(statement, 1);
22         System.out.println(user);
23         
24         /*
25          * 一級緩存默認就會被使用
26          */
27         user = session.selectOne(statement, 1);
28         System.out.println(user);
29         session.close();
30         /*
31          1. 必須是同一個Session,如果session對象已經close()過了就不可能用了 
32          */
33         session = MyBatisUtil.getSqlSession();
34         user = session.selectOne(statement, 1);
35         System.out.println(user);
36         
37         /*
38          2. 查詢條件是一樣的
39          */
40         user = session.selectOne(statement, 2);
41         System.out.println(user);
42         
43         /*
44          3. 沒有執行過session.clearCache()清理緩存
45          */
46         //session.clearCache(); 
47         user = session.selectOne(statement, 2);
48         System.out.println(user);
49         
50         /*
51          4. 沒有執行過增刪改的操作(這些操作都會清理緩存)
52          */
53         session.update("me.gacl.mapping.userMapper.updateUser",
54                 new User(2, "user", 23));
55         user = session.selectOne(statement, 2);
56         System.out.println(user);
57         
58     }
59 }
復制代碼

1.2、Mybatis二級緩存測試

　　1、開啟二級緩存，在userMapper.xml文件中添加如下配置

<mapper namespace="me.gacl.mapping.userMapper">
<!-- 開啟二級緩存 -->
<cache/>

　　2、測試二級緩存

復制代碼 
 1 package me.gacl.test;
 2 
 3 import me.gacl.domain.User;
 4 import me.gacl.util.MyBatisUtil;
 5 import org.apache.ibatis.session.SqlSession;
 6 import org.apache.ibatis.session.SqlSessionFactory;
 7 import org.junit.Test;
 8 
 9 /**
10  * @author gacl
11  * 測試二級緩存
12  */
13 public class TestTwoLevelCache {
14     
15     /*
16      * 測試二級緩存
17      * 使用兩個不同的SqlSession對象去執行相同查詢條件的查詢，第二次查詢時不會再發送SQL語句，而是直接從緩存中取出數據
18      */
19     @Test
20     public void testCache2() {
21         String statement = "me.gacl.mapping.userMapper.getUser";
22         SqlSessionFactory factory = MyBatisUtil.getSqlSessionFactory();
23         //開啟兩個不同的SqlSession
24         SqlSession session1 = factory.openSession();
25         SqlSession session2 = factory.openSession();
26         //使用二級緩存時，User類必須實現一個Serializable接口===> User implements Serializable
27         User user = session1.selectOne(statement, 1);
28         session1.commit();//不懂為啥，這個地方一定要提交事務之后二級緩存才會起作用
29         System.out.println("user="+user);
30         
31         //由於使用的是兩個不同的SqlSession對象，所以即使查詢條件相同，一級緩存也不會開啟使用
32         user = session2.selectOne(statement, 1);
33         //session2.commit();
34         System.out.println("user2="+user);
35     }
36 }
復制代碼

1.3、二級緩存補充說明

　　1. 映射語句文件中的所有select語句將會被緩存。

　　2. 映射語句文件中的所有insert，update和delete語句會刷新緩存。

　　3. 緩存會使用Least Recently Used（LRU，最近最少使用的）算法來收回。

　　4. 緩存會根據指定的時間間隔來刷新。

　　5. 緩存會存儲1024個對象

cache標簽常用屬性：

<cache 
eviction="FIFO"  <!--回收策略為先進先出-->
flushInterval="60000" <!--自動刷新時間60s-->
size="512" <!--最多緩存512個引用對

http://www.cnblogs.com/xdp-gacl/p/4270403.html

 

首先當然得下載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>


該文件放在資源文件的任意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);


而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>


配置中的${}都是占位符，在你指定數據庫驅動打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>


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>


對應於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>



到此為止，我們只講了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. }


下面逐個對里面的注解進行分析：
@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>


注意文件中的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. }


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. ......

 

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. ......

 

引自：http://wwww.iteye.com/blog/1235996

 

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 laravel之緩存配置文件 Mybatis緩存+配置 Mybatis緩存（1）--------系統緩存及簡單配置介紹 Mybatis緩存配置—— 二級緩存 MyBatis 緩存配置之一級緩存 Redis for Windows(C#緩存)配置文件詳解 springmvc緩存和mybatis緩存 springmvc緩存和mybatis緩存 mybatis緩存 Mybatis配置文件
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM