Java教程

Spring 采用纯注解使用 RedisTemplate

本文主要是介绍Spring 采用纯注解使用 RedisTemplate,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

我在前面的博客中介绍过采用 Jedis 操作 Redis,今天准备介绍 Spring 使用 RedisTemplate 操作 Redis。

Jedis 和 RedisTemplate 两者之间的区别在于:Jedis 是 Redis 官方推荐的面向 Java 操作 Redis 的客户端开发 Jar 包,而 RedisTemplate 是 Spring 框架对 Jedis API 的进行了高度封装(也就是说 RedisTemplate 底层是通过 Jedis 来实现的)。RedisTemplate 能够支持连接池自动管理,使用起来更加方便,实际上在大部分开发场景中,使用 RedisTemplate 会更多一些。

本篇博客的 Demo 基于之前 Jedis 操作 Redis 的 Demo 代码进行简单改造,实现 RedisTemplate 对 Redis 的操作,在博客最后会提供 Demo 源代码。有关 RedisTemplate 的详细内容,请查看 Spring 官网:https://spring.io/projects/spring-data-redis


一、搭建工程

新建一个 maven 项目,导入相关 jar 包,有关 Redis 相关的 jar 包不是最新的 jar 包,其它 jar 包都是最新的,内容如下:

有关具体的 jar 包地址,可以在 https://mvnrepository.com 上进行查询。

<dependencies>
    <!--Spring 相关 jar 包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.17</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.17</version>
    </dependency>

    <!--单元测试 jar 包-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
    </dependency>

    <!--操作 Redis 的相关 jar 包-->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>2.0.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>

    <!--
    日志相关 jar 包,主要是上面的 Redis 相关的 jar 包,在运行时需要日志的 jar 包。
    日志的 jar 包也可以不导入,只不过运行过程中控制台总是有红色提示,看着心烦。
    -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.21</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

注意:本博客的 Demo 中有关 Redis 相关的 jar 包,不是导入最新的,使用的是经过测试无误的稳定版本。另外 slf4j 和 log4j 相关的日志 jar 包,是 Redis 相关的 jar 所需要的,如果不导入的话,控制台上总是打印出相关的红色提示信息,看着比较心烦。

配置好引用的 jar 包后,打开右侧的 Maven 窗口,刷新一下,这样 Maven 会自动下载所需的 jar 包文件。

搭建好的项目工程整体目录比较简单,具体如下图所示:

image

项目工程结构简单介绍:

com.jobs.config 包下存储的是 Spring 相关的配置文件
resources 目录下存储的是相关的配置文件

test 目录下的文件介绍:
com.jobs.RedisTest 类是专门用来编写 junit 单元测试方法,用来测试操作 Redis 的方法


二、配置相关

resources 目录下 redis.properties 是连接 Redis 的相关配置文件,log4j.properties 是日志相关的配置文件,内容分别如下:

redis.host=localhost
redis.port=6379

# 如果你的 redis 设置了密码的话,可以使用密码配置
# redis.password=123456

redis.maxActive=10
redis.maxIdle=5
redis.minIdle=1
redis.maxWait=3000
log4j.rootLogger=WARN, stdout

# 如果你既要控制台打印日志,也要文件记录日志的话,可以使用下面这行配置
# log4j.rootLogger=WARN, stdout, logfile

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

RedisConfig 类主要实现的功能是读取 Redis 配置信息,创建 RedisTemplate 对象并将其装载到 Spring 容器中:

package com.jobs.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.PropertySource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPool;

@PropertySource("redis.properties")
public class RedisConfig {

    @Value("${redis.host}")
    private String host;
    @Value("${redis.port}")
    private Integer port;

    //@Value("${redis.password}")
    //private String password;

    @Value("${redis.maxActive}")
    private Integer maxActive;
    @Value("${redis.minIdle}")
    private Integer minIdle;
    @Value("${redis.maxIdle}")
    private Integer maxIdle;
    @Value("${redis.maxWait}")
    private Integer maxWait;

    //获取RedisTemplate
    @Bean
    public RedisTemplate getRedisTemplate(
            @Autowired RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        //设置 Redis 生成的key的序列化器,这个很重要
        //RedisTemplate 默认使用 jdk 序列化器,会出现 Redis 的 key 保存成乱码的情况
        //一般情况下 Redis 的 key 都使用字符串,
        //为了保障在任何情况下使用正常,最好使用 StringRedisSerializer 对 key 进行序列化
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        return redisTemplate;
    }

    //获取 Redis 连接工厂
    @Bean
    public RedisConnectionFactory getRedisConnectionFactory(
            @Autowired RedisStandaloneConfiguration redisStandaloneConfiguration,
            @Autowired GenericObjectPoolConfig genericObjectPoolConfig) {
        JedisClientConfiguration.JedisPoolingClientConfigurationBuilder builder
                = (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)
                   JedisClientConfiguration.builder();
        builder.poolConfig(genericObjectPoolConfig);
        JedisConnectionFactory jedisConnectionFactory =
                new JedisConnectionFactory(redisStandaloneConfiguration, builder.build());
        return jedisConnectionFactory;
    }

    //获取 Spring 提供的 Redis 连接池信息
    @Bean
    public GenericObjectPoolConfig getGenericObjectPoolConfig() {
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        return genericObjectPoolConfig;
    }

    //获取 Redis 配置对象
    @Bean
    public RedisStandaloneConfiguration getRedisStandaloneConfiguration() {
        RedisStandaloneConfiguration redisStandaloneConfiguration =
            new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        //redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
        return redisStandaloneConfiguration;
    }
}

下面列出 Spring 的启动类配置类 SpringConfig 的详细内容:

package com.jobs.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ComponentScan("com.jobs")
@Import(RedisConfig.class)
public class SpringConfig {
}

三、使用 RedisTemplate 操作 Redis

我们编写一个单元测试类 RedisTest 来演示 RedisTemplate 操作 Redis 的常见数据类型:

package com.jobs;

import com.jobs.config.SpringConfig;
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;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    //测试字符串 String 数据类型
    @Test
    public void testString() {

        //设置
        redisTemplate.opsForValue().set("name", "候胖胖");
        redisTemplate.opsForValue().set("age", "40");

        //获取
        String name = redisTemplate.opsForValue().get("name").toString();
        String age = redisTemplate.opsForValue().get("age").toString();

        System.out.println("name:" + name + ",age:" + age);
    }

    //测试列表 List 数据类型
    @Test
    public void testList() {

        //redis 的 list 可以作为队列使用
        //从列表右边添加数据
        redisTemplate.opsForList().rightPush("fat", "任肥肥");
        redisTemplate.opsForList().rightPush("fat", "侯胖胖");
        redisTemplate.opsForList().rightPush("fat", "李墩墩");

        //获取列表的容量大小
        long fatCount = redisTemplate.opsForList().size("fat");
        System.out.println("列表数量:" + fatCount);

        //从左侧逐个取数据
        for (int i = 0; i < fatCount; i++) {
            String fatMan = redisTemplate.opsForList().leftPop("fat").toString();
            System.out.println(fatMan);
        }
    }

    //测试散列 Hash 数据类型
    @Test
    public void testHash() {

        //redis 的 hash 比较适合存储对象数据
        Map<String, String> user1 = new HashMap<>();
        user1.put("name", "侯胖胖");
        user1.put("age", "40");
        user1.put("kg", "80");

        Map<String, String> user2 = new HashMap<>();
        user2.put("name", "任肥肥");
        user2.put("age", "38");
        user2.put("kg", "90");

        redisTemplate.opsForHash().putAll("user1", user1);
        redisTemplate.opsForHash().putAll("user2", user2);

        //修改第一个用户的年龄
        redisTemplate.opsForHash().put("user1", "age", "45");
        //修改第二个用户的体重
        redisTemplate.opsForHash().put("user2", "kg", "100");

        //获取两个对象的属性值
        Map<String, String> user111 = redisTemplate.opsForHash().entries("user1");
        Map<String, String> user222 = redisTemplate.opsForHash().entries("user2");
        System.out.println(user111);
        System.out.println(user222);
    }

    //测试集合 Set 数据类型
    @Test
    public void testSet() {

        //redis 的 set 跟 java 的 set 使用方式一样,重复的元素只保留一个
        redisTemplate.opsForSet().add("aaa", "a", "b", "c", "x", "y", "z", "a", "x");
        redisTemplate.opsForSet().add("bbb", "b", "c", "d", "e", "f", "y", "b", "e");

        //获取交集
        Set<String> sinter = redisTemplate.opsForSet().intersect("aaa", "bbb");
        System.out.println("交集:" + sinter);

        //获取并集
        Set<String> sunion = redisTemplate.opsForSet().union("aaa", "bbb");
        System.out.println("并集:" + sunion);

        //获取 aaa 相对于 bbb 的差集(存在于 aaa 但不存在与 bbb 的元素)
        Set<String> sdiff = redisTemplate.opsForSet().difference("aaa", "bbb");
        System.out.println("aaa 相对于 bbb 的差集:" + sdiff);
    }

    //测试有序集合 Sorted Set (ZSet) 数据类型
    @Test
    public void testZset() {

        //redis 的 zSet 比较适合做排行榜

        //粉丝投票
        redisTemplate.opsForZSet().add("vote", "侯胖胖", 10d);
        redisTemplate.opsForZSet().add("vote", "李墩墩", 7d);
        redisTemplate.opsForZSet().add("vote", "任肥肥", 6d);
        redisTemplate.opsForZSet().add("vote", "乔豆豆", 12d);
        redisTemplate.opsForZSet().add("vote", "杨重重", 8d);

        //修改任肥肥的投票数
        redisTemplate.opsForZSet().add("vote", "任肥肥", 9d);

        //zSet 默认是按照分值的升序排列
        Set<String> vote1 = redisTemplate.opsForZSet().range("vote", 0, -1);
        System.out.println("投票数量升序排列:" + vote1);

        //获取粉丝投票数量最多的前三个人
        Set<String> vote2 = redisTemplate.opsForZSet().reverseRange("vote", 0, 2);
        System.out.println("投票数量倒序前 3 个人:" + vote2);
    }
}


到此为止,已经快速搭建和演示了 Spring 采用纯注解配置和使用 RedisTemplate 操作 Redis 常见数据类型的 Demo ,整体来说还是非常简单的。更多 RedisTemplate 的使用方式,请参考 Spring 官网。

本博客的 Demo 源代码为:https://files.cnblogs.com/files/blogs/699532/Spring_RedisTemplate.zip



这篇关于Spring 采用纯注解使用 RedisTemplate的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!