RedissonClient

package com.sdk.cloud.storge.service.redisservice.config;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.ClusterServersConfig;
import org.redisson.config.Config;
import org.redisson.config.ReadMode;
import org.redisson.config.SingleServerConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

import com.sdk.cloud.storge.service.common.DistributedLocker;
import com.sdk.cloud.storge.service.redisservice.RedissonLockUtil;
import com.sdk.cloud.storge.service.redisservice.RedissonDistributedLocker;
import com.sdk.cloud.storge.service.redisservice.config.RedisModeProperties;

@ConditionalOnClass(Config.class)
@Configuration
@EnableConfigurationProperties(RedisModeProperties.class)
public class RedisCacheConfiguration {

    @Autowired
    RedisModeProperties redisProperties;
    
    @Configuration
    @ConditionalOnClass({Redisson.class})
    @ConditionalOnExpression("'${spring.redis.mode}'=='single' or '${spring.redis.mode}'=='cluster' or '${spring.redis.mode}'=='sentinel'")
    public  class  RedissonSingleClientConfiguration{
        
        @Bean
        @ConditionalOnProperty(name = "spring.redis.mode", havingValue = "single")
        public RedissonClient  redissonSingle(){
            Config config = new Config();
            String address = redisProperties.getSingle().getAddress();
            address = ((address.startsWith("redis://") ) ? address : "redis://"+address);
            SingleServerConfig serverConfig = config.useSingleServer().setAddress(address).setClientName("Single")
            .setConnectionPoolSize(redisProperties.getPool().getSize())
            .setConnectionMinimumIdleSize(redisProperties.getPool().getMinIdle())
            .setConnectTimeout(redisProperties.getPool().getConnTimeout())
            .setDatabase(redisProperties.getDatabase());
            if(StringUtils.isNotBlank(redisProperties.getPassword())) {
                serverConfig.setPassword(redisProperties.getPassword());
            }
            return  Redisson.create(config);
        }
        
        @SuppressWarnings("deprecation")
        @Bean
        @ConditionalOnProperty(name = "spring.redis.mode", havingValue = "sentinel")
        public RedissonClient redissonSentinel() {
            Config config = new  Config();
            String[] nodes = redisProperties.getSentinel().getNodes().split(",");
            List newNodes = new ArrayList<>(nodes.length);
            Arrays.stream(nodes).forEach((index)->newNodes.add(index.startsWith("redis://") ? index : "redis://" + index));
            config.useSentinelServers()
            .addSentinelAddress(newNodes.toArray(new String[0]))
            .setMasterConnectionPoolSize(redisProperties.getPool().getSize())
            .setSlaveConnectionPoolSize(redisProperties.getPool().getSize())
            .setClientName("Sentinel")
            .setReadMode(ReadMode.SLAVE)
            .setMasterName(redisProperties.getSentinel().getMaster())
            .setDatabase(redisProperties.getDatabase())
            .setFailedAttempts(redisProperties.getSentinel().getFailMax())
            .setTimeout(redisProperties.getTimeout());
            
            
            
            return Redisson.create(config);
        }
        @Bean
        @ConditionalOnProperty(name = "spring.redis.mode", havingValue = "cluster")
        public RedissonClient redissonCluster() {
             Config config = new Config();
             String[] nodes = redisProperties.getCluster().getNodes().split(",");
             ArrayList addresses = new ArrayList<>(nodes.length);
             Arrays.stream(nodes).forEach((index)->addresses.add(index.startsWith("redis://") ? index : "redis://" + index));
             ClusterServersConfig clusterServersConfig = config.useClusterServers().addNodeAddress(addresses.toArray(new String[0]))
             .setClientName("Cluster")
             .setConnectTimeout(redisProperties.getTimeout())
             .setRetryInterval(redisProperties.getCluster().getRetryInterval())
             .setIdleConnectionTimeout(redisProperties.getPool().getSoTimeout())
             .setScanInterval(redisProperties.getCluster().getRetryInterval())
             .setMasterConnectionPoolSize(redisProperties.getCluster().getMasterConnectionPoolSize())
             .setSlaveConnectionPoolSize(redisProperties.getCluster().getSlaveConnectionPoolSize())
             .setFailedAttempts(redisProperties.getCluster().getFailedAttempts());
             if(StringUtils.isNotBlank(redisProperties.getPassword())) {
                 clusterServersConfig.setPassword(redisProperties.getPassword()) ;
             }
             return Redisson.create(config);
             
         }
    
    
    }    
    
    

    /**
     * 装配locker类，并将实例注入到RedissLockUtil中
     * @return
     */
    @Bean
    public DistributedLocker distributedLocker(RedissonClient redissonClient) {
        RedissonDistributedLocker locker = new RedissonDistributedLocker();
        locker.setRedissonClient(redissonClient);
        RedissonLockUtil.setLocker(locker);
        return locker;
    }
    
    
    
    
    
    
}