Mybatis中parameterType、resultMap、statementType等等配置詳解(標簽中基本配置詳解)

一、（轉自：https://blog.csdn.net/majinggogogo/article/details/72123185）

映射文件是以<mapper>作為根節點，在根節點中支持9個元素，分別為insert、update、delete、select（增刪改查）;cache、cache-ref、resultMap、parameterMap、sql。

下文中，我們將首先對增刪改進行描述，然后對查進行詳細說明，最后對其他五個元素進行簡單說明。

（1）insert、update、delete

 

<delete id="deleteByPrimaryKey" parameterType="java.lang.String" >
    delete from product where product_id = #{productId,jdbcType=VARCHAR}
</delete>
 <insert id="insert" parameterType="pojo.Product" >
    insert into product (product_id, product_factroy, product_store, product_descript)
    values (#{productId,jdbcType=VARCHAR}, #{productFactroy,jdbcType=VARCHAR}, #{productStore,jdbcType=INTEGER}, #{productDescript,jdbcType=VARCHAR})
 </insert>

 

 

<?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對應一個dao -->
<mapper namespace="com.dy.dao.UserDao">
 
    <insert
      <!-- 1. id （必須配置）
        一個命名空間（namespace） 對應一個dao接口（id是命名空間中的唯一標識符，可被用來代表這條語句）, 
        這個id也應該對應dao里面的某個方法（相當於方法的實現implement），因此id 應該與方法名一致 -->
      
      id="addUser"
      
      <!-- 2. parameterType （可選配置, 默認為mybatis自動選擇處理）
        將要傳入語句的參數的完全限定類名或別名， 如果不配置，mybatis會通過ParameterHandler 根據參數類型默認選擇合適的typeHandler進行處理
        parameterType 主要指定參數類型，可以是int, short, long, string等類型，也可以是復雜類型（如對象） -->
      
      parameterType="user"
      
      <!-- 3. flushCache （可選配置，默認配置為true）
        將其設置為 true，任何時候只要語句被調用，都會導致本地緩存和二級緩存都會被清空，默認值：true（對應插入、更新和刪除語句） -->
      
      flushCache="true"
      
      <!-- 4. statementType （可選配置，默認配置為PREPARED）
        STATEMENT，PREPARED 或 CALLABLE 的一個。這會讓 MyBatis 分別使用 Statement，PreparedStatement 或 CallableStatement，默認值：PREPARED。 -->
      
      statementType="PREPARED"
      
      <!-- 5. keyProperty (可選配置， 默認為unset)
        （僅對 insert 和 update 有用）唯一標記一個屬性，MyBatis 會通過 getGeneratedKeys 的返回值或者通過 insert 語句的 selectKey 子元素設置它的鍵值，默認：unset。如果希望得到多個生成的列，也可以是逗號分隔的屬性名稱列表。 -->
      
      keyProperty=""
      
      <!-- 6. keyColumn     (可選配置)
        （僅對 insert 和 update 有用）通過生成的鍵值設置表中的列名，這個設置僅在某些數據庫（像 PostgreSQL）是必須的，當主鍵列不是表中的第一列的時候需要設置。如果希望得到多個生成的列，也可以是逗號分隔的屬性名稱列表。 -->
      
      keyColumn=""
      
      <!-- 7. useGeneratedKeys (可選配置， 默認為false)
        （僅對 insert 和 update 有用）這會令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法來取出由數據庫內部生成的主鍵（比如：像 MySQL 和 SQL Server 這樣的關系數據庫管理系統的自動遞增字段），默認值：false。  -->
      
      useGeneratedKeys="false"
      
      <!-- 8. timeout  (可選配置， 默認為unset, 依賴驅動)
        這個設置是在拋出異常之前，驅動程序等待數據庫返回請求結果的秒數。默認值為 unset（依賴驅動）。 -->
      timeout="20">
 
    <update
      id="updateUser"
      parameterType="user"
      flushCache="true"
      statementType="PREPARED"
      timeout="20">
 
    <delete
      id="deleteUser"
      parameterType="user"
      flushCache="true"
      statementType="PREPARED"
      timeout="20">
</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.majing.learning.mybatis.dao.UserDao">
    
    <insert id="addUser" parameterType="user" useGeneratedKeys="true" keyProperty="id">
        insert into user(name,password,age) values(#{name},#{password},#{age})
    </insert>
    
    <delete id="deleteUser" parameterType="int">
        delete from user where id = #{id}
    </delete>
    
    <update id="updateUser" parameterType="user" >
        update user set name = #{name}, password = #{password}, age = #{age} where id = #{id}
    </update>
    
    
 
</mapper>

這里的parameterType設置成user是因為如果不設置的情況下，會自動將類名首字母小寫后的名稱，原來的類名為User。不過，建議大家還是使用typeAlias進行配置吧。唯一需要說明的就是<insert>元素里面的useGeneratedKeys和keyProperties屬性，這兩個屬性是用來獲取數據庫中的主鍵的。

在數據庫里面經常性的會給數據庫表設置一個自增長的列作為主鍵，如果我們操作數據庫后希望能夠獲取這個主鍵該怎么弄呢？正如上面所述，如果是支持自增長的數據庫，如mysql數據庫，那么只需要設置useGeneratedKeys和keyProperties屬性便可以了，但是對於不支持自增長的數據庫（如oracle）該怎么辦呢？

mybatis里面在<insert>元素下面提供了<selectKey>子元素用於幫助解決這個問題。來看下配置：

<selectKey
        <!-- selectKey 語句結果應該被設置的目標屬性。如果希望得到多個生成的列，也可以是逗號分隔的屬性名稱列表。 -->
        keyProperty="id"
        <!-- 結果的類型。MyBatis 通常可以推算出來，但是為了更加確定寫上也不會有什么問題。MyBatis 允許任何簡單類型用作主鍵的類型，包括字符串。如果希望作用於多個生成的列，則可以使用一個包含期望屬性的 Object 或一個 Map。 -->
        resultType="int"
        <!-- 這可以被設置為 BEFORE 或 AFTER。如果設置為 BEFORE，那么它會首先選擇主鍵，設置 keyProperty 然后執行插入語句。如果設置為 AFTER，那么先執行插入語句，然后是 selectKey 元素 - 這和像 Oracle 的數據庫相似，在插入語句內部可能有嵌入索引調用。 -->
        order="BEFORE"
        <!-- 與前面相同，MyBatis 支持 STATEMENT，PREPARED 和 CALLABLE 語句的映射類型，分別代表 PreparedStatement 和 CallableStatement 類型。 -->
        statementType="PREPARED">
</selectKey>

針對不能使用自增長特性的數據庫，可以使用下面的配置來實現相同的功能：

<insert id="insertUser" parameterType="com.dy.entity.User">
           <!-- oracle等不支持id自增長的，可根據其id生成策略，先獲取id -->
           
        <selectKey resultType="int" order="BEFORE" keyProperty="id">
              select seq_user_id.nextval as id from dual
        </selectKey>
  
           insert into user(id, name, password, age, deleteFlag) 
               values(#{id}, #{name}, #{password}, #{age}, #{deleteFlag})
   </insert>

（2）select、resultType、resultMap

我們先來看看select元素都有哪些配置可以設置：

<select
        <!--  1. id （必須配置）
        id是命名空間中的唯一標識符，可被用來代表這條語句。 
        一個命名空間（namespace） 對應一個dao接口, 
        這個id也應該對應dao里面的某個方法（相當於方法的實現），因此id 應該與方法名一致  -->
     
     id="findUserById"
     
     <!-- 2. parameterType （可選配置, 默認為mybatis自動選擇處理）
        將要傳入語句的參數的完全限定類名或別名， 如果不配置，mybatis會通過ParameterHandler 根據參數類型默認選擇合適的typeHandler進行處理
        parameterType 主要指定參數類型，可以是int, short, long, string等類型，也可以是復雜類型（如對象） -->
     parameterType="int"
     
     <!-- 3. resultType (resultType 與 resultMap 二選一配置)
         resultType用以指定返回類型，指定的類型可以是基本類型，可以是java容器，也可以是javabean -->
     resultType="User"
     
     <!-- 4. resultMap (resultType 與 resultMap 二選一配置)
         resultMap用於引用我們通過 resultMap標簽定義的映射類型，這也是mybatis組件高級復雜映射的關鍵 -->
     resultMap="userResultMap"
     
     <!-- 5. flushCache (可選配置)
         將其設置為 true，任何時候只要語句被調用，都會導致本地緩存和二級緩存都會被清空，默認值：false -->
     flushCache="false"
     
     <!-- 6. useCache (可選配置)
         將其設置為 true，將會導致本條語句的結果被二級緩存，默認值：對 select 元素為 true -->
     useCache="true"
     
     <!-- 7. timeout (可選配置) 
         這個設置是在拋出異常之前，驅動程序等待數據庫返回請求結果的秒數。默認值為 unset（依賴驅動）-->
     timeout="10000"
     
     <!-- 8. fetchSize (可選配置) 
         這是嘗試影響驅動程序每次批量返回的結果行數和這個設置值相等。默認值為 unset（依賴驅動)-->
     fetchSize="256"
     
     <!-- 9. statementType (可選配置) 
         STATEMENT，PREPARED 或 CALLABLE 的一個。這會讓 MyBatis 分別使用 Statement，PreparedStatement 或 CallableStatement，默認值：PREPARED-->
     statementType="PREPARED"
     
     <!-- 10. resultSetType (可選配置) 
         FORWARD_ONLY，SCROLL_SENSITIVE 或 SCROLL_INSENSITIVE 中的一個，默認值為 unset （依賴驅動）-->
     resultSetType="FORWARD_ONLY">

我們還是從具體的示例來看看，

<select id="findUserById" resultType="User">
    select * from user where id = #{id}
</select>

這里我們根據用戶id去查詢這個用戶的信息，resultType=User是一個別名，如果我們接觸到的是這種一對一的問題，那么可以簡單的定義一個實體，這個實體代表數據庫表中的一條記錄即可。但是如果我們遇到一對多的問題呢，就拿這里的查詢用戶信息來說，如果每個用戶有各種興趣，需要維護每個用戶的興趣信息，那么我們可能就存在下面的數據表結構：

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  `age` int(3) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=15 DEFAULT CHARSET=utf8;
 
CREATE TABLE `userinterests` (
  `userid` int(11) DEFAULT NULL,
  `interestid` int(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
CREATE TABLE `interests` (
  `interestid` int(11) NOT NULL,
  `interestname` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`interestid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

其中user表用於記錄用戶信息，interests表用於維護所有的興趣標簽，而userinterests用於維護每個用戶的興趣情況。

這時候，如果我們需要根據用戶id去查詢用戶的信息和興趣信息該怎么做呢？這時候我們就要用到<select>中的另一個重要屬性了，那就是resultMap。

在配置查詢的返回結果時，resultType和resultMap是二選一的操作。對於比較復雜的查詢結果，一般都會設置成resultMap。

resultMap該怎么配置呢？又支持哪些配置呢？我們看看下面：

<resultMap type="" id="">
    
        <!-- id, 唯一性，注意啦，這個id用於標示這個javabean對象的唯一性， 不一定會是數據庫的主鍵（不要把它理解為數據庫對應表的主鍵） 
            property屬性對應javabean的屬性名，column對應數據庫表的列名
            （這樣，當javabean的屬性與數據庫對應表的列名不一致的時候，就能通過指定這個保持正常映射了）
        -->
        <id property="" column=""/>
        
        <!-- result與id相比， 對應普通屬性 -->    
        <result property="" column=""/>
        
        <!-- 
            constructor對應javabean中的構造方法
         -->
        <constructor>
            <!-- idArg 對應構造方法中的id參數 -->
            <idArg column=""/>
            <!-- arg 對應構造方法中的普通參數 -->
            <arg column=""/>
        </constructor>
        
        <!-- 
            collection，對應javabean中容器類型, 是實現一對多的關鍵 
            property 為javabean中容器對應字段名
            column 為體現在數據庫中列名
            ofType 就是指定javabean中容器指定的類型
        -->
        <collection property="" column="" ofType=""></collection>
        
        <!-- 
            association 為關聯關系，是實現N對一的關鍵。
            property 為javabean中容器對應字段名
            column 為體現在數據庫中列名
            javaType 指定關聯的類型
         -->
        <association property="" column="" javaType=""></association>
</resultMap>

根據上面的說明，我們來看看之前的問題怎么解決？

先截圖給出三個表的數據情況：

實體類：略（User2, Interests）

package com.majing.learning.mybatis.dao;
 
import com.majing.learning.mybatis.entity.User2;
 
public interface UserDao2 {
    /**
     * 查詢
     * @param userId
     * @return
     */
    User2 findUserById (int userId);
}

然后，我們給相關實體類創建一下別名：

<typeAliases>
        <typeAlias alias="UserWithInterests" type="com.majing.learning.mybatis.entity.User2"/>
        <typeAlias alias="Interests" type="com.majing.learning.mybatis.entity.Interests"/>
</typeAliases>

然后再創建一個對應跟UserDao2對應的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.majing.learning.mybatis.dao.UserDao2">
 
    <resultMap type="UserWithInterests" id="UserWithInterestsMap">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="password" column="password"/>
        <result property="age" column="age"/>
        <collection property="interests" column="interestname" ofType="Interests">
            <id property="id" column="interestid"/>
            <result property="name" column="interestname"/>
        </collection>
    </resultMap>
 
    <select id="findUserById" resultMap="UserWithInterestsMap">
        select a.*,c.* from user as a right join userinterests as b on a.id = b.userid right join interests as c on b.interestid = c.interestid where id = #{id}
    </select>
 
</mapper>

最后將這個映射文件添加到<mappers>元素配置下：

<mappers>
        <mapper resource="com\majing\learning\mybatis\dao\UserDaoMapper.xml" />
        <mapper resource="com\majing\learning\mybatis\dao\UserDao2Mapper.xml" />
</mappers>

運行：

public class UserDaoTest3 {
    @Test
    public void testFindUserById(){
        SqlSession sqlSession = getSessionFactory().openSession(true);  
        UserDao2 userMapper = sqlSession.getMapper(UserDao2.class);  
 
        User2 user = userMapper.findUserById(10);  
        System.out.println("記錄為："+user);
 
    }
 
    // Mybatis 通過SqlSessionFactory獲取SqlSession, 然后才能通過SqlSession與數據庫進行交互
    private static SqlSessionFactory getSessionFactory() {
        SqlSessionFactory sessionFactory = null;
        String resource = "configuration.xml";
        try {
            sessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sessionFactory;
    }
}