Merge remote-tracking branch 'origin/master'

# Conflicts:
#	easyexcel-core/src/main/java/com/alibaba/excel/util/PoiUtils.java

README.md

@@ -31,7 +31,7 @@ easyexcel重写了poi对07版Excel的解析，一个3M的excel用POI sax解析
 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>easyexcel</artifactId>
-    <version>3.2.1</version>
+    <version>3.3.1</version>
 </dependency>
 ```
 

README_EN.md

@@ -122,7 +122,7 @@ DEMO：[https://github.com/alibaba/easyexcel/blob/master/src/test/java/com/aliba
      *  1. Create an entity object, refer to{@link DownloadData}. 
      *     Each property of the entity object corresponds to a specific field of Excel
      *  2. Specify the returned properties
-     *  3. Invoke wirte function, then the OutputStream is automatically closed when it ends.
+     *  3. Invoke write function, then the OutputStream is automatically closed when it ends.
      * </p>
      */
     @GetMapping("download")

easyexcel-core/pom.xml

@@ -40,5 +40,9 @@
             <groupId>org.ehcache</groupId>
             <artifactId>ehcache</artifactId>
         </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+        </dependency>
     </dependencies>
 </project>

easyexcel-core/src/main/java/com/alibaba/excel/analysis/ExcelAnalyserImpl.java

@@ -19,6 +19,7 @@ import com.alibaba.excel.read.metadata.holder.csv.CsvReadWorkbookHolder;
 import com.alibaba.excel.read.metadata.holder.xls.XlsReadWorkbookHolder;
 import com.alibaba.excel.read.metadata.holder.xlsx.XlsxReadWorkbookHolder;
 import com.alibaba.excel.support.ExcelTypeEnum;
+import com.alibaba.excel.util.ClassUtils;
 import com.alibaba.excel.util.DateUtils;
 import com.alibaba.excel.util.FileUtils;
 import com.alibaba.excel.util.NumberDataFormatterUtils;
@@ -212,6 +213,7 @@ public class ExcelAnalyserImpl implements ExcelAnalyser {
     private void removeThreadLocalCache() {
         NumberDataFormatterUtils.removeThreadLocalCache();
         DateUtils.removeThreadLocalCache();
+        ClassUtils.removeThreadLocalCache();
     }
 
     private void clearEncrypt03() {

easyexcel-core/src/main/java/com/alibaba/excel/analysis/csv/CsvExcelReadExecutor.java

@@ -1,6 +1,7 @@
 package com.alibaba.excel.analysis.csv;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.nio.file.Files;
 import java.util.ArrayList;
@@ -11,6 +12,7 @@ import java.util.Map;
 
 import com.alibaba.excel.analysis.ExcelReadExecutor;
 import com.alibaba.excel.context.csv.CsvReadContext;
+import com.alibaba.excel.enums.ByteOrderMarkEnum;
 import com.alibaba.excel.enums.CellDataTypeEnum;
 import com.alibaba.excel.enums.RowTypeEnum;
 import com.alibaba.excel.exception.ExcelAnalysisException;
@@ -27,6 +29,7 @@ import org.apache.commons.collections4.MapUtils;
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVParser;
 import org.apache.commons.csv.CSVRecord;
+import org.apache.commons.io.input.BOMInputStream;
 
 /**
  * read executor
@@ -82,17 +85,26 @@ public class CsvExcelReadExecutor implements ExcelReadExecutor {
     private CSVParser csvParser() throws IOException {
         CsvReadWorkbookHolder csvReadWorkbookHolder = csvReadContext.csvReadWorkbookHolder();
         CSVFormat csvFormat = csvReadWorkbookHolder.getCsvFormat();
-
+        ByteOrderMarkEnum byteOrderMark = ByteOrderMarkEnum.valueOfByCharsetName(
+            csvReadContext.csvReadWorkbookHolder().getCharset().name());
         if (csvReadWorkbookHolder.getMandatoryUseInputStream()) {
-            return csvFormat.parse(
-                new InputStreamReader(csvReadWorkbookHolder.getInputStream(), csvReadWorkbookHolder.getCharset()));
+            return buildCsvParser(csvFormat, csvReadWorkbookHolder.getInputStream(), byteOrderMark);
         }
         if (csvReadWorkbookHolder.getFile() != null) {
-            return csvFormat.parse(new InputStreamReader(Files.newInputStream(csvReadWorkbookHolder.getFile().toPath()),
-                csvReadWorkbookHolder.getCharset()));
+            return buildCsvParser(csvFormat, Files.newInputStream(csvReadWorkbookHolder.getFile().toPath()),
+                byteOrderMark);
+        }
+        return buildCsvParser(csvFormat, csvReadWorkbookHolder.getInputStream(), byteOrderMark);
+    }
+
+    private CSVParser buildCsvParser(CSVFormat csvFormat, InputStream inputStream, ByteOrderMarkEnum byteOrderMark)
+        throws IOException {
+        if (byteOrderMark == null) {
+            return csvFormat.parse(
+                new InputStreamReader(inputStream, csvReadContext.csvReadWorkbookHolder().getCharset()));
         }
-        return csvFormat.parse(
-            new InputStreamReader(csvReadWorkbookHolder.getInputStream(), csvReadWorkbookHolder.getCharset()));
+        return csvFormat.parse(new InputStreamReader(new BOMInputStream(inputStream, byteOrderMark.getByteOrderMark()),
+            csvReadContext.csvReadWorkbookHolder().getCharset()));
     }
 
     private void dealRecord(CSVRecord record, int rowIndex) {

easyexcel-core/src/main/java/com/alibaba/excel/analysis/v07/handlers/sax/SharedStringsTableHandler.java

@@ -1,11 +1,31 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
 package com.alibaba.excel.analysis.v07.handlers.sax;
 
-import org.xml.sax.Attributes;
-import org.xml.sax.helpers.DefaultHandler;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import com.alibaba.excel.cache.ReadCache;
 import com.alibaba.excel.constant.ExcelXmlConstants;
 
+import org.xml.sax.Attributes;
+import org.xml.sax.helpers.DefaultHandler;
+
 /**
  * Sax read sharedStringsTable.xml
  *
@@ -13,6 +33,8 @@ import com.alibaba.excel.constant.ExcelXmlConstants;
  */
 public class SharedStringsTableHandler extends DefaultHandler {
 
+    private static final Pattern UTF_PATTTERN = Pattern.compile("_x([0-9A-Fa-f]{4})_");
+
     /**
      * The final piece of data
      */
@@ -86,7 +108,7 @@ public class SharedStringsTableHandler extends DefaultHandler {
                 if (currentData == null) {
                     readCache.put(null);
                 } else {
-                    readCache.put(currentData.toString());
+                    readCache.put(utfDecode(currentData.toString()));
                 }
                 break;
             case ExcelXmlConstants.SHAREDSTRINGS_RPH_TAG:
@@ -109,4 +131,51 @@ public class SharedStringsTableHandler extends DefaultHandler {
         }
         currentElementData.append(ch, start, length);
     }
+
+    /**
+     * from poi XSSFRichTextString
+     *
+     * @param value the string to decode
+     * @return the decoded string or null if the input string is null
+     * <p>
+     * For all characters which cannot be represented in XML as defined by the XML 1.0 specification,
+     * the characters are escaped using the Unicode numerical character representation escape character
+     * format _xHHHH_, where H represents a hexadecimal character in the character's value.
+     * <p>
+     * Example: The Unicode character 0D is invalid in an XML 1.0 document,
+     * so it shall be escaped as <code>_x000D_</code>.
+     * </p>
+     * See section 3.18.9 in the OOXML spec.
+     * @see org.apache.poi.xssf.usermodel.XSSFRichTextString#utfDecode(String)
+     */
+    static String utfDecode(String value) {
+        if (value == null || !value.contains("_x")) {
+            return value;
+        }
+
+        StringBuilder buf = new StringBuilder();
+        Matcher m = UTF_PATTTERN.matcher(value);
+        int idx = 0;
+        while (m.find()) {
+            int pos = m.start();
+            if (pos > idx) {
+                buf.append(value, idx, pos);
+            }
+
+            String code = m.group(1);
+            int icode = Integer.decode("0x" + code);
+            buf.append((char)icode);
+
+            idx = m.end();
+        }
+
+        // small optimization: don't go via StringBuilder if not necessary,
+        // the encodings are very rare, so we should almost always go via this shortcut.
+        if (idx == 0) {
+            return value;
+        }
+
+        buf.append(value.substring(idx));
+        return buf.toString();
+    }
 }

easyexcel-core/src/main/java/com/alibaba/excel/context/WriteContextImpl.java

@@ -265,7 +265,7 @@ public class WriteContextImpl implements WriteContext {
             Head head = entry.getValue();
             int columnIndex = entry.getKey();
             ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(null,
-                currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), head.getFieldName());
+                currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), head.getFieldName(), currentWriteHolder);
 
             CellWriteHandlerContext cellWriteHandlerContext = WriteHandlerUtils.createCellWriteHandlerContext(this, row,
                 rowIndex, head, columnIndex, relativeRowIndex, Boolean.TRUE, excelContentProperty);
@@ -427,6 +427,7 @@ public class WriteContextImpl implements WriteContext {
     private void removeThreadLocalCache() {
         NumberDataFormatterUtils.removeThreadLocalCache();
         DateUtils.removeThreadLocalCache();
+        ClassUtils.removeThreadLocalCache();
     }
 
     @Override

easyexcel-core/src/main/java/com/alibaba/excel/converters/DefaultConverterLoader.java

@@ -115,8 +115,6 @@ public class DefaultConverterLoader {
         putAllConverter(new StringNumberConverter());
         putAllConverter(new StringStringConverter());
         putAllConverter(new StringErrorConverter());
-
-        putAllConverter(new BigIntegerStringConverter());
     }
 
     private static void initDefaultWriteConverter() {
@@ -154,7 +152,6 @@ public class DefaultConverterLoader {
         putWriteStringConverter(new LongStringConverter());
         putWriteStringConverter(new ShortStringConverter());
         putWriteStringConverter(new StringStringConverter());
-        putWriteStringConverter(new BigIntegerStringConverter());
     }
 
     /**

easyexcel-core/src/main/java/com/alibaba/excel/enums/ByteOrderMarkEnum.java

@@ -0,0 +1,66 @@
+package com.alibaba.excel.enums;
+
+import java.nio.charset.Charset;
+import java.util.Map;
+
+import com.alibaba.excel.util.MapUtils;
+
+import lombok.Getter;
+import org.apache.commons.io.ByteOrderMark;
+
+/**
+ * byte order mark
+ *
+ * @author Jiaju Zhuang
+ */
+@Getter
+public enum ByteOrderMarkEnum {
+
+    /**
+     * UTF_8
+     */
+    UTF_8(ByteOrderMark.UTF_8),
+    /**
+     * UTF_16BE
+     */
+    UTF_16BE(ByteOrderMark.UTF_16BE),
+    /**
+     * UTF_16LE
+     */
+    UTF_16LE(ByteOrderMark.UTF_16LE),
+    /**
+     * UTF_32BE
+     */
+    UTF_32BE(ByteOrderMark.UTF_32BE),
+    /**
+     * UTF_32LE
+     */
+    UTF_32LE(ByteOrderMark.UTF_32LE),
+
+    ;
+
+    final ByteOrderMark byteOrderMark;
+    final String stringPrefix;
+
+    ByteOrderMarkEnum(ByteOrderMark byteOrderMark) {
+        this.byteOrderMark = byteOrderMark;
+        Charset charset = Charset.forName(byteOrderMark.getCharsetName());
+        this.stringPrefix = new String(byteOrderMark.getBytes(), charset);
+    }
+
+    /**
+     * store character aliases corresponding to `ByteOrderMark` prefix
+     */
+    private static final Map<String, ByteOrderMarkEnum> CHARSET_BYTE_ORDER_MARK_MAP = MapUtils.newHashMap();
+
+    static {
+        for (ByteOrderMarkEnum value : ByteOrderMarkEnum.values()) {
+            CHARSET_BYTE_ORDER_MARK_MAP.put(value.getByteOrderMark().getCharsetName(), value);
+        }
+    }
+
+    public static ByteOrderMarkEnum valueOfByCharsetName(String charsetName) {
+        return CHARSET_BYTE_ORDER_MARK_MAP.get(charsetName);
+    }
+
+}

easyexcel-core/src/main/java/com/alibaba/excel/enums/CacheLocationEnum.java

@@ -0,0 +1,23 @@
+package com.alibaba.excel.enums;
+
+/**
+ * cache locaciton
+ *
+ * @author Jiaju Zhuang
+ **/
+public enum CacheLocationEnum {
+    /**
+     * The cache will be stored in {@code ThreadLocal}, and will be cleared when the excel read and write is completed.
+     */
+    THREAD_LOCAL,
+
+    /**
+     * The cache will not be cleared unless the app is stopped.
+     */
+    MEMORY,
+
+    /**
+     * No caching.It may lose some of performance.
+     */
+    NONE;
+}

easyexcel-core/src/main/java/com/alibaba/excel/metadata/AbstractHolder.java

@@ -83,6 +83,15 @@ public abstract class AbstractHolder implements ConfigurationHolder {
             globalConfiguration.setLocale(basicParameter.getLocale());
         }
 
+        if (basicParameter.getFiledCacheLocation() == null) {
+            if (prentAbstractHolder != null) {
+                globalConfiguration.setFiledCacheLocation(
+                    prentAbstractHolder.getGlobalConfiguration().getFiledCacheLocation());
+            }
+        } else {
+            globalConfiguration.setFiledCacheLocation(basicParameter.getFiledCacheLocation());
+        }
+
     }
 
     @Override

easyexcel-core/src/main/java/com/alibaba/excel/metadata/AbstractParameterBuilder.java

@@ -4,6 +4,7 @@ import java.util.List;
 import java.util.Locale;
 
 import com.alibaba.excel.converters.Converter;
+import com.alibaba.excel.enums.CacheLocationEnum;
 import com.alibaba.excel.util.ListUtils;
 
 /**
@@ -73,6 +74,18 @@ public abstract class AbstractParameterBuilder<T extends AbstractParameterBuilde
         return self();
     }
 
+    /**
+     * The cache used when parsing fields such as head.
+     *
+     * default is THREAD_LOCAL.
+     *
+     * @since 3.3.0
+     */
+    public T filedCacheLocation(CacheLocationEnum filedCacheLocation) {
+        parameter().setFiledCacheLocation(filedCacheLocation);
+        return self();
+    }
+
     /**
      * Automatic trim includes sheet name and content
      *

easyexcel-core/src/main/java/com/alibaba/excel/metadata/BasicParameter.java

@@ -4,6 +4,7 @@ import java.util.List;
 import java.util.Locale;
 
 import com.alibaba.excel.converters.Converter;
+import com.alibaba.excel.enums.CacheLocationEnum;
 
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
@@ -54,4 +55,11 @@ public class BasicParameter {
      * default is false
      */
     private Boolean useScientificFormat;
+
+    /**
+     * The cache used when parsing fields such as head.
+     *
+     * default is THREAD_LOCAL.
+     */
+    private CacheLocationEnum filedCacheLocation;
 }

easyexcel-core/src/main/java/com/alibaba/excel/metadata/FieldCache.java

@@ -0,0 +1,33 @@
+package com.alibaba.excel.metadata;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.Set;
+
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * filed cache
+ *
+ * @author Jiaju Zhuang
+ */
+@Getter
+@Setter
+@EqualsAndHashCode
+@AllArgsConstructor
+public class FieldCache {
+
+    /**
+     * A field cache that has been sorted by a class.
+     * It will exclude fields that are not needed.
+     */
+    private Map<Integer, FieldWrapper> sortedFieldMap;
+
+    /**
+     * Fields using the index attribute
+     */
+    private Map<Integer, FieldWrapper> indexFieldMap;
+}

easyexcel-core/src/main/java/com/alibaba/excel/metadata/FieldWrapper.java

@@ -0,0 +1,43 @@
+package com.alibaba.excel.metadata;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.Set;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * filed wrapper
+ *
+ * @author Jiaju Zhuang
+ */
+@Getter
+@Setter
+@EqualsAndHashCode
+@AllArgsConstructor
+@NoArgsConstructor
+public class FieldWrapper {
+
+    /**
+     * field
+     */
+    private Field field;
+
+    /**
+     * The field name matching cglib
+     */
+    private String fieldName;
+
+    /**
+     * The name of the sheet header.
+     *
+     * @see ExcelProperty
+     */
+    private String[] heads;
+}

easyexcel-core/src/main/java/com/alibaba/excel/metadata/GlobalConfiguration.java

@@ -2,6 +2,8 @@ package com.alibaba.excel.metadata;
 
 import java.util.Locale;
 
+import com.alibaba.excel.enums.CacheLocationEnum;
+
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
@@ -32,6 +34,7 @@ public class GlobalConfiguration {
      * used when formatting dates and numbers.
      */
     private Locale locale;
+
     /**
      * Whether to use scientific Format.
      *
@@ -39,10 +42,18 @@ public class GlobalConfiguration {
      */
     private Boolean useScientificFormat;
 
+    /**
+     * The cache used when parsing fields such as head.
+     *
+     * default is THREAD_LOCAL.
+     */
+    private CacheLocationEnum filedCacheLocation;
+
     public GlobalConfiguration() {
         this.autoTrim = Boolean.TRUE;
         this.use1904windowing = Boolean.FALSE;
         this.locale = Locale.getDefault();
         this.useScientificFormat = Boolean.FALSE;
+        this.filedCacheLocation = CacheLocationEnum.THREAD_LOCAL;
     }
 }

easyexcel-core/src/main/java/com/alibaba/excel/metadata/csv/CsvSheet.java

@@ -3,24 +3,30 @@ package com.alibaba.excel.metadata.csv;
 import java.io.Closeable;
 import java.io.IOException;
 import java.math.BigDecimal;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
 import com.alibaba.excel.constant.BuiltinFormats;
+import com.alibaba.excel.enums.ByteOrderMarkEnum;
 import com.alibaba.excel.enums.NumericCellTypeEnum;
 import com.alibaba.excel.exception.ExcelGenerateException;
 import com.alibaba.excel.util.DateUtils;
 import com.alibaba.excel.util.ListUtils;
+import com.alibaba.excel.util.MapUtils;
 import com.alibaba.excel.util.NumberDataFormatterUtils;
 import com.alibaba.excel.util.StringUtils;
 
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVPrinter;
+import org.apache.commons.io.ByteOrderMark;
 import org.apache.poi.ss.usermodel.AutoFilter;
 import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.ss.usermodel.CellRange;
@@ -51,6 +57,7 @@ import org.apache.poi.ss.util.PaneInformation;
 @Setter
 @EqualsAndHashCode
 public class CsvSheet implements Sheet, Closeable {
+
     /**
      * workbook
      */
@@ -109,6 +116,13 @@ public class CsvSheet implements Sheet, Closeable {
         }
         rowCache = ListUtils.newArrayListWithExpectedSize(rowCacheCount);
         try {
+            if (csvWorkbook.getWithBom()) {
+                ByteOrderMarkEnum byteOrderMark = ByteOrderMarkEnum.valueOfByCharsetName(
+                    csvWorkbook.getCharset().name());
+                if (byteOrderMark != null) {
+                    out.append(byteOrderMark.getStringPrefix());
+                }
+            }
             csvPrinter = csvFormat.print(out);
         } catch (IOException e) {
             throw new ExcelGenerateException(e);

easyexcel-core/src/main/java/com/alibaba/excel/metadata/csv/CsvWorkbook.java

@@ -2,6 +2,7 @@ package com.alibaba.excel.metadata.csv;
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.nio.charset.Charset;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
@@ -71,11 +72,25 @@ public class CsvWorkbook implements Workbook {
      */
     private List<CsvCellStyle> csvCellStyleList;
 
-    public CsvWorkbook(Appendable out, Locale locale, Boolean use1904windowing, Boolean useScientificFormat) {
+    /**
+     * charset.
+     */
+    private Charset charset;
+
+    /**
+     * Set the encoding prefix in the csv file, otherwise the office may open garbled characters.
+     * Default true.
+     */
+    private Boolean withBom;
+
+    public CsvWorkbook(Appendable out, Locale locale, Boolean use1904windowing, Boolean useScientificFormat,
+        Charset charset, Boolean withBom) {
         this.out = out;
         this.locale = locale;
         this.use1904windowing = use1904windowing;
         this.useScientificFormat = useScientificFormat;
+        this.charset = charset;
+        this.withBom = withBom;
     }
 
     @Override

easyexcel-core/src/main/java/com/alibaba/excel/metadata/property/ExcelHeadProperty.java

@@ -9,6 +9,9 @@ import java.util.TreeMap;
 
 import com.alibaba.excel.annotation.ExcelProperty;
 import com.alibaba.excel.enums.HeadKindEnum;
+import com.alibaba.excel.metadata.ConfigurationHolder;
+import com.alibaba.excel.metadata.FieldCache;
+import com.alibaba.excel.metadata.FieldWrapper;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.Holder;
 import com.alibaba.excel.util.ClassUtils;
@@ -51,22 +54,17 @@ public class ExcelHeadProperty {
      * Configuration header information
      */
     private Map<Integer, Head> headMap;
-    /**
-     * Fields ignored
-     */
-    private Map<String, Field> ignoreMap;
 
-    public ExcelHeadProperty(Holder holder, Class<?> headClazz, List<List<String>> head) {
+    public ExcelHeadProperty(ConfigurationHolder configurationHolder, Class<?> headClazz, List<List<String>> head) {
         this.headClazz = headClazz;
         headMap = new TreeMap<>();
-        ignoreMap = MapUtils.newHashMap();
         headKind = HeadKindEnum.NONE;
         headRowNumber = 0;
         if (head != null && !head.isEmpty()) {
             int headIndex = 0;
             for (int i = 0; i < head.size(); i++) {
-                if (holder instanceof AbstractWriteHolder) {
-                    if (((AbstractWriteHolder)holder).ignore(null, i)) {
+                if (configurationHolder instanceof AbstractWriteHolder) {
+                    if (((AbstractWriteHolder)configurationHolder).ignore(null, i)) {
                         continue;
                     }
                 }
@@ -76,7 +74,7 @@ public class ExcelHeadProperty {
             headKind = HeadKindEnum.STRING;
         }
         // convert headClazz to head
-        initColumnProperties(holder);
+        initColumnProperties(configurationHolder);
 
         initHeadRowNumber();
         if (LOGGER.isDebugEnabled()) {
@@ -104,24 +102,15 @@ public class ExcelHeadProperty {
         }
     }
 
-    private void initColumnProperties(Holder holder) {
+    private void initColumnProperties(ConfigurationHolder configurationHolder) {
         if (headClazz == null) {
             return;
         }
-        // Declared fields
-        Map<Integer, Field> sortedAllFieldMap = MapUtils.newTreeMap();
-        Map<Integer, Field> indexFieldMap = MapUtils.newTreeMap();
-
-        boolean needIgnore = (holder instanceof AbstractWriteHolder) && (
-            !CollectionUtils.isEmpty(((AbstractWriteHolder)holder).getExcludeColumnFieldNames()) || !CollectionUtils
-                .isEmpty(((AbstractWriteHolder)holder).getExcludeColumnIndexes()) || !CollectionUtils
-                .isEmpty(((AbstractWriteHolder)holder).getIncludeColumnFieldNames()) || !CollectionUtils
-                .isEmpty(((AbstractWriteHolder)holder).getIncludeColumnIndexes()));
-
-        ClassUtils.declaredFields(headClazz, sortedAllFieldMap, indexFieldMap, ignoreMap, needIgnore, holder);
+        FieldCache fieldCache = ClassUtils.declaredFields(headClazz, configurationHolder);
 
-        for (Map.Entry<Integer, Field> entry : sortedAllFieldMap.entrySet()) {
-            initOneColumnProperty(entry.getKey(), entry.getValue(), indexFieldMap.containsKey(entry.getKey()));
+        for (Map.Entry<Integer, FieldWrapper> entry : fieldCache.getSortedFieldMap().entrySet()) {
+            initOneColumnProperty(entry.getKey(), entry.getValue(),
+                fieldCache.getIndexFieldMap().containsKey(entry.getKey()));
         }
         headKind = HeadKindEnum.CLASS;
     }
@@ -134,22 +123,20 @@ public class ExcelHeadProperty {
      * @param forceIndex
      * @return Ignore current field
      */
-    private void initOneColumnProperty(int index, Field field, Boolean forceIndex) {
-        ExcelProperty excelProperty = field.getAnnotation(ExcelProperty.class);
-        List<String> tmpHeadList = new ArrayList<String>();
-        String fieldName = FieldUtils.resolveCglibFieldName(field);
-        boolean notForceName = excelProperty == null || excelProperty.value().length <= 0
-            || (excelProperty.value().length == 1 && StringUtils.isEmpty((excelProperty.value())[0]));
+    private void initOneColumnProperty(int index, FieldWrapper field, Boolean forceIndex) {
+        List<String> tmpHeadList = new ArrayList<>();
+        boolean notForceName = field.getHeads() == null || field.getHeads().length == 0
+            || (field.getHeads().length == 1 && StringUtils.isEmpty(field.getHeads()[0]));
         if (headMap.containsKey(index)) {
             tmpHeadList.addAll(headMap.get(index).getHeadNameList());
         } else {
             if (notForceName) {
-                tmpHeadList.add(fieldName);
+                tmpHeadList.add(field.getFieldName());
             } else {
-                Collections.addAll(tmpHeadList, excelProperty.value());
+                Collections.addAll(tmpHeadList, field.getHeads());
             }
         }
-        Head head = new Head(index, field, fieldName, tmpHeadList, forceIndex, !notForceName);
+        Head head = new Head(index, field.getField(), field.getFieldName(), tmpHeadList, forceIndex, !notForceName);
         headMap.put(index, head);
     }
 

easyexcel-core/src/main/java/com/alibaba/excel/read/listener/ModelBuildEventListener.java

@@ -149,7 +149,8 @@ public class ModelBuildEventListener implements IgnoreExceptionReadListener<Map<
             ReadCellData<?> cellData = cellDataMap.get(index);
             Object value = ConverterUtils.convertToJavaObject(cellData, head.getField(),
                 ClassUtils.declaredExcelContentProperty(dataMap, readSheetHolder.excelReadHeadProperty().getHeadClazz(),
-                    fieldName), readSheetHolder.converterMap(), context, context.readRowHolder().getRowIndex(), index);
+                    fieldName, readSheetHolder), readSheetHolder.converterMap(), context,
+                context.readRowHolder().getRowIndex(), index);
             if (value != null) {
                 dataMap.put(fieldName, value);
             }

easyexcel-core/src/main/java/com/alibaba/excel/read/listener/PageReadListener.java

@@ -15,7 +15,7 @@ import org.apache.commons.collections4.CollectionUtils;
  */
 public class PageReadListener<T> implements ReadListener<T> {
     /**
-     * Defuault single handle the amount of data
+     * Default single handle the amount of data
      */
     public static int BATCH_COUNT = 100;
     /**

easyexcel-core/src/main/java/com/alibaba/excel/read/listener/ReadListener.java

@@ -36,7 +36,7 @@ public interface ReadListener<T> extends Listener {
     /**
      * When analysis one row trigger invoke function.
      *
-     * @param data    one row value. Is is same as {@link AnalysisContext#readRowHolder()}
+     * @param data    one row value. It is same as {@link AnalysisContext#readRowHolder()}
      * @param context analysis context
      */
     void invoke(T data, AnalysisContext context);

easyexcel-core/src/main/java/com/alibaba/excel/read/metadata/holder/csv/CsvReadWorkbookHolder.java

@@ -10,6 +10,9 @@ import lombok.Setter;
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVParser;
 
+import java.io.IOException;
+import java.nio.file.Files;
+
 /**
  * Workbook holder
  *

easyexcel-core/src/main/java/com/alibaba/excel/read/metadata/property/ExcelReadHeadProperty.java

@@ -2,6 +2,7 @@ package com.alibaba.excel.read.metadata.property;
 
 import java.util.List;
 
+import com.alibaba.excel.metadata.ConfigurationHolder;
 import com.alibaba.excel.metadata.Holder;
 import com.alibaba.excel.metadata.property.ExcelHeadProperty;
 
@@ -12,7 +13,7 @@ import com.alibaba.excel.metadata.property.ExcelHeadProperty;
  */
 public class ExcelReadHeadProperty extends ExcelHeadProperty {
 
-    public ExcelReadHeadProperty(Holder holder, Class headClazz, List<List<String>> head) {
-        super(holder, headClazz, head);
+    public ExcelReadHeadProperty(ConfigurationHolder configurationHolder, Class headClazz, List<List<String>> head) {
+        super(configurationHolder, headClazz, head);
     }
 }

easyexcel-core/src/main/java/com/alibaba/excel/support/ExcelTypeEnum.java

@@ -23,10 +23,12 @@ public enum ExcelTypeEnum {
      * csv
      */
     CSV(".csv", new byte[] {-27, -89, -109, -27}),
+
     /**
      * xls
      */
     XLS(".xls", new byte[] {-48, -49, 17, -32, -95, -79, 26, -31}),
+
     /**
      * xlsx
      */
@@ -96,13 +98,11 @@ public enum ExcelTypeEnum {
         byte[] data = IOUtils.peekFirstNBytes(inputStream, MAX_PATTERN_LENGTH);
         if (findMagic(XLSX.magic, data)) {
             return XLSX;
-        } else if (findMagic(CSV.magic, data)) {
-            return CSV;
         } else if (findMagic(XLS.magic, data)) {
             return XLS;
         }
-        throw new ExcelCommonException(
-            "Convert excel format exception.You can try specifying the 'excelType' yourself");
+        // csv has no fixed prefix, if the format is not specified, it defaults to csv
+        return CSV;
     }
 
     private static boolean findMagic(byte[] expected, byte[] actual) {

easyexcel-core/src/main/java/com/alibaba/excel/util/ClassUtils.java

@@ -3,6 +3,7 @@ package com.alibaba.excel.util;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -10,6 +11,7 @@ import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -23,7 +25,9 @@ import com.alibaba.excel.annotation.write.style.ContentStyle;
 import com.alibaba.excel.converters.AutoConverter;
 import com.alibaba.excel.converters.Converter;
 import com.alibaba.excel.exception.ExcelCommonException;
-import com.alibaba.excel.metadata.Holder;
+import com.alibaba.excel.metadata.ConfigurationHolder;
+import com.alibaba.excel.metadata.FieldCache;
+import com.alibaba.excel.metadata.FieldWrapper;
 import com.alibaba.excel.metadata.property.DateTimeFormatProperty;
 import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.metadata.property.FontProperty;
@@ -35,6 +39,7 @@ import lombok.AllArgsConstructor;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
+import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.cglib.beans.BeanMap;
 
 /**
@@ -55,18 +60,38 @@ import org.springframework.cglib.beans.BeanMap;
  */
 public class ClassUtils {
 
-    public static final Map<Class<?>, FieldCache> FIELD_CACHE = new ConcurrentHashMap<>();
+    /**
+     * memory cache
+     */
+    public static final ConcurrentHashMap<Class<?>, FieldCache> FIELD_CACHE = new ConcurrentHashMap<>();
+    /**
+     * thread local cahe
+     */
+    private static final ThreadLocal<Map<Class<?>, FieldCache>> FIELD_THREAD_LOCAL = new ThreadLocal<>();
+
+    /**
+     * The cache configuration information for each of the class
+     */
+    public static final ConcurrentHashMap<Class<?>, Map<String, ExcelContentProperty>> CLASS_CONTENT_CACHE
+        = new ConcurrentHashMap<>();
+
+    /**
+     * The cache configuration information for each of the class
+     */
+    private static final ThreadLocal<Map<Class<?>, Map<String, ExcelContentProperty>>> CLASS_CONTENT_THREAD_LOCAL
+        = new ThreadLocal<>();
 
     /**
      * The cache configuration information for each of the class
      */
-    public static final Map<Class<?>, Map<String, ExcelContentProperty>> CLASS_CONTENT_CACHE
+    public static final ConcurrentHashMap<ContentPropertyKey, ExcelContentProperty> CONTENT_CACHE
         = new ConcurrentHashMap<>();
 
     /**
      * The cache configuration information for each of the class
      */
-    public static final Map<ContentPropertyKey, ExcelContentProperty> CONTENT_CACHE = new ConcurrentHashMap<>();
+    private static final ThreadLocal<Map<ContentPropertyKey, ExcelContentProperty>> CONTENT_THREAD_LOCAL
+        = new ThreadLocal<>();
 
     /**
      * Calculate the configuration information for the class
@@ -77,7 +102,7 @@ public class ClassUtils {
      * @return
      */
     public static ExcelContentProperty declaredExcelContentProperty(Map<?, ?> dataMap, Class<?> headClazz,
-        String fieldName) {
+        String fieldName, ConfigurationHolder configurationHolder) {
         Class<?> clazz = null;
         if (dataMap instanceof BeanMap) {
             Object bean = ((BeanMap)dataMap).getBean();
@@ -85,26 +110,49 @@ public class ClassUtils {
                 clazz = bean.getClass();
             }
         }
-        return getExcelContentProperty(clazz, headClazz, fieldName);
+        return getExcelContentProperty(clazz, headClazz, fieldName, configurationHolder);
     }
 
-    private static ExcelContentProperty getExcelContentProperty(Class<?> clazz, Class<?> headClass, String fieldName) {
-        return CONTENT_CACHE.computeIfAbsent(buildKey(clazz, headClass, fieldName), key -> {
-            ExcelContentProperty excelContentProperty = Optional.ofNullable(declaredFieldContentMap(clazz))
-                .map(map -> map.get(fieldName))
-                .orElse(null);
-            ExcelContentProperty headExcelContentProperty = Optional.ofNullable(declaredFieldContentMap(headClass))
-                .map(map -> map.get(fieldName))
-                .orElse(null);
-            ExcelContentProperty combineExcelContentProperty = new ExcelContentProperty();
-
-            combineExcelContentProperty(combineExcelContentProperty, headExcelContentProperty);
-            if (clazz != headClass) {
-                combineExcelContentProperty(combineExcelContentProperty, excelContentProperty);
-            }
-            return combineExcelContentProperty;
-        });
+    private static ExcelContentProperty getExcelContentProperty(Class<?> clazz, Class<?> headClass, String fieldName,
+        ConfigurationHolder configurationHolder) {
+        switch (configurationHolder.globalConfiguration().getFiledCacheLocation()) {
+            case THREAD_LOCAL:
+                Map<ContentPropertyKey, ExcelContentProperty> contentCacheMap = CONTENT_THREAD_LOCAL.get();
+                if (contentCacheMap == null) {
+                    contentCacheMap = MapUtils.newHashMap();
+                    CONTENT_THREAD_LOCAL.set(contentCacheMap);
+                }
+                return contentCacheMap.computeIfAbsent(buildKey(clazz, headClass, fieldName), key -> {
+                    return doGetExcelContentProperty(clazz, headClass, fieldName, configurationHolder);
+                });
+            case MEMORY:
+                return CONTENT_CACHE.computeIfAbsent(buildKey(clazz, headClass, fieldName), key -> {
+                    return doGetExcelContentProperty(clazz, headClass, fieldName, configurationHolder);
+                });
+            case NONE:
+                return doGetExcelContentProperty(clazz, headClass, fieldName, configurationHolder);
+            default:
+                throw new UnsupportedOperationException("unsupported enum");
+        }
+    }
 
+    private static ExcelContentProperty doGetExcelContentProperty(Class<?> clazz, Class<?> headClass,
+        String fieldName, ConfigurationHolder configurationHolder) {
+        ExcelContentProperty excelContentProperty = Optional.ofNullable(
+                declaredFieldContentMap(clazz, configurationHolder))
+            .map(map -> map.get(fieldName))
+            .orElse(null);
+        ExcelContentProperty headExcelContentProperty = Optional.ofNullable(
+                declaredFieldContentMap(headClass, configurationHolder))
+            .map(map -> map.get(fieldName))
+            .orElse(null);
+        ExcelContentProperty combineExcelContentProperty = new ExcelContentProperty();
+
+        combineExcelContentProperty(combineExcelContentProperty, headExcelContentProperty);
+        if (clazz != headClass) {
+            combineExcelContentProperty(combineExcelContentProperty, excelContentProperty);
+        }
+        return combineExcelContentProperty;
     }
 
     public static void combineExcelContentProperty(ExcelContentProperty combineExcelContentProperty,
@@ -136,164 +184,258 @@ public class ClassUtils {
         return new ContentPropertyKey(clazz, headClass, fieldName);
     }
 
-    private static Map<String, ExcelContentProperty> declaredFieldContentMap(Class<?> clazz) {
+    private static Map<String, ExcelContentProperty> declaredFieldContentMap(Class<?> clazz,
+        ConfigurationHolder configurationHolder) {
         if (clazz == null) {
             return null;
         }
-        return CLASS_CONTENT_CACHE.computeIfAbsent(clazz, key -> {
-            List<Field> tempFieldList = new ArrayList<>();
-            Class<?> tempClass = clazz;
-            while (tempClass != null) {
-                Collections.addAll(tempFieldList, tempClass.getDeclaredFields());
-                // Get the parent class and give it to yourself
-                tempClass = tempClass.getSuperclass();
-            }
-
-            ContentStyle parentContentStyle = clazz.getAnnotation(ContentStyle.class);
-            ContentFontStyle parentContentFontStyle = clazz.getAnnotation(ContentFontStyle.class);
-            Map<String, ExcelContentProperty> fieldContentMap = MapUtils.newHashMapWithExpectedSize(
-                tempFieldList.size());
-            for (Field field : tempFieldList) {
-                ExcelContentProperty excelContentProperty = new ExcelContentProperty();
-                excelContentProperty.setField(field);
-
-                ExcelProperty excelProperty = field.getAnnotation(ExcelProperty.class);
-                if (excelProperty != null) {
-                    Class<? extends Converter<?>> convertClazz = excelProperty.converter();
-                    if (convertClazz != AutoConverter.class) {
-                        try {
-                            Converter<?> converter = convertClazz.getDeclaredConstructor().newInstance();
-                            excelContentProperty.setConverter(converter);
-                        } catch (Exception e) {
-                            throw new ExcelCommonException(
-                                "Can not instance custom converter:" + convertClazz.getName());
-                        }
-                    }
+        switch (configurationHolder.globalConfiguration().getFiledCacheLocation()) {
+            case THREAD_LOCAL:
+                Map<Class<?>, Map<String, ExcelContentProperty>> classContentCacheMap
+                    = CLASS_CONTENT_THREAD_LOCAL.get();
+                if (classContentCacheMap == null) {
+                    classContentCacheMap = MapUtils.newHashMap();
+                    CLASS_CONTENT_THREAD_LOCAL.set(classContentCacheMap);
                 }
+                return classContentCacheMap.computeIfAbsent(clazz, key -> {
+                    return doDeclaredFieldContentMap(clazz);
+                });
+            case MEMORY:
+                return CLASS_CONTENT_CACHE.computeIfAbsent(clazz, key -> {
+                    return doDeclaredFieldContentMap(clazz);
+                });
+            case NONE:
+                return doDeclaredFieldContentMap(clazz);
+            default:
+                throw new UnsupportedOperationException("unsupported enum");
+        }
 
-                ContentStyle contentStyle = field.getAnnotation(ContentStyle.class);
-                if (contentStyle == null) {
-                    contentStyle = parentContentStyle;
-                }
-                excelContentProperty.setContentStyleProperty(StyleProperty.build(contentStyle));
+    }
+
+    private static Map<String, ExcelContentProperty> doDeclaredFieldContentMap(Class<?> clazz) {
+        if (clazz == null) {
+            return null;
+        }
+        List<Field> tempFieldList = new ArrayList<>();
+        Class<?> tempClass = clazz;
+        while (tempClass != null) {
+            Collections.addAll(tempFieldList, tempClass.getDeclaredFields());
+            // Get the parent class and give it to yourself
+            tempClass = tempClass.getSuperclass();
+        }
 
-                ContentFontStyle contentFontStyle = field.getAnnotation(ContentFontStyle.class);
-                if (contentFontStyle == null) {
-                    contentFontStyle = parentContentFontStyle;
+        ContentStyle parentContentStyle = clazz.getAnnotation(ContentStyle.class);
+        ContentFontStyle parentContentFontStyle = clazz.getAnnotation(ContentFontStyle.class);
+        Map<String, ExcelContentProperty> fieldContentMap = MapUtils.newHashMapWithExpectedSize(
+            tempFieldList.size());
+        for (Field field : tempFieldList) {
+            ExcelContentProperty excelContentProperty = new ExcelContentProperty();
+            excelContentProperty.setField(field);
+
+            ExcelProperty excelProperty = field.getAnnotation(ExcelProperty.class);
+            if (excelProperty != null) {
+                Class<? extends Converter<?>> convertClazz = excelProperty.converter();
+                if (convertClazz != AutoConverter.class) {
+                    try {
+                        Converter<?> converter = convertClazz.getDeclaredConstructor().newInstance();
+                        excelContentProperty.setConverter(converter);
+                    } catch (Exception e) {
+                        throw new ExcelCommonException(
+                            "Can not instance custom converter:" + convertClazz.getName());
+                    }
                 }
-                excelContentProperty.setContentFontProperty(FontProperty.build(contentFontStyle));
+            }
 
-                excelContentProperty.setDateTimeFormatProperty(
-                    DateTimeFormatProperty.build(field.getAnnotation(DateTimeFormat.class)));
-                excelContentProperty.setNumberFormatProperty(
-                    NumberFormatProperty.build(field.getAnnotation(NumberFormat.class)));
+            ContentStyle contentStyle = field.getAnnotation(ContentStyle.class);
+            if (contentStyle == null) {
+                contentStyle = parentContentStyle;
+            }
+            excelContentProperty.setContentStyleProperty(StyleProperty.build(contentStyle));
 
-                fieldContentMap.put(field.getName(), excelContentProperty);
+            ContentFontStyle contentFontStyle = field.getAnnotation(ContentFontStyle.class);
+            if (contentFontStyle == null) {
+                contentFontStyle = parentContentFontStyle;
             }
-            return fieldContentMap;
-        });
+            excelContentProperty.setContentFontProperty(FontProperty.build(contentFontStyle));
+
+            excelContentProperty.setDateTimeFormatProperty(
+                DateTimeFormatProperty.build(field.getAnnotation(DateTimeFormat.class)));
+            excelContentProperty.setNumberFormatProperty(
+                NumberFormatProperty.build(field.getAnnotation(NumberFormat.class)));
+
+            fieldContentMap.put(field.getName(), excelContentProperty);
+        }
+        return fieldContentMap;
     }
 
     /**
      * Parsing field in the class
      *
-     * @param clazz             Need to parse the class
-     * @param sortedAllFieldMap Complete the map of sorts
-     * @param indexFieldMap     Use the index to sort fields
-     * @param ignoreMap         You want to ignore field map
-     * @param needIgnore        If you want to ignore fields need to ignore
-     * @param holder            holder
+     * @param clazz               Need to parse the class
+     * @param configurationHolder configuration
      */
-    public static void declaredFields(Class<?> clazz, Map<Integer, Field> sortedAllFieldMap,
-        Map<Integer, Field> indexFieldMap, Map<String, Field> ignoreMap, Boolean needIgnore, Holder holder) {
-        FieldCache fieldCache = declaredFields(clazz);
-        if (fieldCache == null) {
-            return;
+    public static FieldCache declaredFields(Class<?> clazz, ConfigurationHolder configurationHolder) {
+        switch (configurationHolder.globalConfiguration().getFiledCacheLocation()) {
+            case THREAD_LOCAL:
+                Map<Class<?>, FieldCache> fieldCacheMap = FIELD_THREAD_LOCAL.get();
+                if (fieldCacheMap == null) {
+                    fieldCacheMap = MapUtils.newHashMap();
+                    FIELD_THREAD_LOCAL.set(fieldCacheMap);
+                }
+                return fieldCacheMap.computeIfAbsent(clazz, key -> {
+                    return doDeclaredFields(clazz, configurationHolder);
+                });
+            case MEMORY:
+                return FIELD_CACHE.computeIfAbsent(clazz, key -> {
+                    return doDeclaredFields(clazz, configurationHolder);
+                });
+            case NONE:
+                return doDeclaredFields(clazz, configurationHolder);
+            default:
+                throw new UnsupportedOperationException("unsupported enum");
+        }
+    }
+
+    private static FieldCache doDeclaredFields(Class<?> clazz, ConfigurationHolder configurationHolder) {
+        List<Field> tempFieldList = new ArrayList<>();
+        Class<?> tempClass = clazz;
+        // When the parent class is null, it indicates that the parent class (Object class) has reached the top
+        // level.
+        while (tempClass != null) {
+            Collections.addAll(tempFieldList, tempClass.getDeclaredFields());
+            // Get the parent class and give it to yourself
+            tempClass = tempClass.getSuperclass();
         }
-        if (ignoreMap != null) {
-            ignoreMap.putAll(fieldCache.getIgnoreMap());
+        // Screening of field
+        Map<Integer, List<FieldWrapper>> orderFieldMap = new TreeMap<>();
+        Map<Integer, FieldWrapper> indexFieldMap = new TreeMap<>();
+        Set<String> ignoreSet = new HashSet<>();
+
+        ExcelIgnoreUnannotated excelIgnoreUnannotated = clazz.getAnnotation(ExcelIgnoreUnannotated.class);
+        for (Field field : tempFieldList) {
+            declaredOneField(field, orderFieldMap, indexFieldMap, ignoreSet, excelIgnoreUnannotated);
         }
-        Map<Integer, Field> tempIndexFieldMap = indexFieldMap;
-        if (tempIndexFieldMap == null) {
-            tempIndexFieldMap = MapUtils.newTreeMap();
+        Map<Integer, FieldWrapper> sortedFieldMap = buildSortedAllFieldMap(orderFieldMap, indexFieldMap);
+        FieldCache fieldCache = new FieldCache(sortedFieldMap, indexFieldMap);
+
+        if (!(configurationHolder instanceof WriteHolder)) {
+            return fieldCache;
         }
-        tempIndexFieldMap.putAll(fieldCache.getIndexFieldMap());
 
-        Map<Integer, Field> originSortedAllFieldMap = fieldCache.getSortedAllFieldMap();
+        WriteHolder writeHolder = (WriteHolder)configurationHolder;
+
+        boolean needIgnore = !CollectionUtils.isEmpty(writeHolder.excludeColumnFieldNames())
+            || !CollectionUtils.isEmpty(writeHolder.excludeColumnIndexes())
+            || !CollectionUtils.isEmpty(writeHolder.includeColumnFieldNames())
+            || !CollectionUtils.isEmpty(writeHolder.includeColumnIndexes());
+
         if (!needIgnore) {
-            sortedAllFieldMap.putAll(originSortedAllFieldMap);
-            return;
+            return fieldCache;
         }
-
+        // ignore filed
+        Map<Integer, FieldWrapper> tempSortedFieldMapp = MapUtils.newHashMap();
         int index = 0;
-        for (Map.Entry<Integer, Field> entry : originSortedAllFieldMap.entrySet()) {
+        for (Map.Entry<Integer, FieldWrapper> entry : sortedFieldMap.entrySet()) {
             Integer key = entry.getKey();
-            Field field = entry.getValue();
+            FieldWrapper field = entry.getValue();
 
             // The current field needs to be ignored
-            if (((WriteHolder)holder).ignore(entry.getValue().getName(), entry.getKey())) {
-                if (ignoreMap != null) {
-                    ignoreMap.put(field.getName(), field);
+            if (writeHolder.ignore(field.getFieldName(), entry.getKey())) {
+                if (ignoreSet != null) {
+                    ignoreSet.add(field.getFieldName());
                 }
-                tempIndexFieldMap.remove(index);
+                indexFieldMap.remove(index);
             } else {
                 // Mandatory sorted fields
-                if (tempIndexFieldMap.containsKey(key)) {
-                    sortedAllFieldMap.put(key, field);
+                if (ignoreSet.contains(key)) {
+                    tempSortedFieldMapp.put(key, field);
                 } else {
                     // Need to reorder automatically
                     // Check whether the current key is already in use
-                    while (sortedAllFieldMap.containsKey(index)) {
+                    while (tempSortedFieldMapp.containsKey(index)) {
                         index++;
                     }
-                    sortedAllFieldMap.put(index++, field);
+                    tempSortedFieldMapp.put(index++, field);
                 }
             }
         }
-    }
+        fieldCache.setSortedFieldMap(tempSortedFieldMapp);
 
-    public static void declaredFields(Class<?> clazz, Map<Integer, Field> sortedAllFieldMap, Boolean needIgnore,
-        WriteHolder writeHolder) {
-        declaredFields(clazz, sortedAllFieldMap, null, null, needIgnore, writeHolder);
+        // resort field
+        resortField(writeHolder, fieldCache);
+        return fieldCache;
     }
 
-    private static FieldCache declaredFields(Class<?> clazz) {
-        if (clazz == null) {
-            return null;
+    /**
+     * it only works when {@link WriteHolder#getIncludeColumnFieldNames()} or
+     * {@link WriteHolder#getIncludeColumnIndexes()} ()} has value
+     * and {@link WriteHolder#getOrderByIncludeColumn()} ()} is true
+     **/
+    private static void resortField(WriteHolder writeHolder, FieldCache fieldCache) {
+        if (!writeHolder.orderByIncludeColumn()) {
+            return;
         }
-        return FIELD_CACHE.computeIfAbsent(clazz, key -> {
-            List<Field> tempFieldList = new ArrayList<>();
-            Class<?> tempClass = clazz;
-            // When the parent class is null, it indicates that the parent class (Object class) has reached the top
-            // level.
-            while (tempClass != null) {
-                Collections.addAll(tempFieldList, tempClass.getDeclaredFields());
-                // Get the parent class and give it to yourself
-                tempClass = tempClass.getSuperclass();
+        Map<Integer, FieldWrapper> indexFieldMap = fieldCache.getIndexFieldMap();
+
+        Collection<String> includeColumnFieldNames = writeHolder.includeColumnFieldNames();
+        if (!CollectionUtils.isEmpty(includeColumnFieldNames)) {
+            // Field sorted map
+            Map<String, Integer> filedIndexMap = MapUtils.newHashMap();
+            int fieldIndex = 0;
+            for (String includeColumnFieldName : includeColumnFieldNames) {
+                filedIndexMap.put(includeColumnFieldName, fieldIndex++);
             }
-            // Screening of field
-            Map<Integer, List<Field>> orderFieldMap = new TreeMap<Integer, List<Field>>();
-            Map<Integer, Field> indexFieldMap = new TreeMap<Integer, Field>();
-            Map<String, Field> ignoreMap = new HashMap<String, Field>(16);
-
-            ExcelIgnoreUnannotated excelIgnoreUnannotated = clazz.getAnnotation(ExcelIgnoreUnannotated.class);
-            for (Field field : tempFieldList) {
-                declaredOneField(field, orderFieldMap, indexFieldMap, ignoreMap, excelIgnoreUnannotated);
+
+            // rebuild sortedFieldMap
+            Map<Integer, FieldWrapper> tempSortedFieldMap = MapUtils.newHashMap();
+            fieldCache.getSortedFieldMap().forEach((index, field) -> {
+                Integer tempFieldIndex = filedIndexMap.get(field.getFieldName());
+                if (tempFieldIndex != null) {
+                    tempSortedFieldMap.put(tempFieldIndex, field);
+
+                    //  The user has redefined the ordering and the ordering of annotations needs to be invalidated
+                    if (!tempFieldIndex.equals(index)) {
+                        indexFieldMap.remove(index);
+                    }
+                }
+            });
+            fieldCache.setSortedFieldMap(tempSortedFieldMap);
+            return;
+        }
+
+        Collection<Integer> includeColumnIndexes = writeHolder.includeColumnIndexes();
+        if (!CollectionUtils.isEmpty(includeColumnIndexes)) {
+            // Index sorted map
+            Map<Integer, Integer> filedIndexMap = MapUtils.newHashMap();
+            int fieldIndex = 0;
+            for (Integer includeColumnIndexe : includeColumnIndexes) {
+                filedIndexMap.put(includeColumnIndexe, fieldIndex++);
             }
-            return new FieldCache(buildSortedAllFieldMap(orderFieldMap, indexFieldMap), indexFieldMap, ignoreMap);
-        });
+
+            // rebuild sortedFieldMap
+            Map<Integer, FieldWrapper> tempSortedFieldMap = MapUtils.newHashMap();
+            fieldCache.getSortedFieldMap().forEach((index, field) -> {
+                Integer tempFieldIndex = filedIndexMap.get(index);
+
+                //  The user has redefined the ordering and the ordering of annotations needs to be invalidated
+                if (tempFieldIndex != null) {
+                    tempSortedFieldMap.put(tempFieldIndex, field);
+                }
+            });
+            fieldCache.setSortedFieldMap(tempSortedFieldMap);
+        }
     }
 
-    private static Map<Integer, Field> buildSortedAllFieldMap(Map<Integer, List<Field>> orderFieldMap,
-        Map<Integer, Field> indexFieldMap) {
+    private static Map<Integer, FieldWrapper> buildSortedAllFieldMap(Map<Integer, List<FieldWrapper>> orderFieldMap,
+        Map<Integer, FieldWrapper> indexFieldMap) {
 
-        Map<Integer, Field> sortedAllFieldMap = new HashMap<Integer, Field>(
+        Map<Integer, FieldWrapper> sortedAllFieldMap = new HashMap<>(
             (orderFieldMap.size() + indexFieldMap.size()) * 4 / 3 + 1);
 
-        Map<Integer, Field> tempIndexFieldMap = new HashMap<Integer, Field>(indexFieldMap);
+        Map<Integer, FieldWrapper> tempIndexFieldMap = new HashMap<>(indexFieldMap);
         int index = 0;
-        for (List<Field> fieldList : orderFieldMap.values()) {
-            for (Field field : fieldList) {
+        for (List<FieldWrapper> fieldList : orderFieldMap.values()) {
+            for (FieldWrapper field : fieldList) {
                 while (tempIndexFieldMap.containsKey(index)) {
                     sortedAllFieldMap.put(index, tempIndexFieldMap.get(index));
                     tempIndexFieldMap.remove(index);
@@ -307,34 +449,45 @@ public class ClassUtils {
         return sortedAllFieldMap;
     }
 
-    private static void declaredOneField(Field field, Map<Integer, List<Field>> orderFieldMap,
-        Map<Integer, Field> indexFieldMap, Map<String, Field> ignoreMap,
+    private static void declaredOneField(Field field, Map<Integer, List<FieldWrapper>> orderFieldMap,
+        Map<Integer, FieldWrapper> indexFieldMap, Set<String> ignoreSet,
         ExcelIgnoreUnannotated excelIgnoreUnannotated) {
+        String fieldName = FieldUtils.resolveCglibFieldName(field);
+        FieldWrapper fieldWrapper = new FieldWrapper();
+        fieldWrapper.setField(field);
+        fieldWrapper.setFieldName(fieldName);
 
         ExcelIgnore excelIgnore = field.getAnnotation(ExcelIgnore.class);
+
         if (excelIgnore != null) {
-            ignoreMap.put(field.getName(), field);
+            ignoreSet.add(fieldName);
             return;
         }
         ExcelProperty excelProperty = field.getAnnotation(ExcelProperty.class);
         boolean noExcelProperty = excelProperty == null && excelIgnoreUnannotated != null;
         if (noExcelProperty) {
-            ignoreMap.put(field.getName(), field);
+            ignoreSet.add(fieldName);
             return;
         }
         boolean isStaticFinalOrTransient =
             (Modifier.isStatic(field.getModifiers()) && Modifier.isFinal(field.getModifiers()))
                 || Modifier.isTransient(field.getModifiers());
         if (excelProperty == null && isStaticFinalOrTransient) {
-            ignoreMap.put(field.getName(), field);
+            ignoreSet.add(fieldName);
             return;
         }
+        // set heads
+        if (excelProperty != null) {
+            fieldWrapper.setHeads(excelProperty.value());
+        }
+
         if (excelProperty != null && excelProperty.index() >= 0) {
             if (indexFieldMap.containsKey(excelProperty.index())) {
-                throw new ExcelCommonException("The index of '" + indexFieldMap.get(excelProperty.index()).getName()
-                    + "' and '" + field.getName() + "' must be inconsistent");
+                throw new ExcelCommonException(
+                    "The index of '" + indexFieldMap.get(excelProperty.index()).getFieldName()
+                        + "' and '" + field.getName() + "' must be inconsistent");
             }
-            indexFieldMap.put(excelProperty.index(), field);
+            indexFieldMap.put(excelProperty.index(), fieldWrapper);
             return;
         }
 
@@ -342,34 +495,8 @@ public class ClassUtils {
         if (excelProperty != null) {
             order = excelProperty.order();
         }
-        List<Field> orderFieldList = orderFieldMap.computeIfAbsent(order, key -> ListUtils.newArrayList());
-        orderFieldList.add(field);
-    }
-
-    private static class FieldCache {
-
-        private final Map<Integer, Field> sortedAllFieldMap;
-        private final Map<Integer, Field> indexFieldMap;
-        private final Map<String, Field> ignoreMap;
-
-        public FieldCache(Map<Integer, Field> sortedAllFieldMap, Map<Integer, Field> indexFieldMap,
-            Map<String, Field> ignoreMap) {
-            this.sortedAllFieldMap = sortedAllFieldMap;
-            this.indexFieldMap = indexFieldMap;
-            this.ignoreMap = ignoreMap;
-        }
-
-        public Map<Integer, Field> getSortedAllFieldMap() {
-            return sortedAllFieldMap;
-        }
-
-        public Map<Integer, Field> getIndexFieldMap() {
-            return indexFieldMap;
-        }
-
-        public Map<String, Field> getIgnoreMap() {
-            return ignoreMap;
-        }
+        List<FieldWrapper> orderFieldList = orderFieldMap.computeIfAbsent(order, key -> ListUtils.newArrayList());
+        orderFieldList.add(fieldWrapper);
     }
 
     /**
@@ -425,4 +552,10 @@ public class ClassUtils {
         private Class<?> headClass;
         private String fieldName;
     }
+
+    public static void removeThreadLocalCache() {
+        FIELD_THREAD_LOCAL.remove();
+        CLASS_CONTENT_THREAD_LOCAL.remove();
+        CONTENT_THREAD_LOCAL.remove();
+    }
 }

easyexcel-core/src/main/java/com/alibaba/excel/util/PoiUtils.java

@@ -1,7 +1,5 @@
 package com.alibaba.excel.util;
 
-import java.lang.reflect.Field;
-
 import com.alibaba.excel.exception.ExcelRuntimeException;
 
 import org.apache.poi.hssf.record.RowRecord;
@@ -11,6 +9,8 @@ import org.apache.poi.util.BitField;
 import org.apache.poi.util.BitFieldFactory;
 import org.apache.poi.xssf.usermodel.XSSFRow;
 
+import java.lang.reflect.Field;
+
 /**
  * utils
  *
@@ -23,7 +23,7 @@ public class PoiUtils {
      */
     public static final BitField CUSTOM_HEIGHT = BitFieldFactory.getInstance(0x640);
 
-    private static volatile Field ROW_RECORD_FIELD;
+    private static final Field ROW_RECORD_FIELD = FieldUtils.getField(HSSFRow.class, "row", true);
 
     /**
      * Whether to customize the height
@@ -39,13 +39,6 @@ public class PoiUtils {
         if (row instanceof HSSFRow) {
             HSSFRow hssfRow = (HSSFRow)row;
             try {
-                if (ROW_RECORD_FIELD == null) {
-                    synchronized (PoiUtils.class) {
-                        if (ROW_RECORD_FIELD == null) {
-                            initRowRecordField();
-                        }
-                    }
-                }
                 RowRecord record = (RowRecord)ROW_RECORD_FIELD.get(hssfRow);
                 return CUSTOM_HEIGHT.getValue(record.getOptionFlags()) == 1;
             } catch (IllegalAccessException ignore) {
@@ -53,13 +46,4 @@ public class PoiUtils {
         }
         return false;
     }
-
-    private static void initRowRecordField() {
-        try {
-            ROW_RECORD_FIELD = HSSFRow.class.getDeclaredField("row");
-            ROW_RECORD_FIELD.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            throw new ExcelRuntimeException(e);
-        }
-    }
 }

easyexcel-core/src/main/java/com/alibaba/excel/util/WorkBookUtil.java

@@ -70,7 +70,9 @@ public class WorkBookUtil {
                     new OutputStreamWriter(writeWorkbookHolder.getOutputStream(), writeWorkbookHolder.getCharset())),
                     writeWorkbookHolder.getGlobalConfiguration().getLocale(),
                     writeWorkbookHolder.getGlobalConfiguration().getUse1904windowing(),
-                    writeWorkbookHolder.getGlobalConfiguration().getUseScientificFormat());
+                    writeWorkbookHolder.getGlobalConfiguration().getUseScientificFormat(),
+                    writeWorkbookHolder.getCharset(),
+                    writeWorkbookHolder.getWithBom());
                 writeWorkbookHolder.setCachedWorkbook(csvWorkbook);
                 writeWorkbookHolder.setWorkbook(csvWorkbook);
                 return;

easyexcel-core/src/main/java/com/alibaba/excel/write/builder/AbstractExcelWriterParameterBuilder.java

@@ -120,4 +120,16 @@ public abstract class AbstractExcelWriterParameterBuilder<T extends AbstractExce
         parameter().setIncludeColumnFieldNames(includeColumnFieldNames);
         return self();
     }
+
+    /**
+     * Data will be order by  {@link #includeColumnFieldNames} or  {@link #includeColumnIndexes}.
+     *
+     * default is false.
+     *
+     * @since 3.3.0
+     **/
+    public T orderByIncludeColumn(Boolean orderByIncludeColumn) {
+        parameter().setOrderByIncludeColumn(orderByIncludeColumn);
+        return self();
+    }
 }

easyexcel-core/src/main/java/com/alibaba/excel/write/builder/ExcelWriterBuilder.java

@@ -94,6 +94,15 @@ public class ExcelWriterBuilder extends AbstractExcelWriterParameterBuilder<Exce
         return this;
     }
 
+    /**
+     * Set the encoding prefix in the csv file, otherwise the office may open garbled characters.
+     * Default true.
+     */
+    public ExcelWriterBuilder withBom(Boolean withBom) {
+        writeWorkbook.setWithBom(withBom);
+        return this;
+    }
+
     /**
      * Template file.
      * This file is read into memory, excessive cases can lead to OOM.

easyexcel-core/src/main/java/com/alibaba/excel/write/executor/ExcelWriteAddExecutor.java

@@ -10,6 +10,8 @@ import java.util.TreeMap;
 
 import com.alibaba.excel.context.WriteContext;
 import com.alibaba.excel.enums.HeadKindEnum;
+import com.alibaba.excel.metadata.FieldCache;
+import com.alibaba.excel.metadata.FieldWrapper;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.util.BeanMapUtils;
@@ -50,18 +52,15 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
         if (writeSheetHolder.isNew() && !writeSheetHolder.getExcelWriteHeadProperty().hasHead()) {
             newRowIndex += writeContext.currentWriteHolder().relativeHeadRowIndex();
         }
-        // BeanMap is out of order, so use sortedAllFieldMap
-        Map<Integer, Field> sortedAllFieldMap = new TreeMap<>();
         int relativeRowIndex = 0;
         for (Object oneRowData : data) {
             int lastRowIndex = relativeRowIndex + newRowIndex;
-            addOneRowOfDataToExcel(oneRowData, lastRowIndex, relativeRowIndex, sortedAllFieldMap);
+            addOneRowOfDataToExcel(oneRowData, lastRowIndex, relativeRowIndex);
             relativeRowIndex++;
         }
     }
 
-    private void addOneRowOfDataToExcel(Object oneRowData, int rowIndex, int relativeRowIndex,
-        Map<Integer, Field> sortedAllFieldMap) {
+    private void addOneRowOfDataToExcel(Object oneRowData, int rowIndex, int relativeRowIndex) {
         if (oneRowData == null) {
             return;
         }
@@ -79,7 +78,7 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
         } else if (oneRowData instanceof Map) {
             addBasicTypeToExcel(new MapRowData((Map<Integer, ?>)oneRowData), row, rowIndex, relativeRowIndex);
         } else {
-            addJavaObjectToExcel(oneRowData, row, rowIndex, relativeRowIndex, sortedAllFieldMap);
+            addJavaObjectToExcel(oneRowData, row, rowIndex, relativeRowIndex);
         }
 
         WriteHandlerUtils.afterRowDispose(rowWriteHandlerContext);
@@ -119,7 +118,7 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
         int dataIndex, int columnIndex) {
         ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(null,
             writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(),
-            head == null ? null : head.getFieldName());
+            head == null ? null : head.getFieldName(), writeContext.currentWriteHolder());
 
         CellWriteHandlerContext cellWriteHandlerContext = WriteHandlerUtils.createCellWriteHandlerContext(writeContext,
             row, rowIndex, head, columnIndex, relativeRowIndex, Boolean.FALSE, excelContentProperty);
@@ -138,8 +137,7 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
         WriteHandlerUtils.afterCellDispose(cellWriteHandlerContext);
     }
 
-    private void addJavaObjectToExcel(Object oneRowData, Row row, int rowIndex, int relativeRowIndex,
-        Map<Integer, Field> sortedAllFieldMap) {
+    private void addJavaObjectToExcel(Object oneRowData, Row row, int rowIndex, int relativeRowIndex) {
         WriteHolder currentWriteHolder = writeContext.currentWriteHolder();
         BeanMap beanMap = BeanMapUtils.create(oneRowData);
         // Bean the contains of the Map Key method with poor performance,So to create a keySet here
@@ -158,7 +156,7 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
                 }
 
                 ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(beanMap,
-                    currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), name);
+                    currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), name, currentWriteHolder);
                 CellWriteHandlerContext cellWriteHandlerContext = WriteHandlerUtils.createCellWriteHandlerContext(
                     writeContext, row, rowIndex, head, columnIndex, relativeRowIndex, Boolean.FALSE,
                     excelContentProperty);
@@ -185,19 +183,17 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
         }
         maxCellIndex++;
 
-        Map<String, Field> ignoreMap = writeContext.currentWriteHolder().excelWriteHeadProperty().getIgnoreMap();
-        initSortedAllFieldMapFieldList(oneRowData.getClass(), sortedAllFieldMap);
-        for (Map.Entry<Integer, Field> entry : sortedAllFieldMap.entrySet()) {
-            Field field = entry.getValue();
-            String fieldName = FieldUtils.resolveCglibFieldName(field);
-            boolean uselessData = !beanKeySet.contains(fieldName) || beanMapHandledSet.contains(fieldName)
-                || ignoreMap.containsKey(fieldName);
+        FieldCache fieldCache = ClassUtils.declaredFields(oneRowData.getClass(), writeContext.currentWriteHolder());
+        for (Map.Entry<Integer, FieldWrapper> entry : fieldCache.getSortedFieldMap().entrySet()) {
+            FieldWrapper field = entry.getValue();
+            String fieldName = field.getFieldName();
+            boolean uselessData = !beanKeySet.contains(fieldName) || beanMapHandledSet.contains(fieldName);
             if (uselessData) {
                 continue;
             }
             Object value = beanMap.get(fieldName);
             ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(beanMap,
-                currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), fieldName);
+                currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), fieldName, currentWriteHolder);
             CellWriteHandlerContext cellWriteHandlerContext = WriteHandlerUtils.createCellWriteHandlerContext(
                 writeContext, row, rowIndex, null, maxCellIndex, relativeRowIndex, Boolean.FALSE, excelContentProperty);
             WriteHandlerUtils.beforeCellCreate(cellWriteHandlerContext);
@@ -218,18 +214,4 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
         }
     }
 
-    private void initSortedAllFieldMapFieldList(Class<?> clazz, Map<Integer, Field> sortedAllFieldMap) {
-        if (!sortedAllFieldMap.isEmpty()) {
-            return;
-        }
-
-        WriteSheetHolder writeSheetHolder = writeContext.writeSheetHolder();
-        boolean needIgnore =
-            !CollectionUtils.isEmpty(writeSheetHolder.getExcludeColumnFieldNames()) || !CollectionUtils
-                .isEmpty(writeSheetHolder.getExcludeColumnIndexes()) || !CollectionUtils
-                .isEmpty(writeSheetHolder.getIncludeColumnFieldNames()) || !CollectionUtils
-                .isEmpty(writeSheetHolder.getIncludeColumnIndexes());
-        ClassUtils.declaredFields(clazz, sortedAllFieldMap, needIgnore, writeSheetHolder);
-    }
-
 }

easyexcel-core/src/main/java/com/alibaba/excel/write/executor/ExcelWriteFillExecutor.java

@@ -37,7 +37,9 @@ import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
 import org.apache.commons.collections4.CollectionUtils;
+
 import com.alibaba.excel.util.PoiUtils;
+
 import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.ss.usermodel.CellStyle;
 import org.apache.poi.ss.usermodel.CellType;
@@ -215,7 +217,8 @@ public class ExcelWriteFillExecutor extends AbstractExcelWriteExecutor {
                 }
                 Object value = dataMap.get(variable);
                 ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(dataMap,
-                    writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(), variable);
+                    writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(), variable,
+                    writeContext.currentWriteHolder());
                 cellWriteHandlerContext.setExcelContentProperty(excelContentProperty);
 
                 createCell(analysisCell, fillConfig, cellWriteHandlerContext, rowWriteHandlerContext);
@@ -249,7 +252,8 @@ public class ExcelWriteFillExecutor extends AbstractExcelWriteExecutor {
                     }
                     Object value = dataMap.get(variable);
                     ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(dataMap,
-                        writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(), variable);
+                        writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(), variable,
+                        writeContext.currentWriteHolder());
                     cellWriteHandlerContext.setOriginalValue(value);
                     cellWriteHandlerContext.setOriginalFieldClass(FieldUtils.getFieldClass(dataMap, variable, value));
                     cellWriteHandlerContext.setExcelContentProperty(excelContentProperty);

easyexcel-core/src/main/java/com/alibaba/excel/write/metadata/WriteBasicParameter.java

@@ -56,4 +56,11 @@ public class WriteBasicParameter extends BasicParameter {
      * Only output the custom columns.
      */
     private Collection<String> includeColumnFieldNames;
+
+    /**
+     * Data will be order by  {@link #includeColumnFieldNames} or  {@link #includeColumnIndexes}.
+     *
+     * default is false.
+     */
+    private Boolean orderByIncludeColumn;
 }

easyexcel-core/src/main/java/com/alibaba/excel/write/metadata/WriteWorkbook.java

@@ -41,6 +41,13 @@ public class WriteWorkbook extends WriteBasicParameter {
      * Only work on the CSV file
      */
     private Charset charset;
+
+    /**
+     * Set the encoding prefix in the csv file, otherwise the office may open garbled characters.
+     * Default true.
+     */
+    private Boolean withBom;
+
     /**
      * Template input stream
      * <p>

easyexcel-core/src/main/java/com/alibaba/excel/write/metadata/holder/AbstractWriteHolder.java

@@ -95,6 +95,13 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
      */
     private Collection<String> includeColumnFieldNames;
 
+    /**
+     * Data will be order by  {@link #includeColumnFieldNames} or  {@link #includeColumnIndexes}.
+     *
+     * default is false.
+     */
+    private Boolean orderByIncludeColumn;
+
     /**
      * Write handler
      */
@@ -194,6 +201,17 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
         } else {
             this.includeColumnFieldNames = writeBasicParameter.getIncludeColumnFieldNames();
         }
+
+        if (writeBasicParameter.getOrderByIncludeColumn() == null) {
+            if (parentAbstractWriteHolder == null) {
+                this.orderByIncludeColumn = Boolean.FALSE;
+            } else {
+                this.orderByIncludeColumn = parentAbstractWriteHolder.getOrderByIncludeColumn();
+            }
+        } else {
+            this.orderByIncludeColumn = writeBasicParameter.getOrderByIncludeColumn();
+        }
+
         if (writeBasicParameter.getIncludeColumnIndexes() == null && parentAbstractWriteHolder != null) {
             this.includeColumnIndexes = parentAbstractWriteHolder.getIncludeColumnIndexes();
         } else {
@@ -480,4 +498,28 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
         return getAutomaticMergeHead();
     }
 
+    @Override
+    public boolean orderByIncludeColumn() {
+        return getOrderByIncludeColumn();
+    }
+
+    @Override
+    public Collection<Integer> includeColumnIndexes() {
+        return getIncludeColumnIndexes();
+    }
+
+    @Override
+    public Collection<String> includeColumnFieldNames() {
+        return getIncludeColumnFieldNames();
+    }
+
+    @Override
+    public Collection<Integer> excludeColumnIndexes() {
+        return getExcludeColumnIndexes();
+    }
+
+    @Override
+    public Collection<String> excludeColumnFieldNames() {
+        return getExcludeColumnFieldNames();
+    }
 }

easyexcel-core/src/main/java/com/alibaba/excel/write/metadata/holder/WriteHolder.java

@@ -1,10 +1,11 @@
 package com.alibaba.excel.write.metadata.holder;
 
+import java.util.Collection;
+
 import com.alibaba.excel.metadata.ConfigurationHolder;
 import com.alibaba.excel.write.property.ExcelWriteHeadProperty;
 
 /**
- *
  * Get the corresponding Holder
  *
  * @author Jiaju Zhuang
@@ -46,4 +47,42 @@ public interface WriteHolder extends ConfigurationHolder {
      * @return
      */
     int relativeHeadRowIndex();
+
+    /**
+     * Data will be order by  {@link #includeColumnFieldNames} or  {@link #includeColumnIndexes}.
+     *
+     * default is false.
+     *
+     * @return
+     */
+
+    boolean orderByIncludeColumn();
+
+    /**
+     * Only output the custom columns.
+     *
+     * @return
+     */
+    Collection<Integer> includeColumnIndexes();
+
+    /**
+     * Only output the custom columns.
+     *
+     * @return
+     */
+    Collection<String> includeColumnFieldNames();
+
+    /**
+     * Ignore the custom columns.
+     *
+     * @return
+     */
+    Collection<Integer> excludeColumnIndexes();
+
+    /**
+     * Ignore the custom columns.
+     *
+     * @return
+     */
+    Collection<String> excludeColumnFieldNames();
 }

easyexcel-core/src/main/java/com/alibaba/excel/write/metadata/holder/WriteWorkbookHolder.java

@@ -11,6 +11,7 @@ import java.nio.charset.Charset;
 import java.util.HashMap;
 import java.util.Map;
 
+import com.alibaba.excel.enums.CacheLocationEnum;
 import com.alibaba.excel.enums.HolderEnum;
 import com.alibaba.excel.exception.ExcelGenerateException;
 import com.alibaba.excel.metadata.data.DataFormatData;
@@ -84,6 +85,13 @@ public class WriteWorkbookHolder extends AbstractWriteHolder {
      * Only work on the CSV file
      */
     private Charset charset;
+
+    /**
+     * Set the encoding prefix in the csv file, otherwise the office may open garbled characters.
+     * Default true.
+     */
+    private Boolean withBom;
+
     /**
      * Template input stream
      * <p>
@@ -176,6 +184,12 @@ public class WriteWorkbookHolder extends AbstractWriteHolder {
             this.charset = writeWorkbook.getCharset();
         }
 
+        if (writeWorkbook.getWithBom() == null) {
+            this.withBom = Boolean.TRUE;
+        } else {
+            this.withBom = writeWorkbook.getWithBom();
+        }
+
         if (writeWorkbook.getAutoCloseStream() == null) {
             this.autoCloseStream = Boolean.TRUE;
         } else {

easyexcel-core/src/main/java/com/alibaba/excel/write/property/ExcelWriteHeadProperty.java

@@ -16,6 +16,7 @@ import com.alibaba.excel.annotation.write.style.HeadStyle;
 import com.alibaba.excel.annotation.write.style.OnceAbsoluteMerge;
 import com.alibaba.excel.enums.HeadKindEnum;
 import com.alibaba.excel.metadata.CellRange;
+import com.alibaba.excel.metadata.ConfigurationHolder;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.Holder;
 import com.alibaba.excel.metadata.property.ColumnWidthProperty;
@@ -44,8 +45,8 @@ public class ExcelWriteHeadProperty extends ExcelHeadProperty {
     private RowHeightProperty contentRowHeightProperty;
     private OnceAbsoluteMergeProperty onceAbsoluteMergeProperty;
 
-    public ExcelWriteHeadProperty(Holder holder, Class<?> headClazz, List<List<String>> head) {
-        super(holder, headClazz, head);
+    public ExcelWriteHeadProperty(ConfigurationHolder configurationHolder, Class<?> headClazz, List<List<String>> head) {
+        super(configurationHolder, headClazz, head);
         if (getHeadKind() != HeadKindEnum.CLASS) {
             return;
         }

easyexcel-support/pom.xml

@@ -21,6 +21,7 @@
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-core</artifactId>
+            <version>5.3.27</version>
             <exclusions>
                 <exclusion>
                     <groupId>org.springframework</groupId>

easyexcel-test/pom.xml

@@ -24,27 +24,38 @@
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>easyexcel-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>ch.qos.logback</groupId>
-            <artifactId>logback-classic</artifactId>
-            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>com.alibaba.fastjson2</groupId>
             <artifactId>fastjson2</artifactId>
-            <scope>test</scope>
+            <version>2.0.29</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
-            <scope>test</scope>
+            <version>2.7.11</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <version>2.7.11</version>
+        </dependency>
+
+        <!-- logback -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>jcl-over-slf4j</artifactId>
+            <version>1.7.36</version>
         </dependency>
         <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <scope>test</scope>
+            <groupId>org.slf4j</groupId>
+            <artifactId>log4j-over-slf4j</artifactId>
+            <version>1.7.36</version>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>1.4.7</version>
         </dependency>
     </dependencies>
 
@@ -54,11 +65,9 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <configuration>
-                    <excludes>
-                        <exclude>/com/alibaba/easyexcel/test/demo/**/*.java</exclude>
-                        <exclude>/com/alibaba/easyexcel/test/temp/**/*.java</exclude>
-                        <exclude>/com/alibaba/easyexcel/test/util/**/*.java</exclude>
-                    </excludes>
+                    <includes>
+                        <include>/com/alibaba/easyexcel/test/core/**/*.java</include>
+                    </includes>
                     <testFailureIgnore>true</testFailureIgnore>
                 </configuration>
             </plugin>

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/annotation/AnnotationDataListener.java

@@ -4,16 +4,16 @@ import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.excel.exception.ExcelCommonException;
 import com.alibaba.excel.util.DateUtils;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -28,14 +28,14 @@ public class AnnotationDataListener extends AnalysisEventListener<AnnotationData
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         AnnotationData data = list.get(0);
         try {
-            Assert.assertEquals(data.getDate(), DateUtils.parseDate("2020-01-01 01:01:01"));
+            Assertions.assertEquals(data.getDate(), DateUtils.parseDate("2020-01-01 01:01:01"));
         } catch (ParseException e) {
             throw new ExcelCommonException("Test Exception", e);
         }
-        Assert.assertEquals(data.getNumber(), 99.99, 0.00);
+        Assertions.assertEquals(data.getNumber(), 99.99, 0.00);
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/annotation/AnnotationDataTest.java

@@ -14,16 +14,16 @@ import org.apache.poi.ss.usermodel.Row;
 import org.apache.poi.ss.usermodel.Sheet;
 import org.apache.poi.ss.usermodel.Workbook;
 import org.apache.poi.ss.usermodel.WorkbookFactory;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class AnnotationDataTest {
 
     private static File file07;
@@ -32,7 +32,7 @@ public class AnnotationDataTest {
     private static File fileStyle07;
     private static File fileStyle03;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("annotation07.xlsx");
         file03 = TestFileUtil.createNewFile("annotation03.xls");
@@ -74,24 +74,24 @@ public class AnnotationDataTest {
 
         Row row0 = sheet.getRow(0);
         Cell cell00 = row0.getCell(0);
-        Assert.assertArrayEquals(new byte[] {-1, 0, -1}, StyleTestUtils.getFillForegroundColor(cell00));
-        Assert.assertArrayEquals(new byte[] {-1, -52, 0}, StyleTestUtils.getFontColor(cell00, workbook));
-        Assert.assertEquals(40, StyleTestUtils.getFontHeightInPoints(cell00, workbook));
+        Assertions.assertArrayEquals(new byte[] {-1, 0, -1}, StyleTestUtils.getFillForegroundColor(cell00));
+        Assertions.assertArrayEquals(new byte[] {-1, -52, 0}, StyleTestUtils.getFontColor(cell00, workbook));
+        Assertions.assertEquals(40, StyleTestUtils.getFontHeightInPoints(cell00, workbook));
 
         Cell cell01 = row0.getCell(1);
-        Assert.assertArrayEquals(new byte[] {-1, 0, 0}, StyleTestUtils.getFillForegroundColor(cell01));
-        Assert.assertArrayEquals(new byte[] {0, -1, -1}, StyleTestUtils.getFontColor(cell01, workbook));
-        Assert.assertEquals(20, StyleTestUtils.getFontHeightInPoints(cell01, workbook));
+        Assertions.assertArrayEquals(new byte[] {-1, 0, 0}, StyleTestUtils.getFillForegroundColor(cell01));
+        Assertions.assertArrayEquals(new byte[] {0, -1, -1}, StyleTestUtils.getFontColor(cell01, workbook));
+        Assertions.assertEquals(20, StyleTestUtils.getFontHeightInPoints(cell01, workbook));
 
         Row row1 = sheet.getRow(1);
         Cell cell10 = row1.getCell(0);
-        Assert.assertArrayEquals(new byte[] {0, -52, -1}, StyleTestUtils.getFillForegroundColor(cell10));
-        Assert.assertArrayEquals(new byte[] {0, 0, -1}, StyleTestUtils.getFontColor(cell10, workbook));
-        Assert.assertEquals(50, StyleTestUtils.getFontHeightInPoints(cell10, workbook));
+        Assertions.assertArrayEquals(new byte[] {0, -52, -1}, StyleTestUtils.getFillForegroundColor(cell10));
+        Assertions.assertArrayEquals(new byte[] {0, 0, -1}, StyleTestUtils.getFontColor(cell10, workbook));
+        Assertions.assertEquals(50, StyleTestUtils.getFontHeightInPoints(cell10, workbook));
         Cell cell11 = row1.getCell(1);
-        Assert.assertArrayEquals(new byte[] {0, -128, 0}, StyleTestUtils.getFillForegroundColor(cell11));
-        Assert.assertArrayEquals(new byte[] {-64, -64, -64}, StyleTestUtils.getFontColor(cell11, workbook));
-        Assert.assertEquals(30, StyleTestUtils.getFontHeightInPoints(cell11, workbook));
+        Assertions.assertArrayEquals(new byte[] {0, -128, 0}, StyleTestUtils.getFillForegroundColor(cell11));
+        Assertions.assertArrayEquals(new byte[] {-64, -64, -64}, StyleTestUtils.getFontColor(cell11, workbook));
+        Assertions.assertEquals(30, StyleTestUtils.getFontHeightInPoints(cell11, workbook));
     }
 
     private void readAndWrite(File file) throws Exception {
@@ -103,13 +103,13 @@ public class AnnotationDataTest {
 
         Workbook workbook = WorkbookFactory.create(file);
         Sheet sheet = workbook.getSheetAt(0);
-        Assert.assertEquals(50 * 256, sheet.getColumnWidth(0), 0);
+        Assertions.assertEquals(50 * 256, sheet.getColumnWidth(0), 0);
 
         Row row0 = sheet.getRow(0);
-        Assert.assertEquals(1000, row0.getHeight(), 0);
+        Assertions.assertEquals(1000, row0.getHeight(), 0);
 
         Row row1 = sheet.getRow(1);
-        Assert.assertEquals(2000, row1.getHeight(), 0);
+        Assertions.assertEquals(2000, row1.getHeight(), 0);
     }
 
     private List<AnnotationStyleData> dataStyle() throws Exception {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/annotation/AnnotationIndexAndNameDataListener.java

@@ -3,14 +3,14 @@ package com.alibaba.easyexcel.test.core.annotation;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -25,12 +25,12 @@ public class AnnotationIndexAndNameDataListener extends AnalysisEventListener<An
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         AnnotationIndexAndNameData data = list.get(0);
-        Assert.assertEquals(data.getIndex0(), "第0个");
-        Assert.assertEquals(data.getIndex1(), "第1个");
-        Assert.assertEquals(data.getIndex2(), "第2个");
-        Assert.assertEquals(data.getIndex4(), "第4个");
+        Assertions.assertEquals(data.getIndex0(), "第0个");
+        Assertions.assertEquals(data.getIndex1(), "第1个");
+        Assertions.assertEquals(data.getIndex2(), "第2个");
+        Assertions.assertEquals(data.getIndex4(), "第4个");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/annotation/AnnotationIndexAndNameDataTest.java

@@ -7,24 +7,24 @@ import java.util.List;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * Annotation data test
  *
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class AnnotationIndexAndNameDataTest {
 
     private static File file07;
     private static File file03;
     private static File fileCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("annotationIndexAndName07.xlsx");
         file03 = TestFileUtil.createNewFile("annotationIndexAndName03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/bom/BomData.java

@@ -0,0 +1,17 @@
+package com.alibaba.easyexcel.test.core.bom;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@EqualsAndHashCode
+public class BomData {
+    @ExcelProperty("姓名")
+    private String name;
+    @ExcelProperty("年纪")
+    private Long age;
+}

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/bom/BomDataTest.java

@@ -0,0 +1,126 @@
+package com.alibaba.easyexcel.test.core.bom;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.nio.charset.Charset;
+import java.util.List;
+import java.util.Map;
+
+import com.alibaba.easyexcel.test.util.TestFileUtil;
+import com.alibaba.excel.EasyExcel;
+import com.alibaba.excel.context.AnalysisContext;
+import com.alibaba.excel.metadata.data.ReadCellData;
+import com.alibaba.excel.read.listener.ReadListener;
+import com.alibaba.excel.support.ExcelTypeEnum;
+import com.alibaba.excel.util.ListUtils;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.compress.utils.Lists;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+/**
+ * bom test
+ *
+ * @author Jiaju Zhuang
+ */
+@TestMethodOrder(MethodOrderer.MethodName.class)
+@Slf4j
+public class BomDataTest {
+
+    @Test
+    public void t01ReadCsv() {
+        readCsv(TestFileUtil.readFile("bom" + File.separator + "no_bom.csv"));
+        readCsv(TestFileUtil.readFile("bom" + File.separator + "office_bom.csv"));
+    }
+
+    @Test
+    public void t02ReadAndWriteCsv() throws Exception {
+        readAndWriteCsv(TestFileUtil.createNewFile("bom" + File.separator + "bom_default.csv"), null, null);
+        readAndWriteCsv(TestFileUtil.createNewFile("bom" + File.separator + "bom_utf_8.csv"), "UTF-8", null);
+        readAndWriteCsv(TestFileUtil.createNewFile("bom" + File.separator + "bom_utf_8_lower_case.csv"), "utf-8", null);
+        readAndWriteCsv(TestFileUtil.createNewFile("bom" + File.separator + "bom_gbk.csv"), "GBK", null);
+        readAndWriteCsv(TestFileUtil.createNewFile("bom" + File.separator + "bom_gbk_lower_case.csv"), "gbk", null);
+        readAndWriteCsv(TestFileUtil.createNewFile("bom" + File.separator + "bom_utf_16be.csv"), "UTF-16BE", null);
+        readAndWriteCsv(TestFileUtil.createNewFile("bom" + File.separator + "bom_utf_8_not_with_bom.csv"), "UTF-8",
+            Boolean.FALSE);
+    }
+
+    private void readAndWriteCsv(File file, String charsetName, Boolean withBom) throws Exception {
+        Charset charset = null;
+        if (charsetName != null) {
+            charset = Charset.forName(charsetName);
+        }
+        EasyExcel.write(new FileOutputStream(file), BomData.class)
+            .charset(charset)
+            .withBom(withBom)
+            .excelType(ExcelTypeEnum.CSV)
+            .sheet()
+            .doWrite(data());
+
+        EasyExcel.read(file, BomData.class, new ReadListener<BomData>() {
+
+                private final List<BomData> dataList = Lists.newArrayList();
+
+                @Override
+                public void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {
+                    String head = headMap.get(0).getStringValue();
+                    Assertions.assertEquals("姓名", head);
+                }
+
+                @Override
+                public void invoke(BomData data, AnalysisContext context) {
+                    dataList.add(data);
+                }
+
+                @Override
+                public void doAfterAllAnalysed(AnalysisContext context) {
+                    Assertions.assertEquals(dataList.size(), 10);
+                    BomData bomData = dataList.get(0);
+                    Assertions.assertEquals("姓名0", bomData.getName());
+                    Assertions.assertEquals(20, (long)bomData.getAge());
+                }
+            })
+            .charset(charset)
+            .sheet().doRead();
+    }
+
+    private void readCsv(File file) {
+        EasyExcel.read(file, BomData.class, new ReadListener<BomData>() {
+
+            private final List<BomData> dataList = Lists.newArrayList();
+
+            @Override
+            public void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {
+                String head = headMap.get(0).getStringValue();
+                Assertions.assertEquals("姓名", head);
+            }
+
+            @Override
+            public void invoke(BomData data, AnalysisContext context) {
+                dataList.add(data);
+            }
+
+            @Override
+            public void doAfterAllAnalysed(AnalysisContext context) {
+                Assertions.assertEquals(dataList.size(), 10);
+                BomData bomData = dataList.get(0);
+                Assertions.assertEquals("姓名0", bomData.getName());
+                Assertions.assertEquals(20L, (long)bomData.getAge());
+            }
+        }).sheet().doRead();
+    }
+
+    private List<BomData> data() {
+        List<BomData> list = ListUtils.newArrayList();
+        for (int i = 0; i < 10; i++) {
+            BomData data = new BomData();
+            data.setName("姓名" + i);
+            data.setAge(20L);
+            list.add(data);
+        }
+        return list;
+    }
+}

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/cache/CacheData.java

@@ -0,0 +1,21 @@
+package com.alibaba.easyexcel.test.core.cache;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @author Jiaju Zhuang
+ */
+@Getter
+@Setter
+@EqualsAndHashCode
+public class CacheData {
+    @ExcelProperty("姓名")
+    private String name;
+
+    @ExcelProperty("年龄")
+    private Long age;
+}

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/cache/CacheDataTest.java

@@ -0,0 +1,219 @@
+package com.alibaba.easyexcel.test.core.cache;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import com.alibaba.easyexcel.test.demo.read.DemoData;
+import com.alibaba.easyexcel.test.util.TestFileUtil;
+import com.alibaba.excel.EasyExcel;
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.context.AnalysisContext;
+import com.alibaba.excel.enums.CacheLocationEnum;
+import com.alibaba.excel.event.AnalysisEventListener;
+import com.alibaba.excel.metadata.FieldCache;
+import com.alibaba.excel.read.listener.PageReadListener;
+import com.alibaba.excel.util.ClassUtils;
+import com.alibaba.excel.util.FieldUtils;
+
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+/**
+ * @author Jiaju Zhuang
+ */
+@TestMethodOrder(MethodOrderer.MethodName.class)
+@Slf4j
+public class CacheDataTest {
+
+    private static File file07;
+    private static File fileCacheInvoke;
+    private static File fileCacheInvoke2;
+    private static File fileCacheInvokeMemory;
+    private static File fileCacheInvokeMemory2;
+
+    @BeforeAll
+    public static void init() {
+        file07 = TestFileUtil.createNewFile("cache/cache.xlsx");
+        fileCacheInvoke = TestFileUtil.createNewFile("cache/fileCacheInvoke.xlsx");
+        fileCacheInvoke2 = TestFileUtil.createNewFile("cache/fileCacheInvoke2.xlsx");
+        fileCacheInvokeMemory = TestFileUtil.createNewFile("cache/fileCacheInvokeMemory.xlsx");
+        fileCacheInvokeMemory2 = TestFileUtil.createNewFile("cache/fileCacheInvokeMemory2.xlsx");
+    }
+
+    @Test
+    public void t01ReadAndWrite() throws Exception {
+        Field field = FieldUtils.getField(ClassUtils.class, "FIELD_THREAD_LOCAL", true);
+        ThreadLocal<Map<Class<?>, FieldCache>> fieldThreadLocal = (ThreadLocal<Map<Class<?>, FieldCache>>)field.get(
+            ClassUtils.class.newInstance());
+        Assertions.assertNull(fieldThreadLocal.get());
+        EasyExcel.write(file07, CacheData.class).sheet().doWrite(data());
+        EasyExcel.read(file07, CacheData.class, new PageReadListener<DemoData>(dataList -> {
+                Assertions.assertNotNull(fieldThreadLocal.get());
+            }))
+            .sheet()
+            .doRead();
+        Assertions.assertNull(fieldThreadLocal.get());
+    }
+
+    @Test
+    public void t02ReadAndWriteInvoke() throws Exception {
+        EasyExcel.write(fileCacheInvoke, CacheInvokeData.class).sheet().doWrite(dataInvoke());
+        EasyExcel.read(fileCacheInvoke, CacheInvokeData.class, new AnalysisEventListener<CacheInvokeData>() {
+
+                @Override
+                public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
+                    Assertions.assertEquals(2, headMap.size());
+                    Assertions.assertEquals("姓名", headMap.get(0));
+                    Assertions.assertEquals("年龄", headMap.get(1));
+                }
+
+                @Override
+                public void invoke(CacheInvokeData data, AnalysisContext context) {
+                }
+
+                @Override
+                public void doAfterAllAnalysed(AnalysisContext context) {
+
+                }
+            }).sheet()
+            .doRead();
+
+        Field name = FieldUtils.getField(CacheInvokeData.class, "name", true);
+        ExcelProperty annotation = name.getAnnotation(ExcelProperty.class);
+        InvocationHandler invocationHandler = Proxy.getInvocationHandler(annotation);
+        Field memberValues = invocationHandler.getClass().getDeclaredField("memberValues");
+        memberValues.setAccessible(true);
+        Map map = (Map)memberValues.get(invocationHandler);
+        map.put("value", new String[] {"姓名2"});
+
+        EasyExcel.write(fileCacheInvoke2, CacheInvokeData.class).sheet().doWrite(dataInvoke());
+        EasyExcel.read(fileCacheInvoke2, CacheInvokeData.class, new AnalysisEventListener<CacheInvokeData>() {
+
+                @Override
+                public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
+                    Assertions.assertEquals(2, headMap.size());
+                    Assertions.assertEquals("姓名2", headMap.get(0));
+                    Assertions.assertEquals("年龄", headMap.get(1));
+                }
+
+                @Override
+                public void invoke(CacheInvokeData data, AnalysisContext context) {
+                }
+
+                @Override
+                public void doAfterAllAnalysed(AnalysisContext context) {
+
+                }
+            }).sheet()
+            .doRead();
+
+    }
+
+    @Test
+    public void t03ReadAndWriteInvokeMemory() throws Exception {
+        EasyExcel.write(fileCacheInvokeMemory, CacheInvokeMemoryData.class)
+            .filedCacheLocation(CacheLocationEnum.MEMORY)
+            .sheet()
+            .doWrite(dataInvokeMemory());
+        EasyExcel.read(fileCacheInvokeMemory, CacheInvokeMemoryData.class,
+                new AnalysisEventListener<CacheInvokeMemoryData>() {
+
+                    @Override
+                    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
+                        Assertions.assertEquals(2, headMap.size());
+                        Assertions.assertEquals("姓名", headMap.get(0));
+                        Assertions.assertEquals("年龄", headMap.get(1));
+                    }
+
+                    @Override
+                    public void invoke(CacheInvokeMemoryData data, AnalysisContext context) {
+                    }
+
+                    @Override
+                    public void doAfterAllAnalysed(AnalysisContext context) {
+
+                    }
+                })
+            .filedCacheLocation(CacheLocationEnum.MEMORY)
+            .sheet()
+            .doRead();
+
+        Field name = FieldUtils.getField(CacheInvokeMemoryData.class, "name", true);
+        ExcelProperty annotation = name.getAnnotation(ExcelProperty.class);
+        InvocationHandler invocationHandler = Proxy.getInvocationHandler(annotation);
+        Field memberValues = invocationHandler.getClass().getDeclaredField("memberValues");
+        memberValues.setAccessible(true);
+        Map map = (Map)memberValues.get(invocationHandler);
+        map.put("value", new String[] {"姓名2"});
+
+        EasyExcel.write(fileCacheInvokeMemory2, CacheInvokeMemoryData.class)
+            .filedCacheLocation(CacheLocationEnum.MEMORY)
+            .sheet()
+            .doWrite(dataInvokeMemory());
+        EasyExcel.read(fileCacheInvokeMemory2, CacheInvokeMemoryData.class,
+                new AnalysisEventListener<CacheInvokeMemoryData>() {
+
+                    @Override
+                    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
+                        Assertions.assertEquals(2, headMap.size());
+                        Assertions.assertEquals("姓名", headMap.get(0));
+                        Assertions.assertEquals("年龄", headMap.get(1));
+                    }
+
+                    @Override
+                    public void invoke(CacheInvokeMemoryData data, AnalysisContext context) {
+                    }
+
+                    @Override
+                    public void doAfterAllAnalysed(AnalysisContext context) {
+
+                    }
+                })
+            .filedCacheLocation(CacheLocationEnum.MEMORY)
+            .sheet()
+            .doRead();
+
+    }
+
+    private List<CacheData> data() {
+        List<CacheData> list = new ArrayList<CacheData>();
+        for (int i = 0; i < 10; i++) {
+            CacheData simpleData = new CacheData();
+            simpleData.setName("姓名" + i);
+            simpleData.setAge((long)i);
+            list.add(simpleData);
+        }
+        return list;
+    }
+
+    private List<CacheInvokeData> dataInvoke() {
+        List<CacheInvokeData> list = new ArrayList<>();
+        for (int i = 0; i < 10; i++) {
+            CacheInvokeData simpleData = new CacheInvokeData();
+            simpleData.setName("姓名" + i);
+            simpleData.setAge((long)i);
+            list.add(simpleData);
+        }
+        return list;
+    }
+
+    private List<CacheInvokeMemoryData> dataInvokeMemory() {
+        List<CacheInvokeMemoryData> list = new ArrayList<>();
+        for (int i = 0; i < 10; i++) {
+            CacheInvokeMemoryData simpleData = new CacheInvokeMemoryData();
+            simpleData.setName("姓名" + i);
+            simpleData.setAge((long)i);
+            list.add(simpleData);
+        }
+        return list;
+    }
+}

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/cache/CacheInvokeData.java

@@ -0,0 +1,21 @@
+package com.alibaba.easyexcel.test.core.cache;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @author Jiaju Zhuang
+ */
+@Getter
+@Setter
+@EqualsAndHashCode
+public class CacheInvokeData {
+    @ExcelProperty("姓名")
+    private String name;
+
+    @ExcelProperty("年龄")
+    private Long age;
+}

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/cache/CacheInvokeMemoryData.java

@@ -0,0 +1,21 @@
+package com.alibaba.easyexcel.test.core.cache;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @author Jiaju Zhuang
+ */
+@Getter
+@Setter
+@EqualsAndHashCode
+public class CacheInvokeMemoryData {
+    @ExcelProperty("姓名")
+    private String name;
+
+    @ExcelProperty("年龄")
+    private Long age;
+}

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/celldata/CellDataDataListener.java

@@ -8,7 +8,7 @@ import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.excel.support.ExcelTypeEnum;
 import com.alibaba.fastjson2.JSON;
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -26,16 +26,16 @@ public class CellDataDataListener extends AnalysisEventListener<CellDataReadData
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         CellDataReadData cellDataData = list.get(0);
 
-        Assert.assertEquals("2020年01月01日", cellDataData.getDate().getData());
-        Assert.assertEquals((long)cellDataData.getInteger1().getData(), 2L);
-        Assert.assertEquals((long)cellDataData.getInteger2(), 2L);
+        Assertions.assertEquals("2020年01月01日", cellDataData.getDate().getData());
+        Assertions.assertEquals((long)cellDataData.getInteger1().getData(), 2L);
+        Assertions.assertEquals((long)cellDataData.getInteger2(), 2L);
         if (context.readWorkbookHolder().getExcelType() != ExcelTypeEnum.CSV) {
-            Assert.assertEquals(cellDataData.getFormulaValue().getFormulaData().getFormulaValue(), "B2+C2");
+            Assertions.assertEquals(cellDataData.getFormulaValue().getFormulaData().getFormulaValue(), "B2+C2");
         } else {
-            Assert.assertNull(cellDataData.getFormulaValue().getData());
+            Assertions.assertNull(cellDataData.getFormulaValue().getData());
         }
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/celldata/CellDataDataTest.java

@@ -12,23 +12,22 @@ import com.alibaba.excel.metadata.data.FormulaData;
 import com.alibaba.excel.metadata.data.WriteCellData;
 import com.alibaba.excel.util.DateUtils;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class CellDataDataTest {
 
     private static File file07;
     private static File file03;
     private static File fileCsv;
 
-
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("cellData07.xlsx");
         file03 = TestFileUtil.createNewFile("cellData03.xls");
@@ -50,7 +49,6 @@ public class CellDataDataTest {
         readAndWrite(fileCsv);
     }
 
-
     private void readAndWrite(File file) throws Exception {
         EasyExcel.write(file, CellDataWriteData.class).sheet().doWrite(data());
         EasyExcel.read(file, CellDataReadData.class, new CellDataDataListener()).sheet().doRead();

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/charset/CharsetDataTest.java

@@ -14,11 +14,11 @@ import com.alibaba.excel.read.listener.ReadListener;
 
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.compress.utils.Lists;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * charset
@@ -26,14 +26,14 @@ import org.junit.runners.MethodSorters;
  * @author Jiaju Zhuang
  */
 @Slf4j
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class CharsetDataTest {
     private static final Charset GBK = Charset.forName("GBK");
     private static File fileCsvGbk;
     private static File fileCsvUtf8;
     private static File fileCsvError;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         fileCsvGbk = TestFileUtil.createNewFile("charset" + File.separator + "fileCsvGbk.csv");
         fileCsvUtf8 = TestFileUtil.createNewFile("charset" + File.separator + "fileCsvUtf8.csv");
@@ -56,7 +56,7 @@ public class CharsetDataTest {
             @Override
             public void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {
                 String head = headMap.get(0).getStringValue();
-                Assert.assertNotEquals("姓名", head);
+                Assertions.assertNotEquals("姓名", head);
             }
 
             @Override
@@ -79,7 +79,7 @@ public class CharsetDataTest {
             @Override
             public void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {
                 String head = headMap.get(0).getStringValue();
-                Assert.assertEquals("姓名", head);
+                Assertions.assertEquals("姓名", head);
             }
 
             @Override
@@ -89,10 +89,10 @@ public class CharsetDataTest {
 
             @Override
             public void doAfterAllAnalysed(AnalysisContext context) {
-                Assert.assertEquals(dataList.size(), 10);
+                Assertions.assertEquals(dataList.size(), 10);
                 CharsetData charsetData = dataList.get(0);
-                Assert.assertEquals("姓名0", charsetData.getName());
-                Assert.assertEquals(0, (long)charsetData.getAge());
+                Assertions.assertEquals("姓名0", charsetData.getName());
+                Assertions.assertEquals(0, (long)charsetData.getAge());
             }
         }).charset(charset).sheet().doRead();
     }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/compatibility/CompatibilityTest.java

@@ -6,30 +6,27 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
-import com.alibaba.easyexcel.test.core.large.LargeData;
-import com.alibaba.easyexcel.test.core.large.LargeDataListener;
 import com.alibaba.easyexcel.test.core.simple.SimpleData;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.cache.Ehcache;
-import com.alibaba.excel.constant.EasyExcelConstants;
 import com.alibaba.excel.enums.ReadDefaultReturnEnum;
 import com.alibaba.excel.util.FileUtils;
 import com.alibaba.fastjson2.JSON;
 
 import lombok.extern.slf4j.Slf4j;
 import org.apache.poi.util.TempFile;
-import org.junit.Assert;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * Compatible with some special files
  *
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 @Slf4j
 public class CompatibilityTest {
 
@@ -38,9 +35,9 @@ public class CompatibilityTest {
         // https://github.com/alibaba/easyexcel/issues/2236
         List<Map<Integer, Object>> list = EasyExcel.read(TestFileUtil.getPath() + "compatibility/t01.xls").sheet()
             .doReadSync();
-        Assert.assertEquals(2, list.size());
+        Assertions.assertEquals(2, list.size());
         Map<Integer, Object> row1 = list.get(1);
-        Assert.assertEquals("Q235(碳钢)", row1.get(0));
+        Assertions.assertEquals("Q235(碳钢)", row1.get(0));
     }
 
     @Test
@@ -49,9 +46,9 @@ public class CompatibilityTest {
         List<Map<Integer, Object>> list = EasyExcel.read(TestFileUtil.getPath() + "compatibility/t02.xlsx").sheet()
             .headRowNumber(0).doReadSync();
         log.info("data:{}", JSON.toJSONString(list));
-        Assert.assertEquals(3, list.size());
+        Assertions.assertEquals(3, list.size());
         Map<Integer, Object> row2 = list.get(2);
-        Assert.assertEquals("1，2-戊二醇", row2.get(2));
+        Assertions.assertEquals("1，2-戊二醇", row2.get(2));
     }
 
     @Test
@@ -60,9 +57,9 @@ public class CompatibilityTest {
         List<Map<Integer, Object>> list = EasyExcel.read(TestFileUtil.getPath() + "compatibility/t03.xlsx").sheet()
             .doReadSync();
         log.info("data:{}", JSON.toJSONString(list));
-        Assert.assertEquals(1, list.size());
+        Assertions.assertEquals(1, list.size());
         Map<Integer, Object> row0 = list.get(0);
-        Assert.assertEquals(12, row0.size());
+        Assertions.assertEquals(12, row0.size());
     }
 
     @Test
@@ -71,9 +68,9 @@ public class CompatibilityTest {
         List<Map<Integer, Object>> list = EasyExcel.read(TestFileUtil.getPath() + "compatibility/t04.xlsx").sheet()
             .doReadSync();
         log.info("data:{}", JSON.toJSONString(list));
-        Assert.assertEquals(56, list.size());
+        Assertions.assertEquals(56, list.size());
         Map<Integer, Object> row0 = list.get(0);
-        Assert.assertEquals("QQSJK28F152A012242S0081", row0.get(5));
+        Assertions.assertEquals("QQSJK28F152A012242S0081", row0.get(5));
     }
 
     @Test
@@ -85,11 +82,11 @@ public class CompatibilityTest {
             .sheet()
             .doReadSync();
         log.info("data:{}", JSON.toJSONString(list));
-        Assert.assertEquals("2023-01-01 00:00:00", list.get(0).get(0));
-        Assert.assertEquals("2023-01-01 00:00:00", list.get(1).get(0));
-        Assert.assertEquals("2023-01-01 00:00:00", list.get(2).get(0));
-        Assert.assertEquals("2023-01-01 00:00:01", list.get(3).get(0));
-        Assert.assertEquals("2023-01-01 00:00:01", list.get(4).get(0));
+        Assertions.assertEquals("2023-01-01 00:00:00", list.get(0).get(0));
+        Assertions.assertEquals("2023-01-01 00:00:00", list.get(1).get(0));
+        Assertions.assertEquals("2023-01-01 00:00:00", list.get(2).get(0));
+        Assertions.assertEquals("2023-01-01 00:00:01", list.get(3).get(0));
+        Assertions.assertEquals("2023-01-01 00:00:01", list.get(4).get(0));
     }
 
     @Test
@@ -101,7 +98,7 @@ public class CompatibilityTest {
             .sheet()
             .doReadSync();
         log.info("data:{}", JSON.toJSONString(list));
-        Assert.assertEquals("2087.03", list.get(0).get(2));
+        Assertions.assertEquals("2087.03", list.get(0).get(2));
     }
 
     @Test
@@ -114,14 +111,14 @@ public class CompatibilityTest {
             .sheet()
             .doReadSync();
         log.info("data:{}", JSON.toJSONString(list));
-        Assert.assertEquals(0, new BigDecimal("24.1998124").compareTo((BigDecimal)list.get(0).get(11)));
+        Assertions.assertEquals(0, new BigDecimal("24.1998124").compareTo((BigDecimal)list.get(0).get(11)));
 
         list = EasyExcel
             .read(TestFileUtil.getPath() + "compatibility/t07.xlsx")
             .sheet()
             .doReadSync();
         log.info("data:{}", JSON.toJSONString(list));
-        Assert.assertEquals("24.20", list.get(0).get(11));
+        Assertions.assertEquals("24.20", list.get(0).get(11));
     }
 
     @Test
@@ -137,7 +134,7 @@ public class CompatibilityTest {
             .readCache(new Ehcache(null, 20))
             .sheet()
             .doReadSync();
-        Assert.assertEquals(10L, list.size());
+        Assertions.assertEquals(10L, list.size());
 
         FileUtils.delete(new File(System.getProperty(TempFile.JAVA_IO_TMPDIR)));
 
@@ -145,7 +142,21 @@ public class CompatibilityTest {
             .readCache(new Ehcache(null, 20))
             .sheet()
             .doReadSync();
-        Assert.assertEquals(10L, list.size());
+        Assertions.assertEquals(10L, list.size());
+    }
+
+    @Test
+    public void t09() {
+        // `SH_x005f_x000D_Z002` exists in `ShardingString.xml` and needs to be replaced by: `SH_x000D_Z002`
+        File file = TestFileUtil.readFile("compatibility/t09.xlsx");
+        List<Map<Integer, Object>> list = EasyExcel.read(file)
+            .headRowNumber(0)
+            .sheet()
+            .doReadSync();
+        log.info("data:{}", JSON.toJSONString(list));
+        Assertions.assertEquals(1, list.size());
+
+        Assertions.assertEquals("SH_x000D_Z002", list.get(0).get(0));
     }
 
     private List<SimpleData> data() {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/converter/ConverterDataListener.java

@@ -2,19 +2,15 @@ package com.alibaba.easyexcel.test.core.converter;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
-import java.text.ParseException;
-import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.List;
 
 import com.alibaba.easyexcel.test.util.TestUtil;
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
-import com.alibaba.excel.exception.ExcelCommonException;
-import com.alibaba.excel.util.DateUtils;
 import com.alibaba.fastjson2.JSON;
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -32,22 +28,22 @@ public class ConverterDataListener extends AnalysisEventListener<ConverterReadDa
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         ConverterReadData data = list.get(0);
-        Assert.assertEquals(TestUtil.TEST_DATE, data.getDate());
-        Assert.assertEquals(TestUtil.TEST_LOCAL_DATE, data.getLocalDate());
-        Assert.assertEquals(TestUtil.TEST_LOCAL_DATE_TIME, data.getLocalDateTime());
-        Assert.assertEquals(data.getBooleanData(), Boolean.TRUE);
-        Assert.assertEquals(data.getBigDecimal().doubleValue(), BigDecimal.ONE.doubleValue(), 0.0);
-        Assert.assertEquals(data.getBigInteger().intValue(), BigInteger.ONE.intValue(), 0.0);
-        Assert.assertEquals((long)data.getLongData(), 1L);
-        Assert.assertEquals((long)data.getIntegerData(), 1L);
-        Assert.assertEquals((long)data.getShortData(), 1L);
-        Assert.assertEquals((long)data.getByteData(), 1L);
-        Assert.assertEquals(data.getDoubleData(), 1.0, 0.0);
-        Assert.assertEquals(data.getFloatData(), (float)1.0, 0.0);
-        Assert.assertEquals(data.getString(), "测试");
-        Assert.assertEquals(data.getCellData().getStringValue(), "自定义");
+        Assertions.assertEquals(TestUtil.TEST_DATE, data.getDate());
+        Assertions.assertEquals(TestUtil.TEST_LOCAL_DATE, data.getLocalDate());
+        Assertions.assertEquals(TestUtil.TEST_LOCAL_DATE_TIME, data.getLocalDateTime());
+        Assertions.assertEquals(data.getBooleanData(), Boolean.TRUE);
+        Assertions.assertEquals(data.getBigDecimal().doubleValue(), BigDecimal.ONE.doubleValue(), 0.0);
+        Assertions.assertEquals(data.getBigInteger().intValue(), BigInteger.ONE.intValue(), 0.0);
+        Assertions.assertEquals((long)data.getLongData(), 1L);
+        Assertions.assertEquals((long)data.getIntegerData(), 1L);
+        Assertions.assertEquals((long)data.getShortData(), 1L);
+        Assertions.assertEquals((long)data.getByteData(), 1L);
+        Assertions.assertEquals(data.getDoubleData(), 1.0, 0.0);
+        Assertions.assertEquals(data.getFloatData(), (float)1.0, 0.0);
+        Assertions.assertEquals(data.getString(), "测试");
+        Assertions.assertEquals(data.getCellData().getStringValue(), "自定义");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/converter/ConverterDataTest.java

@@ -4,8 +4,6 @@ import java.io.File;
 import java.io.InputStream;
 import java.math.BigDecimal;
 import java.math.BigInteger;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -13,18 +11,17 @@ import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.easyexcel.test.util.TestUtil;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.metadata.data.WriteCellData;
-import com.alibaba.excel.util.DateUtils;
 import com.alibaba.excel.util.FileUtils;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class ConverterDataTest {
 
     private static File file07;
@@ -33,7 +30,7 @@ public class ConverterDataTest {
     private static File fileImage07;
     private static File fileImage03;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("converter07.xlsx");
         file03 = TestFileUtil.createNewFile("converter03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/converter/ConverterTest.java

@@ -6,15 +6,15 @@ import com.alibaba.excel.converters.WriteConverterContext;
 import com.alibaba.excel.converters.floatconverter.FloatNumberConverter;
 import com.alibaba.excel.metadata.data.WriteCellData;
 
-import org.junit.Assert;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class ConverterTest {
 
     @Test
@@ -23,7 +23,7 @@ public class ConverterTest {
         WriteConverterContext<Float> context = new WriteConverterContext<>();
         context.setValue(95.62F);
         WriteCellData<?> writeCellData = floatNumberConverter.convertToExcelData(context);
-        Assert.assertEquals(0, writeCellData.getNumberValue().compareTo(new BigDecimal("95.62")));
+        Assertions.assertEquals(0, writeCellData.getNumberValue().compareTo(new BigDecimal("95.62")));
     }
 
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/converter/ReadAllConverterDataListener.java

@@ -13,7 +13,7 @@ import com.alibaba.excel.support.ExcelTypeEnum;
 import com.alibaba.excel.util.DateUtils;
 import com.alibaba.fastjson2.JSON;
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -31,54 +31,56 @@ public class ReadAllConverterDataListener extends AnalysisEventListener<ReadAllC
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         ReadAllConverterData data = list.get(0);
-        Assert.assertEquals(data.getBigDecimalBoolean().doubleValue(), BigDecimal.ONE.doubleValue(), 0.0);
-        Assert.assertEquals(data.getBigDecimalNumber().doubleValue(), BigDecimal.ONE.doubleValue(), 0.0);
-        Assert.assertEquals(data.getBigDecimalString().doubleValue(), BigDecimal.ONE.doubleValue(), 0.0);
-        Assert.assertEquals(data.getBigIntegerBoolean().intValue(), BigInteger.ONE.intValue(), 0.0);
-        Assert.assertEquals(data.getBigIntegerNumber().intValue(), BigInteger.ONE.intValue(), 0.0);
-        Assert.assertEquals(data.getBigIntegerString().intValue(), BigInteger.ONE.intValue(), 0.0);
-        Assert.assertTrue(data.getBooleanBoolean());
-        Assert.assertTrue(data.getBooleanNumber());
-        Assert.assertTrue(data.getBooleanString());
-        Assert.assertEquals((long)data.getByteBoolean(), 1L);
-        Assert.assertEquals((long)data.getByteNumber(), 1L);
-        Assert.assertEquals((long)data.getByteString(), 1L);
+        Assertions.assertEquals(data.getBigDecimalBoolean().doubleValue(), BigDecimal.ONE.doubleValue(), 0.0);
+        Assertions.assertEquals(data.getBigDecimalNumber().doubleValue(), BigDecimal.ONE.doubleValue(), 0.0);
+        Assertions.assertEquals(data.getBigDecimalString().doubleValue(), BigDecimal.ONE.doubleValue(), 0.0);
+        Assertions.assertEquals(data.getBigIntegerBoolean().intValue(), BigInteger.ONE.intValue(), 0.0);
+        Assertions.assertEquals(data.getBigIntegerNumber().intValue(), BigInteger.ONE.intValue(), 0.0);
+        Assertions.assertEquals(data.getBigIntegerString().intValue(), BigInteger.ONE.intValue(), 0.0);
+        Assertions.assertTrue(data.getBooleanBoolean());
+        Assertions.assertTrue(data.getBooleanNumber());
+        Assertions.assertTrue(data.getBooleanString());
+        Assertions.assertEquals((long)data.getByteBoolean(), 1L);
+        Assertions.assertEquals((long)data.getByteNumber(), 1L);
+        Assertions.assertEquals((long)data.getByteString(), 1L);
         try {
-            Assert.assertEquals(data.getDateNumber(), DateUtils.parseDate("2020-01-01 01:01:01"));
-            Assert.assertEquals(data.getDateString(), DateUtils.parseDate("2020-01-01 01:01:01"));
+            Assertions.assertEquals(data.getDateNumber(), DateUtils.parseDate("2020-01-01 01:01:01"));
+            Assertions.assertEquals(data.getDateString(), DateUtils.parseDate("2020-01-01 01:01:01"));
         } catch (ParseException e) {
             throw new ExcelCommonException("Test Exception", e);
         }
-        Assert.assertEquals(data.getLocalDateTimeNumber(), DateUtils.parseLocalDateTime("2020-01-01 01:01:01", null, null));
-        Assert.assertEquals(data.getLocalDateTimeString(), DateUtils.parseLocalDateTime("2020-01-01 01:01:01", null, null));
-        Assert.assertEquals(data.getDoubleBoolean(), 1.0, 0.0);
-        Assert.assertEquals(data.getDoubleNumber(), 1.0, 0.0);
-        Assert.assertEquals(data.getDoubleString(), 1.0, 0.0);
-        Assert.assertEquals(data.getFloatBoolean(), (float)1.0, 0.0);
-        Assert.assertEquals(data.getFloatNumber(), (float)1.0, 0.0);
-        Assert.assertEquals(data.getFloatString(), (float)1.0, 0.0);
-        Assert.assertEquals((long)data.getIntegerBoolean(), 1L);
-        Assert.assertEquals((long)data.getIntegerNumber(), 1L);
-        Assert.assertEquals((long)data.getIntegerString(), 1L);
-        Assert.assertEquals((long)data.getLongBoolean(), 1L);
-        Assert.assertEquals((long)data.getLongNumber(), 1L);
-        Assert.assertEquals((long)data.getLongString(), 1L);
-        Assert.assertEquals((long)data.getShortBoolean(), 1L);
-        Assert.assertEquals((long)data.getShortNumber(), 1L);
-        Assert.assertEquals((long)data.getShortString(), 1L);
-        Assert.assertEquals(data.getStringBoolean().toLowerCase(), "true");
-        Assert.assertEquals(data.getStringString(), "测试");
-        Assert.assertEquals(data.getStringError(), "#VALUE!");
+        Assertions.assertEquals(data.getLocalDateTimeNumber(),
+            DateUtils.parseLocalDateTime("2020-01-01 01:01:01", null, null));
+        Assertions.assertEquals(data.getLocalDateTimeString(),
+            DateUtils.parseLocalDateTime("2020-01-01 01:01:01", null, null));
+        Assertions.assertEquals(data.getDoubleBoolean(), 1.0, 0.0);
+        Assertions.assertEquals(data.getDoubleNumber(), 1.0, 0.0);
+        Assertions.assertEquals(data.getDoubleString(), 1.0, 0.0);
+        Assertions.assertEquals(data.getFloatBoolean(), (float)1.0, 0.0);
+        Assertions.assertEquals(data.getFloatNumber(), (float)1.0, 0.0);
+        Assertions.assertEquals(data.getFloatString(), (float)1.0, 0.0);
+        Assertions.assertEquals((long)data.getIntegerBoolean(), 1L);
+        Assertions.assertEquals((long)data.getIntegerNumber(), 1L);
+        Assertions.assertEquals((long)data.getIntegerString(), 1L);
+        Assertions.assertEquals((long)data.getLongBoolean(), 1L);
+        Assertions.assertEquals((long)data.getLongNumber(), 1L);
+        Assertions.assertEquals((long)data.getLongString(), 1L);
+        Assertions.assertEquals((long)data.getShortBoolean(), 1L);
+        Assertions.assertEquals((long)data.getShortNumber(), 1L);
+        Assertions.assertEquals((long)data.getShortString(), 1L);
+        Assertions.assertEquals(data.getStringBoolean().toLowerCase(), "true");
+        Assertions.assertEquals(data.getStringString(), "测试");
+        Assertions.assertEquals(data.getStringError(), "#VALUE!");
         if (context.readWorkbookHolder().getExcelType() != ExcelTypeEnum.CSV) {
-            Assert.assertEquals("2020-1-1 1:01", data.getStringNumberDate());
+            Assertions.assertEquals("2020-1-1 1:01", data.getStringNumberDate());
         } else {
-            Assert.assertEquals("2020-01-01 01:01:01", data.getStringNumberDate());
+            Assertions.assertEquals("2020-01-01 01:01:01", data.getStringNumberDate());
         }
         double doubleStringFormulaNumber = new BigDecimal(data.getStringFormulaNumber()).doubleValue();
-        Assert.assertEquals(doubleStringFormulaNumber, 2.0, 0.0);
-        Assert.assertEquals(data.getStringFormulaString(), "1测试");
+        Assertions.assertEquals(doubleStringFormulaNumber, 2.0, 0.0);
+        Assertions.assertEquals(data.getStringFormulaString(), "1测试");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/dataformat/DateFormatTest.java

@@ -8,23 +8,23 @@ import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
 import lombok.extern.slf4j.Slf4j;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 @Slf4j
 public class DateFormatTest {
 
     private static File file07;
     private static File file03;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.readFile("dataformat" + File.separator + "dataformat.xlsx");
         file03 = TestFileUtil.readFile("dataformat" + File.separator + "dataformat.xls");
@@ -54,8 +54,8 @@ public class DateFormatTest {
             }
         }
         for (DateFormatData data : list) {
-            Assert.assertEquals(data.getDateStringCn(), data.getDate());
-            Assert.assertEquals(data.getNumberStringCn(), data.getNumber());
+            Assertions.assertEquals(data.getDateStringCn(), data.getDate());
+            Assertions.assertEquals(data.getNumberStringCn(), data.getNumber());
         }
     }
 
@@ -71,8 +71,8 @@ public class DateFormatTest {
             }
         }
         for (DateFormatData data : list) {
-            Assert.assertEquals(data.getDateStringUs(), data.getDate());
-            Assert.assertEquals(data.getNumberStringUs(), data.getNumber());
+            Assertions.assertEquals(data.getDateStringUs(), data.getDate());
+            Assertions.assertEquals(data.getNumberStringUs(), data.getNumber());
         }
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/encrypt/EncryptDataListener.java

@@ -3,14 +3,14 @@ package com.alibaba.easyexcel.test.core.encrypt;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -25,10 +25,10 @@ public class EncryptDataListener extends AnalysisEventListener<EncryptData> {
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 10);
-        Assert.assertEquals(list.get(0).getName(), "姓名0");
-        Assert.assertEquals((int)(context.readSheetHolder().getSheetNo()), 0);
-        Assert.assertEquals(
+        Assertions.assertEquals(list.size(), 10);
+        Assertions.assertEquals(list.get(0).getName(), "姓名0");
+        Assertions.assertEquals((int)(context.readSheetHolder().getSheetNo()), 0);
+        Assertions.assertEquals(
             context.readSheetHolder().getExcelReadHeadProperty().getHeadMap().get(0).getHeadNameList().get(0), "姓名");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/encrypt/EncryptDataTest.java

@@ -14,15 +14,15 @@ import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.support.ExcelTypeEnum;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class EncryptDataTest {
 
     private static File file07;
@@ -39,7 +39,7 @@ public class EncryptDataTest {
         System.out.println(decimalFormat.format(bigDecimal));
     }
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("encrypt07.xlsx");
         file03 = TestFileUtil.createNewFile("encrypt03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/exception/ExceptionDataListener.java

@@ -3,14 +3,14 @@ package com.alibaba.easyexcel.test.core.exception;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -38,10 +38,10 @@ public class ExceptionDataListener extends AnalysisEventListener<ExceptionData>
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 8);
-        Assert.assertEquals(list.get(0).getName(), "姓名0");
-        Assert.assertEquals((int)(context.readSheetHolder().getSheetNo()), 0);
-        Assert.assertEquals(
+        Assertions.assertEquals(list.size(), 8);
+        Assertions.assertEquals(list.get(0).getName(), "姓名0");
+        Assertions.assertEquals((int)(context.readSheetHolder().getSheetNo()), 0);
+        Assertions.assertEquals(
             context.readSheetHolder().getExcelReadHeadProperty().getHeadMap().get(0).getHeadNameList().get(0), "姓名");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/exception/ExceptionDataTest.java

@@ -9,16 +9,16 @@ import java.util.List;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class ExceptionDataTest {
 
     private static File file07;
@@ -27,7 +27,7 @@ public class ExceptionDataTest {
     private static File fileException03;
     private static File fileCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("exception.xlsx");
         file03 = TestFileUtil.createNewFile("exception.xls");
@@ -63,10 +63,10 @@ public class ExceptionDataTest {
 
     private void readAndWriteException(File file) throws Exception {
         EasyExcel.write(new FileOutputStream(file), ExceptionData.class).sheet().doWrite(data());
-        ArithmeticException exception = Assert.assertThrows(ArithmeticException.class, () -> EasyExcel.read(
+        ArithmeticException exception = Assertions.assertThrows(ArithmeticException.class, () -> EasyExcel.read(
             new FileInputStream(file), ExceptionData.class,
             new ExceptionThrowDataListener()).sheet().doRead());
-        Assert.assertEquals("/ by zero",exception.getMessage());
+        Assertions.assertEquals("/ by zero", exception.getMessage());
     }
 
     private void readAndWrite(File file) throws Exception {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/excludeorinclude/ExcludeOrIncludeDataTest.java

@@ -10,16 +10,16 @@ import java.util.Set;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class ExcludeOrIncludeDataTest {
 
     private static File excludeIndex07;
@@ -34,8 +34,15 @@ public class ExcludeOrIncludeDataTest {
     private static File includeFieldName07;
     private static File includeFieldName03;
     private static File includeFieldNameCsv;
+    private static File includeFieldNameOrder07;
+    private static File includeFieldNameOrder03;
+    private static File includeFieldNameOrderCsv;
 
-    @BeforeClass
+    private static File includeFieldNameOrderIndex07;
+    private static File includeFieldNameOrderIndex03;
+    private static File includeFieldNameOrderIndexCsv;
+
+    @BeforeAll
     public static void init() {
         excludeIndex07 = TestFileUtil.createNewFile("excludeIndex.xlsx");
         excludeIndex03 = TestFileUtil.createNewFile("excludeIndex.xls");
@@ -49,6 +56,12 @@ public class ExcludeOrIncludeDataTest {
         includeFieldName07 = TestFileUtil.createNewFile("includeFieldName.xlsx");
         includeFieldName03 = TestFileUtil.createNewFile("includeFieldName.xls");
         includeFieldNameCsv = TestFileUtil.createNewFile("includeFieldName.csv");
+        includeFieldNameOrder07 = TestFileUtil.createNewFile("includeFieldNameOrder.xlsx");
+        includeFieldNameOrder03 = TestFileUtil.createNewFile("includeFieldNameOrder.xls");
+        includeFieldNameOrderCsv = TestFileUtil.createNewFile("includeFieldNameOrder.csv");
+        includeFieldNameOrderIndex07 = TestFileUtil.createNewFile("includeFieldNameOrderIndex.xlsx");
+        includeFieldNameOrderIndex03 = TestFileUtil.createNewFile("includeFieldNameOrderIndex.xls");
+        includeFieldNameOrderIndexCsv = TestFileUtil.createNewFile("includeFieldNameOrderIndex.csv");
     }
 
     @Test
@@ -81,7 +94,6 @@ public class ExcludeOrIncludeDataTest {
         excludeFieldName(excludeFieldNameCsv);
     }
 
-
     @Test
     public void t21IncludeIndex07() {
         includeIndex(includeIndex07);
@@ -112,6 +124,36 @@ public class ExcludeOrIncludeDataTest {
         includeFieldName(includeFieldNameCsv);
     }
 
+    @Test
+    public void t41IncludeFieldNameOrder07() {
+        includeFieldNameOrder(includeFieldNameOrder07);
+    }
+
+    @Test
+    public void t42IncludeFieldNameOrder03() {
+        includeFieldNameOrder(includeFieldNameOrder03);
+    }
+
+    @Test
+    public void t43IncludeFieldNameOrderCsv() {
+        includeFieldNameOrder(includeFieldNameOrderCsv);
+    }
+
+    @Test
+    public void t41IncludeFieldNameOrderIndex07() {
+        includeFieldNameOrderIndex(includeFieldNameOrderIndex07);
+    }
+
+    @Test
+    public void t42IncludeFieldNameOrderIndex03() {
+        includeFieldNameOrderIndex(includeFieldNameOrderIndex03);
+    }
+
+    @Test
+    public void t43IncludeFieldNameOrderIndexCsv() {
+        includeFieldNameOrderIndex(includeFieldNameOrderIndexCsv);
+    }
+
     private void excludeIndex(File file) {
         Set<Integer> excludeColumnIndexes = new HashSet<Integer>();
         excludeColumnIndexes.add(0);
@@ -119,11 +161,11 @@ public class ExcludeOrIncludeDataTest {
         EasyExcel.write(file, ExcludeOrIncludeData.class).excludeColumnIndexes(excludeColumnIndexes).sheet()
             .doWrite(data());
         List<Map<Integer, String>> dataMap = EasyExcel.read(file).sheet().doReadSync();
-        Assert.assertEquals(1, dataMap.size());
+        Assertions.assertEquals(1, dataMap.size());
         Map<Integer, String> record = dataMap.get(0);
-        Assert.assertEquals(2, record.size());
-        Assert.assertEquals("column2", record.get(0));
-        Assert.assertEquals("column3", record.get(1));
+        Assertions.assertEquals(2, record.size());
+        Assertions.assertEquals("column2", record.get(0));
+        Assertions.assertEquals("column3", record.get(1));
 
     }
 
@@ -135,10 +177,10 @@ public class ExcludeOrIncludeDataTest {
         EasyExcel.write(file, ExcludeOrIncludeData.class).excludeColumnFieldNames(excludeColumnFieldNames).sheet()
             .doWrite(data());
         List<Map<Integer, String>> dataMap = EasyExcel.read(file).sheet().doReadSync();
-        Assert.assertEquals(1, dataMap.size());
+        Assertions.assertEquals(1, dataMap.size());
         Map<Integer, String> record = dataMap.get(0);
-        Assert.assertEquals(1, record.size());
-        Assert.assertEquals("column2", record.get(0));
+        Assertions.assertEquals(1, record.size());
+        Assertions.assertEquals("column2", record.get(0));
 
     }
 
@@ -149,11 +191,11 @@ public class ExcludeOrIncludeDataTest {
         EasyExcel.write(file, ExcludeOrIncludeData.class).includeColumnIndexes(includeColumnIndexes).sheet()
             .doWrite(data());
         List<Map<Integer, String>> dataMap = EasyExcel.read(file).sheet().doReadSync();
-        Assert.assertEquals(1, dataMap.size());
+        Assertions.assertEquals(1, dataMap.size());
         Map<Integer, String> record = dataMap.get(0);
-        Assert.assertEquals(2, record.size());
-        Assert.assertEquals("column2", record.get(0));
-        Assert.assertEquals("column3", record.get(1));
+        Assertions.assertEquals(2, record.size());
+        Assertions.assertEquals("column2", record.get(0));
+        Assertions.assertEquals("column3", record.get(1));
 
     }
 
@@ -164,11 +206,51 @@ public class ExcludeOrIncludeDataTest {
         EasyExcel.write(file, ExcludeOrIncludeData.class).includeColumnFieldNames(includeColumnFieldNames).sheet()
             .doWrite(data());
         List<Map<Integer, String>> dataMap = EasyExcel.read(file).sheet().doReadSync();
-        Assert.assertEquals(1, dataMap.size());
+        Assertions.assertEquals(1, dataMap.size());
+        Map<Integer, String> record = dataMap.get(0);
+        Assertions.assertEquals(2, record.size());
+        Assertions.assertEquals("column2", record.get(0));
+        Assertions.assertEquals("column3", record.get(1));
+    }
+
+    private void includeFieldNameOrderIndex(File file) {
+        List<Integer> includeColumnIndexes = new ArrayList<>();
+        includeColumnIndexes.add(3);
+        includeColumnIndexes.add(1);
+        includeColumnIndexes.add(2);
+        includeColumnIndexes.add(0);
+        EasyExcel.write(file, ExcludeOrIncludeData.class)
+            .includeColumnIndexes(includeColumnIndexes)
+            .orderByIncludeColumn(true).
+            sheet()
+            .doWrite(data());
+        List<Map<Integer, String>> dataMap = EasyExcel.read(file).sheet().doReadSync();
+        Assertions.assertEquals(1, dataMap.size());
+        Map<Integer, String> record = dataMap.get(0);
+        Assertions.assertEquals(4, record.size());
+        Assertions.assertEquals("column4", record.get(0));
+        Assertions.assertEquals("column2", record.get(1));
+        Assertions.assertEquals("column3", record.get(2));
+        Assertions.assertEquals("column1", record.get(3));
+    }
+
+    private void includeFieldNameOrder(File file) {
+        List<String> includeColumnFieldNames = new ArrayList<>();
+        includeColumnFieldNames.add("column4");
+        includeColumnFieldNames.add("column2");
+        includeColumnFieldNames.add("column3");
+        EasyExcel.write(file, ExcludeOrIncludeData.class)
+            .includeColumnFieldNames(includeColumnFieldNames)
+            .orderByIncludeColumn(true).
+            sheet()
+            .doWrite(data());
+        List<Map<Integer, String>> dataMap = EasyExcel.read(file).sheet().doReadSync();
+        Assertions.assertEquals(1, dataMap.size());
         Map<Integer, String> record = dataMap.get(0);
-        Assert.assertEquals(2, record.size());
-        Assert.assertEquals("column2", record.get(0));
-        Assert.assertEquals("column3", record.get(1));
+        Assertions.assertEquals(3, record.size());
+        Assertions.assertEquals("column4", record.get(0));
+        Assertions.assertEquals("column2", record.get(1));
+        Assertions.assertEquals("column3", record.get(2));
     }
 
     private List<ExcludeOrIncludeData> data() {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/extra/ExtraDataListener.java

@@ -1,14 +1,14 @@
 package com.alibaba.easyexcel.test.core.extra;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.excel.metadata.CellExtra;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -26,28 +26,28 @@ public class ExtraDataListener extends AnalysisEventListener<ExtraData> {
         LOGGER.info("extra data:{}", JSON.toJSONString(extra));
         switch (extra.getType()) {
             case COMMENT:
-                Assert.assertEquals("批注的内容", extra.getText());
-                Assert.assertEquals(4, (int)extra.getRowIndex());
-                Assert.assertEquals(0, (int)extra.getColumnIndex());
+                Assertions.assertEquals("批注的内容", extra.getText());
+                Assertions.assertEquals(4, (int)extra.getRowIndex());
+                Assertions.assertEquals(0, (int)extra.getColumnIndex());
                 break;
             case HYPERLINK:
                 if ("Sheet1!A1".equals(extra.getText())) {
-                    Assert.assertEquals(1, (int)extra.getRowIndex());
-                    Assert.assertEquals(0, (int)extra.getColumnIndex());
+                    Assertions.assertEquals(1, (int)extra.getRowIndex());
+                    Assertions.assertEquals(0, (int)extra.getColumnIndex());
                 } else if ("Sheet2!A1".equals(extra.getText())) {
-                    Assert.assertEquals(2, (int)extra.getFirstRowIndex());
-                    Assert.assertEquals(0, (int)extra.getFirstColumnIndex());
-                    Assert.assertEquals(3, (int)extra.getLastRowIndex());
-                    Assert.assertEquals(1, (int)extra.getLastColumnIndex());
+                    Assertions.assertEquals(2, (int)extra.getFirstRowIndex());
+                    Assertions.assertEquals(0, (int)extra.getFirstColumnIndex());
+                    Assertions.assertEquals(3, (int)extra.getLastRowIndex());
+                    Assertions.assertEquals(1, (int)extra.getLastColumnIndex());
                 } else {
-                    Assert.fail("Unknown hyperlink!");
+                    Assertions.fail("Unknown hyperlink!");
                 }
                 break;
             case MERGE:
-                Assert.assertEquals(5, (int)extra.getFirstRowIndex());
-                Assert.assertEquals(0, (int)extra.getFirstColumnIndex());
-                Assert.assertEquals(6, (int)extra.getLastRowIndex());
-                Assert.assertEquals(1, (int)extra.getLastColumnIndex());
+                Assertions.assertEquals(5, (int)extra.getFirstRowIndex());
+                Assertions.assertEquals(0, (int)extra.getFirstColumnIndex());
+                Assertions.assertEquals(6, (int)extra.getLastRowIndex());
+                Assertions.assertEquals(1, (int)extra.getLastColumnIndex());
                 break;
             default:
         }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/extra/ExtraDataTest.java

@@ -2,12 +2,6 @@ package com.alibaba.easyexcel.test.core.extra;
 
 import java.io.File;
 
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.context.AnalysisContext;
@@ -16,6 +10,12 @@ import com.alibaba.excel.metadata.CellExtra;
 import com.alibaba.excel.read.listener.ReadListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -26,7 +26,7 @@ public class ExtraDataTest {
 
     private static File extraRelationships;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file03 = TestFileUtil.readFile("extra" + File.separator + "extra.xls");
         file07 = TestFileUtil.readFile("extra" + File.separator + "extra.xlsx");
@@ -60,13 +60,13 @@ public class ExtraDataTest {
                     switch (extra.getType()) {
                         case HYPERLINK:
                             if ("222222222".equals(extra.getText())) {
-                                Assert.assertEquals(1, (int)extra.getRowIndex());
-                                Assert.assertEquals(0, (int)extra.getColumnIndex());
+                                Assertions.assertEquals(1, (int)extra.getRowIndex());
+                                Assertions.assertEquals(0, (int)extra.getColumnIndex());
                             } else if ("333333333333".equals(extra.getText())) {
-                                Assert.assertEquals(1, (int)extra.getRowIndex());
-                                Assert.assertEquals(1, (int)extra.getColumnIndex());
+                                Assertions.assertEquals(1, (int)extra.getRowIndex());
+                                Assertions.assertEquals(1, (int)extra.getColumnIndex());
                             } else {
-                                Assert.fail("Unknown hyperlink!");
+                                Assertions.fail("Unknown hyperlink!");
                             }
                             break;
                         default:

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/fill/FillDataTest.java

@@ -16,16 +16,16 @@ import com.alibaba.excel.write.metadata.WriteSheet;
 import com.alibaba.excel.write.metadata.fill.FillConfig;
 import com.alibaba.excel.write.metadata.fill.FillWrapper;
 
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class FillDataTest {
 
     private static File file07;
@@ -51,7 +51,7 @@ public class FillDataTest {
     private static File fileComposite03;
     private static File compositeFillTemplate03;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("fill07.xlsx");
         file03 = TestFileUtil.createNewFile("fill03.xls");
@@ -89,9 +89,9 @@ public class FillDataTest {
 
     @Test
     public void t03FillCsv() {
-        ExcelGenerateException excelGenerateException = Assert.assertThrows(ExcelGenerateException.class,
+        ExcelGenerateException excelGenerateException = Assertions.assertThrows(ExcelGenerateException.class,
             () -> fill(fileCsv, simpleTemplateCsv));
-        Assert.assertEquals("csv cannot use template.", excelGenerateException.getMessage());
+        Assertions.assertEquals("csv cannot use template.", excelGenerateException.getMessage());
     }
 
     @Test
@@ -159,11 +159,11 @@ public class FillDataTest {
 
         List<Object> list = EasyExcel.read(file).ignoreEmptyRow(false).sheet().headRowNumber(0).doReadSync();
         Map<String, String> map0 = (Map<String, String>)list.get(0);
-        Assert.assertEquals("张三", map0.get(21));
+        Assertions.assertEquals("张三", map0.get(21));
         Map<String, String> map27 = (Map<String, String>)list.get(27);
-        Assert.assertEquals("张三", map27.get(0));
+        Assertions.assertEquals("张三", map27.get(0));
         Map<String, String> map29 = (Map<String, String>)list.get(29);
-        Assert.assertEquals("张三", map29.get(3));
+        Assertions.assertEquals("张三", map29.get(3));
     }
 
     private void horizontalFill(File file, File template) {
@@ -179,9 +179,9 @@ public class FillDataTest {
         }
 
         List<Object> list = EasyExcel.read(file).sheet().headRowNumber(0).doReadSync();
-        Assert.assertEquals(list.size(), 5L);
+        Assertions.assertEquals(list.size(), 5L);
         Map<String, String> map0 = (Map<String, String>)list.get(0);
-        Assert.assertEquals("张三", map0.get(2));
+        Assertions.assertEquals("张三", map0.get(2));
     }
 
     private void complexFill(File file, File template) {
@@ -196,9 +196,9 @@ public class FillDataTest {
             excelWriter.fill(map, writeSheet);
         }
         List<Object> list = EasyExcel.read(file).sheet().headRowNumber(3).doReadSync();
-        Assert.assertEquals(list.size(), 21L);
+        Assertions.assertEquals(list.size(), 21L);
         Map<String, String> map19 = (Map<String, String>)list.get(19);
-        Assert.assertEquals("张三", map19.get(0));
+        Assertions.assertEquals("张三", map19.get(0));
     }
 
     private void fill(File file, File template) {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/fill/annotation/FillAnnotationDataTest.java

@@ -22,17 +22,17 @@ import org.apache.poi.ss.util.CellRangeAddress;
 import org.apache.poi.xssf.usermodel.XSSFPicture;
 import org.apache.poi.xssf.usermodel.XSSFShape;
 import org.apache.poi.xssf.usermodel.XSSFSheet;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 import org.openxmlformats.schemas.drawingml.x2006.spreadsheetDrawing.CTMarker;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class FillAnnotationDataTest {
 
     private static File file07;
@@ -40,7 +40,7 @@ public class FillAnnotationDataTest {
     private static File fileTemplate07;
     private static File fileTemplate03;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("fillAnnotation07.xlsx");
         file03 = TestFileUtil.createNewFile("fillAnnotation03.xls");
@@ -65,14 +65,14 @@ public class FillAnnotationDataTest {
             Sheet sheet = workbook.getSheetAt(0);
 
             Row row1 = sheet.getRow(1);
-            Assert.assertEquals(2000, row1.getHeight(), 0);
+            Assertions.assertEquals(2000, row1.getHeight(), 0);
             Cell cell10 = row1.getCell(0);
             Date date = cell10.getDateCellValue();
-            Assert.assertEquals(DateUtils.parseDate("2020-01-01 01:01:01").getTime(), date.getTime());
+            Assertions.assertEquals(DateUtils.parseDate("2020-01-01 01:01:01").getTime(), date.getTime());
             String dataFormatString = cell10.getCellStyle().getDataFormatString();
-            Assert.assertEquals("yyyy年MM月dd日HH时mm分ss秒", dataFormatString);
+            Assertions.assertEquals("yyyy年MM月dd日HH时mm分ss秒", dataFormatString);
             Cell cell11 = row1.getCell(1);
-            Assert.assertEquals(99.99, cell11.getNumericCellValue(), 2);
+            Assertions.assertEquals(99.99, cell11.getNumericCellValue(), 2);
             boolean hasMerge = false;
             for (CellRangeAddress mergedRegion : sheet.getMergedRegions()) {
                 if (mergedRegion.getFirstRow() == 1 && mergedRegion.getLastRow() == 1
@@ -81,25 +81,25 @@ public class FillAnnotationDataTest {
                     break;
                 }
             }
-            Assert.assertTrue(hasMerge);
+            Assertions.assertTrue(hasMerge);
             if (sheet instanceof XSSFSheet) {
                 XSSFSheet xssfSheet = (XSSFSheet)sheet;
                 List<XSSFShape> shapeList = xssfSheet.getDrawingPatriarch().getShapes();
                 XSSFShape shape0 = shapeList.get(0);
-                Assert.assertTrue(shape0 instanceof XSSFPicture);
+                Assertions.assertTrue(shape0 instanceof XSSFPicture);
                 XSSFPicture picture0 = (XSSFPicture)shape0;
                 CTMarker ctMarker0 = picture0.getPreferredSize().getFrom();
-                Assert.assertEquals(1, ctMarker0.getRow());
-                Assert.assertEquals(4, ctMarker0.getCol());
+                Assertions.assertEquals(1, ctMarker0.getRow());
+                Assertions.assertEquals(4, ctMarker0.getCol());
             } else {
                 HSSFSheet hssfSheet = (HSSFSheet)sheet;
                 List<HSSFShape> shapeList = hssfSheet.getDrawingPatriarch().getChildren();
                 HSSFShape shape0 = shapeList.get(0);
-                Assert.assertTrue(shape0 instanceof HSSFPicture);
+                Assertions.assertTrue(shape0 instanceof HSSFPicture);
                 HSSFPicture picture0 = (HSSFPicture)shape0;
                 HSSFClientAnchor anchor = (HSSFClientAnchor)picture0.getAnchor();
-                Assert.assertEquals(1, anchor.getRow1());
-                Assert.assertEquals(4, anchor.getCol1());
+                Assertions.assertEquals(1, anchor.getRow1());
+                Assertions.assertEquals(4, anchor.getCol1());
             }
         }
     }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/fill/style/FillStyleAnnotatedTest.java

@@ -25,16 +25,16 @@ import org.apache.poi.xssf.usermodel.XSSFCell;
 import org.apache.poi.xssf.usermodel.XSSFRow;
 import org.apache.poi.xssf.usermodel.XSSFSheet;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class FillStyleAnnotatedTest {
 
     private static File FillStyleAnnotated07;
@@ -42,7 +42,7 @@ public class FillStyleAnnotatedTest {
     private static File fileStyleTemplate07;
     private static File fileStyleTemplate03;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         FillStyleAnnotated07 = TestFileUtil.createNewFile("FillStyleAnnotated07.xlsx");
         FillStyleAnnotated03 = TestFileUtil.createNewFile("FillStyleAnnotated03.xls");
@@ -61,46 +61,47 @@ public class FillStyleAnnotatedTest {
 
     private void t01Fill07check(XSSFRow row) {
         XSSFCell cell0 = row.getCell(0);
-        Assert.assertEquals("张三", cell0.getStringCellValue());
-        Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFFFF00", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF808000", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell0.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("张三", cell0.getStringCellValue());
+        Assertions.assertEquals(49, cell0.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFFFF00", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF808000", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell0.getCellStyle().getFont().getBold());
 
         XSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
-        Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF0000", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF800000", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell1.getCellStyle().getFont().getBold());
+        Assertions.assertEquals(5.2, cell1.getNumericCellValue(), 1);
+        Assertions.assertEquals(0, cell1.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF0000", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF800000", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell1.getCellStyle().getFont().getBold());
 
         XSSFCell cell2 = row.getCell(2);
-        Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
-        Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("FF008000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF003300", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell2.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("2020-01-01 01:01:01",
+            DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
+        Assertions.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
+        Assertions.assertEquals("FF008000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF003300", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell2.getCellStyle().getFont().getBold());
 
         XSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
-        Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell3.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
+        Assertions.assertEquals(0, cell3.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell3.getCellStyle().getFont().getBold());
 
         XSSFCell cell4 = row.getCell(4);
-        Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
-        Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFC00000", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF000000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertFalse(cell4.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
+        Assertions.assertEquals(0, cell4.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFC00000", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF000000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertFalse(cell4.getCellStyle().getFont().getBold());
 
         XSSFCell cell5 = row.getCell(5);
-        Assert.assertEquals("空", cell5.getStringCellValue());
-        Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFF79646", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF8064A2", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertFalse(cell5.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("空", cell5.getStringCellValue());
+        Assertions.assertEquals(0, cell5.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFF79646", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF8064A2", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertFalse(cell5.getCellStyle().getFont().getBold());
     }
 
     @Test
@@ -114,150 +115,153 @@ public class FillStyleAnnotatedTest {
 
     private void t02Fill03check(HSSFWorkbook workbook, HSSFRow row) {
         HSSFCell cell0 = row.getCell(0);
-        Assert.assertEquals("张三", cell0.getStringCellValue());
-        Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:FFFF:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:8080:0", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("张三", cell0.getStringCellValue());
+        Assertions.assertEquals(49, cell0.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:FFFF:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:8080:0", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
-        Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:0:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:0:0", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals(5.2, cell1.getNumericCellValue(), 1);
+        Assertions.assertEquals(0, cell1.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:0:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:0:0", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell1.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell1.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell2 = row.getCell(2);
-        Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
-        Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("0:8080:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:3333:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook).getHexString());
-        Assert.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertEquals("2020-01-01 01:01:01",
+            DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
+        Assertions.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
+        Assertions.assertEquals("0:8080:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("0:3333:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+            .getHexString());
+        Assertions.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
-        Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
+        Assertions.assertEquals(0, cell3.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell4 = row.getCell(4);
-        Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
-        Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("9999:3333:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("3333:3333:3333", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
+        Assertions.assertEquals(0, cell4.getCellStyle().getDataFormat());
+        Assertions.assertEquals("9999:3333:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("3333:3333:3333", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertFalse(cell4.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertFalse(cell4.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell5 = row.getCell(5);
-        Assert.assertEquals("空", cell5.getStringCellValue());
-        Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("9999:3333:0", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("CCCC:9999:FFFF", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("空", cell5.getStringCellValue());
+        Assertions.assertEquals(0, cell5.getCellStyle().getDataFormat());
+        Assertions.assertEquals("9999:3333:0", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("CCCC:9999:FFFF", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertFalse(cell5.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertFalse(cell5.getCellStyle().getFont(workbook).getBold());
     }
 
     private void fill(File file, File template) throws Exception {
         EasyExcel.write(file, FillStyleAnnotatedData.class).withTemplate(template).sheet().doFill(data());
     }
 
-
     private void t11FillStyleHandler07check(XSSFRow row) {
         XSSFCell cell0 = row.getCell(0);
-        Assert.assertEquals("张三", cell0.getStringCellValue());
-        Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFFFF00", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF808000", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell0.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("张三", cell0.getStringCellValue());
+        Assertions.assertEquals(49, cell0.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFFFF00", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF808000", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell0.getCellStyle().getFont().getBold());
 
         XSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals("5", cell1.getStringCellValue());
-        Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF0000", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF800000", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell1.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("5", cell1.getStringCellValue());
+        Assertions.assertEquals(0, cell1.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF0000", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF800000", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell1.getCellStyle().getFont().getBold());
 
         XSSFCell cell2 = row.getCell(2);
-        Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
-        Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("FF008000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF003300", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell2.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("2020-01-01 01:01:01",
+            DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
+        Assertions.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
+        Assertions.assertEquals("FF008000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF003300", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell2.getCellStyle().getFont().getBold());
 
         XSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5岁了", cell3.getStringCellValue());
-        Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("FF0000FF", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF000080", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell3.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("张三今年5岁了", cell3.getStringCellValue());
+        Assertions.assertEquals(0, cell3.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FF0000FF", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF000080", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell3.getCellStyle().getFont().getBold());
 
         XSSFCell cell4 = row.getCell(4);
-        Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
-        Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFFFF00", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF808000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell4.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
+        Assertions.assertEquals(0, cell4.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFFFF00", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF808000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell4.getCellStyle().getFont().getBold());
 
         XSSFCell cell5 = row.getCell(5);
-        Assert.assertEquals("空", cell5.getStringCellValue());
-        Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("FF008080", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF003366", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell5.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("空", cell5.getStringCellValue());
+        Assertions.assertEquals(0, cell5.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FF008080", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF003366", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell5.getCellStyle().getFont().getBold());
     }
 
-
     private void t12FillStyleHandler03check(HSSFWorkbook workbook, HSSFRow row) {
         HSSFCell cell0 = row.getCell(0);
-        Assert.assertEquals("张三", cell0.getStringCellValue());
-        Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:FFFF:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:8080:0", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("张三", cell0.getStringCellValue());
+        Assertions.assertEquals(49, cell0.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:FFFF:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:8080:0", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals("5", cell1.getStringCellValue());
-        Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:0:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:0:0", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("5", cell1.getStringCellValue());
+        Assertions.assertEquals(0, cell1.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:0:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:0:0", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell1.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell1.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell2 = row.getCell(2);
-        Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
-        Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("0:8080:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:3333:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook).getHexString());
-        Assert.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertEquals("2020-01-01 01:01:01",
+            DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
+        Assertions.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
+        Assertions.assertEquals("0:8080:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("0:3333:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+            .getHexString());
+        Assertions.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5岁了", cell3.getStringCellValue());
-        Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("0:0:FFFF", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:0:8080", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("张三今年5岁了", cell3.getStringCellValue());
+        Assertions.assertEquals(0, cell3.getCellStyle().getDataFormat());
+        Assertions.assertEquals("0:0:FFFF", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("0:0:8080", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell4 = row.getCell(4);
-        Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
-        Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:FFFF:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:8080:0", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
+        Assertions.assertEquals(0, cell4.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:FFFF:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:8080:0", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell4.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell4.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell5 = row.getCell(5);
-        Assert.assertEquals("空", cell5.getStringCellValue());
-        Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("0:8080:8080", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:3333:6666", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("空", cell5.getStringCellValue());
+        Assertions.assertEquals(0, cell5.getCellStyle().getDataFormat());
+        Assertions.assertEquals("0:8080:8080", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("0:3333:6666", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell5.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell5.getCellStyle().getFont(workbook).getBold());
     }
 
     private void fillStyleHandler(File file, File template) throws Exception {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/fill/style/FillStyleDataTest.java

@@ -24,16 +24,16 @@ import org.apache.poi.xssf.usermodel.XSSFCell;
 import org.apache.poi.xssf.usermodel.XSSFRow;
 import org.apache.poi.xssf.usermodel.XSSFSheet;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class FillStyleDataTest {
 
     private static File fileStyle07;
@@ -43,7 +43,7 @@ public class FillStyleDataTest {
     private static File fileStyleTemplate07;
     private static File fileStyleTemplate03;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         fileStyle07 = TestFileUtil.createNewFile("fileStyle07.xlsx");
         fileStyle03 = TestFileUtil.createNewFile("fileStyle03.xls");
@@ -64,46 +64,47 @@ public class FillStyleDataTest {
 
     private void t01Fill07check(XSSFRow row) {
         XSSFCell cell0 = row.getCell(0);
-        Assert.assertEquals("张三", cell0.getStringCellValue());
-        Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("FF00B050", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF7030A0", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell0.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("张三", cell0.getStringCellValue());
+        Assertions.assertEquals(49, cell0.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FF00B050", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF7030A0", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell0.getCellStyle().getFont().getBold());
 
         XSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
-        Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("FF92D050", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF4BACC6", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertFalse(cell1.getCellStyle().getFont().getBold());
+        Assertions.assertEquals(5.2, cell1.getNumericCellValue(), 1);
+        Assertions.assertEquals(0, cell1.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FF92D050", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF4BACC6", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertFalse(cell1.getCellStyle().getFont().getBold());
 
         XSSFCell cell2 = row.getCell(2);
-        Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
-        Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("FFFFC000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FFC0504D", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell2.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("2020-01-01 01:01:01",
+            DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
+        Assertions.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
+        Assertions.assertEquals("FFFFC000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FFC0504D", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell2.getCellStyle().getFont().getBold());
 
         XSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
-        Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell3.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
+        Assertions.assertEquals(0, cell3.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell3.getCellStyle().getFont().getBold());
 
         XSSFCell cell4 = row.getCell(4);
-        Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
-        Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFC00000", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF000000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertFalse(cell4.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
+        Assertions.assertEquals(0, cell4.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFC00000", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF000000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertFalse(cell4.getCellStyle().getFont().getBold());
 
         XSSFCell cell5 = row.getCell(5);
-        Assert.assertEquals("空", cell5.getStringCellValue());
-        Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFF79646", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF8064A2", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertFalse(cell5.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("空", cell5.getStringCellValue());
+        Assertions.assertEquals(0, cell5.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFF79646", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF8064A2", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertFalse(cell5.getCellStyle().getFont().getBold());
     }
 
     @Test
@@ -117,51 +118,53 @@ public class FillStyleDataTest {
 
     private void t02Fill03check(HSSFWorkbook workbook, HSSFRow row) {
         HSSFCell cell0 = row.getCell(0);
-        Assert.assertEquals("张三", cell0.getStringCellValue());
-        Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("0:8080:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:0:8080", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("张三", cell0.getStringCellValue());
+        Assertions.assertEquals(49, cell0.getCellStyle().getDataFormat());
+        Assertions.assertEquals("0:8080:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:0:8080", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
-        Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("9999:CCCC:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:8080:8080", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals(5.2, cell1.getNumericCellValue(), 1);
+        Assertions.assertEquals(0, cell1.getCellStyle().getDataFormat());
+        Assertions.assertEquals("9999:CCCC:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("0:8080:8080", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertFalse(cell1.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertFalse(cell1.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell2 = row.getCell(2);
-        Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
-        Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("FFFF:CCCC:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:0:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook).getHexString());
-        Assert.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertEquals("2020-01-01 01:01:01",
+            DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
+        Assertions.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
+        Assertions.assertEquals("FFFF:CCCC:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:0:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+            .getHexString());
+        Assertions.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
-        Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
+        Assertions.assertEquals(0, cell3.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell4 = row.getCell(4);
-        Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
-        Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("9999:3333:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("3333:3333:3333", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
+        Assertions.assertEquals(0, cell4.getCellStyle().getDataFormat());
+        Assertions.assertEquals("9999:3333:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("3333:3333:3333", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertFalse(cell4.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertFalse(cell4.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell5 = row.getCell(5);
-        Assert.assertEquals("空", cell5.getStringCellValue());
-        Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("9999:3333:0", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("CCCC:9999:FFFF", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("空", cell5.getStringCellValue());
+        Assertions.assertEquals(0, cell5.getCellStyle().getDataFormat());
+        Assertions.assertEquals("9999:3333:0", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("CCCC:9999:FFFF", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertFalse(cell5.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertFalse(cell5.getCellStyle().getFont(workbook).getBold());
     }
 
     private void fill(File file, File template) throws Exception {
@@ -179,46 +182,47 @@ public class FillStyleDataTest {
 
     private void t11FillStyleHandler07check(XSSFRow row) {
         XSSFCell cell0 = row.getCell(0);
-        Assert.assertEquals("张三", cell0.getStringCellValue());
-        Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFFFF00", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF808000", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell0.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("张三", cell0.getStringCellValue());
+        Assertions.assertEquals(49, cell0.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFFFF00", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF808000", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell0.getCellStyle().getFont().getBold());
 
         XSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
-        Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF0000", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF800000", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell1.getCellStyle().getFont().getBold());
+        Assertions.assertEquals(5.2, cell1.getNumericCellValue(), 1);
+        Assertions.assertEquals(0, cell1.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF0000", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF800000", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell1.getCellStyle().getFont().getBold());
 
         XSSFCell cell2 = row.getCell(2);
-        Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
-        Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("FF008000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF003300", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell2.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("2020-01-01 01:01:01",
+            DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
+        Assertions.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
+        Assertions.assertEquals("FF008000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF003300", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell2.getCellStyle().getFont().getBold());
 
         XSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
-        Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell3.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
+        Assertions.assertEquals(0, cell3.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertTrue(cell3.getCellStyle().getFont().getBold());
 
         XSSFCell cell4 = row.getCell(4);
-        Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
-        Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFC00000", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF000000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertFalse(cell4.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
+        Assertions.assertEquals(0, cell4.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFC00000", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF000000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertFalse(cell4.getCellStyle().getFont().getBold());
 
         XSSFCell cell5 = row.getCell(5);
-        Assert.assertEquals("空", cell5.getStringCellValue());
-        Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFF79646", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF8064A2", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertFalse(cell5.getCellStyle().getFont().getBold());
+        Assertions.assertEquals("空", cell5.getStringCellValue());
+        Assertions.assertEquals(0, cell5.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFF79646", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assertions.assertEquals("FF8064A2", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assertions.assertFalse(cell5.getCellStyle().getFont().getBold());
     }
 
     @Test
@@ -232,51 +236,53 @@ public class FillStyleDataTest {
 
     private void t12FillStyleHandler03check(HSSFWorkbook workbook, HSSFRow row) {
         HSSFCell cell0 = row.getCell(0);
-        Assert.assertEquals("张三", cell0.getStringCellValue());
-        Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:FFFF:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:8080:0", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("张三", cell0.getStringCellValue());
+        Assertions.assertEquals(49, cell0.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:FFFF:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:8080:0", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
-        Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:0:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:0:0", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals(5.2, cell1.getNumericCellValue(), 1);
+        Assertions.assertEquals(0, cell1.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:0:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("8080:0:0", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell1.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell1.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell2 = row.getCell(2);
-        Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
-        Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("0:8080:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:3333:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook).getHexString());
-        Assert.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertEquals("2020-01-01 01:01:01",
+            DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
+        Assertions.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
+        Assertions.assertEquals("0:8080:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("0:3333:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+            .getHexString());
+        Assertions.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
-        Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
+        Assertions.assertEquals(0, cell3.getCellStyle().getDataFormat());
+        Assertions.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell4 = row.getCell(4);
-        Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
-        Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("9999:3333:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("3333:3333:3333", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
+        Assertions.assertEquals(0, cell4.getCellStyle().getDataFormat());
+        Assertions.assertEquals("9999:3333:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("3333:3333:3333", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertFalse(cell4.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertFalse(cell4.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell5 = row.getCell(5);
-        Assert.assertEquals("空", cell5.getStringCellValue());
-        Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("9999:3333:0", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("CCCC:9999:FFFF", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assertions.assertEquals("空", cell5.getStringCellValue());
+        Assertions.assertEquals(0, cell5.getCellStyle().getDataFormat());
+        Assertions.assertEquals("9999:3333:0", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assertions.assertEquals("CCCC:9999:FFFF", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertFalse(cell5.getCellStyle().getFont(workbook).getBold());
+        Assertions.assertFalse(cell5.getCellStyle().getFont(workbook).getBold());
     }
 
     private void fillStyleHandler(File file, File template) throws Exception {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/handler/WriteHandler.java

@@ -14,7 +14,7 @@ import com.alibaba.excel.write.metadata.holder.WriteWorkbookHolder;
 
 import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.ss.usermodel.Row;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 
 /**
  * @author JiaJu Zhuang
@@ -38,18 +38,18 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
     public void beforeCellCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Row row,
         Head head, Integer columnIndex, Integer relativeRowIndex, Boolean isHead) {
         if (isHead) {
-            Assert.assertEquals(0L, beforeCellCreate);
-            Assert.assertEquals(0L, afterCellCreate);
-            Assert.assertEquals(0L, afterCellDataConverted);
-            Assert.assertEquals(0L, afterCellDispose);
-            Assert.assertEquals(1L, beforeRowCreate);
-            Assert.assertEquals(1L, afterRowCreate);
-            Assert.assertEquals(0L, afterRowDispose);
-            Assert.assertEquals(1L, beforeSheetCreate);
-            Assert.assertEquals(1L, afterSheetCreate);
-            Assert.assertEquals(1L, beforeWorkbookCreate);
-            Assert.assertEquals(1L, afterWorkbookCreate);
-            Assert.assertEquals(0L, afterWorkbookDispose);
+            Assertions.assertEquals(0L, beforeCellCreate);
+            Assertions.assertEquals(0L, afterCellCreate);
+            Assertions.assertEquals(0L, afterCellDataConverted);
+            Assertions.assertEquals(0L, afterCellDispose);
+            Assertions.assertEquals(1L, beforeRowCreate);
+            Assertions.assertEquals(1L, afterRowCreate);
+            Assertions.assertEquals(0L, afterRowDispose);
+            Assertions.assertEquals(1L, beforeSheetCreate);
+            Assertions.assertEquals(1L, afterSheetCreate);
+            Assertions.assertEquals(1L, beforeWorkbookCreate);
+            Assertions.assertEquals(1L, afterWorkbookCreate);
+            Assertions.assertEquals(0L, afterWorkbookDispose);
             beforeCellCreate++;
         }
 
@@ -59,18 +59,18 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
     public void afterCellCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Cell cell,
         Head head, Integer relativeRowIndex, Boolean isHead) {
         if (isHead) {
-            Assert.assertEquals(1L, beforeCellCreate);
-            Assert.assertEquals(0L, afterCellCreate);
-            Assert.assertEquals(0L, afterCellDataConverted);
-            Assert.assertEquals(0L, afterCellDispose);
-            Assert.assertEquals(1L, beforeRowCreate);
-            Assert.assertEquals(1L, afterRowCreate);
-            Assert.assertEquals(0L, afterRowDispose);
-            Assert.assertEquals(1L, beforeSheetCreate);
-            Assert.assertEquals(1L, afterSheetCreate);
-            Assert.assertEquals(1L, beforeWorkbookCreate);
-            Assert.assertEquals(1L, afterWorkbookCreate);
-            Assert.assertEquals(0L, afterWorkbookDispose);
+            Assertions.assertEquals(1L, beforeCellCreate);
+            Assertions.assertEquals(0L, afterCellCreate);
+            Assertions.assertEquals(0L, afterCellDataConverted);
+            Assertions.assertEquals(0L, afterCellDispose);
+            Assertions.assertEquals(1L, beforeRowCreate);
+            Assertions.assertEquals(1L, afterRowCreate);
+            Assertions.assertEquals(0L, afterRowDispose);
+            Assertions.assertEquals(1L, beforeSheetCreate);
+            Assertions.assertEquals(1L, afterSheetCreate);
+            Assertions.assertEquals(1L, beforeWorkbookCreate);
+            Assertions.assertEquals(1L, afterWorkbookCreate);
+            Assertions.assertEquals(0L, afterWorkbookDispose);
             afterCellCreate++;
         }
     }
@@ -78,18 +78,18 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
     @Override
     public void afterCellDataConverted(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
         WriteCellData<?> cellData, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {
-        Assert.assertEquals(1L, beforeCellCreate);
-        Assert.assertEquals(1L, afterCellCreate);
-        Assert.assertEquals(0L, afterCellDataConverted);
-        Assert.assertEquals(1, afterCellDispose);
-        Assert.assertEquals(1L, beforeRowCreate);
-        Assert.assertEquals(1L, afterRowCreate);
-        Assert.assertEquals(1L, afterRowDispose);
-        Assert.assertEquals(1L, beforeSheetCreate);
-        Assert.assertEquals(1L, afterSheetCreate);
-        Assert.assertEquals(1L, beforeWorkbookCreate);
-        Assert.assertEquals(1L, afterWorkbookCreate);
-        Assert.assertEquals(0L, afterWorkbookDispose);
+        Assertions.assertEquals(1L, beforeCellCreate);
+        Assertions.assertEquals(1L, afterCellCreate);
+        Assertions.assertEquals(0L, afterCellDataConverted);
+        Assertions.assertEquals(1, afterCellDispose);
+        Assertions.assertEquals(1L, beforeRowCreate);
+        Assertions.assertEquals(1L, afterRowCreate);
+        Assertions.assertEquals(1L, afterRowDispose);
+        Assertions.assertEquals(1L, beforeSheetCreate);
+        Assertions.assertEquals(1L, afterSheetCreate);
+        Assertions.assertEquals(1L, beforeWorkbookCreate);
+        Assertions.assertEquals(1L, afterWorkbookCreate);
+        Assertions.assertEquals(0L, afterWorkbookDispose);
         afterCellDataConverted++;
     }
 
@@ -97,18 +97,18 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
     public void afterCellDispose(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
         List<WriteCellData<?>> cellDataList, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {
         if (isHead) {
-            Assert.assertEquals(1L, beforeCellCreate);
-            Assert.assertEquals(1L, afterCellCreate);
-            Assert.assertEquals(0L, afterCellDataConverted);
-            Assert.assertEquals(0L, afterCellDispose);
-            Assert.assertEquals(1L, beforeRowCreate);
-            Assert.assertEquals(1L, afterRowCreate);
-            Assert.assertEquals(0L, afterRowDispose);
-            Assert.assertEquals(1L, beforeSheetCreate);
-            Assert.assertEquals(1L, afterSheetCreate);
-            Assert.assertEquals(1L, beforeWorkbookCreate);
-            Assert.assertEquals(1L, afterWorkbookCreate);
-            Assert.assertEquals(0L, afterWorkbookDispose);
+            Assertions.assertEquals(1L, beforeCellCreate);
+            Assertions.assertEquals(1L, afterCellCreate);
+            Assertions.assertEquals(0L, afterCellDataConverted);
+            Assertions.assertEquals(0L, afterCellDispose);
+            Assertions.assertEquals(1L, beforeRowCreate);
+            Assertions.assertEquals(1L, afterRowCreate);
+            Assertions.assertEquals(0L, afterRowDispose);
+            Assertions.assertEquals(1L, beforeSheetCreate);
+            Assertions.assertEquals(1L, afterSheetCreate);
+            Assertions.assertEquals(1L, beforeWorkbookCreate);
+            Assertions.assertEquals(1L, afterWorkbookCreate);
+            Assertions.assertEquals(0L, afterWorkbookDispose);
             afterCellDispose++;
         }
     }
@@ -117,18 +117,18 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
     public void beforeRowCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Integer rowIndex,
         Integer relativeRowIndex, Boolean isHead) {
         if (isHead) {
-            Assert.assertEquals(0L, beforeCellCreate);
-            Assert.assertEquals(0L, afterCellCreate);
-            Assert.assertEquals(0L, afterCellDataConverted);
-            Assert.assertEquals(0L, afterCellDispose);
-            Assert.assertEquals(0L, beforeRowCreate);
-            Assert.assertEquals(0L, afterRowCreate);
-            Assert.assertEquals(0L, afterRowDispose);
-            Assert.assertEquals(1L, beforeSheetCreate);
-            Assert.assertEquals(1L, afterSheetCreate);
-            Assert.assertEquals(1L, beforeWorkbookCreate);
-            Assert.assertEquals(1L, afterWorkbookCreate);
-            Assert.assertEquals(0L, afterWorkbookDispose);
+            Assertions.assertEquals(0L, beforeCellCreate);
+            Assertions.assertEquals(0L, afterCellCreate);
+            Assertions.assertEquals(0L, afterCellDataConverted);
+            Assertions.assertEquals(0L, afterCellDispose);
+            Assertions.assertEquals(0L, beforeRowCreate);
+            Assertions.assertEquals(0L, afterRowCreate);
+            Assertions.assertEquals(0L, afterRowDispose);
+            Assertions.assertEquals(1L, beforeSheetCreate);
+            Assertions.assertEquals(1L, afterSheetCreate);
+            Assertions.assertEquals(1L, beforeWorkbookCreate);
+            Assertions.assertEquals(1L, afterWorkbookCreate);
+            Assertions.assertEquals(0L, afterWorkbookDispose);
             beforeRowCreate++;
         }
 
@@ -138,18 +138,18 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
     public void afterRowCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Row row,
         Integer relativeRowIndex, Boolean isHead) {
         if (isHead) {
-            Assert.assertEquals(0L, beforeCellCreate);
-            Assert.assertEquals(0L, afterCellCreate);
-            Assert.assertEquals(0L, afterCellDataConverted);
-            Assert.assertEquals(0L, afterCellDispose);
-            Assert.assertEquals(1L, beforeRowCreate);
-            Assert.assertEquals(0L, afterRowCreate);
-            Assert.assertEquals(0L, afterRowDispose);
-            Assert.assertEquals(1L, beforeSheetCreate);
-            Assert.assertEquals(1L, afterSheetCreate);
-            Assert.assertEquals(1L, beforeWorkbookCreate);
-            Assert.assertEquals(1L, afterWorkbookCreate);
-            Assert.assertEquals(0L, afterWorkbookDispose);
+            Assertions.assertEquals(0L, beforeCellCreate);
+            Assertions.assertEquals(0L, afterCellCreate);
+            Assertions.assertEquals(0L, afterCellDataConverted);
+            Assertions.assertEquals(0L, afterCellDispose);
+            Assertions.assertEquals(1L, beforeRowCreate);
+            Assertions.assertEquals(0L, afterRowCreate);
+            Assertions.assertEquals(0L, afterRowDispose);
+            Assertions.assertEquals(1L, beforeSheetCreate);
+            Assertions.assertEquals(1L, afterSheetCreate);
+            Assertions.assertEquals(1L, beforeWorkbookCreate);
+            Assertions.assertEquals(1L, afterWorkbookCreate);
+            Assertions.assertEquals(0L, afterWorkbookDispose);
             afterRowCreate++;
         }
     }
@@ -158,120 +158,120 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
     public void afterRowDispose(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Row row,
         Integer relativeRowIndex, Boolean isHead) {
         if (isHead) {
-            Assert.assertEquals(1L, beforeCellCreate);
-            Assert.assertEquals(1L, afterCellCreate);
-            Assert.assertEquals(0L, afterCellDataConverted);
-            Assert.assertEquals(1L, afterCellDispose);
-            Assert.assertEquals(1L, beforeRowCreate);
-            Assert.assertEquals(1L, afterRowCreate);
-            Assert.assertEquals(0L, afterRowDispose);
-            Assert.assertEquals(1L, beforeSheetCreate);
-            Assert.assertEquals(1L, afterSheetCreate);
-            Assert.assertEquals(1L, beforeWorkbookCreate);
-            Assert.assertEquals(1L, afterWorkbookCreate);
-            Assert.assertEquals(0L, afterWorkbookDispose);
+            Assertions.assertEquals(1L, beforeCellCreate);
+            Assertions.assertEquals(1L, afterCellCreate);
+            Assertions.assertEquals(0L, afterCellDataConverted);
+            Assertions.assertEquals(1L, afterCellDispose);
+            Assertions.assertEquals(1L, beforeRowCreate);
+            Assertions.assertEquals(1L, afterRowCreate);
+            Assertions.assertEquals(0L, afterRowDispose);
+            Assertions.assertEquals(1L, beforeSheetCreate);
+            Assertions.assertEquals(1L, afterSheetCreate);
+            Assertions.assertEquals(1L, beforeWorkbookCreate);
+            Assertions.assertEquals(1L, afterWorkbookCreate);
+            Assertions.assertEquals(0L, afterWorkbookDispose);
             afterRowDispose++;
         }
     }
 
     @Override
     public void beforeSheetCreate(WriteWorkbookHolder writeWorkbookHolder, WriteSheetHolder writeSheetHolder) {
-        Assert.assertEquals(0L, beforeCellCreate);
-        Assert.assertEquals(0L, afterCellCreate);
-        Assert.assertEquals(0L, afterCellDataConverted);
-        Assert.assertEquals(0L, afterCellDispose);
-        Assert.assertEquals(0L, beforeRowCreate);
-        Assert.assertEquals(0L, afterRowCreate);
-        Assert.assertEquals(0L, afterRowDispose);
-        Assert.assertEquals(0L, beforeSheetCreate);
-        Assert.assertEquals(0L, afterSheetCreate);
-        Assert.assertEquals(1L, beforeWorkbookCreate);
-        Assert.assertEquals(1L, afterWorkbookCreate);
-        Assert.assertEquals(0L, afterWorkbookDispose);
+        Assertions.assertEquals(0L, beforeCellCreate);
+        Assertions.assertEquals(0L, afterCellCreate);
+        Assertions.assertEquals(0L, afterCellDataConverted);
+        Assertions.assertEquals(0L, afterCellDispose);
+        Assertions.assertEquals(0L, beforeRowCreate);
+        Assertions.assertEquals(0L, afterRowCreate);
+        Assertions.assertEquals(0L, afterRowDispose);
+        Assertions.assertEquals(0L, beforeSheetCreate);
+        Assertions.assertEquals(0L, afterSheetCreate);
+        Assertions.assertEquals(1L, beforeWorkbookCreate);
+        Assertions.assertEquals(1L, afterWorkbookCreate);
+        Assertions.assertEquals(0L, afterWorkbookDispose);
         beforeSheetCreate++;
     }
 
     @Override
     public void afterSheetCreate(WriteWorkbookHolder writeWorkbookHolder, WriteSheetHolder writeSheetHolder) {
-        Assert.assertEquals(0L, beforeCellCreate);
-        Assert.assertEquals(0L, afterCellCreate);
-        Assert.assertEquals(0L, afterCellDataConverted);
-        Assert.assertEquals(0L, afterCellDispose);
-        Assert.assertEquals(0L, beforeRowCreate);
-        Assert.assertEquals(0L, afterRowCreate);
-        Assert.assertEquals(0L, afterRowDispose);
-        Assert.assertEquals(1L, beforeSheetCreate);
-        Assert.assertEquals(0L, afterSheetCreate);
-        Assert.assertEquals(1L, beforeWorkbookCreate);
-        Assert.assertEquals(1L, afterWorkbookCreate);
-        Assert.assertEquals(0L, afterWorkbookDispose);
+        Assertions.assertEquals(0L, beforeCellCreate);
+        Assertions.assertEquals(0L, afterCellCreate);
+        Assertions.assertEquals(0L, afterCellDataConverted);
+        Assertions.assertEquals(0L, afterCellDispose);
+        Assertions.assertEquals(0L, beforeRowCreate);
+        Assertions.assertEquals(0L, afterRowCreate);
+        Assertions.assertEquals(0L, afterRowDispose);
+        Assertions.assertEquals(1L, beforeSheetCreate);
+        Assertions.assertEquals(0L, afterSheetCreate);
+        Assertions.assertEquals(1L, beforeWorkbookCreate);
+        Assertions.assertEquals(1L, afterWorkbookCreate);
+        Assertions.assertEquals(0L, afterWorkbookDispose);
         afterSheetCreate++;
     }
 
     @Override
     public void beforeWorkbookCreate() {
-        Assert.assertEquals(0L, beforeCellCreate);
-        Assert.assertEquals(0L, afterCellCreate);
-        Assert.assertEquals(0L, afterCellDataConverted);
-        Assert.assertEquals(0L, afterCellDispose);
-        Assert.assertEquals(0L, beforeRowCreate);
-        Assert.assertEquals(0L, afterRowCreate);
-        Assert.assertEquals(0L, afterRowDispose);
-        Assert.assertEquals(0L, beforeSheetCreate);
-        Assert.assertEquals(0L, afterSheetCreate);
-        Assert.assertEquals(0L, beforeWorkbookCreate);
-        Assert.assertEquals(0L, afterWorkbookCreate);
-        Assert.assertEquals(0L, afterWorkbookDispose);
+        Assertions.assertEquals(0L, beforeCellCreate);
+        Assertions.assertEquals(0L, afterCellCreate);
+        Assertions.assertEquals(0L, afterCellDataConverted);
+        Assertions.assertEquals(0L, afterCellDispose);
+        Assertions.assertEquals(0L, beforeRowCreate);
+        Assertions.assertEquals(0L, afterRowCreate);
+        Assertions.assertEquals(0L, afterRowDispose);
+        Assertions.assertEquals(0L, beforeSheetCreate);
+        Assertions.assertEquals(0L, afterSheetCreate);
+        Assertions.assertEquals(0L, beforeWorkbookCreate);
+        Assertions.assertEquals(0L, afterWorkbookCreate);
+        Assertions.assertEquals(0L, afterWorkbookDispose);
         beforeWorkbookCreate++;
     }
 
     @Override
     public void afterWorkbookCreate(WriteWorkbookHolder writeWorkbookHolder) {
-        Assert.assertEquals(0L, beforeCellCreate);
-        Assert.assertEquals(0L, afterCellCreate);
-        Assert.assertEquals(0L, afterCellDataConverted);
-        Assert.assertEquals(0L, afterCellDispose);
-        Assert.assertEquals(0L, beforeRowCreate);
-        Assert.assertEquals(0L, afterRowCreate);
-        Assert.assertEquals(0L, afterRowDispose);
-        Assert.assertEquals(0L, beforeSheetCreate);
-        Assert.assertEquals(0L, afterSheetCreate);
-        Assert.assertEquals(1L, beforeWorkbookCreate);
-        Assert.assertEquals(0L, afterWorkbookCreate);
-        Assert.assertEquals(0L, afterWorkbookDispose);
+        Assertions.assertEquals(0L, beforeCellCreate);
+        Assertions.assertEquals(0L, afterCellCreate);
+        Assertions.assertEquals(0L, afterCellDataConverted);
+        Assertions.assertEquals(0L, afterCellDispose);
+        Assertions.assertEquals(0L, beforeRowCreate);
+        Assertions.assertEquals(0L, afterRowCreate);
+        Assertions.assertEquals(0L, afterRowDispose);
+        Assertions.assertEquals(0L, beforeSheetCreate);
+        Assertions.assertEquals(0L, afterSheetCreate);
+        Assertions.assertEquals(1L, beforeWorkbookCreate);
+        Assertions.assertEquals(0L, afterWorkbookCreate);
+        Assertions.assertEquals(0L, afterWorkbookDispose);
         afterWorkbookCreate++;
     }
 
     @Override
     public void afterWorkbookDispose(WriteWorkbookHolder writeWorkbookHolder) {
-        Assert.assertEquals(1L, beforeCellCreate);
-        Assert.assertEquals(1L, afterCellCreate);
-        Assert.assertEquals(1L, afterCellDataConverted);
-        Assert.assertEquals(1L, afterCellDispose);
-        Assert.assertEquals(1L, beforeRowCreate);
-        Assert.assertEquals(1L, afterRowCreate);
-        Assert.assertEquals(1L, afterRowDispose);
-        Assert.assertEquals(1L, beforeSheetCreate);
-        Assert.assertEquals(1L, afterSheetCreate);
-        Assert.assertEquals(1L, beforeWorkbookCreate);
-        Assert.assertEquals(1L, afterWorkbookCreate);
-        Assert.assertEquals(0L, afterWorkbookDispose);
+        Assertions.assertEquals(1L, beforeCellCreate);
+        Assertions.assertEquals(1L, afterCellCreate);
+        Assertions.assertEquals(1L, afterCellDataConverted);
+        Assertions.assertEquals(1L, afterCellDispose);
+        Assertions.assertEquals(1L, beforeRowCreate);
+        Assertions.assertEquals(1L, afterRowCreate);
+        Assertions.assertEquals(1L, afterRowDispose);
+        Assertions.assertEquals(1L, beforeSheetCreate);
+        Assertions.assertEquals(1L, afterSheetCreate);
+        Assertions.assertEquals(1L, beforeWorkbookCreate);
+        Assertions.assertEquals(1L, afterWorkbookCreate);
+        Assertions.assertEquals(0L, afterWorkbookDispose);
         afterWorkbookDispose++;
 
     }
 
     public void afterAll() {
-        Assert.assertEquals(1L, beforeCellCreate);
-        Assert.assertEquals(1L, afterCellCreate);
-        Assert.assertEquals(1L, afterCellDataConverted);
-        Assert.assertEquals(1L, afterCellDispose);
-        Assert.assertEquals(1L, beforeRowCreate);
-        Assert.assertEquals(1L, afterRowCreate);
-        Assert.assertEquals(1L, afterRowDispose);
-        Assert.assertEquals(1L, beforeSheetCreate);
-        Assert.assertEquals(1L, afterSheetCreate);
-        Assert.assertEquals(1L, beforeWorkbookCreate);
-        Assert.assertEquals(1L, afterWorkbookCreate);
-        Assert.assertEquals(1L, afterWorkbookDispose);
+        Assertions.assertEquals(1L, beforeCellCreate);
+        Assertions.assertEquals(1L, afterCellCreate);
+        Assertions.assertEquals(1L, afterCellDataConverted);
+        Assertions.assertEquals(1L, afterCellDispose);
+        Assertions.assertEquals(1L, beforeRowCreate);
+        Assertions.assertEquals(1L, afterRowCreate);
+        Assertions.assertEquals(1L, afterRowDispose);
+        Assertions.assertEquals(1L, beforeSheetCreate);
+        Assertions.assertEquals(1L, afterSheetCreate);
+        Assertions.assertEquals(1L, beforeWorkbookCreate);
+        Assertions.assertEquals(1L, afterWorkbookCreate);
+        Assertions.assertEquals(1L, afterWorkbookDispose);
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/handler/WriteHandlerTest.java

@@ -7,24 +7,22 @@ import java.util.List;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
- *
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class WriteHandlerTest {
 
     private static File file07;
     private static File file03;
     private static File fileCsv;
 
-
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("writeHandler07.xlsx");
         file03 = TestFileUtil.createNewFile("writeHandler03.xls");
@@ -46,7 +44,6 @@ public class WriteHandlerTest {
         workbookWrite(fileCsv);
     }
 
-
     @Test
     public void t11SheetWrite07() throws Exception {
         sheetWrite(file07);
@@ -72,7 +69,6 @@ public class WriteHandlerTest {
         tableWrite(file03);
     }
 
-
     @Test
     public void t23TableWriteCsv() throws Exception {
         tableWrite(fileCsv);

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/head/ComplexDataListener.java

@@ -3,14 +3,14 @@ package com.alibaba.easyexcel.test.core.head;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -25,9 +25,9 @@ public class ComplexDataListener extends AnalysisEventListener<ComplexHeadData>
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         ComplexHeadData data = list.get(0);
-        Assert.assertEquals(data.getString4(), "字符串4");
+        Assertions.assertEquals(data.getString4(), "字符串4");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/head/ComplexHeadDataTest.java

@@ -7,15 +7,15 @@ import java.util.List;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class ComplexHeadDataTest {
 
     private static File file07;
@@ -25,7 +25,7 @@ public class ComplexHeadDataTest {
     private static File file03AutomaticMergeHead;
     private static File fileCsvAutomaticMergeHead;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("complexHead07.xlsx");
         file03 = TestFileUtil.createNewFile("complexHead03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/head/ListHeadDataListener.java

@@ -9,7 +9,7 @@ import com.alibaba.excel.metadata.data.ReadCellData;
 import com.alibaba.excel.read.listener.ReadListener;
 import com.alibaba.fastjson2.JSON;
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -23,10 +23,10 @@ public class ListHeadDataListener implements ReadListener<Map<Integer, String>>
 
     @Override
     public void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {
-        Assert.assertNotNull(context.readRowHolder().getRowIndex());
+        Assertions.assertNotNull(context.readRowHolder().getRowIndex());
         headMap.forEach((key, value) -> {
-            Assert.assertEquals(value.getRowIndex(), context.readRowHolder().getRowIndex());
-            Assert.assertEquals(value.getColumnIndex(), key);
+            Assertions.assertEquals(value.getRowIndex(), context.readRowHolder().getRowIndex());
+            Assertions.assertEquals(value.getColumnIndex(), key);
         });
     }
 
@@ -37,12 +37,12 @@ public class ListHeadDataListener implements ReadListener<Map<Integer, String>>
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         Map<Integer, String> data = list.get(0);
-        Assert.assertEquals("字符串0", data.get(0));
-        Assert.assertEquals("1", data.get(1));
-        Assert.assertEquals("2020-01-01 01:01:01", data.get(2));
-        Assert.assertEquals("额外数据", data.get(3));
+        Assertions.assertEquals("字符串0", data.get(0));
+        Assertions.assertEquals("1", data.get(1));
+        Assertions.assertEquals("2020-01-01 01:01:01", data.get(2));
+        Assertions.assertEquals("额外数据", data.get(3));
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/head/ListHeadDataTest.java

@@ -9,24 +9,22 @@ import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.util.DateUtils;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
- *
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class ListHeadDataTest {
 
     private static File file07;
     private static File file03;
     private static File fileCsv;
 
-
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("listHead07.xlsx");
         file03 = TestFileUtil.createNewFile("listHead03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/head/NoHeadDataListener.java

@@ -3,14 +3,14 @@ package com.alibaba.easyexcel.test.core.head;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -25,9 +25,9 @@ public class NoHeadDataListener extends AnalysisEventListener<NoHeadData> {
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         NoHeadData data = list.get(0);
-        Assert.assertEquals(data.getString(), "字符串0");
+        Assertions.assertEquals(data.getString(), "字符串0");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/head/NoHeadDataTest.java

@@ -7,22 +7,22 @@ import java.util.List;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class NoHeadDataTest {
 
     private static File file07;
     private static File file03;
     private static File fileCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("noHead07.xlsx");
         file03 = TestFileUtil.createNewFile("noHead03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/large/LargeDataListener.java

@@ -5,7 +5,7 @@ import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.excel.support.ExcelTypeEnum;
 import com.alibaba.fastjson2.JSON;
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -31,9 +31,9 @@ public class LargeDataListener extends AnalysisEventListener<LargeData> {
     public void doAfterAllAnalysed(AnalysisContext context) {
         LOGGER.info("Large row count:{}", count);
         if (context.readWorkbookHolder().getExcelType() != ExcelTypeEnum.CSV) {
-            Assert.assertEquals(count, 464509);
+            Assertions.assertEquals(count, 464509);
         } else {
-            Assert.assertEquals(count, 499999);
+            Assertions.assertEquals(count, 499999);
         }
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/large/LargeDataTest.java

@@ -2,35 +2,30 @@ package com.alibaba.easyexcel.test.core.large;
 
 import java.io.File;
 import java.io.FileOutputStream;
-import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;
 
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.ExcelWriter;
-import com.alibaba.excel.cache.Ehcache;
-import com.alibaba.excel.cache.ReadCache;
-import com.alibaba.excel.util.FileUtils;
 import com.alibaba.excel.write.metadata.WriteSheet;
 
-import org.apache.poi.util.TempFile;
 import org.apache.poi.xssf.streaming.SXSSFCell;
 import org.apache.poi.xssf.streaming.SXSSFRow;
 import org.apache.poi.xssf.streaming.SXSSFSheet;
 import org.apache.poi.xssf.streaming.SXSSFWorkbook;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class LargeDataTest {
     private static final Logger LOGGER = LoggerFactory.getLogger(LargeDataTest.class);
     private static File fileFill07;
@@ -42,7 +37,7 @@ public class LargeDataTest {
 
     private int i = 0;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         fileFill07 = TestFileUtil.createNewFile("largefill07.xlsx");
         fileWrite07 = TestFileUtil.createNewFile("large" + File.separator + "fileWrite07.xlsx");
@@ -60,7 +55,6 @@ public class LargeDataTest {
         LOGGER.info("Large data total time spent:{}", System.currentTimeMillis() - start);
     }
 
-
     @Test
     public void t02Fill() {
         try (ExcelWriter excelWriter = EasyExcel.write(fileFill07).withTemplate(template07).build()) {
@@ -131,7 +125,7 @@ public class LargeDataTest {
         long costPoi = System.currentTimeMillis() - start;
         LOGGER.info("poi write cost:{}", System.currentTimeMillis() - start);
         LOGGER.info("{} vs {}", cost, costPoi);
-        Assert.assertTrue(costPoi * 2 > cost);
+        Assertions.assertTrue(costPoi * 2 > cost);
     }
 
     private List<LargeData> data() {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/multiplesheets/MultipleSheetsDataTest.java

@@ -8,22 +8,22 @@ import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.ExcelReader;
 import com.alibaba.excel.read.metadata.ReadSheet;
 
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class MultipleSheetsDataTest {
 
     private static File file07;
     private static File file03;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.readFile("multiplesheets" + File.separator + "multiplesheets.xlsx");
         file03 = TestFileUtil.readFile("multiplesheets" + File.separator + "multiplesheets.xls");
@@ -56,7 +56,7 @@ public class MultipleSheetsDataTest {
             int count = 1;
             for (ReadSheet readSheet : sheets) {
                 excelReader.read(readSheet);
-                Assert.assertEquals(multipleSheetsListener.getList().size(), count);
+                Assertions.assertEquals(multipleSheetsListener.getList().size(), count);
                 count++;
             }
         }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/multiplesheets/MultipleSheetsListener.java

@@ -3,14 +3,14 @@ package com.alibaba.easyexcel.test.core.multiplesheets;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -26,7 +26,7 @@ public class MultipleSheetsListener extends AnalysisEventListener<MultipleSheets
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
         LOGGER.debug("A form is read finished.");
-        Assert.assertEquals(list.get(0).getTitle(), "表1数据");
+        Assertions.assertEquals(list.get(0).getTitle(), "表1数据");
         LOGGER.debug("All row:{}", JSON.toJSONString(list));
     }
 

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/nomodel/NoModelDataTest.java

@@ -15,16 +15,16 @@ import com.alibaba.excel.util.DateUtils;
 import com.alibaba.fastjson2.JSON;
 
 import lombok.extern.slf4j.Slf4j;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 @Slf4j
 public class NoModelDataTest {
 
@@ -35,7 +35,7 @@ public class NoModelDataTest {
     private static File fileRepeat03;
     private static File fileRepeatCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("noModel07.xlsx");
         file03 = TestFileUtil.createNewFile("noModel03.xls");
@@ -63,11 +63,11 @@ public class NoModelDataTest {
     private void readAndWrite(File file, File fileRepeat, boolean isCsv) throws Exception {
         EasyExcel.write(file).sheet().doWrite(data());
         List<Map<Integer, String>> result = EasyExcel.read(file).headRowNumber(0).sheet().doReadSync();
-        Assert.assertEquals(10, result.size());
+        Assertions.assertEquals(10, result.size());
         Map<Integer, String> data10 = result.get(9);
-        Assert.assertEquals("string19", data10.get(0));
-        Assert.assertEquals("109", data10.get(1));
-        Assert.assertEquals("2020-01-01 01:01:01", data10.get(2));
+        Assertions.assertEquals("string19", data10.get(0));
+        Assertions.assertEquals("109", data10.get(1));
+        Assertions.assertEquals("2020-01-01 01:01:01", data10.get(2));
 
         List<Map<Integer, Object>> actualDataList = EasyExcel.read(file)
             .headRowNumber(0)
@@ -75,16 +75,16 @@ public class NoModelDataTest {
             .sheet()
             .doReadSync();
         log.info("actualDataList:{}", JSON.toJSONString(actualDataList));
-        Assert.assertEquals(10, actualDataList.size());
+        Assertions.assertEquals(10, actualDataList.size());
         Map<Integer, Object> actualData10 = actualDataList.get(9);
-        Assert.assertEquals("string19", actualData10.get(0));
+        Assertions.assertEquals("string19", actualData10.get(0));
         if (isCsv) {
             //  CSV only string type
-            Assert.assertEquals("109", actualData10.get(1));
-            Assert.assertEquals("2020-01-01 01:01:01", actualData10.get(2));
+            Assertions.assertEquals("109", actualData10.get(1));
+            Assertions.assertEquals("2020-01-01 01:01:01", actualData10.get(2));
         } else {
-            Assert.assertEquals(0, new BigDecimal("109").compareTo((BigDecimal)actualData10.get(1)));
-            Assert.assertEquals(LocalDateTime.of(2020, 1, 1, 1, 1, 1), actualData10.get(2));
+            Assertions.assertEquals(0, new BigDecimal("109").compareTo((BigDecimal)actualData10.get(1)));
+            Assertions.assertEquals(LocalDateTime.of(2020, 1, 1, 1, 1, 1), actualData10.get(2));
         }
 
         List<Map<Integer, ReadCellData<?>>> readCellDataList = EasyExcel.read(file)
@@ -93,25 +93,25 @@ public class NoModelDataTest {
             .sheet()
             .doReadSync();
         log.info("readCellDataList:{}", JSON.toJSONString(readCellDataList));
-        Assert.assertEquals(10, readCellDataList.size());
+        Assertions.assertEquals(10, readCellDataList.size());
         Map<Integer, ReadCellData<?>> readCellData10 = readCellDataList.get(9);
-        Assert.assertEquals("string19", readCellData10.get(0).getData());
+        Assertions.assertEquals("string19", readCellData10.get(0).getData());
         if (isCsv) {
             //  CSV only string type
-            Assert.assertEquals("109", readCellData10.get(1).getData());
-            Assert.assertEquals("2020-01-01 01:01:01", readCellData10.get(2).getData());
+            Assertions.assertEquals("109", readCellData10.get(1).getData());
+            Assertions.assertEquals("2020-01-01 01:01:01", readCellData10.get(2).getData());
         } else {
-            Assert.assertEquals(0, new BigDecimal("109").compareTo((BigDecimal)readCellData10.get(1).getData()));
-            Assert.assertEquals(LocalDateTime.of(2020, 1, 1, 1, 1, 1), readCellData10.get(2).getData());
+            Assertions.assertEquals(0, new BigDecimal("109").compareTo((BigDecimal)readCellData10.get(1).getData()));
+            Assertions.assertEquals(LocalDateTime.of(2020, 1, 1, 1, 1, 1), readCellData10.get(2).getData());
         }
 
         EasyExcel.write(fileRepeat).sheet().doWrite(result);
         result = EasyExcel.read(fileRepeat).headRowNumber(0).sheet().doReadSync();
-        Assert.assertEquals(10, result.size());
+        Assertions.assertEquals(10, result.size());
         data10 = result.get(9);
-        Assert.assertEquals("string19", data10.get(0));
-        Assert.assertEquals("109", data10.get(1));
-        Assert.assertEquals("2020-01-01 01:01:01", data10.get(2));
+        Assertions.assertEquals("string19", data10.get(0));
+        Assertions.assertEquals("109", data10.get(1));
+        Assertions.assertEquals("2020-01-01 01:01:01", data10.get(2));
     }
 
     private List<List<Object>> data() throws Exception {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/noncamel/UnCamelDataListener.java

@@ -9,7 +9,7 @@ import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
 import lombok.extern.slf4j.Slf4j;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 
 /**
  * @author Jiaju Zhuang
@@ -21,12 +21,12 @@ public class UnCamelDataListener extends AnalysisEventListener<UnCamelData> {
     @Override
     public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
         log.debug("Head is:{}", JSON.toJSONString(headMap));
-        Assert.assertEquals(headMap.get(0), "string1");
-        Assert.assertEquals(headMap.get(1), "string2");
-        Assert.assertEquals(headMap.get(2), "STring3");
-        Assert.assertEquals(headMap.get(3), "STring4");
-        Assert.assertEquals(headMap.get(4), "STRING5");
-        Assert.assertEquals(headMap.get(5), "STRing6");
+        Assertions.assertEquals(headMap.get(0), "string1");
+        Assertions.assertEquals(headMap.get(1), "string2");
+        Assertions.assertEquals(headMap.get(2), "STring3");
+        Assertions.assertEquals(headMap.get(3), "STring4");
+        Assertions.assertEquals(headMap.get(4), "STRING5");
+        Assertions.assertEquals(headMap.get(5), "STRing6");
 
     }
 
@@ -37,14 +37,14 @@ public class UnCamelDataListener extends AnalysisEventListener<UnCamelData> {
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 10);
+        Assertions.assertEquals(list.size(), 10);
         UnCamelData unCamelData = list.get(0);
-        Assert.assertEquals(unCamelData.getString1(), "string1");
-        Assert.assertEquals(unCamelData.getString2(), "string2");
-        Assert.assertEquals(unCamelData.getSTring3(), "string3");
-        Assert.assertEquals(unCamelData.getSTring4(), "string4");
-        Assert.assertEquals(unCamelData.getSTRING5(), "string5");
-        Assert.assertEquals(unCamelData.getSTRing6(), "string6");
+        Assertions.assertEquals(unCamelData.getString1(), "string1");
+        Assertions.assertEquals(unCamelData.getString2(), "string2");
+        Assertions.assertEquals(unCamelData.getSTring3(), "string3");
+        Assertions.assertEquals(unCamelData.getSTring4(), "string4");
+        Assertions.assertEquals(unCamelData.getSTRING5(), "string5");
+        Assertions.assertEquals(unCamelData.getSTRing6(), "string6");
         log.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/noncamel/UnCamelDataTest.java

@@ -7,23 +7,22 @@ import java.util.List;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class UnCamelDataTest {
 
     private static File file07;
     private static File file03;
     private static File fileCsv;
 
-
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("unCame07.xlsx");
         file03 = TestFileUtil.createNewFile("unCame03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/parameter/ParameterDataListener.java

@@ -3,14 +3,14 @@ package com.alibaba.easyexcel.test.core.parameter;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -25,10 +25,10 @@ public class ParameterDataListener extends AnalysisEventListener<ParameterData>
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 10);
-        Assert.assertEquals(list.get(0).getName(), "姓名0");
-        Assert.assertEquals((int)(context.readSheetHolder().getSheetNo()), 0);
-        Assert.assertEquals(
+        Assertions.assertEquals(list.size(), 10);
+        Assertions.assertEquals(list.get(0).getName(), "姓名0");
+        Assertions.assertEquals((int)(context.readSheetHolder().getSheetNo()), 0);
+        Assertions.assertEquals(
             context.readSheetHolder().getExcelReadHeadProperty().getHeadMap().get(0).getHeadNameList().get(0), "姓名");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/parameter/ParameterDataTest.java

@@ -16,21 +16,21 @@ import com.alibaba.excel.support.ExcelTypeEnum;
 import com.alibaba.excel.write.metadata.WriteSheet;
 import com.alibaba.excel.write.metadata.WriteTable;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class ParameterDataTest {
 
     private static File file07;
     private static File fileCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("parameter07.xlsx");
         fileCsv = TestFileUtil.createNewFile("parameterCsv.csv");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/repetition/RepetitionDataListener.java

@@ -3,15 +3,15 @@ package com.alibaba.easyexcel.test.core.repetition;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.easyexcel.test.core.simple.SimpleDataListener;
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -26,9 +26,9 @@ public class RepetitionDataListener extends AnalysisEventListener<RepetitionData
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 2);
-        Assert.assertEquals(list.get(0).getString(), "字符串0");
-        Assert.assertEquals(list.get(1).getString(), "字符串0");
+        Assertions.assertEquals(list.size(), 2);
+        Assertions.assertEquals(list.get(0).getString(), "字符串0");
+        Assertions.assertEquals(list.get(1).getString(), "字符串0");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/repetition/RepetitionDataTest.java

@@ -12,15 +12,15 @@ import com.alibaba.excel.read.metadata.ReadSheet;
 import com.alibaba.excel.write.metadata.WriteSheet;
 import com.alibaba.excel.write.metadata.WriteTable;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class RepetitionDataTest {
 
     private static File file07;
@@ -30,7 +30,7 @@ public class RepetitionDataTest {
     private static File fileTable03;
     private static File fileTableCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("repetition07.xlsx");
         file03 = TestFileUtil.createNewFile("repetition03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/simple/SimpleDataListener.java

@@ -4,14 +4,14 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -22,7 +22,7 @@ public class SimpleDataListener extends AnalysisEventListener<SimpleData> {
     @Override
     public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
         LOGGER.debug("Head is:{}", JSON.toJSONString(headMap));
-        Assert.assertEquals(headMap.get(0), "姓名");
+        Assertions.assertEquals(headMap.get(0), "姓名");
     }
 
     @Override
@@ -32,10 +32,10 @@ public class SimpleDataListener extends AnalysisEventListener<SimpleData> {
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 10);
-        Assert.assertEquals(list.get(0).getName(), "姓名0");
-        Assert.assertEquals((int)(context.readSheetHolder().getSheetNo()), 0);
-        Assert.assertEquals(
+        Assertions.assertEquals(list.size(), 10);
+        Assertions.assertEquals(list.get(0).getName(), "姓名0");
+        Assertions.assertEquals((int)(context.readSheetHolder().getSheetNo()), 0);
+        Assertions.assertEquals(
             context.readSheetHolder().getExcelReadHeadProperty().getHeadMap().get(0).getHeadNameList().get(0), "姓名");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/simple/SimpleDataSheetNameListener.java

@@ -3,14 +3,14 @@ package com.alibaba.easyexcel.test.core.simple;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -25,8 +25,8 @@ public class SimpleDataSheetNameListener extends AnalysisEventListener<SimpleDat
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
-        Assert.assertEquals(list.get(0).getName(), "张三");
+        Assertions.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.get(0).getName(), "张三");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/simple/SimpleDataTest.java

@@ -7,23 +7,22 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
-import com.alibaba.easyexcel.test.demo.read.DemoData;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.read.listener.PageReadListener;
 import com.alibaba.excel.support.ExcelTypeEnum;
 
 import lombok.extern.slf4j.Slf4j;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 @Slf4j
 public class SimpleDataTest {
 
@@ -31,7 +30,7 @@ public class SimpleDataTest {
     private static File file03;
     private static File fileCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("simple07.xlsx");
         file03 = TestFileUtil.createNewFile("simple03.xls");
@@ -99,14 +98,14 @@ public class SimpleDataTest {
                 TestFileUtil.readFile("simple" + File.separator + "simple07.xlsx"))
             .sheet("simple")
             .doReadSync();
-        Assert.assertEquals(1, list.size());
+        Assertions.assertEquals(1, list.size());
     }
 
     @Test
     public void t22PageReadListener07() {
         EasyExcel.read(file07, SimpleData.class,
                 new PageReadListener<SimpleData>(dataList -> {
-                    Assert.assertEquals(5, dataList.size());
+                    Assertions.assertEquals(5, dataList.size());
                 }, 5))
             .sheet().doRead();
     }
@@ -114,9 +113,9 @@ public class SimpleDataTest {
     private void synchronousRead(File file) {
         // Synchronous read file
         List<Object> list = EasyExcel.read(file).head(SimpleData.class).sheet().doReadSync();
-        Assert.assertEquals(list.size(), 10);
-        Assert.assertTrue(list.get(0) instanceof SimpleData);
-        Assert.assertEquals(((SimpleData)list.get(0)).getName(), "姓名0");
+        Assertions.assertEquals(list.size(), 10);
+        Assertions.assertTrue(list.get(0) instanceof SimpleData);
+        Assertions.assertEquals(((SimpleData)list.get(0)).getName(), "姓名0");
     }
 
     private List<SimpleData> data() {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/skip/SkipDataTest.java

@@ -14,23 +14,23 @@ import com.alibaba.excel.exception.ExcelGenerateException;
 import com.alibaba.excel.read.metadata.ReadSheet;
 import com.alibaba.excel.write.metadata.WriteSheet;
 
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class SkipDataTest {
 
     private static File file07;
     private static File file03;
     private static File fileCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("skip.xlsx");
         file03 = TestFileUtil.createNewFile("skip.xls");
@@ -49,7 +49,7 @@ public class SkipDataTest {
 
     @Test
     public void t03ReadAndWriteCsv() {
-        Assert.assertThrows(ExcelGenerateException.class, () -> readAndWrite(fileCsv));
+        Assertions.assertThrows(ExcelGenerateException.class, () -> readAndWrite(fileCsv));
     }
 
     private void readAndWrite(File file) {
@@ -65,8 +65,8 @@ public class SkipDataTest {
         }
 
         List<SkipData> list = EasyExcel.read(file, SkipData.class, null).sheet("第二个").doReadSync();
-        Assert.assertEquals(1, list.size());
-        Assert.assertEquals("name2", list.get(0).getName());
+        Assertions.assertEquals(1, list.size());
+        Assertions.assertEquals("name2", list.get(0).getName());
 
         SyncReadListener syncReadListener = new SyncReadListener();
         try (ExcelReader excelReader = EasyExcel.read(file, SkipData.class, null).registerReadListener(syncReadListener)
@@ -75,9 +75,9 @@ public class SkipDataTest {
             ReadSheet readSheet3 = EasyExcel.readSheet("第四个").build();
             excelReader.read(readSheet1, readSheet3);
             List<Object> syncList = syncReadListener.getList();
-            Assert.assertEquals(2, syncList.size());
-            Assert.assertEquals("name2", ((SkipData)syncList.get(0)).getName());
-            Assert.assertEquals("name4", ((SkipData)syncList.get(1)).getName());
+            Assertions.assertEquals(2, syncList.size());
+            Assertions.assertEquals("name2", ((SkipData)syncList.get(0)).getName());
+            Assertions.assertEquals("name4", ((SkipData)syncList.get(1)).getName());
         }
     }
 

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/sort/SortDataListener.java

@@ -3,13 +3,13 @@ package com.alibaba.easyexcel.test.core.sort;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -18,7 +18,6 @@ public class SortDataListener extends AnalysisEventListener<SortData> {
     private static final Logger LOGGER = LoggerFactory.getLogger(SortDataListener.class);
     List<SortData> list = new ArrayList<SortData>();
 
-
     @Override
     public void invoke(SortData data, AnalysisContext context) {
         list.add(data);
@@ -26,13 +25,13 @@ public class SortDataListener extends AnalysisEventListener<SortData> {
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 1);
+        Assertions.assertEquals(list.size(), 1);
         SortData sortData = list.get(0);
-        Assert.assertEquals("column1", sortData.getColumn1());
-        Assert.assertEquals("column2", sortData.getColumn2());
-        Assert.assertEquals("column3", sortData.getColumn3());
-        Assert.assertEquals("column4", sortData.getColumn4());
-        Assert.assertEquals("column5", sortData.getColumn5());
-        Assert.assertEquals("column6", sortData.getColumn6());
+        Assertions.assertEquals("column1", sortData.getColumn1());
+        Assertions.assertEquals("column2", sortData.getColumn2());
+        Assertions.assertEquals("column3", sortData.getColumn3());
+        Assertions.assertEquals("column4", sortData.getColumn4());
+        Assertions.assertEquals("column5", sortData.getColumn5());
+        Assertions.assertEquals("column6", sortData.getColumn6());
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/sort/SortDataTest.java

@@ -9,16 +9,16 @@ import java.util.Map;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class SortDataTest {
 
     private static File file07;
@@ -28,7 +28,7 @@ public class SortDataTest {
     private static File sortNoHead03;
     private static File sortNoHeadCsv;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("sort.xlsx");
         file03 = TestFileUtil.createNewFile("sort.xls");
@@ -71,14 +71,14 @@ public class SortDataTest {
     private void readAndWrite(File file) {
         EasyExcel.write(file, SortData.class).sheet().doWrite(data());
         List<Map<Integer, String>> dataMap = EasyExcel.read(file).sheet().doReadSync();
-        Assert.assertEquals(1, dataMap.size());
+        Assertions.assertEquals(1, dataMap.size());
         Map<Integer, String> record = dataMap.get(0);
-        Assert.assertEquals("column1", record.get(0));
-        Assert.assertEquals("column2", record.get(1));
-        Assert.assertEquals("column3", record.get(2));
-        Assert.assertEquals("column4", record.get(3));
-        Assert.assertEquals("column5", record.get(4));
-        Assert.assertEquals("column6", record.get(5));
+        Assertions.assertEquals("column1", record.get(0));
+        Assertions.assertEquals("column2", record.get(1));
+        Assertions.assertEquals("column3", record.get(2));
+        Assertions.assertEquals("column4", record.get(3));
+        Assertions.assertEquals("column5", record.get(4));
+        Assertions.assertEquals("column6", record.get(5));
 
         EasyExcel.read(file, SortData.class, new SortDataListener()).sheet().doRead();
     }
@@ -86,14 +86,14 @@ public class SortDataTest {
     private void readAndWriteNoHead(File file) {
         EasyExcel.write(file).head(head()).sheet().doWrite(data());
         List<Map<Integer, String>> dataMap = EasyExcel.read(file).sheet().doReadSync();
-        Assert.assertEquals(1, dataMap.size());
+        Assertions.assertEquals(1, dataMap.size());
         Map<Integer, String> record = dataMap.get(0);
-        Assert.assertEquals("column1", record.get(0));
-        Assert.assertEquals("column2", record.get(1));
-        Assert.assertEquals("column3", record.get(2));
-        Assert.assertEquals("column4", record.get(3));
-        Assert.assertEquals("column5", record.get(4));
-        Assert.assertEquals("column6", record.get(5));
+        Assertions.assertEquals("column1", record.get(0));
+        Assertions.assertEquals("column2", record.get(1));
+        Assertions.assertEquals("column3", record.get(2));
+        Assertions.assertEquals("column4", record.get(3));
+        Assertions.assertEquals("column5", record.get(4));
+        Assertions.assertEquals("column6", record.get(5));
         EasyExcel.read(file, SortData.class, new SortDataListener()).sheet().doRead();
     }
 

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/style/StyleDataListener.java

@@ -3,15 +3,15 @@ package com.alibaba.easyexcel.test.core.style;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.easyexcel.test.core.simple.SimpleDataListener;
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -26,9 +26,9 @@ public class StyleDataListener extends AnalysisEventListener<StyleData> {
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 2);
-        Assert.assertEquals(list.get(0).getString(), "字符串0");
-        Assert.assertEquals(list.get(1).getString(), "字符串1");
+        Assertions.assertEquals(list.size(), 2);
+        Assertions.assertEquals(list.get(0).getString(), "字符串0");
+        Assertions.assertEquals(list.get(1).getString(), "字符串1");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/style/StyleDataTest.java

@@ -33,16 +33,16 @@ import org.apache.poi.ss.usermodel.Sheet;
 import org.apache.poi.ss.usermodel.VerticalAlignment;
 import org.apache.poi.ss.usermodel.Workbook;
 import org.apache.poi.ss.usermodel.WorkbookFactory;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class StyleDataTest {
 
     private static File file07;
@@ -51,7 +51,7 @@ public class StyleDataTest {
     private static File fileVerticalCellStyleStrategy207;
     private static File fileLoopMergeStrategy;
 
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("style07.xlsx");
         file03 = TestFileUtil.createNewFile("style03.xls");
@@ -209,30 +209,30 @@ public class StyleDataTest {
 
         Workbook workbook = WorkbookFactory.create(file);
         Sheet sheet = workbook.getSheetAt(0);
-        Assert.assertEquals(50 * 256, sheet.getColumnWidth(0), 0);
+        Assertions.assertEquals(50 * 256, sheet.getColumnWidth(0), 0);
 
         Row row0 = sheet.getRow(0);
-        Assert.assertEquals(800, row0.getHeight(), 0);
+        Assertions.assertEquals(800, row0.getHeight(), 0);
         Cell cell00 = row0.getCell(0);
-        Assert.assertArrayEquals(new byte[] {-1, -1, 0}, StyleTestUtils.getFillForegroundColor(cell00));
-        Assert.assertArrayEquals(new byte[] {-128, -128, 0}, StyleTestUtils.getFontColor(cell00, workbook));
-        Assert.assertEquals(20, StyleTestUtils.getFontHeightInPoints(cell00, workbook));
+        Assertions.assertArrayEquals(new byte[] {-1, -1, 0}, StyleTestUtils.getFillForegroundColor(cell00));
+        Assertions.assertArrayEquals(new byte[] {-128, -128, 0}, StyleTestUtils.getFontColor(cell00, workbook));
+        Assertions.assertEquals(20, StyleTestUtils.getFontHeightInPoints(cell00, workbook));
 
         Cell cell01 = row0.getCell(1);
-        Assert.assertArrayEquals(new byte[] {-1, -1, 0}, StyleTestUtils.getFillForegroundColor(cell01));
-        Assert.assertArrayEquals(new byte[] {-128, -128, 0}, StyleTestUtils.getFontColor(cell01, workbook));
-        Assert.assertEquals(20, StyleTestUtils.getFontHeightInPoints(cell01, workbook));
+        Assertions.assertArrayEquals(new byte[] {-1, -1, 0}, StyleTestUtils.getFillForegroundColor(cell01));
+        Assertions.assertArrayEquals(new byte[] {-128, -128, 0}, StyleTestUtils.getFontColor(cell01, workbook));
+        Assertions.assertEquals(20, StyleTestUtils.getFontHeightInPoints(cell01, workbook));
 
         Row row1 = sheet.getRow(1);
-        Assert.assertEquals(1000, row1.getHeight(), 0);
+        Assertions.assertEquals(1000, row1.getHeight(), 0);
         Cell cell10 = row1.getCell(0);
-        Assert.assertArrayEquals(new byte[] {0, -128, -128}, StyleTestUtils.getFillForegroundColor(cell10));
-        Assert.assertArrayEquals(new byte[] {0, 51, 102}, StyleTestUtils.getFontColor(cell10, workbook));
-        Assert.assertEquals(30, StyleTestUtils.getFontHeightInPoints(cell10, workbook));
+        Assertions.assertArrayEquals(new byte[] {0, -128, -128}, StyleTestUtils.getFillForegroundColor(cell10));
+        Assertions.assertArrayEquals(new byte[] {0, 51, 102}, StyleTestUtils.getFontColor(cell10, workbook));
+        Assertions.assertEquals(30, StyleTestUtils.getFontHeightInPoints(cell10, workbook));
         Cell cell11 = row1.getCell(1);
-        Assert.assertArrayEquals(new byte[] {0, -128, -128}, StyleTestUtils.getFillForegroundColor(cell11));
-        Assert.assertArrayEquals(new byte[] {0, 51, 102}, StyleTestUtils.getFontColor(cell11, workbook));
-        Assert.assertEquals(30, StyleTestUtils.getFontHeightInPoints(cell11, workbook));
+        Assertions.assertArrayEquals(new byte[] {0, -128, -128}, StyleTestUtils.getFillForegroundColor(cell11));
+        Assertions.assertArrayEquals(new byte[] {0, 51, 102}, StyleTestUtils.getFontColor(cell11, workbook));
+        Assertions.assertEquals(30, StyleTestUtils.getFontHeightInPoints(cell11, workbook));
     }
 
     private List<StyleData> data() {

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/template/TemplateDataListener.java

@@ -3,15 +3,15 @@ package com.alibaba.easyexcel.test.core.template;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.alibaba.easyexcel.test.core.simple.SimpleDataListener;
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.fastjson2.JSON;
 
+import org.junit.jupiter.api.Assertions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * @author Jiaju Zhuang
  */
@@ -26,9 +26,9 @@ public class TemplateDataListener extends AnalysisEventListener<TemplateData> {
 
     @Override
     public void doAfterAllAnalysed(AnalysisContext context) {
-        Assert.assertEquals(list.size(), 2);
-        Assert.assertEquals(list.get(0).getString0(), "字符串0");
-        Assert.assertEquals(list.get(1).getString0(), "字符串1");
+        Assertions.assertEquals(list.size(), 2);
+        Assertions.assertEquals(list.get(0).getString0(), "字符串0");
+        Assertions.assertEquals(list.get(1).getString0(), "字符串1");
         LOGGER.debug("First row:{}", JSON.toJSONString(list.get(0)));
     }
 }

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/core/template/TemplateDataTest.java

@@ -7,23 +7,21 @@ import java.util.List;
 import com.alibaba.easyexcel.test.util.TestFileUtil;
 import com.alibaba.excel.EasyExcel;
 
-import org.junit.BeforeClass;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 
 /**
- *
  * @author Jiaju Zhuang
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class TemplateDataTest {
 
     private static File file07;
     private static File file03;
 
-
-    @BeforeClass
+    @BeforeAll
     public static void init() {
         file07 = TestFileUtil.createNewFile("template07.xlsx");
         file03 = TestFileUtil.createNewFile("template03.xls");

easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/fill/FillTest.java

@@ -16,8 +16,7 @@ import com.alibaba.excel.write.metadata.WriteSheet;
 import com.alibaba.excel.write.metadata.fill.FillConfig;
 import com.alibaba.excel.write.metadata.fill.FillWrapper;
 
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * 写的填充写法
@@ -25,7 +24,7 @@ import org.junit.Test;
  * @author Jiaju Zhuang
  * @since 2.1.1
  */
-@Ignore
+
 public class FillTest {
     /**
      * 最简单的填充
@@ -73,18 +72,7 @@ public class FillTest {
         // 这里 会填充到第一个sheet， 然后文件流会自动关闭
         EasyExcel.write(fileName).withTemplate(templateFileName).sheet().doFill(data());
 
-        // 方案2 分多次 填充 会使用文件缓存（省内存） jdk8
-        // since: 3.0.0-beta1
-        fileName = TestFileUtil.getPath() + "listFill" + System.currentTimeMillis() + ".xlsx";
-        EasyExcel.write(fileName)
-            .withTemplate(templateFileName)
-            .sheet()
-            .doFill(() -> {
-                // 分页查询数据
-                return data();
-            });
-
-        // 方案3 分多次 填充 会使用文件缓存（省内存）
+        // 方案2 分多次 填充 会使用文件缓存（省内存）
         fileName = TestFileUtil.getPath() + "listFill" + System.currentTimeMillis() + ".xlsx";
         try (ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build()) {
             WriteSheet writeSheet = EasyExcel.writerSheet().build();