SpringDataRedis(SpringData)

2023-08-17 08:33:10

介绍：在lettuce那一篇里面写了用lettuce连接数据库，并且操作redis数据库

结构图:

1.依赖包

<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.1.9.RELEASE</version>
</dependency>

2.SpringData连接redis数据库

• 先创建一个src/main/profiles/dev/config/redis.properties配置文件，dev为源文件夹。在此配置文件中配置所有与redis有关的属性。

redis.host=redis-server//redis数据库连接的主机名称或ip地址
redis.port=6379 //连接端口
redis.auth=hellolee   //认证信息
redis.database=0  //数据库的索引编号
redis.pool.maxTotal=10  //连接池最大的总连接数量
redis.pool.maxIdle=5   //连接池维持的最大连接数量
redis.pool.minIdle=3  //连接池维持的最小的连接数量
redis.pool.testOnBorrow=true  //所有的连接测试后返回

• 在src/main/resources/spring/spring-base.xml配置文件中添加扫描redis.properties所在的包

<context:component-scan base-package="com.yootk.redis.config"/>

•编写配置类SpringDataRedisConfig.java

package com.yootk.redis.config;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;

@Configuration
@PropertySource("classpath:config/redis.properties")
public class SpringDataRedisConfig {
    @Bean("redisConfiguration")
    public RedisStandaloneConfiguration getRedisConfiguration(
            @Value("${redis.host}") String hostName ,
            @Value("${redis.port}") int port,
            @Value("${redis.auth}") String password,
            @Value("${redis.database}") int database
    ) {
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration() ;
        configuration.setHostName(hostName); // 设置Redis主机名称
        configuration.setPort(port); // 设置Redis的访问端口
        configuration.setPassword(RedisPassword.of(password)); // 设置密码
        configuration.setDatabase(database); // 设置数据库索引
        return configuration ;
    }
    @Bean("objectPoolConfig")
    public GenericObjectPoolConfig getObjectPoolConfig(
            @Value("${redis.pool.maxTotal}") int maxTotal ,
            @Value("${redis.pool.maxIdle}") int maxIdle ,
            @Value("${redis.pool.minIdle}") int minIdle ,
            @Value("${redis.pool.testOnBorrow}") boolean testOnBorrow
    ) {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig() ;
        poolConfig.setMaxTotal(maxTotal);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setTestOnBorrow(testOnBorrow);
        return poolConfig ;
    }
    @Bean("lettuceClientConfiguration")
    public LettuceClientConfiguration getLettuceClientConfiguration(
            @Autowired GenericObjectPoolConfig poolConfig
    ) { // 创建Lettuce组件的连接池客户端配置对象
        return LettucePoolingClientConfiguration.builder().poolConfig(poolConfig).build() ;
    }
    @Bean("redisConnectionFactory")//相当于在这例实例化了RedisConnectionFactory类的实例化对象，前面双引号中的内容就是对象，
　　　//一旦在其他地方自动注入此对象的时候，此方法便自动执行，所以执行此方法就相当于执行了一个构造方法。
    public RedisConnectionFactory getConnectionFactory(
            @Autowired RedisStandaloneConfiguration redisConfiguration ,
            @Autowired LettuceClientConfiguration lettuceClientConfiguration
    ) {
        LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(redisConfiguration,lettuceClientConfiguration) ;
        return connectionFactory ;
    }
}

　测试当前的Redis是否可以正常连接，编写测试类

package com.yootk.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@ContextConfiguration(locations = {"classpath:spring/*.xml"})
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisConnection {
    @Autowired
    private RedisConnectionFactory redisConnectionFactory ;
    @Test
    public void testRedis() {
        System.out.println(this.redisConnectionFactory);    // 输出连接工厂实例
        this.redisConnectionFactory.getConnection().flushDb();  // 清空数据库
    }
}

3.RedisTemplate

• 修改配置类SpringDataRedisConfig.java，添加两个方法

    @Bean("stringRedisTemplate")
    public RedisTemplate getStringRedisTempalate(
            @Autowired RedisConnectionFactory connectionFactory
    ) {
        StringRedisTemplate redisTemplate = new StringRedisTemplate() ;
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate ;
    }
    @Bean("redisTemplate")
    public RedisTemplate getRedisTempalate(
            @Autowired RedisConnectionFactory connectionFactory
    ) {
        RedisTemplate<String,String> redisTemplate = new RedisTemplate<>() ;
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate ;
    }

• 测试StringRedisTemplate

package com.yootk.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

@ContextConfiguration(locations = {"classpath:spring/*.xml"})
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisTemplateBase {
    @Autowired
    private RedisTemplate<String, String> stringRedisTemplate;
    @Test
    public void testString() {
        for (int x = 0; x < 10; x++) {
            this.stringRedisTemplate.opsForValue().set("msg - " + x, "Hello - " + x);
        }
    }
    @Test
    public void testHash() {
        Map<String, String> map = new HashMap<>();
        map.put("name", "可爱的小李老师");
        map.put("age", String.valueOf(16));
        map.put("salary", String.valueOf(1.1));
        this.stringRedisTemplate.opsForHash().putAll("member-lee", map);
        System.out.println(this.stringRedisTemplate.opsForHash().get("member-lee","name"));
    }
    @Test
    public void testKeys() {
        Set<String> keys = this.stringRedisTemplate.keys("msg - *");
        System.out.println("【所有的key】" + keys);
    }
}

• 测试RedisTemplate

package com.yootk.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@ContextConfiguration(locations = {"classpath:spring/*.xml"})
@RunWith(SpringJUnit4ClassRunner.class)
public class TestRedisTemplate {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Test
    public void testString() {
        this.redisTemplate.execute(new RedisCallback<Object>() {    // Redis回调
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushDb(); // 清空数据库
                return "ok";
            }
        }) ;
        for (int x = 0; x < 10; x++) {
            this.redisTemplate.opsForValue().set("message-" + x, "Hello - " + x);
        }
    }
    @Test
    public void testGet() {
        System.err.println("【获取数据】" + this.redisTemplate.opsForValue().get("message-3"));
    }
}

4.　对象序列化存储：在redis数据库中存放类的对象,强调：对象对应的类一定要实现Serializable接口。

　　RedisTemplate与StringRedisTemplate的区别：StringRedisTemplate是设置了一系列字符串序列化处理的RedisTemplate。

　　在SpringDataRedis里面对象序列化处理操作有两种方式：基于JDK的序列化处理机制，基于JSON的序列化处理机制。如果哦代码通过java实现，并且充分考虑到性能则使用JDK的机制，如果考虑到数据的通用性则使用JSON机制。

• 使用JDK机制存储对象，修改配置类SpringDataRedisConfig.java

 @Bean("redisTemplate")//将原来的getRedisTempalate方法改成现在这个
    public RedisTemplate getRedisTempalate(
            @Autowired RedisConnectionFactory connectionFactory
    ) {
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>() ;
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer()); // 数据的key通过字符串存储
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer()); // 保存的value为对象
        redisTemplate.setHashKeySerializer(new StringRedisSerializer()); // 数据的key通过字符串存储
        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer()); // 保存的value为对象
        return redisTemplate ;
    }

• 使用JSON机制存储对象，修改配置类SpringDataRedisConfig.java　

    @Bean("redisTemplate")//将原来的getRedisTempalate方法改成现在这个
    public RedisTemplate getRedisTempalate(
            @Autowired RedisConnectionFactory connectionFactory
    ) {
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>() ;
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer()); // 数据的key通过字符串存储
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Object.class)); // 保存的value为对象
        redisTemplate.setHashKeySerializer(new StringRedisSerializer()); // 数据的key通过字符串存储
        redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer(Object.class)); // 保存的value为对象
        return redisTemplate ;
    }

5.Pipeline流水线(详情见笔记)

码农公寓

相关文章