SpringBoot系列十：SpringBoot整合Redis
本文内容纲要：
声明：本文来源于MLDN培训视频的课堂笔记，写在这里只是为了方便查阅。
1、概念：SpringBoot整合Redis
2、背景
Redis的数据库的整合在java里面提供的官方工具包：jedis，所以即便你现在使用的是SpringBoot，那么也继续使用此开发包。
2.1、RedisTemplate模版操作
在Spring支持的Redis操作之中提供有一个RedisTemplate处理程序类，利用这个类可以非常方便的实现Redis的各种基本数据操作。
1、修改项目中的pom.xml配置文件，追加redis的依赖引用：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、如果要想使用Redis操作，则一定要修改application.yml配置文件，在这个配置文件之中要进行Redis的各种连接配置处理；
spring:
redis:
host:192.168.68.166
port:6379
password:studyjava
timeout:1000
database:0
pool:
max-active:10
max-idle:8
min-idle:2
max-wait:100
3、下面就可以通过程序来利用RedisTemplate模版进行数据处理了，因为以上的配置一旦完成之后会在Spring内部帮助用户直接获得一个RedisTemplate模版处理对象，为了简单，直接建立一个测试类完成：
packagecn.study.microboot;
importjavax.annotation.Resource;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.boot.test.context.SpringBootTest;
importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
importorg.springframework.test.context.web.WebAppConfiguration;
@SpringBootTest(classes=StartSpringBootMain.class)
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
publicclassTestRedis{
@Resource
privateRedisTemplate<String,String>redisTemplate;
@Test
publicvoidtestSet(){
this.redisTemplate.opsForValue().set("study","java");
System.out.println(this.redisTemplate.opsForValue().get("study"));
}
}
则此时就可以利用Redis实现在SpringBoot中的数据存储操作了。
2.2、Redis对象序列化操作
虽然以上的代码实现了Redis基础的数据操作，但是遗憾的是在Java开发领域内必须要考虑一个实际的问题，那么就是对象的序列化保存问题，毕竟Redis数据库的读写速度是非常快的，但是如果不能够进行对象的存储，这样的存储意义就不大了，这样就需要准备一个对象的序列化处理程序类，通过对象的形式进行数据的存储。
1、如果要想进行Redis对象序列化操作则一定要首先准备一个序列化处理程序类，这个程序类有实现要求：
packagecn.study.microboot.util.redis;
importorg.springframework.core.convert.converter.Converter;
importorg.springframework.core.serializer.support.DeserializingConverter;
importorg.springframework.core.serializer.support.SerializingConverter;
importorg.springframework.data.redis.serializer.RedisSerializer;
importorg.springframework.data.redis.serializer.SerializationException;
//此时定义的序列化操作表示可以序列化所有类的对象，当然，这个对象所在的类一定要实现序列化接口
publicclassRedisObjectSerializerimplementsRedisSerializer<Object>{
//为了方便进行对象与字节数组的转换，所以应该首先准备出两个转换器
privateConverter<Object,byte[]>serializingConverter=newSerializingConverter();
privateConverter<byte[],Object>deserializingConverter=newDeserializingConverter();
privatestaticfinalbyte[]EMPTY_BYTE_ARRAY=newbyte[0];//做一个空数组，不是null
@Override
publicbyte[]serialize(Objectobj)throwsSerializationException{
if(obj==null){//这个时候没有要序列化的对象出现，所以返回的字节数组应该就是一个空数组
returnEMPTY_BYTE_ARRAY;
}
returnthis.serializingConverter.convert(obj);//将对象变为字节数组
}
@Override
publicObjectdeserialize(byte[]data)throwsSerializationException{
if(data==null||data.length==0){//此时没有对象的内容信息
returnnull;
}
returnthis.deserializingConverter.convert(data);
}
}
2、此时如果要想让RedisTemplate操作模版知道有这样一个序列化程序类存在，那么就不能够采用RedisTemplate默认配置形式，需要准备一个单独的配置类进行处理：
packagecn.study.microboot.config;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.data.redis.connection.RedisConnectionFactory;
importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.data.redis.serializer.StringRedisSerializer;
importcn.study.microboot.util.redis.RedisObjectSerializer;
@Configuration
publicclassRedisConfig{
@Bean
publicRedisTemplate<String,Object>getRedisTemplate(
RedisConnectionFactoryfactory){
RedisTemplate<String,Object>redisTemplate=newRedisTemplate<String,Object>();
redisTemplate.setConnectionFactory(factory);
redisTemplate.setKeySerializer(newStringRedisSerializer());//key的序列化类型
redisTemplate.setValueSerializer(newRedisObjectSerializer());//value的序列化类型
returnredisTemplate;
}
}
3、进行程序的测试使用：
packagecn.study.microboot.vo;
importjava.io.Serializable;
@SuppressWarnings("serial")
publicclassMemberimplementsSerializable{
privateStringmid;
privateIntegerage;
publicStringgetMid(){
returnmid;
}
publicvoidsetMid(Stringmid){
this.mid=mid;
}
publicIntegergetAge(){
returnage;
}
publicvoidsetAge(Integerage){
this.age=age;
}
@Override
publicStringtoString(){
return"Member[mid="+mid+",age="+age+"]";
}
}
packagecn.study.microboot;
importjavax.annotation.Resource;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.boot.test.context.SpringBootTest;
importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
importorg.springframework.test.context.web.WebAppConfiguration;
importcn.mldn.microboot.vo.Member;
@SpringBootTest(classes=StartSpringBootMain.class)
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
publicclassTestRedis{
@Resource
privateRedisTemplate<String,Object>redisTemplate;
@Test
publicvoidtestGet(){
System.out.println(this.redisTemplate.opsForValue().get("study"));
}
@Test
publicvoidtestSet(){
Membervo=newMember();
vo.setMid("studyjava");
vo.setAge(19);
this.redisTemplate.opsForValue().set("study",vo);;
}
}
此时可以进行对象的序列化保存处理，这样整体的数据存储的手段可以更加的丰富。
2.3、配置多个RedisTemplate
由于在项目的实际开发过程之中Redis的使用会非常的频繁，那么就有可能出现这样一种问题：现在的项目里面要求连接两个Redis数据库。SpringBoot里面针对于Redis的连接配置本质上只提供有一个连接配置项，那么如果你真的需要进行更多的Redis的连接配置，那么就需要自己来进行Redis的创建管理了。
1、以非正规的形式修改application.yml配置文件：
spring:
redis:
host:192.168.68.166
port:6379
password:studyjava
timeout:1000
database:0
pool:
max-active:10
max-idle:8
min-idle:2
max-wait:100
redis-two:
host:192.168.68.166
port:6380
password:studyjava
timeout:1000
database:0
pool:
max-active:10
max-idle:8
min-idle:2
max-wait:100
2、建立一个RedisTwoConfig的程序配置类，进行第二个Redis连接的配置处理：
packagecn.study.microboot.config;
importorg.springframework.beans.factory.annotation.Value;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.data.redis.connection.RedisConnectionFactory;
importorg.springframework.data.redis.connection.jedis.JedisConnectionFactory;
importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.data.redis.serializer.StringRedisSerializer;
importcn.study.microboot.util.redis.RedisObjectSerializer;
importredis.clients.jedis.JedisPoolConfig;
@Configuration
publicclassRedisTwoConfig{
publicRedisConnectionFactorygetRedisConnectionFactory(StringhostName,
Stringpassword,intport,intmaxActive,intmaxIdle,intminIdle,
longmaxWait,intdatabase){//是负责建立Factory的连接工厂类
JedisConnectionFactoryjedisFactory=newJedisConnectionFactory();
jedisFactory.setHostName(hostName);
jedisFactory.setPort(port);
jedisFactory.setPassword(password);
jedisFactory.setDatabase(database);
JedisPoolConfigpoolConfig=newJedisPoolConfig();//进行连接池配置
poolConfig.setMaxTotal(maxActive);
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
poolConfig.setMaxWaitMillis(maxWait);
jedisFactory.setPoolConfig(poolConfig);
jedisFactory.afterPropertiesSet();//初始化连接池配置
returnjedisFactory;
}
@Bean("redisTwo")
publicRedisTemplate<String,Object>getRedisTemplate(
@Value("${spring.redis-two.host}")StringhostName,
@Value("${spring.redis-two.password}")Stringpassword,
@Value("${spring.redis-two.port}")intport,
@Value("${spring.redis-two.database}")intdatabase,
@Value("${spring.redis-two.pool.max-active}")intmaxActive,
@Value("${spring.redis-two.pool.max-idle}")intmaxIdle,
@Value("${spring.redis-two.pool.min-idle}")intminIdle,
@Value("${spring.redis-two.pool.max-wait}")longmaxWait){
RedisConnectionFactoryfactory=this.getRedisConnectionFactory(
hostName,password,port,maxActive,maxIdle,minIdle,maxWait,
database);//建立Redis的连接
RedisTemplate<String,Object>redisTemplate=newRedisTemplate<String,Object>();
redisTemplate.setConnectionFactory(factory);
redisTemplate.setKeySerializer(newStringRedisSerializer());//key的序列化类型
redisTemplate.setValueSerializer(newRedisObjectSerializer());//value的序列化类型
returnredisTemplate;
}
}
3、编写测试程序类：
packagecn.study.microboot;
importjavax.annotation.Resource;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.boot.test.context.SpringBootTest;
importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
importorg.springframework.test.context.web.WebAppConfiguration;
importcn.study.microboot.vo.Member;
@SpringBootTest(classes=StartSpringBootMain.class)
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
publicclassTestRedisTwo{
@Resource(name="redisTwo")
privateRedisTemplate<String,Object>redisTemplate;
@Test
publicvoidtestGet(){
System.out.println(this.redisTemplate.opsForValue().get("study"));
}
@Test
publicvoidtestSet(){
Membervo=newMember();
vo.setMid("studyjava");
vo.setAge(19);
this.redisTemplate.opsForValue().set("study",vo);;
}
}
在实际的工作之中由于Redis数据库的使用相当频繁，所以有很大的可能性是一个项目里面需要连接不同的Redis数据库。
3、总结
Redis是一个重要的数据库产品，实际开发之中会利用Redis实现高并发的信息存储，所以多个Redis数据库的使用是一种常见形式。
本文内容总结：
原文链接：https://www.cnblogs.com/leeSmall/p/8728231.html