SpringBoot：往Redis中添加获取数据、序列化方式

RedisTemple：是SpringBoot中提供的一个类，来操作Redis数据的 

 

 

创建项目：

pom.xml:项目创建时加的起步依赖：

 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.bjpowernode</groupId>
    <artifactId>021-springboot-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--redis起步依赖：直接在项目中使用RedisTemplate（StringRedisTemplate）-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--springweb起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件application.properties:端口号、Redis的连接等相关设置

#设置煅后端口号，和上下文访问路径
server.port=9001
server.servlet.context-path=/myredis

#指定redis（host，ip，password）
spring.redis.host=localhost
spring.redis.port=6379

#自己的电脑redis没有密码
#spring.redis.password=123

创建控制类：

RedisController：使用RedisTemplate类

package com.bjpowernode.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController  // @Controller和@ResponseBody的组合    @ResponseBody:把String返回值当做数据来返回给浏览器
public class RedisController {

    /*注入RedisTemplate
    * 可以写<String,String> 也可以<Object,Object> 也可以不写
    *
    * RedisTemplate泛型：
    *   RedisTemplate<String,String>
    *   RedisTemplate<Object,Object>
    *   RedisTemplate
    *
    * 注意RedisTemplate的对象名称 redisTemplate  默认采用JDK的序列化方式
    *  */
    @Resource //注解注入进来
    private RedisTemplate redisTemplate;

    //添加数据到Redis
    @PostMapping("/redis/addstring")
    public String addToRedis(String name,String value){

        ValueOperations valueOperations = redisTemplate.opsForValue();
        //添加数据到redis
        valueOperations.set("myname","lisi");

        return "向redis添加string类型的数据";
    }

    //从redis中获取数据
    @GetMapping("/redis/getk")
    public String getData(String k){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object v = valueOperations.get(k);
        return "key是:"+k+",它的值是："+v;
    }
}

 在运行项目之前先打开Windows版本的Redis

 

主启动类MyApplicatioin：运行项目：

package com.bjpowernode;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

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

}

使用postman发送请求：

 PostMapper  是一个post请求

 成功添加数据：

 获取数据：

 通过客户端可以看到：用的是jdk的序列化，但是发现可读性 不好

RedisController：中在使用StringRedisTemplate类，后两个方法添加获取数据

package com.bjpowernode.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController  // @Controller和@ResponseBody的组合    @ResponseBody:把String返回值当做数据来返回给浏览器
public class RedisController {

    /*注入RedisTemplate
    * 可以写<String,String> 也可以<Object,Object> 也可以不写
    *
    * RedisTemplate泛型：
    *   RedisTemplate<String,String>
    *   RedisTemplate<Object,Object>
    *   RedisTemplate
    *
    * 注意RedisTemplate的对象名称 redisTemplate  //采用JDK序列化
    *  */
    @Resource //注解注入进来
    private RedisTemplate redisTemplate;

    @Resource
    private StringRedisTemplate stringRedisTemplate; //默认采用字符串序列化

    //添加数据到Redis
    @PostMapping("/redis/addstring")
    public String addToRedis(String name,String value){

        ValueOperations valueOperations = redisTemplate.opsForValue();
        //添加数据到redis
        valueOperations.set("myname","lisi");

        return "向redis添加string类型的数据";
    }

    //从redis中获取数据
    @GetMapping("/redis/getk")
    public String getData(String k){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object v = valueOperations.get(k);
        return "key是:"+k+",它的值是："+v;
    }


    //StringRedisTemplate


    @PostMapping("/redis/{k}/{v}")
    public String addStringKV(@PathVariable String k,
                              @PathVariable String v){

        //使用StringRedisTemplate对象
        stringRedisTemplate.opsForValue().set(k,v);
        return "使用StringRedisTemple对象";

    }

    //从redis中获取数据
    @GetMapping("/redis/getstr/{k}")
    public String getStringValue(@PathVariable String k){
        String v = stringRedisTemplate.opsForValue().get(k);
        return "key是:"+k+",它的值是："+v;
    }
}

 使用postman发送请求：添加方法

获取方法 

 

 

使用客户端获取数据：StringRedisTemplate采用的String的序列化，可读性较好

 

 

 

序列化

 

 

 

 如果那你想改变RedisTemplate的序列化机制

RedisController：最后一个方法

package com.bjpowernode.controller;

        import org.springframework.data.redis.core.RedisTemplate;
        import org.springframework.data.redis.core.StringRedisTemplate;
        import org.springframework.data.redis.core.ValueOperations;
        import org.springframework.data.redis.serializer.StringRedisSerializer;
        import org.springframework.web.bind.annotation.GetMapping;
        import org.springframework.web.bind.annotation.PathVariable;
        import org.springframework.web.bind.annotation.PostMapping;
        import org.springframework.web.bind.annotation.RestController;

        import javax.annotation.Resource;

@RestController  // @Controller和@ResponseBody的组合    @ResponseBody:把String返回值当做数据来返回给浏览器
public class RedisController {

    /*注入RedisTemplate
     * 可以写<String,String> 也可以<Object,Object> 也可以不写
     *
     * RedisTemplate泛型：
     *   RedisTemplate<String,String>
     *   RedisTemplate<Object,Object>
     *   RedisTemplate
     *
     * 注意RedisTemplate的对象名称 redisTemplate  //采用JDK序列化
     *  */
    @Resource //注解注入进来
    private RedisTemplate redisTemplate;

    @Resource
    private StringRedisTemplate stringRedisTemplate; //默认采用字符串序列化

    //添加数据到Redis
    @PostMapping("/redis/addstring")
    public String addToRedis(String name,String value){

        ValueOperations valueOperations = redisTemplate.opsForValue();
        //添加数据到redis
        valueOperations.set("myname","lisi");

        return "向redis添加string类型的数据";
    }

    //从redis中获取数据
    @GetMapping("/redis/getk")
    public String getData(String k){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object v = valueOperations.get(k);
        return "key是:"+k+",它的值是："+v;
    }


    //StringRedisTemplate


    @PostMapping("/redis/{k}/{v}")  //RESTful风格
    public String addStringKV(@PathVariable String k,
                              @PathVariable String v){

        //使用StringRedisTemplate对象
        stringRedisTemplate.opsForValue().set(k,v);
        return "使用StringRedisTemple对象";

    }

    //从redis中获取数据
    @GetMapping("/redis/getstr/{k}")
    public String getStringValue(@PathVariable String k){
        String v = stringRedisTemplate.opsForValue().get(k);
        return "key是:"+k+",它的值是："+v;
    }

    /*设置RedisTemplate 序列化
    *  可以设置key 的序列化，可以设置value的序列化
    *  可以同时设置key和value的序列化
    *
    * */
    @PostMapping("/redis/addstr")
    public String addString(String  k,String v){
        //使用RedisTemplate
        //设置key 使用String的序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        //设置value的序列化
        redisTemplate.setValueSerializer(new StringRedisSerializer());

        redisTemplate.opsForValue().set(k,v);

        return "定义RedisTemplate对象 key ，value的序列化";
    }
}

 

 客户端查看：

 图形 客户端界面：

 Json的序列化和反序列化：

创建Student类：

package com.bjpowernode.vo;

import java.io.Serializable;

public class Student implements Serializable {
    //放在Student类上Alt+回车生成序列化版本号
    private static final long serialVersionUID = 6957173297825217669L;
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

RedisController：最后两个方法：

package com.bjpowernode.controller;

        import com.bjpowernode.vo.Student;
        import org.springframework.data.redis.core.RedisTemplate;
        import org.springframework.data.redis.core.StringRedisTemplate;
        import org.springframework.data.redis.core.ValueOperations;
        import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
        import org.springframework.data.redis.serializer.StringRedisSerializer;
        import org.springframework.web.bind.annotation.GetMapping;
        import org.springframework.web.bind.annotation.PathVariable;
        import org.springframework.web.bind.annotation.PostMapping;
        import org.springframework.web.bind.annotation.RestController;

        import javax.annotation.Resource;

@RestController  // @Controller和@ResponseBody的组合    @ResponseBody:把String返回值当做数据来返回给浏览器
public class RedisController {

    /*注入RedisTemplate
     * 可以写<String,String> 也可以<Object,Object> 也可以不写
     *
     * RedisTemplate泛型：
     *   RedisTemplate<String,String>
     *   RedisTemplate<Object,Object>
     *   RedisTemplate
     *
     * 注意RedisTemplate的对象名称 redisTemplate  //采用JDK序列化
     *  */
    @Resource //注解注入进来
    private RedisTemplate redisTemplate;

    @Resource
    private StringRedisTemplate stringRedisTemplate; //默认采用字符串序列化

    //添加数据到Redis
    @PostMapping("/redis/addstring")
    public String addToRedis(String name,String value){

        ValueOperations valueOperations = redisTemplate.opsForValue();
        //添加数据到redis
        valueOperations.set("myname","lisi");

        return "向redis添加string类型的数据";
    }

    //从redis中获取数据
    @GetMapping("/redis/getk")
    public String getData(String k){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object v = valueOperations.get(k);
        return "key是:"+k+",它的值是："+v;
    }


    //StringRedisTemplate


    @PostMapping("/redis/{k}/{v}")  //RESTful风格
    public String addStringKV(@PathVariable String k,
                              @PathVariable String v){

        //使用StringRedisTemplate对象
        stringRedisTemplate.opsForValue().set(k,v);
        return "使用StringRedisTemple对象";

    }

    //从redis中获取数据
    @GetMapping("/redis/getstr/{k}")
    public String getStringValue(@PathVariable String k){
        String v = stringRedisTemplate.opsForValue().get(k);
        return "key是:"+k+",它的值是："+v;
    }

    /*设置RedisTemplate 序列化
    *  可以设置key 的序列化，可以设置value的序列化
    *  可以同时设置key和value的序列化
    *
    * */
    @PostMapping("/redis/addstr")
    public String addString(String  k,String v){
        //使用RedisTemplate
        //设置key 使用String的序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        //设置value的序列化
        redisTemplate.setValueSerializer(new StringRedisSerializer());

        redisTemplate.opsForValue().set(k,v);

        return "定义RedisTemplate对象 key ，value的序列化";
    }


    /*使用json 序列化，把java对象转换为json
    *
    *
    * */
    @PostMapping("/redis/addjson")
    public String addJson(){
        Student student=new Student();
        student.setId(1001);
        student.setName("zhangsan");
        student.setAge(20);

        redisTemplate.setKeySerializer(new StringRedisSerializer());

        //把值作json序列化
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Student.class));

        redisTemplate.opsForValue().set("mystudent",student);

        return "json序列化";
    }

    //反序列化  获取json数据，转换为对象
    @PostMapping("/redis/getjson")
    public String getJson(){

        redisTemplate.setKeySerializer(new StringRedisSerializer());

        //把值作json序列化
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Student.class));

        //这个类已经做了，你用什么序列化，它既可以给你反序列化回来
        Object obj = redisTemplate.opsForValue().get("mystudent");

        return "json反序列化="+obj;
    }
}

重启启动主启动类，用postman做这个请求：

java对象序列化

redis客户端：

 

 反序列化获取对象：把redis中存放的json反序列化成一个对象