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

// 示例代碼展示一級緩存行為
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！從一級緩存讀取
    System.out.println("查詢用戶2:");
    User user3 = mapper.selectById(2);  // 發(fā)SQL：參數(shù)不同，緩存未命中
    System.out.println("修改用戶1:");
    mapper.updateUser(user1);  // 清空一級緩存
    System.out.println("再次查詢用戶1:");
    User user4 = mapper.selectById(1);  // 發(fā)SQL：緩存被清空
    session.close();
}

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

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

<!-- 1. 全局配置開啟二級緩存 -->
<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>
<!-- 2. Mapper XML中配置 -->
<mapper namespace="com.example.UserMapper">
    <!-- 基本配置 -->
    <cache/>
    <!-- 詳細(xì)配置 -->
    <cache
        eviction="LRU"           <!-- 淘汰策略 -->
        flushInterval="60000"    <!-- 刷新間隔（毫秒） -->
        size="1024"              <!-- 緩存對象數(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>

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

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

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

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

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

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

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

public class LruCache implements Cache {
    private final Cache delegate;
    // 使用LinkedHashMap實現(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) {
        // 訪問時更新順序
        keyMap.get(key);
        return delegate.getObject(key);
    }
}

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

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

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

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

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

// 設(shè)置事務(wù)隔離級別
@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);
        }
    }
}

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

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

// 獲取緩存統(tǒng)計信息
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())) + "%");
}