Redisson

一、什么是redisson

Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。

二、使用redisson工具类

import org.redisson.api.RAtomicLong;
import org.redisson.api.RBucket;
import org.redisson.api.RCountDownLatch;
import org.redisson.api.RDeque;
import org.redisson.api.RList;
import org.redisson.api.RLock;
import org.redisson.api.RMap;
import org.redisson.api.RQueue;
import org.redisson.api.RSet;
import org.redisson.api.RSortedSet;
import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class RedissonUtils{


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

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

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

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

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

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

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

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

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

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

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


}

三、配置

#哨兵模式
spring:
  redis:
    database: 0
    password: 123456 #密码
    port: 6379
        jedis:
            pool:
              #最大连接数
              max-active: 8
              #最大阻塞等待时间(负数表示没限制)
              max-wait: -1ms
              #最大空闲
              max-idle: 8
              #最小空闲
              min-idle: 0
    timeout: 300s
    sentinel:  #哨兵模式
      master: master1
      nodes: 192.168.252.136:16001,192.168.252.136:16002
server:
  port: 9090
# THYMELEAF (ThymeleafAutoConfiguration)
#spring:
#  thymeleaf:
#    cache: false
#    check-template: true
#    check-template-location: true
#    enabled: true
#    encoding: utf-8
    #去掉thymeleaf的严格的模板校验
#    mode: LEGACYHTML5
#    prefix: classpath:/templates/
#    suffix: .html
#    excluded-view-names:
#spring:
#  groovy:
#   template:
      #关闭前端模板引擎缓存模式
#      cache: false

四、redisson配置

#哨兵模式
---
sentinelServersConfig:
  idleConnectionTimeout: 10000
  pingTimeout: 1000
  connectTimeout: 10000
  timeout: 3000
  retryAttempts: 3
  retryInterval: 1500
  reconnectionTimeout: 3000
  failedAttempts: 3
  password: 12345678
  subscriptionsPerConnection: 5
  clientName: null
  loadBalancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
  slaveSubscriptionConnectionMinimumIdleSize: 1
  slaveSubscriptionConnectionPoolSize: 50
  slaveConnectionMinimumIdleSize: 10
  slaveConnectionPoolSize: 64
  masterConnectionMinimumIdleSize: 10
  masterConnectionPoolSize: 64
  readMode: "SLAVE"
  sentinelAddresses:
  - "redis://192.168.252.136:16001"
  - "redis://192.168.252.136:16002"
  masterName: "master1"
  database: 0
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {}
useLinuxNativeEpoll: false

五、启动配置

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ClassPathResource;

import java.io.IOException;

@SpringBootApplication
public class JedisredissonApplication {

    @Autowired
    private Environment env;

    public static void main(String[] args) {
        SpringApplication.run(JedisredissonApplication.class, args);
    }

    /**
     * 哨兵模式获取配置文件参数
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() throws IOException {
        String[] profiles = env.getActiveProfiles();
        String profile = "";
        if(profiles.length > 0) {
            profile = "-" + profiles[0];
        }
        return Redisson.create(
                Config.fromYAML(new ClassPathResource("redisson" + profile + ".yml").getInputStream())
        );
    }

}

六、控制层

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/demo")
public class DemoController {

    private static Logger logger = LoggerFactory.getLogger(DemoController.class);

    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    @Autowired
    private RedissonClient redissonClient;

    @ResponseBody
    @RequestMapping("/lock")
    public String lock(@RequestParam("sid") String serverId) {
        Long counter = redisTemplate.opsForValue().increment("COUNTER", 1);
        RLock lock = redissonClient.getLock("TEST");
        try {
            lock.lock();
            logger.info("Request Thread - " + counter + "[" + serverId +"] locked and begun...");
            Thread.sleep(5000); // 5 sec
            logger.info("Request Thread - " + counter + "[" + serverId +"] ended successfully...");
        } catch (Exception ex) {
            logger.error("Error occurred");
        } finally {
            lock.unlock();
            logger.info("Request Thread - " + counter + "[" + serverId +"] unlocked...");
        }

        return "lock-" + counter + "[" + serverId +"]";
    }
}

七、redisson的api地址：https://github.com/redisson/redisson/wiki/Redisson%E9%A1%B9%E7%9B%AE%E4%BB%8B%E7%BB%8D

八、参考网上博客：https://blog.csdn.net/c_zyer/article/details/79415728

猜你喜欢