SpringBoot整合Redis

SpringBoot整合Redis,第1张

我们之所以要学习Redis,是要令我们Java程序更加有效率,我们在使用数据库的时候给它加上一个缓存中间件,就是用来提高我们程序的效率的,那么当然,Redis还是要集成到我们SpringBoot项目里面的!!

整合也非常简单,新建一个SpringBoot项目,导入相关依赖

 只要把这些选项勾起来,那么SpringBoot在创建项目的时候就会自动帮我们导入所需要的依赖!

    
		
         org.springframework.boot
         spring-boot-starter-data-redis
     
			
     
         org.springframework.boot
         spring-boot-starter-web
     
		
     
         org.springframework.boot
         spring-boot-devtools
         runtime
         true
     

     
         org.springframework.boot
         spring-boot-configuration-processor
         true
     
		
     
         org.projectlombok
         lombok
         true
     
     
         org.springframework.boot
         spring-boot-starter-test
         test
     

到我们SpringBoot2.x版本,其内置的Redis中间件再也不是Jedis了,而是换成了lettuce。我们点进redis依赖就可以发现

那么lettuce是什么呢,其与Jedis有什么区别呢?

  • lettuce: Lettuce 是 一种可伸缩,线程安全,完全非阻塞的Redis客户端,多个线程可以共享一个RedisConnection,它利用Netty NIO 框架来高效地管理多个连接,从而提供了异步和同步数据访问方式,用于构建非阻塞的反应性应用程序。

  • Jedis: Jedis 在实现上是直连 redis server,多线程环境下非线程安全,除非使用连接池,为每个 redis实例增加 物理连接。 这种方式更加类似于我们 BIO 一条线程连一个客户端,并且是阻塞式的,会一直连接着客户端等待客户端的命令

那么导入这个redis,根据我们之前学习SpringBoot,我们知道一定有一个Properties配置类去配置我们的Redis的

那么我们在IDEA中双击shift查看

点进这个类中查看可以配置什么  

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
 
 // redis的模板实例,可以帮助我们快速 *** 作redis
	@Bean
 // 如果这个名为redisTemplate实例不存在的话,该bean生效,那么我们可以代替SpringBoot,自定义我们的redis模板实例!!!
	@ConditionalOnMissingBean(name = "redisTemplate")
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) 	  {
		RedisTemplate template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

 // 因为我们很多情况都是 *** 作String类型的数据,那么这个类帮我们也配置了String的redis模板供我们使用!
 // 其方法与上面的redisTemplate一样
	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
 {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}
}

我们点进这个RedisProperties类中查看相关配置!

可以看到我们可以在SpringBoot配置文件中配置以下东西

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {

	/**
	 * 可以配置使用的db下标
	 */
	private int database = 0;

	/**
	 * 这个配置可以让我们连接到远程的redis中。例如:
	 * redis://user:password@example.com:6379
	 */
	private String url;

	/**
	 * Redis服务端的主机名
	 */
	private String host = "localhost";

	/**
	 * Login username of the redis server.
	 */
	private String username;

	/**
	 * Login password of the redis server.
	 */
	private String password;

	/**
	 * Redis的端口号
	 */
	private int port = 6379;

	/**
	 * 是否开启安全认证
	 */
	private boolean ssl;

	/**
	 * Read timeout.
	 */
	private Duration timeout;

	/**
	 * Connection timeout.
	 */
	private Duration connectTimeout;

	/**
	 * Client name to be set on connections with CLIENT SETNAME.
	 */
	private String clientName;

	/**
	 * Type of client to use. By default, auto-detected according to the classpath.
	 */
	private ClientType clientType;

	private Sentinel sentinel;

	private Cluster cluster;
}

其中主机名和端口号都有默认值,如果我们连自己的电脑,那么这两个配置都可以不用修改!

我们这里不用修改配置文件,就使用默认的即可!

测试连接

那么从我们导入redis的依赖,就可以使用了,我们现在来测试一下连接!

 //自动注入redisTemplate
	@Autowired
 private RedisTemplate redisTemplate;
 @Test
 void contextLoads() {
      //获取redis数据库连接对象
     RedisConnectionFactory connectionFactory = redisTemplate.getConnectionFactory();
     RedisConnection connection = connectionFactory.getConnection();
     
     // 往Redis服务端中设置一个String类型的key,值为zhangsan
     redisTemplate.opsForValue().set("name","zhangsan");
     // 获取并打印这个key的值
     System.out.println(redisTemplate.opsForValue().get("name"));
 }

我们还需要在window系统中开启我们的Redis服务端!

测试结果

zhangsan       # 控制台成功打印出key的值

我们连接Redis客户端,再获取这个key

127.0.0.1:6379> ping			# 测试连接
PONG
127.0.0.1:6379> get name		# 获取key中的value
"zhangsan"					   # 返回zhangsan,测试成功!

那么现在我们能在SpringBoot项目中使用Redis了,但是我们如果存中文的话会发生乱码!例如

redisTemplate.opsForValue().set("name","张三");				//往value中添加中文
System.out.println(redisTemplate.opsForValue().get("name"));

那么再次测试Redis

张三			# 控制台可以输出中文

Redis客户端获取key

127.0.0.1:6379> keys *
1) "\xac\xed\x00\x05t\x00\x04name"			# key乱码了

我们在分析Redis配置文件中也发现了我们的RedisTemplate时可以让我们配置的,那么默认的RedisTemplate给我们配置了什么?

点进这个类中看一下

public class RedisTemplate extends RedisAccessor implements RedisOperations, 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;
 public void afterPropertiesSet() {

		super.afterPropertiesSet();

		boolean defaultUsed = false;

		if (defaultSerializer == null) {
			// 默认的序列化方式为JDK中自带的序列化
			defaultSerializer = new JdkSerializationRedisSerializer(
					classLoader != null ? classLoader : this.getClass().getClassLoader());
		}

		if (enableDefaultSerializer) {
			// 因为我们并没有设置其序列化的实例,那么在创建这个RedisTemplate实例的时候,全部都默认成了JDK的序列化方式!
			if (keySerializer == null) {
				keySerializer = defaultSerializer;
				defaultUsed = true;
			}
			if (valueSerializer == null) {
				valueSerializer = defaultSerializer;
				defaultUsed = true;
			}
			if (hashKeySerializer == null) {
				hashKeySerializer = defaultSerializer;
				defaultUsed = true;
			}
			if (hashValueSerializer == null) {
				hashValueSerializer = defaultSerializer;
				defaultUsed = true;
			}
		}

		if (enableDefaultSerializer && defaultUsed) {
			Assert.notNull(defaultSerializer, "default serializer null and not all serializers initialized");
		}

		if (scriptExecutor == null) {
			this.scriptExecutor = new DefaultScriptExecutor<>(this);
		}

		initialized = true;
	}
 ........
}

我们可以知道,如果我们不配置RedisTemplate的序列化方式,默认的是使用JDK中的序列化方式,那么我们点进这个JdkSerializationRedisSerializer类中看看

点进深层我们发现,里面其实创建了一个序列化转换器,而转换器默认的构造方法是JDK默认的序列化工具,其实现了Serializer接口

void serialize(T object, OutputStream outputStream) throws IOException;

因为我们java使用ISO-8859-1编码进行传输数据的,那么我们传输字符串的话,那么编解码会不一致,一定会出现乱码!!!

所以我们得自己重写一个RedisTemplate来修改默认的序列化方式!

我们从上面分析可以知道,当我们的类中出现以redisTemplate命名的bean的时候,SpringBoot的配置将不会生效!

那我们来接管一下这个redisTemplate

// 标志为配置类
@Configuration
public class RedisConfig {
 
	// 把这个bean的name设置为redisTemplate,这样我们才能全面接管redisTemplate!
 @Bean(name = "redisTemplate")
 public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)     {
     RedisTemplate template = new RedisTemplate<>();
     template.setConnectionFactory(redisConnectionFactory);
     // jackson序列化所有的类
     Jackson2JsonRedisSerializer Jackson2JsonRedisSerializer = new 			  Jackson2JsonRedisSerializer(Object.class);
     // jackson序列化的一些配置
     ObjectMapper om = new ObjectMapper();
     om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
     om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance);
     Jackson2JsonRedisSerializer.setObjectMapper(om);
     // String的序列化
     StringRedisSerializer stringSerializer = new StringRedisSerializer();

     //将我们的key采用String的序列化方式
     template.setKeySerializer(stringSerializer);
     //将我们的hash的key也采用String的序列化方式
     template.setHashKeySerializer(stringSerializer);
     //value采用jackson序列化方式
     template.setValueSerializer(Jackson2JsonRedisSerializer);
     //hash的value也采用jackson序列化方式
     template.setHashValueSerializer(Jackson2JsonRedisSerializer);

     template.afterPropertiesSet();


     return template;
 }

 我们继续来编写一个简单的实体类,其中这个类必须要实现序列化!!!!不然直接报错,因为这个类不能序列化

@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
//我们的实体类全部需要序列化!
public class User implements Serializable {
 private String name;
 private int age;
}

我们测试一下

	    User user = new User("李四",3);
     redisTemplate.opsForValue().set("lisi",user);

我们这里使用Redis Desktop Manager可视化工具来查看结果

我们看到,key和value不再乱码了,乱码问题解决!!!

我们这里不使用cmd命令行去查看结果的原因是,其编码格式是使用GBK编码的,value还是会乱码!

Redis工具类

我们在SpringBoot中去 *** 作Redis总是要写这么几个方法

redisTemplate.opsForValue().set();

那么当我们频繁 *** 作Redis的时候,这就会显得代码很冗余,加大了维护成本!

所以我们要编写自己的工具类去封装Redis中的方法!

这里只截取一部分,只要注入我们的redisTemplate,封装里面常用的的方法即可

@Service
public class RedisUtil {
 @Autowired
 private RedisTemplate redisTemplate;

 /**
     * 写入缓存
  *
     * @param key
     * @param value
     * @return
  */
 public boolean set(final String key, Object value) {
     boolean result = false;
     try {
         ValueOperations operations = redisTemplate.opsForValue();
         operations.set(key, value);
         result = true;
     } catch (Exception e) {
         e.printStackTrace();
     }
     return result;
 }

 /**
     * 写入缓存设置时效时间
  *
     * @param key
     * @param value
     * @return
  */
 public boolean set(final String key, Object value, Long expireTime, TimeUnit timeUnit) {
     boolean result = false;
     try {
         ValueOperations operations = redisTemplate.opsForValue();
         operations.set(key, value);
         redisTemplate.expire(key, expireTime, timeUnit);
         result = true;
     } catch (Exception e) {
         e.printStackTrace();
     }
     return result;
 }

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/langs/870910.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-05-13
下一篇 2022-05-13

发表评论

登录后才能评论

评论列表(0条)

保存