Redisson 原理、用途及Spring Boot集成指南Redisson 原理 Redisson 是一个基于Redi

Redisson 原理

Redisson 是一个基于Redis的Java驻内存数据网格（In-Memory Data Grid），它在Redis的基础上实现了丰富的分布式数据结构和服务。其核心原理包括：

非阻塞I/O：基于Netty框架实现高性能的网络通信
响应式编程：支持Reactive和RxJava接口
分布式数据结构：在Redis基础上实现了Java常见数据结构的分布式版本
锁与同步器：实现了多种分布式锁和同步机制
服务治理：提供分布式服务、调度服务和映射归约服务

Redisson 主要用途

分布式锁：实现跨JVM的线程同步
分布式集合：如Map、Set、List、Queue等
分布式对象：如AtomicLong、CountDownLatch等
发布/订阅：支持基于主题的消息传递
数据缓存：提供二级缓存和Spring Cache集成
分布式服务：远程服务调用和调度服务

Spring Boot 集成配置

1. 添加Maven依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.17.0</version>
</dependency>

2. 配置文件（application.yml）

spring:
  redis:
    host: localhost
    port: 6379
    password: 
    database: 0

redisson:
  file: classpath:redisson.yaml  # 可选，使用外部配置文件

3. 代码配置类

@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host}")
    private String host;
    
    @Value("${spring.redis.port}")
    private String port;
    
    @Value("${spring.redis.password}")
    private String password;
    
    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://" + host + ":" + port)
              .setPassword(password)
              .setDatabase(0)
              .setConnectionPoolSize(10)
              .setConnectionMinimumIdleSize(2)
              .setIdleConnectionTimeout(10000)
              .setConnectTimeout(10000)
              .setTimeout(3000);
        
        return Redisson.create(config);
    }
}

关键实现代码示例

1. 分布式锁使用

public class OrderService {
    
    @Autowired
    private RedissonClient redissonClient;
    
    public void createOrder(String orderId) {
        RLock lock = redissonClient.getLock("orderLock:" + orderId);
        
        try {
            // 尝试获取锁，最多等待10秒，锁持有时间30秒
            boolean isLocked = lock.tryLock(10, 30, TimeUnit.SECONDS);
            
            if (isLocked) {
                // 执行业务逻辑
                processOrder(orderId);
            } else {
                throw new RuntimeException("获取锁失败");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("锁获取被中断", e);
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
    
    private void processOrder(String orderId) {
        // 订单处理逻辑
    }
}

2. 分布式Map使用

public class UserCacheService {
    
    @Autowired
    private RedissonClient redissonClient;
    
    public void cacheUserInfo(String userId, User user) {
        RMap<String, User> userMap = redissonClient.getMap("userCache");
        userMap.put(userId, user);
        
        // 设置过期时间
        userMap.expire(1, TimeUnit.HOURS);
    }
    
    public User getUserInfo(String userId) {
        RMap<String, User> userMap = redissonClient.getMap("userCache");
        return userMap.get(userId);
    }
}

3. 分布式原子操作

public class CounterService {
    
    @Autowired
    private RedissonClient redissonClient;
    
    public long increment(String key) {
        RAtomicLong atomicLong = redissonClient.getAtomicLong(key);
        return atomicLong.incrementAndGet();
    }
    
    public long getCurrentValue(String key) {
        RAtomicLong atomicLong = redissonClient.getAtomicLong(key);
        return atomicLong.get();
    }
}

4. 发布订阅模式

@Service
public class MessagePublisher {
    
    @Autowired
    private RedissonClient redissonClient;
    
    public void publish(String channel, String message) {
        RTopic topic = redissonClient.getTopic(channel);
        topic.publish(message);
    }
}

// 消息订阅者
@Component
public class MessageSubscriber implements ApplicationListener<ReadyEvent> {
    
    @Autowired
    private RedissonClient redissonClient;
    
    @Override
    public void onApplicationEvent(ReadyEvent event) {
        RTopic topic = redissonClient.getTopic("notifications");
        topic.addListener(String.class, (channel, msg) -> {
            System.out.println("收到消息: " + msg + "，来自频道: " + channel);
        });
    }
}

5. Spring Cache集成

@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager(RedissonClient redissonClient) {
        Map<String, CacheConfig> config = new HashMap<>();
        
        // 创建名为"userCache"的缓存，TTL为10分钟
        config.put("userCache", 
            new CacheConfig(10*60*1000, 5*60*1000));
        
        return new RedissonSpringCacheManager(redissonClient, config);
    }
}

// 在服务类中使用缓存
@Service
public class UserService {
    
    @Cacheable(value = "userCache", key = "#userId")
    public User getUserById(String userId) {
        // 从数据库获取用户
        return userRepository.findById(userId);
    }
    
    @CacheEvict(value = "userCache", key = "#userId")
    public void updateUser(User user) {
        userRepository.update(user);
    }
}

集群模式配置

public RedissonClient redissonClusterClient() {
    Config config = new Config();
    config.useClusterServers()
          .addNodeAddress("redis://127.0.0.1:7000", "redis://127.0.0.1:7001")
          .setScanInterval(2000) // 集群状态扫描间隔
          .setPassword("password")
          .setRetryAttempts(3)
          .setTimeout(1000);
    
    return Redisson.create(config);
}

总结

Redisson为Spring Boot应用提供了强大的分布式功能支持，通过简单的配置即可使用各种分布式数据结构和同步机制。在实际应用中，应根据具体需求选择合适的配置和数据结构，并注意合理设置超时时间和重试策略，以确保系统的稳定性和性能。