SpringBoot整合Redis数据库
文章目录
Redis的数据库的整合在java里面提供的官方工具包:jedis,所以即便你现在使用的是SpringBoot,那么也继续使用此开发包,
1.1、RedisTemplate模板操作
在Spring支持的Redis操作之中提供有一个RedisTemplate处理程序类,利用这个类可以非常方便的实现Redis的各种基本数据操作。
1、修改项目中的pom.xml配置文件,追加redis的依赖引用:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.1.4.RELEASE</version> </dependency>
2、如果想使用Redis操作,则一定要修改application.yml配置文件,在这个配置文件中要进行Redis的各种连接配置处理:
spring: redis: host: 192.168.68.164 port: 6379 password: mldnjava timeout: 1000 database: 0 pool: max-active: 10 max-idle: 8 min-idle: 2 max-wait: 100
3、下面就可以通过程序来利用RedisTemplate模板进行数据处理了,因为以上的配置一旦完成之后会在Spring内部帮助用户直接获得一个RedisTemplate模板处理对象,为了简单,直接建立一个测试类完成:
package cn.mldn.microboot; import javax.annotation.Resource; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.context.web.WebAppConfiguration; @SpringBootTest(classes = MicrobootRedisApplication.class) @RunWith(SpringJUnit4ClassRunner.class) @WebAppConfiguration public class TestRedis { @Resource private RedisTemplate<String, String> redisTemplate; @Test public void testSet() { this.redisTemplate.opsForValue().set("mldn", "java"); System.out.println(this.redisTemplate.opsForValue().get("mldn")); } }
则此时就可以利用Redis实现在SpringBoot中的数据存储操作了。
1.2、Redis对象序列化操作
虽然以上的代码实现了Redis基础的数据操作,但是遗憾的是在Java开发领域内必须要考虑一个实际的问题,那就是对象的序列化保存的问题,毕竟Redis数据库的读写是非常快的,但是如果不能够进行对象的存储,这样的存储意义就不大,这样就需要准备一个对象的序列化处理程序类,通过对象的形式进行数据的存储:
1、如果要想进行Redis对象序列化操作则一定要首先准备一个序列化处理程序类,这个程序类有实现要求:
package cn.mldn.microboot.util.redis; import org.springframework.core.convert.converter.Converter; import org.springframework.core.serializer.support.DeserializingConverter; import org.springframework.core.serializer.support.SerializingConverter; import org.springframework.data.redis.serializer.RedisSerializer; import org.springframework.data.redis.serializer.SerializationException; //此时定义的序列化操作表示可以序列化所有类的对象,当然,这个对象所在的类一定要实现系列话接口 public class RedisObjectSerializer implements RedisSerializer<Object> { //为了方便进行对象与字节数组的转换,所以应该首先准备出连个转换器 private Converter<Object, byte[]> serializingConverter = new SerializingConverter(); private Converter<byte[], Object> deserializingConverter = new DeserializingConverter(); private static final byte[] EMPTY_BYTE_ARRAY = new byte[0]; //做一个空数组,不是null @Override public byte[] serialize(Object obj) throws SerializationException { //这个时候没有要序列化的对象出现,所以返回的字节数组应该是一个空数组 if (obj == null){ return EMPTY_BYTE_ARRAY; } return this.serializingConverter.convert(obj); //将对象变为字节数组 } @Override public Object deserialize(byte[] data) throws SerializationException { if (data == null || data.length == 0){ //此时没有对象的内容信息 return null; } return this.deserializingConverter.convert(data); } }
2、此时如果要想让RedisTemplate操作模板知道有这样一个序列化类存在,那么就不能够采用RedisTemplate默认配置形式,需要准备一个单独的配置类进行处理:
package cn.mldn.microboot.config; import cn.mldn.microboot.util.redis.RedisObjectSerializer; 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.StringRedisSerializer; @Configuration public class RedisConfig { @Bean public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory){ RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(factory); redisTemplate.setKeySerializer(new StringRedisSerializer()); //key的序列化类型 redisTemplate.setValueSerializer(new RedisObjectSerializer()); //value的序列化类型 return redisTemplate; } }
3、进行程序的测试使用:
package cn.mldn.microboot.vo; import java.io.Serializable; public class Member implements Serializable{ private static final long serialVersionUID = -2836019751586928703L; private String mid; private Integer age; public String getMid() { return mid; } public void setMid(String mid) { this.mid = mid; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Override public String toString() { return "Member{" + "mid='" + mid + '\'' + ", age=" + age + '}'; } }
测试类方法如下:
package cn.mldn.microboot; import javax.annotation.Resource; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.context.web.WebAppConfiguration; import cn.mldn.microboot.vo.Member; @SpringBootTest(classes = MicrobootRedisApplication.class) @RunWith(SpringJUnit4ClassRunner.class) @WebAppConfiguration public class TestRedis { @Resource private RedisTemplate<String, Object> redisTemplate; @Test public void testGet(){ System.out.println(this.redisTemplate.opsForValue().get("mldn")); } @Test public void testSet() { Member vo = new Member(); vo.setMid("mldnjava"); vo.setAge(19); this.redisTemplate.opsForValue().set("mldn", vo); } }
此时可以进行对象的序列化保存处理,这样整体的数据存储的手段可以更加的丰富。
1.3、配置多个RedisTemplate
由于在项目的实际开发过程之中Redis的使用会非常频繁,那么就有可能出现这样一种问题:现在的项目里面要求连接两个Redis数据库。SpringBoot里面针对于Redis的连接配置本质上只提供有一个连接配置项,那么如果你真的需要 进行更多的Redis的连接配置,那么就需要自己来进行Redis的创建管理了。
1、以非正规的形式修改application.yml配置文件:
spring: redis: host: 192.168.68.164 port: 6379 password: mldnjava timeout: 1000 database: 0 pool: max-active: 10 max-idle: 8 min-idle: 2 max-wait: 100redis-two: host: 192.168.68.164 port: 6380 password: mldnjava timeout: 1000 database: 0 pool: max-active: 10 max-idle: 8 min-idle: 2 max-wait: 100
2、建立一个RedisTwoConfig的程序配置类,进行第二个Redis连接的配置处理:
package cn.mldn.microboot.config; import cn.mldn.microboot.util.redis.RedisObjectSerializer; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.connection.jedis.JedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.StringRedisSerializer; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; @Configuration public class RedisTwoConfig { public RedisConnectionFactory getRedisConnectionFactory(String hostName, String password, int port, int database, int maxActive, int maxIdle, int minIdle, long maxWait){ //是负责建立Factory的连接工厂 JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(); jedisConnectionFactory.setHostName(hostName); jedisConnectionFactory.setPassword(password); jedisConnectionFactory.setPort(port); jedisConnectionFactory.setPort(database); JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); jedisPoolConfig.setMaxTotal(maxActive); jedisPoolConfig.setMaxIdle(maxIdle); jedisPoolConfig.setMinIdle(minIdle); jedisPoolConfig.setMaxWaitMillis(maxWait); jedisConnectionFactory.setPoolConfig(jedisPoolConfig); jedisConnectionFactory.afterPropertiesSet(); //初始化连接池配置 return jedisConnectionFactory; } @Bean("redisTwo") public RedisTemplate<String, Object> getRedisTemplate( @Value("${spring.redis-two.host}")String hostName, @Value("${spring.redis-two.password}")String password, @Value("${spring.redis-two.port}")int port, @Value("${spring.redis-two.database}")int database, @Value("${spring.redis-two.pool.max-active}")int maxActive, @Value("${spring.redis-two.pool.max-idle}")int maxIdle, @Value("${spring.redis-two.pool.min-idle}")int minIdle, @Value("${spring.redis-two.pool.max-wait}")long maxWait){ //建立Redis连接 RedisConnectionFactory factory = this.getRedisConnectionFactory(hostName, password, port, database, maxActive, maxIdle, minIdle, maxWait); RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(factory); redisTemplate.setKeySerializer(new StringRedisSerializer()); //key的序列化类型 redisTemplate.setValueSerializer(new RedisObjectSerializer()); //value的序列化类型 return redisTemplate; } }
测试类如下:
package cn.mldn.microboot; import cn.mldn.microboot.vo.Member; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.context.web.WebAppConfiguration; import javax.annotation.Resource; @SpringBootTest(classes = MicrobootRedisApplication.class) @RunWith(SpringJUnit4ClassRunner.class) @WebAppConfiguration public class TestRedisTwo { @Resource(name = "redisTwo") private RedisTemplate<String, Object> redisTemplate; @Test public void testGet(){ System.out.println(this.redisTemplate.opsForValue().get("mldn")); } @Test public void testSet() { Member vo = new Member(); vo.setMid("mldnjava"); vo.setAge(19); this.redisTemplate.opsForValue().set("mldn", vo); } }
在实际的的工作之中由于Redis数据库的使用相当频繁,所以有很大的可能性是一个项目里面需要连接不同的Redis数据库。
- SpringBoot整合mybatis、shiro、redis实现基于数据库的细粒度动态权限管理系统实例
- SpringBoot 整合Redis 数据库的方法
- SpringBoot整合mybatis、shiro、redis实现基于数据库的细粒度动态权限管理系统实例(转)
- SpringBoot整合mybatis、shiro、redis实现基于数据库的细粒度动态权限管理系统实例
- SpringBoot整合mybatis、shiro、redis实现基于数据库的细粒度动态权限管理系统实例
- spring boot 整合 redis,使用@Cacheable,@CacheEvict,@CachePut,jedisPool操作redis数据库
- SpringBoot整合mybatis、shiro、redis实现基于数据库的细粒度动态权限管理系统实例
- springboot整合redis作为K-V数据库
- SpringBoot整合mybatis、shiro、redis实现基于数据库的细粒度动态权限管理系统实例
- Spring Boot+Shiro+Redis(redisson)整合时,采用内嵌tomcat启动错误原因分析
- springboot 查询 整合redis
- SpringBoot进阶教程(三十)整合Redis之Sentinel哨兵模式
- spring boot整合redis
- SpringBoot2.X 整合RedisTemplate 简单实现消息队列
- SpringBoot进阶教程(二十八)整合Redis事物
- springboot整合spring-data-redis遇到的坑
- springboot 整合Redis
- SpringBoot整合Spring Data Redis
- spring boot整合redis,实现shiro的CacheManager
- Docker 部署 SpringBoot 项目整合 Redis 镜像做访问计数Demo