Comment Java SpringBoot exploite-t-il Redis ?

Redis

1. Ajouter une dépendance Redis

spring Boot fournit un package de composants pour l'intégration de Redis : spring-boot-starter-data-redis, qui dépend de spring-data-redis et de lettuce.

De plus, il y a deux petits détails ici :

• À l'ère Spring Boot 1.x, la couche inférieure de spring-data-redis utilisait Jedis ; à l'ère 2.x, elle a été remplacée par Lettuce.

• Lettuce dépend de 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, fichier de configuration

## 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, fonctionnant avec l'API redis

Dans ce test unitaire, nous utilisons redisTemplate pour stocker une chaîne "Hello Redis" .

Spring Data Redis a reclassé et encapsulé l'API, encapsulant le même type d'opérations dans l'interface 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;
    }
}

RedisTemplateb272177b2cdcb9ccceef20c389511534 semble plus "puissant" que StringRedisTemplate car il n'exige pas que le type de clés et de valeurs soit String.

 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工具反序化成对象

Si springboot Le La dépendance spring-boot-starter-web n'est pas introduite, vous devez donc ajouter la dépendance jackson.

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

problème d'expiration automatique de la clé, Redis peut définir un délai d'attente lors du stockage de chaque donnée, et les données seront automatiquement supprimées après cette heure. MINUTES : minutes

Opération propriétaire	Description
ValueOperations	Opérations de données de type chaîne
ListeOpérations Opération de données de type liste	4, RedisTemplate et StringRedisTemplate
Mais évidemment, cela est contraire à la situation réelle de Redis : au plus petit niveau d'unité de stockage, Redis ne peut essentiellement stocker que des chaînes et ne peut pas stocker d'autres types. De ce point de vue, StringRedisTemplate correspond davantage à la nature de stockage de Redis. Comment RedisTemplate prend-il en charge n'importe quel type en sérialisant les valeurs ?	Lorsque vous utilisez RedisTemplate pour stocker des objets, l'adresse de l'objet sera enregistrée pour la désérialisation, ce qui gaspillera grandement de l'espace de stockage. Pour résoudre ce problème, utilisez StringRedisTemplate, en pensant que vous souhaitez sérialiser et désérialiser manuellement
5. SpringBoot exploite la chaîne de caractères	a, l'expiration de la clé
Unités de temps Redis couramment utilisées

SECONDS

 : secondes

DAYS

 : jours

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

b, supprimer des données

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

6, opération SpringBoot Hash (hash)

Normal Quand nous stockons une clé, il est naturel d'utiliser get/set pour la stocker. En fait, ce n'est pas une bonne pratique. Redis aura une mémoire minimale pour stocker une clé, quelle que soit la taille de la clé que vous stockez, elle ne sera pas inférieure à cette mémoire. Par conséquent, une utilisation raisonnable de Hash peut nous aider à économiser beaucoup de mémoire.

	@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);
    }

Selon le cas de test ci-dessus, il s'avère que trois paramètres doivent être transmis lors du jeu de hachage, le premier est la clé, le second est le champ et le troisième est la valeur stockée. De manière générale, Key représente un ensemble de données, field est l'attribut lié à key et value est la valeur correspondant à l'attribut.

7. SpringBoot exploite le type de collection List

Redis List a de nombreux scénarios d'application et est également l'une des structures de données les plus importantes de Redis. Vous pouvez facilement implémenter une file d'attente à l'aide de List. Un scénario d'application typique de List est la file d'attente de messages. Vous pouvez utiliser l'opération Push de List pour stocker les tâches dans List, puis le thread de travail utilise l'opération POP pour exécuter la tâche.

/**
     * 测试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 est implémenté sous la forme d'une liste chaînée bidirectionnelle, qui peut prendre en charge la recherche inversée et le parcours, ce qui la rend plus pratique à utiliser. Cependant, elle entraîne une surcharge de mémoire supplémentaire dans Redis, y compris les files d'attente de tampon d'envoi, etc. ., utilisation également de cette structure de données.

8. SpringBoot fonctionne sur le type de collection Set

Les fonctions externes fournies par Redis Set sont similaires à List. La particularité est que Set peut automatiquement dédupliquer les données d'une liste, mais vous le faites. ne pas vouloir Set est un bon choix lorsque des données en double se produisent, et Set fournit une interface importante pour déterminer si un membre fait partie d'une collection Set, ce que List ne peut pas fournir.

 /**
     * 测试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 exploite le type de collection ZSet

Redis Le scénario d'utilisation de ZSet est similaire à Set. La différence est que Set n'est pas automatiquement ordonné, tandis que ZSet peut trier les membres en fournissant un paramètre de priorité supplémentaire (Score) par l'utilisateur. . Et c'est l'ordre d'insertion, c'est-à-dire le tri automatique.

	/**
     * 测试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);
        }
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!