StringRedisTemplate缓存的使用

1.业务层

package com.sjzl.config.service;

import java.util.concurrent.TimeUnit;

public interface RedisService {

    /**
     * 存储数据
     */
    void set(String key, String value);


    /**
     * 存储数据
     */
    void set(String key, String value, Long time, TimeUnit timeUnit);

    /**
     * @param key
     * @return
     */

    boolean exists(final String key);

    /**
     * 获取数据
     */
    String get(String key);

    /**
     * 设置超期时间
     */
    boolean expire(String key, long expire);

    /**
     * 删除数据
     */
    void remove(String key);

    /**
     * 自增操作
     *
     * @param delta 自增步长
     */
    Long increment(String key, long delta);
}

2.实现层

package com.sjzl.config.service.impl;


import com.sjzl.config.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

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


@Service
public class RedisServiceImpl implements RedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private final RedisTemplate redisTemplate;

    public RedisServiceImpl(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void set(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    @Override
    public void set(String key, String value, Long time, TimeUnit timeUnit) {
        stringRedisTemplate.opsForValue().set(key, value, time, timeUnit);
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    @Override
    public boolean exists(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    @Override
    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    @Override
    public boolean expire(String key, long expire) {
        return stringRedisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }

    public boolean lexpire(String key, long time) {
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public void remove(String key) {
        stringRedisTemplate.delete(key);
    }

    @Override
    public Long increment(String key, long delta) {
        return stringRedisTemplate.opsForValue().increment(key, delta);
    }

    public long delAllKey() {
        /*执行删除*/
        final Set<String> keys = stringRedisTemplate.keys("*");
        return stringRedisTemplate.delete(keys);
    }
}

 3.标记层

package com.sjzl.common.constant;


public class RedisConstant {

    /**
     * reids  存储所有字典信息
     */
    public static final String allSysDicts = "sjzl:allSysDicts";

    /**
     * reids  存储字典主表信息
     */
    public static final String allSysDictsMain = "sjzl:allSysDictsMain";
}

 实例一.存

package com.sjzl.run;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.sjzl.common.constant.RedisConstant;
import com.sjzl.config.service.impl.RedisServiceImpl;
import com.sjzl.entity.SysDict;
import com.sjzl.entity.SysDictItem;
import com.sjzl.service.ISysDictItemService;
import com.sjzl.service.ISysDictService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class ApplicationRunnerImpl implements ApplicationRunner {

    private static final Logger logger = LoggerFactory.getLogger(ApplicationRunnerImpl.class);

    @Autowired
    private RedisServiceImpl redisService;
    @Autowired
    private ISysDictItemService sysDictItemService;

    @Autowired
    private ISysDictService sysDictService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
     logger.info("初始化redis数据");
     //清除redis所有的key
     redisService.delAllKey();

      //字典列表
      List<SysDictItem> list = sysDictItemService.list(new LambdaQueryWrapper<SysDictItem>()
              .select(SysDictItem::getDictCode,SysDictItem::getDictItemCode,SysDictItem::getDictItemName,SysDictItem::getSortNum)
              .eq(SysDictItem::getDeleteFlag,"0"));
      redisService.lSet(RedisConstant.allSysDicts,list);
      //设置时间
      redisService.lexpire(RedisConstant.allSysDicts,10000000);

      //字典主列表
      List<SysDict> list1 = sysDictService.list(new LambdaQueryWrapper<SysDict>()
              .select(SysDict::getDictCode,SysDict::getDictName)
              .eq(SysDict::getDeleteFlag,"0"));
      redisService.lSet(RedisConstant.allSysDictsMain,list1);
      //设置时间
      redisService.lexpire(RedisConstant.allSysDictsMain,10000000);

        logger.info("初始化redis数据完成");
    }
}

 5.取

List<SysDictItem> list = (List) redisService.lGet(RedisConstant.allSysDicts, 0, -1).get(0);

实例二： 用流将Excel读成对象并保存在缓存

import com.alibaba.excel.EasyExcel;

@Resource
private RedisTemplate<String, Object> redisTemplate;//redis

@Override
public String browseExcel(MultipartFile file) throws Exception{
    //用流将excel读成对象
    List<UploadOrderTestedDto> uploadDtos = new ArrayList<>();
    try {
        uploadDtos = Collections.synchronizedList(
                EasyExcel.read(file.getInputStream())
                        .head(UploadOrderTestedDto.class)
                        .headRowNumber(1)
                        .doReadAllSync());
        if (uploadDtos.stream().filter(m->StringUtils.isBlank(m.getRelationSfzn()) ||
                StringUtils.isBlank(m.getTestedSfzh()) ||
                StringUtils.isBlank(m.getRelationshipName()) ||
                StringUtils.isBlank(m.getPackageName()) ||
                StringUtils.isBlank(m.getTestedPerson()) ||
                StringUtils.isBlank(m.getTestedTel())).collect(Collectors.toList()).size() > 0) {
            throw new Exception("有值未填写，请重新检查！");
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    String redisKey = "UploadOrderTestedDto";
    redisTemplate.opsForValue().set(redisKey, JSON.toJSONString(uploadDtos));
    return redisKey;
}

 2.取

//根据redisKey获取值
List<UploadOrderTestedDto> uploadOrderTestedDtos = JSON.parseArray(String.valueOf(redisTemplate.opsForValue().get(dto.getRedisKey())), UploadOrderTestedDto.class);