SpringBoot整合Redis数据库

最新推荐文章于 2022-07-15 05:15:00 发布

minq508

最新推荐文章于 2022-07-15 05:15:00 发布

阅读量123

点赞数

分类专栏： Redis 文章标签： Springboot整合Redis数据库

本文链接：https://blog.csdn.net/qq_18840277/article/details/89187374

版权

Redis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

1.1、RedisTemplate模板操作
1.2、Redis对象序列化操作
1.3、配置多个RedisTemplate

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: 100
  redis-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数据库。

minq508

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot整合Redis数据库

文章目录redistemplate操作1.1、RedisTemplate模板操作redistemplate操作Redis的数据库的整合在java里面提供的官方工具包：jedis，所以即便你现在使用的是SpringBoot，那么也继续使用此开发包，1.1、RedisTemplate模板操作在Spring支持的Redis操作之中提供有一个RedisTemplate处理程序类，利用这个类可以非常...
复制链接

扫一扫