詳解Java的MyBatis框架中SQL語句映射部分的編寫

更新時間：2016年04月06日 17:20:09 作者：limingnihao

這篇文章主要介紹了Java的MyBatis框架中SQL語句映射部分的編寫,文中分為resultMap和增刪查改實現(xiàn)兩個部分來講解,需要的朋友可以參考下

1.resultMap
SQL 映射XML 文件是所有sql語句放置的地方。需要定義一個workspace，一般定義為對應(yīng)的接口類的路徑。寫好SQL語句映射文件后，需要在MyBAtis配置文件mappers標(biāo)簽中引用，例如：

<mappers> 
  <mapper resource="com/liming/manager/data/mappers/UserMapper.xml" /> 
  <mapper resource="com/liming/manager/data/mappers/StudentMapper.xml" /> 
  <mapper resource="com/liming/manager/data/mappers/ClassMapper.xml" /> 
  <mapper resource="com/liming/manager/data/mappers/TeacherMapper.xml" /> 
</mappers>

當(dāng)Java接口與XML文件在一個相對路徑下時，可以不在myBatis配置文件的mappers中聲明。

SQL 映射XML 文件一些初級的元素：

（1）. cache – 配置給定模式的緩存
（2）. cache-ref – 從別的模式中引用一個緩存
（3）. resultMap – 這是最復(fù)雜而卻強大的一個元素了，它描述如何從結(jié)果集中加載對象
（4）. sql – 一個可以被其他語句復(fù)用的SQL 塊
（5）. insert – 映射INSERT 語句
（6）. update – 映射UPDATE 語句
（7）. delete – 映射DELEETE 語句
（8）. select - 映射SELECT語句

1.1 resultMap
resultMap 是MyBatis 中最重要最強大的元素了。你可以讓你比使用JDBC 調(diào)用結(jié)果集省掉90%的代碼，也可以讓你做許多JDBC 不支持的事?，F(xiàn)實上，要寫一個等同類似于交互的映射這樣的復(fù)雜語句，可能要上千行的代碼。ResultMaps的目的，就是這樣簡單的語句而不需要多余的結(jié)果映射，更多復(fù)雜的語句，除了只要一些絕對必須的語句描述關(guān)系以外，再也不需要其它的。
resultMap屬性：type為java實體類；id為此resultMap的標(biāo)識。

resultMap可以設(shè)置的映射：

（1）. constructor – 用來將結(jié)果反射給一個實例化好的類的構(gòu)造器
a) idArg – ID 參數(shù)；將結(jié)果集標(biāo)記為ID，以方便全局調(diào)用
b) arg –反射到構(gòu)造器的通常結(jié)果

（2）. id – ID 結(jié)果，將結(jié)果集標(biāo)記為ID，以方便全局調(diào)用

（3）. result – 反射到JavaBean 屬性的普通結(jié)果

（4）. association – 復(fù)雜類型的結(jié)合；多個結(jié)果合成的類型
a) nested result mappings – 幾resultMap 自身嵌套關(guān)聯(lián)，也可以引用到一個其它上

（5）. collection –復(fù)雜類型集合a collection of complex types

（6）. nested result mappings – resultMap 的集合，也可以引用到一個其它上

（7）. discriminator – 使用一個結(jié)果值以決定使用哪個resultMap
a) case – 基本一些值的結(jié)果映射的case 情形
i. nested result mappings –一個case 情形本身就是一個結(jié)果映射，因此也可以包括一些相同的元素，也可以引用一個外部resultMap。

1.1.1 id、result
id、result是最簡單的映射，id為主鍵映射；result其他基本數(shù)據(jù)庫表字段到實體類屬性的映射。
最簡單的例子：

<resultMap type="liming.student.manager.data.model.StudentEntity" id="studentResultMap"> 
  <id property="studentId"    column="STUDENT_ID" javaType="String" jdbcType="VARCHAR"/> 
  <result property="studentName"    column="STUDENT_NAME" javaType="String" jdbcType="VARCHAR"/> 
  <result property="studentSex"    column="STUDENT_SEX" javaType="int" jdbcType="INTEGER"/> 
  <result property="studentBirthday"  column="STUDENT_BIRTHDAY" javaType="Date" jdbcType="DATE"/> 
  <result property="studentPhoto" column="STUDENT_PHOTO" javaType="byte[]" jdbcType="BLOB" typeHandler="org.apache.ibatis.type.BlobTypeHandler" /> 
</resultMap>

id、result語句屬性配置細(xì)節(jié)：

屬性	描述
property	需要映射到JavaBean 的屬性名稱。
column	數(shù)據(jù)表的列名或者標(biāo)簽別名。
javaType	一個完整的類名，或者是一個類型別名。如果你匹配的是一個JavaBean，那MyBatis 通常會自行檢測到。然后，如果你是要映射到一個HashMap，那你需要指定javaType 要達(dá)到的目的。
jdbcType	數(shù)據(jù)表支持的類型列表。這個屬性只在insert,update 或delete 的時候針對允許空的列有用。JDBC 需要這項，但MyBatis 不需要。如果你是直接針對JDBC 編碼，且有允許空的列，而你要指定這項。
typeHandler	使用這個屬性可以覆寫類型處理器。這項值可以是一個完整的類名，也可以是一個類型別名。

支持的JDBC類型
為了將來的引用，MyBatis 支持下列JDBC 類型，通過JdbcType 枚舉：
BIT，F(xiàn)LOAT，CHAR，TIMESTAMP，OTHER，UNDEFINED，TINYINT，REAL，VARCHAR，BINARY，BLOB，NVARCHAR，SMALLINT，DOUBLE，LONGVARCHAR，VARBINARY，CLOB，NCHAR，INTEGER，NUMERIC，DATE，LONGVARBINARY，BOOLEAN，NCLOB，BIGINT，DECIMAL，TIME，NULL，CURSOR

1.1.2 constructor
我們使用id、result時候，需要定義java實體類的屬性映射到數(shù)據(jù)庫表的字段上。這個時候是使用JavaBean實現(xiàn)的。當(dāng)然我們也可以使用實體類的構(gòu)造方法來實現(xiàn)值的映射，這個時候是通過構(gòu)造方法參數(shù)的書寫的順序來進(jìn)行賦值的。使用construcotr功能有限（例如使用collection級聯(lián)查詢）。上面使用id、result實現(xiàn)的功能就可以改為：

<resultMap type="StudentEntity" id="studentResultMap" > 
  <constructor> 
    <idArg javaType="String" column="STUDENT_ID"/> 
    <arg javaType="String" column="STUDENT_NAME"/> 
    <arg javaType="String" column="STUDENT_SEX"/> 
    <arg javaType="Date" column="STUDENT_BIRTHDAY"/> 
  </constructor> 
</resultMap>

當(dāng)然，我們需要定義StudentEntity實體類的構(gòu)造方法：

public StudentEntity(String studentID, String studentName, String studentSex, Date studentBirthday){ 
  this.studentID = studentID; 
  this.studentName = studentName; 
  this.studentSex = studentSex; 
  this.studentBirthday = studentBirthday; 
}

1.1.3 association聯(lián)合
聯(lián)合元素用來處理“一對一”的關(guān)系。需要指定映射的Java實體類的屬性，屬性的javaType（通常MyBatis 自己會識別）。對應(yīng)的數(shù)據(jù)庫表的列名稱。如果想覆寫的話返回結(jié)果的值，需要指定typeHandler。
不同情況需要告訴MyBatis 如何加載一個聯(lián)合。MyBatis 可以用兩種方式加載：
（1）. select: 執(zhí)行一個其它映射的SQL 語句返回一個Java實體類型。較靈活；
（2）. resultsMap: 使用一個嵌套的結(jié)果映射來處理通過join查詢結(jié)果集，映射成Java實體類型。

例如，一個班級對應(yīng)一個班主任。
首先定義好班級中的班主任屬性：

private TeacherEntity teacherEntity;

1.1.3.1使用select實現(xiàn)聯(lián)合
例：班級實體類中有班主任的屬性，通過聯(lián)合在得到一個班級實體時，同時映射出班主任實體。
這樣可以直接復(fù)用在TeacherMapper.xml文件中定義好的查詢teacher根據(jù)其ID的select語句。而且不需要修改寫好的SQL語句，只需要直接修改resultMap即可。

ClassMapper.xml文件部分內(nèi)容：

<resultMap type="ClassEntity" id="classResultMap"> 
  <id property="classID" column="CLASS_ID" /> 
  <result property="className" column="CLASS_NAME" /> 
  <result property="classYear" column="CLASS_YEAR" /> 
  <association property="teacherEntity" column="TEACHER_ID" select="getTeacher"/> 
</resultMap> 
 
<select id="getClassByID" parameterType="String" resultMap="classResultMap"> 
  SELECT * FROM CLASS_TBL CT 
  WHERE CT.CLASS_ID = #{classID}; 
</select>

TeacherMapper.xml文件部分內(nèi)容：

<resultMap type="TeacherEntity" id="teacherResultMap"> 
  <id property="teacherID" column="TEACHER_ID" /> 
  <result property="teacherName" column="TEACHER_NAME" /> 
  <result property="teacherSex" column="TEACHER_SEX" /> 
  <result property="teacherBirthday" column="TEACHER_BIRTHDAY"/> 
  <result property="workDate" column="WORK_DATE"/> 
  <result property="professional" column="PROFESSIONAL"/> 
</resultMap> 
 
<select id="getTeacher" parameterType="String" resultMap="teacherResultMap"> 
  SELECT * 
   FROM TEACHER_TBL TT 
   WHERE TT.TEACHER_ID = #{teacherID} 
</select>

1.1.3.2使用resultMap實現(xiàn)聯(lián)合
與上面同樣的功能，查詢班級，同時查詢器班主任。需在association中添加resultMap（在teacher的xml文件中定義好的），新寫sql（查詢班級表left join教師表），不需要teacher的select。

修改ClassMapper.xml文件部分內(nèi)容：

<resultMap type="ClassEntity" id="classResultMap"> 
  <id property="classID" column="CLASS_ID" /> 
  <result property="className" column="CLASS_NAME" /> 
  <result property="classYear" column="CLASS_YEAR" /> 
  <association property="teacherEntity" column="TEACHER_ID" resultMap="teacherResultMap"/> 
</resultMap> 
 
<select id="getClassAndTeacher" parameterType="String" resultMap="classResultMap"> 
  SELECT * 
   FROM CLASS_TBL CT LEFT JOIN TEACHER_TBL TT ON CT.TEACHER_ID = TT.TEACHER_ID 
   WHERE CT.CLASS_ID = #{classID}; 
</select>

其中的teacherResultMap請見上面TeacherMapper.xml文件部分內(nèi)容中。

1.1.4 collection聚集
聚集元素用來處理“一對多”的關(guān)系。需要指定映射的Java實體類的屬性，屬性的javaType（一般為ArrayList）；列表中對象的類型ofType（Java實體類）；對應(yīng)的數(shù)據(jù)庫表的列名稱；
不同情況需要告訴MyBatis 如何加載一個聚集。MyBatis 可以用兩種方式加載：
（1）. select: 執(zhí)行一個其它映射的SQL 語句返回一個Java實體類型。較靈活；
（2）. resultsMap: 使用一個嵌套的結(jié)果映射來處理通過join查詢結(jié)果集，映射成Java實體類型。
例如，一個班級有多個學(xué)生。
首先定義班級中的學(xué)生列表屬性：
private List<StudentEntity> studentList;
1.1.4.1使用select實現(xiàn)聚集
用法和聯(lián)合很類似，區(qū)別在于，這是一對多，所以一般映射過來的都是列表。所以這里需要定義javaType為ArrayList，還需要定義列表中對象的類型ofType，以及必須設(shè)置的select的語句名稱（需要注意的是，這里的查詢student的select語句條件必須是外鍵classID）。
ClassMapper.xml文件部分內(nèi)容：

<resultMap type="ClassEntity" id="classResultMap"> 
  <id property="classID" column="CLASS_ID" /> 
  <result property="className" column="CLASS_NAME" /> 
  <result property="classYear" column="CLASS_YEAR" /> 
  <association property="teacherEntity" column="TEACHER_ID" select="getTeacher"/> 
  <collection property="studentList" column="CLASS_ID" javaType="ArrayList" ofType="StudentEntity" select="getStudentByClassID"/> 
</resultMap> 
 
<select id="getClassByID" parameterType="String" resultMap="classResultMap"> 
  SELECT * FROM CLASS_TBL CT 
  WHERE CT.CLASS_ID = #{classID}; 
</select>

StudentMapper.xml文件部分內(nèi)容：

<!-- java屬性，數(shù)據(jù)庫表字段之間的映射定義 --> 
<resultMap type="StudentEntity" id="studentResultMap"> 
  <id property="studentID" column="STUDENT_ID" /> 
  <result property="studentName" column="STUDENT_NAME" /> 
  <result property="studentSex" column="STUDENT_SEX" /> 
  <result property="studentBirthday" column="STUDENT_BIRTHDAY" /> 
</resultMap> 
 
<!-- 查詢學(xué)生list，根據(jù)班級id --> 
<select id="getStudentByClassID" parameterType="String" resultMap="studentResultMap"> 
  <include refid="selectStudentAll" /> 
  WHERE ST.CLASS_ID = #{classID} 
</select>

1.1.4.2使用resultMap實現(xiàn)聚集
使用resultMap，就需要重寫一個sql，left join學(xué)生表。

<resultMap type="ClassEntity" id="classResultMap"> 
  <id property="classID" column="CLASS_ID" /> 
  <result property="className" column="CLASS_NAME" /> 
  <result property="classYear" column="CLASS_YEAR" /> 
  <association property="teacherEntity" column="TEACHER_ID" resultMap="teacherResultMap"/> 
  <collection property="studentList" column="CLASS_ID" javaType="ArrayList" ofType="StudentEntity" resultMap="studentResultMap"/> 
</resultMap> 
 
<select id="getClassAndTeacherStudent" parameterType="String" resultMap="classResultMap"> 
  SELECT * 
   FROM CLASS_TBL CT 
      LEFT JOIN STUDENT_TBL ST 
       ON CT.CLASS_ID = ST.CLASS_ID 
      LEFT JOIN TEACHER_TBL TT 
       ON CT.TEACHER_ID = TT.TEACHER_ID 
   WHERE CT.CLASS_ID = #{classID}; 
</select>

其中的teacherResultMap請見上面TeacherMapper.xml文件部分內(nèi)容中。studentResultMap請見上面StudentMapper.xml文件部分內(nèi)容中。
1.1.5discriminator鑒別器
有時一個單獨的數(shù)據(jù)庫查詢也許返回很多不同（但是希望有些關(guān)聯(lián)）數(shù)據(jù)類型的結(jié)果集。鑒別器元素就是被設(shè)計來處理這個情況的，還有包括類的繼承層次結(jié)構(gòu)。鑒別器非常容易理解，因為它的表現(xiàn)很像Java語言中的switch語句。
定義鑒別器指定了column和javaType屬性。列是MyBatis查找比較值的地方。JavaType是需要被用來保證等價測試的合適類型（盡管字符串在很多情形下都會有用）。
下面這個例子為，當(dāng)classId為20000001時，才映射classId屬性。

<resultMap type="liming.student.manager.data.model.StudentEntity" id="resultMap_studentEntity_discriminator"> 
  <id property="studentId"    column="STUDENT_ID" javaType="String" jdbcType="VARCHAR"/> 
  <result property="studentName"    column="STUDENT_NAME" javaType="String" jdbcType="VARCHAR"/> 
  <result property="studentSex"    column="STUDENT_SEX" javaType="int" jdbcType="INTEGER"/> 
  <result property="studentBirthday"  column="STUDENT_BIRTHDAY" javaType="Date" jdbcType="DATE"/> 
  <result property="studentPhoto" column="STUDENT_PHOTO" javaType="byte[]" jdbcType="BLOB" typeHandler="org.apache.ibatis.type.BlobTypeHandler" /> 
  <result property="placeId"      column="PLACE_ID" javaType="String" jdbcType="VARCHAR"/> 
  <discriminator column="CLASS_ID" javaType="String" jdbcType="VARCHAR"> 
    <case value="20000001" resultType="liming.student.manager.data.model.StudentEntity" > 
      <result property="classId" column="CLASS_ID" javaType="String" jdbcType="VARCHAR"/> 
    </case> 
  </discriminator> 
</resultMap>

2.增刪改查、參數(shù)、緩存

2.1 select
一個select 元素非常簡單。例如：

<!-- 查詢學(xué)生，根據(jù)id --> 
<select id="getStudent" parameterType="String" resultMap="studentResultMap"> 
  SELECT ST.STUDENT_ID, 
        ST.STUDENT_NAME, 
        ST.STUDENT_SEX, 
        ST.STUDENT_BIRTHDAY, 
        ST.CLASS_ID 
     FROM STUDENT_TBL ST 
     WHERE ST.STUDENT_ID = #{studentID} 
</select>

這條語句就叫做‘getStudent，有一個String參數(shù)，并返回一個StudentEntity類型的對象。
注意參數(shù)的標(biāo)識是：#{studentID}。

select 語句屬性配置細(xì)節(jié)：

屬性	描述	取值	默認(rèn)
id	在這個模式下唯一的標(biāo)識符，可被其它語句引用
parameterType	傳給此語句的參數(shù)的完整類名或別名
resultType	語句返回值類型的整類名或別名。注意，如果是集合，那么這里填寫的是集合的項的整類名或別名，而不是集合本身的類名。（resultType 與resultMap 不能并用）
resultMap	引用的外部resultMap 名。結(jié)果集映射是MyBatis 中最強大的特性。許多復(fù)雜的映射都可以輕松解決。（resultType 與resultMap 不能并用）
flushCache	如果設(shè)為true，則會在每次語句調(diào)用的時候就會清空緩存。select 語句默認(rèn)設(shè)為false	true\|false	false
useCache	如果設(shè)為true，則語句的結(jié)果集將被緩存。select 語句默認(rèn)設(shè)為false true\|false false timeout 設(shè)置驅(qū)動器在拋出異常前等待回應(yīng)的最長時間，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	true\|false	false
timeout	設(shè)置驅(qū)動器在拋出異常前等待回應(yīng)的最長時間，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	正整數(shù)	未設(shè)置
fetchSize	設(shè)置一個值后，驅(qū)動器會在結(jié)果集數(shù)目達(dá)到此數(shù)值后，激發(fā)返回，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	正整數(shù)	驅(qū)動器決定
statementType	statement，preparedstatement，callablestatement。預(yù)準(zhǔn)備語句、可調(diào)用語句	STATEMENT PREPARED CALLABLE	PREPARED
resultSetType	forward_only，scroll_sensitive，scroll_insensitive 只轉(zhuǎn)發(fā)，滾動敏感，不區(qū)分大小寫的滾動	FORWARD_ONLY SCROLL_SENSITIVE SCROLL_INSENSITIVE	驅(qū)動器決定

2.2 insert
一個簡單的insert語句：

<!-- 插入學(xué)生 --> 
<insert id="insertStudent" parameterType="StudentEntity"> 
    INSERT INTO STUDENT_TBL (STUDENT_ID, 
                     STUDENT_NAME, 
                     STUDENT_SEX, 
                     STUDENT_BIRTHDAY, 
                     CLASS_ID) 
       VALUES  (#{studentID}, 
             #{studentName}, 
             #{studentSex}, 
             #{studentBirthday}, 
             #{classEntity.classID}) 
</insert>

insert可以使用數(shù)據(jù)庫支持的自動生成主鍵策略，設(shè)置useGeneratedKeys=”true”，然后把keyProperty 設(shè)成對應(yīng)的列，就搞定了。比如說上面的StudentEntity 使用auto-generated 為id 列生成主鍵.還可以使用selectKey元素。下面例子，使用mysql數(shù)據(jù)庫nextval('student')為自定義函數(shù)，用來生成一個key。

<!-- 插入學(xué)生 自動主鍵--> 
<insert id="insertStudentAutoKey" parameterType="StudentEntity"> 
  <selectKey keyProperty="studentID" resultType="String" order="BEFORE"> 
      select nextval('student') 
  </selectKey> 
    INSERT INTO STUDENT_TBL (STUDENT_ID, 
                 STUDENT_NAME, 
                 STUDENT_SEX, 
                 STUDENT_BIRTHDAY, 
                 CLASS_ID) 
       VALUES  (#{studentID}, 
            #{studentName}, 
            #{studentSex}, 
            #{studentBirthday}, 
            #{classEntity.classID})   
</insert>

insert語句屬性配置細(xì)節(jié)：

屬性	描述	取值	默認(rèn)
id	在這個模式下唯一的標(biāo)識符，可被其它語句引用
parameterType	傳給此語句的參數(shù)的完整類名或別名
flushCache	如果設(shè)為true，則會在每次語句調(diào)用的時候就會清空緩存。select 語句默認(rèn)設(shè)為false	true\|false	false
useCache	如果設(shè)為true，則語句的結(jié)果集將被緩存。select 語句默認(rèn)設(shè)為false true\|false false timeout 設(shè)置驅(qū)動器在拋出異常前等待回應(yīng)的最長時間，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	true\|false	false
timeout	設(shè)置驅(qū)動器在拋出異常前等待回應(yīng)的最長時間，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	正整數(shù)	未設(shè)置
fetchSize	設(shè)置一個值后，驅(qū)動器會在結(jié)果集數(shù)目達(dá)到此數(shù)值后，激發(fā)返回，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	正整數(shù)	驅(qū)動器決定
statementType	statement，preparedstatement，callablestatement。預(yù)準(zhǔn)備語句、可調(diào)用語句	STATEMENT PREPARED CALLABLE	PREPARED
useGeneratedKeys	告訴MyBatis 使用JDBC 的getGeneratedKeys 方法來獲取數(shù)據(jù)庫自己生成的主鍵（MySQL、SQLSERVER 等關(guān)系型數(shù)據(jù)庫會有自動生成的字段）。默認(rèn)：false	true\|false	false
keyProperty	標(biāo)識一個將要被MyBatis 設(shè)置進(jìn)getGeneratedKeys 的key 所返回的值，或者為insert 語句使用一個selectKey 子元素。

selectKey語句屬性配置細(xì)節(jié)：

屬性	描述	取值
keyProperty	selectKey 語句生成結(jié)果需要設(shè)置的屬性。
resultType	生成結(jié)果類型，MyBatis 允許使用基本的數(shù)據(jù)類型，包括String 、int類型。
order	可以設(shè)成BEFORE 或者AFTER，如果設(shè)為BEFORE，那它會先選擇主鍵，然后設(shè)置keyProperty，再執(zhí)行insert語句；如果設(shè)為AFTER，它就先運行insert 語句再運行selectKey 語句，通常是insert 語句中內(nèi)部調(diào)用數(shù)據(jù)庫（像Oracle）內(nèi)嵌的序列機制。	BEFORE AFTER
statementType	像上面的那樣， MyBatis 支持STATEMENT，PREPARED和CALLABLE 的語句形式，對應(yīng)Statement ，PreparedStatement 和CallableStatement 響應(yīng)	STATEMENT PREPARED CALLABLE

2.3 update、delete
一個簡單的update：

<!-- 更新學(xué)生信息 --> 
<update id="updateStudent" parameterType="StudentEntity"> 
    UPDATE STUDENT_TBL 
      SET STUDENT_TBL.STUDENT_NAME = #{studentName},  
        STUDENT_TBL.STUDENT_SEX = #{studentSex}, 
        STUDENT_TBL.STUDENT_BIRTHDAY = #{studentBirthday}, 
        STUDENT_TBL.CLASS_ID = #{classEntity.classID} 
     WHERE STUDENT_TBL.STUDENT_ID = #{studentID};   
</update>

一個簡單的delete：

<!-- 刪除學(xué)生 --> 
<delete id="deleteStudent" parameterType="StudentEntity"> 
    DELETE FROM STUDENT_TBL WHERE STUDENT_ID = #{studentID} 
</delete>

update、delete語句屬性配置細(xì)節(jié)：

屬性	描述	取值	默認(rèn)
id	在這個模式下唯一的標(biāo)識符，可被其它語句引用
parameterType	傳給此語句的參數(shù)的完整類名或別名
flushCache	如果設(shè)為true，則會在每次語句調(diào)用的時候就會清空緩存。select 語句默認(rèn)設(shè)為false	true\|false	false
useCache	如果設(shè)為true，則語句的結(jié)果集將被緩存。select 語句默認(rèn)設(shè)為false true\|false false timeout 設(shè)置驅(qū)動器在拋出異常前等待回應(yīng)的最長時間，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	true\|false	false
timeout	設(shè)置驅(qū)動器在拋出異常前等待回應(yīng)的最長時間，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	正整數(shù)	未設(shè)置
fetchSize	設(shè)置一個值后，驅(qū)動器會在結(jié)果集數(shù)目達(dá)到此數(shù)值后，激發(fā)返回，默認(rèn)為不設(shè)值，由驅(qū)動器自己決定	正整數(shù)	驅(qū)動器決定
statementType	statement，preparedstatement，callablestatement。預(yù)準(zhǔn)備語句、可調(diào)用語句	STATEMENT PREPARED CALLABLE	PREPARED

2.4 sql
Sql元素用來定義一個可以復(fù)用的SQL 語句段，供其它語句調(diào)用。比如：

<!-- 復(fù)用sql語句 查詢student表所有字段 --> 
<sql id="selectStudentAll"> 
    SELECT ST.STUDENT_ID, 
          ST.STUDENT_NAME, 
          ST.STUDENT_SEX, 
          ST.STUDENT_BIRTHDAY, 
          ST.CLASS_ID 
       FROM STUDENT_TBL ST 
</sql>

這樣，在select的語句中就可以直接引用使用了，將上面select語句改成：

<!-- 查詢學(xué)生，根據(jù)id --> 
<select id="getStudent" parameterType="String" resultMap="studentResultMap"> 
  <include refid="selectStudentAll"/> 
      WHERE ST.STUDENT_ID = #{studentID}  
</select>

2.5 parameters
        上面很多地方已經(jīng)用到了參數(shù)，比如查詢、修改、刪除的條件，插入，修改的數(shù)據(jù)等，MyBatis可以使用的基本數(shù)據(jù)類型和Java的復(fù)雜數(shù)據(jù)類型。
        基本數(shù)據(jù)類型，String，int，date等。
        但是使用基本數(shù)據(jù)類型，只能提供一個參數(shù)，所以需要使用Java實體類，或Map類型做參數(shù)類型。通過#{}可以直接得到其屬性。
2.5.1 基本類型參數(shù)
根據(jù)入學(xué)時間，檢索學(xué)生列表：

<!-- 查詢學(xué)生list，根據(jù)入學(xué)時間 --> 
<select id="getStudentListByDate" parameterType="Date" resultMap="studentResultMap"> 
  SELECT * 
   FROM STUDENT_TBL ST LEFT JOIN CLASS_TBL CT ON ST.CLASS_ID = CT.CLASS_ID 
   WHERE CT.CLASS_YEAR = #{classYear};   
</select>

List<StudentEntity> studentList = studentMapper.getStudentListByClassYear(StringUtil.parse("2007-9-1")); 
for (StudentEntity entityTemp : studentList) { 
  System.out.println(entityTemp.toString()); 
}

2.5.2 Java實體類型參數(shù)
根據(jù)姓名和性別，檢索學(xué)生列表。使用實體類做參數(shù)：

<!-- 查詢學(xué)生list，like姓名、=性別，參數(shù)entity類型 --> 
<select id="getStudentListWhereEntity" parameterType="StudentEntity" resultMap="studentResultMap"> 
  SELECT * from STUDENT_TBL ST 
    WHERE ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName}),'%') 
     AND ST.STUDENT_SEX = #{studentSex} 
</select>

StudentEntity entity = new StudentEntity(); 
entity.setStudentName("李"); 
entity.setStudentSex("男"); 
List<StudentEntity> studentList = studentMapper.getStudentListWhereEntity(entity); 
for (StudentEntity entityTemp : studentList) { 
  System.out.println(entityTemp.toString()); 
}

2.5.3Map參數(shù)
根據(jù)姓名和性別，檢索學(xué)生列表。使用Map做參數(shù)：

<!-- 查詢學(xué)生list，=性別，參數(shù)map類型 --> 
<select id="getStudentListWhereMap" parameterType="Map" resultMap="studentResultMap"> 
  SELECT * from STUDENT_TBL ST 
   WHERE ST.STUDENT_SEX = #{sex} 
     AND ST.STUDENT_SEX = #{sex} 
</select>

Map<String, String> map = new HashMap<String, String>(); 
map.put("sex", "女"); 
map.put("name", "李"); 
List<StudentEntity> studentList = studentMapper.getStudentListWhereMap(map); 
for (StudentEntity entityTemp : studentList) { 
  System.out.println(entityTemp.toString()); 
}

2.5.4多參數(shù)的實現(xiàn)
如果想傳入多個參數(shù)，則需要在接口的參數(shù)上添加@Param注解。給出一個實例：
接口寫法：

public List<StudentEntity> getStudentListWhereParam(@Param(value = "name") String name, @Param(value = "sex") String sex, @Param(value = "birthday") Date birthdar, @Param(value = "classEntity") ClassEntity classEntity);

SQL寫法：

<!-- 查詢學(xué)生list，like姓名、=性別、=生日、=班級，多參數(shù)方式 --> 
<select id="getStudentListWhereParam" resultMap="studentResultMap"> 
  SELECT * from STUDENT_TBL ST 
  <where> 
    <if test="name!=null and name!='' "> 
      ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{name}),'%') 
    </if> 
    <if test="sex!= null and sex!= '' "> 
      AND ST.STUDENT_SEX = #{sex} 
    </if> 
    <if test="birthday!=null"> 
      AND ST.STUDENT_BIRTHDAY = #{birthday} 
    </if> 
    <if test="classEntity!=null and classEntity.classID !=null and classEntity.classID!='' "> 
      AND ST.CLASS_ID = #{classEntity.classID} 
    </if> 
  </where> 
</select>

進(jìn)行查詢：

List<StudentEntity> studentList = studentMapper.getStudentListWhereParam("", "",StringUtil.parse("1985-05-28"), classMapper.getClassByID("20000002")); 
for (StudentEntity entityTemp : studentList) { 
  System.out.println(entityTemp.toString()); 
}

2.5.5字符串代入法
默認(rèn)的情況下，使用#{}語法會促使MyBatis 生成PreparedStatement 屬性并且使用PreparedStatement 的參數(shù)（=？）來安全的設(shè)置值。盡量這些是快捷安全，也是經(jīng)常使用的。但有時候你可能想直接未更改的字符串代入到SQL 語句中。比如說，對于ORDER BY，你可能會這樣使用：ORDER BY ${columnName}但MyBatis 不會修改和規(guī)避掉這個字符串。
注意：這樣地接收和應(yīng)用一個用戶輸入到未更改的語句中，是非常不安全的。這會讓用戶能植入破壞代碼，所以，要么要求字段不要允許客戶輸入，要么你直接來檢測他的合法性。
2.6 cache緩存

MyBatis 包含一個強在的、可配置、可定制的緩存機制。MyBatis 3 的緩存實現(xiàn)有了許多改進(jìn)，既強勁也更容易配置。默認(rèn)的情況，緩存是沒有開啟，除了會話緩存以外，它可以提高性能，且能解決全局依賴。開啟二級緩存，你只需要在SQL 映射文件中加入簡單的一行：<cache/>

這句簡單的語句的作用如下：
（1）. 所有在映射文件里的select 語句都將被緩存。
（2）. 所有在映射文件里insert,update 和delete 語句會清空緩存。
（3）. 緩存使用“最近很少使用”算法來回收
（4）. 緩存不會被設(shè)定的時間所清空。
（5）. 每個緩存可以存儲1024 個列表或?qū)ο蟮囊茫ú还懿樵兂鰜淼慕Y(jié)果是什么）。
（6）. 緩存將作為“讀/寫”緩存，意味著獲取的對象不是共享的且對調(diào)用者是安全的。不會有其它的調(diào)用
（7）. 者或線程潛在修改。

例如，創(chuàng)建一個FIFO 緩存讓60 秒就清空一次，存儲512 個對象結(jié)果或列表引用，并且返回的結(jié)果是只讀。因為在不用的線程里的兩個調(diào)用者修改它們可能會導(dǎo)致引用沖突。

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"> 
</cache>

還可以在不同的命名空間里共享同一個緩存配置或者實例。在這種情況下，你就可以使用cache-ref 來引用另外一個緩存。
<cache-ref namespace="com.liming.manager.data.StudentMapper"/>

Cache 語句屬性配置細(xì)節(jié)：

屬性	說明	取值	默認(rèn)值
eviction	緩存策略： LRU - 最近最少使用法：移出最近較長周期內(nèi)都沒有被使用的對象。 FIFI- 先進(jìn)先出：移出隊列里較早的對象 SOFT - 軟引用：基于軟引用規(guī)則，使用垃圾回收機制來移出對象 WEAK - 弱引用：基于弱引用規(guī)則，使用垃圾回收機制來強制性地移出對象	LRU FIFI SOFT WEAK	LRU
flushInterval	代表一個合理的毫秒總計時間。默認(rèn)是不設(shè)置，因此使用無間隔清空即只能調(diào)用語句來清空。	正整數(shù)	不設(shè)置
size	緩存的對象的大小	正整數(shù)	1024
readOnly	只讀緩存將對所有調(diào)用者返回同一個實例。因此都不能被修改，這可以極大的提高性能?？蓪懙木彺鎸⑼ㄟ^序列化來返回一個緩存對象的拷貝。這會比較慢，但是比較安全。所以默認(rèn)值是false。	true\|false	false