學習mybatis-3 step by step 篇二

時間  2019-12-11
標籤 學習 mybatis step 欄目 MyBatis 简体版
原文   原文鏈接

Mapper XML 文件

基本的*Mapper.xml文件配置就不熬述了具體可參考：html

http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.htmljava

一、sql元素算法

這個元素能夠被用來定義可重用的 SQL 代碼段，能夠包含在其餘語句中。它能夠被靜態地(在加載參數) 參數化. 不一樣的屬性值經過包含的實例變化. 好比：sql

<sql id="userColumns"> ${alias}.id,${alias}.username,${alias}.password </sql>

這個 SQL 片斷能夠被包含在其餘語句中，例如：數據庫

<select id="selectUsers" resultType="map">
  select
    <include refid="userColumns"><property name="alias" value="t1"/></include>,
    <include refid="userColumns"><property name="alias" value="t2"/></include>
  from some_table t1
    cross join some_table t2
</select>

屬性值能夠用於包含的refid屬性或者包含的字句裏面的屬性值，例如：緩存

<sql id="sometable">
  ${prefix}Table
</sql>

<sql id="someinclude">
  from
    <include refid="${include_target}"/>
</sql>

<select id="select" resultType="map">
  select
    field1, field2, field3
  <include refid="someinclude">
    <property name="prefix" value="Some"/>
    <property name="include_target" value="sometable"/>
  </include>
</select>

上面這段SQL首先引用了someinclude而後再someinclude裏面又引用了sometable。利用該功能配合if就能動態生成SQL語句了。安全

二、使用Mybatis優雅的解決N+1查詢問題(關聯的嵌套查詢)session

歸納地講,N+1 查詢問題能夠是這樣引發的:mybatis

  • 你執行了一個單獨的 SQL 語句來獲取結果列表(就是「+1」)。
  • 對返回的每條記錄,你執行了一個查詢語句來爲每一個加載細節(就是「N」)。

以上問題可使用關聯嵌套查詢來解決問題，如下介紹一下嵌套查詢的標籤<association>屬性的做用。app

  • column:來自數據庫的類名,或重命名的列標籤。這和一般傳遞給 resultSet.getString(columnName)方法的字符串是相同的。 column 注 意 : 要 處 理 復 合 主 鍵 , 你 可 以 指 定 多 個 列 名 通 過 column= 」 {prop1=col1,prop2=col2} 」 這種語法來傳遞給嵌套查詢語 句。這會引發 prop1 和 prop2 以參數對象形式來設置給目標嵌套查詢語句。
  • select:另一個映射語句的 ID,能夠加載這個屬性映射須要的複雜類型。獲取的 在列屬性中指定的列的值將被傳遞給目標 select 語句做爲參數。表格後面 有一個詳細的示例。 select 注 意 : 要 處 理 復 合 主 鍵 , 你 可 以 指 定 多 個 列 名 通 過 column= 」 {prop1=col1,prop2=col2} 」 這種語法來傳遞給嵌套查詢語 句。這會引發 prop1 和 prop2 以參數對象形式來設置給目標嵌套查詢語句。
  • fetchType:可選的。有效值爲 lazy和eager。 若是使用了，它將取代全局配置參數lazyLoadingEnabled。

    先舉一個簡單的例子：客戶表customer和car是有一對多的關係，假設有實體類以下:

package com.zealzhangz.entity;

import java.io.Serializable;
import java.util.List;

public class Customer implements Serializable {

    private static final long serialVersionUID = 7500918067281634276L;

    private String name;                    // 名稱

    private String sex;                    // 性別

    private String idCar;

    private Car customerCar;



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getIdCar() {
        return idCar;
    }

    public void setIdCar(String idCar) {
        this.idCar = idCar;
    }

    public Car getCustomerCar() {
        return customerCar;
    }

    public void setCustomerCar(Car customerCar) {
        this.customerCar = customerCar;
    }
}

若是要獲取客戶和車輛的信息，通常的作法須要兩次查詢才能查出結果。固然能夠換一種方式，把Car中字段拿到Customer中來，SQL JOIN查詢也能查出結果，對於List<car>這種狀況JOIN就無能爲力了。可是mybatis已經提供了直接優雅

完成這種查詢的功能SQL以下：

<?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="CustomerMapper">
    <resultMap type="Customer" id="customerMap">
        <association property="customerCar" column="idCar" javaType="Car" select="selectCar"/>
    </resultMap>
    <select id="selectCustomer" resultMap="customerMap" parameterType="string">
        select name,sex,cc.id_car AS idCar from customer c INNER JOIN customer_car cc ON c.pk_id=cc.id_customer where c.pk_id = CAST(#{pk_id} AS UNSIGNED)
    </select>

    <select id="selectCar" resultType="Car">
        select car_prefix AS carPrefix,car_no AS carNo,vin,car_brand_name AS carBrandName, car_series_mame AS carSeriesMame from car  where pk_id = CAST(#{id} AS UNSIGNED)
    </select>
</mapper>

結果以下：

{
  "customerCar": {
    "carBrandName": "Jeep",
    "carNo": "A666666",
    "carPrefix": "蘇",
    "carSeriesMame": "Compass [指南者]",
    "vin": "1C4NJCCA9CD645865"
  },
  "name": "張先生",
  "sex": "先生"
}

更復雜的情形有多輛車的狀況，這種狀況咱們稍後考慮。

注意：以上聯合查詢是一個分離的複雜的聯合查詢，下面這個是一個很是簡單的示例 來講明它如何工做。代替了執行一個分離的語句：

    <select id="selectCustomerCar" resultType="Customer" parameterType="string">
        SELECT
            name,
            sex,
            cc.id_car AS idCar,
            r.car_prefix AS carPrefix,
            r.car_no AS carNo,
            vin,
            car_brand_name AS carBrandName,
            car_series_mame AS carSeriesMame
        FROM
            tm_customer c
                INNER JOIN
            tm_customer_car cc ON c.pk_id = cc.id_customer
                INNER JOIN
            tm_car r ON cc.id_car = r.pk_id
        WHERE
            c.pk_id = CAST(#{pk_id} AS UNSIGNED)
    </select>

下面使用兩個resultMap來聯合映射上面的查詢結果：

    <resultMap id="customerCarResult" type="Customer">
        <id property="idCustomer" column="idCustomer"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <association property="customerCar" column="idCar" javaType="Car" resultMap="carResult"/>
    </resultMap>

    <resultMap id="carResult" type="Car">
        <id property="idCar" column="idCar"/>
        <result property="carPrefix" column="carPrefix"/>
        <result property="carNo" column="carNo"/>
        <result property="vin" column="vin"/>
        <result property="carBrandName" column="carBrandName"/>
        <result property="carSeriesMame" column="carSeriesMame"/>
    </resultMap>

很是重要: id元素在嵌套結果映射中扮演着非 常重要的角色。你應該老是指定一個或多個能夠惟一標識結果的屬性。實際上若是你不指定它的話, MyBatis仍然能夠工做,可是會有嚴重的性能問題。在能夠惟一標識結果的狀況下, 儘量少的選擇屬性。主鍵是一個顯而易見的選擇（即便是複合主鍵）。

如今,上面的示例用了外部的結果映射元素來映射關聯。這使得Car結果映射能夠 重用。然而,若是你不須要重用它的話,或者你僅僅引用你全部的結果映射合到一個單獨描 述的結果映射中。你能夠嵌套結果映射。這裏給出使用這種方式的相同示例:

    <resultMap id="customerCarResultUnion" type="Customer">
        <id property="idCustomer" column="idCustomer"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <association property="customerCar" javaType="Car">
            <id property="idCar" column="idCar"/>
            <result property="carPrefix" column="carPrefix"/>
            <result property="carNo" column="carNo"/>
            <result property="vin" column="vin"/>
            <result property="carBrandName" column="carBrandName"/>
            <result property="carSeriesMame" column="carSeriesMame"/>
        </association>
    </resultMap>

 假設有一種業務，每一個customer有一輛平常用車還有一輛備用車（這個業務現實中可能並不存在），客戶實體就變成這個樣子了：

import java.io.Serializable;
import java.util.List;

public class Customer implements Serializable {

    private static final long serialVersionUID = 7500918067281634276L;

    private String idCustomer;

    private String name;                    // 名稱

    private String sex;                    // 性別

    private String idCar;

    private Car customerCar;

    private Car backupCar; //備用車

    public String getIdCustomer() {
        return idCustomer;
    }

    public void setIdCustomer(String idCustomer) {
        this.idCustomer = idCustomer;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getIdCar() {
        return idCar;
    }

    public void setIdCar(String idCar) {
        this.idCar = idCar;
    }

    public Car getCustomerCar() {
        return customerCar;
    }

    public void setCustomerCar(Car customerCar) {
        this.customerCar = customerCar;
    }

    public Car getBackupCar() {
        return backupCar;
    }

    public void setBackupCar(Car backupCar) {
        this.backupCar = backupCar;
    }
}

兩個Car類型的字段：customerCar、backupCar，這個時候SQL查詢怎麼區分呢？

由於結果中的列名與resultMap中的列名不一樣。 你須要指定columnPrefix去重用映射ba_car結果的resultMap。

    <resultMap id="carResult" type="Car">
        <id property="idCar" column="idCar"/>
        <result property="carPrefix" column="carPrefix"/>
        <result property="carNo" column="carNo"/>
        <result property="vin" column="vin"/>
        <result property="carBrandName" column="carBrandName"/>
        <result property="carSeriesMame" column="carSeriesMame"/>
    </resultMap>

    <resultMap id="customerCarResultAll" type="Customer">
        <id property="idCustomer" column="idCustomer"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <association property="customerCar" resultMap="carResult"/>
        <association property="backupCar" resultMap="carResult" columnPrefix="ba_"/>
    </resultMap>

    <select id="selectCustomerCarAll" resultMap="customerCarResultAll" parameterType="string">
        SELECT
        c.pk_id AS idCustomer,
        c.name,
        c.sex,
        cc.id_car AS idCar,
        r.car_prefix AS carPrefix,
        r.car_no AS carNo,
        r.vin,
        r.car_brand_name AS carBrandName,
        r.car_series_mame AS carSeriesMame,
        '1314182348972' AS ba_idCar,
        '雲' AS ba_carPrefix,
        'AR6248' AS ba_carNo,
        '1231sdfhs623462e7' AS ba_vin,
        '五羊' AS ba_carBrandName,
        '本田' AS ba_carSeriesMame
        FROM
        tm_customer c
        INNER JOIN
        tm_customer_car cc ON c.pk_id = cc.id_customer
        INNER JOIN
        tm_car r ON cc.id_car = r.pk_id
        WHERE
        c.pk_id = CAST(#{pk_id} AS UNSIGNED)
    </select>

結果以下：

{
    "backupCar": {
        "carBrandName": "五羊",
        "carNo": "AR6248",
        "carPrefix": "雲",
        "carSeriesMame": "本田",
        "idCar": "1314182348972",
        "vin": "1231sdfhs623462e7"
    },
    "customerCar": {
        "carBrandName": "Jeep",
        "carNo": "A666666",
        "carPrefix": "蘇",
        "carSeriesMame": "Compass [指南者]",
        "idCar": "10545406337939703159",
        "vin": "1C4NJCCA9CD645865"
    },
    "idCustomer": "10545406337939703158",
    "name": "張先生",
    "sex": "先生"
}

 

集合的嵌套查詢

        假設這種場景，一個客戶有不少輛車且車和車之間沒有邏輯關係，這時候咱們會用private List<Car> cars;來存儲全部車輛的信息。這種狀況改怎麼寫查詢呢？

    <resultMap id="customerCarListResult" type="Customer">
        <id property="idCustomer" column="idCustomer"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <collection property="cars" javaType="ArrayList" column="idCustomer" ofType="Car" select="selectCarByIdCustomer"/>
    </resultMap>

    <select id="selectCarByIdCustomer" resultType="Car">
        SELECT
            r.car_prefix AS carPrefix,
            r.car_no AS carNo,
            r.vin,
            r.car_brand_name AS carBrandName,
            r.car_series_mame AS carSeriesMame
        FROM
            tm_customer_car cc INNER JOIN
            tm_car r ON cc.id_car = r.pk_id
        WHERE
            cc.id_customer = CAST(#{idCustomer} AS UNSIGNED)
    </select>

    <select id="selectCustomerListCar" resultMap="customerCarListResult" parameterType="string">
        select pk_id AS idCustomer,name,sex from tm_customer  where pk_id = CAST(#{pk_id} AS UNSIGNED)
    </select>

結果以下圖：

{
    "cars": [
        {
            "carBrandName": "Jeep",
            "carNo": "A666666",
            "carPrefix": "蘇",
            "carSeriesMame": "Compass [指南者]",
            "vin": "1C4NJCCA9CD645865"
        },
        {
            "carBrandName": "寶馬",
            "carNo": "A86866",
            "carPrefix": "蘇",
            "carSeriesMame": "X5 xDrive35i",
            "vin": "5UXZV4C51D0B11025"
        }
    ],
    "idCustomer": "10545406337939703158",
    "name": "張先生",
    "sex": "先生"
}

這裏咱們應該注意不少東西,但大部分代碼和上面的關聯元素是很是類似的。首先,你應 該注意咱們使用的是集合元素。而後要注意那個新的「ofType」屬性。這個屬性用來區分 JavaBean(或字段)屬性類型和集合包含的類型來講是很重要的。因此你能夠讀出下面這個 映射:

<collection property="cars" javaType="ArrayList" column="idCustomer" ofType="Car"  select="selectCarByIdCustomer"/>

讀做: 「在Car類型的 ArrayList 中的 cars 的集合。」

javaType 屬性是不須要的,由於 MyBatis 在不少狀況下會爲你算出來。因此你能夠縮短 寫法:

<collection property="cars" column="idCustomer" ofType="Car"  select="selectCarByIdCustomer"/>

 

集合的嵌套結果

至此,咱們能夠猜想集合的嵌套結果是如何來工做的,由於它和關聯徹底相同,除了它應 用了一個「ofType」屬性,請看以下SQL：

    <select id="selectCustomerListCarUnion" resultMap="selectCustomerListCarUnionResult">
        SELECT
            c.pk_id AS idCustomer,
            c.name,
            c.sex,
            cc.id_car AS idCar,
            r.car_prefix AS carPrefix,
            r.car_no AS carNo,
            r.vin,
            r.car_brand_name AS carBrandName,
            r.car_series_mame AS carSeriesMame
        FROM
            tm_customer c
                INNER JOIN
            tm_customer_car cc ON c.pk_id = cc.id_customer
                LEFT JOIN
            tm_car r ON r.pk_id = cc.id_car
        WHERE
            c.pk_id = CAST(#{idCustomer} AS UNSIGNED)
    </select>

咱們在一個SQL中查詢出了一個客戶的全部車輛信息，查詢的結果形式以下：

客戶1    車輛1

客戶1    車輛2

咱們又一次聯合了客戶和車輛表,結果列標籤的簡單映射。現 在用汽車映射集合映射客戶,能夠簡單寫爲:

    <resultMap id="selectCustomerListCarUnionResult" type="Customer">
        <id property="idCustomer" column="idCustomer"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <collection property="cars" ofType="Car">
            <id property="idCar" column="idCar"/>
            <result property="carPrefix" column="carPrefix"/>
            <result property="carNo" column="carNo"/>
            <result property="vin" column="vin"/>
            <result property="carBrandName" column="carBrandName"/>
            <result property="carSeriesMame" column="carSeriesMame"/>
        </collection>
    </resultMap>

注意這裏的<collection property="cars" ofType="Car">和上面<association property="customerCar" javaType="Car">不一樣支出就是ofType是針對集合的。

一樣,要記得 id 元素的重要性,若是你不記得了,請閱讀上面的關聯部分。

一樣, 若是你引用更長的形式容許你的結果映射的更多重用, 你可使用下面這個替代 的映射:

    <resultMap id="selectCustomerListCarUnionCustomerResult" type="Customer">
        <id property="idCustomer" column="idCustomer"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <collection property="cars" ofType="Car" resultMap="carListUnion" columnPrefix="car_"/>
    </resultMap>

    <resultMap id="carListUnion" type="Car">
        <id property="idCar" column="idCar"/>
        <result property="carPrefix" column="carPrefix"/>
        <result property="carNo" column="carNo"/>
        <result property="vin" column="vin"/>
        <result property="carBrandName" column="carBrandName"/>
        <result property="carSeriesMame" column="carSeriesMame"/>
    </resultMap>

    <select id="selectCustomerListCarUnion" resultMap="selectCustomerListCarUnionCustomerResult">
        SELECT
            c.pk_id AS idCustomer,
            c.name,
            c.sex,
            cc.id_car AS car_idCar,
            r.car_prefix AS car_carPrefix,
            r.car_no AS car_carNo,
            r.vin AS car_vin,
            r.car_brand_name AS car_carBrandName,
            r.car_series_mame AS car_carSeriesMame
        FROM
            tm_customer c
                INNER JOIN
            tm_customer_car cc ON c.pk_id = cc.id_customer
                LEFT JOIN
            tm_car r ON r.pk_id = cc.id_car
        WHERE
            c.pk_id = CAST(#{idCustomer} AS UNSIGNED)
    </select>

 

鑑別器

有的時候結果集的映射須要根據結果集的每一個字段進行動態映射，好比結果實體有繼承關係時。 鑑別器很是容易理 解,由於它的表現很像 Java 語言中的 switch 語句。好比：

    <select id="selectCarDiscriminator" resultMap="carResultDiscriminator">
        SELECT
            pk_id AS idCar,
            car_prefix AS carPrefix,
            car_no AS carNo,
            vin AS vin,
            car_brand_name AS carBrandName,
            car_series_mame AS carSeriesMame,
            2 AS flag
        FROM
            tm_car
        WHERE
            pk_id = CAST(#{pk_id} AS UNSIGNED)
    </select>

    <resultMap id="carResultDiscriminator" type="Car">
        <id property="idCar" column="idCar"/>
        <result property="carPrefix" column="carPrefix"/>
        <result property="carNo" column="carNo"/>
        <result property="vin" column="vin"/>
        <result property="carBrandName" column="carBrandName"/>
        <result property="carSeriesMame" column="carSeriesMame"/>
        <discriminator javaType="int" column="flag">
            <case value="1" resultMap="test1Result"/>
            <case value="2" resultMap="test2Result"/>
        </discriminator>
    </resultMap>

    <resultMap id="test1Result" type="Car">
        <result property="test1" column="flag"/>
    </resultMap>
    <resultMap id="test2Result" type="Car">
        <result property="test2" column="vin"/>
    </resultMap>

以上邏輯<discriminator javaType="int" column="flag">中flag的值（1或2）動態映射test1Result或test2Result

以上result可簡寫爲以下：

    <resultMap id="carResultDiscriminator" type="Car">
        <id property="idCar" column="idCar"/>
        <result property="carPrefix" column="carPrefix"/>
        <result property="carNo" column="carNo"/>
        <result property="vin" column="vin"/>
        <result property="carBrandName" column="carBrandName"/>
        <result property="carSeriesMame" column="carSeriesMame"/>
        <discriminator javaType="int" column="flag">
            <case value="1" resultMap="test1Result">
                <result property="test1" column="flag"/>
            </case>
            <case value="2" resultMap="test2Result">
                <result property="test2" column="vin"/>
            </case>
        </discriminator>
    </resultMap>

 

自動映射

當自動映射查詢結果時，MyBatis會獲取sql返回的列名並在java類中查找相同名字的屬性（忽略大小寫）。 這意味着若是Mybatis發現了ID列和id屬性，Mybatis會將ID的值賦給id。一般數據庫列使用大寫單詞命名，單詞間用下劃線分隔；而java屬性通常遵循駝峯命名法。 爲了在這兩種命名方式之間啓用自動映射，須要將 mapUnderscoreToCamelCase設置爲true。

有三種自動映射等級：

  • NONE - 禁用自動映射。僅設置手動映射屬性。
  • PARTIAL - 將自動映射結果除了那些有內部定義內嵌結果映射的(joins).
  • FULL - 自動映射全部。

默認值是PARTIAL，這是有緣由的。當使用FULL時，自動映射會在處理join結果時執行，而且join取得若干相同行的不一樣實體數據，所以這可能致使非預期的映射。好比兩個實體都有id屬性，SELECT出來的id就不知道映射給誰。

緩存

MyBatis 包含一個很是強大的查詢緩存特性,它能夠很是方便地配置和定製。MyBatis 3 中的緩存實現的不少改進都已經實現了,使得它更增強大並且易於配置。

默認狀況下是沒有開啓緩存的,除了局部的 session 緩存,能夠加強變現並且處理循環 依賴也是必須的。要開啓二級緩存,你須要在你的 SQL 映射文件中添加一行:

<cache/>

字面上看就是這樣。這個簡單語句的效果以下:

  • 映射語句文件中的全部 select 語句將會被緩存。
  • 映射語句文件中的全部 insert,update 和 delete 語句會刷新緩存。
  • 緩存會使用 Least Recently Used(LRU,最近最少使用的)算法來收回。
  • 根據時間表(好比 no Flush Interval,沒有刷新間隔), 緩存不會以任什麼時候間順序 來刷新。
  • 緩存會存儲列表集合或對象(不管查詢方法返回什麼)的 1024 個引用。
  • 緩存會被視爲是 read/write(可讀/可寫)的緩存,意味着對象檢索不是共享的,而 且能夠安全地被調用者修改,而不干擾其餘調用者或線程所作的潛在修改。
<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

這個更高級的配置建立了一個 FIFO 緩存,並每隔 60 秒刷新,存數結果對象或列表的 512 個引用,並且返回的對象被認爲是隻讀的,所以在不一樣線程中的調用者之間修改它們會 致使衝突。

可用的收回策略有:

  • LRU – 最近最少使用的:移除最長時間不被使用的對象。
  • FIFO – 先進先出:按對象進入緩存的順序來移除它們。
  • SOFT – 軟引用:移除基於垃圾回收器狀態和軟引用規則的對象。
  • WEAK – 弱引用:更積極地移除基於垃圾收集器狀態和弱引用規則的對象。

默認的是 LRU。

flushInterval(刷新間隔)能夠被設置爲任意的正整數,並且它們表明一個合理的毫秒 形式的時間段。默認狀況是不設置,也就是沒有刷新間隔,緩存僅僅調用語句時刷新。

size(引用數目)能夠被設置爲任意正整數,要記住你緩存的對象數目和你運行環境的 可用內存資源數目。默認值是 1024。

readOnly(只讀)屬性能夠被設置爲 true 或 false。只讀的緩存會給全部調用者返回緩 存對象的相同實例。所以這些對象不能被修改。這提供了很重要的性能優點。可讀寫的緩存 會返回緩存對象的拷貝(經過序列化) 。這會慢一些,可是安全,所以默認是 false

注意：若是手動修改了數據庫的數據就可能會發生髒讀，由於手動改數據觸發不了mybatis的緩存更新機制。

使用自定義緩存

除了這些自定義緩存的方式, 你也能夠經過實現你本身的緩存或爲其餘第三方緩存方案 建立適配器來徹底覆蓋緩存行爲。

<cache type="com.domain.something.MyCustomCache"/>

這個示 例展 示了 如何 使用 一個 自定義 的緩 存實 現。type 屬 性指 定的 類必 須實現 org.mybatis.cache.Cache 接口。這個接口是 MyBatis 框架中不少複雜的接口之一,可是簡單 給定它作什麼就行。

public interface Cache {
  String getId();
  int getSize();
  void putObject(Object key, Object value);
  Object getObject(Object key);
  boolean hasKey(Object key);
  Object removeObject(Object key);
  void clear();
}

 記得緩存配置和緩存實例是綁定在 SQL 映射文件的命名空間是很重要的。所以,全部 在相同命名空間的語句正如綁定的緩存同樣。 語句能夠修改和緩存交互的方式, 或在語句的 語句的基礎上使用兩種簡單的屬性來徹底排除它們。默認狀況下,語句能夠這樣來配置:

<select ... flushCache="false" useCache="true"/>
<insert ... flushCache="true"/>
<update ... flushCache="true"/>
<delete ... flushCache="true"/>

由於那些是默認的,你明顯不能明確地以這種方式來配置一條語句。相反,若是你想改 變默認的行爲,只能設置 flushCache 和 useCache 屬性。好比,在一些狀況下你也許想排除 從緩存中查詢特定語句結果,或者你也許想要一個查詢語句來刷新緩存。類似地,你也許有 一些更新語句依靠執行而不須要刷新緩存。

參照緩存

這個特殊命名空間的惟一緩存會被使用或者刷新相同命名空間內 的語句。也許未來的某個時候,你會想在命名空間中共享相同的緩存配置和實例。在這樣的 狀況下你可使用 cache-ref 元素來引用另一個緩存。

<cache-ref namespace="com.someone.application.data.SomeMapper"/>
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程