shz.paper.excel.reader.DefaultExcelSheetReader Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of paper
${project.artifactId}
There is a newer version: 2023.2.0
package shz.paper.excel.reader;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import shz.core.*;
import shz.core.msg.ServerFailureMsg;
import shz.core.reference.IReference;
import shz.paper.excel.ExcelHelp;
import shz.paper.excel.ExcelType;
import shz.paper.excel.annotation.ExcelHeader;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executor;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class DefaultExcelSheetReader implements ExcelSheetReader {
    final Class cls;
    final Consumer> consumer;
    final Predicate filter;
    final int batchSize;
    final Executor executor;
    final int headerNum;
    final Map mapping = new HashMap<>();

    public DefaultExcelSheetReader(Class cls, Consumer> consumer, Predicate filter, int batchSize, Executor executor) {
        this.cls = cls;
        this.consumer = consumer;
        this.filter = filter;
        this.batchSize = batchSize <= 0 ? 2000 : batchSize;
        this.executor = executor;

        IReference headerNumRef = new IReference();
        AccessibleHelp.fields(this.cls, field -> {
            ExcelHeader[] excelHeaders = field.getAnnotationsByType(ExcelHeader.class);
            if (excelHeaders.length != 0) {
                headerNumRef.set(Math.max(excelHeaders.length, headerNumRef.value));
                mapping.put(excelHeaders[excelHeaders.length - 1].value(), field.getName());
            }
            return false;
        });
        ServerFailureMsg.requireNonEmpty(mapping, "类:%s不存在%s注解域", this.cls.getName(), ExcelHeader.class.getName());
        headerNum = headerNumRef.value;
    }

    public DefaultExcelSheetReader(Class cls, Consumer> consumer, Predicate filter) {
        this(cls, consumer, filter, 0, null);
    }

    public DefaultExcelSheetReader(Class cls, Consumer> consumer) {
        this(cls, consumer, null);
    }

    @Override
    public final void read(ExcelType type, Sheet sheet) {
        Runner.run(singleConsumer -> {
                    if (sheet.getPhysicalNumberOfRows() - headerNum < 0) return;

                    int headerRowIndex = sheet.getFirstRowNum() + headerNum - 1;
                    Row row = sheet.getRow(headerRowIndex);
                    int columnSize = row.getPhysicalNumberOfCells();
                    String[] labels = new String[columnSize];
                    boolean mark = true;
                    for (int i = 0; i < columnSize; ++i) {
                        labels[i] = mapping.get(ExcelHelp.getCellValue(row.getCell(i)));
                        if (labels[i] != null) mark = false;
                    }
                    if (mark) return;

                    int lastRowNum = sheet.getLastRowNum();
                    for (int i = headerRowIndex + 1; i <= lastRowNum; ++i) {
                        row = sheet.getRow(i);
                        int cells = Math.min(row.getPhysicalNumberOfCells(), columnSize);
                        Map map = ToMap.get(cells).build();
                        for (int j = 0; j < cells; ++j) if (labels[j] != null) map.put(labels[j], row.getCell(j));

                        T data = FieldSetter.create(ToMap.explicitCollect(map.keySet().stream(), Function.identity(), key -> ExcelHelp.getCellValue(map.get(key)), map.size()), cls);
                        singleConsumer.accept(data);
                    }
                }, consumer, filter, batchSize, executor
        );
    }
}