tessl/maven-com-alibaba--easyexcel

High-performance Java library for reading and writing Excel files with minimal memory usage

—

Pending

Overview

Eval results

Files

Reading Operations

Name: tessl/maven-com-alibaba--easyexcel
Author: tessl

Core functionality for reading Excel files with memory-efficient streaming and event-driven processing. EasyExcel supports XLS, XLSX, and CSV formats with configurable parsing options.

Capabilities

Main Read Entry Points

Factory methods for creating Excel readers with various input sources.

/**
 * Create a reader builder without specifying input source
 * @return ExcelReaderBuilder for configuration
 */
public static ExcelReaderBuilder read();

/**
 * Create a reader builder for a file
 * @param file File to read
 * @return ExcelReaderBuilder for configuration
 */
public static ExcelReaderBuilder read(File file);

/**
 * Create a reader builder for a file path
 * @param pathName Path to the file to read
 * @return ExcelReaderBuilder for configuration
 */
public static ExcelReaderBuilder read(String pathName);

/**
 * Create a reader builder for an input stream
 * @param inputStream InputStream to read from
 * @return ExcelReaderBuilder for configuration
 */
public static ExcelReaderBuilder read(InputStream inputStream);

/**
 * Create a reader builder with listener
 * @param file File to read
 * @param readListener Listener to handle read events
 * @return ExcelReaderBuilder for configuration
 */
public static ExcelReaderBuilder read(File file, ReadListener<?> readListener);

/**
 * Create a reader builder with head class and listener
 * @param file File to read
 * @param head Class for data mapping
 * @param readListener Listener to handle read events
 * @return ExcelReaderBuilder for configuration
 */
public static ExcelReaderBuilder read(File file, Class<?> head, ReadListener<?> readListener);

ExcelReaderBuilder Configuration

Fluent builder for configuring Excel reader options before execution.

public class ExcelReaderBuilder {
    /**
     * Set the input source file
     * @param file File to read
     * @return this builder
     */
    public ExcelReaderBuilder file(File file);
    
    /**
     * Set the input source by path
     * @param pathName Path to file
     * @return this builder
     */
    public ExcelReaderBuilder file(String pathName);
    
    /**
     * Set the input source stream
     * @param inputStream InputStream to read
     * @return this builder
     */
    public ExcelReaderBuilder file(InputStream inputStream);
    
    /**
     * Set the head class for data mapping
     * @param head Class with ExcelProperty annotations
     * @return this builder
     */
    public ExcelReaderBuilder head(Class<?> head);
    
    /**
     * Register a read listener for event handling
     * @param readListener Listener to handle read events
     * @return this builder
     */
    public ExcelReaderBuilder registerReadListener(ReadListener<?> readListener);
    
    /**
     * Set character encoding for CSV files
     * @param charset Character encoding
     * @return this builder
     */
    public ExcelReaderBuilder charset(Charset charset);
    
    /**
     * Set password for encrypted files
     * @param password File password
     * @return this builder
     */
    public ExcelReaderBuilder password(String password);
    
    /**
     * Configure whether to ignore empty rows
     * @param ignoreEmptyRow true to ignore empty rows
     * @return this builder
     */
    public ExcelReaderBuilder ignoreEmptyRow(Boolean ignoreEmptyRow);
    
    /**
     * Configure reading of extra information
     * @param cellExtraTypeEnum Type of extra info (COMMENT, HYPERLINK, MERGE)
     * @return this builder
     */
    public ExcelReaderBuilder extraRead(CellExtraTypeEnum cellExtraTypeEnum);
    
    /**
     * Build the ExcelReader instance
     * @return ExcelReader for manual control
     */
    public ExcelReader build();
    
    /**
     * Read all sheets and return data synchronously
     * @return List of all data objects
     */
    public List<Object> doReadAllSync();
    
    /**
     * Execute reading of all sheets with registered listeners
     */
    public void doReadAll();
    
    /**
     * Create a sheet builder for specific sheet configuration
     * @return ExcelReaderSheetBuilder
     */
    public ExcelReaderSheetBuilder sheet();
    
    /**
     * Create a sheet builder for specific sheet
     * @param sheetNo Sheet index (0-based)
     * @return ExcelReaderSheetBuilder
     */
    public ExcelReaderSheetBuilder sheet(Integer sheetNo);
    
    /**
     * Create a sheet builder for named sheet
     * @param sheetName Sheet name
     * @return ExcelReaderSheetBuilder
     */
    public ExcelReaderSheetBuilder sheet(String sheetName);
}

ExcelReaderSheetBuilder Configuration

Configure specific sheet reading parameters.

public class ExcelReaderSheetBuilder {
    /**
     * Set sheet index to read
     * @param sheetNo Sheet index (0-based)
     * @return this builder
     */
    public ExcelReaderSheetBuilder sheetNo(Integer sheetNo);
    
    /**
     * Set sheet name to read
     * @param sheetName Sheet name
     * @return this builder
     */
    public ExcelReaderSheetBuilder sheetName(String sheetName);
    
    /**
     * Set head class for this sheet
     * @param head Class with annotations
     * @return this builder
     */
    public ExcelReaderSheetBuilder head(Class<?> head);
    
    /**
     * Set header row number
     * @param headRowNumber Row number containing headers (0-based)
     * @return this builder
     */
    public ExcelReaderSheetBuilder headRowNumber(Integer headRowNumber);
    
    /**
     * Register listener for this sheet
     * @param readListener Listener for handling events
     * @return this builder
     */
    public ExcelReaderSheetBuilder registerReadListener(ReadListener<?> readListener);
    
    /**
     * Execute reading for this sheet
     */
    public void doRead();
    
    /**
     * Execute synchronous reading and return data
     * @return List of data objects from this sheet
     */
    public List<Object> doReadSync();
}

ExcelReader Manual Control

Direct control over the reading process for advanced scenarios.

public class ExcelReader implements Closeable {
    /**
     * Read all sheets using registered listeners
     * @return ExcelReader for chaining
     */
    public ExcelReader readAll();
    
    /**
     * Read specific sheets
     * @param readSheets Sheets to read
     * @return ExcelReader for chaining
     */
    public ExcelReader read(ReadSheet... readSheets);
    
    /**
     * Get the analysis context
     * @return AnalysisContext with metadata
     */
    public AnalysisContext analysisContext();
    
    /**
     * Finish reading and cleanup resources
     */
    public void finish();
    
    /**
     * Close the reader and cleanup resources
     */
    public void close();
}

Sheet Factory Methods

Static factory methods for creating sheet configurations.

/**
 * Create a default sheet configuration
 * @return ExcelReaderSheetBuilder
 */
public static ExcelReaderSheetBuilder readSheet();

/**
 * Create a sheet configuration by index
 * @param sheetNo Sheet index (0-based)
 * @return ExcelReaderSheetBuilder
 */
public static ExcelReaderSheetBuilder readSheet(Integer sheetNo);

/**
 * Create a sheet configuration by name
 * @param sheetName Sheet name
 * @return ExcelReaderSheetBuilder
 */
public static ExcelReaderSheetBuilder readSheet(String sheetName);

/**
 * Create a sheet configuration with index and name
 * @param sheetNo Sheet index (0-based)
 * @param sheetName Sheet name
 * @return ExcelReaderSheetBuilder
 */
public static ExcelReaderSheetBuilder readSheet(Integer sheetNo, String sheetName);

Usage Examples

Basic Synchronous Reading

import com.alibaba.excel.EasyExcel;
import java.util.List;

// Simple reading with data model
List<UserData> users = EasyExcel.read("users.xlsx")
    .head(UserData.class)
    .sheet()
    .doReadSync();

// Reading specific sheet by index
List<UserData> users = EasyExcel.read("workbook.xlsx")
    .head(UserData.class)
    .sheet(1) // Second sheet
    .doReadSync();

// Reading specific sheet by name
List<UserData> users = EasyExcel.read("workbook.xlsx")
    .head(UserData.class)
    .sheet("UserData")
    .doReadSync();

Event-Driven Reading for Large Files

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.read.listener.ReadListener;

// Create custom listener
public class UserDataListener implements ReadListener<UserData> {
    @Override
    public void invoke(UserData data, AnalysisContext context) {
        // Process each row
        System.out.println("Row " + context.getCurrentRowNum() + ": " + data);
    }
    
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        System.out.println("Reading completed");
    }
}

// Use event-driven reading
EasyExcel.read("large-file.xlsx", UserData.class, new UserDataListener())
    .sheet()
    .doRead();

Advanced Configuration

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.enums.CellExtraTypeEnum;
import java.nio.charset.StandardCharsets;

// Advanced reading configuration
EasyExcel.read("data.xlsx")
    .head(UserData.class)
    .charset(StandardCharsets.UTF_8) // For CSV files
    .password("secret123") // For encrypted files
    .ignoreEmptyRow(false) // Include empty rows
    .extraRead(CellExtraTypeEnum.COMMENT) // Read comments
    .registerReadListener(new UserDataListener())
    .sheet(0)
    .headRowNumber(2) // Headers on row 3 (0-based)
    .doRead();

Manual Reader Control

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.read.metadata.ReadSheet;

// Manual control over reading process
try (ExcelReader excelReader = EasyExcel.read("workbook.xlsx")
        .head(UserData.class)
        .registerReadListener(new UserDataListener())
        .build()) {
    
    // Read specific sheets
    ReadSheet sheet1 = EasyExcel.readSheet(0).build();
    ReadSheet sheet2 = EasyExcel.readSheet(1).build();
    
    excelReader.read(sheet1, sheet2);
    
    // Access context information
    AnalysisContext context = excelReader.analysisContext();
    System.out.println("Current sheet: " + context.getCurrentSheet().getSheetName());
}

Reading Without Data Model

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.read.listener.ReadListener;
import java.util.Map;

// Reading as Map when no data model is available
public class MapDataListener implements ReadListener<Map<Integer, String>> {
    @Override
    public void invoke(Map<Integer, String> data, AnalysisContext context) {
        System.out.println("Row data: " + data);
    }
    
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        System.out.println("Analysis completed");
    }
}

// Read without head class
EasyExcel.read("data.xlsx", new MapDataListener())
    .sheet()
    .doRead();

Install with Tessl CLI

npx tessl i tessl/maven-com-alibaba--easyexcel

docs

annotations-and-mapping.md

data-conversion.md

event-system.md

exception-handling.md

index.md

reading-operations.md

writing-operations.md

tile.json

tessl/maven-com-alibaba--easyexcel