Tio Boot 整合 Spring Boot Starter Data Redis 指南

引言

在现代 Java 开发中，Tio Boot 是一个高性能的异步非阻塞网络框架，而 Spring Boot 则是一个简化 Spring 应用开发的快速开发框架。将两者结合，可以构建出高性能且易于维护的应用程序。

本指南将详细介绍如何将 Tio Boot 与 Spring Boot Starter Data Redis 整合，使得在使用 Tio Boot 的异步非阻塞特性的同时，也能方便地使用 Spring 提供的 Redis 功能。

配置步骤

1. 配置 Maven 依赖（pom.xml）

在项目的 pom.xml 文件中，添加必要的依赖和插件配置：

<properties>
  <java.version>1.8</java.version>
  <spring-boot.version>2.5.6</spring-boot.version>
  <hotswap-classloader.version>1.2.5</hotswap-classloader.version>
  <main.class>com.litongjava.spring.boot.tio.boot.demo01.Application</main.class>
</properties>

<dependencies>
  <!-- Lombok，用于简化 Java 代码 -->
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>provided</scope>
  </dependency>

  <!-- JUnit，用于单元测试 -->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>test</scope>
  </dependency>

  <!-- Hotswap Classloader，用于热加载 -->
  <dependency>
    <groupId>com.litongjava</groupId>
    <artifactId>hotswap-classloader</artifactId>
    <version>${hotswap-classloader.version}</version>
  </dependency>

  <!-- Tio Boot 依赖 -->
  <dependency>
    <groupId>com.litongjava</groupId>
    <artifactId>tio-boot</artifactId>
    <version>1.6.2</version>
  </dependency>

  <!-- Java DB 工具包 -->
  <dependency>
    <groupId>com.litongjava</groupId>
    <artifactId>java-db</artifactId>
    <version>1.2.5</version>
  </dependency>

  <!-- Druid 数据库连接池 -->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
  </dependency>

  <!-- MySQL 驱动 -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
  </dependency>

  <!-- Spring Boot 基础依赖 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>

  <!-- Spring Boot Redis 依赖 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
      <!-- 排除默认的 Lettuce 客户端 -->
      <exclusion>
        <groupId>io.lettuce</groupId>
        <artifactId>lettuce-core</artifactId>
      </exclusion>
    </exclusions>
  </dependency>

  <!-- 引入 Jedis 作为 Redis 客户端 -->
  <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
  </dependency>
</dependencies>

<build>
  <plugins>
    <!-- Spring Boot Maven 插件 -->
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <version>${spring-boot.version}</version>
      <configuration>
        <includeSystemScope>true</includeSystemScope>
        <!-- 启用热启动 -->
        <fork>true</fork>
        <mainClass>${main.class}</mainClass>
        <!-- 排除 Lombok 相关的编译 -->
        <excludeGroupIds>org.projectlombok</excludeGroupIds>
      </configuration>
      <!-- 配置执行目标 -->
      <executions>
        <execution>
          <goals>
            <goal>repackage</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

<dependencyManagement>
  <dependencies>
    <!-- Spring Boot 依赖管理 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>${spring-boot.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

解释：

  • spring-boot-starter-data-redis：Spring Boot 提供的 Redis 自动配置和模板支持。
  • 排除 Lettuce：默认情况下，Spring Boot 使用 Lettuce 作为 Redis 客户端。这里我们排除它，转而使用 Jedis。
  • 引入 Jedis：添加 Jedis 作为 Redis 客户端实现。

2. 配置 application.yml

首先，在项目的 src/main/resources 目录下创建或编辑 application.yml 文件，添加 Redis 的相关配置：

spring:
  redis:
    database: 0
    host: 192.168.3.9
    port: 6379
    password: 123456
    timeout: 3600
    jedis:
      pool:
        max-active: 8
        max-wait: 1ms
        max-idle: 20
        min-idle: 5

解释：

  • spring.redis.database：指定使用的 Redis 数据库索引。
  • spring.redis.host：Redis 服务器的主机地址。
  • spring.redis.port：Redis 服务器的端口号。
  • spring.redis.password：连接 Redis 服务器的密码。
  • spring.redis.timeout：连接超时时间。
  • spring.redis.jedis.pool：Jedis 连接池配置。
    • max-active：最大连接数。
    • max-wait：最大等待时间。
    • max-idle：最大空闲连接数。
    • min-idle：最小空闲连接数。

3. 编写启动类（Application）

创建主应用程序启动类，使用 Tio Boot 启动应用，并整合 Spring Boot：

package com.litongjava.spring.boot.tio.boot.demo01;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.litongjava.hotswap.wrapper.tio.boot.TioApplicationWrapper;
import com.litongjava.jfinal.aop.annotation.AComponentScan;

@AComponentScan
@SpringBootApplication
public class Application {
  public static void main(String[] args) {
    long start = System.currentTimeMillis();
    // 使用 Tio Boot 启动应用
    TioApplicationWrapper.run(Application.class, args);
    long end = System.currentTimeMillis();
    System.out.println("应用启动耗时：" + (end - start) + "ms");
  }
}

解释：

  • @AComponentScan：启用 Tio Boot 的组件扫描。
  • @SpringBootApplication：标记为 Spring Boot 应用程序。
  • TioApplicationWrapper.run()：使用 Tio Boot 启动应用，并传入应用主类和参数。

4. 编写配置类（SpringConfig）

创建配置类，整合 Spring Boot 与 Tio Boot：

package com.litongjava.spring.boot.tio.boot.demo01.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ConfigurableApplicationContext;

import com.litongjava.jfinal.aop.Aop;
import com.litongjava.jfinal.aop.AopManager;
import com.litongjava.jfinal.aop.annotation.AConfiguration;
import com.litongjava.jfinal.aop.annotation.AInitialization;
import com.litongjava.jfinal.spring.SpringBeanContextUtils;
import com.litongjava.spring.boot.tio.boot.demo01.Application;
import com.litongjava.tio.boot.server.TioBootServer;
import com.litongjava.tio.utils.environment.EnvUtils;

@AConfiguration
public class SpringConfig {

  @AInitialization
  public void config() {
    // 启动 Spring Boot 应用
    ConfigurableApplicationContext context = SpringApplication.run(Application.class, EnvUtils.getArgs());

    // 启用与 Spring 的整合
    AopManager.me().getAopFactory().setEnableWithSpring(true);
    SpringBeanContextUtils.setContext(context);

    // 使 Tio Boot 的 Bean 支持 @Autowired 注解
    Aop.addFetchBeanAnnotation(Autowired.class);

    // 注册应用关闭时的销毁方法
    TioBootServer.me().addDestroyMethod(context::close);
  }
}

解释：

  • @AConfiguration：标记为 Tio Boot 的配置类。
  • @AInitialization：初始化方法，执行配置逻辑。
  • SpringApplication.run()：启动 Spring Boot 应用，获取应用上下文。
  • AopManager：配置 AOP 工厂，使其支持与 Spring 的整合。
  • SpringBeanContextUtils：设置 Spring 应用上下文。
  • Aop.addFetchBeanAnnotation(Autowired.class)：使得 Tio Boot 的 Bean 可以使用 @Autowired 注解进行自动装配。
  • TioBootServer.me().addDestroyMethod()：注册应用销毁时需要执行的方法。

5. 编写控制器（SpringController）

创建控制器类，测试 Redis 的功能：

package com.litongjava.spring.boot.tio.boot.demo01.controller;

import org.springframework.data.redis.core.StringRedisTemplate;
import com.litongjava.jfinal.spring.SpringBeanContextUtils;
import com.litongjava.tio.http.server.annotation.RequestPath;

@RequestPath("/spring")
public class SpringController {

  public String[] beans() {
    // 获取 Spring 应用上下文中的所有 Bean 名称
    return SpringBeanContextUtils.getContext().getBeanDefinitionNames();
  }

  public String redisTest() {
    // 从 Spring 上下文中获取 StringRedisTemplate Bean
    StringRedisTemplate redisTemplate = SpringBeanContextUtils.getBean(StringRedisTemplate.class);
    // 操作 Redis，设置键值对
    redisTemplate.opsForValue().set("key1", "value1");
    // 从 Redis 中获取键对应的值
    return redisTemplate.opsForValue().get("key1");
  }
}

解释：

  • @RequestPath("/spring")：定义请求路径前缀为 /spring。
  • beans() 方法：返回 Spring 应用上下文中的所有 Bean 名称，便于查看哪些 Bean 被注册。
  • redisTest() 方法：测试 Redis 的读写功能。

6. 测试应用

启动应用后，访问以下 URL 进行测试：

  • 测试 Redis 功能：http://localhost/spring/redisTest

预期输出：

value1

这表示成功地将值写入到 Redis，并成功读取。

整合的好处

  1. 性能优势：Tio Boot 提供了高性能的异步非阻塞网络处理能力，能够更高效地处理大量并发请求。

  2. 生态支持：通过整合 Spring Boot，可以利用其庞大的生态系统，包括自动配置、依赖注入、数据访问等功能。

  3. 简化开发：使用 Spring Boot Starter Data Redis，可以方便地操作 Redis，而无需手动配置连接和管理客户端。

  4. 灵活性：这种整合方式允许开发者在保留 Tio Boot 性能优势的同时，仍然可以使用 Spring 的特性，达到两全其美的效果。

  5. 可维护性：借助 Spring 的依赖注入和组件扫描机制，代码更清晰，易于维护和扩展。

  6. 扩展性：未来需要添加其他 Spring Boot Starter 时，可以更方便地进行整合，如数据库、消息队列等。

总结

通过上述步骤，我们成功地将 Tio Boot 与 Spring Boot Starter Data Redis 整合，实现了在 Tio Boot 的异步非阻塞环境中，使用 Spring 提供的 Redis 功能。这种整合方式不仅保留了 Tio Boot 的性能优势，还充分利用了 Spring Boot 的生态和便利性，为开发高性能、可维护的应用程序提供了良好的基础。

希望本指南对您有所帮助！