Springbootアクセスcachecloud redis実践

11694 ワード
最近のプロジェクトではRedis CacheCloudにアクセスする必要があり、CacheCloudはオープンソースのRedis運営・メンテナンス監視クラウドプラットフォームであり、機能は非常に強く、Redisインスタンスの自動配置、拡張、破片管理、統計、監視などの機能をサポートし、特に単機、sentinel、clusterの3つのモードの自動配置をサポートし、redisクラスタの構築は一歩で簡単に行うことができる.
JAvaプロジェクトでCacheCloud redisにアクセスする方法は主に2つあります.
1つ目はCacheCloudでredisインスタンスを作成した後に対応するIP、ポートを直接配置して配置形式でプロジェクトに適用することであり、汎用性がよく、既存のプロジェクトの改造コストが低いという利点があるが、万が一後期のCacheCloudでredisを管理拡張すれば、手動で各プロジェクトのredis配置を変更することができるだけである.
第2のCacheCloudでインスタンスを作成した後、対応するappIdがあり、プログラムはCacheCloudプラットフォームのrestインタフェースを呼び出してappIdを通じてredis関連構成を取得し、プログラム中のredis構成をCacheCloudプラットフォームに統一して管理・維持し、後期管理と拡張は便利であるが、プログラム改造コストは比較的高い.
現在、第2の方法でアクセスし、プロジェクトはspringbootを採用し、redisは哨兵モードを採用し、redisクライアントは主にspring-data-redisとredissonを使用し、アクセスの流れは以下の通りである.
pomに構成を追加する.xmlファイル
    
       
            com.sohu.tv
            cachecloud-open-client-redis
            1.0-SNAPSHOT
        

        
            com.sohu.tv
            cachecloud-open-client-basic
            1.0-SNAPSHOT
        

        
            com.sohu.tv
            cachecloud-open-common
            1.0-SNAPSHOT
        
   
   
         
            org.springframework.boot
            spring-boot-starter-data-redis
            
                
                    jedis
                    redis.clients
                
            
        
        
            org.redisson
            redisson
            3.9.0

プロファイルの準備properties,プロジェクト開始時VMパラメータ追加-Dcachecloud.config=プロファイルパス
http_conn_timeout = 3000
http_socket_timeout = 5000
client_version = 1.0-SNAPSHOT
domain_url = http://192.168.33.221:8585   #cachecloud    
redis_cluster_suffix = /cache/client/redis/cluster/%s.json?clientVersion=
redis_sentinel_suffix = /cache/client/redis/sentinel/%s.json?clientVersion=
redis_standalone_suffix = /cache/client/redis/standalone/%s.json?clientVersion=
cachecloud_report_url = /cachecloud/client/reportData.json

基本的な考え方は,まずcachecloudのrestapiインタフェースを介してredisノードの構成情報を取得し解析し,その後,従来のredisへのアクセス方式で初期化し,RedisTemplateオブジェクトを取得することである.
JAvaコードは次のとおりです.
import com.alibaba.fastjson.JSONObject;
import com.sohu.tv.cachecloud.client.basic.heartbeat.ClientStatusEnum;
import com.sohu.tv.cachecloud.client.basic.util.ConstUtils;
import com.sohu.tv.cachecloud.client.basic.util.HttpUtils;
import com.sohu.tv.cachecloud.client.jedis.stat.ClientDataCollectReportExecutor;
import lombok.Getter;
import lombok.Setter;
import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Component
public class RedisProperties {

    public static Logger logger = LoggerFactory.getLogger(RedisProperties.class);

    /**
     *    
     */
    private static final Lock LOCK = new ReentrantLock();

    @Value("${cacheCloud.appId}")  //cahcecloud   redis     id
    private Integer appId;

    @Getter
    @Setter
    private String masterName;

    @Getter
    @Setter
    private Set> sentinelSet = new HashSet<>();

    private Boolean clientStatIsOpen=true;

    @Getter
    @Setter
    private String password;

    private Boolean getConfigSuccess = false;

    @PostConstruct
    public void init() {

        while (true) {
            try {
                LOCK.tryLock(10, TimeUnit.MILLISECONDS);
                if (!getConfigSuccess) {
                    /**
                     * http          ；
                     */
                    String response = HttpUtils.doGet(String.format(ConstUtils.REDIS_SENTINEL_URL, appId));
                    if (response == null || response.isEmpty()) {
                        logger.warn("get response from remote server error, appId: {}, continue...", appId);
                        continue;
                    }

                    /**
                     * http           ；
                     */
                    JSONObject jsonObject = null;
                    try {
                        jsonObject = JSONObject.parseObject(response);
                    } catch (Exception e) {
                        logger.error("heartbeat error, appId: {}. continue...", appId, e);
                    }
                    if (jsonObject == null) {
                        logger.error("get sentinel info for appId: {} error. continue...", appId);
                        continue;
                    }
                    int status = jsonObject.getIntValue("status");
                    String message = jsonObject.getString("message");

                    /**         **/
                    if (status == ClientStatusEnum.ERROR.getStatus()) {
                        throw new IllegalStateException(message);
                    } else if (status == ClientStatusEnum.WARN.getStatus()) {
                        logger.warn(message);
                    } else {
                        logger.info(message);
                    }

                    /**
                     *      ：  masterName sentinels；
                     */
                    masterName = jsonObject.getString("masterName");
                    String sentinels = jsonObject.getString("sentinels");
                    for (String sentinelStr : sentinels.split(" ")) {
                        String[] sentinelArr = sentinelStr.split(":");
                        if (sentinelArr.length == 2) {
                            sentinelSet.add(Pair.of(sentinelArr[0], sentinelArr[1]));
                        }
                    }

                    //      
                    if (clientStatIsOpen) {
                        ClientDataCollectReportExecutor.getInstance();
                    }
                    password = jsonObject.getString("password");
                    getConfigSuccess = true;
                    return;
                }
            } catch (Throwable e) {//  
                logger.error("error in build, appId: {}", appId, e);
            } finally {
                LOCK.unlock();
            }
            try {
                TimeUnit.MILLISECONDS.sleep(200 + new Random().nextInt(1000));//  
            } catch (InterruptedException e) {
                logger.error(e.getMessage(), e);
            }
        }
    }
}
import com.shunwang.buss.dispatchPay.provider.config.PropertiesUtil;
import org.apache.commons.lang3.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.ReadMode;
import org.redisson.config.SentinelServersConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.net.UnknownHostException;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toList;


@Configuration
public class RedisConfig {

    /**
     * JedisPoolConfig    
     */
    @Bean
    public JedisPoolConfig jedisPoolConfig(RedisProperties properties) {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //      
        jedisPoolConfig.setMaxIdle(20);
        //             
        jedisPoolConfig.setMaxTotal(20);
        //           
        jedisPoolConfig.setMaxWaitMillis(3000);
        return jedisPoolConfig;
    }

    /**
     *   redis   
     */
    @Bean
    public RedisSentinelConfiguration sentinelConfiguration(RedisProperties properties) {
        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
        //   redis   sentinel
        Set redisNodeSet = properties.getSentinelSet().stream()
                .map(pair -> new RedisNode(pair.getLeft(), Integer.parseInt(pair.getRight())))
                .collect(Collectors.toSet());
        redisSentinelConfiguration.setSentinels(redisNodeSet);
        redisSentinelConfiguration.setMaster(properties.getMasterName());
        return redisSentinelConfiguration;
    }

    /**
     *     
     */
    @Bean
    public RedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig, RedisSentinelConfiguration sentinelConfig) {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfig, jedisPoolConfig);
        return jedisConnectionFactory;
    }


    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        //    （value）      FastJsonRedisSerializer。
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);
        //    （key）      StringRedisSerializer。
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    /**
     * Redisson   
     */
    @Bean
    public RedissonClient redissonClient(RedisProperties properties) {
        Config config = new Config();
        List newNodes = properties.getSentinelSet().stream()
                .map(pa -> "redis://" + pa.getLeft() + ":" + pa.getRight()).collect(toList());
        SentinelServersConfig serverConfig = config.useSentinelServers()
                .addSentinelAddress(newNodes.toArray(new String[newNodes.size()]))
                .setMasterName(properties.getMasterName())
                .setReadMode(ReadMode.SLAVE);

        if (StringUtils.isNotBlank(properties.getPassword())){
            serverConfig.setPassword(properties.getPassword());
        }
        return Redisson.create(config);
    }
}

ここまでSpringでRedisTemplateとRedissonClientオブジェクトを生成しましたが、基本的なデータ構造操作も分散ロックも簡単にサポートされており、具体的な使用は展開されません.
初めてのブログですが、不行き届きな点はお許しください.
いちばん高い塔を建てる
Android java project to kotlin