spring boot 之 redis多数据源

最新推荐文章于 2024-08-20 02:07:38 发布
最新推荐文章于 2024-08-20 02:07:38 发布
阅读量3.1k 收藏 2
点赞数
分类专栏： spring boot redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linhui258/article/details/80790808
版权

redis多数据源配置有多种方式，比如可以同时使用redisson客户端和Jedis两个数据源即可实现。

这里我讲的是怎么通过配置使用Jedis生成两个RedisTemplate实例来进行多数据源的配置

一、依赖引入

<!-- 集群redis -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

二、application配置文件

spring.cluster.pool1.nodes=10.200.85.185:6380,10.200.85.186:6380,10.200.85.187:6380,10.200.85.189:6380,10.200.85.190:6380,10.200.85.191:6380
spring.redis.cluster.max-redirects=2
spring.cluster.pool1.maxIdel=0
spring.cluster.pool1.maxWaitMillis=1000
spring.cluster.pool1.maxTotal=30
spring.cluster.pool1.minEvictableIdleTimeMillis=1800000
spring.cluster.pool1.minIdel=0
spring.cluster.pool1.lifo=false
spring.cluster.pool1.softMinEvictableIdleTimeMillis=1800000

#redis
spring.cluster.pool2.nodes=10.200.85.211:6379,10.200.85.212:6379,10.200.85.213:6379,10.200.85.214:6379,10.200.85.215:6379,10.200.85.216:6379
#spring.redis.cluster.max-redirects=2
spring.cluster.pool2.maxIdel=0
spring.cluster.pool2.maxWaitMillis=1000
spring.cluster.pool2.maxTotal=30
spring.cluster.pool2.minEvictableIdleTimeMillis=1800000
spring.cluster.pool2.minIdel=0
spring.cluster.pool2.lifo=false
spring.cluster.pool2.softMinEvictableIdleTimeMillis=1800000

三、Java配置

 

  • 读取配置属性
package com.migu.live.config.redisConfig;

import com.alibaba.fastjson.JSONObject;

import java.util.List;

public class ClusterRedisPoolProperties {

	private int maxIdel;
	private long maxWaitMillis;
	private int maxTotal;
	private long minEvictableIdleTimeMillis;
	private int minIdel;
	private boolean lifo;
	private long softMinEvictableIdleTimeMillis;
	private List<String> nodes;

	public int getMaxIdel() {
		return maxIdel;
	}

	public void setMaxIdel(int maxIdel) {
		this.maxIdel = maxIdel;
	}

	public long getMaxWaitMillis() {
		return maxWaitMillis;
	}

	public void setMaxWaitMillis(long maxWaitMillis) {
		this.maxWaitMillis = maxWaitMillis;
	}

	public int getMaxTotal() {
		return maxTotal;
	}

	public void setMaxTotal(int maxTotal) {
		this.maxTotal = maxTotal;
	}

	public long getMinEvictableIdleTimeMillis() {
		return minEvictableIdleTimeMillis;
	}

	public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
		this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
	}

	public int getMinIdel() {
		return minIdel;
	}

	public void setMinIdel(int minIdel) {
		this.minIdel = minIdel;
	}

	public boolean isLifo() {
		return lifo;
	}

	public void setLifo(boolean lifo) {
		this.lifo = lifo;
	}

	public long getSoftMinEvictableIdleTimeMillis() {
		return softMinEvictableIdleTimeMillis;
	}

	public void setSoftMinEvictableIdleTimeMillis(long softMinEvictableIdleTimeMillis) {
		this.softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;
	}

	public List<String> getNodes() {
		return nodes;
	}

	public void setNodes(List<String> nodes) {
		this.nodes = nodes;
	}

	@Override
	public String toString() {
		return JSONObject.toJSONString(this);
	}
}

 

  • 第一个redis库配置
package com.migu.live.config.redisConfig;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @author wangcongming
 * @Package com.example.multidatasource.config.redis
 * @Description:
 * @date 2018/4/5 19:49
 */
@Configuration
@ConfigurationProperties(prefix = "spring.cluster.pool1")
public class FirstRedisConfig extends ClusterRedisPoolProperties {

    private final static Logger log = LoggerFactory.getLogger(FirstRedisConfig.class);

    @Bean(name = "firstRedisConnectionFactory")
    @Primary
    public RedisConnectionFactory connectionFactory() {
        log.info("************初始化redis1集群************");
        JedisConnectionFactory factory = new JedisConnectionFactory(
                new RedisClusterConfiguration(this.getNodes()));
        JedisPoolConfig config = factory.getPoolConfig();
        config.setMaxIdle(this.getMaxIdel());
        config.setMaxWaitMillis(this.getMaxWaitMillis());
        config.setMaxTotal(this.getMaxTotal());
        config.setMinEvictableIdleTimeMillis(this.getMinEvictableIdleTimeMillis());
        config.setMinIdle(this.getMinIdel());
        config.setLifo(this.isLifo());
        config.setSoftMinEvictableIdleTimeMillis(this.getSoftMinEvictableIdleTimeMillis());
        log.info("************初始化redis1集群结束************");
        return factory;
    }
}

 

  • 第二个redis配置
package com.migu.live.config.redisConfig;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @author wangcongming
 * @Package com.example.multidatasource.config.redis
 * @Description:
 * @date 2018/4/5 19:49
 */
@Configuration
@ConfigurationProperties(prefix = "spring.cluster.pool2")
public class SecondRedisConfig extends ClusterRedisPoolProperties {

    private final static Logger log = LoggerFactory.getLogger(FirstRedisConfig.class);

    @Bean(name = "secondRedisConnectionFactory")
    public RedisConnectionFactory connectionFactory() {
        log.info("************初始化redis2集群************");
        JedisConnectionFactory factory = new JedisConnectionFactory(
                new RedisClusterConfiguration(this.getNodes()));
        JedisPoolConfig config = factory.getPoolConfig();
        config.setMaxIdle(this.getMaxIdel());
        config.setMaxWaitMillis(this.getMaxWaitMillis());
        config.setMaxTotal(this.getMaxTotal());
        config.setMinEvictableIdleTimeMillis(this.getMinEvictableIdleTimeMillis());
        config.setMinIdle(this.getMinIdel());
        config.setLifo(this.isLifo());
        config.setSoftMinEvictableIdleTimeMillis(this.getSoftMinEvictableIdleTimeMillis());
        log.info("************初始化redis2集群结束************");
        return factory;
    }
}
  • RedisTemplate和StringRedisTemplate具体配置
package com.migu.live.config.redisConfig;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class AppConfig {

//	private final static Logger logger = LoggerFactory.getLogger(AppConfig.class);

	@Autowired
	@Qualifier(value = "firstRedisConnectionFactory")
	private RedisConnectionFactory redisConnectionFactory;

	@Autowired
	@Qualifier(value = "secondRedisConnectionFactory")
	private RedisConnectionFactory secondRedisConnectionFactory;

	@Bean(name = "firstRedisTemplate")
	@Primary
	public RedisTemplate<Object,Object> redisTemplate(){
		return getRedisTemplate(redisConnectionFactory);
	}

	@Bean(name = "firstStringRedisTemplate")
	@Primary
	public StringRedisTemplate stringRedisTemplate(){
		return getStringRedisTemplate(redisConnectionFactory);
	}

	@Bean(name = "secondRedisTemplate")
	public RedisTemplate<Object,Object> secondRedisTemplate(){
		return getRedisTemplate(secondRedisConnectionFactory);
	}

	@Bean(name = "secondStringRedisTemplate")
	public StringRedisTemplate secondStringRedisTemplate(){
		return getStringRedisTemplate(secondRedisConnectionFactory);
	}

	private RedisTemplate<Object,Object> getRedisTemplate(RedisConnectionFactory connectionFactory){
		RedisTemplate<Object,Object> template = new RedisTemplate<Object,Object>();
		template.setConnectionFactory(connectionFactory);
		setSerializer(template);
		template.afterPropertiesSet();
		return template;
	}

	private StringRedisTemplate getStringRedisTemplate(RedisConnectionFactory connectionFactory){
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(connectionFactory);
		setStringSerializer(template);
		template.afterPropertiesSet();
		return template;
	}

	private void setStringSerializer(StringRedisTemplate template){
		RedisSerializer<String> stringSerializer = new StringRedisSerializer();
		template.setKeySerializer(stringSerializer);
		template.setValueSerializer(stringSerializer );
		template.setHashKeySerializer(stringSerializer );
		template.setHashValueSerializer(stringSerializer );
		template.afterPropertiesSet();
	}

	private void setSerializer(RedisTemplate<Object, Object> template) {
		Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
				Object.class);
		ObjectMapper om = new ObjectMapper();
		om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
		jackson2JsonRedisSerializer.setObjectMapper(om);
		template.setKeySerializer(jackson2JsonRedisSerializer);
		template.setValueSerializer(jackson2JsonRedisSerializer);
		template.setHashValueSerializer(jackson2JsonRedisSerializer);
	}
}

四、使用示例

package com.migu.live.util;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

@SuppressWarnings("rawtypes")
@Component
public class RedisSrcUtil {
	
	@Resource(name = "firstStringRedisTemplate")
	private StringRedisTemplate stringRedisTemplate;
	
	@Resource(name = "firstStringRedisTemplate")
	private ValueOperations<String, String> stringRedisOperations;
	
	@Resource(name = "firstRedisTemplate")
	private RedisTemplate redisTemplate;
	
	@Resource(name = "firstRedisTemplate")
	private ValueOperations<String, String> redisOperations;
	
	@Resource(name = "firstStringRedisTemplate")
	private HashOperations<String, String, String> hMapOps;
	
	@Resource(name = "firstStringRedisTemplate")
	ZSetOperations<String, String> zSetOps;
	
	@Resource(name = "firstRedisTemplate")
	ListOperations<String, Object> listOps;
	
	/**
	 * StringRedisTemplate<br>
	 * 放入redis,使用默认的过期时间<br>
	 * @param key
	 * @param value
	 */
	public void setStringValue(final String key,String value){
		stringRedisOperations.set(key, value);
	}
	
	/**
	 * StringRedisTemplate<br>
	 * 从redis取出value
	 * @param key
	 * @return
	 */
	public String getStringValue(final String key){
		return stringRedisOperations.get(key);
	}
	
	/**
	 * StringRedisTemplate<br>
	 * 放入redis,并设置过期时间(分钟)
	 * @param key
	 * @param value
	 * @param expireTime
	 */
	public void setStringValue(final String key,String value,Long expireTime){
		stringRedisOperations.set(key, value);
		stringRedisTemplate.expire(key, expireTime, TimeUnit.MINUTES);
	}
	
	/**
	 * StringRedisTemplate<br>
	 * 判断是否存在key
	 * @param key
	 * @return
	 */
	public boolean hasKey(final String key){
		return stringRedisTemplate.hasKey(key);
	}
	
	/**
	 * StringRedisTemplate<br>
	 * 删除相应的value
	 * @param key
	 */
	public void remove(final String key){
		stringRedisTemplate.delete(key);
	}
	
	
	public StringRedisTemplate geStringRedisTemplate(){
		return this.stringRedisTemplate;
	}
	
	public RedisTemplate geRedisTemplate(){
		return this.redisTemplate;
	}
	
	/**
	 * StringRedisTemplate<br>
	 * 批量删除对应的value
	 * 
	 * @param keys
	 */
	public void remove(final String... keys) {
		for (String key : keys) {
			remove(key);
		}
	}
	
	/**
	 * StringRedisTemplate<br>
	 * 返回 StringRedisOperation
	 * @return
	 */
	public ValueOperations<String, String> getOperations(){
		return this.stringRedisOperations;
	}
	
	/**
	 * RedisTemplate<br>
	 * 获取对象类型的值
	 * @param key
	 * @return
	 */
	public Object getObjectValue(String key){
		return redisOperations.get(key);
	}
	
	/**
	 * RedisTemplate<br>
	 * 添加对象类型数据
	 * @param key
	 * @param object
	 */
	public void setObjectValue(String key,Object object){
		redisOperations.set(key, (String) object);
	}
	
	/**
	 * RedisTemplate<br>
	 * @param key
	 * @param object
	 * @param expireTime
	 */
/*	@SuppressWarnings("unchecked")
	public void setObjectValue(String key,Object object ,Long expireTime){
		redisOperations.set(key, object);
		redisTemplate.expire(key, expireTime, TimeUnit.MINUTES);
	}*/
	
	public void increment(String key,Long delta){
		redisOperations.increment(key, delta);
	}
	
	@SuppressWarnings("unchecked")
	public void expire(String key,Long expireTime){
		redisTemplate.expire(key, expireTime, TimeUnit.MINUTES);
	}
	
	public void expire(String key,Long expireTime,TimeUnit unit){
		stringRedisTemplate.expire(key, expireTime, unit);
	}
	
	@SuppressWarnings("unchecked")
	public Set getKeysByPattern(String pattern){
		return redisTemplate.keys(pattern);
	}
	
	public void setHash(String key,String hashKey ,String value) {
		hMapOps.put(key, hashKey, value);
	}
	
	public String getHashValue(String key, String mapKey) {
		return hMapOps.get(key, mapKey);
	}
	
	public Map<String, String> getHashAll(String key){
		return hMapOps.entries(key);
	}
	
	public long setHashIncrement(String key, String hashKey, long counts) {
		return hMapOps.increment(key, hashKey, counts);
	}
	
	public long size(String key){
		return hMapOps.size(key);
	}
	
	public long lookTimeOut(String key, TimeUnit timeUnit) {
		return stringRedisTemplate.getExpire(key, timeUnit);
	}
	
	public boolean zAddZsetElement(String key, String value, long score) {
		return zSetOps.add(key, value, score);
	}
	
	public Double getZsetScore(String key, String value) {
		return zSetOps.score(key, value);
	}
	
	public long getListSize(String key) {
		return listOps.size(key);
	}
	public List<Object> getList(String key) {
		return listOps.range(key,0L ,-1L);
	}

	public void addList(String key, List<Object> values) {
		if (values == null || values.size() == 0) {
			return;
		}

		listOps.rightPushAll(key, values);
	}
	/**
	 * 获取自增值
	 * @param key
	 * @return
	 */
	public int getIncrValue(final String key) {  

	    return stringRedisTemplate.execute(new RedisCallback<Integer>() {
	    	@Override  
	        public Integer doInRedis(RedisConnection connection) throws DataAccessException {  
	            RedisSerializer<String> serializer = stringRedisTemplate.getStringSerializer();  
	            byte[] rowkey=serializer.serialize(key);  
	            byte[] rowval=connection.get(rowkey);  
	            try {  
	                String val=serializer.deserialize(rowval);
	                return Integer.parseInt(val);  
	            } catch (Exception e) {  
	                return 0;  
	            }  
	        }
		});  
	}

	@SuppressWarnings("unchecked")
	@PostConstruct
	public void init(){
		redisTemplate.setKeySerializer(new StringRedisSerializer());
		redisTemplate.setValueSerializer(new StringRedisSerializer());
	}
	public long delOfflineContent(String contentId,String listId){
		return listOps.remove(listId,1,contentId);
	}
}

到此，redis多数据源就介绍完了

 

分享一套spring boot 学习视频：https://download.csdn.net/download/linhui258/10546450

linhui258
关注
专栏目录
Spring Boot实现Redis多数据源动态切换 | Spring Cloud 32
gmHappy
03-28 1万+
在前面我们通过以下章节对Redis使用有了基础的了解： Spring Boot实现Redis同数据源动态切换DB | Spring Cloud 31 此章节基于spring-boot-starter-data-redis模块，实现了Redis多数据源动态切换，具体功能如下： 突破一个项目只能一个连接Redis数据源的限制 提供多种操作切换Redis数据源的方式（@Autowired方式 和RedisSelectSupport方式） 提供完善的代码使用示例
SpringBoot2整合Redis多数据源步骤详解
08-19
SpringBoot2整合Redis多数据源步骤详解 SpringBoot2整合Redis多数据源是一个非常重要的知识点， especially 在分布式系统中，REDIS作为一个高性能的Key-Value数据库，广泛应用于缓存、Session管理、消息队列等领域...
Redis配置多数据源(同一个Redis，多个不同db)
qq_42974262的博客
11-25 2908
redis配置多数据源
SpringBoot配置Redis多集群数据源
TheOne的博客
12-10 3184
Redis 三大客户端 简介 Jedis：是Redis 老牌的Java实现客户端，提供了比较全面的Redis命令的支持， Redisson：实现了分布式和可扩展的Java数据结构。 Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。 优点： Jedis：比较全面的提供了Redis的操作特性 Redisson：促使使用者对Redis的关注分离，提供很多分布式相关操作服务，例如分布式锁，分布式集合，可通过Redis支持延迟队列 Le..
若依配置多redis数据源
最新发布
weixin_34638409的博客
08-20 103
我整理的一些关于【数据】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/eDOcp1如何在“若依”框架中配置多Redis数据源 在现代的开发过程中，我们经常需要使用多个数据源来满足系统的需求。而Redis作为一种高性能的键值存储工具，常常被用作缓存或会话存储。在本文中，我们将...
SpringBoot配置多个Redis数据源
iGD_Hz的博客
10-28 2975
SpringBoot配置多RedisTemplate
springboot 配置多个Redis数据源详解
A_awen的博客
10-31 3253
springboot 配置多个redis数据源
spring-boot整合redis（多数据源）
赶路人儿
04-29 2638
官网：https://spring.io/projects/spring-data-redis Spring Data Redis是Spring Data系列的一部分，可轻松配置并从Spring应用程序访问Redis，并支持low-level和hight-level的抽象接口。可以看到spring data下面共提供了如下技术方案： 市面上已经有 Redis、Redisson、Lettuce 等优秀的 Java Redis 工具库，为什么还要有 Spring Data Redis 呢？ 对于下层，
Spring Boot实现Redis多数据源
qq_41548206的博客
08-10 1796
Spring Boot实现Redis多数据源
Spring Boot 整合 Redis.docx
11-20
// 从数据库或其他数据源获取数据 } @CacheEvict(value = "myCache", key = "#id") public void removeData(String id) { // 删除对应ID的数据 } @CachePut(value = "myCache", key = "#id") public My...
Spring boot -redis
02-21
它集成了大量的常用第三方库配置，如数据源、JPA、WebSocket、Thymeleaf 等，使得开发者可以快速构建健壮的 web 应用程序。 Redis 是一个高性能的键值对数据存储系统，常被用作数据库、缓存和消息中间件。它支持...
Spring Boot整合redis
08-24
以上就是Spring Boot整合Redis的相关知识点，包括配置、数据操作、模板引擎Thymeleaf、数据源Druid、声明式事务管理和Redis事务的使用。通过这些知识，你可以构建一个具备数据缓存能力的Web应用。
springboot + mybatis-plus + oracle + 多数据源 + redis + hutool
04-06
springboot + mybatis-plus + database+ 多数据源 + redis + hutool 框架干净，没有其他冗余的成分； 配置了MP的代码生成器，意见生成代码，节省开发时间！ 可用于各种定时任务处理，各种夸库操作， 多数据源支持...
Redisson的配置
qq_44861126的博客
04-23 4973
【代码】Redisson的配置。
SpringBoot+redis RedisTemplate/jedis 配置多个数据源 灵活切库 选择库
weixin_45220510的博客
06-26 3905
SpringBoot+redis RedisTemplate/jedis 配置多个数据源 灵活切库 选择库 1.加入依赖并在在yml 文件里面加入配置spring:redis:host: urlport: 6379pool:database:db10: 10db4: 4我这里选择redis的 10号库和4号库，如果不同 请自行添加 db0:0 比如再添加一个0号库使用2.添加配置文件/***/@Bean// 配置redis连接池// 构建工厂对象.build();// 设置使用的redis数据库。
【Redis】Spring Boot下使用Redis，配置多个database数据源
qq_39043700的博客
09-02 5361
本文介绍在spring boot下，如何为redis配置多个database数据源。
Redis 多数据源 Spring Boot 实现
谢文峰的博客
07-05 1652
本文为大家提供一个 redis 配置多数据源的实现方案，在实际项目中遇到，分享给大家。后续如果有时间会写一个升级版本，升级方向在第5点。
Redis配置多数据源
FirstMrRight的博客
03-15 3308
使用场景 Redis具有多个databases，通过CONFIG GET databases命令可查看，Redis不同的database间具有数据隔离性，即在项目中我们配置一个databases 0信息后，并无法获取其他databases的数据，所以，当我们业务中需要获取其他databases时，便需要配置多Redis数据源。 配置文件 以properties为例 #redis databases 1 spring.redis.database=1 spring.redis.host=127.0.0.1
利用redisson实现数据缓存
07-27
使用Redisson可以很方便地实现数据缓存。Redisson是一个基于Redis的Java客户端，它提供了丰富的功能和API，包括分布式锁、分布式集合、分布式对象等。在使用Redisson实现数据缓存时，可以通过以下步骤进行操作： 1. 引入Redisson的依赖并配置Redis连接信息。 2. 创建RedissonClient对象，该对象是Redisson的核心组件，用于与Redis进行通信。 3. 使用Redisson提供的分布式锁功能，可以通过调用tryLock方法来加锁，该方法会返回一个布尔值表示是否成功获取到锁。在加锁时，可以设置锁的过期时间，以防止锁被长时间占用。 4. 在获取到锁之后，可以从缓存中读取数据。如果缓存中不存在所需的数据，可以从数据库或其他数据源中获取，并将数据存入缓存中。 5. 在数据更新或删除时，需要先获取到锁，然后进行相应的操作，并更新缓存。 6. 在操作完成后，需要释放锁，以便其他线程或进程可以获取到锁并进行操作。 通过以上步骤，可以利用Redisson实现数据缓存，并保证数据的一致性和并发安全性。\[1\]\[2\]\[3\] #### 引用[.reference_title] - *1* [分布式锁Redisson快速入门及利用AOP实现声明式缓存](https://blog.csdn.net/weixin_44743245/article/details/120805755)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [redisson做分布式缓存（加锁方面）](https://blog.csdn.net/weixin_55034383/article/details/129333680)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值