Spring AOP實現Redis緩存數據庫查詢源碼

應用場景
我們希望能夠將數據庫查詢結果緩存到Redis中，這樣在第二次做同樣的查詢時便可以直接從redis取結果，從而減少數據庫讀寫次數。
需要解決的問題
操作緩存的代碼寫在哪？必須要做到與業務邏輯代碼完全分離。
如何避免髒讀？從緩存中讀出的數據必須與數據庫中的數據一致。
如何爲一個數據庫查詢結果生成一個唯一的標識？即通過該標識(Redis中爲Key)，能唯一確定一個查詢結果，同一個查詢結果，一定能映射到同一個key。只有這樣才能保證緩存內容的正確性
如何序列化查詢結果？查詢結果可能是單個實體對象，也可能是一個List。
解決方案
避免髒讀
我們緩存了查詢結果，那麼一旦數據庫中的數據發生變化，緩存的結果就不可用了。爲了實現這一保證，可以在執行相關表的更新查詢(update, delete, insert)查詢前，讓相關的緩存過期。這樣下一次查詢時程序就會重新從數據庫中讀取新數據緩存到redis中。那麼問題來了，在執行一條insert前我怎麼知道應該讓哪些緩存過期呢？對於Redis，我們可以使用Hash Set數據結構，讓一張表對應一個Hash Set，所有在這張表上的查詢都保存到該Set下。這樣當表數據發生變動時，直接讓Set過期即可。我們可以自定義一個註解，在數據庫查詢方法上通過註解的屬性註明這個操作與哪些表相關，這樣在執行過期操作時，就能直接從註解中得知應該讓哪些Set過期了。
爲查詢生成唯一標識
對於MyBatis，我們可以直接使用SQL字符串做爲key。但是這樣就必須編寫基於MyBatis的攔截器，從而使你的緩存代碼與MyBatis緊緊耦合在一起。如果哪天更換了持久層的框架，你的緩存代碼就白寫了，所以這個方案並不完美。
仔細想一想，其實如果兩次查詢調用的類名、方法名和參數值相同，我們就可以確定這兩次查詢結果一定是相同的（在數據沒有變動的前提下）。因此，我們可以將這三個元素組合成一個字符串做爲key, 就解決了標識問題。
序列化查詢結果
最方便的序列化方式就是使用JDK自帶的ObjectOutputStream和ObjectInputStream。優點是幾乎任何一個對象，只要實現了Serializable接口，都用同一套代碼能被序列化和反序列化。但缺點也很致命，那就是序列化的結果容量偏大，在redis中會消耗大量內存（是對應JSON格式的3倍左右）。那麼我們只剩下JSON這一個選擇了。
JSON的優點是結構緊湊，可讀性強，但美中不足的是，反序列化對象時必須提供具體的類型參數(Class對象)，如果是List對象，還必須提供List和List中的元素類型兩種信息，才能被正確反序列化。這樣就增加了代碼的複雜度。不過這些困難都是可以克服的，所以我們還是選擇JSON作爲序列化存儲方式。【加羣】：857565362
代碼寫在哪
毫無疑問，該AOP上場了。在我們的例子中，持久化框架使用的是MyBatis，因此我們的任務就是攔截Mapper接口方法的調用，通過Around(環繞通知)編寫以下邏輯：
方法被調用之前，根據類名、方法名和參數值生成Key
通過Key向Redis發起查詢【加羣】：857565362
如果緩存命中，則將緩存結果反序列化作爲方法調用的返回值，並阻止被代理方法的調用。
如果緩存未命中，則執行代理方法，得到查詢結果，序列化，用當前的Key將序列化結果放入redis中。
代碼實現
因爲我們要攔截的是Mapper接口方法，因此必須命令spring使用JDK的動態代理而不是cglib的代理。爲此，我們需要做以下配置：

<!-- 當proxy-target-class爲false時使用JDK動態代理 -->
<!-- 爲true時使用cglib -->
<!-- cglib無法攔截接口方法 -->
<aop:aspectj-autoproxy proxy-target-class="false" />

然後定義兩個標註在接口方法上的註解，用於傳遞類型參數：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface RedisCache {
  Class type();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RedisEvict {
  Class type();
}

註解的使用方式如下：

// 表示該方法需要執行 (緩存是否命中 ? 返回緩存並阻止方法調用 : 執行方法並緩存結果)的緩存邏輯
@RedisCache(type = JobPostModel.class)
JobPostModel selectByPrimaryKey(Integer id);

// 表示該方法需要執行清除緩存邏輯
@RedisEvict(type = JobPostModel.class)
int deleteByPrimaryKey(Integer id);

AOP的代碼如下:

@Aspect
@Component
public class RedisCacheAspect {
  public static final Logger infoLog = LogUtils.getInfoLogger();  
  @Qualifier("redisTemplateForString")
  @Autowired
  StringRedisTemplate rt;
  /**
   * 方法調用前，先查詢緩存。如果存在緩存，則返回緩存數據，阻止方法調用;
   * 如果沒有緩存，則調用業務方法，然後將結果放到緩存中
   * @param jp
   * @return
   * @throws Throwable
   */
  @Around("execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.select*(..))" +      
  "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.get*(..))" + 
     "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.find*(..))" +      
     "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.search*(..))")  public Object cache(ProceedingJoinPoint jp) throws Throwable {
    // 得到類名、方法名和參數
    String clazzName = jp.getTarget().getClass().getName();
    String methodName = jp.getSignature().getName();
    Object[] args = jp.getArgs();
     // 根據類名，方法名和參數生成key
    String key = genKey(clazzName, methodName, args);
    if (infoLog.isDebugEnabled()) {
      infoLog.debug("生成key:{}", key);
    }
    // 得到被代理的方法
    Method me = ((MethodSignature) jp.getSignature()).getMethod();
    // 得到被代理的方法上的註解
    Class modelType = me.getAnnotation(RedisCache.class).type();
     // 檢查redis中是否有緩存
    String value = (String)rt.opsForHash().get(modelType.getName(), key);
    // result是方法的最終返回結果
    Object result = null;
    if (null == value) {
      // 緩存未命中
      if (infoLog.isDebugEnabled()) {
        infoLog.debug("緩存未命中");
      }
      // 調用數據庫查詢方法
      result = jp.proceed(args);
       // 序列化查詢結果
      String json = serialize(result);
      // 序列化結果放入緩存
      rt.opsForHash().put(modelType.getName(), key, json);
    } else {
      // 緩存命中
      if (infoLog.isDebugEnabled()) {
        infoLog.debug("緩存命中, value = {}", value);
      }
      // 得到被代理方法的返回值類型
      Class returnType = ((MethodSignature) jp.getSignature()).getReturnType();
       // 反序列化從緩存中拿到的json
      result = deserialize(value, returnType, modelType);
       if (infoLog.isDebugEnabled()) {
        infoLog.debug("反序列化結果 = {}", result);
      }
    }
    return result;
  }
  /** 
  * 在方法調用前清除緩存，然後調用業務方法
   * @param jp
   * @return
   * @throws Throwable
   */
  @Around("execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.insert*(..))" +      
  "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.update*(..))" + 
     "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.delete*(..))" +      
     "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.increase*(..))" +      
     "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.decrease*(..))" +      
     "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.complaint(..))" +      
     "|| execution(* com.fh.taolijie.dao.mapper.JobPostModelMapper.set*(..))")
  public Object evictCache(ProceedingJoinPoint jp) throws Throwable {
    // 得到被代理的方法
    Method me = ((MethodSignature) jp.getSignature()).getMethod();
    // 得到被代理的方法上的註解
    Class modelType = me.getAnnotation(RedisEvict.class).type();
    if (infoLog.isDebugEnabled()) {
      infoLog.debug("清空緩存:{}", modelType.getName());
    }
    // 清除對應緩存
    rt.delete(modelType.getName());
    return jp.proceed(jp.getArgs());
  }
  /**
   * 根據類名、方法名和參數生成key
   * @param clazzName
   * @param methodName
   * @param args 方法參數
   * @return
   */
  protected String genKey(String clazzName, String methodName, Object[] args) {    
  StringBuilder sb = new StringBuilder(clazzName);
    sb.append(Constants.DELIMITER);
    sb.append(methodName);
    sb.append(Constants.DELIMITER);
     for (Object obj : args) {
      sb.append(obj.toString());
      sb.append(Constants.DELIMITER);
    }
    return sb.toString();
  }
  protected String serialize(Object target) {
    return JSON.toJSONString(target);
  }
  protected Object deserialize(String jsonString, Class clazz, Class modelType) {
    // 序列化結果應該是List對象
    if (clazz.isAssignableFrom(List.class)) {
      return JSON.parseArray(jsonString, modelType);
    }
    // 序列化結果是普通對象
    return JSON.parseObject(jsonString, clazz);
  }
}

這樣我們就完成了數據庫查詢緩存的實現。
UPDATE:
最好爲Hash Set設置一個過期時間，這樣即使緩存策略有誤（導致讀出髒數據），過期時間到了以後依然可以與數據庫保持同步：

// 序列化結果放入緩存
      rt.execute(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection redisConn) throws DataAccessException {
          // 配置文件中指定了這是一個String類型的連接
          // 所以這裏向下強制轉換一定是安全的
          StringRedisConnection conn = (StringRedisConnection) redisConn;
          // 判斷hash名是否存在
          // 如果不存在，創建該hash並設置過期時間
          if (false == conn.exists(hashName) ){
            conn.hSet(hashName, key, json);
            conn.expire(hashName, Constants.HASH_EXPIRE_TIME);
          } else {
            conn.hSet(hashName, key, json);
          } 
         return null;
        }
      });

我這兒整理了比較全面的JAVA相關的面試資料，
需要領取面試資料的同學，請加羣：473984645

獲取更多學習資料，可以加羣：473984645或掃描下方二維碼

Spring AOP實現Redis緩存數據庫查詢源碼

SQL優化-20231016

Java架構進階之Redis內存回收策略

深入剖析HashMap應用原理

redis源碼分析—基本數據結構

Java高併發網絡編程

Java高併發- 鎖的優化及 JVM 對鎖優化所做的努力

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結