精华内容
下载资源
问答
  • 引入redisson依赖

    引入redisson依赖

     

    展开全文
  • springboot整合redisson

    千次阅读 2018-09-29 14:37:07
    原因:启动redis的方式不对,没有走redis.config,本文最下边会说明。...1、添加redisson依赖包 <!--redission 依赖包--> <dependency> <groupId>org.rediss...

    遇到的最大问题:redisson配置了password之后依然显示的是未配置密码

    原因:启动redis的方式不对,没有走redis.config,本文最下边会说明。

    整合步骤

    1、添加redisson依赖包

    <!--redission 依赖包-->
            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>3.5.4</version>
                <exclusions>
                    <exclusion>
                        <artifactId>cache-api</artifactId>
                        <groupId>javax.cache</groupId>
                    </exclusion>
                </exclusions>
            </dependency>

    2、主项目中添加redisson相关bean

    @Autowired
        private RedisProperties redisProperties;
    
        @Bean
        public RedissonClient redissonClient() {
            Config config = new Config();
    
            SingleServerConfig singleServerConfig = config.useSingleServer();
            String schema = redisProperties.isSsl() ? "rediss://" : "redis://";
            singleServerConfig.setAddress(schema + redisProperties.getHost() + ":" + redisProperties.getPort());
            singleServerConfig.setDatabase(redisProperties.getDatabase());
            if (redisProperties.getPassword() != null) {
                singleServerConfig.setPassword(redisProperties.getPassword());
            }
    
            // 其他配置项都先采用默认值
            return Redisson.create(config);
        }

    3、service层可直接编写redisson操作缓存

    public void testRedisson(){
            RBucket<String > bucket = redissonClient.getBucket(redisConfig.addPrefix("CarryJey"));
            System.out.println(bucket.getName());
        }

    4、启动redis服务方式(一定要一致)

    (1)最简单的就是不指定配置启动$:./redis-server &

    这样就不要配置spring.redis.password=了。

    (2)安全起见,配置密码

    redis按指定配置文件启动

    项目redis密码也要配置


    注意点:使用redisson需要将自己本地的redis配置文件redis.config 将requirepass foobared注释打开,(foobared即为密码)

    然后重启redis:

    关闭:  redis-cli -h 127.0.0.1 -p 6379 shutdown

    启动:1)、指定配置文件 $: ./redis-server /usr/local/redis.conf &

              2)、不指定配置:$: ./redis-server &

              不指定配置文件启动时采用默认配置,无密码 redis通过属性requirepass 设置访问密码,但没有设置该属性时,客户端向服务端发送AUTH请求,服务端就好返回异常:ERR Client sent AUTH, but no password is set

     


    解决问题相关资料:

    1、ERR Client sent AUTH, but no password is set

    https://blog.csdn.net/iw1210/article/details/72428824

    2、启动、停止、重启redis服务器

    https://blog.csdn.net/sinat_29330337/article/details/77740368

     

     

    展开全文
  • 1.添加redisson依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.5.7</version> </dependency> 2.添加...

    1.添加redisson依赖

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

    2.创建CacheManager使用redisson的配置文件类

    import org.redisson.Redisson;
    import org.redisson.api.RedissonClient;
    import org.redisson.config.Config;
    import org.redisson.spring.cache.CacheConfig;
    import org.redisson.spring.cache.RedissonSpringCacheManager;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 2 * @Author: ZhangShuai
     * 3 * @Date: 2020/6/24 10:19
     * 4 Redisson提供了将Redis无缝整合到Spring框架的能力。
     *   Redisson依照Spring Cache标准提供了基于Redis的Spring缓存实现。
     *   每个缓存(Cache)实例都提供了了两个重要的可配置参数:过期时间(ttl)和最长空闲时间(maxIdleTime),
     *   如果这两个参数都未指定或值为0,那么实例管理的数据将永久保存。
     */
    @Configuration
    @ComponentScan
    @EnableCaching
    public class RedisConfigManager {
    
    
        @Bean(destroyMethod = "shutdown")
        RedissonClient redisson() throws IOException {
            Config config = new Config();
            //这里使用你的redis地址 以及redis的密码 和redis要存储的数据库
            config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("123").setDatabase(0);
            return Redisson.create(config);
        }
    
        @Bean
        CacheManager cacheManager(RedissonClient redissonClient) {
            Map<String, CacheConfig> config = new HashMap<String, CacheConfig>();
            // 创建一个名称为"testMap"的缓存,过期时间ttl为24分钟,同时最长空闲时maxIdleTime为12分钟。
            config.put("testMap", new CacheConfig(24 * 60 * 1000, 12 * 60 * 1000));
            return new RedissonSpringCacheManager(redissonClient, config);
        }
    
    
    }
    

    3.使用Cacheable等注解

    	@Cacheable(value="users", key="#id")
    	public User find(Integer id) {
    		return null;
    	}
    

    4.使用SpringBoot连接redis

    4.1 创建redis配置类,配置redis要连接的机器

    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;
    
    /**
     * 2 * @Author: ZhangShuai
     * 3 * @Date: 2020/6/17 10:11
     * 4  创建redis配置类,配置redis要连接的机器
     */
    @Configuration
    public class RedisConfig {
        @Bean
        public RedissonClient redissonClient() {
            //配置当前redis要连接的信息 redis://127.0.0.1:6379
            Config config = new Config();
            config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("123").setDatabase(0);
            //config.useSingleServer().setAddress("redis://"+address+":"+port).setPassword(password).setDatabase(database);
            return Redisson.create(config);
        }
    
    
    }
    

    4.2 :创建redis中常用的方法

    import org.redisson.api.RBucket;
    import org.redisson.api.RCountDownLatch;
    import org.redisson.api.RReadWriteLock;
    import org.redisson.api.RedissonClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.util.StringUtils;
    
    import java.util.concurrent.TimeUnit;
    /**
     * 2 * @Author: ZhangShuai
     * 3 * @Date: 2020/6/17 10:11
     * 4  创建redis中常用的方法
     */
    @Component
    public class RedisMethod {
    
        @Autowired
        private RedissonClient redissonClient;
    
        //获取一个 key
        public String getString(String key) {
            //RExpirable RExpirable.remainTimeToLive(), RExpirable.remainTimeToLiveAsync(), RExpirableReactive.remainTimeToLive();
            RBucket<Object> result = this.redissonClient.getBucket(key);
            if (StringUtils.isEmpty(result.get())) {
                return null;
            }
            return result.get().toString();
        }
    
        //获取一个key的过期时间
        public long getTime(String key) {
            long result = redissonClient.getPermitExpirableSemaphore(key).remainTimeToLive();
            ;
            return result;
        }
    
    
        //设置一个 key vlaue的值
        public void setString(String key, Object value) {
            RBucket<Object> result = this.redissonClient.getBucket(key);
            if (!result.isExists()) {
                result.set(value);
            }
        }
    
    
        //设置key的过期时间 time为秒单位
        public void setStringTime(String key, Object value, Long time) {
            RBucket<Object> result = this.redissonClient.getBucket(key);
            if (!result.isExists()) {
                result.set(value, time, TimeUnit.SECONDS);
            }
        }
    
        //判断这个key是否存在
        public boolean hasString(String key) {
            RBucket<Object> result = this.redissonClient.getBucket(key);
            if (result.isExists()) {
                return true;
            } else {
                return false;
            }
        }
    
        //删除一个key
        public boolean delString(String key) {
            RBucket<Object> result = this.redissonClient.getBucket(key);
            if (result.delete()) {
                return true;
            } else {
                return false;
            }
        }
    
        public long incr(String key, long delta) {
            return this.redissonClient.getAtomicLong(key).addAndGet(delta);
        }
        // -----------------------------------------------------------------------
    
        public void lock() {
            RCountDownLatch countDown = redissonClient.getCountDownLatch("aa");
            countDown.trySetCount(1);
            try {
                countDown.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            RCountDownLatch latch = redissonClient.getCountDownLatch("countDownLatchName");
            latch.countDown();
            RReadWriteLock rwlock = redissonClient.getReadWriteLock("lockName");
            rwlock.readLock().lock();
            rwlock.writeLock().lock();
            rwlock.readLock().lock(10, TimeUnit.SECONDS);
            rwlock.writeLock().lock(10, TimeUnit.SECONDS);
            try {
                boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
                boolean res1 = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    
    }
    

    5.使用定义的方法获取redis的值

    注入 RedisMethod 使用里面的方法 传入相对的参数 即可
    在这里插入图片描述

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

    2021-01-18 15:59:45
    1.引入redisson依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.5.4</version> </dependency> 2...

    1.引入redisson依赖

    	<dependency>
    			<groupId>org.redisson</groupId>
    			<artifactId>redisson</artifactId>
    			<version>3.5.4</version>
       </dependency>

    2.自定义注解实现redisson分布式锁

    /**
     * @Description: 基于注解的分布式式锁
     * @author lz
     */
    @Documented
    @Inherited
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface DistributedLock {
    
        /**
         * 锁的名称
         */
        String value() default "redisson";
    
        /**
         * 锁的有效时间
         */
        int leaseTime() default 10;
    }
    

    3. Redisson分布式锁注解解析器

    /**
     * @Description: Redisson分布式锁注解解析器
     * @author lz
     */
    @Aspect
    @Component
    @Slf4j
    public class DistributedLockHandler {
    
        @Autowired
        RedissonLock redissonLock;
    
    
        @Around("@annotation(distributedLock)")
        public void around(ProceedingJoinPoint joinPoint, DistributedLock distributedLock) {
            log.info("[开始]执行RedisLock环绕通知,获取Redis分布式锁开始");
            //获取锁名称
            String lockName = distributedLock.value();
            //获取超时时间,默认10秒
            int leaseTime = distributedLock.leaseTime();
            redissonLock.lock(lockName, leaseTime);
            try {
                log.info("获取Redis分布式锁[成功],加锁完成,开始执行业务逻辑...");
                joinPoint.proceed();
            } catch (Throwable throwable) {
                log.error("获取Redis分布式锁[异常],加锁失败", throwable);
                throwable.printStackTrace();
            } finally {
                //如果该线程还持有该锁,那么释放该锁。如果该线程不持有该锁,说明该线程的锁已到过期时间,自动释放锁
                if (redissonLock.isHeldByCurrentThread(lockName)) {
                    redissonLock.unlock(lockName);
                }
            }
            log.info("释放Redis分布式锁[成功],解锁完成,结束业务逻辑...");
        }
    }
    

    4.针对源码Redisson进行一层封装

    /**
     * @Description: 针对源码Redisson进行一层封装
     * @author lz
     */
    @Slf4j
    public class RedissonLock {
    
    
      private Redisson redisson;
    
    
        public RedissonLock(RedissonManager redissonManager) {
            this.redissonManager = redissonManager;
            this.redisson = redissonManager.getRedisson();
        }
    
        public RedissonLock() {}
    
        /**
         * 加锁操作 (设置锁的有效时间)
         * @param lockName 锁名称
         * @param leaseTime  锁有效时间
         */
        public void lock(String lockName, long leaseTime) {
            RLock rLock = redisson.getLock(lockName);
            rLock.lock(leaseTime,TimeUnit.SECONDS);
        }
    
        /**
         * 加锁操作 (锁有效时间采用默认时间30秒)
         * @param lockName 锁名称
         */
        public void lock(String lockName) {
            RLock rLock = redisson.getLock(lockName);
            rLock.lock();
        }
    
        /**
         * 加锁操作(tryLock锁,没有等待时间)
         * @param lockName  锁名称
         * @param leaseTime 锁有效时间
         */
        public boolean tryLock(String lockName, long leaseTime) {
    
            RLock rLock = redisson.getLock(lockName);
            boolean getLock = false;
            try {
                getLock = rLock.tryLock( leaseTime, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                log.error("获取Redisson分布式锁[异常],lockName=" + lockName, e);
                e.printStackTrace();
                return false;
            }
            return getLock;
        }
    
        /**
         * 加锁操作(tryLock锁,有等待时间)
         * @param lockName   锁名称
         * @param leaseTime  锁有效时间
         * @param waitTime   等待时间
         */
        public  boolean tryLock(String lockName, long leaseTime,long waitTime) {
    
            RLock rLock = redisson.getLock(lockName);
            boolean getLock = false;
            try {
                getLock = rLock.tryLock( waitTime,leaseTime, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                log.error("获取Redisson分布式锁[异常],lockName=" + lockName, e);
                e.printStackTrace();
                return false;
            }
            return getLock;
        }
    
        /**
         * 解锁
         * @param lockName  锁名称
         */
        public void unlock(String lockName) {
            redisson.getLock(lockName).unlock();
        }
    
        /**
         * 判断该锁是否已经被线程持有
         * @param lockName  锁名称
         */
        public boolean isLock(String lockName) {
            RLock rLock = redisson.getLock(lockName);
            return rLock.isLocked();
        }
    
    
        /**
         * 判断该线程是否持有当前锁
         * @param lockName  锁名称
         */
        public boolean isHeldByCurrentThread(String lockName) {
            RLock rLock = redisson.getLock(lockName);
            return rLock.isHeldByCurrentThread();
        }
    
    
    }
    

    5.注解使用

    /**
     * @author lz
     * @Description: 基于注解的方式 加锁
     * @date 2020/10/24 下午11:01
     */
    @RestController
    @Slf4j
    public class AnnotatinLockController {
    
        @Autowired
        RedissonLock redissonLock;
        /**
         * 模拟这个是商品库存
         */
        public static volatile Integer TOTAL = 10;
    
        @GetMapping("annotatin-lock-decrease-stock")
        @DistributedLock(value="goods", leaseTime=5)
        public String lockDecreaseStock() throws InterruptedException {
            if (TOTAL > 0) {
                TOTAL--;
            }
            log.info("===注解模式=== 减完库存后,当前库存===" + TOTAL);
            return "=================================";
        }
    }
    

     

    展开全文
  • 一、pom.xml文件中引入redisson依赖包 <!-- https://mvnrepository.com/artifact/org.redisson/redisson --> <dependency> <groupId>org.redisson</groupId> <artifactId>r...
  • Springboot集成Redisson分布式锁

    千次阅读 2019-05-29 15:18:57
    pom文件添加Redisson依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.6.5</version> </dependency> ...
  • 前言 最近开发了几个微服务上线了,发现定时任务执行了很多次,查看rancher发现这几个微服务都是多实例的,也就是说定时任务执行了多次,...添加Redisson依赖 <dependency> <groupId>org.redisson<...
  • 最近的项目中要用到分布式锁,而且redis的官方文档也...1.引入redisson依赖: <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version&g...
  • SpringBoot集成Redisson实现简单...1. Maven添加Redisson依赖 pom.xml中添加如下内容: <!-- 集成redis --> <dependency> <groupId>org.springframework.boot</groupId> <art...
  • Redisson依赖: <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</artifactId> <version>3.13.3</version> &
  • 在【Redis Jedis实战(含Spring Boot)】基础上做如下...添加redisson依赖 <!-- <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</art...
  • Redisson依赖: dependency>  groupId>org.redissongroupId>  artifactId>redissonartifactId>  version>2.2.13version> dependency> 网上关于redis分布式锁实现的文章很多,本文也参考了很多网上的代码,不过我...
  • Redisson官方文档 - 15. 项目依赖列表

    千次阅读 2018-03-20 07:46:43
    以下是所有被Redisson使用到的依赖: 组名(Group ID) 项目名(Artifact ID) 版本(version) 依赖需求 io.netty netty-common 4.1+ 必要 io.netty netty-codec 4.1+ 必要 io.netty netty-buffer 4.1+ ...
  • 本文主要介绍redisson的分布式锁,其他功能请查看redisson的中文文档apihttps://github....首先导入redisson依赖 <!--redisson--> <dependency> <groupI...
  • 依赖 <!-- spring boot 1.x --> < groupId>com.github.drtrang</ groupId> < artifactId>redisson-spring-boot-starter < version>1.2.5 <!-- spring boot 2.x --> < groupId>...
  • 分布式锁 redisson

    2020-11-04 23:50:44
    1、导入依赖 ・ <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.11.1</version> </dependency> ・ 2、配置...
  • RedisSon实现分布式锁

    2020-03-17 21:26:52
    1、引入RedisSon依赖 2、配置RedisSon的配置类 3、使用RedisSon构建分布式锁,在需要使用分布式锁的地方注入RedissonClient这个类来获取锁 第一步、引入依赖: <parent> <groupId>org.spring...
  • Redisson 分布式锁

    2019-11-06 21:35:21
    POM依赖: <!-- redisson --> <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.5.7</version> </dep...
  • Redisson分布式锁实现

    2021-03-22 23:29:09
    依赖 <redisson>3.14.0</redisson> <!-- redisson RedLock 实现 --> <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</...
  • redisson锁实现

    2021-02-06 20:25:16
    1.maven引入依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.11.2</version> </dependency> 2.配置...
  • redisson 整合springboot

    2019-11-15 09:10:25
    依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.8.0</version> ...
  • Redisson 简单使用

    2020-03-25 20:42:31
    参考于这篇博客 导入依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.8.0</version&g...
  • redisson入门使用

    2020-09-07 19:09:31
    一、相关依赖 <!--edisson--> <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</artifactId> <version>3.13.1</...
  • springboot 整合 redisson

    千次阅读 2019-06-11 23:05:37
    在之前的文章中有提到 redisson ,基于 redis 的分布式锁。...1. pom 依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> &...
  • Springboot整合Redisson

    2021-05-05 21:07:07
    Redisson前言一、依赖二、配置文件三、锁的使用读写锁信号量闭锁四、分布式秒杀 前言 Redisson是一个在Redis的基础上实现的Java驻内存数据网格 一、依赖 <dependency> <groupId>org.redisson</...
  • redisson实现分布式锁

    2020-07-17 17:11:02
    这里我只导入redisson,其他还需要redis的依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.12.5&l
  • springboot集成redisson

    千次阅读 2018-11-09 17:50:44
    添加依赖: &lt;dependency&gt; &lt;groupId&gt;org.redisson&lt;/groupId&gt; &lt;artifactId&gt;redisson&lt;/artifactId&gt; &lt;version&gt;3.5.0&...
  • 分布式锁-Redisson

    2020-07-23 18:12:21
    1,导入依赖 <!--以后使用redisson作为所有分布式锁,分布式对象等功能框架--> <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 274
精华内容 109
关键字:

redisson依赖

redis 订阅