Springboot操作redis（一） 五种数据类型的基本操作

一、创建项目，导入pom依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.5.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--redis框架依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <!--连接池-->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>

    <!--简化实体类的开发-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

</dependencies>

二、创建实体对象

package com.asiainfo.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * @author: LIJY
 * @Description: 实体类
 *      需实现序列化接口，不然无法存入redis中
 * @Date: 2019/11/17 17:46
 */
@Data
public class Student implements Serializable {
    private Integer id;
    private String name;
    private Double score;
    private Date birthday;
}

三、创建控制器

package com.asiainfo.controller;

import com.asiainfo.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Set;

/**
 * @author: LIJY
 * @Description: 控制器 -- Spring boot操作redis
 * @Date: 2019/11/17 17:52
 */
@RestController
public class StudentHandler {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 存入redis
     * @param student
     */
    @PostMapping("/set")
    public void set(@RequestBody Student student){
        redisTemplate.opsForValue().set("student", student);
    }

    /**
     * 查询
     * @param key ： student
     * @return
     */
    @GetMapping("/get/{key}")
    public Student get(@PathVariable("key") String key){
        return (Student) redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除
     * @param key ： student
     * @return 删除成功，不存在   返回false
     */
    @DeleteMapping("/delete/{key}")
    public Boolean delete(@PathVariable("key") String key){
        // 删除
        redisTemplate.delete(key);
        // 返回是否还存在key
        return redisTemplate.hasKey(key);
    }
}

四、创建启动类

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

五、创建配置文件： application.yml

spring:
  redis:
    database: 0
    host: localhost
    port: 6379

六、使用postman测试

1、 存储请求：
请求方式post，  url ： http://localhost:8080/set

报文： 
{
    "id":101,
    "name":"lee",
    "birthday":"1993-04-11",
    "score": 99.5
}

2、查询测试：
get请求， url：  http://localhost:8080/get/student

3、删除测试：
delete请求， url： http://localhost:8080/get/student

redis 的数据类型（五种）
字符串、列表、集合、有序集合、哈希。

/**
 * redis 存取字符串
 */
@PostMapping("/string")
public String stringTest(){
    // 存储String类型
    redisTemplate.opsForValue().set("string", "hello world");
    // 取出存储的String类型
    String str = (String) redisTemplate.opsForValue().get("string");
    return str;
}

/**
 * redis 存取 list -- 列表
 * @return
 */
@GetMapping("/list")
public List<String> listTest(){
    // redis存储list
    ListOperations<String, String> listOperations = redisTemplate.opsForList();
    // 从左边存
    listOperations.leftPush("list", "hello");
    listOperations.leftPush("list", "world");
    listOperations.leftPush("list", "java!");
    // 从右边存
    listOperations.rightPush("list", "redis");
    listOperations.rightPush("list", "mysql");
    listOperations.rightPush("list", "oracle");
    // 从list取数据，list 是 key， 第二个参数是开始取的下标，从0开始，第三个参数是结束的下标
    List<String> list = listOperations.range("list", 0, 2);
    return list;
}

/**
 * redis操作集合 -- set （无序，不重复）
 * @return
 */
@GetMapping("/set")
public Set<String> setTest() {
    // redis存储集合 set
    SetOperations<String, String> setOperations = redisTemplate.opsForSet();
    setOperations.add("set", "hello");
    setOperations.add("set", "hello");
    setOperations.add("set", "world");
    setOperations.add("set", "world");
    setOperations.add("set", "redis");
    setOperations.add("set", "redis");
    // redis 取集合
    Set<String> set = setOperations.members("set");
    return set;
}

/**
 * redis操作有序集合 -- zset
 * @return
 */
@GetMapping("/zset")
public Set<String> zsetTest(){
    // redis存储有序集合
    ZSetOperations<String, String> zSetOperations = redisTemplate.opsForZSet();
    // 最后一个参数是序号
    zSetOperations.add("zset","hello", 1);
    zSetOperations.add("zset", "world", 2);
    zSetOperations.add("zset", "redis", 3);
    Set<String> zset = zSetOperations.range("zset", 0,2);
    return zset;
}

/**
 * redis操作 哈希 -- hash
 * HashOperations   key , hashkey, value
 * key是每组数据的ID， hashkey和value是一组完整的HashMap数据，通过key区分不同的 HashMap
 */
@GetMapping("hash")
public void hashTest(){
    HashOperations<String, String, String> hashOperations = redisTemplate.opsForHash();
    hashOperations.put("key", "hashkey", "hello");
    System.out.println(hashOperations.get("key", "hashkey"));
}