每次学习到新的知识，最期待的一步就是整合SpringBoot，这真的很令人兴奋！废话少说，我们赶快开始进行SpringBoot整合Redis的学习！
SpringBoot整合RedisSpring整合Redis要借助SpringData，之前使用的是jedis，现在被替换成了lettuce
替换原因：
jedis采用直连方式，多个线程操作的话是不安全的，如果想要避免这个问题，就需要使用连接池技术，会发生阻塞。
lettuce底层使用netty，实例可以在多个线程中共享，不存在线程不安全的情况，可以减少线程，发生阻塞的情况相比于jedis少，性能也就更加优秀。
1.导入依赖
org.springframework.boot spring-boot-starter-data-redis
2.在配置文件中配置Redis连接(两种配置文件选其一，看自己配置文件的尾缀)
在application.properties文件中配置Redis连接
spirng.redis.host=127.0.0.1 spring.redis.port=6379
在application.yml文件中配置
spring:
# redis配置
redis:
# 连接主机IP
host: 127.0.0.1
# 端口号
port: 6800
# 超时时间
timeout: 3000ms
# 默认数据库
database: 0
# 密码
password: 123456
# lettuce连接池
lettuce:
pool:
max-active: 8
min-idle: 0
max-idle: 8
max-wait: -1ms
3.测试连接
package com.test;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
@SpringBootTest
class RedisSpringBootApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
// redisTemplate 用来操作不同数据类型，操作方法及释义↓
// opsForValue 操作字符串
// opsForList 操作list集合
// opsForSet 操作set集合
// opsForHash 操作hash集合
// opsForZset 操作Zset集合
// opsForGeo 操作地理位置
// opsForHyperloglog 操作hyperloglog
// opsForStream 操作Bitmap
// opsForCluster 操作集群
//获取Redis数据库连接
RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
// 测试数据库连接
connection.ping();
// 清空当前数据库
connection.flushDb();
// 清空全部数据库
connection.flushAll();
}
}
我们连接上了Redis后会有一个问题，就是当前我们连接的Redis是没有序列化的，也就是说我们在Java代码中输入的中文，在Redis服务器上打开会显示乱码，我们需要自己自定义一个配置类来解决这个问题。
并且一般情况下我们不会传Java对象作为value，我们都会先将Java对象转换成JSON字符串后进行传输。
自定义配置类进行序列化
package com.test.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypevalidator;
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 {
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
RedisTemplate template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
// Json序列化配置
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.activateDefaultTyping(LaissezFaireSubTypevalidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
// String序列化配置
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key 与 hash类型的key使用String类型的序列化
template.setKeySerializer(stringRedisSerializer);
template.setHashKeySerializer(stringRedisSerializer);
// value 与 hash类型的value使用json类型的序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashValueSerializer(jackson2JsonRedisSerializer);
// 保存修改
template.afterPropertiesSet();
return template;
}
}
最后友情附送一下Redis工具类，对底层常用方法进行封装，手打了一个多小时QAQ
package com.test.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public final class RedisUtil {
@Autowired
private RedisTemplate redisTemplate;
// =============================公共============================
public boolean expire(String key, long time) {
try{
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
}catch (Exception e) {
e.printStackTrace();
return false;
}
}
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
public boolean hasKey(String key) {
try{
return redisTemplate.hasKey(key);
}catch (Exception e) {
e.printStackTrace();
return false;
}
}
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
}else {
redisTemplate.delete((Collection) CollectionUtils.arrayToList(key));
}
}
}
// ==============================String====================================================
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
public boolean set(String key, Object value) {
try{
redisTemplate.opsForValue().set(key, value);
return true;
}catch (Exception e) {
e.printStackTrace();
return false;
}
}
public boolean set(String key, Object value, long time) {
try{
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
}else {
set(key, value);
}
return true;
}catch (Exception e) {
e.printStackTrace();
return false;
}
}
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
public long decr(String key, long delta) {
if (delta > 0) {
throw new RuntimeException("递减因子必须小于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ============================Hash==========================================
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
public Map hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
public boolean hmset(String key, Map map) {
try{
redisTemplate.opsForHash().putAll(key, map);
return true;
}catch (Exception e) {
e.printStackTrace();
return false;
}
}
public boolean hmset(String key, Map map, long time) {
try{
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
}catch (Exception e) {
e.printStackTrace();
return false;
}
}
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
public boolean hHaskey(String key, Object item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ===============================Set=============================================
public Set
下一篇请戳↓
Redis学习笔记(五)——持久化及redis.conf配置文件叙述
