临时测试

src/main/java/com/alibaba/excel/util/ClassUtils.java

@@ -31,6 +31,8 @@ import com.alibaba.excel.metadata.property.NumberFormatProperty;
 import com.alibaba.excel.metadata.property.StyleProperty;
 import com.alibaba.excel.write.metadata.holder.WriteHolder;
 
+import lombok.AllArgsConstructor;
+import lombok.Data;
 import net.sf.cglib.beans.BeanMap;
 
 /**
@@ -51,7 +53,7 @@ public class ClassUtils {
     /**
      * The cache configuration information for each of the class
      */
-    public static final Map<String, ExcelContentProperty> CONTENT_CACHE = new ConcurrentHashMap<>();
+    public static final Map<ContentPropertyKey, ExcelContentProperty> CONTENT_CACHE = new ConcurrentHashMap<>();
 
     /**
      * Calculate the configuration information for the class
@@ -117,20 +119,8 @@ public class ClassUtils {
         }
     }
 
-    private static String buildKey(Class<?> clazz, Class<?> headClass, String fieldName) {
+    private static ContentPropertyKey buildKey(Class<?> clazz, Class<?> headClass, String fieldName) {
-        String key = "";
+        return new ContentPropertyKey(clazz, headClass, fieldName);
-        if (clazz != null) {
-            key += clazz.getName();
-        }
-        key += "-";
-        if (headClass != null) {
-            key += headClass.getName();
-        }
-        key += "-";
-        if (fieldName != null) {
-            key += fieldName;
-        }
-        return key;
     }
 
     private static Map<String, ExcelContentProperty> declaredFieldContentMap(Class<?> clazz) {
@@ -413,4 +403,11 @@ public class ClassUtils {
         }
     }
 
+    @Data
+    @AllArgsConstructor
+    public static class ContentPropertyKey {
+        private Class<?> clazz;
+        private Class<?> headClass;
+        private String fieldName;
+    }
 }

src/main/java/com/alibaba/excel/util/CostUtil.java

@@ -0,0 +1,23 @@
+package com.alibaba.excel.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CostUtil {
+    private static final Logger LOGGER = LoggerFactory.getLogger(CostUtil.class);
+    private static long start = 0;
+
+    public static int count = 0;
+    public static int count2 = 0;
+
+
+    public static void start() {
+        start = System.currentTimeMillis();
+        LOGGER.info("开始执行");
+    }
+
+    public static void print(String print) {
+        LOGGER.info(print + "为止耗时：{}", System.currentTimeMillis() - start);
+        start = System.currentTimeMillis();
+    }
+}

src/main/java/com/alibaba/excel/util/WriteHandlerUtils.java

@@ -15,7 +15,12 @@ import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
 import com.alibaba.excel.write.handler.context.RowWriteHandlerContext;
 import com.alibaba.excel.write.handler.context.SheetWriteHandlerContext;
 import com.alibaba.excel.write.handler.context.WorkbookWriteHandlerContext;
+import com.alibaba.excel.write.handler.impl.DefaultRowWriteHandler;
+import com.alibaba.excel.write.handler.impl.FillStyleCellWriteHandler;
+import com.alibaba.excel.write.metadata.holder.AbstractWriteHolder;
+import com.alibaba.excel.write.style.DefaultStyle;
 
+import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.poi.ss.usermodel.Row;
 
@@ -24,6 +29,7 @@ import org.apache.poi.ss.usermodel.Row;
  *
  * @author Jiaju Zhuang
  */
+@Slf4j
 public class WriteHandlerUtils {
 
     private WriteHandlerUtils() {}
@@ -154,38 +160,61 @@ public class WriteHandlerUtils {
 
     public static void beforeCellCreate(CellWriteHandlerContext context) {
         List<WriteHandler> handlerList = context.getHandlerList();
+        DefaultStyle.defaultStyle.beforeCellCreate(context);
+        AbstractWriteHolder.abstractVerticalCellStyleStrategy.beforeCellCreate(context);
         if (CollectionUtils.isNotEmpty(handlerList)) {
+            CostUtil.count++;
+
             for (WriteHandler writeHandler : handlerList) {
+
                 ((CellWriteHandler)writeHandler).beforeCellCreate(context);
             }
         }
+        FillStyleCellWriteHandler.fillStyleCellWriteHandler.beforeCellCreate(context);
     }
 
     public static void afterCellCreate(CellWriteHandlerContext context) {
         List<WriteHandler> handlerList = context.getHandlerList();
+        DefaultStyle.defaultStyle.afterCellCreate(context);
+        AbstractWriteHolder.abstractVerticalCellStyleStrategy.afterCellCreate(context);
         if (CollectionUtils.isNotEmpty(handlerList)) {
+            CostUtil.count++;
+
             for (WriteHandler writeHandler : handlerList) {
+
                 ((CellWriteHandler)writeHandler).afterCellCreate(context);
             }
         }
+        FillStyleCellWriteHandler.fillStyleCellWriteHandler.afterCellCreate(context);
+
     }
 
     public static void afterCellDataConverted(CellWriteHandlerContext context) {
         List<WriteHandler> handlerList = context.getHandlerList();
+        DefaultStyle.defaultStyle.afterCellDataConverted(context);
+        AbstractWriteHolder.abstractVerticalCellStyleStrategy.afterCellDataConverted(context);
         if (CollectionUtils.isNotEmpty(handlerList)) {
+            CostUtil.count++;
             for (WriteHandler writeHandler : handlerList) {
                 ((CellWriteHandler)writeHandler).afterCellDataConverted(context);
             }
         }
+        FillStyleCellWriteHandler.fillStyleCellWriteHandler.afterCellDataConverted(context);
+
     }
 
     public static void afterCellDispose(CellWriteHandlerContext context) {
         List<WriteHandler> handlerList = context.getHandlerList();
+        DefaultStyle.defaultStyle.afterCellDispose(context);
+        AbstractWriteHolder.abstractVerticalCellStyleStrategy.afterCellDispose(context);
         if (CollectionUtils.isNotEmpty(handlerList)) {
+            CostUtil.count++;
             for (WriteHandler writeHandler : handlerList) {
                 ((CellWriteHandler)writeHandler).afterCellDispose(context);
             }
         }
+        FillStyleCellWriteHandler.fillStyleCellWriteHandler.afterCellDispose(context);
+
     }
 
     public static RowWriteHandlerContext createRowWriteHandlerContext(WriteContext writeContext, Integer rowIndex,
@@ -218,6 +247,7 @@ public class WriteHandlerUtils {
 
     public static void afterRowDispose(RowWriteHandlerContext context) {
         List<WriteHandler> handlerList = context.getHandlerList();
+        DefaultRowWriteHandler.defaultRowWriteHandler.afterRowDispose(context);
         if (CollectionUtils.isNotEmpty(handlerList)) {
             for (WriteHandler writeHandler : handlerList) {
                 ((RowWriteHandler)writeHandler).afterRowDispose(context);

src/main/java/com/alibaba/excel/write/handler/AbstractCellWriteHandler.java

@@ -1,15 +1,5 @@
 package com.alibaba.excel.write.handler;
 
-import java.util.List;
-
-import com.alibaba.excel.metadata.Head;
-import com.alibaba.excel.metadata.data.WriteCellData;
-import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
-import com.alibaba.excel.write.metadata.holder.WriteTableHolder;
-
-import org.apache.poi.ss.usermodel.Cell;
-import org.apache.poi.ss.usermodel.Row;
-
 /**
  * Abstract cell write handler
  *
@@ -19,26 +9,4 @@ import org.apache.poi.ss.usermodel.Row;
 @Deprecated
 public abstract class AbstractCellWriteHandler implements CellWriteHandler {
 
-    @Override
-    public void beforeCellCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Row row,
-        Head head, Integer columnIndex, Integer relativeRowIndex, Boolean isHead) {
-
-    }
-
-    @Override
-    public void afterCellCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Cell cell,
-        Head head, Integer relativeRowIndex, Boolean isHead) {
-
-    }
-
-    @Override
-    public void afterCellDataConverted(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
-        WriteCellData<?> cellData, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {
-    }
-
-    @Override
-    public void afterCellDispose(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
-        List<WriteCellData<?>> cellDataList, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {
-
-    }
 }

src/main/java/com/alibaba/excel/write/handler/CellWriteHandler.java

@@ -1,16 +1,6 @@
 package com.alibaba.excel.write.handler;
 
-import java.util.List;
-
-import com.alibaba.excel.metadata.Head;
-import com.alibaba.excel.metadata.data.WriteCellData;
 import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
-import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
-import com.alibaba.excel.write.metadata.holder.WriteTableHolder;
-
-import org.apache.commons.collections4.CollectionUtils;
-import org.apache.poi.ss.usermodel.Cell;
-import org.apache.poi.ss.usermodel.Row;
 
 /**
  * intercepts handle cell creation
@@ -24,95 +14,30 @@ public interface CellWriteHandler extends WriteHandler {
      *
      * @param context
      */
-    default void beforeCellCreate(CellWriteHandlerContext context) {
+     void beforeCellCreate(CellWriteHandlerContext context);
-        beforeCellCreate(context.getWriteSheetHolder(), context.getWriteTableHolder(), context.getRow(),
-            context.getHeadData(), context.getColumnIndex(), context.getRelativeRowIndex(), context.getHead());
-    }
 
-    /**
-     * Called before create the cell
-     *
-     * @param writeSheetHolder
-     * @param writeTableHolder Nullable.It is null without using table writes.
-     * @param row
-     * @param head             Nullable.It is null in the case of fill data and without head.
-     * @param columnIndex
-     * @param relativeRowIndex Nullable.It is null in the case of fill data.
-     * @param isHead           It will always be false when fill data.
-     */
-    default void beforeCellCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Row row,
-        Head head, Integer columnIndex, Integer relativeRowIndex, Boolean isHead) {}
 
     /**
      * Called after the cell is created
      *
      * @param context
      */
-    default void afterCellCreate(CellWriteHandlerContext context) {
+     void afterCellCreate(CellWriteHandlerContext context) ;
-        afterCellCreate(context.getWriteSheetHolder(), context.getWriteTableHolder(), context.getCell(),
-            context.getHeadData(), context.getRelativeRowIndex(), context.getHead());
-    }
 
-    /**
-     * Called after the cell is created
-     *
-     * @param writeSheetHolder
-     * @param writeTableHolder Nullable.It is null without using table writes.
-     * @param cell
-     * @param head             Nullable.It is null in the case of fill data and without head.
-     * @param relativeRowIndex Nullable.It is null in the case of fill data.
-     * @param isHead           It will always be false when fill data.
-     */
-    default void afterCellCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Cell cell,
-        Head head, Integer relativeRowIndex, Boolean isHead) {}
 
-    /**
-     * Called after the cell data is converted
-     *
-     * @param context
-     */
-    default void afterCellDataConverted(CellWriteHandlerContext context) {
-        WriteCellData<?> writeCellData = CollectionUtils.isNotEmpty(context.getCellDataList()) ? context
-            .getCellDataList().get(0) : null;
-        afterCellDataConverted(context.getWriteSheetHolder(), context.getWriteTableHolder(), writeCellData,
-            context.getCell(), context.getHeadData(), context.getRelativeRowIndex(), context.getHead());
-    }
 
     /**
      * Called after the cell data is converted
      *
-     * @param writeSheetHolder
+     * @param context
-     * @param writeTableHolder Nullable.It is null without using table writes.
-     * @param cell
-     * @param head             Nullable.It is null in the case of fill data and without head.
-     * @param cellData         Nullable.It is null in the case of add header.
-     * @param relativeRowIndex Nullable.It is null in the case of fill data.
-     * @param isHead           It will always be false when fill data.
      */
-    default void afterCellDataConverted(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
+     void afterCellDataConverted(CellWriteHandlerContext context);
-        WriteCellData<?> cellData, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {}
 
     /**
      * Called after all operations on the cell have been completed
      *
      * @param context
      */
-    default void afterCellDispose(CellWriteHandlerContext context) {
+     void afterCellDispose(CellWriteHandlerContext context);
-        afterCellDispose(context.getWriteSheetHolder(), context.getWriteTableHolder(), context.getCellDataList(),
-            context.getCell(), context.getHeadData(), context.getRelativeRowIndex(), context.getHead());
-    }
 
-    /**
-     * Called after all operations on the cell have been completed
-     *
-     * @param writeSheetHolder
-     * @param writeTableHolder Nullable.It is null without using table writes.
-     * @param cell
-     * @param head             Nullable.It is null in the case of fill data and without head.
-     * @param cellDataList     Nullable.It is null in the case of add header.There may be several when fill the data.
-     * @param relativeRowIndex Nullable.It is null in the case of fill data.
-     * @param isHead           It will always be false when fill data.
-     */
-    default void afterCellDispose(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
-        List<WriteCellData<?>> cellDataList, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {}
 }

src/main/java/com/alibaba/excel/write/handler/DefaultWriteHandlerLoader.java

@@ -5,8 +5,6 @@ import java.util.List;
 
 import com.alibaba.excel.write.handler.impl.DefaultRowWriteHandler;
 import com.alibaba.excel.write.handler.impl.DimensionWorkbookWriteHandler;
-import com.alibaba.excel.write.handler.impl.FillStyleCellWriteHandler;
-import com.alibaba.excel.write.style.DefaultStyle;
 
 /**
  * Load default handler
@@ -20,7 +18,7 @@ public class DefaultWriteHandlerLoader {
     static {
         DEFAULT_WRITE_HANDLER_LIST.add(new DimensionWorkbookWriteHandler());
         DEFAULT_WRITE_HANDLER_LIST.add(new DefaultRowWriteHandler());
-        DEFAULT_WRITE_HANDLER_LIST.add(new FillStyleCellWriteHandler());
+        //DEFAULT_WRITE_HANDLER_LIST.add(new FillStyleCellWriteHandler());
     }
 
     /**
@@ -31,7 +29,7 @@ public class DefaultWriteHandlerLoader {
     public static List<WriteHandler> loadDefaultHandler(Boolean useDefaultStyle) {
         List<WriteHandler> handlerList = new ArrayList<>();
         if (useDefaultStyle) {
-            handlerList.add(new DefaultStyle());
+            //handlerList.add(new DefaultStyle());
         }
         handlerList.addAll(DEFAULT_WRITE_HANDLER_LIST);
         return handlerList;

src/main/java/com/alibaba/excel/write/handler/impl/DefaultRowWriteHandler.java

@@ -12,6 +12,7 @@ import lombok.extern.slf4j.Slf4j;
  */
 @Slf4j
 public class DefaultRowWriteHandler implements RowWriteHandler {
+    public static DefaultRowWriteHandler defaultRowWriteHandler=new DefaultRowWriteHandler();
 
     @Override
     public void afterRowDispose(RowWriteHandlerContext context) {

src/main/java/com/alibaba/excel/write/handler/impl/FillStyleCellWriteHandler.java

@@ -19,11 +19,30 @@ import org.apache.poi.ss.usermodel.CellStyle;
 @Slf4j
 public class FillStyleCellWriteHandler implements CellWriteHandler {
 
+    public static int count=0;
+
+    public static FillStyleCellWriteHandler fillStyleCellWriteHandler = new FillStyleCellWriteHandler();
+
     @Override
     public int order() {
         return OrderConstant.FILL_STYLE;
     }
 
+    @Override
+    public void beforeCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+    }
+
     @Override
     public void afterCellDispose(CellWriteHandlerContext context) {
         if (BooleanUtils.isTrue(context.getIgnoreFillStyle())) {
@@ -41,6 +60,8 @@ public class FillStyleCellWriteHandler implements CellWriteHandler {
         }
         WriteWorkbookHolder writeWorkbookHolder = context.getWriteWorkbookHolder();
         context.getCell().setCellStyle(writeWorkbookHolder.createCellStyle(writeCellStyle, originCellStyle));
+        count++;
+
     }
 
 }

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

@@ -229,15 +229,32 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
         }
 
         //if (hasStyle) {
-            dealStyle(handlerList);
+        dealStyle(handlerList);
         //}
 
         dealRowHigh(handlerList);
         dealOnceAbsoluteMerge(handlerList);
     }
 
+    public static AbstractVerticalCellStyleStrategy abstractVerticalCellStyleStrategy = null;
+
     private void dealStyle(List<WriteHandler> handlerList) {
-        WriteHandler styleStrategy = new AbstractVerticalCellStyleStrategy() {
+        abstractVerticalCellStyleStrategy = new AbstractVerticalCellStyleStrategy() {
+            @Override
+            public void beforeCellCreate(CellWriteHandlerContext context) {
+
+            }
+
+            @Override
+            public void afterCellCreate(CellWriteHandlerContext context) {
+
+            }
+
+            @Override
+            public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+            }
+
             @Override
             public int order() {
                 return OrderConstant.ANNOTATION_DEFINE_STYLE;
@@ -257,7 +274,8 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
                     excelContentProperty.getContentFontProperty());
             }
         };
-        handlerList.add(styleStrategy);
+        //abstractVerticalCellStyleStrategy = styleStrategy;
+        //handlerList.add(abstractVerticalCellStyleStrategy);
     }
 
     private void dealLoopMerge(List<WriteHandler> handlerList, Head head) {
@@ -296,6 +314,21 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
 
     private void dealColumnWidth(List<WriteHandler> handlerList) {
         WriteHandler columnWidthStyleStrategy = new AbstractHeadColumnWidthStyleStrategy() {
+            @Override
+            public void beforeCellCreate(CellWriteHandlerContext context) {
+
+            }
+
+            @Override
+            public void afterCellCreate(CellWriteHandlerContext context) {
+
+            }
+
+            @Override
+            public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+            }
+
             @Override
             protected Integer columnWidth(Head head, Integer columnIndex) {
                 if (head == null) {

src/main/java/com/alibaba/excel/write/style/DefaultStyle.java

@@ -16,6 +16,7 @@ import org.apache.poi.ss.usermodel.VerticalAlignment;
  * @author Jiaju Zhuang
  */
 public class DefaultStyle extends HorizontalCellStyleStrategy {
+    public static DefaultStyle defaultStyle = new DefaultStyle();
 
     @Override
     public int order() {

src/main/java/com/alibaba/excel/write/style/HorizontalCellStyleStrategy.java

@@ -65,4 +65,18 @@ public class HorizontalCellStyleStrategy extends AbstractCellStyleStrategy {
         return context.getFirstCellData() == null;
     }
 
+    @Override
+    public void beforeCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+    }
 }

src/main/java/com/alibaba/excel/write/style/column/LongestMatchColumnWidthStyleStrategy.java

@@ -8,6 +8,7 @@ import com.alibaba.excel.enums.CellDataTypeEnum;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.data.WriteCellData;
 import com.alibaba.excel.util.MapUtils;
+import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
 import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
 
 import org.apache.commons.collections4.CollectionUtils;
@@ -74,4 +75,19 @@ public class LongestMatchColumnWidthStyleStrategy extends AbstractColumnWidthSty
                 return -1;
         }
     }
+
+    @Override
+    public void beforeCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+    }
 }

src/main/java/com/alibaba/excel/write/style/column/SimpleColumnWidthStyleStrategy.java

@@ -1,6 +1,7 @@
 package com.alibaba.excel.write.style.column;
 
 import com.alibaba.excel.metadata.Head;
+import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
 
 /**
  * All the columns are the same width
@@ -22,4 +23,19 @@ public class SimpleColumnWidthStyleStrategy extends AbstractHeadColumnWidthStyle
     protected Integer columnWidth(Head head, Integer columnIndex) {
         return columnWidth;
     }
+
+    @Override
+    public void beforeCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+    }
 }

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

@@ -264,6 +264,21 @@ public class FillStyleAnnotatedTest {
         EasyExcel.write(file, FillData.class).withTemplate(template).sheet()
             .registerWriteHandler(new AbstractVerticalCellStyleStrategy() {
 
+                @Override
+                public void beforeCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+                }
+
                 @Override
                 protected WriteCellStyle contentCellStyle(CellWriteHandlerContext context) {
                     WriteCellStyle writeCellStyle = new WriteCellStyle();

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

@@ -283,6 +283,21 @@ public class FillStyleDataTest {
         EasyExcel.write(file, FillStyleData.class).withTemplate(template).sheet()
             .registerWriteHandler(new AbstractVerticalCellStyleStrategy() {
 
+                @Override
+                public void beforeCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+                }
+
                 @Override
                 protected WriteCellStyle contentCellStyle(CellWriteHandlerContext context) {
                     WriteCellStyle writeCellStyle = new WriteCellStyle();

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

@@ -1,18 +1,14 @@
 package com.alibaba.easyexcel.test.core.handler;
 
-import java.util.List;
-
-import com.alibaba.excel.metadata.Head;
-import com.alibaba.excel.metadata.data.WriteCellData;
 import com.alibaba.excel.write.handler.CellWriteHandler;
 import com.alibaba.excel.write.handler.RowWriteHandler;
 import com.alibaba.excel.write.handler.SheetWriteHandler;
 import com.alibaba.excel.write.handler.WorkbookWriteHandler;
+import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
 import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
 import com.alibaba.excel.write.metadata.holder.WriteTableHolder;
 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;
 
@@ -34,85 +30,6 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
     private long afterWorkbookCreate = 0L;
     private long afterWorkbookDispose = 0L;
 
-    @Override
-    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);
-            beforeCellCreate++;
-        }
-
-    }
-
-    @Override
-    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);
-            afterCellCreate++;
-        }
-    }
-
-    @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);
-        afterCellDataConverted++;
-    }
-
-    @Override
-    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);
-            afterCellDispose++;
-        }
-    }
-
     @Override
     public void beforeRowCreate(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Integer rowIndex,
         Integer relativeRowIndex, Boolean isHead) {
@@ -274,4 +191,24 @@ public class WriteHandler implements WorkbookWriteHandler, SheetWriteHandler, Ro
         Assert.assertEquals(1L, afterWorkbookCreate);
         Assert.assertEquals(1L, afterWorkbookDispose);
     }
+
+    @Override
+    public void beforeCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellDispose(CellWriteHandlerContext context) {
+
+    }
 }

src/test/java/com/alibaba/easyexcel/test/core/large/Cellhanderl.java

@@ -0,0 +1,30 @@
+package com.alibaba.easyexcel.test.core.large;
+
+import com.alibaba.excel.write.handler.CellWriteHandler;
+import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
+
+public class Cellhanderl implements CellWriteHandler {
+
+    public static int cout;
+
+    @Override
+    public void beforeCellCreate(CellWriteHandlerContext context) {
+        cout=context.getColumnIndex();
+    }
+
+    @Override
+    public void afterCellCreate(CellWriteHandlerContext context) {
+        cout=context.getColumnIndex();
+    }
+
+    @Override
+    public void afterCellDataConverted(CellWriteHandlerContext context) {
+        cout=context.getColumnIndex();
+    }
+
+    @Override
+    public void afterCellDispose(CellWriteHandlerContext context) {
+        cout=context.getColumnIndex();
+    }
+
+}

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

@@ -3,18 +3,20 @@ package com.alibaba.easyexcel.test.core.large;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.util.ArrayList;
+import java.util.Iterator;
 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.util.CostUtil;
+import com.alibaba.excel.write.handler.impl.FillStyleCellWriteHandler;
 import com.alibaba.excel.write.metadata.WriteSheet;
 
 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;
@@ -83,30 +85,151 @@ public class LargeDataTest {
         LOGGER.info("CSV large data total time spent:{}", System.currentTimeMillis() - start);
     }
 
+    @Test
+    public void t04Write44() throws Exception {
+        //read();
+        long start = System.currentTimeMillis();
+
+        for (int j = 0; j < 20; j++) {
+            List<LargeData> data = data();
+            LOGGER.info("" + data.size());
+        }
+
+        LOGGER.info("poi写入消费:{}", System.currentTimeMillis() - start);
+
+    }
+
+    @Test
+    public void t04Write445() throws Exception {
+        //read();
+        long start = System.currentTimeMillis();
+
+        for (int j = 0; j < 20; j++) {
+            List<LargeData> data = data2();
+            LOGGER.info("" + data.size());
+        }
+
+        LOGGER.info("poi写入消费:{}", System.currentTimeMillis() - start);
+
+        start = System.currentTimeMillis();
+        LargeData largeData = new LargeData();
+        for (int j = 0; j < 20 * 5000; j++) {
+            largeData.setStr1("1");
+            largeData.setStr2("2");
+            largeData.setStr3("3");
+        }
+
+        LOGGER.info("poi写入消费:{}", System.currentTimeMillis() - start);
+
+    }
+
+    @Test
+    public void t04Writev3() throws Exception {
+        //read();
+        read();
+
+    }
+
     @Test
     public void t04Write() throws Exception {
+        Cellhanderl cellhanderl1 = new Cellhanderl();
+        Cellhanderl cellhanderl2 = new Cellhanderl();
+        Cellhanderl cellhanderl3 = new Cellhanderl();
+        Cellhanderl cellhanderl4 = new Cellhanderl();
+        List<Cellhanderl> list = new ArrayList<>();
+        list.add(cellhanderl1);
+        list.add(cellhanderl2);
+        list.add(cellhanderl3);
+        //list.add(cellhanderl4);
+
         long start = System.currentTimeMillis();
-        ExcelWriter excelWriter = EasyExcel.write(fileWrite07, LargeData.class).build();
+        for (int i = 0; i < 25000075; i++) {
-        WriteSheet writeSheet = EasyExcel.writerSheet().build();
+            for (int j = 0; j < list.size(); j++) {
-        for (int j = 0; j < 100; j++) {
+                Cellhanderl writeHandler = list.get(0);
-            excelWriter.write(data(), writeSheet);
+                writeHandler.beforeCellCreate(null);
-            LOGGER.info("{} write success.", j);
+                writeHandler.afterCellCreate(null);
+                writeHandler.afterCellDataConverted(null);
+                writeHandler.afterCellDispose(null);
+            }
         }
-        excelWriter.finish();
+        LOGGER.info("第一次:{}", System.currentTimeMillis() - start);
-        long cost = System.currentTimeMillis() - start;
+
-        LOGGER.info("write cost:{}", cost);
         start = System.currentTimeMillis();
+        for (int i = 0; i < 25000075; i++) {
+            for (Cellhanderl writeHandler : list) {
+                writeHandler.beforeCellCreate(null);
+                writeHandler.afterCellCreate(null);
+                writeHandler.afterCellDataConverted(null);
+                writeHandler.afterCellDispose(null);
+            }
+        }
+        LOGGER.info("第二次:{}", System.currentTimeMillis() - start);
+
+        start = System.currentTimeMillis();
+        for (int i = 0; i < 25000075; i++) {
+            cellhanderl1.beforeCellCreate(null);
+            cellhanderl1.afterCellCreate(null);
+            cellhanderl1.afterCellDataConverted(null);
+            cellhanderl1.afterCellDispose(null);
+            cellhanderl2.beforeCellCreate(null);
+            cellhanderl2.afterCellCreate(null);
+            cellhanderl2.afterCellDataConverted(null);
+            cellhanderl2.afterCellDispose(null);
+            cellhanderl3.beforeCellCreate(null);
+            cellhanderl3.afterCellCreate(null);
+            cellhanderl3.afterCellDataConverted(null);
+            cellhanderl3.afterCellDispose(null);
+
+        }
+        LOGGER.info("第三次:{}", System.currentTimeMillis() - start);
+
+        start = System.currentTimeMillis();
+        for (int i = 0; i < 25000075; i++) {
+            Iterator<Cellhanderl> iterator = list.iterator();
+            while (iterator.hasNext()) {
+                Cellhanderl writeHandler = iterator.next();
+                writeHandler.beforeCellCreate(null);
+                writeHandler.afterCellCreate(null);
+                writeHandler.afterCellDataConverted(null);
+                writeHandler.afterCellDispose(null);
+            }
+        }
+
+        LOGGER.info("第四次:{}", System.currentTimeMillis() - start);
+
+        start = System.currentTimeMillis();
+        for (int i = 0; i < 25000075; i++) {
+            list.stream().forEach(writeHandler->{
+                writeHandler.beforeCellCreate(null);
+                writeHandler.afterCellCreate(null);
+                writeHandler.afterCellDataConverted(null);
+                writeHandler.afterCellDispose(null);
+            });
+        }
+
+        LOGGER.info("第五次:{}", System.currentTimeMillis() - start);
+    }
+
+    private void v2(Cellhanderl cellhanderl1) {
+        cellhanderl1.beforeCellCreate(null);
+        cellhanderl1.afterCellCreate(null);
+        cellhanderl1.afterCellDataConverted(null);
+        cellhanderl1.afterCellDispose(null);
+    }
+
+    private void read() throws Exception {
+        long start = System.currentTimeMillis();
         try (FileOutputStream fileOutputStream = new FileOutputStream(fileWritePoi07)) {
             SXSSFWorkbook workbook = new SXSSFWorkbook();
             SXSSFSheet sheet = workbook.createSheet("sheet1");
-            for (int i = 0; i < 100 * 5000; i++) {
+            for (int i = 0; i < 20 * 5000; i++) {
                 SXSSFRow row = sheet.createRow(i);
                 for (int j = 0; j < 25; j++) {
                     SXSSFCell cell = row.createCell(j);
                     cell.setCellValue("str-" + j + "-" + i);
                 }
                 if (i % 5000 == 0) {
-                    LOGGER.info("{} write success.", i);
+                    //LOGGER.info("{} write success.", i);
                 }
             }
             workbook.write(fileOutputStream);
@@ -114,8 +237,34 @@ public class LargeDataTest {
             workbook.close();
         }
         long costPoi = System.currentTimeMillis() - start;
-        LOGGER.info("poi write cost:{}", System.currentTimeMillis() - start);
+        LOGGER.info("poi写入消费:{}", System.currentTimeMillis() - start);
-        Assert.assertTrue(costPoi * 3 > cost);
+
+        start = System.currentTimeMillis();
+        ExcelWriter excelWriter = EasyExcel.write(fileWrite07, LargeData.class)
+            //.registerWriteHandler(new Cellhanderl())
+            //.registerWriteHandler(new Cellhanderl())
+            //.registerWriteHandler(new Cellhanderl())
+            //.registerWriteHandler(new Cellhanderl())
+            //.registerWriteHandler(new Cellhanderl())
+            //.registerWriteHandler(new Cellhanderl())
+            //.registerWriteHandler(new Cellhanderl())
+            .build();
+        WriteSheet writeSheet = EasyExcel.writerSheet().build();
+        for (int j = 0; j < 50; j++) {
+            long s1 = System.currentTimeMillis();
+            excelWriter.write(data(), writeSheet);
+            LOGGER.info("平均.{}", System.currentTimeMillis() - s1);
+        }
+        excelWriter.finish();
+        long cost = System.currentTimeMillis() - start;
+        LOGGER.info("easyxcel写入:{}", cost);
+        //LOGGER.info("easyxcel写入:{}", FillStyleCellWriteHandler.count);
+        LOGGER.info("easyxcel写入:{}", Cellhanderl.cout);
+        LOGGER.info("easyxcel写入:{}", CostUtil.count2);
+        LOGGER.info("easyxcel写入:{}", CostUtil.count);
+        LOGGER.info("easyxcel写入:{}", FillStyleCellWriteHandler.count);
+
+
     }
 
     private List<LargeData> data() {
@@ -152,4 +301,17 @@ public class LargeDataTest {
         }
         return list;
     }
+
+    private List<LargeData> data2() {
+        List<LargeData> list = new ArrayList<>();
+        int size = i + 5000;
+        for (; i < size; i++) {
+            LargeData largeData = new LargeData();
+            list.add(largeData);
+            largeData.setStr1("1");
+            largeData.setStr2("2");
+            largeData.setStr3("3");
+        }
+        return list;
+    }
 }

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

@@ -13,6 +13,7 @@ import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.data.DataFormatData;
 import com.alibaba.excel.metadata.property.FontProperty;
 import com.alibaba.excel.metadata.property.StyleProperty;
+import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
 import com.alibaba.excel.write.merge.LoopMergeStrategy;
 import com.alibaba.excel.write.merge.OnceAbsoluteMergeStrategy;
 import com.alibaba.excel.write.metadata.style.WriteCellStyle;
@@ -73,6 +74,21 @@ public class StyleDataTest {
     @Test
     public void t03AbstractVerticalCellStyleStrategy() {
         AbstractVerticalCellStyleStrategy verticalCellStyleStrategy = new AbstractVerticalCellStyleStrategy() {
+            @Override
+            public void beforeCellCreate(CellWriteHandlerContext context) {
+
+            }
+
+            @Override
+            public void afterCellCreate(CellWriteHandlerContext context) {
+
+            }
+
+            @Override
+            public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+            }
+
             @Override
             protected WriteCellStyle headCellStyle(Head head) {
                 WriteCellStyle writeCellStyle = new WriteCellStyle();
@@ -137,6 +153,21 @@ public class StyleDataTest {
         final StyleProperty styleProperty = StyleProperty.build(StyleData.class.getAnnotation(HeadStyle.class));
         final FontProperty fontProperty = FontProperty.build(StyleData.class.getAnnotation(HeadFontStyle.class));
         AbstractVerticalCellStyleStrategy verticalCellStyleStrategy = new AbstractVerticalCellStyleStrategy() {
+            @Override
+            public void beforeCellCreate(CellWriteHandlerContext context) {
+
+            }
+
+            @Override
+            public void afterCellCreate(CellWriteHandlerContext context) {
+
+            }
+
+            @Override
+            public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+            }
+
             @Override
             protected WriteCellStyle headCellStyle(Head head) {
                 WriteCellStyle writeCellStyle = WriteCellStyle.build(styleProperty, fontProperty);

src/test/java/com/alibaba/easyexcel/test/demo/write/CustomCellWriteHandler.java

@@ -18,6 +18,21 @@ import org.apache.poi.ss.usermodel.Hyperlink;
 @Slf4j
 public class CustomCellWriteHandler implements CellWriteHandler {
 
+    @Override
+    public void beforeCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellCreate(CellWriteHandlerContext context) {
+
+    }
+
+    @Override
+    public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+    }
+
     @Override
     public void afterCellDispose(CellWriteHandlerContext context) {
         Cell cell = context.getCell();

src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java

@@ -507,6 +507,21 @@ public class WriteTest {
         fileName = TestFileUtil.getPath() + "handlerStyleWrite" + System.currentTimeMillis() + ".xlsx";
         EasyExcel.write(fileName, DemoData.class)
             .registerWriteHandler(new CellWriteHandler() {
+                @Override
+                public void beforeCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+                }
+
                 @Override
                 public void afterCellDispose(CellWriteHandlerContext context) {
                     // 当前事件会在 数据设置到poi的cell里面才会回调
@@ -537,6 +552,21 @@ public class WriteTest {
         fileName = TestFileUtil.getPath() + "handlerStyleWrite" + System.currentTimeMillis() + ".xlsx";
         EasyExcel.write(fileName, DemoData.class)
             .registerWriteHandler(new CellWriteHandler() {
+                @Override
+                public void beforeCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+                }
+
                 @Override
                 public void afterCellDispose(CellWriteHandlerContext context) {
                     // 当前事件会在 数据设置到poi的cell里面才会回调

src/test/java/com/alibaba/easyexcel/test/temp/WriteV33Test.java

@@ -97,6 +97,21 @@ public class WriteV33Test {
         fileName = TestFileUtil.getPath() + "handlerStyleWrite" + System.currentTimeMillis() + ".xlsx";
         EasyExcel.write(fileName, DemoData.class)
             .registerWriteHandler(new CellWriteHandler() {
+                @Override
+                public void beforeCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellCreate(CellWriteHandlerContext context) {
+
+                }
+
+                @Override
+                public void afterCellDataConverted(CellWriteHandlerContext context) {
+
+                }
+
                 @Override
                 public void afterCellDispose(CellWriteHandlerContext context) {
                     // 当前事件会在 数据设置到poi的cell里面才会回调

src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteCellHandler.java

@@ -1,39 +1,51 @@
 package com.alibaba.easyexcel.test.temp.simple;
 
-import com.alibaba.excel.metadata.Head;
-import com.alibaba.excel.metadata.data.WriteCellData;
 import com.alibaba.excel.write.handler.CellWriteHandler;
-import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
+import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
-import com.alibaba.excel.write.metadata.holder.WriteTableHolder;
 
 import lombok.extern.slf4j.Slf4j;
-import org.apache.poi.ss.usermodel.Cell;
-import org.apache.poi.ss.usermodel.CellStyle;
-import org.apache.poi.ss.usermodel.CreationHelper;
-import org.apache.poi.ss.usermodel.DataFormat;
-import org.apache.poi.ss.usermodel.IndexedColors;
 
 /**
  * @author Jiaju Zhuang
  */
 @Slf4j
 public class WriteCellHandler implements CellWriteHandler {
+    //
+    //@Override
+    //public void afterCellDataConverted(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
+    //    WriteCellData<?> cellData, Cell cell, Head head, Integer integer, Boolean isHead) {
+    //
+    //    if (!isHead) {
+    //        CreationHelper createHelper = writeSheetHolder.getSheet().getWorkbook().getCreationHelper();
+    //        CellStyle cellStyle = writeSheetHolder.getSheet().getWorkbook().createCellStyle();
+    //        if (cellStyle != null) {
+    //            DataFormat dataFormat = createHelper.createDataFormat();
+    //            cellStyle.setWrapText(true);
+    //            cellStyle.setFillBackgroundColor(IndexedColors.RED.getIndex());
+    //            cellStyle.setBottomBorderColor(IndexedColors.RED.getIndex());
+    //            cellStyle.setDataFormat(dataFormat.getFormat("yyyy-MM-dd"));
+    //            cell.setCellStyle(cellStyle);
+    //        }
+    //    }
+    //}
 
     @Override
-    public void afterCellDataConverted(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
+    public void beforeCellCreate(CellWriteHandlerContext context) {
-        WriteCellData<?> cellData, Cell cell, Head head, Integer integer, Boolean isHead) {
+
-
+    }
-        if (!isHead) {
+
-            CreationHelper createHelper = writeSheetHolder.getSheet().getWorkbook().getCreationHelper();
+    @Override
-            CellStyle cellStyle = writeSheetHolder.getSheet().getWorkbook().createCellStyle();
+    public void afterCellCreate(CellWriteHandlerContext context) {
-            if (cellStyle != null) {
+
-                DataFormat dataFormat = createHelper.createDataFormat();
+    }
-                cellStyle.setWrapText(true);
+
-                cellStyle.setFillBackgroundColor(IndexedColors.RED.getIndex());
+    @Override
-                cellStyle.setBottomBorderColor(IndexedColors.RED.getIndex());
+    public void afterCellDataConverted(CellWriteHandlerContext context) {
-                cellStyle.setDataFormat(dataFormat.getFormat("yyyy-MM-dd"));
+
-                cell.setCellStyle(cellStyle);
+    }
-            }
+
-        }
+    @Override
+    public void afterCellDispose(CellWriteHandlerContext context) {
+
     }
 }