Spring Cloud TSF Finchley使用redis分布式锁(解决腾讯封装问题)

最新推荐文章于 2023-10-13 15:57:43 发布
最新推荐文章于 2023-10-13 15:57:43 发布
阅读量1.1k 收藏 2
点赞数 2
文章标签： 腾讯 tsf redis java jedis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40707961/article/details/106219313
版权

redis分布式锁


import java.util.UUID;

@Slf4j
@Component
public class RedisLockUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 获得锁
     *
     * @param lockName    锁的名词
     * @param lockTimeout 锁本身的过期时间
     * @return
     */
    public String acquireLock(String lockName, long lockTimeout) {
        String identifier = UUID.randomUUID().toString();//保证释放锁的时候是同一个持有锁的人
        String lockKey = "lock:" + lockName;
        int lockExpire = (int) (lockTimeout / 1000);
        return (String) redisTemplate.execute((RedisCallback<String>) redisConnection -> {
            Object nativeConnection = redisConnection.getNativeConnection();
            if (nativeConnection instanceof JedisCluster) {
                JedisCluster jedisCluster = (JedisCluster) nativeConnection;
                //获取锁的限定时间
                if (jedisCluster.setnx(lockKey, identifier) == 1) { //设置值成功
                    jedisCluster.expire(lockKey, lockExpire); //设置超时时间
                    return identifier; //获得锁成功
                }
                if (jedisCluster.ttl(lockKey) == -1) {
                    jedisCluster.expire(lockKey, lockExpire); //设置超时时间
                }
            }
            // 单机模式
            else if (nativeConnection instanceof Jedis) {
                Jedis jedis = (Jedis) nativeConnection;
                //获取锁的限定时间
                if (jedis.setnx(lockKey, identifier) == 1) { //设置值成功
                    jedis.expire(lockKey, lockExpire); //设置超时时间
                    return identifier; //获得锁成功
                }
                if (jedis.ttl(lockKey) == -1) {
                    jedis.expire(lockKey, lockExpire); //设置超时时间
                }
            }
            return null;
        });
    }

    /**
     * 释放锁
     *
     * @param lockName
     * @param identifier
     * @return
     */
    public boolean releaseLockWithLua(String lockName, String identifier) {
        log.info(lockName + "开始释放锁：" + identifier);
        return (Boolean) redisTemplate.execute((RedisCallback<Boolean>) redisConnection -> {
            Long rs = 0l;
            String lockKey = "lock:" + lockName;
            String lua = "if redis.call(\"get\",KEYS[1])==ARGV[1] then " + "return redis.call(\"del\",KEYS[1]) " + "else return 0 end";
            Object nativeConnection = redisConnection.getNativeConnection();
            // 集群模式
            if (nativeConnection instanceof JedisCluster) {
                JedisCluster jedisCluster = (JedisCluster) nativeConnection;
                rs = (Long) jedisCluster.eval(lua, 1, new String[]{lockKey, identifier});
            }
            // 单机模式
            else if (nativeConnection instanceof Jedis) {
                Jedis jedis = (Jedis) nativeConnection;
                rs = (Long) jedis.eval(lua, 1, new String[]{lockKey, identifier});
            }
            if (rs.intValue() > 0) {
                return true;
            }
            return false;
        });
    }
}
com.tencent.tsf spring-cloud-tsf-dependencies 1.14.1-Finchley-RELEASE 
<properties>
    <commons.lang3.version>3.4</commons.lang3.version>
    <targetJavaProject>${basedir}/src/main/java</targetJavaProject>
    <!-- XML生成路径 -->
    <targetResourcesProject>${basedir}/src/main/resources</targetResourcesProject>
    <targetXMLPackage>mapper</targetXMLPackage>
    <!-- 依赖版本 -->
    <mapper.version>3.4.0</mapper.version>
    <mybatis.version>3.3.1</mybatis.version>
    <mybatis.spring.version>1.2.4</mybatis.spring.version>
    <pagehelper.version>4.1.1</pagehelper.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <dependency>
        <groupId>com.tencent.tsf</groupId>
        <artifactId>spring-cloud-tsf-consul-config</artifactId>
    </dependency>
    <dependency>
        <groupId>com.tencent.tsf</groupId>
        <artifactId>spring-cloud-tsf-consul-discovery</artifactId>
    </dependency>
    <!--        <dependency>
                <groupId>com.tencent.tsf</groupId>
                <artifactId>spring-cloud-tsf-auth</artifactId>
            </dependency>-->
    <!-- TSF Rate Limit 限流 -->
    <dependency>
        <groupId>com.tencent.tsf</groupId>
        <artifactId>spring-cloud-tsf-ratelimit</artifactId>
    </dependency>
    <!-- TSF Ribbon 客户端路由 -->
    <dependency>
        <groupId>com.tencent.tsf</groupId>
        <artifactId>spring-cloud-tsf-route</artifactId>
    </dependency>
    <!-- TSF Logger 日志 -->
    <dependency>
        <groupId>com.tencent.tsf</groupId>
        <artifactId>spring-cloud-tsf-logger</artifactId>
    </dependency>
    <!-- TSF swagger -->
    <dependency>
        <groupId>com.tencent.tsf</groupId>
        <artifactId>spring-cloud-tsf-swagger</artifactId>
    </dependency>
    <dependency>
        <groupId>com.tencent.tsf</groupId>
        <artifactId>spring-cloud-tsf-sleuth</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!--<dependency>-->
    <!--<groupId>org.springframework.boot</groupId>-->
    <!--<artifactId>spring-boot-starter-data-mongodb</artifactId>-->
    <!--</dependency>-->
    <!-- 使用分布式配置自动刷新功能，需要显示添加actuator的依赖包-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>

    <!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.10.3</version>
    </dependency>

    <!-- druid -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.9</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.9</version>
    </dependency>
    <!--用于测试的，本例可省略-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.33</version>
    </dependency>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>20.0</version>
    </dependency>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava-base</artifactId>
        <version>r03</version>
    </dependency>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava-collections</artifactId>
        <version>r03</version>
    </dependency>
    <!-- jwt -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <!-- Apache Commons upload -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-collections4</artifactId>
        <version>4.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>${commons.lang3.version}</version>
    </dependency>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.6</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.25</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.25</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatisplus-spring-boot-starter</artifactId>
        <version>1.0.5</version>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus</artifactId>
        <version>2.3</version>
    </dependency>

    <!-- 模板引擎 给mybatisplus自动生成用的-->
    <dependency>
        <groupId>org.apache.velocity</groupId>
        <artifactId>velocity-engine-core</artifactId>
        <version>2.0</version>
    </dependency>
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.4</version>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.3</version>
    </dependency>
    <!--导出文件-->
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.17</version>
    </dependency>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>3.17</version>
    </dependency>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.4</version>
    </dependency>
    <!--ui-->
    <dependency>
        <groupId>com.github.xiaoymin</groupId>
        <artifactId>knife4j-micro-spring-boot-starter</artifactId>
        <version>2.0.0</version>
    </dependency>
    <dependency>
        <groupId>com.github.xiaoymin</groupId>
        <artifactId>knife4j-spring-ui</artifactId>
        <version>2.0.0</version>
    </dependency>
    <dependency>
        <groupId>org.jsoup</groupId>
        <artifactId>jsoup</artifactId>
        <version>1.11.3</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>

这里用的 腾讯云的 1.14.1-Finchley-RELEASE的版本

redis的配置

 @Bean
    CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        System.out.println(connectionFactory.getClass());
        //初始化一个RedisCacheWriter
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);
        //设置CacheManager的值序列化方式为JdkSerializationRedisSerializer,但其实RedisCacheConfiguration默认就是使用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value,所以以下注释代码为默认实现
        //ClassLoader loader = this.getClass().getClassLoader();
        //JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer(loader);
        //RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);
        //RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
        //设置默认超过期时间是30秒
        defaultCacheConfig.entryTtl(Duration.ofSeconds(30));
        //初始化RedisCacheManager
        RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
        return cacheManager;
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
        System.out.println(factory.getClass());
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(serializer);
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }

这样写其实有问题的

1.问题是腾讯云默认会封装 redis的RedisConnectionFactory
扒腾讯的源码发现这离使用注解,替换原来默认的 org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
扒腾讯的源码发现这离使用注解,替换原来默认的LettuceConnectionFactory
这里getclass发现就是腾讯的封装类AsyncTracingRedisCommands而不是jedis]
这里getclass发现就是腾讯的封装类AsyncTracingRedisCommands而不是jedis
com.tencent.tsf.sleuth.instrument.redis.lettuceStandalone.AsyncTracingRedisCommands

解决办法 自己定义RedisConnectionFactory


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import com.tencent.tsf.sleuth.instrument.redis.lettuceStandalone.AsyncTracingRedisCommands;

import java.time.Duration;

@Configuration
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String redisHost;
    @Value("${spring.redis.port}")
    private int redisPort;
    @Value("${spring.redis.pool.timeout}")
    private int redisTimeout;
    @Value("${spring.redis.password}")
    private String redisAuth;
    @Value("${spring.redis.database}")
    private int redisDb;
    @Value("${spring.redis.pool.max-active}")
    private int maxActive;
    @Value("${spring.redis.pool.max-wait}")
    private int maxWait;
    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;
    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMaxWaitMillis(maxWait);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(false);
        poolConfig.setTestWhileIdle(true);
        JedisClientConfiguration clientConfig = JedisClientConfiguration.builder().usePooling().poolConfig(poolConfig).and().readTimeout(Duration.ofMillis(redisTimeout)).build();
        // 单点redis
        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
        // 哨兵redis
        // RedisSentinelConfiguration redisConfig = new RedisSentinelConfiguration();
        // 集群redis
        // RedisClusterConfiguration redisConfig = new RedisClusterConfiguration();
        redisConfig.setHostName(redisHost);
        redisConfig.setPassword(RedisPassword.of(redisAuth));
        redisConfig.setPort(redisPort);
        redisConfig.setDatabase(redisDb);

        return new JedisConnectionFactory(redisConfig, clientConfig);
    }

    @Bean
    CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        System.out.println(connectionFactory.getClass());
        //初始化一个RedisCacheWriter
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);
        //设置CacheManager的值序列化方式为JdkSerializationRedisSerializer,但其实RedisCacheConfiguration默认就是使用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value,所以以下注释代码为默认实现
        //ClassLoader loader = this.getClass().getClassLoader();
        //JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer(loader);
        //RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);
        //RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
        //设置默认超过期时间是30秒
        defaultCacheConfig.entryTtl(Duration.ofSeconds(30));
        //初始化RedisCacheManager
        RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
        return cacheManager;
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
        System.out.println(factory.getClass());
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(serializer);
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}
小黑爱自由
关注
SpringCloudGateway企业微服务网关实践
AI天才研究院
07-30 1739
Spring Cloud 是 Spring Boot 的微服务框架。它致力于促进开发人员简单、快速地构建分布式系统，并以一系列组件组成服务网络，包括配置管理、服务发现、熔断容错、监控等，这些组件都可以用 Java 或其他语言编写。其中，Spring Cloud Gateway（以下简称 SCG）是一个基于 Spring Framework 实现的 API 网关。
用阿里云K8S搭建SpringCloud（服务发现:Consul）微服务--问题小结
马猴烧酒└(┐卍^o^)卍ﾄﾞｩﾙﾙﾙ~楪詩月「YUZURIHA SHIZUKI」
02-09 3191
导言 公司原有的微服务是基于Eureka做微服务microservice间的服务发现，以及通过阿里云的Loadbalance设施实现gateway层的负载，以及通过流量权重切换实现分批发布。 原来的方式保证了一定程度的微服务化，把很多重要服务的领域边界都可以划分清楚，几乎很少的服务间请求，所有的数据都在gateway层通过rxJava进行并行io请求和数据组装。保证了业务的灵活性和扩展性。 随着公司业务发展，今年开始有一块跟原来业务区别较大的新产品规划。如果再按eureka去搭一套的话，机器资源是相对浪费的
Spring Cloud Finchley.RELEASE 中文 参考手册 中文文档
06-25
Spring Cloud Finchley.RELEASE 中文 参考手册 中文文档 中文文档都是由软件翻译,翻译内容未检查校对,文档内容仅供参考。
Spring Cloud整合Redis
Write Less,Think More
09-27 1005
项目需要使用Redis来做缓存，研究了一下如何将其与Spring Boot整合。网上的demo要么就是太过于庞大，要么就是版本过于陈旧，配置时候会有各种坑。因此自己在踩过了各种坑之后，写一个小demo来记录下： 1.项目结构： 2.pom的依赖配置： 本人使用的Spring Boot是2.0.4.RELEASE版本的： &lt;parent&gt; &lt;g...
微服务架构 springcloud改为tsf oracle视图改为tbsql（MySQL）
阶前空雨
04-14 1165
springcloud改tsf pom.xml 将原来springcloud相关依赖删除（包括spring-boot-starter-web） 引入tsf相关依赖 <!--腾讯云--> <parent> <groupId>com.tencent.tsf</groupId> <artifactId>spring-cloud-...
Spring 集成腾讯TSF SDK 指导说明
biyulonglan的专栏
08-10 1186
Spring clound 集成腾讯云TSF 调配改造示例和指导
分布式锁的解决方式
架构师的成长之路的博客
01-10 641
转载： Spring-data-redis + redis 分布式锁（二） - 简书 分布式锁的解决方式 基于数据库表做乐观锁，用于分布式锁。(适用于小并发) 使用memcached的add()方法，用于分布式锁。 使用memcached的cas()方法，用于分布式锁。(不常用) 使用redis的setnx()、expire()方法，用于分布式锁。 使用redis的setnx()、get()、getset()方法，用于分布式锁。 使用redis的watch、multi、exec命令，用于分
SpringCloud升级到Finchley的一些坑
芸灵fly的博客
09-11 3656
说明 最近开始使用SpringCloud的Finchley版本，从中踩了一些坑，这里记录一下SpringCloud组件在高版本下的一些变化 快速开始 引入spring-cloud Finchley.SR1 &lt;properties&gt; &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.s...
腾讯云微服务TSF考题及答案_78.docx
12-17
腾讯微服务平台（Tencent Service Framework，TSF）是一个围绕应用和微服务的 PaaS 平台，提供一站式应用全生命周期管理能力和数据化运营支持，提供多维度应用和服务的监控数据，助力服务性能优化。提供基于 Spring ...
一、SpringCloud初步了解
weixin_45966976的博客
02-26 2536
sprincloud
Redis分布式锁的正确实现方式
无怨无悔专栏
11-01 1万+
前言 分布式锁一般有三种实现方式：1. 数据库乐观锁；2. 基于Redis的分布式锁；3. 基于ZooKeeper的分布式锁。本篇博客将介绍第二种方式，基于Redis实现分布式锁。虽然网上已经有各种介绍Redis分布式锁实现的博客，然而他们的实现却有着各种各样的问题，为了避免误人子弟，本篇博客将详细介绍如何正确地实现Redis分布式锁。 可靠性 首先，为了确保分布式锁可用，我
K8S云原生系统架构优化（五）DevOps
最新发布
weixin_53439529的博客
10-13 267
原生的K8S集群系统架构优化——DevOps优化
Non-resolvable import POM: Could not transfer artifact org.springframework.cloud:spring-cloud-depend
qq1252120810的博客
08-15 2万+
mvn clean命令，报错如下： 复制代码 [ERROR] [ERROR] Some problems were encountered while processing the POMs: [ERROR] Non-resolvable import POM: Could not transfer artifact org.springframework.cloud:spring-cloud-d...
SpringCloudConsul之服务发现和配置管理
我与风来
11-05 1238
本文详细描述了如何使用 Spring Consul！
spring-cloud 基本使用(一)
h15637811412的博客
02-22 1万+
本文主要讲了 spring-cloud 注册中心基本使用 spring-cloud 注册中心的一些基本配置及实现集群 spring-cloud 注册中心的使用，即通过注册中心注册及访问 spring-cloud 通过Ribbon实现负载均衡 spring-cloud 通过Retry实现重试机制 1、spring-cloud 注册中心基本使用 spring-cload使用的注册中心是Eu...
导入SpringCloud依赖踩的坑
热门推荐
xzp_forever的博客
06-11 3万+
在使用SpringCloud的时候需要导入spring-cloud-dependencies的依赖, 在springcloud的官网上面可以查到版本Version 但是在上面复制下来的版本号如下:&lt;dependencyManagement&gt; &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;...
Failure to find org.springframework.cloud:spring-cloud-dependencies:pom:Greenwich.M1
Tina的博客
01-22 2万+
错误信息： [ERROR]     Non-resolvable import POM: Failure to find org.springframework.cloud:spring-cloud-dependencies:pom:Greenwich.M1 in http://maven.aliyun.com/nexus/content/groups/public/ was cached in...
腾讯TSF：微服务治理平台，加速企业数字化转型
腾讯分布式微服务治理平台TSF是腾讯云中间件团队推出的一款旨在解决企业架构痛点的产品。随着业务的快速发展，企业面临着诸如业务和数据难以沉淀共享，以及对系统扩展性、效率和安全性的高要求等挑战。传统的单体...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值