redis缓存的存取使用

第一步：导入maven包

org.springframework.boot
spring-boot-starter-data-redis

第二步：
写一个redisUtile的工具类：
package com.nanyinkj.loanshop.utils.redis;

import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

@Resource
private RedisTemplate redisTemplate;

/**
 * 写入缓存
 * @param key
 * @param value
 * @return
 */
public boolean set(final String key, Object value) {
    boolean result = false;
    try {
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        operations.set(key, value);
        result = true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
/**
 * 写入缓存设置时效时间
 * @param key
 * @param value
 * @return
 */
public boolean set(final String key, Object value, Long expireTime) {
    boolean result = false;
    try {
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        operations.set(key, value);
        redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        result = true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
/**
 * 批量删除对应的value
 * @param keys
 */
public void remove(final String... keys) {
    for (String key : keys) {
        remove(key);
    }
}


public Long increment(Object key,Integer l){
    Long aLong = redisTemplate.opsForValue().increment(key,l);
    return aLong;
}

/**
 * 批量删除key
 * @param pattern
 */
public void removePattern(final String pattern) {
    Set<Serializable> keys = redisTemplate.keys(pattern);
    if (keys.size() > 0)
        redisTemplate.delete(keys);
}



/**
 * 删除对应的value
 * @param key
 */
public void remove(final String key) {
    if (exists(key)) {
        redisTemplate.delete(key);
    }
}
/**
 * 判断缓存中是否有对应的value
 * @param key
 * @return
 */
public boolean exists(final String key) {
    return redisTemplate.hasKey(key);
}
/**
 * 读取缓存
 * @param key
 * @return
 */
public Object get(final String key) {
    Object result = null;
    ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    result = operations.get(key);
    return result;
}
/**
 * 哈希 添加
 * @param key
 * @param hashKey
 * @param value
 */
public void hmSet(String key, Object hashKey, Object value){
    HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    hash.put(key,hashKey,value);
}

/**
 * 哈希获取数据
 * @param key
 * @param hashKey
 * @return
 */
public Object hmGet(String key, Object hashKey){
    HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
    return hash.get(key,hashKey);
}

//从redis里面获取或者从数据库里面获取


/**
 * 列表添加
 * @param k
 * @param v
 */
public void lPush(String k,Object v){
    ListOperations<String, Object> list = redisTemplate.opsForList();
    list.rightPush(k,v);
}

/**
 * 列表获取
 * @param k
 * @param l
 * @param l1
 * @return
 */
public List<Object> lRange(String k, long l, long l1){
    ListOperations<String, Object> list = redisTemplate.opsForList();
    return list.range(k,l,l1);
}

/**
 * 集合添加
 * @param key
 * @param value
 */
public void add(String key,Object value){
    SetOperations<String, Object> set = redisTemplate.opsForSet();
    set.add(key,value);
}

/**
 * 集合获取
 * @param key
 * @return
 */
public Set<Object> setMembers(String key){
    SetOperations<String, Object> set = redisTemplate.opsForSet();
    return set.members(key);
}

/**
 * 有序集合添加
 * @param key
 * @param value
 * @param scoure
 */
public void zAdd(String key,Object value,double scoure){
    ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
    zset.add(key,value,scoure);
}

/**
 * 有序集合获取
 * @param key
 * @param scoure
 * @param scoure1
 * @return
 */
public Set<Object> rangeByScore(String key,double scoure,double scoure1){
    ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
    return zset.rangeByScore(key, scoure, scoure1);
}

}

第三部：在service里面可以拿到数据库的数据或者从redis里面拿出数据，

@Override
public List findAllByConfigClass(Integer id) {
String s = (String) redisUtil.get(“1”);
if(s!=null && !"".equals(s)){
List configs = JSON.parseArray(s, Config.class);
return configs;
}
List all = configDao.findAllByConfigClass(id);
String s2 = JSON.toJSONString(all);
redisUtil.set(“1”,s2,60L);
return all;
}
redis使用完毕