redis redisson 使用说明

redis redisson 使用说明

 

redisson将数据存储在redis中，提供了一系列的分布式对象（Set、Map、List、Queue、Lock、发布/订阅、信号量、布隆过滤器等），提高了开发效率

官网：https://github.com/redisson/redisson/wiki

 

**********************************************

配置类

 

Config：入口配置类

public class Config {
    private SentinelServersConfig sentinelServersConfig;        //主从哨兵配置
    private MasterSlaveServersConfig masterSlaveServersConfig;  //主从配置
    private SingleServerConfig singleServerConfig;              //单机配置
    private ClusterServersConfig clusterServersConfig;          //集群配置
    private ReplicatedServersConfig replicatedServersConfig;    //使用云托管模式配置
    private ConnectionManager connectionManager;      //自定义连接时使用，一般不用
    private int threads = 16;
    private int nettyThreads = 32;
    private Codec codec;                     //设置编码方式，用于对象的序列化与反序列化
    private ExecutorService executor;        //线程池
    private boolean referenceEnabled = true;
    private TransportMode transportMode;     //传输模式，默认为nio
    private EventLoopGroup eventLoopGroup;
    private long lockWatchdogTimeout;        //使用分布式锁的超时时间，默认为30s
    private boolean keepPubSubOrder;         //使用发布订阅时，保持发布订阅的顺序，默认为true
    private boolean decodeInExecutor;
    private boolean useScriptCache;
    private int minCleanUpDelay;
    private int maxCleanUpDelay;
    private AddressResolverGroupFactory addressResolverGroupFactory;

********************
构造函数

    public Config() {
        this.transportMode = TransportMode.NIO;
        this.lockWatchdogTimeout = 30000L;
        this.keepPubSubOrder = true;
        this.decodeInExecutor = false;
        this.useScriptCache = false;
        this.minCleanUpDelay = 5;
        this.maxCleanUpDelay = 1800;
        this.addressResolverGroupFactory = new DnsAddressResolverGroupFactory();
    }

    public Config(Config oldConf) {

************************
常用方法

    public Config setCodec(Codec codec) {
    public Codec getCodec() {
                 //编码方式，用于对象的序列化与反序列化

    public int getThreads() {
    public Config setThreads(int threads) {
                  //线程设置

    public Config setTransportMode(TransportMode transportMode) {
    public TransportMode getTransportMode() {
                  //传输模式设置

    public Config setNettyThreads(int nettyThreads) {
    public int getNettyThreads() {
                  //设置netty的线程数量

    public Config setExecutor(ExecutorService executor) {
    public ExecutorService getExecutor() {
                  //设置线程池

    public Config setLockWatchdogTimeout(long lockWatchdogTimeout) {
    public long getLockWatchdogTimeout() {
                   //使用分布式锁时，设置锁的默认失效时间

    public Config setKeepPubSubOrder(boolean keepPubSubOrder) {
    public boolean isKeepPubSubOrder() {
                   //设置发布订阅时，是否保持先后顺序

    public static Config fromJSON(String content) throws IOException {
    public static Config fromJSON(InputStream inputStream) throws IOException {
    public static Config fromJSON(File file, ClassLoader classLoader) throws IOException {
    public static Config fromJSON(File file) throws IOException {
    public static Config fromJSON(URL url) throws IOException {
    public static Config fromJSON(Reader reader) throws IOException {//从json文件中获取配置信息
    public String toJSON() throws IOException {  //将配置对象转换为json输出
                   
    public static Config fromYAML(String content) throws IOException {
    public static Config fromYAML(InputStream inputStream) throws IOException {
    public static Config fromYAML(File file) throws IOException {
    public static Config fromYAML(File file, ClassLoader classLoader) throws IOException {
    public static Config fromYAML(URL url) throws IOException {
    public static Config fromYAML(Reader reader) throws IOException {//从yaml文件中获取配置信息
    public String toYAML() throws IOException {  //将配置信息转换为yanl文件


***********
集群配置

    public ClusterServersConfig useClusterServers() {
    ClusterServersConfig useClusterServers(ClusterServersConfig config) {
    ClusterServersConfig getClusterServersConfig() {
    void setClusterServersConfig(ClusterServersConfig clusterServersConfig) {
                
***********
云配置

    public ReplicatedServersConfig useReplicatedServers() {
    ReplicatedServersConfig useReplicatedServers(ReplicatedServersConfig config) {
    ReplicatedServersConfig getReplicatedServersConfig() {
    void setReplicatedServersConfig(ReplicatedServersConfig replicatedServersConfig) {

***********
单机配置

    public SingleServerConfig useSingleServer() {
    SingleServerConfig useSingleServer(SingleServerConfig config) {
    SingleServerConfig getSingleServerConfig() {
    void setSingleServerConfig(SingleServerConfig singleConnectionConfig) {

************
主从哨兵配置

    public SentinelServersConfig useSentinelServers() {
    SentinelServersConfig useSentinelServers(SentinelServersConfig sentinelServersConfig) {
    SentinelServersConfig getSentinelServersConfig() {
    void setSentinelServersConfig(SentinelServersConfig sentinelConnectionConfig) {

************
主从配置

    public MasterSlaveServersConfig useMasterSlaveServers() {
    MasterSlaveServersConfig useMasterSlaveServers(MasterSlaveServersConfig config) {
    MasterSlaveServersConfig getMasterSlaveServersConfig() {
    void setMasterSlaveServersConfig(MasterSlaveServersConfig masterSlaveConnectionConfig) {

 

BaseConfig：基础配置类

class BaseConfig> {
    private static final Logger log = LoggerFactory.getLogger("config");
    private int idleConnectionTimeout = 10000;  //空闲连接超时时间，默认为10s
    private int pingTimeout = 1000;             //心跳超时时间，默认为1s
    private int connectTimeout = 10000;         //连接超时时间，默认为10s
    private int timeout = 3000;                 //命令等待超时时间，从发送成功开始计算
    private int retryAttempts = 3;              //重试次数
    private int retryInterval = 1500;           //重试间隔
    private String password;                    //密码
    private int subscriptionsPerConnection = 5; //每条连接的订阅次数
    private String clientName;
    private boolean sslEnableEndpointIdentification = true;
    private SslProvider sslProvider;
    private URL sslTruststore;
    private String sslTruststorePassword;
    private URL sslKeystore;
    private String sslKeystorePassword;
    private int pingConnectionInterval;
    private boolean keepAlive;
    private boolean tcpNoDelay;

**************************
构造方法

    BaseConfig() {
        this.sslProvider = SslProvider.JDK;
    }

    BaseConfig(T config) {

 

 

********************************************

SingleServerConfig：单服务器配置类

 

public class SingleServerConfig extends BaseConfig {
    private String address;      //服务器的地址
    private int subscriptionConnectionMinimumIdleSize = 1;
    private int subscriptionConnectionPoolSize = 50;
    private int connectionMinimumIdleSize = 24;
    private int connectionPoolSize = 64;
    private int database = 0;
    private long dnsMonitoringInterval = 5000L;

    SingleServerConfig() {
    }

    SingleServerConfig(SingleServerConfig config) {

 

****************************************

主从配置类

 

BaseMasterSlaveServersConfig：基础主从配置类

public class BaseMasterSlaveServersConfig> extends BaseConfig {
    private LoadBalancer loadBalancer = new RoundRobinLoadBalancer();
    private int slaveConnectionMinimumIdleSize = 24;
    private int slaveConnectionPoolSize = 64;
    private int failedSlaveReconnectionInterval = 3000;
    private int failedSlaveCheckInterval = 180000;
    private int masterConnectionMinimumIdleSize = 24;
    private int masterConnectionPoolSize = 64;
    private ReadMode readMode;                  //读模式，Master、slave、Master_slave
    private SubscriptionMode subscriptionMode;  //订阅模式，master、slave
    private int subscriptionConnectionMinimumIdleSize;
    private int subscriptionConnectionPoolSize;
    private long dnsMonitoringInterval;

    public BaseMasterSlaveServersConfig() {
        this.readMode = ReadMode.SLAVE;
        this.subscriptionMode = SubscriptionMode.MASTER;
        this.subscriptionConnectionMinimumIdleSize = 1;
        this.subscriptionConnectionPoolSize = 50;
        this.dnsMonitoringInterval = 5000L;
    }

    BaseMasterSlaveServersConfig(T config) {



**********************************
ReadMode：读模式

public enum ReadMode {
    SLAVE,         //从slave节点读取
    MASTER,        //从master节点读取
    MASTER_SLAVE;  //主从节点都可以读取

    private ReadMode() {
    }
}

**********************************
SubscriptionMode：订阅模式

public enum SubscriptionMode {
    SLAVE,   //从slave节点订阅
    MASTER;  //从master节点订阅

    private SubscriptionMode() {
    }
}

 

MasterSlaveServersConfig：主从配置类

public class MasterSlaveServersConfig extends BaseMasterSlaveServersConfig {
    private Set slaveAddresses = new HashSet();  //从节点地址
    private String masterAddress;                        //主节点地址
    private int database = 0;

*******************
构造方法

    public MasterSlaveServersConfig() {
    }

    MasterSlaveServersConfig(MasterSlaveServersConfig config) {
        super(config);
        this.setLoadBalancer(config.getLoadBalancer());
        this.setMasterAddress(config.getMasterAddress());
        this.setSlaveAddresses(config.getSlaveAddresses());
        this.setDatabase(config.getDatabase());
    }

*******************
常用方法

    public MasterSlaveServersConfig setMasterAddress(String masterAddress) {
                                    //主节点设置

    public MasterSlaveServersConfig addSlaveAddress(String... addresses) {
    public MasterSlaveServersConfig addSlaveAddress(String slaveAddress) {
    public void setSlaveAddresses(Set readAddresses) {
                                    //设置从节点

    public MasterSlaveServersConfig setDatabase(int database) {
                                    //设置主从操作数据库

    public String getMasterAddress() {        //获取主节点
    public Set getSlaveAddresses() {  //获取从节点
    public int getDatabase() {                //获取主从操作数据库

 

 

********************************************

SentinelServersConfig：主从哨兵配置类

 

public class SentinelServersConfig extends BaseMasterSlaveServersConfig {
    private List sentinelAddresses = new ArrayList();
    private Map natMap = Collections.emptyMap();
    private String masterName;         //监听的主节点的名称，通过监听的主节点名称获取主从集群
    private int database = 0;
    private int scanInterval = 1000;   //扫描间隔，默认为1s

**********************
构造函数

    public SentinelServersConfig() {
    }

    SentinelServersConfig(SentinelServersConfig config) {
        super(config);
        this.setSentinelAddresses(config.getSentinelAddresses());
        this.setMasterName(config.getMasterName());
        this.setDatabase(config.getDatabase());
        this.setScanInterval(config.getScanInterval());
        this.setNatMap(new HashMap(config.getNatMap()));
    }

**********************
常用方法

    public SentinelServersConfig setMasterName(String masterName) {  //设置监听的主节点的名称
    public String getMasterName() { //获取监听的主节点的名称

    public SentinelServersConfig addSentinelAddress(String... addresses) {
    void setSentinelAddresses(List sentinelAddresses) {
                                    //设置哨兵节点地址

    public List getSentinelAddresses() {
                                    //获取哨兵节点地址

 

 

**********************************************

ReplicatedServersConfig：云配置类

 

public class ReplicatedServersConfig extends BaseMasterSlaveServersConfig {
    private List nodeAddresses = new ArrayList();  //节点地址
    private int scanInterval = 1000;     //扫描间隔，默认为1s
    private int database = 0;

**********************
构造函数

    public ReplicatedServersConfig() {
    }

    ReplicatedServersConfig(ReplicatedServersConfig config) {
        super(config);
        this.setNodeAddresses(config.getNodeAddresses());
        this.setScanInterval(config.getScanInterval());
        this.setDatabase(config.getDatabase());
    }

**********************
常用方法

    public ReplicatedServersConfig addNodeAddress(String... addresses) {   
    void setNodeAddresses(List nodeAddresses) { //设置节点地址
    public List getNodeAddresses() {            //获取节点地址

    public int getScanInterval() {    //获取扫描间隔
    public ReplicatedServersConfig setScanInterval(int scanInterval) {
                                      //设置扫描间隔

    public ReplicatedServersConfig setDatabase(int database) {  //设置操作的数据库
    public int getDatabase() {        //获取操作的数据库

 

 

*********************************************

ClsuterServersConfig：集群配置类

 

public class ClusterServersConfig extends BaseMasterSlaveServersConfig {
    private Map natMap = Collections.emptyMap();
    private List nodeAddresses = new ArrayList();    //集群节点地址
    private int scanInterval = 5000;  //扫描间隔，默认为5s

************************
构造方法

    public ClusterServersConfig() {
    }

    ClusterServersConfig(ClusterServersConfig config) {
        super(config);
        this.setNodeAddresses(config.getNodeAddresses());
        this.setScanInterval(config.getScanInterval());
        this.setNatMap(new HashMap(config.getNatMap()));
    }

*************************
常用方法

    public ClusterServersConfig addNodeAddress(String... addresses) {
    void setNodeAddresses(List nodeAddresses) {  //设置节点地址
    public List getNodeAddresses() {             //获取节点地址

    public int getScanInterval() {        //获取扫描间隔
    public ClusterServersConfig setScanInterval(int scanInterval) {
                                          //设置扫描间隔

 

*****************************************

创建客户端

 

RedissonClient：客户端创建接口

public interface RedissonClient {

     RStream getStream(String var1);
     RStream getStream(String var1, Codec var2);
    RBinaryStream getBinaryStream(String var1);  //流对象

    RRateLimiter getRateLimiter(String var1);   //限流器对象

     RGeo getGeo(String var1);
     RGeo getGeo(String var1, Codec var2); //地理操作对象

     RHyperLogLog getHyperLogLog(String var1);
     RHyperLogLog getHyperLogLog(String var1, Codec var2);  //基数模糊计数器

    RSemaphore getSemaphore(String var1);
    RPermitExpirableSemaphore getPermitExpirableSemaphore(String var1);  //信号量

    RCountDownLatch getCountDownLatch(String var1); //倒计数器

    RBitSet getBitSet(String var1);   //位向量

     RBloomFilter getBloomFilter(String var1);
     RBloomFilter getBloomFilter(String var1, Codec var2);   //布隆过滤器

    RScript getScript();
    RScript getScript(Codec var1);  //lua脚本执行器

    RScheduledExecutorService getExecutorService(String var1);
    RScheduledExecutorService getExecutorService(String var1, ExecutorOptions var2);
    RScheduledExecutorService getExecutorService(String var1, Codec var2);
    RScheduledExecutorService getExecutorService(String var1, Codec var2, ExecutorOptions var3);  //定时任务线程池

    RLiveObjectService getLiveObjectService();  //实时对象服务

    RRemoteService getRemoteService();
    RRemoteService getRemoteService(Codec var1);
    RRemoteService getRemoteService(String var1);
    RRemoteService getRemoteService(String var1, Codec var2);  //远程任务调度

*****************
桶对象

     RBucket getBucket(String var1);
     RBucket getBucket(String var1, Codec var2);  //获取桶对象

    RBuckets getBuckets();
    RBuckets getBuckets(Codec var1);   //批量操作多个桶对象


******************
获取锁对象

    RLock getLock(String var1);

    RLock getMultiLock(RLock... var1);
    RLock getRedLock(RLock... var1);

    RLock getFairLock(String var1);

    RReadWriteLock getReadWriteLock(String var1);


*********************
获取list对象

     RList getList(String var1);
     RList getList(String var1, Codec var2);


*********************
获取set对象

     RSet getSet(String var1);
     RSet getSet(String var1, Codec var2);

     RSortedSet getSortedSet(String var1);
     RSortedSet getSortedSet(String var1, Codec var2);

     RScoredSortedSet getScoredSortedSet(String var1);
     RScoredSortedSet getScoredSortedSet(String var1, Codec var2);

    RLexSortedSet getLexSortedSet(String var1);

*********************
获取map对象

     RMap getMap(String var1);
     RMap getMap(String var1, MapOptions var2);
     RMap getMap(String var1, Codec var2);
     RMap getMap(String var1, Codec var2, MapOptions var3);  //获取map对象

     RListMultimap getListMultimap(String var1);
     RListMultimap getListMultimap(String var1, Codec var2);  //获取基于list的多值映射map对象，一个key可对应多个value

     RSetMultimap getSetMultimap(String var1);
     RSetMultimap getSetMultimap(String var1, Codec var2);  //获取基于set的多值映射map对象，一个key可对应多个value


*********************
获取cache对象

     RSetCache getSetCache(String var1);
     RSetCache getSetCache(String var1, Codec var2);  //set缓存

     RMapCache getMapCache(String var1, Codec var2);
     RMapCache getMapCache(String var1, Codec var2, MapOptions var3);
     RMapCache getMapCache(String var1);
     RMapCache getMapCache(String var1, MapOptions var2);  //map缓存

     RListMultimapCache getListMultimapCache(String var1);
     RListMultimapCache getListMultimapCache(String var1, Codec var2);  //基于list的多值映射缓存

     RSetMultimapCache getSetMultimapCache(String var1);
     RSetMultimapCache getSetMultimapCache(String var1, Codec var2);   //基于set的多值映射缓存

     RLocalCachedMap getLocalCachedMap(String var1, LocalCachedMapOptions var2);
     RLocalCachedMap getLocalCachedMap(String var1, Codec var2, LocalCachedMapOptions var3);  //本地映射缓存


***********************
获取topic主题

    RTopic getTopic(String var1);
    RTopic getTopic(String var1, Codec var2);

    RPatternTopic getPatternTopic(String var1);
    RPatternTopic getPatternTopic(String var1, Codec var2);

**************************
获取队列

     RQueue getQueue(String var1);
     RQueue getQueue(String var1, Codec var2);

     RDelayedQueue getDelayedQueue(RQueue var1);

     RRingBuffer getRingBuffer(String var1);
     RRingBuffer getRingBuffer(String var1, Codec var2);

     RPriorityQueue getPriorityQueue(String var1);
     RPriorityQueue getPriorityQueue(String var1, Codec var2);

     RPriorityBlockingQueue getPriorityBlockingQueue(String var1);
     RPriorityBlockingQueue getPriorityBlockingQueue(String var1, Codec var2);

     RBlockingQueue getBlockingQueue(String var1);
     RBlockingQueue getBlockingQueue(String var1, Codec var2);

     RBoundedBlockingQueue getBoundedBlockingQueue(String var1);
     RBoundedBlockingQueue getBoundedBlockingQueue(String var1, Codec var2);

     RDeque getDeque(String var1);
     RDeque getDeque(String var1, Codec var2);

     RPriorityDeque getPriorityDeque(String var1);
     RPriorityDeque getPriorityDeque(String var1, Codec var2);

     RBlockingDeque getBlockingDeque(String var1);
     RBlockingDeque getBlockingDeque(String var1, Codec var2);

     RPriorityBlockingDeque getPriorityBlockingDeque(String var1);
     RPriorityBlockingDeque getPriorityBlockingDeque(String var1, Codec var2);

***********************
获取原子类

    RAtomicLong getAtomicLong(String var1);
    RAtomicDouble getAtomicDouble(String var1);

    RLongAdder getLongAdder(String var1);
    RDoubleAdder getDoubleAdder(String var1);

************************
其他方法

    RBatch createBatch();
    RBatch createBatch(BatchOptions var1);  //批量操作

    RKeys getKeys();       //键操作
    RTransaction createTransaction(TransactionOptions var1);  //事务操作

    void shutdown();
    void shutdown(long var1, long var3, TimeUnit var5);

    Config getConfig();
    NodesGroup getNodesGroup();
    ClusterNodesGroup getClusterNodesGroup();

    boolean isShutdown();
    boolean isShuttingDown();
    String getId();
}

 

Redisson：获得RedissonClient客户端

public class Redisson implements RedissonClient {

****************
构造方法

    protected Redisson(Config config) {

****************
常用方法

    public static RedissonClient create() {
    public static RedissonClient create(Config config) {

    public static RedissonRxClient createRx() {
    public static RedissonRxClient createRx(Config config) {

    public static RedissonReactiveClient createReactive() {
    public static RedissonReactiveClient createReactive(Config config) {

说明：可通过Redisson获得RedissonClient接口，再创建相应的对象