Springboot 2.0.x 结合Redis 分布式锁

最新推荐文章于 2023-02-22 14:34:23 发布
最新推荐文章于 2023-02-22 14:34:23 发布
阅读量378 收藏 1
点赞数
分类专栏： 技术分享 文章标签： redis 分布式锁 springboot redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkillala/article/details/101781923
版权
1. 引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

application.properties增加以下配置

## redis配置
spring.redis.host=127.0.0.1
spring.redis.database=0
spring.redis.port=6379
spring.redis.password=slo
2.加入配置类
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * <p>redis缓存配置</p>
 */
@Configuration
@EnableCaching
public class RedisCachedConfig extends CachingConfigurerSupport {
	//过期时间1天
//	private Duration timeToLive = Duration.ofMinutes(1);
	private Duration timeToLive = Duration.ofHours(1);
	@Bean
	public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
		//默认1
		RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
				.entryTtl(this.timeToLive)
				.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
				.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
				.disableCachingNullValues();
		RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
				.cacheDefaults(config)
				.transactionAware()
				.build();
		return redisCacheManager;
	}
	@Bean(name = "redisTemplate")
	public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
		redisTemplate.setConnectionFactory(redisConnectionFactory);
		redisTemplate.setKeySerializer(keySerializer());
		redisTemplate.setHashKeySerializer(keySerializer());
		redisTemplate.setValueSerializer(valueSerializer());
		redisTemplate.setHashValueSerializer(valueSerializer());
		return redisTemplate;
	}
	private RedisSerializer<String> keySerializer() {
		return new StringRedisSerializer();
	}
	private RedisSerializer<Object> valueSerializer() {
		return new GenericJackson2JsonRedisSerializer();
	}
}
3.编写Lock工具类
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

import org.springframework.data.redis.core.RedisTemplate;

import lombok.Data;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Data
@Component
public class RedisLock {
	private final Logger logger = LoggerFactory.getLogger(this.getClass());

	@Resource
	private RedisTemplate<String, Object> redisTemplate;
	/**
	 * 重试时间
	 */
	private static final int DEFAULT_ACQUIRY_RETRY_MILLIS = 100;
	/**
	 * 锁的后缀
	 */
	private static final String LOCK_SUFFIX = "_redis_lock";
	/**
	 * 锁的key
	 */
	private String lockKey;

	/**
	 * 锁超时时间，防止线程在入锁以后，防止阻塞后面的线程无法获取锁
	 */
	private int expireMsecs = 2 * 60 * 1000;
	/**
	 * 线程获取锁的等待时间
	 */
	private int timeoutMsecs = 10 * 1000;
	/**
	 * 是否锁定标志
	 */
	private volatile boolean locked = false;


	/**
	 * 封装和jedis方法
	 *
	 * @param key
	 * @return
	 */
	private String get(final String key) {
		Object obj = redisTemplate.opsForValue().get(key);
		return obj != null ? obj.toString() : null;
	}

	/**
	 * 封装和jedis方法
	 *
	 * @param key
	 * @param value
	 * @return
	 */
	private boolean setNX(final String key, final String value) {
		return redisTemplate.opsForValue().setIfAbsent(key, value);
	}

	/**
	 * 封装和jedis方法
	 *
	 * @param key
	 * @param value
	 * @return
	 */
	private String getSet(final String key, final String value) {
		Object obj = redisTemplate.opsForValue().getAndSet(key, value);
		return obj != null ? (String) obj : null;
	}


	//=================================公共方法区============================//

	/**
	 * 初始化参数
	 * 默认锁超时时间 2分钟
	 * 默认获取锁等待时间 10秒
	 *
	 * @param lockKey 锁的key
	 */
	public void init(String lockKey) {
		this.lockKey = lockKey + LOCK_SUFFIX;
	}

	/**
	 * 初始化参数
	 *
	 * @param lockKey      锁的key
	 * @param timeoutMsecs 获取锁的超时时间 单位毫秒 eg：2 * 60 * 1000
	 */
	public void init(String lockKey, int timeoutMsecs) {
		this.lockKey = lockKey + LOCK_SUFFIX;
		this.timeoutMsecs = timeoutMsecs;
	}

	/**
	 * 初始化参数
	 *
	 * @param lockKey      锁的key
	 * @param timeoutMsecs 获取锁的超时时间
	 * @param expireMsecs  锁的有效期 单位毫秒 eg: 10 * 1000
	 */
	public void init(String lockKey, int timeoutMsecs, int expireMsecs) {
		this.lockKey = lockKey + LOCK_SUFFIX;
		this.timeoutMsecs = timeoutMsecs;
		this.expireMsecs = expireMsecs;
	}

	public String getLockKey() {
		return lockKey;
	}

	/**
	 * 获取锁
	 *
	 * @return 获取锁成功返回ture，超时返回false
	 * @throws InterruptedException
	 */
	public synchronized boolean lock() throws InterruptedException {
		int timeout = timeoutMsecs;
		logger.info("准备获取锁{}，获取锁超时时间为{}",this.getLockKey(),timeout);
		while (timeout >= 0) {
			long expires = System.currentTimeMillis() + expireMsecs + 1;
			String expiresStr = String.valueOf(expires); // 锁到期时间
			if (this.setNX(lockKey, expiresStr)) {
				locked = true;
				logger.info("成功获取锁{}，锁超时时间为{}",this.getLockKey(),expires);
				return true;
			}
			// redis里key的时间
			String currentValue = this.get(lockKey);
			// 判断锁是否已经过期，过期则重新设置并获取
			if (currentValue != null && Long.parseLong(currentValue) < System.currentTimeMillis()) {
				// 设置锁并返回旧值
				String oldValue = this.getSet(lockKey, expiresStr);
				// 比较锁的时间，如果不一致则可能是其他锁已经修改了值并获取
				if (oldValue != null && oldValue.equals(currentValue)) {
					logger.info("成功获取锁{}，锁超时时间为{}",this.getLockKey(),expires);
					locked = true;
					return true;
				}
			}
			timeout -= DEFAULT_ACQUIRY_RETRY_MILLIS;
			// 延时
			Thread.sleep(DEFAULT_ACQUIRY_RETRY_MILLIS);
		}
		logger.warn("获取锁{}失败了！",this.getLockKey());
		return false;
	}

	/**
	 * 释放获取到的锁
	 */
	public void unlock() {
		logger.info("准备释放锁{}",this.getLockKey());
		if (locked) {
			redisTemplate.delete(lockKey);
			logger.info("成功释放锁{}",this.getLockKey());
			locked = false;
		}
	}

}
4.redis缓存数据测试

具体类无需关心，只要看注解如何使用即可。

//REDIS缓存调用示例

@Deprecated
@Service
@CacheConfig(cacheNames = "user") //指定cache的名字,这里指定了 caheNames，下面的方法的注解里就可以不用指定 value 属性了
public class UserServiceImpl {

	private Map<Long, User> userMap = new HashMap<Long, User>();

	public UserServiceImpl() {
		User u1=new User();
		u1.setId(1L);
		u1.setName("1111");
		u1.setPassword("11223434");
		User u2=new User();
		u2.setId(2L);
		u2.setName("1111");
		u2.setPassword("11223434");
		User u3=new User();
		u3.setId(3L);
		u3.setName("1111");
		u3.setPassword("11223434");

		userMap.put(1L,u1);
		userMap.put(2L,u2);
		userMap.put(3L,u3);
	}

	@Cacheable()
	@Override
	public List<User> list() {
		System.out.println("querying list.....");
		User[] users = new User[userMap.size()];
		this.userMap.values().toArray(users);
		return Arrays.asList(users);
	}

	@Cacheable(key = "'user:'.concat(#id.toString())")
	@Override
	public User findUserById(Long id) {
		System.out.println("没有调用缓存");
		return userMap.get(id);
	}


	@Cacheable(key = "'user:'.concat(#user.id)")
	@Override
	public void update(User user) {
		System.out.println("没有调用缓存");
		userMap.put(user.getId(), user);
	}

	// 清空cache
	@CacheEvict(key = "'user:'.concat(#id.toString())")
	@Override
	public void remove(Long id) {
		System.out.println("没有调用缓存");
		userMap.remove(id);
	}

	@CacheEvict(key = "'user:'.concat(#id.toString())")
	@Override
	public User upuser(Long id) {
		System.out.println("没有调用缓存");
		User d = userMap.get(id);
		d.setName("0000000000000000000000000000000000000000");
		return d;
	}

	@CachePut(key = "'user:'.concat(#user.id)")
	@Override
	public User saveUser(User user) {
		System.out.println("没有调用缓存");
		userMap.put(user.getId(), user);
		return user;
	}

}
5.Lock嵌入添加示例以及测试

以下无需关注具体业务，只需看lock如何嵌入使用

@Transactional
@Service
public class TestSrvImpl implements TestSrv {
	Logger log = LoggerFactory.getLogger(this.getClass());

	@Resource
	private RedisLock redisLock; //这里自动注入redisLock类

	@Resource
	private UserInfoRepository userInfoRepository;

	@LogAnnotation(moduleName = "测试服务", option = "测试方法")
	public ResponseVO testService(RequestVO requestVO) {
		//获取支付配置相关信息
		ResponseVO response = new ResponseVO(requestVO);
		try {
			log.info("准备获取锁...");
			redisLock.init("Test",20*1000);
			if (redisLock.lock()) {
				log.info("成功获取锁，入参:{}", JSON.toJSONString(requestVO));
				Map<String, Object> resultMap = new HashMap<>();
				resultMap.put("no", "123456");
				resultMap.put("name", "test");
				HandlerStateDTO handlerStateDTO = new HandlerStateDTO();
				response.setBizObj(resultMap);
				if (!HandlerType.isSuccessful(handlerStateDTO)) {
					response.setRetInfo(handlerStateDTO);
				}
				log.info("开始进入睡眠模式");
				Thread.sleep(5000);
				log.info("睡眠模式解除");
				redisLock.unlock();
				log.info("释放锁");
			}
		} catch (Exception e) {
			e.printStackTrace();
			//异常释放锁
			redisLock.unlock();
			response.setRetInfo(HandlerType.UNKNOWN);
			log.error("失败了，{}" + e.toString());
		}
		log.info("结束返回");
		return response;
	}

本样例SDK模拟多线程测试用例如下，自己根据自己的服务调用方式模拟调用即可。本项目采用sdk请求http接口进行调用：

/**
	 * 测试
	 */
	@Test
	public void test() {
		logger.info("开始请求");
		SdkClient sdkClient = new SdkClient(web_pay_url, appId, appSecret, signType, encryptType);
		try {
			Map<String,Object> param = new HashMap<>();
			param.put("name","testUser");
			param.put("id","A000001");
//			// 发起交易
			ResponseVO responseParams = sdkClient.unifyCall("test.service.forfun",version,param);
			logger.info("返回的结果为："+JSON.toJSONString(responseParams));
			logger.info("其中业务返回为："+JSON.toJSONString(responseParams.getBizObj()));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
    @Test
	public void test3() throws InterruptedException {
		// 同一时刻最大的并发线程的个数  即并发数
		final int concurrentThreadNum = 2;

		//总共多少线程
		final int countThreadNum = 2;

		ExecutorService executorService = Executors.newCachedThreadPool();
		CountDownLatch countDownLatch = new CountDownLatch(countThreadNum);
		Semaphore semaphore = new Semaphore(concurrentThreadNum);
		for (int i = 0; i< countThreadNum; i++) {
			executorService.execute(()->{
				try {
					semaphore.acquire();
					test();
					semaphore.release();
				} catch (InterruptedException e) {
					logger.error("exception", e);
				}
				countDownLatch.countDown();
			});
		}
		countDownLatch.await();
		executorService.shutdown();
		logger.info("请求完成");
	}
6.基础框架项目

内置spring boot 和接口加解密sdk，redis锁等，下载即可开发具体业务

码云：BaseFramework

stpFrog
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-boot-2.0.3之redis缓存实现，不是你想的那样哦！
weixin_33924312的博客
11-05 115
前言 开心一刻 小白问小明：“你前面有一个5米深的坑，里面没有水，如果你跳进去后该怎样出来了？”小明：“躺着出来呗，还能怎么出来？”小白：“为什么躺着出来？”小明：“5米深的坑，还没有水，跳下去不死就很幸运了，残是肯定会残的，不躺着出来，那能怎么出来？”小白：“假设没死也没残呢？”小明：“你当我超人了？ 那也简单，把脑子里的水放出来就可以漂出来了。”小白：“你脑子里有这么多水吗？”小明：“我脑子里...
springboot整合redis-SpringBoot（22）
weixin_43831002的博客
08-13 266
添加 Redis、MySQL、MyBatis 依赖。
SpringBoot使用RedisTemplate操作Redis的5种数据类型
热门推荐
pan_junbiao的博客
09-30 1万+
Spring 封装了RedisTemplate 来操作 Redis，它支持所有的 Redis 原生的 API。在RedisTemplate 中定义了对5种数据结构的操作方法。 opsForValue()：操作字符串。 opsForHash()：操作散列。 opsForList()：操作列表。 opsForSet()：操作集合。 opsForZSet()：操作有序集合。 下面通过实例来理解和应用这些方法。这里需要特别注意的是，运行上述方法后要对数据进行清空操作，否则多次运行会导致数据重复操作。 ..
Redis的config配置类
richpersion的博客
08-26 1254
@Configuration @EnableCaching public class RedisConfig extends CachingConfigurerSupport { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new Re
Spring Boot整合ehcache的详细使用
嘉禾嘉宁papa
08-31 9742
目录一、简介二、Maven依赖三、配置类（核心配置）3.1 EhcacheConfig3.2 ehcache.xml四、服务层（核心使用）五、实体、持久层、控制层5.1 实体5.2 持久层5.3 控制层六、配置文件七、效果7.1 请求方法7.2 系统启动后7.2 请求A接口两次7.3 不同参数请求B接口多次八、部署路径（linux部署）8.1 配置文件打包到jar8.2 打包增加classpath8.3 执行命令增加-Dloader.path 一、简介   Ehcache是一种广泛使用的纯Java的进程的开
SpringBoot2.0+SpringCloud+redis集群搭建的仿悦诗风吟旗舰网站
12-30
SpringBoot2.0+SpringCloud搭建的仿悦诗风吟旗舰网站，整合了Mybatis、Redis集群、druid等技术，采用分布式架构，面向服务的思想，该项目是自己在学习SpringBoot和SpringCloud时自己写的一个小项目，整体的功能上...
缓存中间件Redis技术入门与应用场景实战（SpringBoot2.x + 抢红包系统设计与实战）
06-16
概要介绍：历经半个多月的时间，Debug呕心沥血、亲自录制的 “缓存中间件Redis技术入门与典型应用场景实战（SpringBoot2.x）”的新课终于完成了，顾名思义，这是一门关于目前相当流行的分布式缓存中间件Redis相关...
SpringBoot2.0+SpringCloud+redis集群搭建的旗舰网店网站
06-30
SpringBoot2.0+SpringCloud+redis集群搭建的旗舰网店网站，整合了Mybatis、Redis集群、druid等技术，采用分布式架构，面向服务的思想，该项目是自己在学习SpringBoot和SpringCloud时自己写的一个小项目，整体的功能...
SpringBoot2.0+SpringCloud+redis集群搭建的旗舰网站
04-21
SpringBoot2.0+SpringCloud搭建的旗舰网站，整合了Mybatis、Redis集群、druid等技术，采用分布式架构，面向服务的思想，该项目是自己在学习SpringBoot和SpringCloud时自己写的一个项目，做了用户登录注册，商品的...
Springboot2.0+redis+SpringMVC+Spring+Mybatis+Mybatis Plus的Java web分布式开发系统
01-02
Springboot2.0+redis+SpringMVC+Spring+Mybatis+Mybatis Plus的Java web分布式开发系统；NettySocketIo排队系统/排队模块/排队框架,它是一款具有代码生成功能的智能
springboot基于redis分布式锁
11-06
SpringBoot基于redis的分布式锁,有word使用文档,根据文档配置即可使用
spring boot 利用redisson实现redis的分布式锁（二）
05-01
NULL 博文链接：https://liaoke0123.iteye.com/blog/2375556
redis 连接池优化
zchlove137的博客
06-17 2259
使用jedis2.9.1的连接池的小伙伴可能存在一个问题，在程序高并发运行一段时间后会出现Could not get a resource from the pool的报错信息，并且在停止接口调用后查看到的redistemplate的连接工厂里面的空闲连接idelPool始终为0,，这部分连接不会再释放，初步怀疑是jedis连接池泄露问题，经过资料的查阅发现jedis2.9.2以下版本存在连接池泄露的问题，在官方可以看到在2.9.2的bug修复说明（经过我的全方位的测试发现这个bug是在2.9.1改出来的，
Spring Boot 整合Redis使用基于注解的缓存
嘉禾嘉宁papa
02-22 5301
springboot整合redis使用基于注解的缓存，详细介绍KeyGenerator、CacheManager、@EnableCaching、@CacheConfig、@Cacheable、@CachePut、@CacheEvict、@Caching的使用
springboot整合redis缓存一些知识点
我的程序人生
11-09 477
springboot整合redis缓存一些知识点前言一、配置文件`application.yml`文件中的内容说明：spring.cache.type: redisspring.cache.redis.cache-null-values: true二、config配置类说明1. 类上的注解@EnableCaching2. extends CachingConfigurerSupport3. Str...
springboot2 redis配置 及 基于redis的分布式锁
张圣晨的博客
08-02 387
pom.xml 引入 springboot 相关依赖 application.yml 配置 redis 连接信息 spring: redis: port: 6379 host: 127.0.0.1 database: 0 redis 配置类 @Configuration public class RedisConfig { // 配置 redis 分布式锁，及锁的 key 的前缀 @Bean public RedisLockRegist..
Spring Boot 2实现Redis分布式锁，这才是实现分布式锁的正确姿势！
、YongTing
04-10 4194
原文：http://itmuch.com/spring-boot/global-lock/ 都9102年了，你还在手写分布式锁吗？ 直接上代码： spring: redis: port: 6379 host: localhost pom: <dependency> <groupId>org.spri...
springboot2结合redis，实现分布式锁
tommer911
10-23 2315
springboot2结合redis，实现分布式锁
springboot2.0 redis使用lettuce连接包实现分布式锁关键词setnx
ywl635563945的博客
12-06 7103
springboot升级到2.0之后,关联的spring-data-redis默认使用的连接包也从原本的jedis改为了性能更好，且线程安全的使用netty实现的lettuce连接包。 鉴于spring-data默认只提供了setnx不带过期时间的入口，为了防止分布式锁的死锁只能自己来实现setnx关键词 以下是使用默认的stringRedisTemplate实现setnx的过程： /**...
springboot项目集成redis哨兵模式分布式锁
最新发布
08-28
要在Spring Boot项目中集成Redis哨兵模式并使用分布式锁，您需要完成以下步骤： 1. 在您的项目中引入Redis相关依赖，包括`spring-boot-starter-data-redis`和`commons-pool2`。这可以通过在`pom.xml`文件中添加以下...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值