Comment Java utilise le client Lettuce pour exécuter des commandes en mode maître-esclave Redis

1 Le concept de réplication maître-esclave Redis

Dans un environnement multi-machines, un service Redis reçoit des commandes d'écriture et les copie sur un ou plusieurs Redis lorsque ses propres données et son statut changent. Ce mode est appelé réplication maître-esclave. Grâce à la commande slaveof, un serveur Redis peut copier les données et l'état d'un autre serveur Redis dans Redis. Nous appelons le serveur principal maître et le serveur esclave esclave.

La réplication maître-esclave garantit que les données seront répliquées lorsque le réseau est anormal ou déconnecté. Lorsque le réseau est normal, le maître continuera à mettre à jour l'esclave en envoyant des commandes. Les mises à jour incluent les écritures du client, l'expiration ou l'expulsion de la clé et d'autres anomalies du réseau. Le maître est déconnecté de l'esclave pendant un certain temps. se reconnecter partiellement après reconnexion au maître Synchroniser, réacquérir les commandes perdues lors de la déconnexion. Lorsqu'une resynchronisation partielle ne peut pas être effectuée, une resynchronisation complète sera effectuée.

2 Pourquoi la réplication maître-esclave est nécessaire

Afin de garantir que les données ne soient pas perdues, la fonction de persistance est parfois utilisée. Mais cela augmentera les opérations d’E/S disque. L'utilisation de la technologie de réplication maître-esclave peut remplacer la persistance et réduire les opérations d'E/S, réduisant ainsi la latence et améliorant les performances.

En mode maître-esclave, le maître est responsable de l'écriture et l'esclave est responsable de la lecture. Bien que la synchronisation maître-esclave puisse entraîner une incohérence des données, elle peut améliorer le débit des opérations de lecture. Le modèle maître-esclave évite le risque de point unique Redis. Améliorez la disponibilité du système grâce à des répliques. Si le nœud maître échoue, le nœud esclave élit un nouveau nœud comme nœud maître pour garantir la disponibilité du système.

3 Configuration et principe de la réplication maître-esclave

La réplication maître-esclave peut être divisée en trois étapes : initialisation, synchronisation et propagation des commandes.

Une fois que le serveur a exécuté la commande slaveof, le serveur esclave établit une connexion socket avec le serveur maître et termine l'initialisation. Si le serveur principal fonctionne normalement, après avoir établi la connexion, il effectuera une détection du rythme cardiaque via la commande ping et renverra une réponse. Lorsqu'un échec se produit et qu'aucune réponse n'est reçue, le nœud esclave réessayera de se connecter au nœud maître. Si le maître définit les informations d'authentification, il vérifiera alors si les données d'authentification sont correctes. Si l'authentification échoue, une erreur sera signalée.

Une fois l'initialisation terminée, lorsque le maître reçoit l'instruction de synchronisation des données de l'esclave, il doit déterminer s'il doit effectuer une synchronisation complète ou partielle en fonction de la situation.

Une fois la synchronisation terminée, le serveur maître et le serveur esclave se confirment mutuellement leur statut en ligne grâce à la détection des battements de cœur pour la transmission des commandes. L'esclave envoie également le décalage de son propre tampon de copie au maître. Sur la base de ces requêtes, le maître déterminera si les commandes nouvellement générées doivent être synchronisées avec l'esclave. L'esclave exécute la commande de synchronisation après l'avoir reçue et se synchronise enfin avec le maître.

4 Utilisez Lettuce pour exécuter des commandes en mode maître-esclave

Jedis, Redission et Lettuce sont des clients Java Redis courants. Lettuce sera utilisé pour démontrer l’exécution de la commande de séparation lecture-écriture en mode maître-esclave.

        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>

Ajouté ci-dessous par

package redis;
import io.lettuce.core.ReadFrom;
import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.codec.Utf8StringCodec;
import io.lettuce.core.masterslave.MasterSlave;
import io.lettuce.core.masterslave.StatefulRedisMasterSlaveConnection;
import org.assertj.core.util.Lists;
 class MainLettuce {
    public static void main(String[] args) {
        List<RedisURI> nodes = Lists.newArrayList(
                RedisURI.create("redis://localhost:7000"),
                RedisURI.create("redis://localhost:7001")
        );
        RedisClient redisClient = RedisClient.create();
        StatefulRedisMasterSlaveConnection<String, String> connection = MasterSlave.connect(
                redisClient,
                new Utf8StringCodec(), nodes);
        connection.setReadFrom(ReadFrom.SLAVE);
        RedisCommands<String, String> redisCommand = connection.sync();
        redisCommand.set("master","master write test2");
        String value = redisCommand.get("master");
        System.out.println(value);
        connection.close();
        redisClient.shutdown();
    }
}

 : Configuration de Lettuce et utilisation du client Redis (basé sur Spring Boot 2.x)

Environnement de développement : utilisation d'Intellij IDEA + Maven + Spring Boot 2.x + JDK 8

Spring Boot À partir de la version 2.0, le client Redis par défaut Jedis sera remplacé par Lettuce. La configuration et l'utilisation de Lettuce sont décrites ci-dessous.

1. Dans le fichier pom.xml du projet, introduisez les dépendances du package Jar pertinentes de Redis sous Spring Boot

    <properties>
        <redisson.version>3.8.2</redisson.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
    </dependencies>

2 Dans le répertoire des ressources du projet, ajoutez les paramètres de configuration de lettuce dans le fichier application.yml.

#Redis配置
spring:
  redis:
    database: 6  #Redis索引0~15，默认为0
    host: 127.0.0.1
    port: 6379
    password:  #密码（默认为空）
    lettuce: # 这里标明使用lettuce配置
      pool:
        max-active: 8   #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms  #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 5     #连接池中的最大空闲连接
        min-idle: 0     #连接池中的最小空闲连接
    timeout: 10000ms    #连接超时时间（毫秒）

3. Ajoutez la classe de lecture du paramètre de configuration Redisson RedisConfig

package com.dbfor.redis.config;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    /**
     * RedisTemplate配置
     * @param connectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());//key序列化
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());//value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

4. Créez la classe de démarrage Spring Boot RedisApplication

package com.dbfor.redis;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RedisApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisApplication.class);
    }
}

5 Écrivez la classe de test RedisTest

package com.dbfor.redis;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.test.context.junit4.SpringRunner;
@SpringBootTest
@RunWith(SpringRunner.class)
@Component
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void set() {
        redisTemplate.opsForValue().set("test:set1", "testValue1");
        redisTemplate.opsForSet().add("test:set2", "asdf");
        redisTemplate.opsForHash().put("hash2", "name1", "lms1");
        redisTemplate.opsForHash().put("hash2", "name2", "lms2");
        redisTemplate.opsForHash().put("hash2", "name3", "lms3");
        System.out.println(redisTemplate.opsForValue().get("test:set"));
        System.out.println(redisTemplate.opsForHash().get("hash2", "name1"));
    }
}

6.

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!