// SqlSession相當(dāng)于一次完整對(duì)話，不是一通電話
SqlSession session = sqlSessionFactory.openSession();
try {
    // 對(duì)話中的多次查詢
    userMapper.getUser(1);  // 第一次查詢
    orderMapper.getOrders(1);  // 第二次查詢
    accountMapper.getBalance(1);  // 第三次查詢
    session.commit();  // 確認(rèn)對(duì)話內(nèi)容
} finally {
    session.close();  // 結(jié)束對(duì)話
}

// 示例代碼展示一級(jí)緩存行為
public void demonstrateLevel1Cache() {
    SqlSession session = sqlSessionFactory.openSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    System.out.println("第一次查詢用戶1:");
    User user1 = mapper.selectById(1);  // 發(fā)SQL：SELECT * FROM user WHERE id=1
    System.out.println("第二次查詢用戶1:");
    User user2 = mapper.selectById(1);  // 不發(fā)SQL！從一級(jí)緩存讀取
    System.out.println("查詢用戶2:");
    User user3 = mapper.selectById(2);  // 發(fā)SQL：參數(shù)不同，緩存未命中
    System.out.println("修改用戶1:");
    mapper.updateUser(user1);  // 清空一級(jí)緩存
    System.out.println("再次查詢用戶1:");
    User user4 = mapper.selectById(1);  // 發(fā)SQL：緩存被清空
    session.close();
}

// 一級(jí)緩存的核心實(shí)現(xiàn)類
public class PerpetualCache implements Cache {
    // 核心：就是一個(gè)ConcurrentHashMap！
    private final Map<Object, Object> cache = new ConcurrentHashMap<>();
    @Override
    public void putObject(Object key, Object value) {
        cache.put(key, value);  // 簡(jiǎn)單的Map.put()
    }
    @Override
    public Object getObject(Object key) {
        return cache.get(key);  // 簡(jiǎn)單的Map.get()
    }
}

// CacheKey包含以下要素，決定兩個(gè)查詢是否"相同"
// 1. Mapper Id（namespace + method）
// 2. 分頁(yè)參數(shù)（offset, limit）
// 3. SQL語(yǔ)句
// 4. 參數(shù)值
// 5. 環(huán)境Id
// 這意味著：即使SQL相同，參數(shù)不同，也會(huì)生成不同的CacheKey

<!-- 1. 全局配置開啟二級(jí)緩存 -->
<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>
<!-- 2. Mapper XML中配置 -->
<mapper namespace="com.example.UserMapper">
    <!-- 基本配置 -->
    <cache/>
    <!-- 詳細(xì)配置 -->
    <cache
        eviction="LRU"           <!-- 淘汰策略 -->
        flushInterval="60000"    <!-- 刷新間隔（毫秒） -->
        size="1024"              <!-- 緩存對(duì)象數(shù) -->
        readOnly="true"          <!-- 是否只讀 -->
        blocking="false"/>       <!-- 是否阻塞 -->
</mapper>
<!-- 3. 在具體查詢上使用緩存 -->
<select id="selectById" resultType="User" useCache="true">
    SELECT * FROM user WHERE id = #{id}
</select>
<!-- 4. 增刪改操作刷新緩存 -->
<update id="updateUser" flushCache="true">
    UPDATE user SET name = #{name} WHERE id = #{id}
</update>

二級(jí)緩存裝飾器鏈（層層包裝）：
┌─────────────────────────┐
│  SerializedCache        │ ← 序列化存儲(chǔ)
│  LoggingCache           │ ← 日志統(tǒng)計(jì)
│  SynchronizedCache      │ ← 線程安全
│  LruCache               │ ← LRU淘汰
│  PerpetualCache         │ ← 基礎(chǔ)HashMap
└─────────────────────────┘

public void demonstrateLevel2Cache() {
    // 用戶A查詢（第一個(gè)訪問(wèn)者）
    SqlSession sessionA = sqlSessionFactory.openSession();
    UserMapper mapperA = sessionA.getMapper(UserMapper.class);
    User user1 = mapperA.selectById(1);  // 查詢數(shù)據(jù)庫(kù)
    sessionA.close();  // 關(guān)鍵：關(guān)閉時(shí)才會(huì)寫入二級(jí)緩存
    // 用戶B查詢（不同SqlSession）
    SqlSession sessionB = sqlSessionFactory.openSession();
    UserMapper mapperB = sessionB.getMapper(UserMapper.class);
    User user2 = mapperB.selectById(1);  // 從二級(jí)緩存讀取，不發(fā)SQL
    // 管理員更新數(shù)據(jù)
    SqlSession sessionC = sqlSessionFactory.openSession();
    UserMapper mapperC = sessionC.getMapper(UserMapper.class);
    mapperC.updateUser(user1);  // 清空相關(guān)二級(jí)緩存
    sessionC.commit();
    sessionC.close();
    // 用戶D再次查詢
    SqlSession sessionD = sqlSessionFactory.openSession();
    UserMapper mapperD = sessionD.getMapper(UserMapper.class);
    User user3 = mapperD.selectById(1);  // 緩存被清，重新查詢數(shù)據(jù)庫(kù)
    sessionD.close();
}

// 場(chǎng)景：事務(wù)內(nèi)查詢，事務(wù)提交前其他會(huì)話看不到更新
SqlSession session1 = sqlSessionFactory.openSession();
UserMapper mapper1 = session1.getMapper(UserMapper.class);
// 修改數(shù)據(jù)，但未提交
mapper1.updateUser(user);
// 此時(shí)二級(jí)緩存還未更新
// 另一個(gè)會(huì)話查詢
SqlSession session2 = sqlSessionFactory.openSession();
UserMapper mapper2 = session2.getMapper(UserMapper.class);
User user2 = mapper2.selectById(1);  // 可能讀到舊數(shù)據(jù)！
session1.commit();  // 提交后，二級(jí)緩存才會(huì)更新
// 之后的新查詢才會(huì)看到新數(shù)據(jù)

// 場(chǎng)景1：方法內(nèi)多次查詢相同數(shù)據(jù)
public void processOrder(Long orderId) {
    Order order1 = validateOrder(orderId);      // 第一次查數(shù)據(jù)庫(kù)
    Order order2 = calculateDiscount(orderId);  // 走一級(jí)緩存
    Order order3 = generateInvoice(orderId);    // 走一級(jí)緩存
}
// 場(chǎng)景2：循環(huán)內(nèi)查詢
for (int i = 0; i < 100; i++) {
    Config config = configMapper.getConfig("system_timeout");
    // 只有第一次查數(shù)據(jù)庫(kù)，后續(xù)99次走緩存
}

// 場(chǎng)景1：讀多寫少的配置數(shù)據(jù)
SystemConfig config = configMapper.getConfig("app_settings");
// 多個(gè)用戶頻繁讀取，很少修改
// 場(chǎng)景2：熱門商品信息
Product product = productMapper.getHotProduct(666);
// 商品詳情頁(yè)，大量用戶訪問(wèn)同一商品
// 場(chǎng)景3：靜態(tài)字典數(shù)據(jù)
List<City> cities = addressMapper.getAllCities();
// 城市列表，很少變化

// 場(chǎng)景1：實(shí)時(shí)性要求高的數(shù)據(jù)
Stock stock = stockMapper.getRealTimeStock(productId);
// 庫(kù)存信息，需要實(shí)時(shí)準(zhǔn)確
// 場(chǎng)景2：頻繁更新的數(shù)據(jù)
UserBalance balance = accountMapper.getBalance(userId);
// 用戶余額，每次交易都變化
// 場(chǎng)景3：大數(shù)據(jù)量查詢
List<Log> logs = logMapper.getTodayLogs();
// 數(shù)據(jù)量大，緩存占用內(nèi)存過(guò)多

<cache eviction="策略類型" size="緩存大小">

public class LruCache implements Cache {
    private final Cache delegate;
    // 使用LinkedHashMap實(shí)現(xiàn)LRU
    private Map<Object, Object> keyMap;
    private Object eldestKey;
    public void setSize(final int size) {
        keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
                boolean tooBig = size() > size;
                if (tooBig) {
                    eldestKey = eldest.getKey();
                }
                return tooBig;
            }
        };
    }
    @Override
    public Object getObject(Object key) {
        // 訪問(wèn)時(shí)更新順序
        keyMap.get(key);
        return delegate.getObject(key);
    }
}

查詢執(zhí)行流程：
1. 請(qǐng)求到達(dá)CachingExecutor（二級(jí)緩存入口）
2. 生成CacheKey（包含SQL、參數(shù)等信息）
3. 查詢二級(jí)緩存
   └─ 命中 → 返回結(jié)果
   └─ 未命中 → 繼續(xù)
4. 查詢一級(jí)緩存
   └─ 命中 → 返回結(jié)果，并放入二級(jí)緩存（事務(wù)提交時(shí)）
   └─ 未命中 → 繼續(xù)
5. 查詢數(shù)據(jù)庫(kù)
6. 結(jié)果存入一級(jí)緩存
7. 事務(wù)提交時(shí)，一級(jí)緩存刷入二級(jí)緩存
8. 返回結(jié)果

<!-- 根據(jù)數(shù)據(jù)特點(diǎn)設(shè)置合適的大小 -->
<cache size="1024"/>  <!-- 緩存1024個(gè)對(duì)象 -->

<!-- 對(duì)于變化不頻繁但需要定期更新的數(shù)據(jù) -->
<cache flushInterval="1800000"/>  <!-- 30分鐘自動(dòng)刷新 -->

<!-- 某些查詢跳過(guò)緩存 -->
<select id="getRealTimeData" useCache="false">
    SELECT * FROM realtime_table
</select>
<!-- 某些查詢強(qiáng)制刷新緩存 -->
<select id="getImportantData" flushCache="true">
    SELECT * FROM important_table
</select>

<!-- 關(guān)聯(lián)查詢時(shí)，使用cache-ref同步緩存 -->
<mapper namespace="com.example.UserMapper">
    <cache/>
    <!-- 其他配置 -->
</mapper>
<mapper namespace="com.example.OrderMapper">
    <!-- 引用UserMapper的緩存 -->
    <cache-ref namespace="com.example.UserMapper"/>
</mapper>

// 設(shè)置事務(wù)隔離級(jí)別
@Transactional(isolation = Isolation.READ_COMMITTED)
public void updateUser(User user) {
    userMapper.updateUser(user);
}
// 或者在Mapper中設(shè)置flushCache
@Update("UPDATE user SET name=#{name} WHERE id=#{id}")
@Options(flushCache = Options.FlushCachePolicy.TRUE)
int updateUser(User user);

public class RedisCache implements Cache {
    private JedisPool jedisPool;
    @Override
    public void putObject(Object key, Object value) {
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.set(serialize(key), serialize(value));
        }
    }
    @Override
    public Object getObject(Object key) {
        try (Jedis jedis = jedisPool.getResource()) {
            byte[] value = jedis.get(serialize(key));
            return deserialize(value);
        }
    }
}

// 緩存空對(duì)象
public User getUser(Long id) {
    User user = userMapper.selectById(id);
    if (user == null) {
        // 緩存空值，設(shè)置短過(guò)期時(shí)間
        cacheNullValue(id);
        return null;
    }
    return user;
}

# 查看緩存命中情況
logging.level.org.mybatis=DEBUG
logging.level.com.example.mapper=TRACE

// 獲取緩存統(tǒng)計(jì)信息
Cache cache = sqlSession.getConfiguration()
    .getCache("com.example.UserMapper");
if (cache instanceof LoggingCache) {
    LoggingCache loggingCache = (LoggingCache) cache;
    System.out.println("命中次數(shù): " + loggingCache.getHitCount());
    System.out.println("未命中次數(shù): " + loggingCache.getMissCount());
    System.out.println("命中率: " + 
        (loggingCache.getHitCount() * 100.0 / 
         (loggingCache.getHitCount() + loggingCache.getMissCount())) + "%");
}