Java SpringBoot Redis

一、Jedis,Redisson,Lettuce 三者的区别

共同点：都提供了基于 Redis 操作的 Java API，只是封装程度，具体实现稍有不同。
不同点：

  • 1.1、Jedis

是 Redis 的 Java 实现的客户端。支持基本的数据类型如：String、Hash、List、Set、Sorted Set。
特点：使用阻塞的 I/O，方法调用同步，程序流需要等到 socket 处理完 I/O 才能执行，不支持异步操作。Jedis 客户端实例不是线程安全的，需要通过连接池来使用 Jedis。

  • 1.1、Redisson

优点点：分布式锁，分布式集合，可通过 Redis 支持延迟队列。

  • 1.3、 Lettuce

用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。
基于 Netty 框架的事件驱动的通信层，其方法调用是异步的。Lettuce 的 API 是线程安全的，所以可以操作单个 Lettuce 连接来完成各种操作。

二、Jedis

三、RedisTemplate

3.1、使用配置

Maven配置引入，（要加上版本号，这里是因为 Parent 已声明）

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>

application-dev.yml

  1. spring:
  2.   redis:
  3.     host: 192.168.1.140
  4.     port: 6379
  5.     password:
  6.     database: 15 # 指定redis的分库（共16个0到15）

3.2、使用示例

  3. @Override
  4. public CustomersEntity findById(Integer id) {
  5.     // 需要缓存
  6.     // 所有涉及的缓存都需要删除，或者更新
  7.     try {
  8.         String toString = stringRedisTemplate.opsForHash().get(REDIS_CUSTOMERS_ONE, id + "").toString();
  9.         if (toString != null) {
  10.             return JSONUtil.toBean(toString, CustomersEntity.class);
  11.         }
  12.     } catch (Exception e) {
  13.         e.printStackTrace();
  14.     }
  15.     // 缓存为空的时候，先查,然后缓存redis
  16.     Optional<CustomersEntity> byId = customerRepo.findById(id);
  17.     if (byId.isPresent()) {
  18.         CustomersEntity customersEntity = byId.get();
  19.         try {
  20.             stringRedisTemplate.opsForHash().put(REDIS_CUSTOMERS_ONE, id + "", JSONUtil.toJsonStr(customersEntity));
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.         }
  24.         return customersEntity;
  25.     }
  26.     return null;
  27. }

3.3、扩展

3.3.1、spring-boot-starter-data-redis 的依赖包

image.png

3.3.2、stringRedisTemplate API（部分展示）

opsForHash —> hash 操作
opsForList —> list 操作
opsForSet —> set 操作
opsForValue —> string 操作
opsForZSet —> Zset 操作
image.png

3.3.3、StringRedisTemplate 默认序列化机制

  1. public class StringRedisTemplate extends RedisTemplate<String, String> {
  3.     /**
  4.      * Constructs a new <code>StringRedisTemplate</code> instance. {@link #setConnectionFactory(RedisConnectionFactory)}
  5.      * and {@link #afterPropertiesSet()} still need to be called.
  6.      */
  7.     public StringRedisTemplate() {
  8.         RedisSerializer<String> stringSerializer = new StringRedisSerializer();
  9.         setKeySerializer(stringSerializer);
  10.         setValueSerializer(stringSerializer);
  11.         setHashKeySerializer(stringSerializer);
  12.         setHashValueSerializer(stringSerializer);
  13.     }
  14. }

四、RedissonClient 操作示例

4.1 基本配置

4.1.1、Maven pom 引入

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>
  5. <dependency>
  6.   <groupId>org.redisson</groupId>
  7.   <artifactId>redisson</artifactId>
  8.   <version>3.8.2</version>
  9.   <optional>true</optional>
  10. </dependency>
  11. <dependency>
  12.   <groupId>org.redisson</groupId>
  13.   <artifactId>redisson-spring-boot-starter</artifactId>
  14.   <version>LATEST</version>
  15. </dependency>

4.1.2、添加配置文件 Yaml 或者 json 格式

redisson-config.yml

  1. # Redisson 配置
  2. singleServerConfig:
  3.   address: "redis://192.168.1.140:6379"
  4.   password: null
  5.   clientName: null
  6.   database: 15 #选择使用哪个数据库0~15
  7.   idleConnectionTimeout: 10000
  8.   pingTimeout: 1000
  9.   connectTimeout: 10000
  10.   timeout: 3000
  11.   retryAttempts: 3
  12.   retryInterval: 1500
  13.   reconnectionTimeout: 3000
  14.   failedAttempts: 3
  15.   subscriptionsPerConnection: 5
  16.   subscriptionConnectionMinimumIdleSize: 1
  17.   subscriptionConnectionPoolSize: 50
  18.   connectionMinimumIdleSize: 32
  19.   connectionPoolSize: 64
  20.   dnsMonitoringInterval: 5000
  21.   #dnsMonitoring: false
  23. threads: 0
  24. nettyThreads: 0
  25. codec:
  26.   class: "org.redisson.codec.JsonJacksonCodec"
  27. transportMode: "NIO"

或者，配置 redisson-config.json

  1. {
  2.   "singleServerConfig": {
  3.     "idleConnectionTimeout": 10000,
  4.     "pingTimeout": 1000,
  5.     "connectTimeout": 10000,
  6.     "timeout": 3000,
  7.     "retryAttempts": 3,
  8.     "retryInterval": 1500,
  9.     "reconnectionTimeout": 3000,
  10.     "failedAttempts": 3,
  11.     "password": null,
  12.     "subscriptionsPerConnection": 5,
  13.     "clientName": null,
  14.     "address": "redis://192.168.1.140:6379",
  15.     "subscriptionConnectionMinimumIdleSize": 1,
  16.     "subscriptionConnectionPoolSize": 50,
  17.     "connectionMinimumIdleSize": 10,
  18.     "connectionPoolSize": 64,
  19.     "database": 0,
  20.     "dnsMonitoring": false,
  21.     "dnsMonitoringInterval": 5000
  22.   },
  23.   "threads": 0,
  24.   "nettyThreads": 0,
  25.   "codec": null,
  26.   "useLinuxNativeEpoll": false
  27. }

4.1.3、读取配置

新建读取配置类

  1. @Configuration
  2. public class RedissonConfig {
  4.     @Bean
  5.     public RedissonClient redisson() throws IOException {
  7.         // 两种读取方式，Config.fromYAML 和 Config.fromJSON
  8.         //        Config config = Config.fromJSON(RedissonConfig.class.getClassLoader().getResource("redisson-config.json"));
  9.         Config config = Config.fromYAML(RedissonConfig.class.getClassLoader().getResource("redisson-config.yml"));
  10.         return Redisson.create(config);
  11.     }
  12. }

或者，在 application.yml 中配置如下

  1. spring:
  2.   redis:
  3.     redisson:
  4.       config: classpath:redisson-config.yaml

4.2 使用示例

  1. @RestController
  2. @RequestMapping("/")
  3. public class TeController {
  5.     @Autowired
  6.     private RedissonClient redissonClient;
  8.     static long i = 20;
  9.     static long sum = 300;
  11.     //    ========================== String =======================
  12.     @GetMapping("/set/{key}")
  13.     public String s1(@PathVariable String key) {
  14.         // 设置字符串
  15.         RBucket<String> keyObj = redissonClient.getBucket(key);
  16.         keyObj.set(key + "1-v1");
  17.         return key;
  18.     }
  20.     @GetMapping("/get/{key}")
  21.     public String g1(@PathVariable String key) {
  22.         // 设置字符串
  23.         RBucket<String> keyObj = redissonClient.getBucket(key);
  24.         String s = keyObj.get();
  25.         return s;
  26.     }
  28.     //    ========================== hash =======================-=
  30.     @GetMapping("/hset/{key}")
  31.     public String h1(@PathVariable String key) {
  33.         Ur ur = new Ur();
  34.         ur.setId(MathUtil.randomLong(1,20));
  35.         ur.setName(key);
  36.         // 存放 Hash
  37.         RMap<String, Ur> ss = redissonClient.getMap("UR");
  38.         ss.put(ur.getId().toString(), ur);
  39.         return ur.toString();
  40.     }
  42.     @GetMapping("/hget/{id}")
  43.     public String h2(@PathVariable String id) {
  44.         // hash 查询
  45.         RMap<String, Ur> ss = redissonClient.getMap("UR");
  46.         Ur ur = ss.get(id);
  47.         return ur.toString();
  48.     }
  50.     // 查询所有的 keys
  51.     @GetMapping("/all")
  52.     public String all(){
  53.         RKeys keys = redissonClient.getKeys();
  54.         Iterable<String> keys1 = keys.getKeys();
  55.         keys1.forEach(System.out::println);
  56.         return keys.toString();
  57.     }
  59.     // ================== ==============读写锁测试 =============================
  61.     @GetMapping("/rw/set/{key}")
  62.     public void rw_set(){
  63.         //        RedissonLock.
  64.         RBucket<String> ls_count = redissonClient.getBucket("LS_COUNT");
  65.         ls_count.set("300",360000000l, TimeUnit.SECONDS);
  66.     }
  68.     // 减法运算
  69.     @GetMapping("/jf")
  70.     public void jf(){
  72.         String key = "S_COUNT";
  74.         //        RAtomicLong atomicLong = redissonClient.getAtomicLong(key);
  75.         //        atomicLong.set(sum);
  76.         //        long l = atomicLong.decrementAndGet();
  77.         //        System.out.println(l);
  79.         RAtomicLong atomicLong = redissonClient.getAtomicLong(key);
  80.         if (!atomicLong.isExists()) {
  81.             atomicLong.set(300l);
  82.         }
  84.         while (i == 0) {
  85.             if (atomicLong.get() > 0) {
  86.                 long l = atomicLong.getAndDecrement();
  87.                 try {
  88.                     Thread.sleep(1000l);
  89.                 } catch (InterruptedException e) {
  90.                     e.printStackTrace();
  91.                 }
  92.                 i --;
  93.                 System.out.println(Thread.currentThread().getName() + "->" + i + "->" + l);
  94.             }
  95.         }
  98.     }
  100.     @GetMapping("/rw/get")
  101.     public String rw_get(){
  103.         String key = "S_COUNT";
  104.         Runnable r = new Runnable() {
  105.             @Override
  106.             public void run() {
  107.                 RAtomicLong atomicLong = redissonClient.getAtomicLong(key);
  108.                 if (!atomicLong.isExists()) {
  109.                     atomicLong.set(300l);
  110.                 }
  111.                 if (atomicLong.get() > 0) {
  112.                     long l = atomicLong.getAndDecrement();
  113.                     i --;
  114.                     System.out.println(Thread.currentThread().getName() + "->" + i + "->" + l);
  115.                 }
  116.             }
  117.         };
  119.         while (i != 0) {
  120.             new Thread(r).start();
  121.             //            new Thread(r).run();
  122.             //            new Thread(r).run();
  123.             //            new Thread(r).run();
  124.             //            new Thread(r).run();
  125.         }
  128.         RBucket<String> bucket = redissonClient.getBucket(key);
  129.         String s = bucket.get();
  130.         System.out.println("================线程已结束================================" + s);
  132.         return s;
  133.     }
  135. }

4.3 扩展

4.3.1 丰富的 jar 支持，尤其是对 Netty NIO 框架

4.3.2 丰富的配置机制选择，这里是详细的配置说明

关于序列化机制中，就有很多
image.png
image.png
更多序列化机制详见：https://github.com/redisson/redisson/wiki/4.-data-serialization

4.3.3 API 支持（部分展示），具体的 Redis —> RedissonClient

image.png

4.3.4 轻便的丰富的锁机制的实现

4.3.4.1 Lock

4.3.4.2 Fair Lock

4.3.4.3 MultiLock

4.3.4.4 RedLock

4.3.4.5 ReadWriteLock

4.3.4.6 Semaphore

4.3.4.7 PermitExpirableSemaphore

4.3.4.8 CountDownLatch

五、基于注解实现的 Redis 缓存

5.1 Maven 和 YML 配置

参考 RedisTemplate 配置
另外，还需要额外的配置类

  1. // todo 定义序列化，解决乱码问题
  2. @EnableCaching
  3. @Configuration
  4. @ConfigurationProperties(prefix = "spring.cache.redis")
  5. public class RedisCacheConfig {
  7.     private Duration timeToLive = Duration.ZERO;
  9.     public void setTimeToLive(Duration timeToLive) {
  10.         this.timeToLive = timeToLive;
  11.     }
  13.     @Bean
  14.     public CacheManager cacheManager(RedisConnectionFactory factory) {
  15.         RedisSerializer<String> redisSerializer = new StringRedisSerializer();
  16.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  18.         // 解决查询缓存转换异常的问题
  19.         ObjectMapper om = new ObjectMapper();
  20.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  21.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  22.         jackson2JsonRedisSerializer.setObjectMapper(om);
  24.         // 配置序列化（解决乱码的问题）
  25.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
  26.                 .entryTtl(timeToLive)
  27.                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
  28.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
  29.                 .disableCachingNullValues();
  31.         RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
  32.                 .cacheDefaults(config)
  33.                 .build();
  34.         return cacheManager;
  35.     }
  37. }

5.2 使用示例

  1. @Transactional
  2. @Service
  3. public class ReImpl implements RedisService {
  5.     @Resource
  6.     private CustomerRepo customerRepo;
  7.     @Resource
  8.     private StringRedisTemplate stringRedisTemplate;
  10.     public static final String REDIS_CUSTOMERS_ONE = "Customers";
  12.     public static final String REDIS_CUSTOMERS_ALL = "allList";
  14.     // =====================================================================使用Spring cahce 注解方式实现缓存
  15.     // ==================================单个操作
  17.     @Override
  18.     @Cacheable(value = "cache:customer", unless = "null == #result",key = "#id")
  19.     public CustomersEntity cacheOne(Integer id) {
  20.         final Optional<CustomersEntity> byId = customerRepo.findById(id);
  21.         return byId.isPresent() ? byId.get() : null;
  22.     }
  24.     @Override
  25.     @Cacheable(value = "cache:customer", unless = "null == #result", key = "#id")
  26.     public CustomersEntity cacheOne2(Integer id) {
  27.         final Optional<CustomersEntity> byId = customerRepo.findById(id);
  28.         return byId.isPresent() ? byId.get() : null;
  29.     }
  31.      // todo 自定义redis缓存的key,
  32.     @Override
  33.     @Cacheable(value = "cache:customer", unless = "null == #result", key = "#root.methodName + '.' + #id")
  34.     public CustomersEntity cacheOne3(Integer id) {
  35.         final Optional<CustomersEntity> byId = customerRepo.findById(id);
  36.         return byId.isPresent() ? byId.get() : null;
  37.     }
  39.     // todo 这里缓存到redis，还有响应页面是String（加了很多转义符\,），不是Json格式
  40.     @Override
  41.     @Cacheable(value = "cache:customer", unless = "null == #result", key = "#root.methodName + '.' + #id")
  42.     public String cacheOne4(Integer id) {
  43.         final Optional<CustomersEntity> byId = customerRepo.findById(id);
  44.         return byId.map(JSONUtil::toJsonStr).orElse(null);
  45.     }
  47.      // todo 缓存json，不乱码已处理好,调整序列化和反序列化
  48.     @Override
  49.     @Cacheable(value = "cache:customer", unless = "null == #result", key = "#root.methodName + '.' + #id")
  50.     public CustomersEntity cacheOne5(Integer id) {
  51.         Optional<CustomersEntity> byId = customerRepo.findById(id);
  52.         return byId.filter(obj -> !StrUtil.isBlankIfStr(obj)).orElse(null);
  53.     }
  57.     // ==================================删除缓存
  58.     @Override
  59.     @CacheEvict(value = "cache:customer", key = "'cacheOne5' + '.' + #id")
  60.     public Object del(Integer id) {
  61.         // 删除缓存后的逻辑
  62.         return null;
  63.     }
  65.     @Override
  66.     @CacheEvict(value = "cache:customer",allEntries = true)
  67.     public void del() {
  69.     }
  71.     @CacheEvict(value = "cache:all",allEntries = true)
  72.     public void delall() {
  74.     }
  75.     // ==================List操作
  77.     @Override
  78.     @Cacheable(value = "cache:all")
  79.     public List<CustomersEntity> cacheList() {
  80.         List<CustomersEntity> all = customerRepo.findAll();
  81.         return all;
  82.     }
  84.     // todo 先查询缓存，再校验是否一致，然后更新操作，比较实用，要清楚缓存的数据格式（明确业务和缓存模型数据）
  85.     @Override
  86.     @CachePut(value = "cache:all",unless = "null == #result",key = "#root.methodName")
  87.     public List<CustomersEntity> cacheList2() {
  88.         List<CustomersEntity> all = customerRepo.findAll();
  89.         return all;
  90.     }
  92. }

5.3 扩展

基于 spring 缓存实现
image.png