精华内容
下载资源
问答
  • springboot 整合 redisson

    千次阅读 2019-06-11 23:05:37
    现在记录一下 springboot 整合 redisson 的过程。 1. pom 依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> &...

    在之前的文章中有提到 redisson ,基于 redis 的分布式锁。现在记录一下 springboot 整合 redisson 的过程。

    1. pom 依赖

    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    			<version>2.9.0</version>
    		</dependency>
    		<dependency>
    			<groupId>org.redisson</groupId>
    			<artifactId>redisson</artifactId>
    			<version>3.5.0</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter</artifactId>
    		</dependency>
    		<!--Spring Boot -->
    		<!--支持 Web 应用开发,包含 Tomcat 和 spring-mvc。 -->
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    

    redisson 3.5.0 和 redisson 2.x 版本有区别,具体得可以去看官方文档,这里使用的 3.5.0

    2. 构建 Springboot Java 配置类

    配置类使用了 @Profile 注解,因为在实际的应用,可能你本地环境是单机模式,测试或者生产环境是集群模式。
    Redisson 还支持主从模式、哨兵模式等,根据自己的需求去进行配置。

    @Configuration
    public class RedissonManagerConfig {
        @Value("${spring.redis.urls}")
        private String urls;
        @Value("${spring.redis.password}")
        private String password;
    
        @Profile("local")
        @Bean(name = "redissonClient")
        public RedissonClient redissonClientSingle() throws IOException {
            RedissonClient redisson = null;
            Config config = new Config();
            config.useSingleServer().setAddress("redis://" + urls);
            redisson = Redisson.create(config);
            // 可通过打印redisson.getConfig().toJSON().toString()来检测是否配置成功
            return redisson;
        }
    
        @Profile("pro")
        @Bean(name = "redissonClient")
        public RedissonClient redissonClientCluster() throws IOException {
            String[] nodes = urls.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).setPassword(password);
            redisson = Redisson.create(config);
            // 可通过打印redisson.getConfig().toJSON().toString()来检测是否配置成功
            return redisson;
        }
    }
    

    3. 具体实现类 RedissonDistributedLocker

    首先定义一个接口,然后对其进行实现。

    public interface AbstractDistributedLocker {
    
        RLock lock(String lockKey);
    
        RLock lock(String lockKey, long timeout);
    
        RLock lock(String lockKey, TimeUnit unit, long timeout);
    
        boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime);
    
        void unlock(String lockKey);
    
        void unlock(RLock lock);
    }
    
    @Component
    public class RedissonDistributedLocker implements AbstractDistributedLocker {
    
        @Autowired
        private RedissonClient redissonClient; // RedissonClient已经由配置类生成,这里自动装配即可
    
        /**
         * lock(), 拿不到lock就不罢休,不然线程就一直block
         */
        @Override
        public RLock lock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock();
            return lock;
        }
    
        /**
         * leaseTime为加锁时间,单位为秒
         */
        @Override
        public RLock lock(String lockKey, long leaseTime) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(leaseTime, TimeUnit.SECONDS);
            return lock;
        }
    
        /**
         * timeout为加锁时间,时间单位由unit确定
         */
        @Override
        public RLock lock(String lockKey, TimeUnit unit, long timeout) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(timeout, unit);
            return lock;
        }
    
        /**
         * tryLock(),马上返回,拿到lock就返回true,不然返回false。
         * 带时间限制的tryLock(),拿不到lock,就等一段时间,超时返回false.
         */
        @Override
        public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
            RLock lock = redissonClient.getLock(lockKey);
            try {
                return lock.tryLock(waitTime, leaseTime, unit);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 释放 key 的锁
         */
        @Override
        public void unlock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.unlock();
        }
    
        /**
         * 释放锁
         */
        @Override
        public void unlock(RLock lock) {
            lock.unlock();
        }
    
    }
    

    4. Controller 类测试

    最后就可以在你想用加锁的地方进行加锁处理了。

    @Controller
    @RequestMapping(value = "/")
    public class HelloController {
    
        @Autowired
        RedissonDistributedLocker redissonDistributedLocker;
    
        @RequestMapping(value = "hello2", method = RequestMethod.GET)
        @ResponseBody
        public String hello2() throws InterruptedException {
            int num = count1.incrementAndGet();
            String lock = "lock_key";
            try {
                if (redissonDistributedLocker.tryLock(lock, TimeUnit.SECONDS, 5L, 10L)) {
                    // 处理逻辑
                    redisUtil.incr("test_num1");
                    // Thread.sleep(1000);
                    System.out.println("TEST1===========第 " + num + " 次请求===================" + redisUtil.get("test_num1"));
                }
            } catch (Exception e) {
                e.getStackTrace();
            } finally {
                redissonDistributedLocker.unlock(lock);
            }
            return "success";
        }
    
    }
    
    
    展开全文
  • springboot整合redisson

    千次阅读 2019-12-12 15:12:10
    01 搭建redis服务 我是在自己的云服务通过docker搭建了一个单机的redis服务 docker run -d --rm --name redis5 -p 6379:6379 redis ...1.在pom.xml文件导入redisson依赖 <dependency> <groupId>org.red...

    01 搭建redis服务

    我是在自己的云服务通过docker搭建了一个单机的redis服务

    docker run -d --rm --name redis5 -p 6379:6379 redis --requirepass "123456"
    

    02 创建应用

    1.在pom.xml文件导入redisson依赖

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

    2.配置连接redis的信息

    我们有两种方式配置连接redis,其它配置方式参考官方文档
    第1种,通过appliancation.properties文件去配置

    spring.redis.host=127.0.0.1
    spring.redis.port=6379
    spring.redis.password=123456
    

    第2种,通过@bean的方式配置

    import org.redisson.Redisson;
    import org.redisson.api.RedissonClient;
    import org.redisson.config.Config;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * @author 594781919@qq.com
     * @date 2019-11-26
     **/
    @Configuration
    public class RedissonConfig {
        @Bean
        public RedissonClient redissonClient() {
            Config config = new Config();
            config.useSingleServer()
                    .setAddress("redis://127.0.0.1:6379")
                    .setPassword("123456");
            return Redisson.create(config);
        }
    }
    

    03 现在我们就可以使用redisson客户端

    1.缓存数据

    下面我们主要测试了redis的两种数据结构,分别是stringlist,其它数据结构的使用方式类似。大家可以参考官方文档

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class RedissonTest {
    
        @Resource
        private RedissonClient redissonClient;
    
        @Test
        public void testBucket() {
            RBucket<Object> bucket = redissonClient.getBucket("name", StringCodec.INSTANCE);
            Object o = bucket.get();
            System.out.println(o);
        }
    
        @Test
        public void testList() {
            RList<String> interests = redissonClient.getList("interests");
            interests.add("篮球");
            interests.add("爬山");
            interests.add("编程");
        }
    }
    

    2.分布式锁

    官方文档提供了很全的使用方式。

    下面我就以简单的分布式锁的使用作为测试。

    代码还是很简单,第1步,获取锁;第2步,加锁;第3步,释放锁。

    测试时,我们可以起一个服务,然后同时访问"/lock1"和"/lock2"或者起两个服务,一个服务访问"/lock1",另一个服务访问"/lock2"。

    通过控制台的打印我们就能发现分布式锁达到我们想要的效果。

        @Resource
        private RedissonClient redissonClient;
    
        @GetMapping("/lock1")
        public String lock1() {
        	// 1.获取分布式锁
            RLock lock = redissonClient.getLock("my:lock");
            // 2.进行加锁操作
            lock.lock();
            System.out.println(LocalDateTime.now() + " lock1 locked");
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
                Thread.currentThread().interrupt();
            }
            // 3.释放锁资源
            lock.unlock();
            System.out.println(LocalDateTime.now() + "lock1 unlocked");
            return "lock1";
        }
    
        @GetMapping("/lock2")
        public String lock2() {
            RLock lock = redissonClient.getLock("my:lock");
            lock.lock();
            System.out.println(LocalDateTime.now() + " lock2 locked");
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
            lock.unlock();
            System.out.println(LocalDateTime.now() + " lock2 unlocked");
            return "lock2";
        }
    

    03 总结

    Redisson底层采用的是Netty 框架,支持异步的操作方式。
    API很全,对redis的操作基本都能满足我们的开发需求。

    展开全文
  • springboot 整合redisson

    2018-06-19 21:48:00
    整合代码已经过测试 1、pom 1 <!-- redisson --> 2 <dependency> 3 <groupId>org.redisson</groupId> 4 <artifactId>redisson</artifactId> 5 <version>3.5.7&.....

    整合代码已经过测试

    1、pom

    1 <!-- redisson -->
    2 <dependency>
    3     <groupId>org.redisson</groupId>
    4     <artifactId>redisson</artifactId>
    5     <version>3.5.7</version>
    6 </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配置类、这里是单机模式

     

     1 package com.example.common.config;
     2 
     3 import org.redisson.Redisson;
     4 import org.redisson.api.RedissonClient;
     5 import org.redisson.config.Config;
     6 import org.springframework.beans.factory.annotation.Value;
     7 import org.springframework.context.annotation.Bean;
     8 import org.springframework.context.annotation.Configuration;
     9 
    10 /**
    11  * redisson 配置类
    12  * Created on 2018/6/19
    13  */
    14 @Configuration
    15 public class RedissonConfig {
    16 
    17     @Value("${spring.redis.host}")
    18     private String host;
    19 
    20     @Value("${spring.redis.port}")
    21     private String port;
    22 
    23     @Value("${spring.redis.password}")
    24     private String password;
    25 
    26     @Bean
    27     public RedissonClient getRedisson(){
    28 
    29         Config config = new Config();
    30         config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
    31         //添加主从配置
    32 //        config.useMasterSlaveServers().setMasterAddress("").setPassword("").addSlaveAddress(new String[]{"",""});
    33 
    34         return Redisson.create(config);
    35     }
    36 
    37 }

    4、加入redisson 操作类(redissonService)

      1 package com.example.common.base;
      2 
      3 import org.redisson.api.*;
      4 import org.redisson.config.Config;
      5 import org.springframework.beans.factory.annotation.Autowired;
      6 import org.springframework.stereotype.Service;
      7 
      8 import java.io.IOException;
      9 
     10 /**
     11  * redisson操作类
     12  */
     13 @Service("redissonService")
     14 public class RedissonService {
     15 
     16     @Autowired
     17     private RedissonClient redissonClient;
     18 
     19     public void getRedissonClient() throws IOException {
     20         Config config = redissonClient.getConfig();
     21         System.out.println(config.toJSON().toString());
     22     }
     23 
     24     /**`
     25      * 获取字符串对象
     26      *
     27      * @param objectName
     28      * @return
     29      */
     30     public <T> RBucket<T> getRBucket(String objectName) {
     31         RBucket<T> bucket = redissonClient.getBucket(objectName);
     32         return bucket;
     33     }
     34 
     35     /**
     36      * 获取Map对象
     37      *
     38      * @param objectName
     39      * @return
     40      */
     41     public <K, V> RMap<K, V> getRMap(String objectName) {
     42         RMap<K, V> map = redissonClient.getMap(objectName);
     43         return map;
     44     }
     45 
     46     /**
     47      * 获取有序集合
     48      *
     49      * @param objectName
     50      * @return
     51      */
     52     public <V> RSortedSet<V> getRSortedSet(String objectName) {
     53         RSortedSet<V> sortedSet = redissonClient.getSortedSet(objectName);
     54         return sortedSet;
     55     }
     56 
     57     /**
     58      * 获取集合
     59      *
     60      * @param objectName
     61      * @return
     62      */
     63     public <V> RSet<V> getRSet(String objectName) {
     64         RSet<V> rSet = redissonClient.getSet(objectName);
     65         return rSet;
     66     }
     67 
     68     /**
     69      * 获取列表
     70      *
     71      * @param objectName
     72      * @return
     73      */
     74     public <V> RList<V> getRList(String objectName) {
     75         RList<V> rList = redissonClient.getList(objectName);
     76         return rList;
     77     }
     78 
     79     /**
     80      * 获取队列
     81      *
     82      * @param objectName
     83      * @return
     84      */
     85     public <V> RQueue<V> getRQueue(String objectName) {
     86         RQueue<V> rQueue = redissonClient.getQueue(objectName);
     87         return rQueue;
     88     }
     89 
     90     /**
     91      * 获取双端队列
     92      *
     93      * @param objectName
     94      * @return
     95      */
     96     public <V> RDeque<V> getRDeque(String objectName) {
     97         RDeque<V> rDeque = redissonClient.getDeque(objectName);
     98         return rDeque;
     99     }
    100 
    101 
    102     /**
    103      * 获取锁
    104      *
    105      * @param objectName
    106      * @return
    107      */
    108     public RLock getRLock(String objectName) {
    109         RLock rLock = redissonClient.getLock(objectName);
    110         return rLock;
    111     }
    112 
    113     /**
    114      * 获取读取锁
    115      *
    116      * @param objectName
    117      * @return
    118      */
    119     public RReadWriteLock getRWLock(String objectName) {
    120         RReadWriteLock rwlock = redissonClient.getReadWriteLock(objectName);
    121         return rwlock;
    122     }
    123 
    124     /**
    125      * 获取原子数
    126      *
    127      * @param objectName
    128      * @return
    129      */
    130     public RAtomicLong getRAtomicLong(String objectName) {
    131         RAtomicLong rAtomicLong = redissonClient.getAtomicLong(objectName);
    132         return rAtomicLong;
    133     }
    134 
    135     /**
    136      * 获取记数锁
    137      *
    138      * @param objectName
    139      * @return
    140      */
    141     public RCountDownLatch getRCountDownLatch(String objectName) {
    142         RCountDownLatch rCountDownLatch = redissonClient.getCountDownLatch(objectName);
    143         return rCountDownLatch;
    144     }
    145 
    146     /**
    147      * 获取消息的Topic
    148      *
    149      * @param objectName
    150      * @return
    151      */
    152     public <M> RTopic<M> getRTopic(String objectName) {
    153         RTopic<M> rTopic = redissonClient.getTopic(objectName);
    154         return rTopic;
    155     }
    156 }
    View Code

    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();
            }
        }
    
    }

     

    转载于:https://www.cnblogs.com/milicool/p/9201271.html

    展开全文
  • 之前写了一篇关于SpringBoot整合Redisson的单机版,这篇是集群版。关于如何在Linux搭建Redis集群,可以参考这篇文章:redis集群搭建一、导入Maven依赖org.redissonredisson-spring-boot-starter3.11.4org.spring...

    之前写了一篇关于SpringBoot整合Redisson的单机版,这篇是集群版。

    关于如何在Linux搭建Redis集群,可以参考这篇文章:

    redis集群搭建

    一、导入Maven依赖

    org.redisson

    redisson-spring-boot-starter

    3.11.4

    org.springframework.boot

    spring-boot-starter-web

    org.springframework.boot

    spring-boot-starter-webflux

    二、核心配置文件

    redis:

    cluster:

    nodes: "192.168.52.1:7000,192.168.52.1:7001,192.168.52.1:7002,192.168.52.1:7003,192.168.52.1:7004,192.168.52.1:7005"

    password: 123456

    lettuce:

    pool:

    max-active: 1500

    max-wait: 5000

    max-idle: 500

    min-idle: 100

    shutdown-timeout: 1000

    timeout: 60000

    三、核心代码配置

    RedisConfigProperties.java

    import org.springframework.boot.context.properties.ConfigurationProperties;

    import org.springframework.stereotype.Component;

    import java.util.List;

    @Component

    @ConfigurationProperties(prefix = "spring.redis")

    public class RedisConfigProperties {

    private String password;

    private cluster cluster;

    public static class cluster {

    private List nodes;

    public List getNodes() {

    return nodes;

    }

    public void setNodes(List nodes) {

    this.nodes = nodes;

    }

    }

    public String getPassword() {

    return password;

    }

    public void setPassword(String password) {

    this.password = password;

    }

    public RedisConfigProperties.cluster getCluster() {

    return cluster;

    }

    public void setCluster(RedisConfigProperties.cluster cluster) {

    this.cluster = cluster;

    }

    }

    RedissonConfig.java

    import org.redisson.Redisson;

    import org.redisson.config.ClusterServersConfig;

    import org.redisson.config.Config;

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

    import org.springframework.context.annotation.Bean;

    import org.springframework.context.annotation.Configuration;

    import java.util.ArrayList;

    import java.util.List;

    @Configuration

    public class RedissonConfig {

    @Autowired

    private RedisConfigProperties redisConfigProperties;

    //添加redisson的bean

    @Bean

    public Redisson redisson() {

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

    List clusterNodes = new ArrayList<>();

    for (int i = 0; i < redisConfigProperties.getCluster().getNodes().size(); i++) {

    clusterNodes.add("redis://" + redisConfigProperties.getCluster().getNodes().get(i));

    }

    Config config = new Config();

    ClusterServersConfig clusterServersConfig = config.useClusterServers()

    .addNodeAddress(clusterNodes.toArray(new String[clusterNodes.size()]));

    clusterServersConfig.setPassword(redisConfigProperties.getPassword());//设置密码

    return (Redisson) Redisson.create(config);

    }

    }

    四、启动项目,只要不报错就表示配置集群成功,同时启动过程中也会显示连接的各个redis

    展开全文
  • SpringBoot整合redisson实现分布式锁

    千次阅读 2020-06-13 20:00:00
    通过 SpringBoot 整合 redisson 来实现分布式锁,并结合 demo 测试结果。 首先看下大佬总结的图 来源:https://www.cnblogs.com/qdhxhz/p/11046905.html 正文 增加依赖 <!--redis--> <dependency&...
  • SpringBoot整合Redisson操作单节点Redis 上文使用Redisson对单节点的redis进行操作,但是在对于集群操作时需要不同的配置以及集群的搭建,本文就一起来探索使用docker的redis集群的搭建。 搭建集群Redis 本文...
  • springboot整合redisson使用redis集群做分布式锁说明maven依赖Redisson配置yml配置client配置使用最后 说明 springboot集群部署时,定时任务存在多份,所以需要一个分布式锁来进行竞争,在zookeeper和redis之间选择...
  • SpringBoot整合redisson分布式锁

    万次阅读 2019-05-08 23:11:50
    一般我们在生产系统中,可以用Redisson框架提供的这个类库来基于redis进行分布式锁的加锁与释放锁 有了上面的概念,下面来具体说一下springboot整合redisson实现分布式锁的代码整合, 1、pom文件需要添加如下依赖,...
  • springboot整合redisson实现分布式锁

    万次阅读 2020-05-24 17:01:10
    1、为什么要用分布式锁? 在一些高并发的场景中,比如秒杀,...这个时候就需要用分布式锁了实现分布式锁的方式很多,我们今天就用redis的分布式锁,redisson也是官方比较推荐的。当然我们其实也可以自己用redis的setn
  • Springboot整合Redisson

    2021-05-05 21:07:07
    Redisson前言一、依赖二、配置文件三、锁的使用读写锁信号量闭锁四、分布式秒杀 前言 Redisson是一个在Redis的基础上实现的Java驻内存数据网格 一、依赖 <dependency> <groupId>org.redisson</...
  • 文章中使用的是spring-boot整合redisson,对单节点的redis进行锁操作 1.添加Redisson <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</...
  • 该篇是基于springboot 项目整合 Redisson 实现对redis的操作。 内容: 1.使用RedissonClient对一些集合的常规操作,数据查询,存储等; 2.以AOP方式实现分布式锁 正文 第一步: pom.xml 添加核心依赖包: ...
  • org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.12.0</version> </dependency> 2)、配置redisson 在config里创建文件:MyRedissonCon

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 205
精华内容 82
关键字:

springboot整合redisson

redis 订阅
spring 订阅