Spring Boot集成redis

文件配置 

# Redis服务器地址
spring.redis.host= localhost
# Redis服务器连接端口
spring.redis.port= 6379
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0
#连接池中的最大空闲连接 默认 0
spring.redis.lettuce.pool.max-idle=8

实现的代码，对ResponseData，这个是自己封装好的返回数据格式，就不再展示。DriverService ，这个是查询数据库，你可以替换自己的数据库。

package com.example.test.redis.controller;

import com.example.test.driver.entity.DriverEntity;
import com.example.test.driver.service.DriverService;
import com.example.test.response.ResponseData;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;

@Api(tags="redis测试数据")
@RestController
@RequestMapping("/api/v1/redis")
public class RedisController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private DriverService driverService;

    @ApiOperation("数据查找")
    @GetMapping("/testString")
    public String testString(){
        stringRedisTemplate.opsForValue().set("user","花花");
        String name=stringRedisTemplate.opsForValue().get("user");
        return "the value is "+name;
    }


    @ApiOperation("数据查找findAll，对于String操作")
    @GetMapping("/findAll")
    public ResponseData findAll() throws JsonProcessingException {

        List<DriverEntity> driverEntityList = null;
        String str= (String) redisTemplate.opsForValue().get("findAll");
        String str1=null;
        if(str==null){
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
            List<DriverEntity> driverList=driverService.list();
            ObjectMapper objectMapper=new ObjectMapper();
            str=objectMapper.writeValueAsString(driverList);
            operations.set("findAll", str);
        }else{
            str1= (String) redisTemplate.opsForValue().get("findAll");
            System.out.println(str1);
            ObjectMapper objectMapper=new ObjectMapper();
            driverEntityList=objectMapper.readValue(str1,List.class);
            System.out.println("数据"+driverEntityList.toString());
            redisTemplate.delete("findAll");
        }

        return ResponseData.success(driverEntityList);

    }


    @ApiOperation("对于list的操作")
    @GetMapping("/operationList")
    public ResponseData operationList(){
        ListOperations listOperations= redisTemplate.opsForList();
        String key="list"+11;
        Boolean flag=redisTemplate.hasKey(key);
        if(flag){
            //查询数据
            List l=listOperations.range(key,0,3);
            System.out.println(listOperations.range(key,0,2));
            //删除对应的key
            listOperations.getOperations().delete(key);
            //
            return ResponseData.success("数据已删除"+l.toString());
        }else{
            List list=new ArrayList();
            list.add("数据1");
            list.add("shu11");
            list.add("asas");
            return ResponseData.success(listOperations.leftPushAll(key,list));
        }

    }

    @ApiOperation("对于set的操作")
    @GetMapping("/operationSet")
    public ResponseData operationSet(){
        //Set可以设置《T，V》
        SetOperations setOperations=redisTemplate.opsForSet();
        String key="Set"+11;
        Boolean flag=redisTemplate.hasKey(key);
        if(flag){
            //查询数据
            Set s=setOperations.members(key);
            System.out.println(s.toString());
            //删除对于的key
            setOperations.getOperations().delete(key);
            return ResponseData.success("数据删除"+s);
        }else{
            setOperations.add(key,"111");
            setOperations.add(key,"222");
            setOperations.add(key,"333");
            return ResponseData.success("数据添加成功");
        }

    }

    @ApiOperation("对于ZSet的操作")
    @GetMapping("/operationZSet")
    public ResponseData operationZSet(){
        //Set可以设置《T，V》
        ZSetOperations zsetOperations=redisTemplate.opsForZSet();
        String key="ZSet"+11;
        Boolean flag=redisTemplate.hasKey(key);
        if(flag){
            //查询数据
            Set s=zsetOperations.range(key,0,3);
            System.out.println(s.toString());
            //删除对于的key
            zsetOperations.getOperations().delete(key);
            return ResponseData.success("数据删除"+s);
        }else{
            zsetOperations.add(key,"111",77);
            zsetOperations.add(key,"222",77);
            zsetOperations.add(key,"333",77);
            return ResponseData.success("数据添加成功");
        }

    }

    @ApiOperation("对于hashMap的操作")
    @GetMapping("/operationHashMap")
    public ResponseData operationHashMap(){
        HashOperations hashOperations=redisTemplate.opsForHash();
        String key="hashMap"+11;
        Boolean flag=redisTemplate.hasKey(key);
        if(flag){
            //查询数据
            System.out.println("get数据"+hashOperations.get(key,0));
            Map m=hashOperations.entries(key);
            System.out.println("entries数据为"+hashOperations.entries(key));
            //删除数据
            hashOperations.getOperations().delete(key);
            return ResponseData.success("entries数据为"+m.toString());
        }else{
            HashMap hashMap=new HashMap<String,String>();
            hashMap.put("1","数据为1");
            hashMap.put("2","数据为2");
            hashMap.put("3","数据为3");
            hashOperations.putAll(key,hashMap);
            return ResponseData.success();
        }
    }


}