So verwenden Sie den Lettuce-Client in Java, um Befehle im Redis-Master-Slave-Modus auszuführen

1 Das Konzept der Redis-Master-Slave-Replikation

In einer Umgebung mit mehreren Maschinen empfängt ein Redis-Dienst Schreibbefehle und kopiert sie auf einen oder mehrere Redis, wenn sich seine eigenen Daten und sein Status ändern. Dieser Modus wird als Master-Slave-Replikation bezeichnet. Mit dem Befehl „slaveof“ kann ein Redis-Server die Daten und den Status eines anderen Redis-Servers in Redis kopieren. Wir nennen den Hauptserver Master und den Slave-Server Slave.

Die Master-Slave-Replikation stellt sicher, dass Daten repliziert werden, wenn das Netzwerk abnormal ist oder die Verbindung unterbrochen ist. Wenn das Netzwerk normal ist, aktualisiert der Master den Slave weiterhin, indem er Befehle sendet. Die Aktualisierungen umfassen Client-Schreibvorgänge, Schlüsselablauf oder Räumung und andere Netzwerkanomalien. Der Master wird dies für einen bestimmten Zeitraum versuchen Nach dem erneuten Herstellen der Verbindung mit dem Master wird die Verbindung teilweise wiederhergestellt. Befehle, die während der Trennung verloren gegangen sind, werden erneut erfasst. Wenn eine teilweise Neusynchronisierung nicht durchgeführt werden kann, wird eine vollständige Neusynchronisierung durchgeführt.

2 Warum eine Master-Slave-Replikation erforderlich ist

Um sicherzustellen, dass keine Daten verloren gehen, wird manchmal die Persistenzfunktion verwendet. Dies erhöht jedoch die Anzahl der Festplatten-E/A-Vorgänge. Der Einsatz der Master-Slave-Replikationstechnologie kann die Persistenz ersetzen und E/A-Vorgänge reduzieren, wodurch die Latenz verringert und die Leistung verbessert wird.

Im Master-Slave-Modus ist der Master für das Schreiben und der Slave für das Lesen verantwortlich. Obwohl die Master-Slave-Synchronisation zu Dateninkonsistenzen führen kann, kann sie den Durchsatz von Lesevorgängen verbessern. Das Master-Slave-Modell vermeidet das Redis-Einzelpunktrisiko. Verbessern Sie die Systemverfügbarkeit durch Replikate. Wenn der Master-Knoten ausfällt, wählt der Slave-Knoten einen neuen Knoten als Master-Knoten, um die Systemverfügbarkeit sicherzustellen.

3 Konfiguration und Prinzip der Master-Slave-Replikation

Die Master-Slave-Replikation kann in drei Phasen unterteilt werden: Initialisierung, Synchronisierung und Befehlsweitergabe.

Nachdem der Server den Befehl „slaveof“ ausgeführt hat, stellt der Slave-Server eine Socket-Verbindung mit dem Master-Server her und schließt die Initialisierung ab. Wenn der Hauptserver normal ist, führt er nach dem Herstellen der Verbindung eine Heartbeat-Erkennung über den Ping-Befehl durch und gibt eine Antwort zurück. Wenn ein Fehler auftritt und keine Antwort empfangen wird, versucht der Slave-Knoten erneut, eine Verbindung zum Master-Knoten herzustellen. Wenn der Master Authentifizierungsinformationen festlegt, prüft er anschließend, ob die Authentifizierungsdaten korrekt sind. Wenn die Authentifizierung fehlschlägt, wird ein Fehler gemeldet.

Nach Abschluss der Initialisierung muss der Master, wenn er die Datensynchronisationsanweisung vom Slave empfängt, je nach Situation entscheiden, ob eine vollständige oder teilweise Synchronisierung durchgeführt werden soll.

Nachdem die Synchronisierung abgeschlossen ist, bestätigen der Master-Server und der Slave-Server gegenseitig den Online-Status durch Heartbeat-Erkennung für die Befehlsübertragung. Der Slave sendet außerdem den Offset seines eigenen Kopierpuffers an den Master. Anhand dieser Anfragen ermittelt der Master, ob die neu generierten Befehle mit dem Slave synchronisiert werden müssen. Der Slave führt den Synchronisationsbefehl nach Erhalt aus und synchronisiert sich schließlich mit dem Master.

4 Verwenden Sie Lettuce, um Befehle im Master-Slave-Modus auszuführen.

Jedis, Redission und Lettuce sind gängige Java Redis-Clients. Lettuce wird verwendet, um die Ausführung des Lese-/Schreib-Trennungsbefehls im Master-Slave-Modus zu demonstrieren.

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

Das Folgende wird ergänzt durch

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

: Lettuce-Konfigurationsnutzung des Redis-Clients (basierend auf Spring Boot 2.x) #🎜🎜 ## 🎜🎜#Entwicklungsumgebung: Verwenden Sie Intellij IDEA + Maven + Spring Boot 2.x + JDK 8

Spring Boot Ab Version 2.0 wird der standardmäßige Redis-Client Jedis durch Lettuce ersetzt unten beschrieben Konfigurieren mit.

1. Führen Sie in der pom.xml-Datei des Projekts die relevanten Jar-Paketabhängigkeiten von Redis unter 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 ein. Fügen Sie in der Anwendung die Salatkonfigurationsparameter zur .yml-Datei hinzu

#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. Fügen Sie die Redisson-Konfigurationsparameter-Leseklasse 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 hinzu #🎜🎜 #

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 Schreiben Sie die Testklasse 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. Sehen Sie sich die laufenden Ergebnisse auf Redis an.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie den Lettuce-Client in Java, um Befehle im Redis-Master-Slave-Modus auszuführen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!