实战：用SpringBoot+RedisJSON+RedisSearch构建高性能查询系统

告别MySQL性能瓶颈，实现毫秒级复杂查询

一、为什么需要这个方案？

在日常开发中，我们经常遇到这样的场景：用户中心需要根据多种条件筛选用户、商品搜索需要支持复杂的过滤和排序、配置信息需要快速查询...传统的MySQL方案在数据量增长后，复杂查询性能急剧下降，即使加了索引，分页查询、多条件组合查询依然会成为系统瓶颈。 传统方案的痛点：

分页查询深度翻页性能差
多字段组合查询索引失效
全文搜索需要引入ES，架构复杂
高并发下数据库连接池打满

我们的解决方案：

SpringBoot + RedisJSON + RedisSearch

这套组合拳的优势：

内存级速度：Redis内存存储，查询响应毫秒级
原生JSON支持：无需反序列化，直接操作JSON
内置搜索引擎：支持全文搜索、聚合、排序
轻量级架构：相比ES更轻量，部署简单

二、环境准备与依赖配置

2.1 Redis环境要求

确保Redis版本≥6.0（支持RedisJSON和RedisSearch模块），推荐使用Docker快速部署：

# 拉取带模块的Redis镜像
docker pull redislabs/redismod:latest

# 启动容器
docker run -d --name redis-mod \
  -p 6379:6379 \
  redislabs/redismod:latest

2.2 SpringBoot项目依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>com.redis</groupId>
        <artifactId>spring-data-redisearch</artifactId>
        <version>2.6.0</version>
    </dependency>
    <dependency>
        <groupId>com.redis</groupId>
        <artifactId>spring-data-redisjson</artifactId>
        <version>2.6.0</version>
    </dependency>
</dependencies>

2.3 配置文件

spring:
  redis:
    host: localhost
    port: 6379
    database: 0
    timeout: 3000ms
    lettuce:
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 8
        min-idle: 0

三、核心代码实战

3.1 实体类定义

以用户信息为例，展示如何定义文档实体：

import com.redis.om.spring.annotations.*;
import lombok.*;
import org.springframework.data.annotation.Id;

@Document
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    @Id
    private String id;
    
    @Indexed
    private String username;
    
    @Indexed
    private String email;
    
    @Indexed
    private Integer age;
    
    @Indexed
    private String city;
    
    @Indexed
    private String status; // 状态：ACTIVE, INACTIVE
    
    @Indexed
    private Double score; // 用户评分
    
    @Indexed
    private Point location; // 地理位置
    
    @Searchable
    private String description; // 支持全文搜索的字段
    
    private Map<String, Object> extraInfo; // 扩展信息
}

注解说明：

@Document：标记为RedisJSON文档
@Indexed：建立索引，支持快速查询
@Searchable：建立全文搜索索引
Point：地理位置类型

3.2 Repository接口

import com.redis.om.spring.repository.RedisDocumentRepository;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Point;

public interface UserRepository extends RedisDocumentRepository<User, String> {
    
    // 根据用户名精确查询
    List<User> findByUsername(String username);
    
    // 根据年龄范围查询
    List<User> findByAgeBetween(Integer minAge, Integer maxAge);
    
    // 根据城市和状态查询
    List<User> findByCityAndStatus(String city, String status);
    
    // 全文搜索：在description字段中搜索关键词
    List<User> searchByDescription(String text);
    
    // 分页查询
    Page<User> findAll(Pageable pageable);
    
    // 地理位置查询：查找附近用户
    List<User> findByLocationNear(Point point, Distance distance);
    
    // 复杂条件组合查询
    @Query("(@age:[$minAge $maxAge]) (@status:{$status})")
    List<User> findByAgeAndStatus(Integer minAge, Integer maxAge, String status);
}

3.3 服务层实现

@Service
@RequiredArgsConstructor
public class UserService {
    
    private final UserRepository userRepository;
    
    /**
     * 创建用户
     */
    public User createUser(User user) {
        if (user.getId() == null) {
            user.setId(UUID.randomUUID().toString());
        }
        return userRepository.save(user);
    }
    
    /**
     * 多条件分页查询
     */
    public Page<User> searchUsers(String keyword, String city, 
                                 Integer minAge, Integer maxAge, 
                                 Pageable pageable) {
        
        // 构建查询条件
        Query query = new Query();
        
        if (StringUtils.hasText(keyword)) {
            // 全文搜索条件
            query.addCriteria(new Criteria("description").contains(keyword));
        }
        
        if (StringUtils.hasText(city)) {
            query.addCriteria(new Criteria("city").is(city));
        }
        
        if (minAge != null && maxAge != null) {
            query.addCriteria(new Criteria("age").between(minAge, maxAge));
        }
        
        return userRepository.search(query, pageable);
    }
    
    /**
     * 查找附近用户（地理位置查询）
     */
    public List<User> findNearbyUsers(Double longitude, Double latitude, Double radiusKm) {
        Point point = new Point(longitude, latitude);
        Distance distance = new Distance(radiusKm, Metrics.KILOMETERS);
        return userRepository.findByLocationNear(point, distance);
    }
    
    /**
     * 批量导入数据
     */
    public void batchImport(List<User> users) {
        userRepository.saveAll(users);
    }
}

3.4 控制器层

@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
public class UserController {
    
    private final UserService userService;
    
    @PostMapping
    public User create(@RequestBody User user) {
        return userService.createUser(user);
    }
    
    @GetMapping("/search")
    public Page<User> search(
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String city,
            @RequestParam(required = false) Integer minAge,
            @RequestParam(required = false) Integer maxAge,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        
        Pageable pageable = PageRequest.of(page, size);
        return userService.searchUsers(keyword, city, minAge, maxAge, pageable);
    }
    
    @GetMapping("/nearby")
    public List<User> nearby(
            @RequestParam Double longitude,
            @RequestParam Double latitude,
            @RequestParam(defaultValue = "5") Double radius) {
        return userService.findNearbyUsers(longitude, latitude, radius);
    }
}

四、性能测试与优化

4.1 测试数据准备

先插入10万条测试数据：

@Test
void batchInsertTest() {
    List<User> users = new ArrayList<>();
    for (int i = 0; i < 100000; i++) {
        User user = new User();
        user.setId("user_" + i);
        user.setUsername("user" + i);
        user.setEmail("user" + i + "@example.com");
        user.setAge(18 + i % 50);
        user.setCity("city_" + (i % 10));
        user.setStatus(i % 2 == 0 ? "ACTIVE" : "INACTIVE");
        user.setScore(Math.random() * 5);
        user.setLocation(new Point(116.4 + Math.random() * 0.1, 39.9 + Math.random() * 0.1));
        user.setDescription("This is user " + i + " description with some random text");
        users.add(user);
    }
    
    userService.batchImport(users);
}

4.2 查询性能对比

测试场景：多条件分页查询（城市+年龄范围+状态+全文搜索）

方案	数据量	平均响应时间	QPS
MySQL（索引优化）	10万	120ms	83
RedisJSON+Search	10万	8ms	1250

结论：在复杂查询场景下，Redis方案比MySQL快15倍以上，QPS提升明显。

4.3 关键优化点

1. 索引设计优化

// 创建复合索引
@Indexed(sortable = true)  // 可排序
@Indexed(alias = "user_age") // 别名
private Integer age;

// 文本索引权重设置
@Searchable(weight = 2.0) // 权重越高，搜索时越重要
private String description;

2. 分页优化

避免深度分页：使用游标分页或基于ID的分页
合理设置PageSize：建议10-50条

3. 内存管理

监控Redis内存使用
设置合理的过期时间
使用LRU淘汰策略

4. 连接池配置

spring:
  redis:
    lettuce:
      pool:
        max-active: 50  # 根据并发量调整
        max-idle: 20
        min-idle: 5

五、生产环境注意事项

5.1 数据同步策略

方案一：实时事件驱动（推荐）

// 在MySQL操作后发送事件
@Transactional
public void saveUser(UserEntity user) {
    userMapper.insert(user);
    // 发送消息到MQ
    eventPublisher.publishEvent(new UserCreatedEvent(user));
}

// 消费者同步到Redis
@EventListener
public void handleUserEvent(UserCreatedEvent event) {
    userService.createUser(convertToRedisUser(event.getUser()));
}

方案二：定时增量同步

@Scheduled(fixedDelay = 30000) // 每30秒同步一次
public void syncData() {
    // 查询MySQL中更新时间大于上次同步时间的数据
    List<UserEntity> changedUsers = userMapper.selectByUpdateTime(lastSyncTime);
    // 批量同步到Redis
    userService.batchImport(convertUsers(changedUsers));
    lastSyncTime = System.currentTimeMillis();
}

5.2 缓存策略

查询结果缓存：

@Cacheable(value = "user_search", key = "#keyword + #city + #minAge + #maxAge + #page + #size")
public Page<User> searchUsers(String keyword, String city, 
                             Integer minAge, Integer maxAge, 
                             Pageable pageable) {
    // 实际查询逻辑
}

缓存失效：

@CacheEvict(value = "user_search", allEntries = true)
public void updateUser(User user) {
    // 更新用户信息
}

5.3 监控告警

内存使用率：设置阈值告警（如80%）
QPS/TPS监控：监控查询和写入性能
连接数监控：防止连接池打满
慢查询日志：记录执行时间超过100ms的查询

六、适用场景与局限性

✅ 推荐使用场景

场景	说明
用户信息查询	多条件筛选、分页、排序
商品搜索	全文搜索、属性过滤、地理位置
配置中心	快速读取配置信息
日志查询	按条件筛选日志
推荐系统	用户画像查询

❌ 不适用场景

强事务场景：需要ACID事务保证
复杂关联查询：多表关联、子查询
数据持久化为主：Redis是内存数据库，数据可能丢失
大数据量存储：内存成本高，不适合TB级数据

七、总结

通过SpringBoot + RedisJSON + RedisSearch的组合，我们成功构建了一个高性能文档查询系统。相比传统MySQL方案，在复杂查询场景下性能提升显著，特别适合读多写少的业务场景。 核心收获：

内存数据库在查询性能上的巨大优势
RedisJSON原生JSON操作带来的便利性
RedisSearch强大的搜索能力
轻量级架构部署简单

后续改进方向：

探索与MySQL的双写一致性方案
研究集群模式下的高可用方案
优化数据同步延迟问题

声明：本文为技术实践分享，生产环境部署请根据实际业务场景进行调整，建议先在测试环境充分验证。

posted @ 2026-01-30 10:19 东峰叵,com 阅读(5) 评论(0) 收藏举报

刷新页面返回顶部

东峰叵.com