import cn.rojao.util.StringUtils;

import org.redisson.Redisson;

import org.redisson.api.RedissonClient;

import org.redisson.config.Config;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;
 

/**

 * redisson配置

 */

@Configuration

public class RedissonConfig {

	@Value("${spring.redis.clusters}")

	private  String cluster;

	@Value("${spring.redis.password}")

	private String password;

 

	@Bean

	public RedissonClient getRedisson(){

		String[] nodes = cluster.split(",");

		//redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加

		for(int i=0;i<nodes.length;i++){

			nodes[i] = "redis://"+nodes[i];

		}

		RedissonClient redisson = null;

		Config config = new Config();

		config.useClusterServers() //这是用的集群server

				.setScanInterval(2000) //设置集群状态扫描时间

				.addNodeAddress(nodes).setRetryAttempts(5).setTimeout(10000);

 

		if(StringUtils.isNotEmpty(password)){

			config.useClusterServers().setPassword(password);

		}

		redisson = Redisson.create(config);

 

		//可通过打印redisson.getConfig().toJSON().toString()来检测是否配置成功

//		try {

//			System.out.println(redisson.getConfig().toJSON().toString());

//		} catch (IOException e) {

//			e.printStackTrace();

//		}

		return redisson;

	}
}

package com.example.springboot_redis.redis;

import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * 分布式Redis锁
 *
 * @author qp
 * @date 2019/7/19 15:21
 */
@Slf4j
@Component
public class DistributedRedisLock {

    @Autowired
    private RedissonClient redissonClient;

    // 加锁
    public Boolean lock(String lockName) {
        try {
            if (redissonClient == null) {
                log.info("DistributedRedisLock redissonClient is null");
                return false;
            }

            RLock lock = redissonClient.getLock(lockName);
            // 锁10秒后自动释放，防止死锁
            lock.lock(10, TimeUnit.SECONDS);

            log.info("Thread [{}] DistributedRedisLock lock [{}] success", Thread.currentThread().getName(), lockName);
            // 加锁成功
            return true;
        } catch (Exception e) {
            log.error("DistributedRedisLock lock [{}] Exception:", lockName, e);
            return false;
        }
    }

    // 释放锁
    public Boolean unlock(String lockName) {
        try {
            if (redissonClient == null) {
                log.info("DistributedRedisLock redissonClient is null");
                return false;
            }

            RLock lock = redissonClient.getLock(lockName);
            lock.unlock();
            log.info("Thread [{}] DistributedRedisLock unlock [{}] success", Thread.currentThread().getName(), lockName);
            // 释放锁成功
            return true;
        } catch (Exception e) {
            log.error("DistributedRedisLock unlock [{}] Exception:", lockName, e);
            return false;
        }
    }

}

package com.example.springboot_redis.contoller;

import com.example.springboot_redis.redis.DistributedRedisLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 分布式Redis锁测试controller
 *
 * @author qp
 * @date 2019/7/19 17:30
 */
@RestController
@RequestMapping("/lock")
public class LockTestController {

    @Autowired
    private DistributedRedisLock distributedRedisLock;

    // 测试分布式锁
    @GetMapping("/testLock")
    public void testLock() {
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Boolean lockFlag = distributedRedisLock.lock("LOCK");
                }
            }).start();
        }
    }

}