Comment utiliser Redis dans SpringBoot

1. Dépendances

Les dépendances Maven sont les suivantes. Il convient de noter que spring-boot-starter-data-redis utilise lettuce comme pilote du client redis par défaut, mais lettuce est moins pratique. client. pilote final, donc la laitue est exclue ici et jedis est introduit :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

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

2. Dépendances

Dépendances dans Spring Data Redis :

Ce que cette dépendance veut exprimer, c'est que Spring exploite Redis via RedisConnection encapsule. la lignée native des Jedis. Pour obtenir l'objet d'interface RedisConnection, il est généré via RedisConnectionFactory.

3. Configuration

Configuration du fichier de configuration :

# Redis 连接配置
# 单机 Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
# 连接池配置
spring.redis.jedis.pool.max-idle=30
spring.redis.jedis.pool.max-total=50
spring.redis.jedis.pool.max-wait=2000ms

Configuration du code :

@Configuration
public class RedisConfig {
    private RedisConnectionFactory connectionFactory = null;
 
    @Bean
    public RedisConnectionFactory initRedisConnectionFactory(){
        if(connectionFactory!=null){
            return connectionFactory;
        }
        JedisPoolConfig poolConfig =new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(30);
        //最大连接数
        poolConfig.setMaxTotal(50);
        //最大等待毫秒数
        poolConfig.setMaxWaitMillis(2000);
        //创建Jedis连接工厂
        JedisConnectionFactory connectionFactory=new JedisConnectionFactory(poolConfig);
        //获取单机的redis配置，如果是集群的话用集群配置类
        RedisStandaloneConfiguration rscfg=connectionFactory.getStandaloneConfiguration();
        connectionFactory.setHostName("127.0.0.1");
        connectionFactory.setPort(6379);
        return connectionFactory;
    }
}

4. RedisTemplate

Ce que je veux expliquer ici, c'est que si nous utilisons RedisConnection directement pour faire fonctionner Redis, nous devons trouver manuellement RedisConnectionFactory pour obtenir. RedisConnection. Et RedisConnection doit être fermé manuellement à chaque fois. Par conséquent, Spring Data Redis fournit RedisTemplate pour faciliter le fonctionnement. Il est encapsulé à partir de jedis et bloque les étapes d'acquisition et de libération des ressources.

La principale chose à laquelle il faut prêter attention lors de l'utilisation de RedisTemplate est son sérialiseur. RedisTemplate a plusieurs sérialiseurs qui utilisent différentes méthodes de sérialisation dans le processus d'écriture des valeurs clés et de lecture de Redis. Par exemple, lors du traitement de caractères, vous devez utiliser un sérialiseur spécifique à une chaîne et lors du traitement d'objets, vous devez utiliser un sérialiseur spécifique à un objet.

Les sérialiseurs actuels sont les suivants :

StringRedisSerializer :

StringRedisSerializer est le sérialiseur de clé et de valeur utilisé par RedisTemplate par défaut. Il sérialise les chaînes en tableaux d'octets, en utilisant le codage UTF-8. Étant donné que Key et Value dans Redis sont toutes deux des chaînes, le sérialiseur StringRedisSerializer par défaut peut répondre aux besoins de la plupart des situations.

Jackson2JsonRedisSerializer :

Jackson2JsonRedisSerializer est un sérialiseur de clé et de valeur Redis basé sur Jackson qui peut sérialiser des objets dans des chaînes au format JSON et les stocker dans Redis. Pour utiliser le sérialiseur Jackson2JsonRedisSerializer, vous devez ajouter une dépendance Jackson. Vous pouvez convertir des objets en chaînes au format JSON ou vous pouvez convertir des chaînes au format JSON en objets.

JdkSerializationRedisSerializer :

JdkSerializationRedisSerializer est un sérialiseur basé sur la propre méthode de sérialisation de Java, qui peut sérialiser des objets dans des tableaux d'octets pour le stockage. Bien que JdkSerializationRedisSerializer soit simple et facile à utiliser, son efficacité est relativement faible et le tableau d'octets sérialisés est relativement volumineux, ce qui le rend inadapté au stockage de grandes quantités de données.

GenericJackson2JsonRedisSerializer :

GenericJackson2JsonRedisSerializer est un Jackson2JsonRedisSerializer qui prend en charge les génériques, qui peuvent sérialiser tout type d'objet et sérialiser l'objet dans une chaîne au format JSON. Cela nécessite de spécifier le type de cible à la fois lors de la sérialisation et de la désérialisation.

OxmSerializer :

OxmSerializer est un sérialiseur basé sur le framework de mappage O/X de Spring, qui prend en charge la sérialisation d'objets dans des chaînes au format XML. Bien qu'OxmSerializer ait une grande flexibilité, ses performances de sérialisation et de désérialisation sont faibles et il n'est pas adapté au stockage de grandes quantités de données.

En bref, lors du choix d'un sérialiseur, vous devez choisir en fonction de la situation réelle et choisir le sérialiseur approprié en fonction du type de données et des exigences de performances.

Vous pouvez simplement le définir directement lors de son utilisation. Lors du paramétrage, de nombreuses options vous sont proposées pour la granularité de l'effet, qu'il soit efficace pour toutes les structures de données de type Redis ou pour un certain type de type de structure de données Redis. :

Par exemple, je souhaite utiliser un sérialiseur String, qui prendra effet globalement :

@Bean
public RedisTemplate<Object,Object> initRedisTemplate(){
  RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
  redisTemplate.setDefaultSerializer(new StringRedisSerializer());
  return redisTemplate;
}

5 Opérations de base

Ce qui suit est un exemple de code pour utiliser RedisTemplate pour exploiter les types de données de base Redis :

Il. Il convient de noter que lorsque @Bean définit RedisTemplate, il doit s'agir d'un alignement générique et générique lorsqu'il est utilisé.

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class RedisService {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
    public void setString(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }
 
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
 
    public void setHash(String key, String hashKey, Object value) {
        HashOperations<String, String, Object> hashOps = redisTemplate.opsForHash();
        hashOps.put(key, hashKey, value);
    }
 
    public Object getHash(String key, String hashKey) {
        HashOperations<String, String, Object> hashOps = redisTemplate.opsForHash();
        return hashOps.get(key, hashKey);
    }
 
    public void setList(String key, Object value) {
        ListOperations<String, Object> listOps = redisTemplate.opsForList();
        listOps.rightPush(key, value);
    }
 
    public Object getList(String key, long index) {
        ListOperations<String, Object> listOps = redisTemplate.opsForList();
        return listOps.index(key, index);
    }
 
    public void setSet(String key, Object value) {
        SetOperations<String, Object> setOps = redisTemplate.opsForSet();
        setOps.add(key, value);
    }
 
    public Object getSet(String key) {
        SetOperations<String, Object> setOps = redisTemplate.opsForSet();
        return setOps.members(key);
    }
 
    public void setZSet(String key, Object value, double score) {
        ZSetOperations<String, Object> zsetOps = redisTemplate.opsForZSet();
        zsetOps.add(key, value, score);
    }
 
    public Object getZSet(String key, long start, long end) {
        ZSetOperations<String, Object> zsetOps = redisTemplate.opsForZSet();
        return zsetOps.range(key, start, end);
    }
 
}

6. Transactions

Voici un exemple de code utilisant des transactions :

@Autowired
private RedisTemplate<String, String> redisTemplate;
 
public void transactionalOperation() {
    // 开启 Redis 事务
    redisTemplate.multi();
 
    try {
        // 执行多个 Redis 命令
        redisTemplate.opsForValue().set("key1", "value1");
        redisTemplate.opsForValue().set("key2", "value2");
 
        // 提交事务
        redisTemplate.exec();
    } catch (Exception e) {
        // 回滚事务
        redisTemplate.discard();
    }
}

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!