利用redis進行springSession的儲存：

儲存：

// 在session中儲存使用者資訊
       HttpSession session = httpRequest.getSession(true);
       session.setAttribute(Constants.SESSION_KEY_USER + userToken,user);
       // 儲存sessionId
       redisService.hmSet(Constants.SESSION_ID_KEY,userToken,session.getId());

獲取：

  String sessionId = (String) redisService.hmGet(Constants.SESSION_ID_KEY,userToken);
    String key = "spring:session:sessions:" + sessionId;
    String hashKey = "sessionAttr:" + Constants.SESSION_KEY_USER + userToken;
    T_user user = (T_user) redisService.hmGet(key,hashKey);
 redisService中的hmSet和hmGet的程式碼：

public void hmSet(String key,String hashKey,Object value) {

    redisTemplate.opsForHash().put(key,hashKey,value);
  }



  public Object hmGet(String key,Object hashKey) {
    HashOperations<Object,Object,Object> hash = redisTemplate.opsForHash();
    return hash.get(key,hashKey);
  }

詳細程式碼：

package com.handsight.platform.fras.service.impl;

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

import javax.annotation.Resource;

import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.stereotype.Service;

import com.handsight.platform.fras.constant.Constants;
import com.handsight.platform.fras.mgt.pojo.T_user;
import com.handsight.platform.fras.service.RedisService;

/**
 * @author Carey 2018年1月23日
 *
 *     redis 操作工具類
 */
@Service
public class RedisServiceImpl implements RedisService {


  @Resource(name = "FrasRedisTemplate")
  private RedisTemplate<Object,Object> redisTemplate;

  public RedisTemplate<Object,Object> getInstance() {
    return redisTemplate;
  }

  /**
   *
   * 判斷key是否存在
   *
   * @param key
   * @return
   */
  @Override
  public boolean hasKey(String key) {
    return redisTemplate.hasKey(key);
  }

  /**
   * 設定 String 型別 key-value
   *
   * @param key
   * @param value
   */
  @Override
  public void set(String key,String value) {
    redisTemplate.opsForValue().set(key,value);
  }

  /**
   * 獲取 String 型別 key-value
   *
   * @param key
   * @return
   */
  @Override
  public String get(String key) {
    return (String) redisTemplate.opsForValue().get(key);
  }

  /**
   * 設定 String 型別 key-value 並新增過期時間 (毫秒單位)
   *
   * @param key
   * @param value
   * @param time 過期時間,毫秒單位
   */
  @Override
  public void setForTimeMS(String key,String value,long time) {
    redisTemplate.opsForValue().set(key,value,time,TimeUnit.MILLISECONDS);
  }

  /**
   * 設定 String 型別 key-value 並新增過期時間 (分鐘單位)
   *
   * @param key
   * @param value
   * @param time 過期時間,分鐘單位
   */
  public void setForTimeMIN(String key,TimeUnit.MINUTES);
  }

  /**
   * 設定 String 型別 key-value 並新增過期時間 (分鐘單位)
   *
   * @param key
   * @param value
   * @param time 過期時間,分鐘單位
   */
  public void setForTimeCustom(String key,long time,TimeUnit type) {
    redisTemplate.opsForValue().set(key,type);
  }

  /**
   * 如果 key 存在則覆蓋,並返回舊值. 如果不存在,返回null 並新增
   *
   * @param key
   * @param value
   * @return
   */
  public String getAndSet(String key,String value) {
    return (String) redisTemplate.opsForValue().getAndSet(key,value);
  }

  /**
   * 批量新增 key-value (重複的鍵會覆蓋)
   *
   * @param keyAndValue
   */
  public void batchSet(Map<String,String> keyAndValue) {
    redisTemplate.opsForValue().multiSet(keyAndValue);
  }

  /**
   * 批量新增 key-value 只有在鍵不存在時,才新增 map 中只要有一個key存在,則全部不新增
   *
   * @param keyAndValue
   */
  public void batchSetIfAbsent(Map<String,String> keyAndValue) {
    redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
  }

  /**
   * 對一個 key-value 的值進行加減操作,如果該 key 不存在 將建立一個key 並賦值該 number 如果 key 存在,但 value
   * 不是長整型,將報錯
   *
   * @param key
   * @param number
   */
  public Long increment(String key,long number) {
    return redisTemplate.opsForValue().increment(key,number);
  }

  /**
   * 對一個 key-value 的值進行加減操作,但 value 不是
   * 純數字,將報錯
   *
   * @param key
   * @param number
   */
  public Double increment(String key,double number) {
    return redisTemplate.opsForValue().increment(key,number);
  }

  /**
   * 給一個指定的 key 值附加過期時間
   *
   * @param key
   * @param time
   * @param type
   * @return
   */
  public boolean expire(String key,TimeUnit type) {
    return redisTemplate.boundValueOps(key).expire(time,type);
  }

  /**
   * 移除指定key 的過期時間
   *
   * @param key
   * @return
   */
  public boolean persist(String key) {
    return redisTemplate.boundValueOps(key).persist();
  }

  /**
   * 獲取指定key 的過期時間
   *
   * @param key
   * @return
   */
  public Long getExpire(String key) {
    return redisTemplate.boundValueOps(key).getExpire();
  }

  /**
   * 修改 key
   *
   * @param key
   * @return
   */
  public void rename(String key,String newKey) {
    redisTemplate.boundValueOps(key).rename(newKey);
  }

  /**
   * 刪除 key-value
   * @param key
   * @return
   */
  @Override
  public void delete(String key){
     redisTemplate.delete(key);
  }

  // hash操作

  /**
   * 新增 Hash 鍵值對
   *
   * @param key
   * @param hashKey
   * @param value
   */
  public void put(String key,String value) {
    redisTemplate.opsForHash().put(key,value);
  }

  /**
   * 批量新增 hash 的 鍵值對 有則覆蓋,沒有則新增
   *
   * @param key
   * @param map
   */
  public void putAll(String key,Map<String,String> map) {
    redisTemplate.opsForHash().putAll(key,map);
  }

  /**
   * 新增 hash 鍵值對. 不存在的時候才新增
   *
   * @param key
   * @param hashKey
   * @param value
   * @return
   */
  public boolean putIfAbsent(String key,String value) {
    return redisTemplate.opsForHash().putIfAbsent(key,value);
  }

  /**
   * 刪除指定 hash 的 HashKey
   *
   * @param key
   * @param hashKeys
   * @return 刪除成功的 數量
   */
  public Long delete(String key,String... hashKeys) {
    return redisTemplate.opsForHash().delete(key,hashKeys);
  }

  /**
   * 給指定 hash 的 hashkey 做增減操作
   *
   * @param key
   * @param hashKey
   * @param number
   * @return
   */
  public Long increment(String key,long number) {
    return redisTemplate.opsForHash().increment(key,number);
  }

  /**
   * 給指定 hash 的 hashkey 做增減操作
   *
   * @param key
   * @param hashKey
   * @param number
   * @return
   */
  public Double increment(String key,Double number) {
    return redisTemplate.opsForHash().increment(key,number);
  }

  /**
   * 獲取指定 key 下的 hashkey
   *
   * @param key
   * @param hashKey
   * @return
   */
  public Object getHashKey(String key,String hashKey) {
    return redisTemplate.opsForHash().get(key,hashKey);
  }

  /**
   * 獲取 key 下的 所有 hashkey 和 value
   *
   * @param key
   * @return
   */
  public Map<Object,Object> getHashEntries(String key) {
    return redisTemplate.opsForHash().entries(key);
  }

  /**
   * 驗證指定 key 下 有沒有指定的 hashkey
   *
   * @param key
   * @param hashKey
   * @return
   */
  public boolean hashKey(String key,String hashKey) {
    return redisTemplate.opsForHash().hasKey(key,hashKey);
  }

  /**
   * 獲取 key 下的 所有 hashkey 欄位名
   *
   * @param key
   * @return
   */
  public Set<Object> hashKeys(String key) {
    return redisTemplate.opsForHash().keys(key);
  }

  /**
   * 獲取指定 hash 下面的 鍵值對 數量
   *
   * @param key
   * @return
   */
  public Long hashSize(String key) {
    return redisTemplate.opsForHash().size(key);
  }

  // List 操作

  /**
   * 指定 list 從左入棧
   *
   * @param key
   * @return 當前佇列的長度
   */
  @Override
  public Long leftPush(String key,Object value) {
    return redisTemplate.opsForList().leftPush(key,value);
  }

  /**
   * 指定 list 從左出棧 如果列表沒有元素,會堵塞到列表一直有元素或者超時為止
   *
   * @param key
   * @return 出棧的值
   */
  public Object leftPop(String key) {
    return redisTemplate.opsForList().leftPop(key);
  }

  /**
   * 從左邊依次入棧 匯入順序按照 Collection 順序 如: a b c => c b a
   *
   * @param key
   * @param values
   * @return
   */
  public Long leftPushAll(String key,Collection<Object> values) {
    return redisTemplate.opsForList().leftPushAll(key,values);
  }

  /**
   * 指定 list 從右入棧
   *
   * @param key
   * @return 當前佇列的長度
   */
  public Long rightPush(String key,Object value) {
    return redisTemplate.opsForList().rightPush(key,value);
  }

  /**
   * 指定 list 從右出棧 如果列表沒有元素,會堵塞到列表一直有元素或者超時為止
   *
   * @param key
   * @return 出棧的值
   */
  @Override
  public Object rightPop(String key) {
    return redisTemplate.opsForList().rightPop(key);
  }

  /**
   * 從右邊依次入棧 匯入順序按照 Collection 順序 如: a b c => a b c
   *
   * @param key
   * @param values
   * @return
   */
  public Long rightPushAll(String key,Collection<Object> values) {
    return redisTemplate.opsForList().rightPushAll(key,values);
  }

  /**
   * 根據下標獲取值
   *
   * @param key
   * @param index
   * @return
   */
  public Object popIndex(String key,long index) {
    return redisTemplate.opsForList().index(key,index);
  }

  /**
   * 獲取列表指定長度
   *
   * @param key
   * @param index
   * @return
   */
  @Override
  public Long listSize(String key) {
    return redisTemplate.opsForList().size(key);
  }

  /**
   * 獲取列表 指定範圍內的所有值
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public List<Object> listRange(String key,long start,long end) {
    return redisTemplate.opsForList().range(key,start,end);
  }

  /**
   * 刪除 key 中 值為 value 的 count 個數.
   *
   * @param key
   * @param count
   * @param value
   * @return 成功刪除的個數
   */
  public Long listRemove(String key,long count,Object value) {
    return redisTemplate.opsForList().remove(key,count,value);
  }

  /**
   * 刪除 列表 [start,end] 以外的所有元素
   *
   * @param key
   * @param start
   * @param end
   */
  public void listTrim(String key,long end) {
    redisTemplate.opsForList().trim(key,end);

  }

  /**
   * 將 key 右出棧,並左入棧到 key2
   *
   * @param key 右出棧的列表
   * @param key2 左入棧的列表
   * @return 操作的值
   */
  public Object rightPopAndLeftPush(String key,String key2) {
    return redisTemplate.opsForList().rightPopAndLeftPush(key,key2);

  }

  // set 操作 無序不重複集合

  /**
   * 新增 set 元素
   *
   * @param key
   * @param values
   * @return
   */
  public Long add(String key,String... values) {
    return redisTemplate.opsForSet().add(key,values);
  }

  /**
   * 獲取兩個集合的差集
   *
   * @param key
   * @param key2
   * @return
   */
  public Set<Object> difference(String key,String otherkey) {
    return redisTemplate.opsForSet().difference(key,otherkey);
  }

  /**
   * 獲取 key 和 集合 collections 中的 key 集合的差集
   *
   * @param key
   * @param collections
   * @return
   */
  public Set<Object> difference(String key,Collection<Object> otherKeys) {
    return redisTemplate.opsForSet().difference(key,otherKeys);
  }

  /**
   * 將 key 與 otherkey 的差集,新增到新的 newKey 集合中
   *
   * @param key
   * @param otherkey
   * @param newKey
   * @return 返回差集的數量
   */
  public Long differenceAndStore(String key,String otherkey,String newKey) {
    return redisTemplate.opsForSet().differenceAndStore(key,otherkey,newKey);
  }

  /**
   * 將 key 和 集合 collections 中的 key 集合的差集 新增到 newkey 集合中
   *
   * @param key
   * @param otherKeys
   * @param newKey
   * @return 返回差集的數量
   */
  public Long differenceAndStore(String key,Collection<Object> otherKeys,String newKey) {
    return redisTemplate.opsForSet().differenceAndStore(newKey,otherKeys,newKey);
  }

  /**
   * 刪除一個或多個集合中的指定值
   *
   * @param key
   * @param values
   * @return 成功刪除數量
   */
  public Long remove(String key,Object... values) {
    return redisTemplate.opsForSet().remove(key,values);
  }

  /**
   * 隨機移除一個元素,並返回出來
   *
   * @param key
   * @return
   */
  public Object randomSetPop(String key) {
    return redisTemplate.opsForSet().pop(key);
  }

  /**
   * 隨機獲取一個元素
   *
   * @param key
   * @return
   */
  public Object randomSet(String key) {
    return redisTemplate.opsForSet().randomMember(key);
  }

  /**
   * 隨機獲取指定數量的元素,同一個元素可能會選中兩次
   *
   * @param key
   * @param count
   * @return
   */
  public List<Object> randomSet(String key,long count) {
    return redisTemplate.opsForSet().randomMembers(key,count);
  }

  /**
   * 隨機獲取指定數量的元素,去重(同一個元素只能選擇兩一次)
   *
   * @param key
   * @param count
   * @return
   */
  public Set<Object> randomSetDistinct(String key,long count) {
    return redisTemplate.opsForSet().distinctRandomMembers(key,count);
  }

  /**
   * 將 key 中的 value 轉入到 destKey 中
   *
   * @param key
   * @param value
   * @param destKey
   * @return 返回成功與否
   */
  public boolean moveSet(String key,Object value,String destKey) {
    return redisTemplate.opsForSet().move(key,destKey);
  }

  /**
   * 無序集合的大小
   *
   * @param key
   * @return
   */
  public Long setSize(String key) {
    return redisTemplate.opsForSet().size(key);
  }

  /**
   * 判斷 set 集合中 是否有 value
   *
   * @param key
   * @param value
   * @return
   */
  public boolean isMember(String key,Object value) {
    return redisTemplate.opsForSet().isMember(key,value);
  }

  /**
   * 返回 key 和 othere 的並集
   *
   * @param key
   * @param otherKey
   * @return
   */
  public Set<Object> unionSet(String key,String otherKey) {
    return redisTemplate.opsForSet().union(key,otherKey);
  }

  /**
   * 返回 key 和 otherKeys 的並集
   *
   * @param key
   * @param otherKey key 的集合
   * @return
   */
  public Set<Object> unionSet(String key,Collection<Object> otherKeys) {
    return redisTemplate.opsForSet().union(key,otherKeys);
  }

  /**
   * 將 key 與 otherKey 的並集,儲存到 destKey 中
   *
   * @param key
   * @param otherKey
   * @param destKey
   * @return destKey 數量
   */
  public Long unionAndStoreSet(String key,String otherKey,String destKey) {
    return redisTemplate.opsForSet().unionAndStore(key,otherKey,destKey);
  }

  /**
   * 將 key 與 otherKey 的並集,儲存到 destKey 中
   *
   * @param key
   * @param otherKeys
   * @param destKey
   * @return destKey 數量
   */
  public Long unionAndStoreSet(String key,destKey);
  }

  /**
   * 返回集合中所有元素
   *
   * @param key
   * @return
   */
  public Set<Object> members(String key) {
    return redisTemplate.opsForSet().members(key);
  }

  // Zset 根據 socre 排序 不重複 每個元素附加一個 socre double型別的屬性(double 可以重複)

  /**
   * 新增 ZSet 元素
   *
   * @param key
   * @param value
   * @param score
   */
  public boolean add(String key,double score) {
    return redisTemplate.opsForZSet().add(key,score);
  }

  /**
   * 批量新增 Zset <br>
   * Set<TypedTuple<Object>> tuples = new HashSet<>();<br>
   * TypedTuple<Object> objectTypedTuple1 = new
   * DefaultTypedTuple<Object>("zset-5",9.6);<br>
   * tuples.add(objectTypedTuple1);
   *
   * @param key
   * @param tuples
   * @return
   */
  public Long batchAddZset(String key,Set<TypedTuple<Object>> tuples) {
    return redisTemplate.opsForZSet().add(key,tuples);
  }

  /**
   * Zset 刪除一個或多個元素
   *
   * @param key
   * @param values
   * @return
   */
  public Long removeZset(String key,String... values) {
    return redisTemplate.opsForZSet().remove(key,values);
  }

  /**
   * 對指定的 zset 的 value 值,socre 屬性做增減操作
   *
   * @param key
   * @param value
   * @param score
   * @return
   */
  public Double incrementScore(String key,double score) {
    return redisTemplate.opsForZSet().incrementScore(key,score);
  }

  /**
   * 獲取 key 中指定 value 的排名(從0開始,從小到大排序)
   *
   * @param key
   * @param value
   * @return
   */
  public Long rank(String key,Object value) {
    return redisTemplate.opsForZSet().rank(key,value);
  }

  /**
   * 獲取 key 中指定 value 的排名(從0開始,從大到小排序)
   *
   * @param key
   * @param value
   * @return
   */
  public Long reverseRank(String key,Object value) {
    return redisTemplate.opsForZSet().reverseRank(key,value);
  }

  /**
   * 獲取索引區間內的排序結果集合(從0開始,從小到大,帶上分數)
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set<TypedTuple<Object>> rangeWithScores(String key,long end) {
    return redisTemplate.opsForZSet().rangeWithScores(key,end);
  }

  /**
   * 獲取索引區間內的排序結果集合(從0開始,只有列名)
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set<Object> range(String key,long end) {
    return redisTemplate.opsForZSet().range(key,end);
  }

  /**
   * 獲取分數範圍內的 [min,max] 的排序結果集合 (從小到大,只有列名)
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Set<Object> rangeByScore(String key,double min,double max) {
    return redisTemplate.opsForZSet().rangeByScore(key,min,max);
  }

  /**
   * 獲取分數範圍內的 [min,集合帶分數)
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Set<TypedTuple<Object>> rangeByScoreWithScores(String key,double max) {
    return redisTemplate.opsForZSet().rangeByScoreWithScores(key,max);
  }

  /**
   * 返回 分數範圍內 指定 count 數量的元素集合,並且從 offset 下標開始(從小到大,不帶分數的集合)
   *
   * @param key
   * @param min
   * @param max
   * @param offset 從指定下標開始
   * @param count 輸出指定元素數量
   * @return
   */
  public Set<Object> rangeByScore(String key,double max,long offset,long count) {
    return redisTemplate.opsForZSet().rangeByScore(key,max,offset,count);
  }

  /**
   * 返回 分數範圍內 指定 count 數量的元素集合,帶分數的集合)
   *
   * @param key
   * @param min
   * @param max
   * @param offset 從指定下標開始
   * @param count 輸出指定元素數量
   * @return
   */
  public Set<TypedTuple<Object>> rangeByScoreWithScores(String key,long count) {
    return redisTemplate.opsForZSet().rangeByScoreWithScores(key,count);
  }

  /**
   * 獲取索引區間內的排序結果集合(從0開始,從大到小,只有列名)
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set<Object> reverseRange(String key,long end) {
    return redisTemplate.opsForZSet().reverseRange(key,帶上分數)
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set<TypedTuple<Object>> reverseRangeWithScores(String key,long end) {
    return redisTemplate.opsForZSet().reverseRangeWithScores(key,max] 的排序結果集合 (從大到小,集合不帶分數)
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Set<Object> reverseRangeByScore(String key,double max) {
    return redisTemplate.opsForZSet().reverseRangeByScore(key,集合帶分數)
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Set<TypedTuple<Object>> reverseRangeByScoreWithScores(String key,double max) {
    return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,並且從 offset 下標開始(從大到小,不帶分數的集合)
   *
   * @param key
   * @param min
   * @param max
   * @param offset 從指定下標開始
   * @param count 輸出指定元素數量
   * @return
   */
  public Set<Object> reverseRangeByScore(String key,long count) {
    return redisTemplate.opsForZSet().reverseRangeByScore(key,帶分數的集合)
   *
   * @param key
   * @param min
   * @param max
   * @param offset 從指定下標開始
   * @param count 輸出指定元素數量
   * @return
   */
  public Set<TypedTuple<Object>> reverseRangeByScoreWithScores(String key,long count) {
    return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,count);
  }

  /**
   * 返回指定分數區間 [min,max] 的元素個數
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public long countZSet(String key,double max) {
    return redisTemplate.opsForZSet().count(key,max);
  }

  /**
   * 返回 zset 集合數量
   *
   * @param key
   * @return
   */
  public long sizeZset(String key) {
    return redisTemplate.opsForZSet().size(key);
  }

  /**
   * 獲取指定成員的 score 值
   *
   * @param key
   * @param value
   * @return
   */
  public Double score(String key,Object value) {
    return redisTemplate.opsForZSet().score(key,value);
  }

  /**
   * 刪除指定索引位置的成員,其中成員分數按( 從小到大 )
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Long removeRange(String key,long end) {
    return redisTemplate.opsForZSet().removeRange(key,end);
  }

  /**
   * 刪除指定 分數範圍 內的成員 [main,max],其中成員分數按( 從小到大 )
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Long removeRangeByScore(String key,double max) {
    return redisTemplate.opsForZSet().removeRangeByScore(key,max);
  }

  /**
   * key 和 other 兩個集合的並集,儲存在 destKey 集合中,列名相同的 score 相加
   *
   * @param key
   * @param otherKey
   * @param destKey
   * @return
   */
  public Long unionAndStoreZset(String key,String destKey) {
    return redisTemplate.opsForZSet().unionAndStore(key,destKey);
  }

  /**
   * key 和 otherKeys 多個集合的並集,列名相同的 score 相加
   *
   * @param key
   * @param otherKeys
   * @param destKey
   * @return
   */
  public Long unionAndStoreZset(String key,Collection<String> otherKeys,destKey);
  }

  /**
   * key 和 otherKey 兩個集合的交集,儲存在 destKey 集合中
   *
   * @param key
   * @param otherKey
   * @param destKey
   * @return
   */
  public Long intersectAndStore(String key,String destKey) {
    return redisTemplate.opsForZSet().intersectAndStore(key,destKey);
  }

  /**
   * key 和 otherKeys 多個集合的交集,儲存在 destKey 集合中
   *
   * @param key
   * @param otherKeys
   * @param destKey
   * @return
   */
  public Long intersectAndStore(String key,destKey);
  }



  /**
   * 新增 Hash 鍵值對 Object
   *
   * @param key
   * @param hashKey
   * @param value
   */
  public void hmSet(String key,hashKey);
  }

  /**
   * 刪除hash鍵
   *
   * @param key
   * @param hashKey
   */
  public void hmDeleteKey(String key,Object> hash = redisTemplate.opsForHash();
    hash.delete(key,hashKey);
  }

  public T_user getSession(String userName) {
    T_user session = (T_user) hmGet(Constants.FRAS_SESSION_KEY,userName);
    return session;
  }

  public void setSession(String userName,T_user session,long dayTime) {
    hmSet(Constants.FRAS_SESSION_KEY,userName,session);
    expire(Constants.FRAS_SESSION_KEY +":" + userName,dayTime,TimeUnit.DAYS );
  }

  public void hmClear(String key,hashKey);
  }

  public void clearSession(String username) {
    hmClear(Constants.FRAS_SESSION_KEY,username);
  }

}

到此這篇關於springboot中的springSession的儲存和獲取實現的文章就介紹到這了,更多相關springSession儲存獲取內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！