Cara Java menggunakan klien Lettuce untuk melaksanakan arahan dalam mod tuan-hamba Redis

1 Konsep replikasi tuan-hamba redis

Dalam persekitaran berbilang mesin, perkhidmatan redis menerima arahan tulis dan menyalinnya ke satu atau lebih redis apabila data dan statusnya sendiri berubah. Mod ini dipanggil replikasi tuan-hamba. Melalui perintah slaveof, satu pelayan Redis boleh menyalin data dan status pelayan Redis lain dalam Redis. Kami memanggil tuan pelayan utama dan hamba pelayan hamba.

Replikasi tuan-hamba memastikan data akan direplikasi apabila rangkaian tidak normal atau terputus sambungan. Apabila rangkaian adalah normal, tuan akan terus mengemas kini hamba dengan menghantar arahan Kemas kini termasuk penulisan klien, tamat tempoh atau pengusiran kunci dan keabnormalan rangkaian yang lain sambung semula sebahagian selepas menyambung semula ke induk Segerakkan, dapatkan semula arahan yang hilang semasa pemotongan. Apabila penyegerakan semula separa tidak dapat dilakukan, penyegerakan semula penuh akan dilakukan.

2 Mengapa replikasi tuan-hamba diperlukan

Untuk memastikan data tidak hilang, fungsi kegigihan kadangkala digunakan. Tetapi ini akan meningkatkan operasi IO cakera. Menggunakan teknologi replikasi tuan-hamba boleh menggantikan kegigihan dan mengurangkan operasi IO, dengan itu mengurangkan kependaman dan meningkatkan prestasi.

Dalam mod tuan-hamba, tuan bertanggungjawab untuk menulis dan hamba bertanggungjawab untuk membaca. Walaupun penyegerakan tuan-hamba boleh menyebabkan ketidakkonsistenan data, ia boleh meningkatkan daya pemprosesan operasi baca. Model tuan-hamba mengelakkan risiko mata tunggal redis. Meningkatkan ketersediaan sistem melalui replika. Jika nod induk gagal, nod hamba memilih nod baharu sebagai nod induk untuk memastikan ketersediaan sistem.

3 Konfigurasi dan prinsip replikasi tuan-hamba

Replikasi tuan-hamba boleh dibahagikan kepada tiga peringkat: pemulaan, penyegerakan dan perambatan arahan.

Selepas pelayan melaksanakan perintah slaveof, pelayan slave mewujudkan sambungan soket dengan pelayan induk dan melengkapkan permulaan. Jika pelayan utama adalah normal, selepas membuat sambungan, ia akan melakukan pengesanan degupan jantung melalui arahan ping dan mengembalikan respons. Apabila kegagalan berlaku dan tiada respons diterima, nod hamba akan cuba semula untuk menyambung ke nod induk. Jika induk menetapkan maklumat pengesahan, ia kemudian akan menyemak sama ada data pengesahan adalah betul. Jika pengesahan gagal, ralat akan dilaporkan.

Selepas permulaan selesai, apabila induk menerima arahan penyegerakan data daripada hamba, ia perlu menentukan sama ada untuk melakukan penyegerakan penuh atau penyegerakan separa mengikut situasi.

Selepas penyegerakan selesai, pelayan induk dan pelayan hamba mengesahkan status dalam talian masing-masing melalui pengesanan degupan jantung untuk penghantaran arahan. Hamba juga menghantar offset penimbal salinannya sendiri kepada tuan. Berdasarkan permintaan ini, tuan akan menentukan sama ada arahan yang baru dijana perlu disegerakkan kepada hamba. Hamba melaksanakan arahan penyegerakan selepas menerimanya, dan akhirnya menyegerakkan dengan induk.

4 Gunakan Lettuce untuk melaksanakan arahan dalam mod master-slave

Jedis, Redission dan Lettuce ialah pelanggan Java Redis biasa. Lettuce akan digunakan untuk menunjukkan pelaksanaan perintah pemisahan baca-tulis dalam mod tuan-hamba.

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

Yang berikut ditambah dengan

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

: Penggunaan konfigurasi salad klien Redis (berdasarkan Spring Boot 2.x)

Persekitaran pembangunan: menggunakan Intellij IDEA + Maven + Spring Boot 2.x + JDK 8

Spring Boot Bermula dari versi 2.0, klien Redis lalai Jedis akan digantikan dengan Lettuce Konfigurasi dan penggunaan Lettuce diterangkan di bawah.

1. Dalam fail pom.xml projek, perkenalkan kebergantungan pakej Jar Redis di bawah 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 Dalam direktori sumber projek, dalam aplikasi. fail yml Tambah parameter konfigurasi selada

#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 Tambah kelas bacaan parameter konfigurasi 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 Bina kelas permulaan Boot Spring 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

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. Lihat hasil yang sedang dijalankan pada Redis

Atas ialah kandungan terperinci Cara Java menggunakan klien Lettuce untuk melaksanakan arahan dalam mod tuan-hamba Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!