MyBatis整合Redis实现二级缓存的示例代码

mybatis:
 configuration:
  cache-enabled: true

package com.leven.mybatis.api.config;

import com.fasterxml.jackson.annotation.jsonautodetect;
import com.fasterxml.jackson.annotation.propertyaccessor;
import com.fasterxml.jackson.databind.objectmapper;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.data.redis.connection.redisconnectionfactory;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.serializer.jackson2jsonredisserializer;
import org.springframework.data.redis.serializer.stringredisserializer;

/**
 * redis缓存配置
 * @author leven
 * @date 2019-09-07
 */
@configuration
public class redisconfig {

  /**
   * 配置自定义redistemplate
   * @return redistemplate
   */
  @bean
  public redistemplate<string, object> redistemplate(redisconnectionfactory redisconnectionfactory) {
    redistemplate<string, object> template = new redistemplate<>();
    template.setconnectionfactory(redisconnectionfactory);
    // 使用jackson2jsonredisserializer来序列化和反序列化redis的value值
    jackson2jsonredisserializer<object> jackson2jsonredisserializer = new jackson2jsonredisserializer<>(object.class);
    stringredisserializer stringredisserializer = new stringredisserializer();
    objectmapper mapper = new objectmapper();
    mapper.setvisibility(propertyaccessor.all, jsonautodetect.visibility.any);
    mapper.enabledefaulttyping(objectmapper.defaulttyping.non_final);
    jackson2jsonredisserializer.setobjectmapper(mapper);
    template.setkeyserializer(stringredisserializer);
    template.setvalueserializer(jackson2jsonredisserializer);
    template.sethashkeyserializer(stringredisserializer);
    template.sethashvalueserializer(jackson2jsonredisserializer);
    template.afterpropertiesset();
    return template;
  }
}

package com.leven.mybatis.core.service;

import java.util.*;
import java.util.concurrent.timeunit;

/**
 * redis基础服务接口
 * @author leven
 * @date 2019-09-07
 */
public interface redisservice {
// =============================common============================
  /**
   * 指定缓存失效时间
   * @param key 键
   * @param time 时间(秒)
   */
  void expire(string key, long time);

  /**
   * 指定缓存失效时间
   * @param key 键
   * @param expireat 失效时间点
   * @return 处理结果
   */
  void expireat(string key, date expireat);

  /**
   * 根据key 获取过期时间
   * @param key 键 不能为null
   * @return 时间(秒) 返回0代表为永久有效
   */
  long getexpire(string key);

  /**
   * 判断key是否存在
   * @param key 键
   * @return true 存在 false不存在
   */
  boolean haskey(string key);

  /**
   * 删除缓存
   * @param key 可以传一个值 或多个
   */
  void delete(string... key);

  /**
   * 删除缓存
   * @param keys 可以传一个值 或多个
   */
  void delete(collection<string> keys);

  // ============================string=============================

  /**
   * 普通缓存获取
   * @param key 键
   * @return 值
   */
  object get(string key);

  /**
   * 普通缓存放入
   * @param key 键
   * @param value 值
   */
  void set(string key, object value);

  /**
   * 普通缓存放入并设置时间
   * @param key 键
   * @param value 值
   * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
   */
  void set(string key, object value, long time);

  /**
   * 普通缓存放入并设置时间
   * @param key 键
   * @param value 值
   * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
   */
  void set(string key, object value, long time, timeunit timeunit);

  /**
   * 递增
   * @param key 键
   * @param value 要增加几(大于0)
   * @return 递增后结果
   */
  long incr(string key, long value);

  /**
   * 递减
   * @param key 键
   * @param value 要减少几(大于0)
   * @return 递减后结果
   */
  long decr(string key, long value);

  // ================================map=================================
  /**
   * hashget
   * @param key 键 不能为null
   * @param item 项 不能为null
   * @return 值
   */
  object hashget(string key, string item);

  /**
   * 获取hashkey对应的所有键值
   * @param key 键
   * @return 对应的多个键值
   */
  map<object, object> hashentries(string key);

  /**
   * hashset
   * @param key 键
   * @param map 对应多个键值
   */
  void hashset(string key, map<string, object> map);

  /**
   * hashset 并设置时间
   * @param key 键
   * @param map 对应多个键值
   * @param time 时间(秒)
   */
  void hashset(string key, map<string, object> map, long time);

  /**
   * 向一张hash表中放入数据,如果不存在将创建
   * @param key 键
   * @param item 项
   * @param value 值
   */
  void hashset(string key, string item, object value);

  /**
   * 向一张hash表中放入数据,如果不存在将创建
   * @param key 键
   * @param item 项
   * @param value 值
   * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
   */
  void hashset(string key, string item, object value, long time);

  /**
   * 删除hash表中的值
   * @param key 键 不能为null
   * @param item 项 可以使多个 不能为null
   */
  void hashdelete(string key, object... item);

  /**
   * 删除hash表中的值
   * @param key 键 不能为null
   * @param items 项 可以使多个 不能为null
   */
  void hashdelete(string key, collection items);

  /**
   * 判断hash表中是否有该项的值
   * @param key 键 不能为null
   * @param item 项 不能为null
   * @return true 存在 false不存在
   */
  boolean hashhaskey(string key, string item);

  /**
   * hash递增 如果不存在,就会创建一个 并把新增后的值返回
   * @param key 键
   * @param item 项
   * @param value 要增加几(大于0)
   * @return 递增后结果
   */
  double hashincr(string key, string item, double value);

  /**
   * hash递减
   * @param key 键
   * @param item 项
   * @param value 要减少记(小于0)
   * @return 递减后结果
   */
  double hashdecr(string key, string item, double value);

  // ============================set=============================
  /**
   * 根据key获取set中的所有值
   * @param key 键
   * @return set集合
   */
  set<object> setget(string key);

  /**
   * 根据value从一个set中查询,是否存在
   * @param key 键
   * @param value 值
   * @return true 存在 false不存在
   */
  boolean setismember(string key, object value);

  /**
   * 将数据放入set缓存
   * @param key 键
   * @param values 值 可以是多个
   * @return 成功个数
   */
  long setadd(string key, object... values);

  /**
   * 将数据放入set缓存
   * @param key 键
   * @param values 值 可以是多个
   * @return 成功个数
   */
  long setadd(string key, collection values);

  /**
   * 将set数据放入缓存
   * @param key 键
   * @param time 时间(秒)
   * @param values 值 可以是多个
   * @return 成功个数
   */
  long setadd(string key, long time, object... values);

  /**
   * 获取set缓存的长度
   * @param key 键
   * @return set长度
   */
  long setsize(string key);

  /**
   * 移除值为value的
   * @param key 键
   * @param values 值 可以是多个
   * @return 移除的个数
   */
  long setremove(string key, object... values);

  // ===============================list=================================
  /**
   * 获取list缓存的内容
   * @param key 键
   * @param start 开始
   * @param end 结束 0 到 -1代表所有值
   * @return 缓存列表
   */
  list<object> listrange(string key, long start, long end);

  /**
   * 获取list缓存的长度
   * @param key 键
   * @return 长度
   */
  long listsize(string key);

  /**
   * 通过索引 获取list中的值
   * @param key 键
   * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
   * @return 值
   */
  object listindex(string key, long index);

  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   */
  void listrightpush(string key, object value);

  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   * @param time 时间(秒)
   */
  void listrightpush(string key, object value, long time);

  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   */
  void listrightpushall(string key, list<object> value);

  /**
   * 将list放入缓存
   *
   * @param key 键
   * @param value 值
   * @param time 时间(秒)
   */
  void listrightpushall(string key, list<object> value, long time);

  /**
   * 根据索引修改list中的某条数据
   * @param key 键
   * @param index 索引
   * @param value 值
   */
  void listset(string key, long index, object value);

  /**
   * 移除n个值为value
   * @param key 键
   * @param count 移除多少个
   * @param value 值
   * @return 移除的个数
   */
  long listremove(string key, long count, object value);
}

package com.leven.mybatis.core.service.impl;

import com.leven.commons.model.exception.spiexception;
import com.leven.mybatis.model.constant.constant;
import com.leven.mybatis.core.service.redisservice;
import com.leven.mybatis.model.constant.exceptioncode;
import lombok.extern.slf4j.slf4j;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.stereotype.service;

import java.util.*;
import java.util.concurrent.timeunit;

/**
 * redis基础服务接口实现
 * @author leven
 * @date 2019-09-07
 */
@slf4j
@service
public class redisserviceimpl implements redisservice {

  /**
   * 
   */
  private static final string prefix = constant.application;

  @autowired
  private redistemplate<string, object> redistemplate;

  // =============================common============================
  /**
   * 指定缓存失效时间
   * @param key 键
   * @param time 时间(秒)
   */
  @override
  public void expire(string key, long time) {
    redistemplate.expire(getkey(key), time, timeunit.seconds);
  }

  /**
   * 指定缓存失效时间
   * @param key 键
   * @param expireat 失效时间点
   * @return 处理结果
   */
  @override
  public void expireat(string key, date expireat) {
    redistemplate.expireat(getkey(key), expireat);
  }

  /**
   * 根据key 获取过期时间
   * @param key 键 不能为null
   * @return 时间(秒) 返回0代表为永久有效
   */
  @override
  public long getexpire(string key) {
    return redistemplate.getexpire(getkey(key), timeunit.seconds);
  }

  /**
   * 判断key是否存在
   * @param key 键
   * @return true 存在 false不存在
   */
  @override
  public boolean haskey(string key) {
    return redistemplate.haskey(getkey(key));
  }

  /**
   * 删除缓存
   * @param keys 可以传一个值 或多个
   */
  @override
  public void delete(string... keys) {
    if (keys != null && keys.length > 0) {
      if (keys.length == 1) {
        redistemplate.delete(getkey(keys[0]));
      } else {
        list<string> keylist = new arraylist<>(keys.length);
        for (string key : keys) {
          keylist.add(getkey(key));
        }
        redistemplate.delete(keylist);
      }
    }
  }

  /**
   * 删除缓存
   * @param keys 可以传一个值 或多个
   */
  @override
  public void delete(collection<string> keys) {
    if (keys != null && !keys.isempty()) {
      list<string> keylist = new arraylist<>(keys.size());
      for (string key : keys) {
        keylist.add(getkey(key));
      }
      redistemplate.delete(keylist);
    }
  }

  // ============================string=============================
  /**
   * 普通缓存获取
   * @param key 键
   * @return 值
   */
  @override
  public object get(string key) {
    return key == null ? null : redistemplate.opsforvalue().get(getkey(key));
  }

  /**
   * 普通缓存放入
   * @param key 键
   * @param value 值
   */
  @override
  public void set(string key, object value) {
    redistemplate.opsforvalue().set(getkey(key), value);
  }

  /**
   * 普通缓存放入并设置时间
   * @param key 键
   * @param value 值
   * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
   */
  @override
  public void set(string key, object value, long time) {
    set(key, value, time, timeunit.seconds);
  }

  /**
   * 普通缓存放入并设置时间
   * @param key 键
   * @param value 值
   * @param time 时间 time要大于0 如果time小于等于0 将设置无限期
   * @param timeunit 时间单位
   */
  @override
  public void set(string key, object value, long time, timeunit timeunit) {
    if (time > 0) {
      redistemplate.opsforvalue().set(getkey(key), value, time, timeunit);
    } else {
      set(getkey(key), value);
    }
  }

  /**
   * 递增
   * @param key 键
   * @param value 要增加几(大于0)
   * @return 递增后结果
   */
  @override
  public long incr(string key, long value) {
    if (value < 1) {
      throw new spiexception(exceptioncode.runtime_unite_exp,"递增因子必须大于0");
    }
    return redistemplate.opsforvalue().increment(getkey(key), value);
  }

  /**
   * 递减
   * @param key 键
   * @param value 要减少几(大于0)
   * @return 递减后结果
   */
  @override
  public long decr(string key, long value) {
    if (value < 1) {
      throw new spiexception(exceptioncode.runtime_unite_exp,"递减因子必须大于0");
    }
    return redistemplate.opsforvalue().decrement(getkey(key), value);
  }

  // ================================map=================================
  /**
   * hashget
   * @param key 键 不能为null
   * @param item 项 不能为null
   * @return 值
   */
  @override
  public object hashget(string key, string item) {
    return redistemplate.opsforhash().get(getkey(key), item);
  }

  /**
   * 获取hashkey对应的所有键值
   * @param key 键
   * @return 对应的多个键值
   */
  @override
  public map<object, object> hashentries(string key) {
    return redistemplate.opsforhash().entries(getkey(key));
  }

  /**
   * hashset
   * @param key 键
   * @param map 对应多个键值
   */
  @override
  public void hashset(string key, map<string, object> map) {
    redistemplate.opsforhash().putall(getkey(key), map);
  }

  /**
   * hashset 并设置时间
   * @param key 键
   * @param map 对应多个键值
   * @param time 时间(秒)
   */
  @override
  public void hashset(string key, map<string, object> map, long time) {
    string k = getkey(key);
    redistemplate.opsforhash().putall(k, map);
    if (time > 0) {
      expire(k, time);
    }
  }

  /**
   * 向一张hash表中放入数据,如果不存在将创建
   * @param key 键
   * @param item 项
   * @param value 值
   */
  @override
  public void hashset(string key, string item, object value) {
    redistemplate.opsforhash().putifabsent(getkey(key), item, value);
  }

  /**
   * 向一张hash表中放入数据,如果不存在将创建
   * @param key 键
   * @param item 项
   * @param value 值
   * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
   */
  @override
  public void hashset(string key, string item, object value, long time) {
    string k = getkey(key);
    redistemplate.opsforhash().putifabsent(k, item, value);
    if (time > 0) {
      expire(k, time);
    }
  }

  /**
   * 删除hash表中的值
   * @param key 键 不能为null
   * @param item 项 可以使多个 不能为null
   */
  @override
  public void hashdelete(string key, object... item) {
    redistemplate.opsforhash().delete(getkey(key), item);
  }

  /**
   * 删除hash表中的值
   * @param key 键 不能为null
   * @param items 项 可以使多个 不能为null
   */
  @override
  public void hashdelete(string key, collection items) {
    redistemplate.opsforhash().delete(getkey(key), items.toarray());
  }

  /**
   * 判断hash表中是否有该项的值
   * @param key 键 不能为null
   * @param item 项 不能为null
   * @return true 存在 false不存在
   */
  @override
  public boolean hashhaskey(string key, string item) {
    return redistemplate.opsforhash().haskey(getkey(key), item);
  }

  /**
   * hash递增 如果不存在,就会创建一个 并把新增后的值返回
   * @param key 键
   * @param item 项
   * @param value 要增加几(大于0)
   * @return 递增后结果
   */
  @override
  public double hashincr(string key, string item, double value) {
    if (value < 1) {
      throw new spiexception(exceptioncode.runtime_unite_exp,"递增因子必须大于0");
    }
    return redistemplate.opsforhash().increment(getkey(key), item, value);
  }

  /**
   * hash递减
   * @param key 键
   * @param item 项
   * @param value 要减少记(小于0)
   * @return 递减后结果
   */
  @override
  public double hashdecr(string key, string item, double value) {
    if (value < 1) {
      throw new spiexception(exceptioncode.runtime_unite_exp,"递减因子必须大于0");
    }
    return redistemplate.opsforhash().increment(getkey(key), item, -value);
  }

  // ============================set=============================
  /**
   * 根据key获取set中的所有值
   * @param key 键
   * @return set集合
   */
  @override
  public set<object> setget(string key) {
    return redistemplate.opsforset().members(getkey(key));
  }

  /**
   * 根据value从一个set中查询,是否存在
   * @param key 键
   * @param value 值
   * @return true 存在 false不存在
   */
  @override
  public boolean setismember(string key, object value) {
    return redistemplate.opsforset().ismember(getkey(key), value);
  }

  /**
   * 将数据放入set缓存
   * @param key 键
   * @param values 值 可以是多个
   * @return 成功个数
   */
  @override
  public long setadd(string key, object... values) {
    return redistemplate.opsforset().add(getkey(key), values);
  }

  /**
   * 将数据放入set缓存
   * @param key 键
   * @param values 值 可以是多个
   * @return 成功个数
   */
  @override
  public long setadd(string key, collection values) {
    return redistemplate.opsforset().add(getkey(key), values.toarray());
  }

  /**
   * 将set数据放入缓存
   * @param key 键
   * @param time 时间(秒)
   * @param values 值 可以是多个
   * @return 成功个数
   */
  @override
  public long setadd(string key, long time, object... values) {
    string k = getkey(key);
    long count = redistemplate.opsforset().add(k, values);
    if (time > 0){
      expire(k, time);
    }
    return count;
  }

  /**
   * 获取set缓存的长度
   * @param key 键
   * @return set长度
   */
  @override
  public long setsize(string key) {
    return redistemplate.opsforset().size(getkey(key));
  }

  /**
   * 移除值为value的
   * @param key 键
   * @param values 值 可以是多个
   * @return 移除的个数
   */
  @override
  public long setremove(string key, object... values) {
    return redistemplate.opsforset().remove(getkey(key), values);
  }

  // ===============================list=================================
  /**
   * 获取list缓存的内容
   * @param key 键
   * @param start 开始
   * @param end 结束 0 到 -1代表所有值
   * @return 缓存列表
   */
  @override
  public list<object> listrange(string key, long start, long end) {
    return redistemplate.opsforlist().range(getkey(key), start, end);
  }

  /**
   * 获取list缓存的长度
   * @param key 键
   * @return 长度
   */
  @override
  public long listsize(string key) {
    return redistemplate.opsforlist().size(getkey(key));
  }

  /**
   * 通过索引 获取list中的值
   * @param key 键
   * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
   * @return 值
   */
  @override
  public object listindex(string key, long index) {
    return redistemplate.opsforlist().index(getkey(key), index);
  }

  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   */
  @override
  public void listrightpush(string key, object value) {
    redistemplate.opsforlist().rightpush(getkey(key), value);
  }

  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   * @param time 时间(秒)
   */
  @override
  public void listrightpush(string key, object value, long time) {
    string k = getkey(key);
    redistemplate.opsforlist().rightpush(k, value);
    if (time > 0){
      expire(k, time);
    }
  }

  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   */
  @override
  public void listrightpushall(string key, list<object> value) {
    redistemplate.opsforlist().rightpushall(getkey(key), value);
  }

  /**
   * 将list放入缓存
   *
   * @param key 键
   * @param value 值
   * @param time 时间(秒)
   */
  @override
  public void listrightpushall(string key, list<object> value, long time) {
    string k = getkey(key);
    redistemplate.opsforlist().rightpushall(k, value);
    if (time > 0) {
      expire(k, time);
    }
  }

  /**
   * 根据索引修改list中的某条数据
   * @param key 键
   * @param index 索引
   * @param value 值
   */
  @override
  public void listset(string key, long index, object value) {
    redistemplate.opsforlist().set(getkey(key), index, value);
  }

  /**
   * 移除n个值为value
   * @param key 键
   * @param count 移除多少个
   * @param value 值
   * @return 移除的个数
   */
  @override
  public long listremove(string key, long count, object value) {
    return redistemplate.opsforlist().remove(getkey(key), count, value);
  }

  private string getkey(string key) {
    return prefix + ":" + key;
  }
}

package com.leven.mybatis.core.cache;

import com.leven.commons.core.util.applicationcontextutils;
import com.leven.commons.model.exception.spiexception;
import com.leven.mybatis.core.service.redisservice;
import com.leven.mybatis.model.constant.exceptioncode;
import lombok.extern.slf4j.slf4j;
import org.apache.commons.lang3.randomutils;
import org.apache.ibatis.cache.cache;

import java.security.messagedigest;
import java.util.hashset;
import java.util.map;
import java.util.set;
import java.util.concurrent.timeunit;
import java.util.concurrent.locks.readwritelock;
import java.util.concurrent.locks.reentrantreadwritelock;

/**
 * mybatis二级缓存redis实现
 * 重点处理以下几个问题
 * 1、缓存穿透：存储空值解决，mybatis框架实现
 * 2、缓存击穿：使用互斥锁，我们自己实现
 * 3、缓存雪崩：缓存有效期设置为一个随机范围，我们自己实现
 * 4、读写性能：redis key不能过长，会影响性能，这里使用sha-256计算摘要当成key
 * @author leven
 * @date 2019-09-07
 */
@slf4j
public class mybatisrediscache implements cache {

  /**
   * 统一字符集
   */
  private static final string charset = "utf-8";
  /**
   * key摘要算法
   */
  private static final string algorithm = "sha-256";
  /**
   * 统一缓存头
   */
  private static final string cache_name = "mybatis:";
  /**
   * 读写锁：解决缓存击穿
   */
  private final readwritelock readwritelock = new reentrantreadwritelock();
  /**
   * 表空间id：方便后面的缓存清理
   */
  private final string id;
  /**
   * redis服务接口：提供基本的读写和清理
   */
  private static volatile redisservice redisservice;
  /**
   * 信息摘要
   */
  private volatile messagedigest messagedigest;

  /////////////////////// 解决缓存雪崩，具体范围根据业务需要设置合理值 //////////////////////////
  /**
   * 缓存最小有效期
   */
  private static final int min_expire_minutes = 60;
  /**
   * 缓存最大有效期
   */
  private static final int max_expire_minutes = 120;

  /**
   * mybatis给每个表空间初始化的时候要用到
   * @param id 其实就是namespace的值
   */
  public mybatisrediscache(string id) {
    if (id == null) {
      throw new illegalargumentexception("cache instances require an id");
    }
    this.id = id;
  }

  /**
   * 获取id
   * @return 真实值
   */
  @override
  public string getid() {
    return id;
  }

  /**
   * 创建缓存
   * @param key 其实就是sql语句
   * @param value sql语句查询结果
   */
  @override
  public void putobject(object key, object value) {
    try {
      string strkey = getkey(key);
      // 有效期为1~2小时之间随机，防止雪崩
      int expireminutes = randomutils.nextint(min_expire_minutes, max_expire_minutes);
      getredisservice().set(strkey, value, expireminutes, timeunit.minutes);
      log.debug("put cache to redis, id={}", id);
    } catch (exception e) {
      log.error("redis put failed, id=" + id, e);
    }
  }

  /**
   * 读取缓存
   * @param key 其实就是sql语句
   * @return 缓存结果
   */
  @override
  public object getobject(object key) {
    try {
      string strkey = getkey(key);
      log.debug("get cache from redis, id={}", id);
      return getredisservice().get(strkey);
    } catch (exception e) {
      log.error("redis get failed, fail over to db", e);
      return null;
    }
  }

  /**
   * 删除缓存
   * @param key 其实就是sql语句
   * @return 结果
   */
  @override
  public object removeobject(object key) {
    try {
      string strkey = getkey(key);
      getredisservice().delete(strkey);
      log.debug("remove cache from redis, id={}", id);
    } catch (exception e) {
      log.error("redis remove failed", e);
    }
    return null;
  }

  /**
   * 缓存清理
   * 网上好多博客这里用了flushdb甚至是flushall，感觉好坑鸭！
   * 应该是根据表空间进行清理
   */
  @override
  public void clear() {
    try {
      log.debug("clear cache, id={}", id);
      string hskey = cache_name + id;
      // 获取cachenamespace所有缓存key
      map<object, object> idmap = getredisservice().hashentries(hskey);
      if (!idmap.isempty()) {
        set<object> keyset = idmap.keyset();
        set<string> keys = new hashset<>(keyset.size());
        keyset.foreach(item -> keys.add(item.tostring()));
        // 清空cachenamespace所有缓存
        getredisservice().delete(keys);
        // 清空cachenamespace
        getredisservice().delete(hskey);
      }
    } catch (exception e) {
      log.error("clear cache failed", e);
    }
  }

  /**
   * 获取缓存大小，暂时没用上
   * @return 长度
   */
  @override
  public int getsize() {
    return 0;
  }

  /**
   * 获取读写锁：为了解决缓存击穿
   * @return 锁
   */
  @override
  public readwritelock getreadwritelock() {
    return readwritelock;
  }

  /**
   * 计算出key的摘要
   * @param cachekey cachekey
   * @return 字符串key
   */
  private string getkey(object cachekey) {
    string cachekeystr = cachekey.tostring();
    log.debug("count hash key, cache key origin string:{}", cachekeystr);
    string strkey = byte2hex(getshadigest(cachekeystr));
    log.debug("hash key:{}", strkey);
    string key = cache_name + strkey;
    // 在redis额外维护cachenamespace创建的key，clear的时候只清理当前cachenamespace的数据
    getredisservice().hashset(cache_name + id, key, "1");
    return key;
  }

  /**
   * 获取信息摘要
   * @param data 待计算字符串
   * @return 字节数组
   */
  private byte[] getshadigest(string data) {
    try {
      if (messagedigest == null) {
        synchronized (messagedigest.class) {
          if (messagedigest == null) {
            messagedigest = messagedigest.getinstance(algorithm);
          }
        }
      }
      return messagedigest.digest(data.getbytes(charset));
    } catch (exception e) {
      log.error("sha-256 digest error: ", e);
      throw new spiexception(exceptioncode.runtime_unite_exp,"sha-256 digest error, id=" + id + ".");
    }
  }

  /**
   * 字节数组转16进制字符串
   * @param bytes 待转换数组
   * @return 16进制字符串
   */
  private string byte2hex(byte[] bytes) {
    stringbuilder sign = new stringbuilder();
    for (byte abyte : bytes) {
      string hex = integer.tohexstring(abyte & 0xff);
      if (hex.length() == 1) {
        sign.append("0");
      }
      sign.append(hex.touppercase());
    }
    return sign.tostring();
  }

  /**
   * 获取redis服务接口
   * 使用双重检查保证线程安全
   * @return 服务实例
   */
  private redisservice getredisservice() {
    if (redisservice == null) {
      synchronized (redisservice.class) {
        if (redisservice == null) {
          redisservice = applicationcontextutils.getbeanbyclass(redisservice.class);
        }
      }
    }
    return redisservice;
  }
}