shikeying
2024-01-11 3b67e947e36133e2a40eb2737b15ea375e157ea0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package com.walker.di.excel;
 
import com.alibaba.excel.EasyExcel;
import com.walker.di.BatchLoadListener;
import com.walker.di.BusinessImportException;
import com.walker.di.Constants;
import com.walker.di.DataImportException;
import com.walker.di.ErrorWriter;
import com.walker.di.support.InputStreamDataImportor;
 
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;
import java.util.Map;
 
/**
 * 基于阿里 <code>EasyExcel</code> 实现的数据导入器。
 * @author 时克英
 * @date 2023-02-03
 */
public abstract class ExcelDataImportor extends InputStreamDataImportor {
 
    private String batchError = null;
    private LoadListener loadListener = new InternalLoadListener();
 
    @Override
    public void setBatchEnabled() {
        this.setBatchSize(MAX_BATCH_SIZE);
    }
 
    @Override
    public void setBatchSize(long batchSize) {
        super.setBatchSize(batchSize);
        // 2023-02-03 因为该对象用户到: BatchLoadListener,所以创建一个默认的。
        this.setBatchLoadListener(new BatchLoadListener() {
            @Override
            public List<Object[]> onBatchLoad(Map<String, List<String>> columnsByName, String[] fieldNames, int dataSize) {
                throw new UnsupportedOperationException("不会使用到该对象");
            }
        });
    }
 
    @Override
    protected List<Object[]> acquireImportDataList(Object source) throws DataImportException {
        this.checkSource(source);
        try {
            DefaultDataListener dataListener = new DefaultDataListener(null);
            dataListener.setHeadRowNumber(this.getHeadRowNumber());
 
            EasyExcel.read((InputStream) source, dataListener)
                    .sheet(0).headRowNumber(this.getHeadRowNumber()).doRead();
            // 设置表头(这里只返回标识行,如果存在多行表头,只是最后一行表头)
            this.setFieldNames(dataListener.getHeaders());
            return dataListener.getRows();
        } catch (Exception ex){
            throw new DataImportException("EasyExcel解析异常:" + ex.getMessage(), ex);
        } finally {
            this.releaseSource(source);
        }
    }
 
    @Override
    protected void acquireImportBatch(BatchLoadListener batchLoadListener, Object source) throws DataImportException {
        BatchDataListener dataListener = new BatchDataListener(this.loadListener);
        dataListener.setHeadRowNumber(this.getHeadRowNumber());
        dataListener.setSaveSizeOnce(this.getSaveSizeOnce());
        dataListener.setSleepMillSeconds(this.getSleepMillSeconds());
 
        try {
            EasyExcel.read((InputStream) source, dataListener)
                    .sheet(0).headRowNumber(this.getHeadRowNumber()).doRead();
        } catch (Exception ex){
            throw new DataImportException("EasyExcel批量解析异常:" + ex.getMessage(), ex);
        } finally {
            this.releaseSource(source);
        }
    }
 
    @Override
    protected ErrorWriter acquireErrorWriter(String id, List<String> fieldNames) {
        File errorFile = null;
        OutputStream errorFileStream = null;
        errorFile = new File(this.getErrorFile());
        try {
            errorFileStream = new BufferedOutputStream(new FileOutputStream(errorFile));
            ErrorWriter errorWriter = new ExcelErrorWriter(errorFileStream, fieldNames);
            if(this.loadListener != null){
                this.loadListener.setErrorWriter(errorWriter);
            }
            return errorWriter;
//            return new ExcelErrorWriter(errorFileStream, fieldNames);
 
        } catch (FileNotFoundException e) {
            logger.error("未找到'错误文件':" + errorFile.getAbsolutePath(), e);
            return null;
        }
    }
 
    @Override
    public String getBatchError(){
        return this.batchError;
    }
 
    @Override
    public String getImportFileSuffix(){
        return Constants.IMPORT_ERROR_SUFFIX_XLSX;
    }
 
    private class InternalLoadListener implements LoadListener{
        @Override
        public void onSave(List<Object[]> rows, List<String> fieldNames) throws BusinessImportException {
            try {
                // 这里必须设置表头
                ExcelDataImportor.this.setFieldNames(fieldNames);
                ExcelDataImportor.this.doExecuteImport(rows, getFieldNames());
            } catch (DataImportException e) {
                batchError = e.getMessage();
                if(e instanceof BusinessImportException){
                    BusinessImportException bex = (BusinessImportException)e;
                    throw bex;
                } else {
                    throw new BusinessImportException("批量导入监听错误:" + e.getMessage(), e);
                }
            }
        }
 
        @Override
        public void setErrorWriter(ErrorWriter errorWriter) {
            this.errorWriter = errorWriter;
        }
 
        @Override
        public ErrorWriter getErrorWriter() {
            return this.errorWriter;
        }
 
        private ErrorWriter errorWriter = null;
    }
}