Redission 使用

## 一句话介绍
基于redis的高级客户端，封装一系列诸如缓存、事务、分布式锁、消息订阅发布等等功能

## wiki 文档

官方wiki

https://github.com/redisson/redisson/wiki/

中文wiki

https://www.bookstack.cn/read/redisson-wiki-zh

## 基础客户端与spring集成

引入maven

```xml
	<dependency>
         <groupId>org.redisson</groupId>
		 <artifactId>redisson-spring-boot-starter</artifactId>
         <version>3.27.2</version>
     </dependency>
```
引入spring2.X配置
https://github.com/redisson/redisson/tree/master/redisson-spring-boot-starter#spring-boot-starter
```yaml
spring:
  redis:
    database: 
    host:
    port:
    password:
    ssl: 
    timeout:
    connectTimeout:
    clientName:
    cluster:
      nodes:
    sentinel:
      master:
      nodes:
```

自动注入和使用

```java
@Configuration
 public class RedissonSpringDataConfig {

@Bean
    public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
        return new RedissonConnectionFactory(redisson);
    }

@Bean(destroyMethod = "shutdown")
    public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
        Config config = Config.fromYAML(configFile.getInputStream());
        return Redisson.create(config);
    }

}

public class RedissonClientBean {

@Autowired
    private RedissonClient redissonClient;

public void commitData() {
       	RMap<String, String> map = redissonClient.getMap("testKey");
        map.put("prop1", "value1");;
    }

}
```

## redis和redission 参照
更多见 https://www.bookstack.cn/read/redisson-wiki-zh/11.-Redis%E5%91%BD%E4%BB%A4%E5%92%8CRedisson%E5%AF%B9%E8%B1%A1%E5%8C%B9%E9%85%8D%E5%88%97%E8%A1%A8.md

| Redis命令                            | Redisson对象方法                                             |
| ------------------------------------ | ------------------------------------------------------------ |
| DEL                                  | RObject.delete(), RObject.deleteAsync(), RObjectReactive.delete(); RKeys.delete(), RKeys.deleteAsync();|                                          |
| EXISTS                               | RObject.isExists(), RObject.isExistsAsync(), RObjectReactive.isExists(); |
| GET                                  | RBucket.get(), RBucket.getAsync(), RBucketReactive.get();    |
| SET                                  | RBucket.set(); RBucket.setAsync(); RBucketReactive.set();    |
| TTL                                  | RExpirable.remainTimeToLive(), RExpirable.remainTimeToLiveAsync(), RExpirableReactive.remainTimeToLive(); |
| HDEL                                 | RMap.fastRemove(), RMap.fastRemoveAsync(), RMapReactive.fastRemove(); |
| HEXISTS                              | RMap.containsKey(), RMap.containsKeyAsync(), RMapReactive.containsKey(); |
| HGET                                 | RMap.get(), RMap.getAsync(), RMapReactive.get();             |
| HGETALL                              | RMap.readAllEntrySet(), RMap.readAllEntrySetAsync(), RMapReactive.readAllEntrySet(); |
| HSET                                 | RMap.put(), RMap.putAsync(), RMapReactive.put();             |

## redis事务
Redisson事务支持的事务隔离等级为: READ_COMMITTED，即仅读取提交后的结果
常规事务

```java
@Configuration
@EnableTransactionManagement
public class RedissonTransactionContextConfig {
    
    @Bean
    public RedissonTransactionManager transactionManager(RedissonClient redisson) {
        return new RedissonTransactionManager(redisson);
    }
    
    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
         Config config = Config.fromYAML(configFile.getInputStream());
        return Redisson.create(config);
    }
    
}

@Service
public class TransactionalBean {

@Autowired
    private RedissonTransactionManager transactionManager;

/**
    * 手动处理则为
	*  try {
	*	   transaction.commit();
	*	} catch(TransactionException e) {
	*	   transaction.rollback();
	*	}
	*/
    @Transactional
    public void commitData() {
        // 每次创建的transaction只能进行一次提交或者回滚
        RTransaction transaction = transactionManager.getCurrentTransaction();
        RMap<String, String> map = transaction.getMap("testKey");
        map.put("prop1", "value1");
    }

}
```

反应式事务

```java
@Configuration
@EnableTransactionManagement
public class RedissonReactiveTransactionContextConfig {
    
    @Bean
    public ReactiveRedissonTransactionManager transactionManager(RedissonReactiveClient redisson) {
        return new ReactiveRedissonTransactionManager(redisson);
    }
    
    @Bean(destroyMethod="shutdown")
    public RedissonReactiveClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
         Config config = Config.fromYAML(configFile.getInputStream());
        return Redisson.createReactive(config);
    }
    
}

@Service
public class TransactionalBean {

@Autowired
    private ReactiveRedissonTransactionManager transactionManager;

@Transactional
    public Mono<Void> commitData() {
        Mono<RTransactionReactive> transaction = transactionManager.getCurrentTransaction();
        return transaction.flatMap(t -> {
            RMapReactive<String, String> map = t.getMap("testKey");
            return map.put("prop1", "value1");
        }).then();
    }
}
```

## 缓存+本地缓存
```java
    @Configuration
    @ComponentScan
    @EnableCaching
    public static class Application {
        @Bean
		public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
			return new RedissonConnectionFactory(redisson);
		}
		@Bean(destroyMethod = "shutdown")
		public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
			Config config = Config.fromYAML(configFile.getInputStream());
			return Redisson.create(config);
		}
        @Bean
        CacheManager cacheManager(RedissonClient redissonClient) {
            Map<String, CacheConfig> config = new HashMap<String, CacheConfig>();
            LocalCachedMapOptions options = LocalCachedMapOptions.defaults()
                   .evictionPolicy(EvictionPolicy.LFU)
                   .cacheSize(1000);
			// 本地缓存追加需要 Redisson PRO
            // 创建一个名称为"testMap"的缓存，过期时间ttl为24分钟，同时最长空闲时maxIdleTime为12分钟。
            config.put("testMap", new LocalCachedCacheConfig(24*60*1000, 12*60*1000, options));
            return new RedissonSpringLocalCachedCacheManager(redissonClient, config);
        }
    }
```