SSM整合 redis 實現緩存管理

1.maven依賴

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.8.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

2.spring整合配置

<!-- redis數據源 -->
<!-- 加載配置文件 -->
<context:property-placeholder location="/WEB-INF/config/redis.properties"/>
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <!-- 最大空閒數 -->
    <property name="maxIdle" value="${redis.maxIdle}"/>
    <!-- 最大空連接數 -->
    <property name="maxTotal" value="${redis.maxTotal}"/>
    <!-- 最大等待時間 -->
    <property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>
    <!-- 連接超時時是否阻塞，false時報異常,ture阻塞直到超時, 默認true -->
    <property name="blockWhenExhausted" value="${redis.blockWhenExhausted}"/>
    <!-- 返回連接時，檢測連接是否成功 -->
    <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
</bean>
<!-- 連接池管理工廠 -->
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    <!-- IP地址 -->
    <property name="hostName" value="${redis.host}"/>
    <!-- 指定db -->
    <property name="database" value="${redis.database}"/>
    <!-- 端口號 -->
    <property name="port" value="${redis.port}"/>
    <!-- 超時時間 默認2000-->
    <property name="timeout" value="${redis.timeout}"/>
    <!-- 連接池配置引用 -->
    <property name="poolConfig" ref="poolConfig"/>
    <!-- usePool：是否使用連接池 -->
    <property name="usePool" value="true"/>
</bean>
<!-- redis template definition -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <property name="connectionFactory" ref="jedisConnectionFactory"/>
    <property name="keySerializer">
        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    </property>
    <property name="valueSerializer">
        <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
    </property>
    <property name="hashKeySerializer">
        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    </property>
    <property name="hashValueSerializer">
        <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
    </property>
    <!--開啓事務  -->
    <property name="enableTransactionSupport" value="true"></property>
</bean>
<!--自定義redis工具類,在需要緩存的地方注入此類  -->
<bean id="redisrCacheManager" class="hotkidclub.redis.RedisCacheManager">
    <property name="redisTemplate" ref="redisTemplate"/>
</bean>

redis數據庫鏈接參數:redis.propertiesr

#本地/測試服host
redis.host=127.0.0.1
#dev服密碼
redis.password=
#指定數據庫
redis.database=1
redis.port=6379
redis.maxIdle=50
redis.maxTotal=100
redis.maxWaitMillis=1000
redis.blockWhenExhausted=true
redis.testOnBorrow=true
redis.timeout=3000
defaultCacheExpireTime=60

3. Redis 工具類 : 封裝redis緩存操作API

 

package hotkidclub.redis;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis 工具類 : 封裝redis緩存操作API
 * <p>
 * 1.操作value爲String
 * <p>
 * 2.操作value爲Map
 * <p>
 * 2.操作value爲list
 * <p>
 * 2.操作value爲set
 * <p>
 *
 * @date 2020.02.06
 */
public class RedisCacheManager {

   private RedisTemplate<String, Object> redisTemplate;

   public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
      this.redisTemplate = redisTemplate;
   }

   /**
    * 指定緩存失效時間
    *
    * @param key 鍵
    * @param time 時間(秒)
    * @return
    */
   public boolean expire(String key, long time) {
      try {
         if (time > 0) {
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
         }
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 根據key 獲取過期時間
    *
    * @param key 鍵 不能爲null
    * @return 時間(秒) 返回0代表爲永久有效
    */
   public long getExpire(String key) {
      return redisTemplate.getExpire(key, TimeUnit.SECONDS);
   }

   /**
    * 判斷key是否存在
    *
    * @param key 鍵
    * @return true 存在 false不存在
    */
   public boolean ifHasKey(String key) {
      try {
         return redisTemplate.hasKey(key);
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 刪除緩存
    *
    * @param key 鍵-支持多個string參數:str1,str2,str3...
    */
   @SuppressWarnings("unchecked")
   public void dellete(String... key) {
      if (key != null && key.length > 0) {
         if (key.length == 1) {
            redisTemplate.delete(key[0]);
         }
         else {
            redisTemplate.delete(CollectionUtils.arrayToList(key));
         }
      }
   }

   /**
    * value type=String : API
    */
   /**
    * 獲取緩存
    *
    * @param key 鍵
    * @return 值
    */
   public Object getStr(String key) {
      return key == null ? null : redisTemplate.opsForValue().get(key);
   }

   /**
    * 放入緩存
    *
    * @param key 鍵
    * @param value 值
    * @return true成功 false失敗
    */
   public boolean setStr(String key, Object value) {
      try {
         redisTemplate.opsForValue().set(key, value);
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 普通緩存放入並設置時間
    *
    * @param key 鍵
    * @param value 值
    * @param time 時間(秒) time要大於0 如果time小於等於0 將設置無限期
    * @return true成功 false 失敗
    */
   public boolean setStrAttachTime(String key, Object value, long time) {
      try {
         if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
         }
         else {
            setStr(key, value);
         }
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 遞增:將鍵的整數值增加1
    *
    * @param key 鍵
    * @param delta 要增加幾(大於0)
    * @return
    */
   public long incr(String key, long delta) {
      if (delta < 0) {
         throw new RuntimeException("遞增因子必須大於0");
      }
      return redisTemplate.opsForValue().increment(key, delta);
   }

   /**
    * 遞減 : 將鍵的整數值減1
    *
    * @param key 鍵
    * @param delta 要減少幾(小於0)
    * @return
    */
   public long decr(String key, long delta) {
      if (delta < 0) {
         throw new RuntimeException("遞減因子必須大於0");
      }
      return redisTemplate.opsForValue().increment(key, -delta);
   }

   /**
    * 2.value type=Map : API
    */
   /**
    * 獲取存儲在指定鍵的哈希字段的值 : Map中某個key的value
    *
    * @param key 鍵 不能爲null
    * @param item 項 不能爲null
    * @return 值
    */
   public Object hget(String key, String item) {
      return redisTemplate.opsForHash().get(key, item);
   }

   /**
    * 獲取存儲在指定鍵的哈希中的所有字段和值 :返回map集合
    *
    * @param key 鍵
    * @return 對應的多個鍵值
    */
   public Map<Object, Object> getMap(String key) {
      return redisTemplate.opsForHash().entries(key);
   }

   /**
    * 放入緩存 : 放入Map
    *
    * @param key 鍵
    * @param map 對應多個鍵值
    * @return true 成功 false 失敗
    */
   public boolean setMap(String key, Map<String, Object> map) {
      try {
         redisTemplate.opsForHash().putAll(key, map);
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 放入緩存,並設置時間
    *
    * @param key 鍵
    * @param map 對應多個鍵值
    * @param time 時間(秒)
    * @return true成功 false失敗
    */
   public boolean setMapAttachTime(String key, Map<String, Object> map, long time) {
      try {
         redisTemplate.opsForHash().putAll(key, map);
         if (time > 0) {
            expire(key, time);
         }
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 向key對應的Map中put鍵值
    *
    * @param key 鍵
    * @param hashKey 項
    * @param value 值
    * @return true 成功 false失敗
    */
   public boolean put(String key, String hashKey, Object value) {
      try {
         redisTemplate.opsForHash().put(key, hashKey, value);
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 向Map中put鍵值-附帶時間
    *
    * @param key 鍵
    * @param hashKey 項
    * @param value 值
    * @param time 時間(秒) 注意:如果已存在的hash表有時間,這裏將會替換原有的時間
    * @return true 成功 false失敗
    */
   public boolean putAttachTime(String key, String hashKey, Object value, long time) {
      try {
         redisTemplate.opsForHash().put(key, hashKey, value);
         if (time > 0) {
            expire(key, time);
         }
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 刪除Map中指定key的值
    *
    * @param key 鍵 不能爲null
    * @param item 項 表示可以傳入多個Map的kek,用','隔開,或用數組傳值 不能爲null
    */
   public void deleteMap(String key, Object... item) {
      redisTemplate.opsForHash().delete(key, item);
   }

   /**
    * 判斷Map中是否有key值
    *
    * @param key 鍵 不能爲null
    * @param hashKey 項 不能爲null
    * @return true 存在 false不存在
    */
   public boolean mapHasKey(String key, String hashKey) {
      return redisTemplate.opsForHash().hasKey(key, hashKey);
   }

   /**
    * value type=list : API
    */
   /**
    * 獲取list緩存的內容:根據index區間
    *
    * @param key 鍵
    * @param startIndex 開始角標
    * @param endIndex 結束角標 0 到 -1代表所有值
    * @return
    */
   public List<Object> getRangeIndex(String key, long startIndex, long endIndex) {
      try {
         return redisTemplate.opsForList().range(key, startIndex, endIndex);
      }
      catch (Exception e) {
         e.printStackTrace();
         return null;
      }
   }

   /**
    * 獲取list緩存的長度
    *
    * @param key 鍵
    * @return
    */
   public long getListSize(String key) {
      try {
         return redisTemplate.opsForList().size(key);
      }
      catch (Exception e) {
         e.printStackTrace();
         return 0;
      }
   }

   /**
    * 通過索引 獲取list中的值
    *
    * @param key 鍵
    * @param index 索引 index>=0時， 0 表頭，1 第二個元素，依次類推；index<0時，-1，表尾，-2倒數第二個元素，依次類推
    * @return
    */
   public Object getIndex(String key, long index) {
      try {
         return redisTemplate.opsForList().index(key, index);
      }
      catch (Exception e) {
         e.printStackTrace();
         return null;
      }
   }

   /**
    * 將list放入緩存: 將數據從右向左(尾部)存壓棧 / 將數據從左向右(頭部)存壓棧
    *
    * @param key 鍵
    * @param value 值
    * @param sortType 值 1右 /2 左
    * @return
    */
   public boolean setListFromRL(String key, Object value, Integer sortType) {
      if (sortType == 1) {
         redisTemplate.opsForList().rightPush(key, value);
      }
      else {
         redisTemplate.opsForList().leftPush(key, value);
      }
      try {
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 將list放入緩存: 將數據從右向左(尾部)存壓棧 / 將數據從左向右(頭部)存壓棧
    *
    * @param key 鍵
    * @param value 值
    * @param sortType 值 1右 /2 左
    * @return
    */
   public boolean setListFromRLAttachTime(String key, Object value, Integer sortType, long time) {
      if (sortType == 1) {
         redisTemplate.opsForList().rightPush(key, value);
      }
      else {
         redisTemplate.opsForList().leftPush(key, value);
      }
      try {
         if (time > 0)
            expire(key, time);
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 將list放入緩存: 將數據從右向左(尾部)存壓棧 / 將數據從左向右(頭部)存壓棧
    *
    * @param key 鍵
    * @param value 值
    * @param sortType 值 1右 /2 左
    * @return
    */
   public boolean setListAllFromRL(String key, Object value, Integer sortType) {
      if (sortType == 1) {
         redisTemplate.opsForList().rightPushAll(key, value);
      }
      else {
         redisTemplate.opsForList().leftPushAll(key, value);
      }
      try {
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 將list放入緩存: 將數據從右向左(尾部)存壓棧 / 將數據從左向右(頭部)存壓棧
    *
    * @param key 鍵
    * @param value 值
    * @param sortType 值 1右 /2 左
    * @return
    */
   public boolean setListAllFromRLAttachTime(String key, Object value, Integer sortType, long time) {
      if (sortType == 1) {
         redisTemplate.opsForList().rightPushAll(key, value);
      }
      else {
         redisTemplate.opsForList().leftPushAll(key, value);
      }
      try {
         if (time > 0) {
            expire(key, time);
         }
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 根據索引修改list中的某條數據
    *
    * @param key 鍵
    * @param index 索引
    * @param value 值
    * @return
    */
   public boolean listUpdateIndex(String key, long index, Object value) {
      try {
         redisTemplate.opsForList().set(key, index, value);
         return true;
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 移除N個值爲value
    *
    * @param key 鍵
    * @param count 移除多少個
    * @param value 值
    * @return 移除的個數
    */
   public long listRemove(String key, long count, Object value) {
      try {
         Long remove = redisTemplate.opsForList().remove(key, count, value);
         return remove;
      }
      catch (Exception e) {
         e.printStackTrace();
         return 0;
      }
   }

   /**
    * value type=set : API
    */
   /**
    * 根據key獲取Set中的所有值
    *
    * @param key 鍵
    * @return
    */
   public Set<Object> sGet(String key) {
      try {
         return redisTemplate.opsForSet().members(key);
      }
      catch (Exception e) {
         e.printStackTrace();
         return null;
      }
   }

   /**
    * 根據value從一個set中查詢,是否存在
    *
    * @param key 鍵
    * @param value 值
    * @return true 存在 false不存在
    */
   public boolean sHasKey(String key, Object value) {
      try {
         return redisTemplate.opsForSet().isMember(key, value);
      }
      catch (Exception e) {
         e.printStackTrace();
         return false;
      }
   }

   /**
    * 將數據放入set緩存
    *
    * @param key 鍵
    * @param values 值 可以是多個
    * @return 成功個數
    */
   public long sSet(String key, Object... values) {
      try {
         return redisTemplate.opsForSet().add(key, values);
      }
      catch (Exception e) {
         e.printStackTrace();
         return 0;
      }
   }

   /**
    * 將set數據放入緩存
    *
    * @param key 鍵
    * @param time 時間(秒)
    * @param values 值 可以是多個
    * @return 成功個數
    */
   public long sSetAndTime(String key, long time, Object... values) {
      try {
         Long count = redisTemplate.opsForSet().add(key, values);
         if (time > 0)
            expire(key, time);
         return count;
      }
      catch (Exception e) {
         e.printStackTrace();
         return 0;
      }
   }

   /**
    * 獲取set緩存的長度
    *
    * @param key 鍵
    * @return
    */
   public long sGetSetSize(String key) {
      try {
         return redisTemplate.opsForSet().size(key);
      }
      catch (Exception e) {
         e.printStackTrace();
         return 0;
      }
   }

   /**
    * 移除值爲value的
    *
    * @param key 鍵
    * @param values 值 可以是多個
    * @return 移除的個數
    */
   public long setRemove(String key, Object... values) {
      try {
         Long count = redisTemplate.opsForSet().remove(key, values);
         return count;
      }
      catch (Exception e) {
         e.printStackTrace();
         return 0;
      }
   }
}