Spring Boot1.x集成Redis集群并实现启动加载MySQL数据到Redis

一、前言

在分布式系统中，Redis凭借高性能、高可用的特性成为缓存中间件的首选，而Spring Boot1.x作为经典的微服务开发框架，与Redis集群的集成是后端开发的核心技能之一。本文将详细讲解Spring Boot1.x集成Redis集群的完整流程，并实现项目启动时自动从MySQL加载数据到Redis集群的实战场景，解决数据库高频查询压力问题。

二、环境准备

1. 核心依赖版本

• Spring Boot：1.5.22.RELEASE（1.x稳定版本）
• Redis集群：3.2.x（兼容1.x客户端）
• MySQL：5.7.x
• Redis客户端：spring-boot-starter-redis（1.x默认Jedis）
• MyBatis：mybatis-spring-boot-starter 1.3.2（数据访问）

2. 依赖引入（pom.xml）

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.22.RELEASE</version>
    <relativePath/>
</parent>

<dependencies>
    <!-- Spring Boot Redis核心依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-redis</artifactId>
    </dependency>
    <!-- Redis集群依赖（Jedis） -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- MyBatis整合Spring Boot -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.2</version>
    </dependency>
    <!-- Spring Boot核心依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

三、Redis集群配置

1. 配置文件（application.properties）

# Redis集群配置
spring.redis.cluster.nodes=192.168.1.100:6379,192.168.1.101:6379,192.168.1.102:6379,192.168.1.100:6380,192.168.1.101:6380,192.168.1.102:6380
# 连接超时时间
spring.redis.timeout=3000
# 最大重定向次数
spring.redis.cluster.max-redirects=3
# 连接池配置
spring.redis.pool.max-active=20
spring.redis.pool.max-idle=10
spring.redis.pool.min-idle=5
spring.redis.pool.max-wait=-1

# MySQL配置
spring.datasource.url=jdbc:mysql://192.168.1.103:3306/test_db?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.tomcat.max-active=20
spring.datasource.tomcat.max-idle=10
spring.datasource.tomcat.min-idle=5

# MyBatis配置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.example.entity

2. Redis配置类

Spring Boot1.x对Redis集群的自动配置支持有限，需手动配置RedisTemplate：

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.RedisClusterConfiguration;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.util.HashSet;
import java.util.Set;

@Configuration
public class RedisClusterConfig {

    @Value("${spring.redis.cluster.nodes}")
    private String clusterNodes;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${spring.redis.cluster.max-redirects}")
    private int maxRedirects;
    @Value("${spring.redis.pool.max-active}")
    private int maxActive;
    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;
    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;
    @Value("${spring.redis.pool.max-wait}")
    private long maxWait;

    /**
     * 配置Jedis连接池
     */
    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxWaitMillis(maxWait);
        return poolConfig;
    }

    /**
     * 配置Redis集群连接工厂
     */
    @Bean
    public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
        RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration();
        // 解析集群节点
        Set<String> nodes = new HashSet<>();
        for (String node : clusterNodes.split(",")) {
            nodes.add(node);
        }
        clusterConfig.setClusterNodes(nodes);
        clusterConfig.setMaxRedirects(maxRedirects);
        // 创建Jedis连接工厂
        JedisConnectionFactory factory = new JedisConnectionFactory(clusterConfig, jedisPoolConfig);
        factory.setTimeout(timeout);
        return factory;
    }

    /**
     * 配置RedisTemplate，序列化方式为JSON
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        // key序列化
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        // value序列化
        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();
        redisTemplate.setValueSerializer(jsonSerializer);
        redisTemplate.setHashValueSerializer(jsonSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

四、实现项目启动加载MySQL数据到Redis集群

1. 定义实体类

以用户表（t_user）为例：

public class User {
    private Long id;
    private String username;
    private String phone;
    private Integer age;
    
    // 省略getter、setter、toString方法
}

2. Mapper层（MyBatis）

（1）Mapper接口

import com.example.entity.User;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface UserMapper {
    /**
     * 查询所有用户
     */
    @Select("SELECT id, username, phone, age FROM t_user")
    List<User> listAllUsers();
}

（2）Mapper.xml（可选，也可只用注解）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <select id="listAllUsers" resultType="com.example.entity.User">
        SELECT id, username, phone, age FROM t_user
    </select>
</mapper>

3. Service层

import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Service
public class UserService {

    @Resource
    private UserMapper userMapper;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 查询所有用户（从MySQL）
     */
    public List<User> listAllUsers() {
        return userMapper.listAllUsers();
    }

    /**
     * 将用户数据加载到Redis集群
     * 存储格式：key=user:{id}，value=用户JSON，设置过期时间24小时
     */
    public void loadUsersToRedis() {
        List<User> userList = listAllUsers();
        if (userList != null && !userList.isEmpty()) {
            for (User user : userList) {
                String key = "user:" + user.getId();
                redisTemplate.opsForValue().set(key, user, 24, TimeUnit.HOURS);
            }
            System.out.println("成功加载" + userList.size() + "条用户数据到Redis集群");
        }
    }
}

4. 启动加载逻辑（ApplicationRunner）

Spring Boot提供ApplicationRunner接口，可实现项目启动后执行指定逻辑：

import com.example.service.UserService;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 项目启动时加载MySQL数据到Redis集群
 */
@Component
public class DataLoadRunner implements ApplicationRunner {

    @Resource
    private UserService userService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 启动时执行数据加载
        userService.loadUsersToRedis();
    }
}

5. 启动类

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.mapper") // 扫描Mapper接口
public class RedisClusterApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisClusterApplication.class, args);
    }
}