springboot 整合redisson

整合代码已经过测试

1、pom

 <!-- redisson -->
 <dependency>
     <groupId>org.redisson</groupId>
     <artifactId>redisson</artifactId>
     <version>3.5.7</version>
 </dependency>

2、properties

# redis
spring.redis.host=
spring.redis.port=
spring.redis.password=
spring.redis.jedis.pool.max-active=500
spring.redis.jedis.pool.max-idle=1000
spring.redis.jedis.pool.max-wait=6000ms
spring.redis.jedis.pool.min-idle=4

3、添加redisson配置类、这里是单机模式

　

 package com.example.common.config;

 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 配置类
  * Created on 2018/6/19
  */
 @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 getRedisson(){

         Config config = new Config();
         config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
         //添加主从配置
 //        config.useMasterSlaveServers().setMasterAddress("").setPassword("").addSlaveAddress(new String[]{"",""});

         return Redisson.create(config);
     }

 }

4、加入redisson 操作类（redissonService）

 package com.example.common.base;

 import org.redisson.api.*;
 import org.redisson.config.Config;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;

 import java.io.IOException;

 /**
  * redisson操作类
  */
 @Service("redissonService")
 public class RedissonService {

     @Autowired
     private RedissonClient redissonClient;

     public void getRedissonClient() throws IOException {
         Config config = redissonClient.getConfig();
         System.out.println(config.toJSON().toString());
     }

     /**`
      * 获取字符串对象
      *
      * @param objectName
      * @return
      */
     public <T> RBucket<T> getRBucket(String objectName) {
         RBucket<T> bucket = redissonClient.getBucket(objectName);
         return bucket;
     }

     /**
      * 获取Map对象
      *
      * @param objectName
      * @return
      */
     public <K, V> RMap<K, V> getRMap(String objectName) {
         RMap<K, V> map = redissonClient.getMap(objectName);
         return map;
     }

     /**
      * 获取有序集合
      *
      * @param objectName
      * @return
      */
     public <V> RSortedSet<V> getRSortedSet(String objectName) {
         RSortedSet<V> sortedSet = redissonClient.getSortedSet(objectName);
         return sortedSet;
     }

     /**
      * 获取集合
      *
      * @param objectName
      * @return
      */
     public <V> RSet<V> getRSet(String objectName) {
         RSet<V> rSet = redissonClient.getSet(objectName);
         return rSet;
     }

     /**
      * 获取列表
      *
      * @param objectName
      * @return
      */
     public <V> RList<V> getRList(String objectName) {
         RList<V> rList = redissonClient.getList(objectName);
         return rList;
     }

     /**
      * 获取队列
      *
      * @param objectName
      * @return
      */
     public <V> RQueue<V> getRQueue(String objectName) {
         RQueue<V> rQueue = redissonClient.getQueue(objectName);
         return rQueue;
     }

     /**
      * 获取双端队列
      *
      * @param objectName
      * @return
      */
     public <V> RDeque<V> getRDeque(String objectName) {
         RDeque<V> rDeque = redissonClient.getDeque(objectName);
         return rDeque;
     }

     /**
      * 获取锁
      *
      * @param objectName
      * @return
      */
     public RLock getRLock(String objectName) {
         RLock rLock = redissonClient.getLock(objectName);
         return rLock;
     }

     /**
      * 获取读取锁
      *
      * @param objectName
      * @return
      */
     public RReadWriteLock getRWLock(String objectName) {
         RReadWriteLock rwlock = redissonClient.getReadWriteLock(objectName);
         return rwlock;
     }

     /**
      * 获取原子数
      *
      * @param objectName
      * @return
      */
     public RAtomicLong getRAtomicLong(String objectName) {
         RAtomicLong rAtomicLong = redissonClient.getAtomicLong(objectName);
         return rAtomicLong;
     }

     /**
      * 获取记数锁
      *
      * @param objectName
      * @return
      */
     public RCountDownLatch getRCountDownLatch(String objectName) {
         RCountDownLatch rCountDownLatch = redissonClient.getCountDownLatch(objectName);
         return rCountDownLatch;
     }

     /**
      * 获取消息的Topic
      *
      * @param objectName
      * @return
      */
     public <M> RTopic<M> getRTopic(String objectName) {
         RTopic<M> rTopic = redissonClient.getTopic(objectName);
         return rTopic;
     }
 }

5.、测试代码

package com.example.test;

import com.example.common.base.RedissonService;
import org.redisson.api.RLock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.concurrent.TimeUnit;

@Controller
@RequestMapping("test")
public class TestService {

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

    @Autowired
    private RedissonService redissonService;

    @RequestMapping(value = "/test")
    @ResponseBody
    public void test(String recordId) {

        RLock lock = redissonService.getRLock(recordId);
        try {
            boolean bs = lock.tryLock(5, 6, TimeUnit.SECONDS);
            if (bs) {
                // 业务代码
                log.info("进入业务代码: " + recordId);

                lock.unlock();
            } else {
                Thread.sleep(300);
            }
        } catch (Exception e) {
            log.error("", e);
            lock.unlock();
        }
    }

}