Redisson用法

用法一

//注入
@Autowired
private RedissonClient redissonClient;
//初始化创建一个RMap
private RMap<String, Object> rMap;

static final String R_MAP = "rMap";
//在执行spring注入后执行
 @PostConstruct
 private void init() {
     rMap = redissonClient.getMapCache(R_MAP);
 }

//--------------------如果不进行全局初始化的话 可以每次自己创建

//创建一个RList
RList<Object> flushCacheHistory = redissonClient.getList("名称");
//创建一个RMap
RMap<String, Object> flushMap = redissonClient.getMap("名称");

用法二 原文链接：https://www.lovecto.cn/20190125/420.html

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

import org.redisson.api.BatchOptions;
import org.redisson.api.RBatch;
import org.redisson.api.RMap;
import org.redisson.api.RMapAsync;
import org.redisson.api.RMapCache;
import org.redisson.api.RMapCacheAsync;
import org.redisson.api.RSetCache;
import org.redisson.api.RSetCacheAsync;
import org.redisson.api.RedissonClient;

import com.google.common.collect.Maps;
import com.google.common.collect.Sets;


public class CacheMap {

    /** 空值缓存时间10分钟 */
    private final static int NULL_VALUE_KEY_CACHE_MILLISECONDS = 10 * 60 * 1000;

    /** redisson map */
    private RMap rMap;
    /** 集合用于缓存空值 */
    private RSetCache rSet;
    /** redisson */
    private RedissonClient redisson;
    /** 批量操作选项 */
    private BatchOptions options = BatchOptions.defaults();
    /** 是否有ttl控制 */
    private boolean ttlControl;
    /** 缓存名称 */
    private String name;
    /** 集合名称 */
    private String setName;
    /** 是否缓存null */
    private boolean cacheNull;

    /**
     * 静态构造方法
     * 
     * @param redisson
     *            redisson客户端
     * @param name
     *            缓存名称
     * @param ttlControl
     *            是否有缓存时间控制
     * @return
     */
    public static CacheMap of(RedissonClient redisson, String name,
            boolean ttlControl, boolean cacheNull) {
        return new CacheMap(redisson, name, ttlControl, cacheNull);
    }

    /**
     * 
     * @param redisson
     * @param name
     * @param ttlControl
     */
    private CacheMap(RedissonClient redisson, String name,
            boolean ttlControl, boolean cacheNull) {
        this.name = name;
        this.setName = name + "_null_value_key_set";
        if (ttlControl) {
            this.rMap = redisson.getMapCache(this.name);
        } else {
            this.rMap = redisson.getMap(this.name);
        }
        if (cacheNull) {
            this.rSet = redisson.getSetCache(this.setName);
        }
        this.ttlControl = ttlControl;
        // 批量操作
        this.redisson = redisson;
        this.cacheNull = cacheNull;
    }

    /**
     * 判断是否存在key
     * 
     * @param key
     * @return
     */
    public boolean containsKey(Object key) {
        boolean r = rMap.containsKey(key);
        if (!r) {
            if(cacheNull){
                r = rSet.contains(key);
            }
        }
        return r;
    }

    /**
     * 清除缓存
     */
    public void clear() {
        rMap.clear();
        if (cacheNull) {
            rSet.clear();
        }
    }

    /**
     * 获取数据
     * 
     * @param key
     * @return
     */
    public Map get(Object key) {
        Map map = Maps.newHashMapWithExpectedSize(1);
        Object r = rMap.get(key);
        if ((r == null && cacheNull && rSet.contains(key)) || r != null) {
            map.put(key, r);
        }
        return map;
    }

    /**
     * 存入map
     * 
     * @param key
     * @param value
     * @return
     */
    public Object put(Object key, Object value) {
        if (value == null) {
            if (cacheNull) {
                rSet.add(key, NULL_VALUE_KEY_CACHE_MILLISECONDS,
                        TimeUnit.MILLISECONDS);
            }
        } else {
            rMap.put(key, value);
        }
        return value;
    }

    /**
     * 移除
     * 
     * @param key
     * @return
     */
    public Object remove(Object key) {
        Object o = rMap.remove(key);
        if (cacheNull) {
            rSet.remove(key);
        }
        return o;
    }

    /**
     * 批量存储
     * 
     * @param map
     */
    public void putAll(Map map) {
        RBatch batch = redisson.createBatch(options);
        RMapAsync mapCache = ttlControl ? batch.getMapCache(this.name) : batch
                .getMap(this.name);
        RSetCacheAsync setCache = batch.getSetCache(this.setName);
        Set<Map.Entry> entrySet = map.entrySet();
        Iterator<Map.Entry> it = entrySet.iterator();
        while (it.hasNext()) {
            Map.Entry e = it.next();
            if (e.getValue() == null) {
                if (cacheNull) {// 缓存null
                    setCache.addAsync(e.getKey(),
                            NULL_VALUE_KEY_CACHE_MILLISECONDS,
                            TimeUnit.MILLISECONDS);
                }
            } else {
                mapCache.putAsync(e.getKey(), e.getValue());
            }
        }
        batch.execute();
    }

    /**
     * 批量获取
     * 
     * @param keys
     * @return
     */
    public Map getAll(Set keys) {
        Map map = rMap.getAll(keys);
        if (keys.size() == map.size()) {
            return map;
        } else if (cacheNull) {
            Set set = rSet.readAll();
            for (Object key : keys) {
                if (!map.containsKey(key)) {
                    if (set.contains(key)) {
                        map.put(key, null);
                    }
                }
            }
        }
        return map;
    }

    /**
     * 批量移除
     * 
     * @param keys
     * @return
     */
    public long fastRemove(Object... keys) {
        long r = rMap.fastRemove(keys);
        if (cacheNull) {
            rSet.removeAll(Sets.newHashSet(keys));
        }
        return r;
    }

    /**
     * 快速存
     * 
     * @param key
     * @param value
     * @return
     */
    public boolean fastPut(Object key, Object value) {
        boolean r = true;
        if (value != null) {
            r = rMap.fastPut(key, value);
        } else if (cacheNull) {
            rSet.add(key, NULL_VALUE_KEY_CACHE_MILLISECONDS,
                    TimeUnit.MILLISECONDS);
        }
        return false;
    }

    /**
     * 带过期时间存
     * 
     * @param key
     * @param value
     * @param ttl
     *            单位毫秒
     * @return
     */
    public Object put(Object key, Object value, long ttl) {
        if(ttl <= 0){
            return put(key, value);
        }
        if (value != null) {
            if (ttlControl) {
                ((RMapCache) rMap).put(key, value, ttl, TimeUnit.MILLISECONDS);
            } else {
                throw new IllegalArgumentException("can not support ttl");
            }
        } else if (cacheNull) {
            rSet.add(key, NULL_VALUE_KEY_CACHE_MILLISECONDS,
                    TimeUnit.MILLISECONDS);
        }
        return value;
    }

    /**
     * 带过期时间的putAll
     * 
     * @param map
     * @param ttl
     */
    public void putAll(Map map, long ttl) {
        if(ttl <= 0){
            putAll(map);
            return;
        }
        RBatch batch = redisson.createBatch(options);
        RMapCacheAsync rMapCache = batch.getMapCache(this.name);
        Set<Map.Entry> entrySet = map.entrySet();
        Iterator<Map.Entry> it = entrySet.iterator();
        while (it.hasNext()) {
            Map.Entry e = it.next();
            if (e.getValue() != null) {
                if (ttlControl) {
                    rMapCache.putAsync(e.getKey(), e.getValue(), ttl,
                            TimeUnit.MILLISECONDS);
                } else {
                    throw new IllegalArgumentException("can not support ttl");
                }
            } else if (cacheNull) {
                rSet.add(e.getKey(), NULL_VALUE_KEY_CACHE_MILLISECONDS,
                        TimeUnit.MILLISECONDS);
            }
        }
        // 批量操作
        batch.execute();
    }

    /**
     * 快速存
     * 
     * @param key
     * @param value
     * @param ttl
     * @param ttlUnit
     * @return
     */
    public boolean fastPut(Object key, Object value, long ttl) {
        boolean r = true;
        if (value != null) {
            if (ttlControl) {
                r = ((RMapCache) rMap).fastPut(key, value, ttl,
                        TimeUnit.MILLISECONDS);
            } else {
                throw new IllegalArgumentException("can not support ttl");
            }
        } else if (cacheNull) {
            rSet.add(key, NULL_VALUE_KEY_CACHE_MILLISECONDS,
                    TimeUnit.MILLISECONDS);
        }
        return r;
    }

}