Java使用Lettuce客户端在Redis在主从复制模式下命令执行的操作

<dependency>

     <groupId>io.lettuce</groupId>

     <artifactId>lettuce-core</artifactId>

     <version> 5.1 . 8 .RELEASE</version>

</dependency>

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

     }

}

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测试数据mons</ groupId >

         < artifactId >commons-pool2</ artifactId >

     </ dependency >

</ dependencies >

#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    #连接超时时间（毫秒）

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;

     }

}

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

     }

}

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( "hash1" , "name1" , "lms1" );

         redisTemplate.opsForHash().put( "hash1" , "name2" , "lms2" );

         redisTemplate.opsForHash().put( "hash1" , "name3" , "lms3" );

         System.out.println(redisTemplate.opsForValue().get( "test:set" ));

         System.out.println(redisTemplate.opsForHash().get( "hash1" , "name1" ));

     }

}