深入浅出Redis(十三):SpringBoot整合Redis客户端

本文涉及的产品
云数据库 Redis 版,社区版 2GB
推荐场景:
搭建游戏排行榜
简介: 深入浅出Redis(十三):SpringBoot整合Redis客户端

引言

Redis是一款性能高效的键值对数据库,之前的多篇文章深入浅出的分析Redis的原理,这篇文章主要来说明从代码层面来使用Redis

本篇文章将使用Java语言并整合SpringBoot分别来使用Jedis、以及SpringBoot封装的Lettuc两种方式作为Redis客户端来使用Redis

Jedis

Jedis是Redis官方推荐Java操作Redis服务端的客户端,封装一系列与redis客户端命令同名的API提供调用

使用 Jedis

  1. 将idea(开发工具)的JDK调为8
  2. 导入Maven依赖
 <dependencies>
         <!-- json解析工具 -->
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>fastjson</artifactId>
             <version>1.2.49</version>
         </dependency>
         <!--Jedis-->
         <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
         <dependency>
             <groupId>redis.clients</groupId>
             <artifactId>jedis</artifactId>
             <version>2.9.0</version>
         </dependency>
 </dependencies>
  1. 测试环境是否成功
 //Jedis源码:  
 public Jedis(final String host, final int port) {
     super(host, port);
 }
 public class TestJedis {
     public static void main(String[] args) {
         Jedis jedis = new Jedis("127.0.0.1",6379);
         //输出pong 成功!
         System.out.println(jedis.ping());
     }
 }
 ​
  1. 练习事务
 package com.liang;
 ​
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.Transaction;
 ​
 public class TestJedis {
     public static void main(String[] args) {
         //使用fastjson将实体类转换为json格式
         JSONObject jsonObject = new JSONObject();
         jsonObject.put("name","Tc.l");
         jsonObject.put("age",99);
         //{"name":"Tc.l","age":99}
         String jsonString = jsonObject.toJSONString();
 ​
         Jedis jedis = new Jedis("127.0.0.1",6379);
         //清空数据库
         jedis.flushDB();
         //watch命令 监听key: {"name":"Tc.l","age":99}
         jedis.watch(jsonString);
         //开启事务
         Transaction multi = jedis.multi();
         try {
             //key=user1,value={"name":"Tc.l","age":99}
             multi.set("user1",jsonString);
             //key=user2,value={"name":"Tc.l","age":99}
             multi.set("user2",jsonString);
             //执行事务
             multi.exec();
         } catch (Exception e) {
             e.printStackTrace();
             //如果异常,放弃事务
             multi.discard();
         }finally {
             //{"name":"Tc.l","age":99}
             System.out.println(jedis.get("user1"));
             //{"name":"Tc.l","age":99}
             System.out.println(jedis.get("user2"));
             //关闭连接
             jedis.close();
         }
     }
 }

SpringBoot操作Redis

Jedis:采用直连,多个线程操作不安全,如果要避免不安全就要使用jedis pool连接池,类似BIO模式

Lettuce:采用netty,实例可以在多个线程中共享,不存在线程不安全,可以减少线程数据,类似NIO模式

SpringBoot 2之后,原来使用的Jedis替换为Lettuce

导入maven依赖

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>

源码分析

RedisAutoConfiguration源码:

 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(RedisOperations.class)
 @EnableConfigurationProperties(RedisProperties.class)
 @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
 public class RedisAutoConfiguration {
 ​
     @Bean
     @ConditionalOnMissingBean(name = "redisTemplate")
     //可以自定义RedisTemplate来替换这个默认的"redisTemplate"
     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
             throws UnknownHostException {
         //默认的redisTemplate没有过多的设置,redis对象都需要序列化
         //俩个泛型都是object ,我们常用的是 <String,Object> 还需要强制转换,用默认的非常麻烦,所以还是自定义的好
         RedisTemplate<Object, Object> template = new RedisTemplate<>();
         template.setConnectionFactory(redisConnectionFactory);
         return template;
     }
 ​
     @Bean
     @ConditionalOnMissingBean
     //String比较常用所以说单独提出来一个bean
     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
             throws UnknownHostException {
         StringRedisTemplate template = new StringRedisTemplate();
         template.setConnectionFactory(redisConnectionFactory);
         return template;
     }
 ​
 }

RedisTemplate源码:

 public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
 ​
     //...
     //序列化配置
     @SuppressWarnings("rawtypes") private @Nullable RedisSerializer keySerializer = null;
     @SuppressWarnings("rawtypes") private @Nullable RedisSerializer valueSerializer = null;
     @SuppressWarnings("rawtypes") private @Nullable RedisSerializer hashKeySerializer = null;
     @SuppressWarnings("rawtypes") private @Nullable RedisSerializer hashValueSerializer = null;
     
     //...
     
     @Override
     public void afterPropertiesSet() {
         //...
         if (defaultSerializer == null) {
             //默认序列化方式,使用的JDK的序列化,我们中文会乱码,可以自定义json的序列化
             defaultSerializer = new JdkSerializationRedisSerializer(
                     classLoader != null ? classLoader : this.getClass().getClassLoader());
         }
         //...
     }
 }

RedisAutoConfiguration自动配置类绑定的配置文件RedisProperties

 @ConfigurationProperties(prefix = "spring.redis")
 public class RedisProperties {
     private int database = 0;//默认使用第一个数据库
     private String url;
     private String host = "localhost"; //默认本机
     //...
 }

点击查看JedisConnectionConfiguration.class发现@ConditionalOnClass报红 说明条件未满足不能使用

点击查看LettuceConnectionConfiguration.class发现@ConditionalOnClass没报红 说明条件满足可以使用

这也就是前面说的spring boot 2后使用lettuce替换了jedis

测试

设置字符串:

 @SpringBootTest
 class SpringbootRedis01ApplicationTests {
     @Autowired
     RedisTemplate redisTemplate;
     @Test
     void contextLoads() {
         /*
         *redisTempalte 操作不同的数据类型 操作API与指令几乎一样
         *opsForValue()  操作String
         *opsForHash()
         *opsForList()
         *opsForSet()
         *opsForZSet()
         *opsForGeo()
         *opsForHyperLogLog()
         *multi()
         * */
         //获得redis连接对象 操作数据库
         RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
         connection.flushAll();
         redisTemplate.opsForValue().set("name","chenliang");
         System.out.println(redisTemplate.opsForValue().get("name"));
     }
 }

结果:chenliang

打开redis客户端(Windows)

keys * 查看: "\xac\xed\x00\x05t\x00\x04name" 发现name前面有一堆中文乱码(因为它是jdk序列化的)

设置对象(如果不序列化对象会报异常SerializationException):

 @AllArgsConstructor
 @NoArgsConstructor
 @Data
 public class User implements Serializable {
     private String name;
     private int age;
 }

测试

 User user = new User("chenliang", 18);
 redisTemplate.opsForValue().set("user",user);
 System.out.println(redisTemplate.opsForValue().get("user"));

结果:

User(name=chenliang, age=18)

自定义RedisTemplate

 package com.liang.config;
 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
 import com.fasterxml.jackson.databind.JsonSerializable;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 import java.net.UnknownHostException;
 ​
 @Configuration
 public class RedisConfig {
     // 自己定义了一个 RedisTemplate
     @Bean
     @SuppressWarnings("all")
     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
         // 我们为了自己开发方便,一般直接使用 <String, Object>
         RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
         template.setConnectionFactory(factory);
 ​
         // Json序列化配置
         //json解析任意对象变成一个json序列化
         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
         //使用ObjectMapper转义
         ObjectMapper om = new ObjectMapper();
         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
         jackson2JsonRedisSerializer.setObjectMapper(om);
         // String 的序列化
         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
 ​
         // key采用String的序列化方式
         template.setKeySerializer(stringRedisSerializer);
         // hash的key也采用String的序列化方式
         template.setHashKeySerializer(stringRedisSerializer);
         // value序列化方式采用jackson
         template.setValueSerializer(jackson2JsonRedisSerializer);
         // hash的value序列化方式采用jackson
         template.setHashValueSerializer(jackson2JsonRedisSerializer);
         template.afterPropertiesSet();
         return template;
     }
 }

@SuppressWarnings("all")抑制所有警告(类中有的方法过期警告)

     setKeySerializer(RedisSerializer<?>)
     setHashKeySerializer(RedisSerializer<?>)
     setValueSerializer(RedisSerializer<?>)
     setHashValueSerializer(RedisSerializer<?>)

可以选择的RedisSerializer<?>:

image.png

测试

 @SpringBootTest
 class SpringbootRedis01ApplicationTests {
     @Autowired
     @Qualifier("myRedisTemplate")
     RedisTemplate redisTemplate;
     @Test
     void contextLoads() {
         RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
         connection.flushAll();
         User user = new User("chenliang", 18);
         redisTemplate.opsForValue().set("user",user);
         System.out.println(redisTemplate.opsForValue().get("user"));
     }
 }

客户端中不再乱码(换成json序列化之后)

 127.0.0.1:6379> keys *
 1) "user"
 127.0.0.1:6379> get user
 "["com.liang.entity.User",{"name":"chenliang","age":18}]"

总结

本篇文章在SpringBoot中简单的使用Jedis和Spring Boot封装的 Lettuce客户端,Spring Boot封装的 Lettuce客户端默认情况下是使用JDK序列化,通常是使用JSON格式进行序列化,需要自定义序列化方式将key、value都设置为使用json格式序列化


相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
相关文章
|
3天前
|
存储 NoSQL Java
在Spring Boot中使用Redis生成订单号,并且保证当天有效性
在Spring Boot中使用Redis生成订单号,并且保证当天有效性
20 4
|
3天前
|
缓存 NoSQL Java
在 Spring Boot 应用中使用 Spring Cache 和 Redis 实现数据查询的缓存功能
在 Spring Boot 应用中使用 Spring Cache 和 Redis 实现数据查询的缓存功能
11 0
|
1天前
|
NoSQL Java Redis
SpringBoot + Redis 执行lua脚本
SpringBoot + Redis 执行lua脚本
|
2天前
|
存储 缓存 NoSQL
springboot redis-cache 自动刷新缓存
springboot redis-cache 自动刷新缓存
|
3天前
|
监控 NoSQL Java
在 Spring Boot 中实现 Redis 的发布/订阅功能可以通过 RedisTemplate 和消息监听器来完成
在 Spring Boot 中实现 Redis 的发布/订阅功能可以通过 RedisTemplate 和消息监听器来完成
7 1
|
18天前
|
NoSQL 大数据 Redis
分享5款.NET开源免费的Redis客户端组件库
分享5款.NET开源免费的Redis客户端组件库
|
19天前
|
NoSQL Java Redis
【Redis】 Java操作客户端命令——列表操作与哈希操作
【Redis】 Java操作客户端命令——列表操作与哈希操作
|
19天前
|
NoSQL Java Linux
【Redis】 使用Java操作Redis的客户端
【Redis】 使用Java操作Redis的客户端
|
1天前
|
NoSQL 安全 Linux
springboot+shiro+redis前后端分离实现认证(一)
springboot+shiro+redis前后端分离实现认证(一)
4 0
|
1天前
|
缓存 NoSQL Java
windows下Springboot部署redis
windows下Springboot部署redis
5 0