How does Java SpringBoot operate Redis?

Redis

1. Add redis dependency

spring Boot provides a component package for Redis integration: spring-boot-starter-data-redis, which depends on spring-data-redis and lettuce.

In addition, there are two small details here:

• In the Spring Boot 1.x era, the bottom layer of spring-data-redis used Jedis; in the 2.x era Replaced with Lettuce.

• Lettuce depends on commons-pool2

<!-- springboot整合redis--> 
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 使用 lettuce 时要加这个包；使用 jedis 时则不需要。-->
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifactId>
</dependency>

2. Configuration file

## 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
## 连接池中的最大空闲连接 默认 8
spring.redis.lett	uce.pool.max-idle=8
## 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

3. Operation redis API

In this unit test, we use redisTemplate to store a string "Hello Redis".

Spring Data Redis has reclassified and encapsulated the api, encapsulating the same type of operations into Operation interface:

##ValueOperationsData operations of string typeListOperationslist type data operationSetOperationsset type data operationZSetOperations zset type data operationHashOperationsmap type data operation##

//解决中文乱码问题
@Configuration
public class RedisConfig {
    
    @Bean
    public RedisTemplate redisTemplateInit(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置序列化Key的实例化对象
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        /**
         *
         * 设置Hash类型存储时，对象序列化报错解决
         */
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
}

4, RedisTemplate and StringRedisTemplate

Proprietary operations	Description

RedisTemplate

But obviously, this is contrary to the actual situation of Redis: at the smallest storage unit level, Redis can essentially only store strings and cannot store other types. From this point of view, StringRedisTemplate is more in line with the storage nature of Redis. How does RedisTemplate support any type by serializing values?.

When using RedisTemplate to store objects, the address of the object will be saved for deserialization, which will greatly waste storage space. To solve this problem, use StringRedisTemplate, thinking that manual serialization and deserialization are required

 Users users = new Users();
 users.setId(2);
 users.setUsername("李四2");
 redisTemplate.opsForValue().set("user:2", JSON.toJSONString(users)); //存的时候序列化对象
 String u = redisTemplate.opsForValue().get("user:2");  //redis 只能返回字符串
 System.out.println("u="+ JSON.parseObject(u,Users.class));  //使用JSON工具反序化成对象

If the spring-boot-starter-web dependency is not introduced in springboot, you need to add the jackson dependency.

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
</dependency>

5. SpringBoot operates String string

a. Key expiration

Automatic expiration problem of key. Redis can set a timeout when storing each data. time, the data will be automatically deleted after this time.

Commonly used redis time units

MINUTES

: Minutes

SECONDS

: Seconds

DAYS

: Day

//给user对象设置10分钟过期时间
redisTemplate.opsForValue().set("user:1", JSON.toJSONString(users),10,TimeUnit.MINUTES );

b, delete data

 //删除键
 redisTemplate.delete(key);
 //判断键是否存在
 boolean exists = redisTemplate.hasKey(key);

6, SpringBoot operates Hash (hash)

Generally when we store a key, it will naturally Using get/set to store is actually not a good idea. Redis will have a minimum memory to store a key. No matter how small the key you store is, it will not be less than this memory. Therefore, reasonable use of Hash can help us save a lot of memory.

	@Test
    public void testHash() {
        String key = "tom";
        HashOperations<String, Object, Object> operations = redisTemplate.opsForHash();
        operations.put(key, "name", "tom");
        operations.put(key, "age", "20");
        String value= (String) operations.get(key,"name");
        System.out.println(value);
    }

According to the above test case, it is found that three parameters need to be passed in during Hash set. The first is key, the second is field, and the third is the stored value. Generally speaking, Key represents a set of data, field is the attribute related to key, and value is the value corresponding to the attribute.

7. SpringBoot operates List collection type

Redis List has many application scenarios and is also one of the most important data structures of Redis. You can easily implement a queue using List. A typical application scenario of List is message queue. You can use the Push operation of List to store tasks in the List, and then the worker thread uses the POP operation to take out the task for execution.

/**
     * 测试List
     * leftPush 将数据添加到key对应的现有数据的左边，也就是头部
     * leftPop  取队列最左边数据（从数据库移除）
     * rightPush 将数据添加到key对应的现有数据的右边，也就是尾部
     */
    @Test
    public void testList() {
        final String key = "list";
        ListOperations<String,Object> list = redisTemplate.opsForList();
        list.leftPush(key, "hello");
        list.leftPush(key, "world");
        list.leftPush(key, "goodbye");
      
        Object mete = list.leftPop("list");
        System.out.println("删除的元素是："+mete); //删除 goodbye 
        String value = (String) list.leftPop(key);

        System.out.println(value.toString());
        
        // range(key, 0, 2) 从下标0开始找，找到2下标
        List<Object> values = list.range(key, 0, 2);
        for (Object v : values) {
            System.out.println("list range :" + v);
        }
    }
}

Redis List is implemented as a two-way linked list, which can support reverse search and traversal, making it more convenient to operate. However, it brings some additional memory overhead, many implementations within Redis, including sending buffer queues, etc. This data structure is also used.

8. SpringBoot operates Set collection type

The external functions provided by Redis Set are similar to List. It is a list function. The special thing is that Set can automatically deduplicate when you need it. Set is a good choice when storing a list of data and does not want duplicate data, and Set provides an important interface for determining whether a member is in a Set collection, which List cannot provide.

 /**
     * 测试Set
     */
    @Test
    public void testSet() {
        final String key = "set";
        SetOperations<String,Object> set = redisTemplate.opsForSet();
        set.add(key, "hello");
        set.add(key, "world");
        set.add(key, "world");
        set.add(key, "goodbye");
        Set<Object> values = set.members(key);
        for (Object v : values) {
            System.out.println("set value :" + v);
        }
       
        Boolean exist = set.isMember(key,"hello") //判断是否存在某个元素
        operations.move("set", "hello", "setcopy"); //把set集合中的hello元素放到setcopy 中
 
    }
}

9. SpringBoot operates ZSet collection type

The usage scenarios of Redis ZSet are similar to Set. The difference is that Set is not automatically ordered, and ZSet can provide an additional priority (Score) through the user. ) parameters to sort the members, and it is insertion order, that is, automatic sorting.

	/**
     * 测试ZSet
     * range(key, 0, 3) 从开始下标到结束下标，score从小到大排序
     * reverseRange  score从大到小排序
     * rangeByScore(key, 0, 3); 返回Score在0至3之间的数据
     */
    @Test
    public void testZset() {
        final String key = "lz";
        ZSetOperations<String,Object> zset = redisTemplate.opsForZSet();
        zset.add(key, "hello", 1);
        zset.add(key, "world", 6);
        zset.add(key, "good", 4);
        zset.add(key, "bye", 3);

        Set<Object> zsets = zset.range(key, 0, 3);
        for (Object v : zsets) {
            System.out.println("zset-A value :"+v);
        }
        
        System.out.println("=======");
        Set<Object> zsetB = zset.rangeByScore(key, 0, 3);
        for (Object v : zsetB) {
            System.out.println("zset-B value :"+v);
        }
    }
}

The above is the detailed content of How does Java SpringBoot operate Redis?. For more information, please follow other related articles on the PHP Chinese website!