基於RedisTemplate封裝Redis

一. 概述

1.1 什麼是RedisTemplate？

• RedisTemplate是對Redis的封裝，它能夠簡化與Redis進行數據交互的細節，提升功能效率和降低使用難度。

1.2 使用方式：

• 引入Spring-Redis的啓動器，在yml等配置文件中配置了相關的Redis地址等信息即可使用。@Autowired引入RedisTemplate即可使用。

1.3 爲什麼還要封裝Redis呢？

• 在使用Redis的過程中，它的RedisTemplate會將數據轉爲二進制，我們在使用桌面版Redis客戶端的時候(RedisDesktopManager)只能看到二進制看不到人容易識別的名稱。
• 封裝後可以進行統一設置，統一管理，更方便使用。
• 使用多級目錄易於使用。

二. 圖示：

2.1 使用RedisTemplate的set方法存儲的數據：

可以看出來，RedisTemplate不易於讀取；我們封裝後有文件夾包裹，更易於使用；

---

三. 示例代碼(SpringBoot+SpringCloud環境)

3.1 yml配置文件圖示：

spring:
  redis:
    database: 10         # Redis數據庫索引（默認爲0）
    host: localhost     # Redis服務器地址
    port: 6379          # Redis服務器連接端口
    password:     # Redis服務器連接密碼（默認爲空）
    expire:
      headerExpire:  #重點.....key不能帶有特殊字符,必須符合變量的定意規範(字母,下劃線,數字)
        [SYS_VERIFYIMAGE]: 600 # 10分鐘
    pool:
      max-active: 600    # 連接池最大連接數（使用負值表示沒有限制）
      max-idle: 300      # 連接池中的最大空閒連接
      max-wait: 2000    # 連接池最大阻塞等待時間（使用負值表示沒有限制）
      min-idle: 5       # 連接池中的最小空閒連接
      timeout: 0        # 連接超時時間（毫秒）   

3.2 目錄結構以及文件名：

• 圖示:
  

• 文件名： RedisConfig RedisExpireConfig RedisService RedisConstans

3.3 RedisConfig.java

package com.cdmtc.redis.config;

import com.cdmtc.redis.RedisService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;


/**
 * @create_by: zhanglei
 * @craete_time 2019/7/16
 */
@Configuration
public class RedisConfig{

	
	/**
	 * 初始化redis header對應的過期時間
	 * @return
	 */
	@Bean
	public RedisExpireConfig redisExpireConfig() {
		return new RedisExpireConfig();
	}
	
	@Bean
	public RedisService redisService(StringRedisTemplate stringRedisTemplate) {
		return new RedisService(stringRedisTemplate);
	}
}

3.4 RedisExpireConfig

package com.cdmtc.redis.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.util.CollectionUtils;

import java.util.Map;

/**
 * @create_by: zhanglei
 * @craete_time 2019/7/16
 */
@ConfigurationProperties(prefix = "spring.redis.expire")
public class RedisExpireConfig {
	/**
	 * redis中header對應的過期時間
	 */
	private Map<String, Long> headerExpire;

	public Map<String, Long> getHeaderExpire() {
		return headerExpire;
	}

	public void setHeaderExpire(Map<String, Long> headerExpire) {
		this.headerExpire = headerExpire;
	}

	/**
	 * 獲取對應header設置的過期時間
	 * 
	 * @param header
	 * @return
	 */
	public long getExpire4Header(String header) {
		if(!CollectionUtils.isEmpty(headerExpire)) {
			Long result = headerExpire.get("["+header+"]");
			if(null == result ) {
				result = 0L;
			}
			return result;
		}
		return 0L;
	}
}

3.5 RedisService.java

package com.cdmtc.redis;

import com.cdmtc.redis.config.RedisExpireConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.util.CollectionUtils;

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

/**
 * @create_by: zhanglei
 * @craete_time 2019/7/16
 */
@SuppressWarnings("unchecked")
public class RedisService {

	private Logger logger = LoggerFactory.getLogger(RedisService.class);

	@SuppressWarnings("rawtypes")
	private RedisTemplate template;
	@SuppressWarnings({ "rawtypes" })
	private ListOperations listOpe;
	@SuppressWarnings("rawtypes")
	private ValueOperations valueOpe;
	@SuppressWarnings("rawtypes")
	private HashOperations hashOpe;
	@SuppressWarnings("rawtypes")
	private ZSetOperations zsetOpe;
	@SuppressWarnings("rawtypes")
	private SetOperations setOpe;
	@Autowired
	private RedisExpireConfig expireConfig;

	@SuppressWarnings("rawtypes")
	public RedisService(RedisTemplate template) {
		this.template = template;
		listOpe = template.opsForList();
		valueOpe = template.opsForValue();
		hashOpe = template.opsForHash();
		zsetOpe = template.opsForZSet();
		setOpe = template.opsForSet();
		this.template = template;
	}

	private String getKey(String head, String key) {
		return head + ":" + key;
	}

	public String get(String head, String key) {
		return (String) valueOpe.get(getKey(head, key));
	}

	public void set(String head, String key, String value) {

		valueOpe.set(getKey(head, key), value);
		// 設置過期時間
		expire(head, key);
	}

	/**
	 * 以配置文件爲準,爲reids設置對應的過期時間
	 * 
	 * @param head
	 * @param key
	 * @return
	 */
	private boolean expire(String head, String key) {
		long times = expireConfig.getExpire4Header(head);
		if (times > 0) {
			try {
				return expire(head, key, times, TimeUnit.SECONDS);
			} catch (Exception e) {
				logger.warn("過期時間設置失敗{head:" + head + ",key:" + key + "}。");
			}
		}
		return false;
	}

	/**
	 * 以傳入的時間爲準,設置相應的過期時間
	 * 
	 * @param head
	 * @param key
	 * @param timeout
	 * @param unit
	 * @return
	 */
	public boolean expire(String head, String key, long timeout, TimeUnit unit) {
		return template.expire(getKey(head, key), timeout, unit);
	}

	public boolean zadd(String head, String key, String member, double score) {
		boolean result = zsetOpe.add(getKey(head, key), member, score);
		expire(head,key);
		return result;
	}

	/**
	 * 按分數從小到大獲取指定數量
	 * 
	 * @param head
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Set<String> rang(String head, String key, long start, long end) {
		return zsetOpe.range(getKey(head, key), start, end);
	}

	/**
	 * 按分數從大到小獲取指定數量
	 * 
	 * @param head
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Set<String> reverseRange(String head, String key, long start, long end) {
		return zsetOpe.reverseRange(getKey(head, key), start, end);
	}

	/**
	 * 獲取指定key下成員的分數
	 * 
	 * @param head
	 * @param key
	 * @param member
	 * @return
	 */
	public double score(String head, String key, String member) {
		return zsetOpe.score(getKey(head, key), member);
	}

	/**
	 * 獲取排名--score低-->高
	 * 
	 * @param head
	 * @param key
	 * @param member
	 * @return
	 */
	public long rank(String head, String key, String member) {
		return zsetOpe.rank(getKey(head, key), member);
	}

	/**
	 * 獲取排名--score高-->低
	 * 
	 * @param head
	 * @param key
	 * @param member
	 * @return
	 */
	public long reverseRank(String head, String key, String member) {
		return zsetOpe.reverseRank(getKey(head, key), member);
	}

	/**
	 * 獲取指定起始位置的排行榜信息
	 * 
	 * @param head
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Set<ZSetOperations.TypedTuple<String>> reverseRangeWithScores(String head, String key, long start,
			long end) {
		return zsetOpe.reverseRangeWithScores(getKey(head, key), start, end);
	}

	/**
	 * 獲取批量hashkey對應value對象json字符串
	 * 
	 * @param head
	 * @param key
	 * @param fields
	 * @param
	 * @param        <
	 * @return
	 */
	public List<String> hmget(String head, String key, Collection<?> fields) {
		if (CollectionUtils.isEmpty(fields)) {
			return null;
		}

		return hashOpe.multiGet(getKey(head, key), fields);
	}

	/**
	 * hset 操作
	 * 
	 * @param head
	 * @param key
	 * @param field
	 * @param value
	 */
	public void hset(String head, String key, String field, String value) {
		hashOpe.put(getKey(head, key), field, value);
		expire(head, key);
	}

	/**
	 * 獲取所有的field
	 * 
	 * @param head
	 * @param key
	 * @return
	 */
	public Set<String> keys(String head, String key) {
		return hashOpe.keys(getKey(head, key));
	}

	/**
	 * 通過field獲取value
	 * 
	 * @param head
	 * @param key
	 * @param field
	 * @return
	 */
	public String hget(String head, String key, String field) {
		return (String)hashOpe.get(getKey(head, key), field);
	}

	/**
	 * 獲取set裏對應成員
	 * 
	 * @param head
	 * @param key
	 * @param
	 * @return
	 */
	public Set<String> smembers(String head, String key) {
		return setOpe.members(getKey(head, key));
	}

	/**
	 * 通過field獲取value
	 * 
	 * @param head
	 * @param key
	 * @param value
	 * @return
	 */
	public long sadd(String head, String key, String value) {
		long result = setOpe.add(getKey(head, key), value);
		expire(head, key);
		return result;
	}

	/**
	 * 在value後面追加值
	 * 
	 * @param head
	 * @param key
	 * @param addString
	 */
	public int append(String head, String key, String addString) {
		return valueOpe.append(getKey(head, key), addString);
	}
	
	/**
	 * 加鎖機制 true加鎖成功 false加鎖失敗
	 * 
	 * @param head
	 * @param key
	 * @param lockValue
	 */
	public boolean setnx(String head, String key, String lockValue) {
		boolean success = valueOpe.setIfAbsent(getKey(head, key), lockValue);
		if (success) {
			// 設置過期時間
			expire(head, key);
		}
		return success;
	}

	/**
	 * 刪除KEY
	 * 
	 * @param head
	 * @param key
	 */
	public boolean delete(String head, String key) {
		return template.delete(getKey(head, key));
	}
	
	public long rightPush(String head, String key,String value) {
		return listOpe.rightPush(getKey(head, key), value);
	}

	/**
	 *
	 * @param head
	 * @param key
	 * @param member
	 * @return
	 */
	public Double incrementScore(String head, String key,String member,Double score) {
		return zsetOpe.incrementScore(getKey(head, key),member,score);

	}

	/**
	 * @description:
	 * @param head
	 * @param key
	 * @param map
	 * @return: void
	 */
	public void hmset(String head ,String key,Map<? extends String, ? extends String> map){
		if (!CollectionUtils.isEmpty(map)){
			hashOpe.putAll(getKey(head,key),map);
			expire(head, key);
		}
	}
	/**
	 *
	 * @param head
	 * @param key
	 * @param filed
	 * @param value
	 * @return
	 */
	public Double Hincrby(String head,String key,String filed,Double value){
		return hashOpe.increment(getKey(head, key), filed, value);
	}

	/**
	 * 刪除hash數據結構
	 *
	 * @param head
	 * @param key
	 */
	public Long hdel(String head, String key,String field) {
		return hashOpe.delete(getKey(head,key),field);
	}

	/**
	 * 判斷可以是否存在
	 * @param head
	 * @param key
	 * @return
	 */
	public boolean hasKey(String head, String key) {
		return template.hasKey(getKey(head,key));
	}

}

3.6 RedisConstans

package com.cdmtc.redis.constans;
/**
 * @create_by: zhanglei
 * @craete_time 2019/7/16
 */
public class RedisConstans {
    public static String SYS_VERIFYIMAGE="SYS_VERIFYIMAGE";     // webSocket 發送消息類型
}