SpringBoot集成redisson(单机,集群,哨兵)-CSDN博客

1.springBoot集成redisson(单机,集群,哨兵) redisson版本使用3.8.2

org.redisson redisson 3.8.2 2.配置文件 application.properties

spring.redis.database=0 spring.redis.password= spring.redis.timeout=3000 #sentinel/cluster/single spring.redis.mode=single #连接池配置 spring.redis.pool.max-idle=16 spring.redis.pool.min-idle=8 spring.redis.pool.max-active=8 spring.redis.pool.max-wait=3000 spring.redis.pool.conn-timeout=3000 spring.redis.pool.so-timeout=3000 spring.redis.pool.size=10 #单机配置 spring.redis.single.address=192.168.60.23:6379 #集群配置 spring.redis.cluster.scan-interval=1000 spring.redis.cluster.nodes= spring.redis.cluster.read-mode=SLAVE spring.redis.cluster.retry-attempts=3 spring.redis.cluster.failed-attempts=3 spring.redis.cluster.slave-connection-pool-size=64 spring.redis.cluster.master-connection-pool-size=64 spring.redis.cluster.retry-interval=1500 #哨兵配置 spring.redis.sentinel.master=business-master spring.redis.sentinel.nodes= spring.redis.sentinel.master-onlyWrite=true spring.redis.sentinel.fail-max=3 3.配置文件读取 RedisProperties

import lombok.Data; import lombok.ToString; import org.springframework.boot.context.properties.ConfigurationProperties;

/**

@author Abbot
@des
@date 2018/10/18 10:42 **/

@ConfigurationProperties(prefix = "spring.redis", ignoreUnknownFields = false) @Data @ToString public class RedisProperties {

private int database;

/**
 * 等待节点回复命令的时间。该时间从命令发送成功时开始计时
 */
private int timeout;

private String password;

private String mode;

/**
 * 池配置
 */
private RedisPoolProperties pool;

/**
 * 单机信息配置
 */
private RedisSingleProperties single;

/**
 * 集群 信息配置
 */
private RedisClusterProperties cluster;

/**
 * 哨兵配置
 */
private RedisSentinelProperties sentinel;
复制代码

} 池配置RedisPoolProperties import lombok.Data; import lombok.ToString;

/**

@author Abbot
@des redis 池配置
@date 2018/10/18 10:43 **/ @Data @ToString public class RedisPoolProperties {

private int maxIdle;

private int minIdle;

private int maxActive;

private int maxWait;

private int connTimeout;

private int soTimeout;

/**
- 池大小 */ private int size;

} RedisSingleProperties

@Data @ToString public class RedisSingleProperties { private String address; } 集群配置RedisClusterProperties @Data @ToString public class RedisClusterProperties {

/**
 * 集群状态扫描间隔时间，单位是毫秒
 */
private int scanInterval;

/**
 * 集群节点
 */
private String nodes;

/**
 * 默认值： SLAVE（只在从服务节点里读取）设置读取操作选择节点的模式。 可用值为： SLAVE - 只在从服务节点里读取。
 * MASTER - 只在主服务节点里读取。 MASTER_SLAVE - 在主从服务节点里都可以读取
 */
private String readMode;
/**
 * （从节点连接池大小） 默认值：64
 */
private int slaveConnectionPoolSize;
/**
 * 主节点连接池大小）默认值：64
 */
private int masterConnectionPoolSize;

/**
 * （命令失败重试次数） 默认值：3
 */
private int retryAttempts;

/**
 *命令重试发送时间间隔，单位：毫秒 默认值：1500
 */
private int retryInterval;

/**
 * 执行失败最大次数默认值：3
 */
private int failedAttempts;
复制代码

} 哨兵配置 RedisSentinelProperties @Data @ToString public class RedisSentinelProperties {

/**
 * 哨兵master 名称
 */
private String master;

/**
 * 哨兵节点
 */
private String nodes;

/**
 * 哨兵配置
 */
private boolean masterOnlyWrite;

/**
 *
 */
private int failMax;
复制代码

} 4.CacheConfiguration

@Configuration @EnableConfigurationProperties(RedisProperties.class) public class CacheConfiguration {

@Autowired
RedisProperties redisProperties;

@Configuration
@ConditionalOnClass({Redisson.class})
@ConditionalOnExpression("'${spring.redis.mode}'=='single' or '${spring.redis.mode}'=='cluster' or '${spring.redis.mode}'=='sentinel'")
protected class RedissonSingleClientConfiguration {

    /**
     * 单机模式 redisson 客户端
     */

    @Bean
    @ConditionalOnProperty(name = "spring.redis.mode", havingValue = "single")
    RedissonClient redissonSingle() {
        Config config = new Config();
        String node = redisProperties.getSingle().getAddress();
        node = node.startsWith("redis://") ? node : "redis://" + node;
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(node)
                .setTimeout(redisProperties.getPool().getConnTimeout())
                .setConnectionPoolSize(redisProperties.getPool().getSize())
                .setConnectionMinimumIdleSize(redisProperties.getPool().getMinIdle());
        if (StringUtils.isNotBlank(redisProperties.getPassword())) {
            serverConfig.setPassword(redisProperties.getPassword());
        }
        return Redisson.create(config);
    }


    /**
     * 集群模式的 redisson 客户端
     *
     * @return
     */
    @Bean
    @ConditionalOnProperty(name = "spring.redis.mode", havingValue = "cluster")
    RedissonClient redissonCluster() {
        System.out.println("cluster redisProperties:" + redisProperties.getCluster());

        Config config = new Config();
        String[] nodes = redisProperties.getCluster().getNodes().split(",");
        List<String> newNodes = new ArrayList(nodes.length);
        Arrays.stream(nodes).forEach((index) -> newNodes.add(
                index.startsWith("redis://") ? index : "redis://" + index));

        ClusterServersConfig serverConfig = config.useClusterServers()
                .addNodeAddress(newNodes.toArray(new String[0]))
                .setScanInterval(
                        redisProperties.getCluster().getScanInterval())
                .setIdleConnectionTimeout(
                        redisProperties.getPool().getSoTimeout())
                .setConnectTimeout(
                        redisProperties.getPool().getConnTimeout())
                .setFailedAttempts(
                        redisProperties.getCluster().getFailedAttempts())
                .setRetryAttempts(
                        redisProperties.getCluster().getRetryAttempts())
                .setRetryInterval(
                        redisProperties.getCluster().getRetryInterval())
                .setMasterConnectionPoolSize(redisProperties.getCluster()
                        .getMasterConnectionPoolSize())
                .setSlaveConnectionPoolSize(redisProperties.getCluster()
                        .getSlaveConnectionPoolSize())
                .setTimeout(redisProperties.getTimeout());
        if (StringUtils.isNotBlank(redisProperties.getPassword())) {
            serverConfig.setPassword(redisProperties.getPassword());
        }
        return Redisson.create(config);
    }

   /**  
     * 哨兵模式 redisson 客户端
     * @return
     */

    @Bean
    @ConditionalOnProperty(name = "spring.redis.mode", havingValue = "sentinel")
    RedissonClient redissonSentinel() {
        System.out.println("sentinel redisProperties:" + redisProperties.getSentinel());
        Config config = new Config();
        String[] nodes = redisProperties.getSentinel().getNodes().split(",");
        List<String> newNodes = new ArrayList(nodes.length);
        Arrays.stream(nodes).forEach((index) -> newNodes.add(
                index.startsWith("redis://") ? index : "redis://" + index));

        SentinelServersConfig serverConfig = config.useSentinelServers()
                .addSentinelAddress(newNodes.toArray(new String[0]))
                .setMasterName(redisProperties.getSentinel().getMaster())
                .setReadMode(ReadMode.SLAVE)
                .setFailedAttempts(redisProperties.getSentinel().getFailMax())
                .setTimeout(redisProperties.getTimeout())
                .setMasterConnectionPoolSize(redisProperties.getPool().getSize())
                .setSlaveConnectionPoolSize(redisProperties.getPool().getSize());

        if (StringUtils.isNotBlank(redisProperties.getPassword())) {
            serverConfig.setPassword(redisProperties.getPassword());
        }

        return Redisson.create(config);
    }
}
复制代码

} 5.使用时候直接注入RedissClient客户端就可以使用如下这样写的目的是为了统一给其它服务提供接口

@Autowired
RedissonClient redisson;

@RequestMapping(value = "lock", method = RequestMethod.POST, consumes = "application/json;charset=UTF-8", produces = "application/json;charset=UTF-8")
public @ResponseBody
ServerResponse<RLock> lock(@RequestBody ServerRequest<LockReqBody> req) {
    return callR(redisson -> {
        RLock lock = redisson.getLock(req.getReqBody().getLockKey());
        lock.lock(req.getReqBody().getTimeout(), req.getReqBody().getUnit());
        return lock;
    });
}
//省略部分代码
private <R> ServerResponse callR(Function<RedissonClient, R> function) {
    ServerResponse dv = RespHelper.serverResponse(RespCodeService.ERROR, "");
    try {
        long startTime = System.currentTimeMillis();
        dv = RespHelper.serverResponse(RespCodeService.SUCCESS, function.apply(redisson));
        logger.info("CALLR METHOD USE TIME:{}", System.currentTimeMillis() - startTime);
    } catch (Throwable e) {          
        System.out.println("callR error");
    }
    return dv;
}
复制代码

欢迎工作一到五年的Java工程师朋友们加入Java架构开发： 855835163 群内提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）合理利用自己每一分每一秒的时间来学习提升自己，不要再用"没有时间“来掩饰自己思想上的懒惰！趁年轻，使劲拼，给未来的自己一个交代！