Redis+Redisson 基础配置和使用

基于springBoot的redisson分布式锁 ，设置基础配置

一、配置文件

1.pom依赖

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.16.1</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

2.yml配置文件配置

spring
  redis:
    host: 127.0.0.1
    timeout: 50000
    port: 6379
    password: 123456
    cluster:
      nodes: 1.1.1.1:6379, 1.1.1.1:6379, 1.1.1.1:6379, 1.1.1.1:6379, 1.1.1.1:6379
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0

二、RedisTemplate序列化配置

@Configuration
@EnableCaching //开启注解
public class RedisTempConfig {
    // 配置序列化
    @Bean // LettuceConnectionFactory 
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //spring 2.x 默认使用的redisclient使用LettuceConnectionFactory 可以实现setDataBase切库功能
        //redisConnectionFactory.setDatabase(1);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
		template.setHashKeySerializer(RedisSerializer.string());
		template.setHashValueSerializer(RedisSerializer.java());
        template.setConnectionFactory(redisConnectionFactory);
        template.afterPropertiesSet();
        return template;
    }
}

三、RedissonConfig配置

利用@ConfigurationProperties获取配置的值，@ConfigurationProperties是springboot提供的基于安全类型的配置放置 , 与@Value(“${spring.redis.host}”) 功能类似，会自动根据application.properties获取属性。

// 
@ConfigurationProperties(prefix = "spring.redis")
@Configuration
@Data
public class RedissonConfig {
 
    // 读取配置文件里面的Redis信息
    private String host;
    private String port;
    private String password;
    private Cluster cluster;
    
    public static class Cluster {
        private List<String> nodes;
        public List<String> getNodes() {
            return nodes;
        }
        public void setNodes(List<String> nodes) {
            this.nodes = nodes;
        }
    }
 
    /**
     * 配置redisson --集群方式
     * Redisson是RedissonClient的实现类 
     * @return
     */
    @Bean(destroyMethod = "shutdown")
    public Redisson redisson() {
        List<String> clusterNodes = new ArrayList<>();
        for (int i = 0; i < this.getCluster().getNodes().size(); i  ) {
            clusterNodes.add("redis://"   this.getCluster().getNodes().get(i));
        }
        Config config = new Config();
        ClusterServersConfig clusterServersConfig = config.useClusterServers()
                .addNodeAddress(clusterNodes.toArray(new String[clusterNodes.size()]));
        clusterServersConfig.setPassword(getPassword());
        return (Redisson) Redisson.create(config);
    }
    /**
     * 配置redisson --单节点
     * @return
     */
    @Bean(destroyMethod = "shutdown")
	public RedissonClient redissonClient() {
        Config config = new Config();
            String address = "redis://"   host   ":"   port;
            //使用json序列化方式
            config.setCodec(new JsonJacksonCodec());
            config.useSingleServer().setAddress(address).setPassword(password);
        
        return Redisson.create(config);
    }
 
}

四、编写RedissonUtil工具类

@Component
public class RedissonUtil {
    private static final Logger logger = LoggerFactory.getLogger(RedissonUtil.class);
    /**
     * redis锁前缀
     */
    public static final String SYS_LOCK_FLAG = "MY_LOCK";
 
    /**
     * 用于隔开缓存前缀与缓存键值
     */
    public static final String KEY_SPLIT = ":";
    
    // 静态属性注入
    private static Redisson redisson;
    @Autowired
    public void setRedisson(Redisson redisson) {
        RedissonUtil.redisson = redisson;
    }
 
    /**
     * 加锁
     *
     * @param lockName    锁名  相同的key表示相同的锁，建议针对不同的业务使用不同的key
     * @param expiresTime 过期时间，单位：秒
     * @return
     */
    public static boolean getLock(String lockName, long expiresTime) {
        String key = getLockKey(lockName);
        //获取锁对象
        RLock lock = redisson.getLock(key);
        //设置锁过期时间，防止死锁的产生
        lock.lock(expiresTime, TimeUnit.SECONDS);
        logger.info("获取锁成功，Redis Lock key :{}", key);
        return true;
    }
 
    /**
     * 释放锁，建议放在 finally里面
     *
     * @param lockName 锁名称
     */
    public static void unlock(String lockName) {
        String key = getLockKey(lockName);
        //获取所对象
        RLock lock = redisson.getLock(key);
        // 释放锁,判断要解锁的key是否已被锁定并且是否被当前线程保持
        if (lock.isLocked() && lock.isHeldByCurrentThread()) {
            lock.unlock();
            logger.info("释放Redis锁成功，key:{}", key);
        }
    }
 
    /**
     * 对锁的key添加系统标识前缀
     *
     * @return
     */
    private static String getLockKey(String key) {
        return RedissonUtil.SYS_LOCK_FLAG   RedissonUtil.KEY_SPLIT   key;
    }
 
}

使用

    @Test
    public void redissonLock(){
        String key = "zhh11";
        long expiresTime = 10;
        // 加锁
        if (RedissonUtil.getLock(key,expiresTime)){
            try{
                Thread.sleep(3000L);
                // 业务代码
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                // 释放锁
                RedissonUtil.unlock(key);
                // 捕获异常之后需要 手动回滚事务
                //    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }else {
            System.out.println("未获取到锁");
        }
    }

这篇好文章是转载于：学新通技术网