RedissonClient（同步异步）、RedissonReactiveClient（反射式 Reactive
）和RedissonRxClient（ RxJava2 ）实例本身和Redisson提供的所有分布式对象都是线程安全的

1.首先先进行一步简单的配置redis的步骤

Config config = new Config();
SingleServerConfig singleServerConfig = config.useSingleServer()
        .setAddress("redis://" + StringUtils.trim("10.6.30.41:6379"))
        .setDatabase(8)
        .setTimeout(3000)
        .setConnectionPoolSize(64)
        .setConnectionMinimumIdleSize(10);
    singleServerConfig.setPassword("123456");
RedissonClient client = Redisson.create(config);
2.了解常用RKeys的API操作
 
RKeys keys = client.getKeys();
//获取所有key值
Iterable<String> allKeys = keys.getKeys();
//获取所有模糊key值
Iterable<String> foundedKeys = keys.getKeysByPattern("key");
//删除多个key值
long numOfDeletedKeys = keys.delete("obj1", "obj2", "obj3");
//删除模糊key值
long deletedKeysAmount = keys.deleteByPattern("test?");
//随机获取key
String randomKey = keys.randomKey();
//当前多少key数
long keysAmount = keys.count();
3.通用对象桶（Object Bucket）
 
Redisson的分布式RBucketJava对象是一种通用对象桶可以用来存放任类型的对象。 除了同步接口外，还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
 
//对象桶 单个元素的存储
RBucket<String> bucket = client.getBucket("REDIS_BUCKET_TEST");
//同步 存储元素进对象桶，无返回值
bucket.set("1");
bucket.setAsync("1");
//返回bucket中key的值，返回1
bucket.get();
//尝试对REDIS_BUCKET_TEST存值，如果已存在值就不存进去，存在就存进去
// （先查询是否存在，true则存入，false则返回）
boolean bl = bucket.trySet("2");
//第一个参数与存的值比较，相等就存入第二个参数
boolean bl = bucket.compareAndSet("2", "3");
//get返回并且存入新的值
String str =  bucket.getAndSet("4");
还可以通过RBuckets接口实现批量操作多个RBucket对象：
 
RBuckets buckets = client.getBuckets();
//获取多个buckets
Map<String, String> loadedBuckets = buckets.get("REDIS_BUCKET_TEST", "REDIS_BUCKET_TEST1", "REDIS_BUCKET_TEST2");
Map<String, Object> map = new HashMap<>();
map.put("REDIS_BUCKET_TEST", "0");
map.put("REDIS_BUCKET_TEST1","1");
// 利用Redis的事务特性，同时保存所有的通用对象桶，如果任意一个通用对象桶已经存在则放弃保存其他所有数据。
buckets.trySet(map);
// 同时保存全部通用对象桶。
buckets.set(map);
4.二进制流（Binary Stream）
 
Redisson的分布式RBinaryStream Java对象同时提供了InputStream接口和OutputStream接口的实现。流的最大容量受Redis主节点的内存大小限制。
 
RBinaryStream stream = client.getBinaryStream("anyStream");
byte[] content = "ceshi".getBytes();
//设置流内容ceshi
stream.set(content);
InputStream is = stream.getInputStream();
byte[] readBuffer = new byte[512];
//读取流ceshi
is.read(readBuffer);
OutputStream os = stream.getOutputStream();
byte[] contentToWrite = "ceshi1".getBytes();
//写入流ceshi1，注意：不是覆盖是写入，最终流为ceshiceshi1
os.write(contentToWrite);
5.地理空间对象桶（Geospatial Bucket）
 
RGeo<String> geo = client.getGeo("test");
//同步存储可存储多个
geo.add(new GeoEntry(13.361389, 38.115556, "Palermo"),
        new GeoEntry(15.087269, 37.502669, "Catania"));
//异步存储只能一个
geo.addAsync(37.618423, 55.751244, "Moscow");
//返回两个坐标的距离
Double distance = geo.dist("Palermo", "Catania", GeoUnit.METERS);
//返回成员的地理位置
Map<String, GeoPosition> positions = geo.pos("test2", "Palermo", "test3", "Catania", "test1");
//暂时没研究
RFuture<Map<String, String>> future= geo.hashAsync("Palermo", "Catania");
List<String> cities = geo.radius(15, 37, 200, GeoUnit.KILOMETERS);
Map<String, GeoPosition> citiesWithPositions = geo.radiusWithPosition(15, 37, 200, GeoUnit.KILOMETERS);
6.BitSet(暂时还不理解)
 
Redisson的分布式RBitSetJava对象采用了与java.util.BiteSet类似结构的设计风格。可以理解为它是一个分布式的可伸缩式位向量。需要注意的是RBitSet的大小受Redis限制，最大长度为4 294 967 295。除了同步接口外，还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
 
RBitSet set = redisson.getBitSet("simpleBitset");
set.set(0, true);
set.set(1812, false);
set.clear(0);
set.addAsync("e");
set.xor("anotherBitset");
BitSet数据分片（Sharding）（分布式RoaringBitMap）
 
基于Redis的Redisson集群分布式BitSet通过RClusteredBitSet接口，为集群状态下的Redis环境提供了BitSet数据分片的功能。通过优化后更加有效的分布式RoaringBitMap算法，突破了原有的BitSet大小限制，达到了集群物理内存容量大小。在这里可以获取更多的内部信息。
 
RClusteredBitSet set = redisson.getClusteredBitSet("simpleBitset");
set.set(0, true);
set.set(1812, false);
set.clear(0);
set.addAsync("e");
set.xor("anotherBitset");
7.原子整长形（AtomicLong）
 
Redisson的分布式整长形RAtomicLong对象和Java中的java.util.concurrent.atomic.AtomicLong对象类似。除了同步接口外，还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
 个人理解：保证齐原子性，用了CAS算法乐观锁技术，
 
RAtomicLong atomicLong = client.getAtomicLong("myAtomicLong");
//设置成3
atomicLong.set(3);
//原子地将当前值增加1。
atomicLong.incrementAndGet();
//获取值
atomicLong.get();
8.原子双精度浮点（AtomicDouble）
 
Redisson还提供了分布式原子双精度浮点RAtomicDouble，弥补了Java自身的不足。除了同步接口外，还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
 
RAtomicDouble atomicDouble = redisson.getAtomicDouble("myAtomicDouble");
//设置值
atomicDouble.set(2.81);
//加法并且返回加好后的值
atomicDouble.addAndGet(4.11);
//获取值
atomicDouble.get();
9.话题（订阅分发）
 
Redisson的分布式话题RTopic对象实现了发布、订阅的机制。除了同步接口外，还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
 
RTopic topic = redisson.getTopic("anyTopic");
topic.addListener(SomeObject.class, new MessageListener<SomeObject>() {
    @Override
    public void onMessage(String channel, SomeObject message) {
        //...
// 在其他线程或JVM节点
RTopic topic = redisson.getTopic("anyTopic");
long clientsReceivedMessage = topic.publish(new SomeObject());
在Redis节点故障转移（主从切换）或断线重连以后，所有的话题监听器将自动完成话题的重新订阅。
 
Redisson的模糊话题RPatternTopic对象可以通过正式表达式来订阅多个话题。除了同步接口外，还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
 
// 订阅所有满足`topic1.*`表达式的话题
RPatternTopic topic1 = redisson.getPatternTopic("topic1.*");
int listenerId = topic1.addListener(Message.class, new PatternMessageListener<Message>() {
    @Override
    public void onMessage(String pattern, String channel, Message msg) {
         Assert.fail();
在Redis节点故障转移（主从切换）或断线重连以后，所有的模糊话题监听器将自动完成话题的重新订阅。
 
10.布隆过滤器（Bloom Filter）
 
Redisson利用Redis实现了Java分布式布隆过滤器（Bloom Filter）。所含最大比特数量为2^32。
 
RBloomFilter<SomeObject> bloomFilter = redisson.getBloomFilter("sample");
// 初始化布隆过滤器，预计统计元素数量为55000000，期望误差率为0.03
bloomFilter.tryInit(55000000L, 0.03);
bloomFilter.add(new SomeObject("field1Value", "field2Value"));
bloomFilter.add(new SomeObject("field5Value", "field8Value"));
bloomFilter.contains(new SomeObject("field1Value", "field8Value"));
6.8.1. 布隆过滤器数据分片（Sharding）
 
基于Redis的Redisson集群分布式布隆过滤器通过RClusteredBloomFilter接口，为集群状态下的Redis环境提供了布隆过滤器数据分片的功能。 通过优化后更加有效的算法，通过压缩未使用的比特位来释放集群内存空间。每个对象的状态都将被分布在整个集群中。所含最大比特数量为2^64。在这里可以获取更多的内部信息。
 
RClusteredBloomFilter<SomeObject> bloomFilter = redisson.getClusteredBloomFilter("sample");
// 采用以下参数创建布隆过滤器
// expectedInsertions = 255000000
// falseProbability = 0.03
bloomFilter.tryInit(255000000L, 0.03);
bloomFilter.add(new SomeObject("field1Value", "field2Value"));
bloomFilter.add(new SomeObject("field5Value", "field8Value"));
bloomFilter.contains(new SomeObject("field1Value", "field8Value"));
该功能仅限于Redisson PRO版本。
 
11.基数估计算法（HyperLogLog）
 
实用场景：概率数据结构使您可以以极高的空间效率维护数百万个项目的计数。
 Redisson利用Redis实现了Java分布式基数估计算法（HyperLogLog）对象。该对象可以在有限的空间内通过概率算法统计大量的数据。除了同步接口外，还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
 
RHyperLogLog<Integer> log = redisson.getHyperLogLog("log");
log.add(1);
log.add(2);
log.add(3);
log.count();
12. 整长型累加器（LongAdder）
 
基于Redis的Redisson分布式整长型累加器（LongAdder）采用了与java.util.concurrent.atomic.LongAdder类似的接口。通过利用客户端内置的LongAdder对象，为分布式环境下递增和递减操作提供了很高得性能。据统计其性能最高比分布式AtomicLong对象快 12000 倍。完美适用于分布式统计计量场景。
 
RLongAdder atomicLong = redisson.getLongAdder("myLongAdder");
atomicLong.add(12);
atomicLong.increment();
atomicLong.decrement();
atomicLong.sum();
当不再使用整长型累加器对象的时候应该自行手动销毁，如果Redisson对象被关闭（shutdown）了，则不用手动销毁。
 
RLongAdder atomicLong = ...
atomicLong.destroy();
13.双精度浮点累加器（DoubleAdder）
 
基于Redis的Redisson分布式双精度浮点累加器（DoubleAdder）采用了与java.util.concurrent.atomic.DoubleAdder类似的接口。通过利用客户端内置的DoubleAdder对象，为分布式环境下递增和递减操作提供了很高得性能。据统计其性能最高比分布式AtomicDouble对象快 12000 倍。完美适用于分布式统计计量场景。
 
RLongDouble atomicDouble = redisson.getLongDouble("myLongDouble");
atomicDouble.add(12);
atomicDouble.increment();
atomicDouble.decrement();
atomicDouble.sum();
当不再使用双精度浮点累加器对象的时候应该自行手动销毁，如果Redisson对象被关闭（shutdown）了，则不用手动销毁。
 
RLongDouble atomicDouble = ...
_b6d2063_
atomicDouble.destroy();
13.限流器（RateLimiter）
 
基于Redis的分布式限流器（RateLimiter）可以用来在分布式环境下现在请求方的调用频率。既适用于不同Redisson实例下的多线程限流，也适用于相同Redisson实例下的多线程限流。该算法不保证公平性。除了同步接口外，还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
 
RRateLimiter rateLimiter = redisson.getRateLimiter("myRateLimiter");
// 初始化
// 最大流速 = 每1秒钟产生10个令牌
rateLimiter.trySetRate(RateType.OVERALL, 10, 1, RateIntervalUnit.SECONDS);
CountDownLatch latch = new CountDownLatch(2);
limiter.acquire(3);
// ...
Thread t = new Thread(() -> {
    limiter.acquire(2);
    // ...        
实操Redission 分布式对象（一） - 简书 
                    公共讲解RedissonClient（同步异步）、RedissonReactiveClient（反射式Reactive）和RedissonRxClient（RxJava2）实例本身和Redisson提供的所有分布式对象都是线程安全的1.首先先进行一步简单的配置redis的步骤Config config = new Config();SingleServerConfig singleServerConfig = config.useSingleServer()        .setA
在 Redis 最重要最基础就属 它丰富的数据结构了，Redis 之所以能脱颖而出很大原因是他数据结构丰富，可以支持多种场景。并且 Redis 的数据结构实现以及应用场景在面试中是相当常见的，接下来就和大家聊聊 Redis 的数据结构。
Redis数据结构有：string、list、hash、set、sorted set这五个是大家都知道的，但Redis还有更高级得数据结构，比如：H..
				
由于最近项目中需要用到距离计算, 附近位置等功能, 就想到redis了的GeoHash, 关于GeoHash的概念就不过多介绍, 用法也比较简单, 但由于项目中使用的是Redission, 网上有关Redission 使用GeoHash的工具类也非常之少, 无奈只能自己动手写了。
话不多说,直接上工具类, 做了两层封装。
一.RedissonTemplate
 * 操作对象
public class RedissonTemplate {
    @Resource
    private R




    

				
文章目录前言引入redisson依赖redisson-spring-data与Spring Boot version的版本对应关系maven依赖配置文件redisson.yml多节点配置使用 RedissonClient
SpringBoot整合Redisson有个比较好用的starter包就是redisson-spring-boot-starter，这也是官方比较推荐的配置方式
引入redisson依赖
只需引入redisson-spring-boot-starter就可以了，不过这里需要注意spr
猿Why比较感兴趣的有这么几种：
Object Bucket（通用对象桶）
可以避免直接使用Redis命令做数据存储和查询。Redission在执行命令的外层，封装了这个对象，一般string类型的数据存储、查询都是使用这个类型做暂存。
Geospatial Bucket（地理空间对象桶）
位置信息，可以理解为将经纬度存储在一个对象中。位置信息可以做计算，计算范围、计算距离。常见的使用场景：微信附近的人、地图位置显示等。
				
redis中geo 就是将坐标存在reids 中可以进行判断坐标之间的距离，判断坐标及公里内的坐标。
但是由于geo大部分博客都是添加geo 进行判断，但是没有教大家怎么删除，对于坐标点比较多的话会
再redis中进行冗余数据。
	geo其实就是redis中的有序集合，大家可以自行百度查看用法。
	我用的是 Map<String, Point> memberCoordinateMap = new HashMap<String, Point>(); 
来存储坐标的RedisTempl.
				
Redis 支持通过使用 Lua 脚本实现分布式锁。可以使用 Redis 的 SET 命令，并在设置锁时设置过期时间，以避免死锁。
以下是 Redisson 库中实现分布式锁的示例代码：
```java
// 创建 RedissonClient 客户端
RedissonClient redisson = Redisson.create();
// 获取锁对象
RLock lock = redisson.getLock("lockName");
// 加锁,设置锁最长占用时间为10s
lock.lock(10, TimeUnit.SECONDS);
try {
    // do something
} finally {
    // 释放锁
    lock.unlock();
1. 获取锁时需要捕获异常,确保释放锁,防止死锁
2. 为了保证锁能尽可能少时间持有,建议锁的持有时间尽可能短
以上代码使用redission来实现分布式锁，用于解决定时任务不重复执行的问题。
                    阳光帅青年: 
                    SpringApplicationBuilder builder = new SpringApplicationBuilder(Empty.class) .bannerMode(Mode.OFF).web(WebApplicationType.NONE) 重启上下文以后，用Empty.class作为启动类去扫描，经过测试，扫描到的BeanDefinition 并不会包含@controller @service注解标识的类， List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); 经过debug beanNames只有spring自己注入的类，请问没有BeanDefinition 是如何用RefreshScope把对象创建出来的。
                ShardingSphere-JDBC篇
                    dotaer-df: 
                    嗯那就需要存一个map来维护，比如说这样ds0->0,ds1->1