spring-boot-starter-redis 熟练运用

Redis 的 Java 客户端很多，官方推荐的有三种：

• Jedis    ( java redis)
• Redisson
• Lettuce

Spring 对 Redis 客户端进行了整合，提供了 Spring Data Redis，在Spring Boot项目中还提供了对应的Starter，即 spring-boot-starter-data-redis。

Jedis(了解)

项目准备

Jedis是Redis的Java版本客户端，现在我们开始进行测试Jedis,创建Maven项目结构如下:

• maven坐标依赖

<?xml versinotallow="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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zbbmeta</groupId>
    <artifactId>day26-01-Jedis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.3.1</version>
        </dependency>

    </dependencies>

</project>

使用Jedis操作Redis步骤

使用Jedis操作Redis步骤，如下:

• 1.获取链接
• 2.执行操作
• 3.关闭连接

示例：

package com.zbbmeta;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

/**
 * @author maguobin
 * @description: TODO
 */
public class JedisMain {
    //目标：使用Jedis（java redis）的java客户端操作redis数据库存储数据
    public static void main(String[] args) {

        //1.创建连接池对象JedisPool
        //创建连接池配置数据对象
        JedisPoolConfig config = new JedisPoolConfig();
        //配置最大连接数
        config.setMaxTotal(10);
        //配置用户等待超时时间
        config.setMaxWait(Duration.ofSeconds(30)); //30秒
        //实例连接池对象
        JedisPool pool = new JedisPool(config,"192.168.150.101", 6379);

        ////2.获取一个连接对象（Jedis对象）
        try (Jedis jedis = pool.getResource()) {
            //3.操作数据
            //Redis的字符串类型
            jedis.set("foo", "bar");
            System.out.println(jedis.get("foo")); // prints bar

            //Redis的Hash类型
            Map<String, String> hash = new HashMap<>();;
            hash.put("name", "John");
            hash.put("surname", "Smith");
            hash.put("company", "Redis");
            hash.put("age", "29");
            jedis.hset("user-session:123", hash);
            System.out.println(jedis.hgetAll("user-session:123"));
            // Prints: {name=John, surname=Smith, company=Redis, age=29}
        }
    }
}

SpringBoot Data Redis学习(重要)

SpringBoot Data Redis介绍

Spring Data Redis 是 Spring 的一部分，提供了在 Spring 应用中通过简单的配置就可以访问 Redis 服务，对 Redis 底层开发包进行了高度封装。在 Spring 项目中，可以使用Spring Data Redis来简化 Redis 操作。

网址：https://spring.io/projects/spring-data-redis

• maven坐标

<dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-redis</artifactId>
  <version>2.7.14</version>
</dependency>

• SpringBoot提供的对应Starter的Maven坐标

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.7.14</version>
</dependency>

Spring Data Redis中提供了一个高度封装的类：RedisTemplate，针对 Jedis 客户端中大量api进行了归类封装,将同一类型操作封装为operation接口，具体分类如下：

• ValueOperations：简单K-V操作
• SetOperations：set类型数据操作
• ZSetOperations：zset类型数据操作
• HashOperations：针对hash类型的数据操作
• ListOperations：针对list类型的数据操作

SpringBoot Data Redis使用方式

【步骤一】:创建SpringBoot项目

创建项目名称为day26-02-spring-data-redis的SpringBoot项目

【步骤二】:配置pom.xml文件和实体类

• pom.xml添加依赖

<?xml versinotallow="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.14</version>
    </parent>
    <groupId>com.zbbmeta</groupId>
    <artifactId>day26-02-spring-data-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.7.14</version>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.3.1</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.32</version>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</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>

• 创建实体类

package com.zbbmeta.entity;

import lombok.Data;

import java.io.Serializable;

/**
 * @author maguobin
 * @description: TODO
 */
@Data
public class User implements Serializable {

    private String name;
    private Integer age;
}

【步骤三】:编写RedisTemplate配置类

springdata_redis帮我们创建的RedisTemplate对象是默认使用jdk的序列号器帮我们键与值存储到redis中，而jdk的序列号器对键与值是采用二进制的方式存储的，所以我们会看到乱码的情况。如果我们需要看得懂，那么需要修改redistemplate使用的序列号器才行。  配置类如下:

package com.zbbmeta.config;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author springboot葵花宝典
 * @description: TODO
 */
@Configuration
public class RedisConfig {
    //目标：通过@Bean创建对象加入IOC容器，这里手动创建RedisTemplate对象目的是修改默认的序列化策略
    // RedisConnectionFactory 是springdatarediis封装的redis连接池工厂
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //修改key的序列化策略为普通字符串序列化，这样就不会进行jdk序列化了
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        //修改默认value的jdk序列器修改为json序列化器,效果是存储到redis服务器中是json字符串格式
        redisTemplate.setValueSerializer(new GenericFastJsonRedisSerializer());
        //注意：一般都不会修改value序列化器，因为一般都不需要关系redis存储数据的格式。

        return redisTemplate;
    }
}

当前配置类不是必须的，因为 Spring Boot 框架会自动装配 RedisTemplate 对象，但是默认的key序列化器为JdkSerializationRedisSerializer，导致我们存到Redis中后的数据和原始数据有差别

【步骤四】:配置Redis链接地址

在application.yml中配置redis地址

spring:
  redis:
    jedis:
      pool:
       # 最大连接数
        max-active: 10
         # 用户等待最大超时时间，单位毫秒
        max-wait: 3000
    port: 6379 # 端口
    host: 192.168.150.101 # 地址
    database: 1 #数据库

创建string(字符串)类型操作测试

package com.zbbmeta;

import com.zbbmeta.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.*;

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

@SpringBootTest
class Day2602SpringDataRedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    //目标：获取字符串操作类对字符串数据实现redis数据库存储操作
    @Test
    public void test(){
        ValueOperations valueOperations = redisTemplate.opsForValue();

        //1.写入字符串数据 set key value
        valueOperations.set("name1","admin");
        String name1 = (String) valueOperations.get("name1");
        System.out.println("name1="+name1);
        //2.写入字符串数据 setex key seconds value
        valueOperations.set("name2","admin2",1, TimeUnit.MINUTES); //设置过期1分钟
        //3.写入字符串数据 setnx key seconds value
        valueOperations.setIfAbsent("name3","admin3");
        //4.删除字符串数据 del value
        redisTemplate.delete("name3");

        //5.存储java对象
        User user = new User();
        user.setAge(20);
        user.setName("播仔");
        valueOperations.set("bozai",user);
        User user2 = (User) valueOperations.get("bozai");

    }
}

效果:

创建hash(哈希)类型操作测试

/**
     * 操作hash类型
     */
    @Test
    public void testHash(){
        //1. 得到操作hash类型的客户端对象
        HashOperations<String, Object, Object> hashOperations = redisTemplate.opsForHash();
        //存储
        hashOperations.put("person","id","110");
        hashOperations.put("person","name","狗娃");
        //取
        System.out.println("姓名："+ hashOperations.get("person","name"));
        //所有field
        Set<Object> set = hashOperations.keys("person");
        for (Object key : set) {
            System.out.print(key+",");
        }
        System.out.println();

        //所有值
        List<Object> list = hashOperations.values("person");
        for (Object value : list) {
            System.out.print(value+",");
        }
        System.out.println();
    }

效果:

创建list类型类型操作测试

/**
 * 操作list类型
 */
@Test
public void testList(){
    //1. 得到操作list对象的客户端对象
    ListOperations<Object, Object> listOperations = redisTemplate.opsForList();
    //2. 存
    listOperations.leftPushAll("list","张三","李四","王五");

    //3. 取
    System.out.println("list集合的元素："+listOperations.range("list",0,-1));

    //4.得到长度
    System.out.println("长度："+ listOperations.size("list"));
}

效果:

创建set类型类型操作测试

@Test
public void testSet(){
    //1. 得到操作set对象的客户端对象
    SetOperations<Object, Object> setOperations = redisTemplate.opsForSet();
    //存
    setOperations.add("set","洋洋","张庭","凡凡","签签","洋洋");
    //取
    Set<Object> set = setOperations.members("set");
    set.forEach(System.out::println);

    //删
    setOperations.remove("set","洋洋");

    //查看内容
    System.out.println("=========删除后的内容=========");
    set = setOperations.members("set");
    set.forEach(System.out::println);
}

效果:

创建zset类型类型操作测试

/**
 * 操作zset类型
 */
@Test
public void testzSet(){
    //1. 得到操作zset对象的客户端对象
    ZSetOperations<Object, Object> zSetOperations = redisTemplate.opsForZSet();

    //2. 存
    zSetOperations.add("zset1","洋洋",100);
    zSetOperations.add("zset1","林荣",180);
    zSetOperations.add("zset1","尚晋",250);

    //取
    Set<Object> zset1 = zSetOperations.range("zset1", 0, -1);
    //注意：降序查询 zSetOperations.reverseRange("zset1",0,-1);
    for (Object name : zset1) {
        System.out.println("姓名："+ name+" 分数："+zSetOperations.score("zset1",name));
    }

    //修改
    zSetOperations.incrementScore("zset1","尚晋",-2);


    //取
    System.out.println("=======修改后的分数==========");
    zset1 = zSetOperations.range("zset1", 0, -1);
    for (Object name : zset1) {
        System.out.println("姓名："+ name+" 分数："+zSetOperations.score("zset1",name));
    }
}

效果: