Shulou(Shulou.com)06/01 Report--

This article mainly introduces "Java how to use Lettuce client to execute commands in Redis master-slave mode". In daily operation, I believe many people have doubts about how to use Lettuce client to execute commands in Redis master-slave mode. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts of "how Java uses Lettuce client to execute commands in Redis master-slave mode". Next, please follow the editor to study!

1 the concept of redis master-slave replication

In a multi-machine environment, a redis service receives write commands and copies its own data and state to one or more redis when it changes. This mode is called master-slave replication. In redis, use the command salveof command to have the redis executing the command copy another redis data and state. We call the master server master and the slave server slave.

Master-slave replication ensures that when the network is abnormal and the network is disconnected, the data will be replicated. When the network is normal, master will update the slave by sending commands, including the write of the client, the expiration or eviction of key and other network exceptions. The connection between master and slave is disconnected for a period of time. After slave is reconnected to master, it will try to resynchronize partially and retrieve the commands lost during the disconnection. When a partial resynchronization cannot be performed, a full resynchronization is performed.

2 Why do you need master-slave replication

Persistence is sometimes used to ensure that data is not lost. However, this increases disk IO operations. By using master-slave replication, you can replace persistence and reduce IO operations, reduce latency and improve performance.

In master-slave mode, master is responsible for writing and slave for reading. Although master-slave synchronization can result in inconsistent windows in the data, it can increase the throughput of read operations. The master-slave mode avoids a single point of risk in redis. Improve system availability through replicas. When master hangs up, select a new machine from slave as the master to ensure that the system is available.

3 configuration and principle of master-slave replication

Master-slave replication can be divided into three stages: initialization, synchronization and command propagation.

Initialization: after executing the slaveof command from the server, slave establishes a socket connection with master. After the connection is established, the heartbeat is detected by ping. If the master is normal, a response is returned. If there is a failure and no response is received, slave will retry to connect to the master. If master sets authentication information, it will check again whether the authentication data is correct. If the authentication fails, an error will be reported.

Synchronization: after initialization, master needs to determine whether to perform full synchronization or partial synchronization after receiving the data synchronization command from slave.

Command propagation: after synchronization is completed, master and slave determine whether each other is online by heartbeat detection. Slave also sends the offset of its own copy buffer to master. Based on these requests, the master determines whether to synchronize the newly generated commands to the slave. When slave receives the synchronization command, it executes, and finally keeps synchronization with master.

4 use Lettuce to execute commands in master-slave mode

Commonly used Java Redis clients are Jedis, Redission, and Lettuce. Here we will use Lettuce to demonstrate the execution of read-write separation commands in master-slave mode.

Io.lettuce lettuce-core 5.1.8.RELEASE

Through the following

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 nodes = Lists.newArrayList (RedisURI.create ("redis://localhost:7000"), RedisURI.create ("redis://localhost:7001")); RedisClient redisClient = RedisClient.create (); StatefulRedisMasterSlaveConnection connection = MasterSlave.connect (redisClient, new Utf8StringCodec (), nodes) Connection.setReadFrom (ReadFrom.SLAVE); RedisCommands redisCommand = connection.sync (); redisCommand.set ("master", "master write test2"); String value = redisCommand.get ("master"); System.out.println (value); connection.close (); redisClient.shutdown ();}}

Supplement: Lettuce configuration of Redis client (based on Spring Boot 2.x)

Development environment: using Intellij IDEA + Maven + Spring Boot 2.x + JDK 8

Starting with version 2. 0, Spring Boot replaces the default Redis client Jedis with Lettuce. The configuration of Lettuce is described below.

1. Under the pom.xml file of the project Introduce the related Jar package dependency of Redis under Spring Boot 3.8.2 org.springframework.boot spring-boot-starter org.springframework.boot spring-boot-starter-test test org.springframework.boot spring-boot-starter-data- Redis org.apache.commons commons-pool2 2. Under the resources directory of the project, add the configuration parameter of lettuce in the application.yml file # Redis configuration spring: redis: database: 6 # Redis index 0room15 The default is 0 host: 127.0.0.1 port: 6379 password: # password (empty by default) lettuce: # here indicates the use of lettuce to configure pool: max-active: 8 # connection pool maximum number of connections (use negative values for no limit) max-wait:-1ms # maximum blocking wait time for connection pool (use negative values for no limit) Max-idle: maximum idle connection in 5 # connection pool min-idle: 0 # minimum idle connection in connection pool timeout: 10000ms # connection timeout (milliseconds) 3. Add the configuration parameter reading class RedisConfigpackage 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 of Redisson @ Configuration@EnableCachingpublic class RedisConfig extends CachingConfigurerSupport {/ * RedisTemplate configuration * @ param connectionFactory * @ return * / @ Bean public RedisTemplate redisTemplate (LettuceConnectionFactory connectionFactory) {/ / configure redisTemplate RedisTemplate redisTemplate = new RedisTemplate (); redisTemplate.setConnectionFactory (connectionFactory); redisTemplate.setKeySerializer (new StringRedisSerializer ()); / / key serialization redisTemplate.setValueSerializer (new GenericJackson2JsonRedisSerializer ()) / / value serializes redisTemplate.afterPropertiesSet (); return redisTemplate;}} 4. Build the startup class RedisApplicationpackage com.dbfor.redis;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class RedisApplication {public static void main (String [] args) {SpringApplication.run (RedisApplication.class);}} 5 of SpringBoot. Write the test class RedisTestpackage 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) @ Componentpublic 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. At this point, the study on "how Java uses the Lettuce client to execute commands in Redis master-slave mode" is over. I hope to be able to solve everyone's doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.