基于 JNI + Rust 实现一种高性能 Excel 导出方案（上篇）

余衫马2024-11-29 13:28

每个不曾起舞的日子，都是对生命的辜负。

------尼采

一、背景：Web 导出 Excel 的场景

Web 导出 Excel 功能在数据处理、分析和共享方面提供了极大的便利，是许多 Web 应用程序中的重要功能。以下是一些典型的场景：

  1. 数据报表导出：在企业管理系统（如ERP、CRM）中，用户经常需要将系统中的数据生成报表并导出为 Excel 文件，以便进行进一步的分析和处理。例如，销售人员可以导出月度销售报告，财务人员可以导出财务报表。
  2. 数据备份与归档：用户可能需要定期将系统中的数据导出为 Excel 文件进行备份或归档，以确保数据安全和可追溯性。例如，学校的学生成绩记录、医院的病人就诊记录等。
  3. 数据共享与交流：在团队协作中，成员之间需要共享数据，Excel 文件是一种方便的格式，可以在不同的软件和平台之间轻松传递和查看。例如，项目经理可以导出项目进度数据，与团队成员或客户分享。
  4. 自定义数据分析：用户可能希望对系统中的数据进行自定义分析，而 Excel 提供了强大的数据处理和分析功能，如透视表、图表等。例如，市场分析人员可以导出市场调查数据，在 Excel 中进行详细的分析和可视化。
  5. 批量数据处理：当用户需要对大量数据进行批量处理时，导出为 Excel 文件可以方便地进行编辑和修改，然后再导入回系统。例如，人力资源部门可以导出员工信息进行批量更新后再导入系统。
  6. 合规与审计需求：某些行业和组织有合规和审计要求，需要定期导出数据以供审计和检查。例如，金融机构需要导出交易记录以满足监管要求。

二、现有解决方案与技术栈

  • 服务器端技术：如 Python 的 Pandas 库、Node.js 的 ExcelJS 库、Java 的 Apache POI 库等，用于生成 Excel 文件。
  • 前端技术：如 JavaScript 的 SheetJS 库，用于在浏览器中生成和下载 Excel 文件。
  • API 接口：通过 RESTful API 或 GraphQL 接口，从服务器获取数据并生成 Excel 文件。

在 Java 中，常见的 Excel 导出方案包括：

1、Apache POI：

优点：

  • 功能强大，支持读写 Microsoft Excel 97-2003 (XLS) 和 Excel 2007+ (XLSX) 文件。
  • 社区活跃，文档和示例丰富。
  • 支持复杂的 Excel 操作，如公式、图表、样式等。

缺点：

  • API 较为复杂，上手需要一定时间。
  • 性能在处理大文件时可能不够理想。

2、JExcelAPI (JXL)

优点：

  • 简单易用，适合处理基本的 Excel 操作。
  • 对 Excel 97-2003 (XLS) 文件有较好的支持。

缺点：

  • 不支持 Excel 2007+ (XLSX) 文件。
  • 功能相对有限，不支持复杂的操作如图表和公式。

3、EasyExcel

EasyExcel 因其高性能、简单易用、功能丰富以及良好的社区支持，成为了许多企业在实现 Excel 导出功能时的首选工具。

优点：

  • 由阿里巴巴开源，专注于高性能的 Excel 读写。
  • 支持 Excel 2007+ (XLSX) 文件。
  • API 简洁，易于使用，特别适合大数据量的导入导出。

缺点：

  • 相对于 Apache POI，功能较少，不支持一些复杂的操作。

4、OpenCSV (用于处理 CSV 文件)

优点：

  • 轻量级，简单易用。
  • 专注于 CSV 格式，性能好。

缺点：

  • 仅支持 CSV 文件，不支持 XLS 或 XLSX 格式。
  • 功能较为单一，只能处理简单的文本数据。

5、JasperReports

优点：

  • 强大的报表生成工具，支持多种格式（包括 Excel）。
  • 可以结合 iReport 等工具进行可视化设计。
  • 支持复杂的报表需求，如分组、汇总、图表等。

缺点：

  • 学习曲线较陡，需要掌握报表设计和配置。
  • 配置和使用较为复杂，适合有报表需求的场景。

6、Spire.XLS for Java

优点：

  • 商业库，提供全面的 Excel 操作功能。
  • 支持所有版本的 Excel 文件格式。
  • 易于使用，文档和技术支持完善。

缺点：

  • 商业软件，需要购买许可证。
  • 社区支持和开源资源较少。

7、Aspose.Cells for Java

优点：

  • 商业库，功能非常强大，支持所有 Excel 文件格式。
  • 提供丰富的 API，可以处理复杂的 Excel 操作，如公式、图表、数据透视表等。
  • 性能优秀，适合处理大数据量的 Excel 文件。

缺点：

  • 商业软件，价格较高。
  • 学习成本较高，需要深入了解其 API。

三、思考：基于 JNI + Rust 的导出方案

1、优势

将 Excel 文件的生成任务交给 Rust 来处理，可以充分利用 Rust 的高性能和内存安全特性，确保文件生成过程高效且可靠。同时，Java 负责 API 接口请求和业务逻辑处理，利用其成熟的生态系统和广泛的企业应用经验，使得整个系统更加易于维护和扩展。

2、职责

Rust 部分：

  • 使用 rust-xlsxwriter 等库来处理 Excel 文件的生成和导出。
  • 将生成的 Excel 文件保存到服务器的某个位置，或者直接返回给调用方。

Java 部分：

  • 使用 Spring Boot 或其他框架来创建 RESTful API。
  • 在接收到请求后，通过 JNI（Java Native Interface）或通过命令行调用 Rust 程序来生成 Excel 文件。
  • 将生成的文件返回给客户端，或者提供下载链接。

补充：rust_xlsxwriter 介绍

rust_xlsxwriter 是一个用于在 Rust 编程语言中创建和写入 Excel 文件（.xlsx 格式）的库。这个库提供了一种简单且高效的方法来生成 Excel 文件，适用于需要处理电子表格数据的各种应用场景，如数据分析、报告生成等。

主要特性

  1. 易于使用：rust_xlsxwriter 提供了直观的 API，使得创建和操作 Excel 文件变得非常简单。
  2. 支持多种数据类型：可以在单元格中写入字符串、数字、日期和布尔值等多种数据类型。
  3. 格式化功能：支持丰富的单元格格式化选项，包括字体样式、颜色、边框和对齐方式等。
  4. 工作表管理：可以创建多个工作表，并在不同的工作表之间切换和操作。
  5. 公式支持：允许在单元格中插入 Excel 公式，自动计算结果。
  6. 图表支持：能够在工作表中插入各种类型的图表，如柱状图、折线图和饼图等。
  7. 性能优化：针对大数据量的处理进行了优化，确保生成 Excel 文件的效率。

四、实践：检验真理的唯一标准

1、使用 Rust 导出 Excel

主要使用 rust_xlsxwriter 这个库，

https://docs.rs/rust_xlsxwriter/latest/rust_xlsxwriter/

示例

创建一个 Rust 项目，添加 rust_xlsxwriter 依赖，

bash 复制代码 
# Cargo.toml
[dependencies]
rust_xlsxwriter = { version = "0.79.4" , features =["zlib","ryu","polars","serde","constant_memory"]  }

修改官网示例，这里尝试导出 10 万行数据，

rust 复制代码 
// main.rs
fn main() -> Result<(), XlsxError> {
    // Create a new Excel file object.
    let mut workbook = Workbook::new();

    // Create some formats to use in the worksheet.
    let date_format = Format::new().set_num_format("yyyy-mm-dd");

    // Add a worksheet to the workbook.
    let worksheet = workbook.add_worksheet();

    // Set the column width for clarity.
    worksheet.set_column_width(0, 16)?;
    worksheet.set_column_width(5, 22)?;

    // Generate data in parallel.
    let data: Vec<Vec<CellValue>> = (0..ROWS)
        .into_par_iter()
        .map(|i| generate_row_data(i))
        .collect();

    // Write data to the worksheet in batches.
    for (i, row_data) in data.chunks(BATCH_SIZE).enumerate() {
        for (j, row) in row_data.iter().enumerate() {
            let row_index = i * BATCH_SIZE + j;
            for (col, value) in row.iter().enumerate() {
                match value {
                    CellValue::String(s) => worksheet.write(row_index as u32, col as u16, *s)?,
                    CellValue::Number(n) => worksheet.write(row_index as u32, col as u16, *n)?,
                    CellValue::Date(d) => worksheet.write_with_format(
                        row_index as u32,
                        col as u16,
                        d,
                        &date_format,
                    )?,
                    CellValue::Url(u) => {
                        worksheet.write(row_index as u32, col as u16, Url::new(*u))?
                    }
                };
            }
        }
    }

    // Save the file to disk.
    workbook.save("parallel_demo.xlsx")?;

    Ok(())
}

编译运行后报错 attempt to add with overflow ，

bash 复制代码 
thread 'main' panicked at /home/sam/.cargo/registry/src/mirrors.ustc.edu.cn-61ef6e0cd06fb9b8/rust_xlsxwriter-0.79.4/src/relationship.rs:112:9:
attempt to add with overflow

原因分析 ：点击报错提示查看源码，发现 id_num定义的数据类型是 u16 ，在 Rust 中 u16 表示一个无符号 16 位整数类型，它的取值范围是从 0 到 65535（即 2^16 - 1），而我们导出的数据行数是 10 万，所以在加法运算的时候溢出了数值范围。


解决方案：使用 u32 类型，重新编译。

运行效果：可以看到 Excel 文件已经成功导出了，

10W数据量也可以正常导出，


2、导出 Rust 库文件

创建一个 Rust 库项目，

bash 复制代码 
cargo new my_excel_writer_lib --lib
bash 复制代码 
[dependencies]
jni = "0.21.1"
rust_xlsxwriter = { version = "0.79.4" , features =["zlib","ryu","polars","serde","constant_memory"]  }

[lib]
crate-type = ["cdylib"]

定义一个结构体，用于保存 Excel 指针，

rust 复制代码 
#[repr(C)]
pub struct WorksheetHandle {
    workbook: *mut Workbook,
    worksheet: *mut Worksheet,
}

定义 createWorksheet 用于初始化创建 Excel 并返回指针，

rust 复制代码 
#[no_mangle]
pub extern "system" fn Java_com_yushanma_crazyexcel_handler_MyExportResultHandler_createWorksheet(
    _env: JNIEnv,
    _class: JClass,
) -> jlong {
    let workbook = Box::new(Workbook::new());
    let workbook_ptr = Box::into_raw(workbook);

    // SAFETY: We just created the raw pointer from a Box, so it's valid.
    let worksheet = unsafe { (*workbook_ptr).add_worksheet() };

    let handle = Box::new(WorksheetHandle {
        workbook: workbook_ptr,
        worksheet: worksheet,
    });

    Box::into_raw(handle) as jlong
}

定义 writeToWorksheet 用于往 worksheet 里面写入单元格数据，

rust 复制代码 
#[no_mangle]
pub extern "system" fn Java_com_yushanma_crazyexcel_handler_MyExportResultHandler_writeToWorksheet(
    env: JNIEnv,
    _class: JClass,
    handle_ptr: jlong,
    row: u32,
    col: u16,
    text: JObject,
) {
    if handle_ptr == 0 {
        eprintln!("Invalid handle pointer");
        return;
    }

    if text.is_null() {
        eprintln!("Text argument is null");
        return;
    }

    let handle = unsafe { &*(handle_ptr as *mut WorksheetHandle) };
    // let content: String = match env.get_string(&text.into()) {
    //     Ok(java_str) => java_str.into(),
    //     Err(e) => {
    //         eprintln!("Couldn't get java string: {:?}", e);
    //         return;
    //     }
    // };

    let content: String = match unsafe { env.get_string_unchecked(&text.into()) } {
        Ok(java_str) => java_str.into(),
        Err(e) => {
            eprintln!("Couldn't get java string: {:?}", e);
            return;
        }
    };

    let worksheet: &mut Worksheet = unsafe { &mut *handle.worksheet };

    if let Err(e) = worksheet.write_string(row, col, content) {
        eprintln!("Failed to write to worksheet: {:?}", e);
    }
}

定义 saveWorkbook 用于导出 Excel 文件到某个 path 路径下，

rust 复制代码 
#[no_mangle]
pub extern "system" fn Java_com_yushanma_crazyexcel_handler_MyExportResultHandler_saveWorkbook(
    env: JNIEnv,
    _class: JClass,
    handle_ptr: jlong,
    file_path: JObject,
) {
    if handle_ptr == 0 {
        eprintln!("Invalid handle pointer");
        return;
    }

    if file_path.is_null() {
        eprintln!("File path argument is null");
        return;
    }

    let handle = unsafe { &*(handle_ptr as *mut WorksheetHandle) };

    // let path: String = match env.get_string(&file_path.into()) {
    //     Ok(java_str) => java_str.into(),
    //     Err(e) => {
    //         eprintln!("Couldn't get java string: {:?}", e);
    //         return;
    //     }
    // };

    let path: String = match unsafe { env.get_string_unchecked(&file_path.into()) } {
        Ok(java_str) => java_str.into(),
        Err(e) => {
            eprintln!("Couldn't get java string: {:?}", e);
            return;
        }
    };

    let workbook = unsafe { &mut *handle.workbook };

    if let Err(e) = workbook.save(path) {
        eprintln!("Failed to save workbook: {:?}", e);
    }
}

定义 freeWorksheetHandle 用于释放指针内存，因为 JVM 没法自动处理这部分资源，

rust 复制代码 
#[no_mangle]
pub extern "system" fn Java_com_yushanma_crazyexcel_handler_MyExportResultHandler_freeWorksheetHandle(
    _env: JNIEnv,
    _class: JClass,
    handle_ptr: jlong,
) {
    if handle_ptr != 0 {
        unsafe {
            // Convert the raw pointer back to a Box and drop it
            let _ = Box::from_raw(handle_ptr as *mut WorksheetHandle);
        }
    }
}

3、搭建 Spring Boot 项目

创建一个 Spring Boot 项目，这里使用的版本是 2.1.8.RELEASE 。

Step1、引入 POM 依赖

xml 复制代码 
<!-- https://mvnrepository.com/artifact/org.postgresql/postgresql -->
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.6.0</version>
</dependency>
 
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>
 
<!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>
 
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>
 
<!-- web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.79</version>
</dependency>

主要引入 PostgreSQL、MyBatis-Plus 依赖。

Step2、配置 YML

yaml 复制代码 
spring:
  datasource:
    # 数据源基本配置
    url: jdbc:postgresql://127.0.0.1:5432/dbname
    username: postgres
    password: #################
    driver-class-name: org.postgresql.Driver
    type: com.alibaba.druid.pool.DruidDataSource

主要配置数据源。

Step3、配置 Mybatis

java 复制代码 
/**
 * @version: V1.0
 * @author: 余衫马
 * @description: Mybatis 配置
 * @data: 2024-11-21 19:44
 **/
@Configuration
@MapperScan("com.yushanma.crazyexcel.dao")
public class MybatisConfig {
}

Step4、实体类封装

TestVo、TestPo 模拟用户需要导出的数据字段，

java 复制代码 
/**
 * @version: V1.0
 * @author: 余衫马
 * @description: 测试 VO
 * @data: 2024-11-21 19:48
 **/
@Data
public class TestVo {
    private String f1;
    // 省略...
    private String f20;
}

Step5、Dao 层定义

TestDao 中定义两个方法，

  • selectMillionData 用于查询数据，特别注意使用的是 ResultHandler 作为参数，void 作为返回值
  • insertMillionData 用于写入数据
java 复制代码 
/**
 * @version: V1.0
 * @author: 余衫马
 * @description: 测试 Dao
 * @data: 2024-11-21 19:46
 **/
@Mapper
public interface TestDao {

    /**
     * 返回百万数据
     * @param resultHandler 结果处理器
     */
    void selectMillionData(ResultHandler<TestVo> resultHandler);

    /**
     * 批量写入数据
     * @param poList
     */
    void insertMillionData(@Param("poList") List<TestPo> poList);
}

Mapper XML 编写具体 SQL 语句，

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.yushanma.crazyexcel.dao.TestDao">
 
    <insert id="insertMillionData">
        INSERT INTO public.test_xls_data_c20(f1, f2, f3, f4, f5, f6, f7, f8, f9, f10,
                                             f11, f12, f13, f14, f15, f16, f17, f18, f19, f20)
        VALUES
        <foreach collection="poList" item="po" separator=",">
            (#{po.f1}, #{po.f2}, #{po.f3}, #{po.f4}, #{po.f5}, #{po.f6}, #{po.f7}, #{po.f8}, #{po.f9}, #{po.f10},
            #{po.f11}, #{po.f12}, #{po.f13}, #{po.f14}, #{po.f15}, #{po.f16}, #{po.f17}, #{po.f18}, #{po.f19}, #{po.f20})
        </foreach>
    </insert>

    <select id="selectMillionData" resultType="com.yushanma.crazyexcel.vo.TestVo">
            SELECT * FROM test_xls_data_c20 LIMIT 100000
    </select>

</mapper>

在数据库对应创建数据表，

sql 复制代码 
create TABLE test_xls_data_c20 (
f1 varchar(50) not null,
 // 省略...
f20 varchar(50) not null
)

4、导出功能核心逻辑

  • MyExportResultHandler 实现 ResultHandler 的 handleResult 方法用于处理数据库返回的数据
  • 引入外部 Rust 库 my_excel_writer_lib，定义本地 Native 方法
  • 构造方法调用 createWorksheet 获取指针对象
  • 每次返回一行数据时调用 writeToWorksheet 将数据写到 worksheet 中
  • 实现 AutoCloseable 接口在指针内存释放前导出 Excel
java 复制代码 
/**
 * @version: V1.0
 * @author: 余衫马
 * @description: Excel 导出处理器
 * @data: 2024-11-21 19:56
 **/
public class MyExportResultHandler implements ResultHandler<TestVo>, AutoCloseable {

    static {
        System.loadLibrary("my_excel_writer_lib");
    }

    /**
     * Excel 指针
     */
    private long handle;

    /**
     * 创建一个 Worksheet
     *
     * @return 指针 handle
     */
    private native long createWorksheet();

    /**
     * 把数据写入 Worksheet
     *
     * @param handle 指针
     * @param row    行
     * @param col    列
     * @param text   内容
     */
    private native void writeToWorksheet(long handle, int row, int col, String text);

    /**
     * 保存 Excel 到某个路径下
     *
     * @param handle   指针
     * @param filePath 保存路径
     */
    private native void saveWorkbook(long handle, String filePath);

    /**
     * 释放 Worksheet 内存
     *
     * @param handle 指针
     */
    private native void freeWorksheetHandle(long handle);


    /**
     * 构造方法
     * 初始化一个 Excel 对象
     */
    public MyExportResultHandler() {
        handle = createWorksheet();
    }


    /**
     * 构造方法
     * 初始化一个 Excel 对象
     *
     * @param head 表头
     */
    public MyExportResultHandler(String[] head) {
        // 创建一个 worksheet
        handle = createWorksheet();
        // 写入表头
        for (int i = 0; i < head.length; i++) {
            writeToWorksheet(handle, 0, i, head[i]);
        }
    }


    /**
     * 自动释放资源
     */
    @Override
    public void close() {

        saveWorkbook(handle, "out.xlsx");

        if (handle != 0) {
            freeWorksheetHandle(handle);
            handle = 0;
        }
        System.out.println("Auto Release!");
    }

    @Override
    public void handleResult(ResultContext<? extends TestVo> resultContext) {
        TestVo testVo = resultContext.getResultObject();
        try {
            // 处理逻辑
            writeToWorksheet(handle, resultContext.getResultCount(), 0, testVo.getF1());
             // 省略...
            writeToWorksheet(handle, resultContext.getResultCount(), 19, testVo.getF20());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ServiceImpl 调用，

java 复制代码 
/**
 * @version: V1.0
 * @author: 余衫马
 * @description: 测试 impl
 * @data: 2024-11-21 19:59
 **/
@Service
public class TestServiceImpl implements TestService {

    @Autowired
    private TestDao testDao;

    /**
     * 生成百万数据
     */
    public void generateMillionData(){

        for (int i = 0; i < 1000; i++) {
            List<TestPo> poList = new ArrayList<>(1000);
            for (int j = 0; j < 1000; j++) {
                TestPo po = new TestPo();
                po.setF1(UUID.randomUUID().toString());
                // 省略...
                po.setF20(UUID.randomUUID().toString());
                poList.add(po);
            }
            testDao.insertMillionData(poList);
        }

    }
   
    @Override
    public void testResultHandler() throws IOException {

        LocalDateTime startDatetime = LocalDateTime.now();

        try (MyExportResultHandler handler = new MyExportResultHandler()) {
            testDao.selectMillionData(handler);
        }

        // 计算两个时间点之间的 Duration
        Duration duration = Duration.between(startDatetime, LocalDateTime.now());

        // 获取分钟、秒和毫秒
        long minutes = duration.toMinutes();
        long seconds = duration.getSeconds() - minutes * 60;
        long millis = duration.toMillis() - minutes * 60 * 1000 - seconds * 1000;

        System.out.printf("数量：10W20行，耗时：%d 分 %d 秒 %d 毫秒\n", minutes, seconds, millis);

    }
}

测试 Controller，

java 复制代码 
/**
 * @version: V1.0
 * @author: 余衫马
 * @description: 测试 Controller
 * @data: 2024-11-25 14:51
 **/
@RestController
@RequestMapping("api/")
public class TestController {

    @Autowired
    private TestService testService;

    @GetMapping("/testResultHandler")
    public void testResultHandler() throws IOException {
        testService.testResultHandler();
    }
}

运行效果：数量 10W20行，总字符数 36 * 20 * 100000 = 7.2 千万，耗时：12 秒 918 毫秒**



5、Web 下载实现

Rust 端封装 writeToStream 函数，Java 把响应流 output_stream 传给 Rust，Rust 将 Excel 数据转为流之后，写入到 output_stream 返回给客户端，

rust 复制代码 
#[no_mangle]
pub extern "system" fn Java_com_yushanma_crazyexcel_handler_MyExportResultHandler_writeToStream(
    mut env: JNIEnv,
    _class: JClass,
    handle_ptr: jlong,
    output_stream: JObject,
) {
    if handle_ptr == 0 {
        eprintln!("Invalid handle pointer");
        return;
    }

    if output_stream.is_null() {
        eprintln!("output stream is null");
        return;
    }

    let handle = unsafe { &*(handle_ptr as *mut WorksheetHandle) };

    let workbook = unsafe { &mut *handle.workbook };

    // 要写入的数据
    let data = match workbook.save_to_buffer() {
        Ok(data) => data,
        Err(e) => {
            eprintln!("Failed to save workbook to buffer: {:?}", e);
            return;
        }
    };

    // 将数据转换为 Java byte array
    let byte_array = match env.byte_array_from_slice(&data) {
        Ok(array) => array,
        Err(e) => {
            eprintln!("Couldn't create byte array: {:?}", e);
            return;
        }
    };

    // 获取 OutputStream 类并获取 write 方法 ID
    let write_method_id = match env.get_method_id("java/io/OutputStream", "write", "([B)V") {
        Ok(id) => id,
        Err(e) => {
            eprintln!("Couldn't find write method: {:?}", e);
            return;
        }
    };

    // 准备参数
    let byte_array_jobject = JObject::from(byte_array);
    let args = [jvalue {
        l: *byte_array_jobject,
    }];

    // 调用 OutputStream 的 write 方法
    if let Err(e) = unsafe {
        env.call_method_unchecked(
            output_stream,
            write_method_id,
            ReturnType::Primitive(Primitive::Void),
            &args,
        )
    } {
        eprintln!("Call to write method failed: {:?}", e);
    }
}

Java 端把 HttpServletResponse 传给 MyExportResultHandler ，在资源释放前将 Excel 文件通过流返回给客户端，

java 复制代码 
/**
 * @version: V1.0
 * @author: 余衫马
 * @description: 测试 impl
 * @data: 2024-11-21 19:59
 **/
@Service
public class TestServiceImpl implements TestService {

    // 省略...

    @Override
    public void testResultHandler(HttpServletResponse response) throws IOException {

        LocalDateTime startDatetime = LocalDateTime.now();

        try (MyExportResultHandler handler = new MyExportResultHandler(response)) {
            testDao.selectMillionData(handler);
        }

        // 计算两个时间点之间的 Duration
        Duration duration = Duration.between(startDatetime, LocalDateTime.now());

        // 获取分钟、秒和毫秒
        long minutes = duration.toMinutes();
        long seconds = duration.getSeconds() - minutes * 60;
        long millis = duration.toMillis() - minutes * 60 * 1000 - seconds * 1000;

        System.out.printf("数量：10W20行，耗时：%d 分 %d 秒 %d 毫秒\n", minutes, seconds, millis);

    }

    // 省略...

}
java 复制代码 
/**
 * @version: V1.0
 * @author: 余衫马
 * @description: Excel 导出处理器
 * @data: 2024-11-21 19:56
 **/
public class MyExportResultHandler implements ResultHandler<TestVo>, AutoCloseable {

    static {
        System.loadLibrary("my_excel_writer_lib");
    }

    /**
     * Excel 指针
     */
    private long handle;

    /**
     * 响应流
     */
    private HttpServletResponse httpServletResponse;

    /**
     * 创建一个 Worksheet
     *
     * @return 指针 handle
     */
    private native long createWorksheet();

    /**
     * 把数据写入 Worksheet
     *
     * @param handle 指针
     * @param row    行
     * @param col    列
     * @param text   内容
     */
    private native void writeToWorksheet(long handle, int row, int col, String text);

    /**
     * 保存 Excel 到某个路径下
     *
     * @param handle   指针
     * @param filePath 保存路径
     */
    private native void saveWorkbook(long handle, String filePath);

    /**
     * 释放 Worksheet 内存
     *
     * @param handle 指针
     */
    private native void freeWorksheetHandle(long handle);

    /**
     * 写到响应流
     *
     * @param handle 指针
     * @param os     OutputStream
     */
    private native void writeToStream(long handle, OutputStream os);

    /**
     * 构造方法
     * 初始化一个 Excel 对象
     */
    public MyExportResultHandler() {
        handle = createWorksheet();
    }

    /**
     * 构造函数
     *
     * @param response HttpServletResponse
     */
    public MyExportResultHandler(HttpServletResponse response) {
        handle = createWorksheet();
        httpServletResponse = response;
    }


    /**
     * 构造方法
     * 初始化一个 Excel 对象
     *
     * @param head 表头
     */
    public MyExportResultHandler(String[] head) {
        // 创建一个 worksheet
        handle = createWorksheet();
        // 写入表头
        for (int i = 0; i < head.length; i++) {
            writeToWorksheet(handle, 0, i, head[i]);
        }
    }


    /**
     * 自动释放资源
     */
    @Override
    public void close() throws IOException {

        httpServletResponse.setContentType("application/vnd.ms-excel");
        httpServletResponse.setCharacterEncoding("utf-8");
        httpServletResponse.setHeader("Content-disposition", "attachment;filename=out.xlsx");
        OutputStream outputStream = httpServletResponse.getOutputStream();
        try {
            writeToStream(handle, outputStream);
        } finally {
            if (handle != 0) {
                freeWorksheetHandle(handle);
                handle = 0;
            }
            // 关闭流
            if (outputStream != null) {
                outputStream.flush();
                outputStream.close();
            }
            System.out.println("Auto Release!");
        }

    }

    @Override
    public void handleResult(ResultContext<? extends TestVo> resultContext) {
        TestVo testVo = resultContext.getResultObject();
        try {
            // 处理逻辑
            writeToWorksheet(handle, resultContext.getResultCount(), 0, testVo.getF1());
            // 省略...
            writeToWorksheet(handle, resultContext.getResultCount(), 19, testVo.getF20());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行效果：数量 10W20行，总字符数 36 * 20 * 100000 = 7.2 千万，耗时：17 秒 496 毫秒



五、JVM 分析

应用刚启动时，


导出100W20行 Excel 时，


导出完成，


总耗时：3 分 38 秒 341 毫秒，100W20行，共 7.2 亿字符，


至此，已经初步实现了导出功能，下一篇文章我们将继续拓展 API，提升使用友好度，并且优化性能。

参考资料

  1. 探索 JNI - Rust 与 Java 互调实战
  2. JVisualVM 性能分析与 Mybatis ResultHandler 实战
  3. https://docs.rs/rust_xlsxwriter/latest/rust_xlsxwriter/
  4. Mybatis Plus 集成 PgSQL 指南
相关推荐
江-小北4 分钟前
Java基础面试题07：finalize() 方法什么时候被调用？析构函数(finalization)的目的是什么？
java·开发语言·jvm
乐得瑞_郑钊展12 分钟前
低成本TYPE-C转DP线
c语言·开发语言
江-小北12 分钟前
Java基础面试题09：Java异常处理完成以后，Exception对象会发生什么变化？
java·开发语言
程饱饱吃得好饱16 分钟前
“小bug”示例
开发语言·c#·bug
l1384942745125 分钟前
项目介绍和游戏搭建（拼图小游戏）
java·开发语言·算法·游戏
Hi-Dison28 分钟前
如何提升C/C++的编程能力
c语言·开发语言·c++
matlabgoodboy30 分钟前
Rust代写 OCaml代做 Go R语言 SML Haskell Prolog DrRacket Lisp
golang·rust·r语言
软件架构师笔记35 分钟前
使用 Go 语言中的 Context 取消协程执行
开发语言·golang·tomcat
秦老师Q44 分钟前
HTML CSS JS基础考试题与答案
开发语言·前端·javascript·css·面试·html
lsx2024061 小时前
R 因子
开发语言
热门推荐
01Docker 夺命连环 15 问02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04如何识别手机是否有灵动岛（dynamic island）05玄机平台应急响应—webshell查杀06PyTorch机器学习实现液态神经网络07文件或文件夹名称中有空格如何批量去除08软件工程从理论到实践客观题汇总(头歌第一章至第八章)09Coze扣子平台完整体验和实践（附国内和国际版对比）10基于微信小程序的自习室预约系统的设计与实现