@Bean
@ConditionalOnMissingBean(value = RequestRateLimiterFactory.class)
public RedisRateLimiterFactory redisRateLimiterFactory(ClientResources redisClientResources, RedisProperties redisProperties) {
    RedisURI.Builder builder = RedisURI.builder()
            .withHost(redisProperties.getHost())
            .withPort(redisProperties.getPort());
    if (!StringUtils.isEmpty(redisProperties.getPassword())) {
        builder = builder.withPassword(redisProperties.getPassword());
    }
    if (null != redisProperties.getTimeout()) {
        builder = builder.withTimeout(redisProperties.getTimeout());
    }
    builder = builder.withDatabase(redisProperties.getDatabase())
            .withSsl(redisProperties.isSsl());
    RedisURI redisUri = builder.build();
    return new RedisRateLimiterFactory(RedisClient.create(redisClientResources, redisUri));
}
 

public static RedisTemplate buildRedisTemplate(byte[] redisProperties){
    JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(
            RedisConfUtils.getClusterConfiguration(
                    (RedisProperties) Serializer.INSTANCE.deserialize(redisProperties)));
    RedisTemplate<String, Long> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(jedisConnectionFactory);
    jedisConnectionFactory.afterPropertiesSet();

    GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    redisTemplate.setKeySerializer(stringRedisSerializer);
    redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
    redisTemplate.setHashKeySerializer(stringRedisSerializer);
    redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
}
 

@Bean
@Primary
public RedisProperties dataSourceProperties() {
    RedisProperties properties = new RedisProperties();
    final String serviceId = environment.getProperty(REDIS_SERVICE_ID);
    if (loadBalancerClient != null && serviceId != null) {
        // also, we can choose redis sentinel system, or wait redis cluster (see https://jira.spring.io/browse/DATAREDIS-315)
        final ServiceInstance infos = loadBalancerClient.choose(serviceId);
        if (infos != null) {
            fillFields(infos, properties);
            LOGGER.info("registered redis from cloud {}:{}", infos.getHost(), infos.getPort());
        } else {
            LOGGER.warn("there is no services with id {} in service discovery", serviceId);
        }
    }
    return properties;
}
 

@Bean
@ConditionalOnMissingBean
public RedissonClient getRedisson() {

    Config config = new Config();

    if (redisProperties.getSentinel() != null) {
        RedisProperties.Sentinel sentinel = redisProperties.getSentinel();
        config.useSentinelServers()
                .setDatabase(redisProperties.getDatabase())
                .setMasterName(sentinel.getMaster())
                .addSentinelAddress(formatNodes(sentinel.getNodes()))
                .setPassword(redisProperties.getPassword());
    } else if (redisProperties.getCluster() != null) {
        RedisProperties.Cluster cluster = redisProperties.getCluster();
        config.useClusterServers()
                .addNodeAddress(formatNodes(cluster.getNodes()))
                .setPassword(redisProperties.getPassword());
    } else if (StringUtils.hasText(redisProperties.getUrl())) {
        config.useSingleServer().setAddress(redisProperties.getUrl())
                .setPassword(redisProperties.getPassword());
    } else {
        config.useSingleServer()
                .setAddress(MessageFormat.format("redis://{0}:{1}",
                        redisProperties.getHost(), String.valueOf(redisProperties.getPort())))
                .setPassword(redisProperties.getPassword());
    }
    return Redisson.create(config);
}
 

@Bean
JedisConnectionFactory jedisConnectionFactory()
{
    RedisProperties properties = redisProperties();
    RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
    configuration.setHostName(properties.getHost());
    configuration.setPort(properties.getPort());
    configuration.setPassword(properties.getPassword());
    configuration.setDatabase(properties.getDatabase());
    return new JedisConnectionFactory(configuration);
}
 

public RedisConfig(RedisProperties properties,
                   ObjectProvider<RedisSentinelConfiguration> sentinelConfiguration,
                   ObjectProvider<RedisClusterConfiguration> clusterConfiguration) {
    this.properties = properties;
    this.sentinelConfiguration = sentinelConfiguration.getIfAvailable();
    this.clusterConfiguration = clusterConfiguration.getIfAvailable();
}
 

/**
 * spring boot 2.0后采用Lettuce作为redis调用客户端
 * 默认配置只支持单机模式，如需要其他模式，需要另外定义
 *
 * @return LettuceConnectionFactory
 */
@Bean
@ConditionalOnMissingBean(type = {"org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory"})
public LettuceConnectionFactory redisConnectionFactory(RedisProperties redisProperties) {
    RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration(redisProperties.getHost(),
            redisProperties.getPort());
    configuration.setDatabase(redisProperties.getDatabase());
    configuration.setPassword(RedisPassword.of(redisProperties.getPassword()));
    return new LettuceConnectionFactory(configuration);
}
 

public RedisConfig(RedisProperties properties,
                   ObjectProvider<RedisSentinelConfiguration> sentinelConfiguration,
                   ObjectProvider<RedisClusterConfiguration> clusterConfiguration) {
    this.properties = properties;
    this.sentinelConfiguration = sentinelConfiguration.getIfAvailable();
    this.clusterConfiguration = clusterConfiguration.getIfAvailable();
}
 

/**
 * {@link org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration#getClusterConfiguration}
 * @param redisProperties
 * @return
 */
public static RedisClusterConfiguration  getClusterConfiguration(RedisProperties redisProperties) {
    if (redisProperties.getCluster() == null) {
        return null;
    }
    RedisProperties.Cluster clusterProperties = redisProperties.getCluster();
    RedisClusterConfiguration config = new RedisClusterConfiguration(
            clusterProperties.getNodes());

    if (clusterProperties.getMaxRedirects() != null) {
        config.setMaxRedirects(clusterProperties.getMaxRedirects());
    }
    return config;
}
 

public CommonsAutoConfiguration(CommonsProperties commonsProperties, RedisProperties redisProperties) {
    Assert.notNull(commonsProperties, "CommonsProperties must not be null!");
    Assert.notNull(redisProperties, "RedisProperties must not be null!");

    this.commonsProperties = commonsProperties;
    this.redisProperties = redisProperties;
}
 

public BeihuRedissonConfiguration(RedisProperties redisProperties) {
    this.redisProperties = redisProperties;
}
 

@Bean
@Primary
public RedisProperties redisProperties() {
    return new RedisProperties();
}
 

public Map<String, RedisProperties> getRedis() {
    return redis;
}
 

public void setRedis(Map<String, RedisProperties> redis) {
    this.redis = redis;
}
 

@Bean
ReactiveRedisConnectionFactory reactiveRedisConnectionFactory(RedisProperties redisProperties) {
	RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration(redisProperties.getHost(), redisProperties.getPort());
	redisStandaloneConfiguration.setPassword(redisProperties.getPassword());
	return new LettuceConnectionFactory(redisStandaloneConfiguration);
}
 

@Autowired
public RedisConfiguration(RedisProperties properties) {
    this.properties = properties;
}
 

@Bean
@Primary
public RedisProperties redisProperties() {
    return new RedisProperties();
}
 

private void fillFields(ServiceInstance serviceInstance, RedisProperties properties) {
    properties.setHost(serviceInstance.getHost());
    properties.setPort(serviceInstance.getPort());
}
 

/**
 * Gets multi.
 *
 * @return the multi
 */
public Map<String, RedisProperties> getMulti() {
    return multi;
}
 

/**
 * Sets multi.
 *
 * @param multi the multi
 */
public void setMulti(Map<String, RedisProperties> multi) {
    this.multi = multi;
}