SpringBoot Redis工具类封装

1.接口类

package com.sze.redis.util;

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

/**
 * 
 * <br>类 名: RedisCachesManager 
 * <br>描 述: 缓存管理类
 * <br>作 者: shizhenwei 
 * <br>创 建: 2017年5月31日 
 * <br>版 本: v0.0.2 
 * <br>
 * <br>历 史: (版本) 作者 时间 注释
 */
public interface RedisCachesManager {

    public static final String ID = "redisCachesManager";
    
    /**
     * 在默认缓存空间内加入和更新缓存信息
     * @param key
     * @param value
     */
    void put(String key, Object value);
    
    /**
     * 在默认缓存空间内加入和更新缓存信息
     * @param key
     * @param value
     */
    void put(String key, Object value, long timeout, TimeUnit unit);
    
    /**
     * 在指定缓存空间内加入或更新缓存信息
     * @param namespace
     * @param timeout 有效时长
     * @param unit 有效时长单位
     */
    void put(String namespace, String key, Object value);
    
    /**
     * 在指定缓存空间内加入或更新缓存信息
     * @param namespace
     * @param key
     * @param value
     * @param timeout 有效时长
     * @param unit 有效时长单位
     */
    void put(String namespace, String key, Object value, long timeout, TimeUnit unit);
    
    /**
     * 在默认缓存空间内获取缓存信息
     * 如果信息不存在这遍历其他缓存空间
     * @param key
     * @return
     */
    <T> T get(String key);
    
    /**
     * 获取缓存信息
     * @param namespace
     * @param key
     */
    <T> T get(String namespace, String key);
       
    /**
     * 在所有缓存空间删除缓存信息
     * @param key
     */
    void remove(String key);
    
    /**
     * 在指定空间内删除缓存信息
     * @param namespace
     * @param key
     */
    void remove(String namespace, String key);
    
    /**
     * 创建缓存空间
     * @param namespace
     */
    void createNamespace(String namespace);
    
    /**
     * 删除缓存空间
     * @param namespace
     */
    void deleteNamespace(String namespace);
    
    /**
     * 获取全部缓存空间名字
     * @return
     */
    List<String> namespaces();
    
    /**
     * 获取所有keys
     * @param namespace
     * @return
     */
    Set<String> keys();
    
    /**
     * 获取指定空间所有keys
     * @param namespace
     * @return
     */
    Set<String> keys(String namespace);
    
    /**
     * 慎用 正常这个方法不会公开，都是通过xshell操作
     * 清空所有缓存
     */
    void clearAll();
    
    /**
     * 慎用 正常这个方法不会公开，都是通过xshell操作
     * 清空所有书库key
     */
    void clearDb();
}

2.实现类

package com.sze.redis.util;

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

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
/**
 * 
 * <br>类 名: RedisCachesManager//避免 RedisCacheManager类冲突
 * <br>描 述: 缓存工具类 
 * <br>作 者: shizhenwei 
 * <br>创 建: 2017年5月31日 
 * <br>版 本: v0.0.2 
 * <br>
 * <br>历 史: (版本) 作者 时间 注释
 */
@Component(RedisCachesManager.ID)
public class RedisCachesManagerImpl implements RedisCachesManager {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    private ValueOperations<String, String> stringRedis;
    
    private ListOperations<String, String> listRedis;
    
    /**
     * <br>描 述: 初始化时赋值
     * <br>作 者: shizhenwei 
     * <br>历 史: (版本) 作者 时间 注释
     */
    @PostConstruct
    private void init(){
        stringRedis = redisTemplate.opsForValue();
        listRedis = redisTemplate.opsForList();
    }

    @Override
    public void put(String key, Object value) {
        put(CacheContents.DEFAULT_CONTEXT,key, value);
    }

    @Override
    public void put(String key, Object value, long timeout, TimeUnit unit) {
        put(CacheContents.DEFAULT_CONTEXT,key, value,timeout,unit);
    }
    
    @Override
    public void put(String namespace, String key, Object value) {
        AssertUtils.assertNotEmpty(namespace, "put缓存namespace");
        AssertUtils.assertNotEmpty(key, "put缓存key");
        AssertUtils.assertNotEmpty(value, "put缓存value");
        createNamespace(namespace);
        
        String className = value.getClass().getName();
        JSONObject json = new JSONObject();
        json.put("class", className);
        json.put("data", JSON.toJSONString(value));
        
        stringRedis.set(fullKey(namespace, key), json.toJSONString());
    }

    @Override
    public void put(String namespace, String key, Object value, long timeout, TimeUnit unit) {
        AssertUtils.assertNotEmpty(namespace, "put缓存namespace");
        AssertUtils.assertNotEmpty(key, "put缓存key");
        AssertUtils.assertNotEmpty(value, "put缓存value");
        AssertUtils.assertNotEmpty(unit, "put缓存unit"); 
        
        createNamespace(namespace);
        
        String className = value.getClass().getName();
        JSONObject json = new JSONObject();
        json.put("class", className);
        json.put("data", JSON.toJSONString(value));
        
        stringRedis.set(fullKey(namespace, key), json.toJSONString(),timeout,unit);
    }

    @Override
    public <T> T get(String key) {
        return get(CacheContents.DEFAULT_CONTEXT, key);
    }

    @Override
    public <T> T get(String namespace, String key) {
        AssertUtils.assertNotEmpty(namespace, "get缓存namespace");
        AssertUtils.assertNotEmpty(key, "get缓存key");
        
        String value = stringRedis.get(fullKey(namespace, key));
        if(!StringUtils.hasText(value)) {
            return null;
        }
        
        JSONObject json = JSON.parseObject(value);
        String className = json.getString("class");
        if(!StringUtils.hasText(className)) {
            return null;
        }
        
        Class<?> clazz;
        try {
            clazz = Class.forName(className);
            T rs = JSON.parseObject(json.getString("data"), clazz);
            return rs;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void remove(String key) {
        remove(CacheContents.DEFAULT_CONTEXT, key);
    }

    @Override
    public void remove(String namespace, String key) {
        AssertUtils.assertNotEmpty(namespace, "remove缓存namespace");
        AssertUtils.assertNotEmpty(key, "remove缓存key");
        redisTemplate.delete(fullKey(namespace, key));
    }

    @Override
    public void createNamespace(String namespace) {
        AssertUtils.assertNotEmpty(namespace, "createNamespace缓存namespace");
        if(!namespaces().contains(namespace)){
            listRedis.leftPush(CacheContents.NAMESPACE_LIST, namespace);
        }
    }
    
    @Override
    public void deleteNamespace(String namespace) {
        AssertUtils.assertNotEmpty(namespace, "deleteNamespace缓存namespace");
        int index = namespaces().indexOf(namespace);
        if(-1 != index){
            listRedis.remove(CacheContents.NAMESPACE_LIST, index, namespace);
        }
        redisTemplate.delete(keys(namespace));
        
    }

    @Override
    public List<String> namespaces() {
        //无值返回[]非null
        return listRedis.range(CacheContents.NAMESPACE_LIST, 0, -1);
    }

    @Override
    public Set<String> keys() {
        //无值返回[]非null
        return redisTemplate.keys("*");
    }
    
    @Override
    public Set<String> keys(String namespace) {
        AssertUtils.assertNotEmpty(namespace, "keys缓存namespace");
        if(null==namespace){
            namespace = CacheContents.DEFAULT_CONTEXT;
        }
        //无值返回[]非null
        return redisTemplate.keys(namespace+":*");
    }

    @Override
    public void clearAll() {
        redisTemplate.getConnectionFactory().getConnection().flushAll();
    }
    
    @Override
    public void clearDb() {
        redisTemplate.getConnectionFactory().getConnection().flushDb();
    }
    
    /**
     * <br>描 述: redis里可没什么命名空间
     * <br>作 者: shizhenwei 
     */
    private String fullKey(String namespace,String key){
        return namespace+":"+key;
    }
}

3.常量类

package com.sze.redis.util;
/**
 * 
 * <br>类 名: CacheContents 
 * <br>描 述: 缓存常量 
 * <br>作 者: shizhenwei 
 * <br>创 建: 2017年5月31日 
 * <br>版 本: v0.0.2 
 * <br>
 * <br>历 史: (版本) 作者 时间 注释
 */
public interface CacheContents {
    /**
     * 存放所有的命名空间
     */
    String NAMESPACE_LIST = "_namespace_list_";
    
    /**
     * 默认存储空间
     */
    String DEFAULT_CONTEXT = "_defualt_context_";
    
    
    /**
     * Session信息空间
     */
    String SESSION_CONTEXT = "_session_context_";
    
    /**
     * 用户登录信息空间
     */
    String USER_CONTEXT = "_user_context_";
    
}

4.断言类

package com.sze.redis.util;

import java.util.Collection;
import java.util.Map;

import com.sze.redis.exception.SzwRunTimeException;

/**
 * <br>类 名: AssertUtils 
 * <br>描 述: 断言 校验类
 * <br>作 者: shizhenwei 
 * <br>创 建: 2017年9月12日 
 * <br>版 本: v1.0.0 
 * <br>
 * <br>历 史: (版本) 作者 时间 注释
 */
public class AssertUtils {

    /**
     * 判断是否为NULL
     * @param obj
     * @param label
     */
    public static void assertNotNull(Object obj, String label) {
        if(null == obj){
            throw new SzwRunTimeException(label + "不能为空");
        }
    }
    
    /**
     * 判断是否为空
     * @param obj
     * @param label
     */
    public static void assertNotEmpty(Object obj, String label) {
        if(null != obj){
            if(obj instanceof String){
                String string = (String) obj;
                if("".equals(string.trim())){
                    throw new SzwRunTimeException(label + "不能为空");
                }
            }else if(obj.getClass().isArray()){
                if(((Object[])obj).length<1){
                    throw new SzwRunTimeException(label + "不能为空");
                }
            }else if(obj instanceof Collection){
                if(((Collection<?>)obj).size()<1){
                    throw new SzwRunTimeException(label + "不能为空");
                }
            }else if(obj instanceof Map){
                if(((Map<?, ?>)obj).size()<1){
                    throw new SzwRunTimeException(label + "不能为空");
                }
            }
        }else{
            throw new SzwRunTimeException(label + "不能为NULL");
        }
    }
    
    
    
    /**
     * 判断数组不能为空
     * @param array
     * @param label
     */
    public static <T> void assertArrayNotEmpty(T[] array, String label){
        if(null!=array){
            if(array.length<1){
                throw new SzwRunTimeException(label + "不能为空");
            }
        }else{
            throw new SzwRunTimeException(label + "不能为NULL");
        }
    }
    
    /**
     * 判断集合不能为空
     * @param array
     * @param label
     */
    public static <T> void assertCollectionNotEmpty(Collection<T> collection, String label){
        if(null!=collection){
            if(collection.size()<1){
                throw new SzwRunTimeException(label + "不能为空");
            }
        }else{
            throw new SzwRunTimeException(label + "不能为NULL");
        }
    }
    
    /**
     * 判断Map不能为空
     * @param array
     * @param label
     */
    public static <E, T> void assertMapNotEmpty(Map<E, T> map, String label) {
        if(null!=map){
            if(map.size()<1){
                throw new SzwRunTimeException(label + "不能为空");
            }
        }else{
            throw new SzwRunTimeException(label + "不能为NULL");
        }
    }
}

5.自定义异常类

package com.sze.redis.exception;

public class SzwRunTimeException extends RuntimeException{

    /** **/
    private static final long serialVersionUID = 8924997566380919394L;

    public SzwRunTimeException() {
        super();
    }

    public SzwRunTimeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }

    public SzwRunTimeException(String message, Throwable cause) {
        super(message, cause);
    }

    public SzwRunTimeException(String message) {
        super(message);
    }

    public SzwRunTimeException(Throwable cause) {
        super(cause);
    }

}