EasyExcel Archived: Migrate to Apache Fesod for Better Performance & Long-Term Support

Introduction

EasyExcel, Alibaba's open-source Java Excel library with over 33,000 GitHub stars, revolutionized large-file processing by using SAX streaming parsing—reading row by row instead of loading entire files into memory. Official benchmarks showed it could read a 75 MB file (460,000 rows × 25 columns) with only 16 MB heap in 23 seconds.

Why EasyExcel Stopped

In 2023, core author Yuxiao left Alibaba. Thereafter EasyExcel entered de facto maintenance mode: GitHub issues went unanswered for 30+ days, pull requests stalled, no formal releases after v3.3.2 (October 2023), and compatibility lagged for Spring Boot 3.x, Java 21, and Apache POI 5.x. Alibaba announced end-of-updates in November 2024 and archived the repository (read-only) in September 2025.

FastExcel: A Near-Total Rewrite

In December 2024, Yuxiao released FastExcel. It is not a simple fork but a thorough rebuild with three key improvements:

Performance: Further optimized memory and I/O on top of SAX parsing. One developer reported processing time dropping from nearly 1 minute to ~18 seconds with peak memory under 800 MB.

New features: Version 1.0.0 added reading specific row ranges and Excel-to-PDF conversion, encapsulating functionality that previously required custom code.

API compatibility: Migration from EasyExcel requires only changing the Maven dependency and package name. Java imports shift from com.alibaba.excel to cn.idev.excel; the API remains nearly identical.

FastExcel gained 1.8K GitHub stars within a month.

FastExcel Graduates to Apache Fesod

In late 2025 to early 2026, the author donated the entire project to the Apache Software Foundation, making it a sub-project of Apache POI and renaming it Apache Fesod (Incubating) . Fesod stands for "Fast. Easy. Spreadsheet and Other Documents." The first incubating release, 2.0.0-incubating, arrived on January 21, 2026, followed by 2.0.1-incubating on February 11, 2026.

This moves code ownership from an individual/company to the Apache Foundation—same governance as Apache POI, Maven, and Tomcat—ensuring long-term maintenance, stable release cadence, and elimination of the "author leaves, project stalls" risk.

FastExcel vs. Apache Fesod: Which to Use?

New projects: Start directly with Apache Fesod to avoid a future migration.

Existing EasyExcel/FastExcel projects: Migrate to Fesod in three steps: update Maven coordinates, change import packages, swap the entry class.

Migration Steps (Code Examples)

1. Update Maven Dependency

<!-- Old FastExcel -->
<dependency>
  <groupId>cn.idev.excel</groupId>
  <artifactId>fastexcel</artifactId>
  <version>1.3.0</version>
</dependency>

<!-- New Apache Fesod -->
<dependency>
  <groupId>org.apache.fesod</groupId>
  <artifactId>fesod</artifactId>
  <version>2.0.1-incubating</version>
</dependency>

2. Change Import Packages

// Old imports
import cn.idev.excel.EasyExcel;
import cn.idev.excel.annotation.ExcelProperty;

// New imports
import org.apache.fesod.Fesod;
import org.apache.fesod.annotation.ExcelProperty;

3. Replace Entry Class

// Old FastExcel
EasyExcel.write(response.getOutputStream(), User.class)
    .sheet("用户列表")
    .doWrite(users);

// New Fesod (API nearly identical)
Fesod.write(response.getOutputStream(), User.class)
    .sheet("用户列表")
    .doWrite(users);

4. Complete Example: Million-Row Export

@RestController
@RequestMapping("/api/export")
public class ExportController {
    @GetMapping("/orders")
    public void exportOrders(HttpServletResponse response) throws IOException {
        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setCharacterEncoding("utf-8");
        String fileName = URLEncoder.encode("订单报表", "UTF-8").replaceAll("\\+", "%20");
        response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");

        try (ExcelWriter writer = Fesod.write(response.getOutputStream(), OrderExportVO.class)
                .sheet("订单数据")
                .build()) {
            int page = 1;
            int pageSize = 10000;
            while (true) {
                List<OrderExportVO> pageData = orderService.pageOrders(page, pageSize);
                if (pageData.isEmpty()) break;
                writer.write(pageData);
                page++;
            }
        }
    }
}

Streaming write ensures no OOM even with millions of rows. A logistics company reported report generation time dropping from 4 hours to 20 minutes and server resource usage reduced by 60% after adopting FastExcel (now Fesod).

Five-Solution Technical Comparison

The article compares six approaches across maintenance status, suitable scale, memory model, and critical drawbacks:

Apache POI (DOM): Active, any scale, but ten-thousand-row writes easily OOM.

POI SXSSF (streaming write): Active, large files, streaming write but weak at reading.

HuTool Excel: Active, under 10k rows, simple, limited advanced features.

EasyExcel: Archived (2024), any scale, streaming, no new features/bug fixes.

FastExcel: Transitional naming, any scale, streaming, deprecated for new projects.

Apache Fesod: Apache incubating, any scale, streaming, still in incubating phase.

Performance Benchmarks (500k Row Write)

dhatim/FastExcel: 13s, 18 GC cycles, 285ms GC pause, 1.68 GB peak memory — fastest speed but poor memory efficiency.

Apache Fesod: 21s, 7 GC cycles , 68ms GC pause , peak memory not disclosed — best overall balance.

EasyExcel/FastExcel (legacy): Comparable speed, GC pauses 42-55ms, similar memory profile.

Fesod's GC count is only 40% of other frameworks; in high-concurrency scenarios, memory efficiency outweighs raw speed because a single GC pause can erase all throughput gains.

Pros and Cons

Pros

Seamless API migration across EasyExcel → FastExcel → Fesod.

Streaming processing keeps memory in MB range even for millions of rows.

Continuous iteration: new features like row-range reading and Excel-to-PDF.

Apache Foundation governance guarantees long-term maintenance.

MIT license — commercial-friendly.

Industry-leading memory efficiency: GC frequency 2.5× better than EasyExcel/FastExcel.

Cons

Still in incubating stage; 2.x API may see minor adjustments.

Naming churn: three names in one year (EasyExcel → FastExcel → Apache Fesod).

FastExcel 1.3.0 is end-of-life; no further updates.

Migration from FastExcel to Fesod requires coordinate, import, and entry-class changes.

Selection Recommendations

New project: Apache Fesod — avoids future migration.

Using EasyExcel: Migrate to Fesod (swap dependency + imports).

Using FastExcel: Migrate to Fesod (swap coordinates + imports + entry class).

Trivial Excel needs (few rows): HuTool one-liner — don't over-engineer.

Need Excel-to-PDF: Fesod has built-in support.

Conclusion

EasyExcel is truly dead (archived September 2025). FastExcel didn't die—it graduated to Apache Fesod, gaining foundation-level longevity. The "triple jump" in one year is a rare open-source success story: from personal maintenance to Apache-backed sustainability. Developers should adopt Fesod for new work and gradually migrate existing codebases. The migration cost is low, and the payoff is Apache-grade maintenance, ongoing feature development, and superior memory efficiency. Fesod is already in production at multiple enterprises and is the strongest choice for large-scale Excel processing today.

Resources:

Apache Fesod GitHub: https://github.com/apache/fesod

Fesod Official Docs: https://fesod.apache.org