springboot项目中实现分布式锁

在Spring Boot项目中实现分布式锁，我们通常会使用Redis或Zookeeper等分布式一致性解决方案。下面是一个使用Redis实现的分布式锁的代码案例。

首先，我们需要在Spring Boot项目中引入相关的依赖：

<dependencies>  
    <!-- other dependencies -->  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-data-redis</artifactId>  
    </dependency>  
    <dependency>  
        <groupId>io.lettuce</groupId>  
        <artifactId>lettuce-core</artifactId>  
        <version>6.1.5.RELEASE</version>  
    </dependency>  
</dependencies>

然后，我们需要在Spring Boot的配置文件中配置Redis的连接信息：

spring:  
  redis:  
    host: localhost  
    port: 6379

接下来，我们可以创建一个用于实现分布式锁的类，如下所示：

import io.lettuce.core.ReadFrom;  
import io.lettuce.core.api.StatefulRedisConnection;  
import io.lettuce.core.api.sync.RedisCommands;  
import io.lettuce.core.api.sync.RedisLock;  
import io.lettuce.core.codec.StringCodec;  
import io.lettuce.core.mgt.sentinel.SentinelPoolConfig;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.context.annotation.Bean;  
import org.springframework.data.redis.connection.RedisConnectionFactory;  
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;  
import org.springframework.data.redis.core.RedisTemplate;  
import org.springframework.data.redis.listener.ChannelTopic;  
import org.springframework.data.redis.listener.RedisMessageListenerContainer;  
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;  
import org.springframework.data.redis.serializer.GenericToStringSerializer;  
import org.springframework.stereotype.Component;  
  
@Component  
public class RedisLockManager {  
  
    @Autowired  
    private RedisConnectionFactory redisConnectionFactory;  
  
    @Bean  
    public RedisTemplate<String, String> redisTemplate() {  
        RedisTemplate<String, String> template = new RedisTemplate<>();  
        template.setConnectionFactory(redisConnectionFactory);  
        template.setKeySerializer(new GenericToStringSerializer<>(StringCodec.UTF8));  
        template.afterPropertiesSet();  
        return template;  
    }  
  
    @Bean  
    public MessageListenerContainer redisContainer() {  
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();  
        container.setConnectionFactory(redisConnectionFactory);  
        container.addMessageListener(messageListenerAdapter(), new ChannelTopic("__keyevent@0__:expired"));  
        return container;  
    }  
  
    @Bean  
    public MessageListenerAdapter messageListenerAdapter() {  
        return new MessageListenerAdapter(new RedisLockListener());  
    }  
  
    public RedisLock<String> getLock(String id) {  
        return redisTemplate().opsForLock().build(new LockKey(id));  
    }  
  
    private class RedisLockListener implements GenericMessageListener<String, Object> {  
  
        @Override  
        public void onMessage(String key, Object value) {  
            if (value instanceof LockKey) {  
                LockKey lockKey = (LockKey) value;  
                redisTemplate().delete(lockKey);  
            }  
        }  
    }  
}

在上面的代码中，我们首先定义了一个RedisLockManager类，它是一个Spring组件。在这个类中，我们使用了Spring Boot提供的RedisTemplate类和RedisMessageListenerContainer类来操作Redis和监听Redis的事件。接着，我们定义了一个getLock方法，它用于获取一个RedisLock对象。这个对象是用于实现分布式锁的关键。最后，我们定义了一个RedisLockListener类，它是一个监听器，用于在Redis的键过期时删除对应的锁。

接下来，我们可以使用RedisLockManager中的getLock方法来获取一个分布式锁，如下所示：

@Service  
public class DistributedLockService {  
  
    @Autowired  
    private RedisLockManager redisLockManager;  
  
    public boolean acquireLock(String id) {  
        RedisLock<String> lock = redisLockManager.getLock(id);  
        try {  
            if (lock.tryLock()) {  
                // 在这里执行需要保护的代码  
                return true;  
            } else {  
                return false;  
            }  
        } catch (Exception e) {  
            // 处理异常  
        } finally {  
            lock.unlock();  
        }  
    }  
}

在上面的代码中，我们使用try-catch-finally语句块来获取锁并保护业务逻辑。如果tryLock()方法返回true，则执行需要保护的代码。如果tryLock()方法返回false，则不执行需要保护的代码。在finally块中，我们释放锁，以确保即使发生异常，锁也会被释放。