diff --git a/src/main/java/com/alibaba/excel/util/ClassUtils.java b/src/main/java/com/alibaba/excel/util/ClassUtils.java index 9020d56c..8c7dd6b4 100644 --- a/src/main/java/com/alibaba/excel/util/ClassUtils.java +++ b/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 CONTENT_CACHE = new ConcurrentHashMap<>(); + public static final Map 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) { - String key = ""; - if (clazz != null) { - key += clazz.getName(); - } - key += "-"; - if (headClass != null) { - key += headClass.getName(); - } - key += "-"; - if (fieldName != null) { - key += fieldName; - } - return key; + private static ContentPropertyKey buildKey(Class clazz, Class headClass, String fieldName) { + return new ContentPropertyKey(clazz, headClass, fieldName); } private static Map 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; + } } diff --git a/src/main/java/com/alibaba/excel/util/CostUtil.java b/src/main/java/com/alibaba/excel/util/CostUtil.java new file mode 100644 index 00000000..80dba36d --- /dev/null +++ b/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(); + } +} diff --git a/src/main/java/com/alibaba/excel/util/WriteHandlerUtils.java b/src/main/java/com/alibaba/excel/util/WriteHandlerUtils.java index cb04b956..a1ac1efd 100644 --- a/src/main/java/com/alibaba/excel/util/WriteHandlerUtils.java +++ b/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 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 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 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 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 handlerList = context.getHandlerList(); + DefaultRowWriteHandler.defaultRowWriteHandler.afterRowDispose(context); if (CollectionUtils.isNotEmpty(handlerList)) { for (WriteHandler writeHandler : handlerList) { ((RowWriteHandler)writeHandler).afterRowDispose(context); diff --git a/src/main/java/com/alibaba/excel/write/handler/AbstractCellWriteHandler.java b/src/main/java/com/alibaba/excel/write/handler/AbstractCellWriteHandler.java index 688598ac..54dd6f13 100644 --- a/src/main/java/com/alibaba/excel/write/handler/AbstractCellWriteHandler.java +++ b/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> cellDataList, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) { - - } } diff --git a/src/main/java/com/alibaba/excel/write/handler/CellWriteHandler.java b/src/main/java/com/alibaba/excel/write/handler/CellWriteHandler.java index fd144e1c..b1ec84c4 100644 --- a/src/main/java/com/alibaba/excel/write/handler/CellWriteHandler.java +++ b/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) { - beforeCellCreate(context.getWriteSheetHolder(), context.getWriteTableHolder(), context.getRow(), - context.getHeadData(), context.getColumnIndex(), context.getRelativeRowIndex(), context.getHead()); - } + void beforeCellCreate(CellWriteHandlerContext context); - /** - * 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) { - afterCellCreate(context.getWriteSheetHolder(), context.getWriteTableHolder(), context.getCell(), - context.getHeadData(), context.getRelativeRowIndex(), context.getHead()); - } + void afterCellCreate(CellWriteHandlerContext context) ; - /** - * 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 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. + * @param context */ - default void afterCellDataConverted(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, - WriteCellData cellData, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {} + void afterCellDataConverted(CellWriteHandlerContext context); /** * Called after all operations on the cell have been completed * * @param context */ - default void afterCellDispose(CellWriteHandlerContext context) { - afterCellDispose(context.getWriteSheetHolder(), context.getWriteTableHolder(), context.getCellDataList(), - context.getCell(), context.getHeadData(), context.getRelativeRowIndex(), context.getHead()); - } + void afterCellDispose(CellWriteHandlerContext context); - /** - * 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> cellDataList, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {} } diff --git a/src/main/java/com/alibaba/excel/write/handler/DefaultWriteHandlerLoader.java b/src/main/java/com/alibaba/excel/write/handler/DefaultWriteHandlerLoader.java index 7fda3908..9f0e21c4 100644 --- a/src/main/java/com/alibaba/excel/write/handler/DefaultWriteHandlerLoader.java +++ b/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 loadDefaultHandler(Boolean useDefaultStyle) { List handlerList = new ArrayList<>(); if (useDefaultStyle) { - handlerList.add(new DefaultStyle()); + //handlerList.add(new DefaultStyle()); } handlerList.addAll(DEFAULT_WRITE_HANDLER_LIST); return handlerList; diff --git a/src/main/java/com/alibaba/excel/write/handler/impl/DefaultRowWriteHandler.java b/src/main/java/com/alibaba/excel/write/handler/impl/DefaultRowWriteHandler.java index 2d1f3f77..e36b6d22 100644 --- a/src/main/java/com/alibaba/excel/write/handler/impl/DefaultRowWriteHandler.java +++ b/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) { diff --git a/src/main/java/com/alibaba/excel/write/handler/impl/FillStyleCellWriteHandler.java b/src/main/java/com/alibaba/excel/write/handler/impl/FillStyleCellWriteHandler.java index d3680e24..ef1269fc 100644 --- a/src/main/java/com/alibaba/excel/write/handler/impl/FillStyleCellWriteHandler.java +++ b/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++; + } } diff --git a/src/main/java/com/alibaba/excel/write/metadata/holder/AbstractWriteHolder.java b/src/main/java/com/alibaba/excel/write/metadata/holder/AbstractWriteHolder.java index 2961efc0..64ef6360 100644 --- a/src/main/java/com/alibaba/excel/write/metadata/holder/AbstractWriteHolder.java +++ b/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 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 handlerList, Head head) { @@ -296,6 +314,21 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ private void dealColumnWidth(List 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) { diff --git a/src/main/java/com/alibaba/excel/write/style/DefaultStyle.java b/src/main/java/com/alibaba/excel/write/style/DefaultStyle.java index 139998ef..44780b73 100644 --- a/src/main/java/com/alibaba/excel/write/style/DefaultStyle.java +++ b/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() { diff --git a/src/main/java/com/alibaba/excel/write/style/HorizontalCellStyleStrategy.java b/src/main/java/com/alibaba/excel/write/style/HorizontalCellStyleStrategy.java index 8f033710..646b77ec 100644 --- a/src/main/java/com/alibaba/excel/write/style/HorizontalCellStyleStrategy.java +++ b/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) { + + } } diff --git a/src/main/java/com/alibaba/excel/write/style/column/LongestMatchColumnWidthStyleStrategy.java b/src/main/java/com/alibaba/excel/write/style/column/LongestMatchColumnWidthStyleStrategy.java index d248de13..77d88b6d 100644 --- a/src/main/java/com/alibaba/excel/write/style/column/LongestMatchColumnWidthStyleStrategy.java +++ b/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) { + + } } diff --git a/src/main/java/com/alibaba/excel/write/style/column/SimpleColumnWidthStyleStrategy.java b/src/main/java/com/alibaba/excel/write/style/column/SimpleColumnWidthStyleStrategy.java index 316ff2c8..677208cb 100644 --- a/src/main/java/com/alibaba/excel/write/style/column/SimpleColumnWidthStyleStrategy.java +++ b/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) { + + } } diff --git a/src/test/java/com/alibaba/easyexcel/test/core/fill/style/FillStyleAnnotatedTest.java b/src/test/java/com/alibaba/easyexcel/test/core/fill/style/FillStyleAnnotatedTest.java index 13367904..c177a33c 100644 --- a/src/test/java/com/alibaba/easyexcel/test/core/fill/style/FillStyleAnnotatedTest.java +++ b/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(); diff --git a/src/test/java/com/alibaba/easyexcel/test/core/fill/style/FillStyleDataTest.java b/src/test/java/com/alibaba/easyexcel/test/core/fill/style/FillStyleDataTest.java index 210a5b9f..afb424be 100644 --- a/src/test/java/com/alibaba/easyexcel/test/core/fill/style/FillStyleDataTest.java +++ b/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(); diff --git a/src/test/java/com/alibaba/easyexcel/test/core/handler/WriteHandler.java b/src/test/java/com/alibaba/easyexcel/test/core/handler/WriteHandler.java index a6f07014..77fd937c 100644 --- a/src/test/java/com/alibaba/easyexcel/test/core/handler/WriteHandler.java +++ b/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> 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) { + + } } diff --git a/src/test/java/com/alibaba/easyexcel/test/core/large/Cellhanderl.java b/src/test/java/com/alibaba/easyexcel/test/core/large/Cellhanderl.java new file mode 100644 index 00000000..f20b2d33 --- /dev/null +++ b/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(); + } + +} diff --git a/src/test/java/com/alibaba/easyexcel/test/core/large/LargeDataTest.java b/src/test/java/com/alibaba/easyexcel/test/core/large/LargeDataTest.java index 3da8500d..4ab85507 100644 --- a/src/test/java/com/alibaba/easyexcel/test/core/large/LargeDataTest.java +++ b/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 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 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 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(); - WriteSheet writeSheet = EasyExcel.writerSheet().build(); - for (int j = 0; j < 100; j++) { - excelWriter.write(data(), writeSheet); - LOGGER.info("{} write success.", j); + for (int i = 0; i < 25000075; i++) { + for (int j = 0; j < list.size(); j++) { + Cellhanderl writeHandler = list.get(0); + writeHandler.beforeCellCreate(null); + writeHandler.afterCellCreate(null); + writeHandler.afterCellDataConverted(null); + writeHandler.afterCellDispose(null); + } } - excelWriter.finish(); - long cost = System.currentTimeMillis() - start; - LOGGER.info("write cost:{}", cost); + LOGGER.info("第一次:{}", System.currentTimeMillis() - start); + 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 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); - Assert.assertTrue(costPoi * 3 > cost); + LOGGER.info("poi写入消费:{}", System.currentTimeMillis() - start); + + 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 data() { @@ -152,4 +301,17 @@ public class LargeDataTest { } return list; } + + private List data2() { + List 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; + } } diff --git a/src/test/java/com/alibaba/easyexcel/test/core/style/StyleDataTest.java b/src/test/java/com/alibaba/easyexcel/test/core/style/StyleDataTest.java index a48c3238..67cf6cf3 100644 --- a/src/test/java/com/alibaba/easyexcel/test/core/style/StyleDataTest.java +++ b/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); diff --git a/src/test/java/com/alibaba/easyexcel/test/demo/write/CustomCellWriteHandler.java b/src/test/java/com/alibaba/easyexcel/test/demo/write/CustomCellWriteHandler.java index 81e12f52..50ebd4fa 100644 --- a/src/test/java/com/alibaba/easyexcel/test/demo/write/CustomCellWriteHandler.java +++ b/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(); diff --git a/src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java b/src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java index 7af059f3..4ea83981 100644 --- a/src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java +++ b/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里面才会回调 diff --git a/src/test/java/com/alibaba/easyexcel/test/temp/WriteV33Test.java b/src/test/java/com/alibaba/easyexcel/test/temp/WriteV33Test.java index 4e258e51..73030d28 100644 --- a/src/test/java/com/alibaba/easyexcel/test/temp/WriteV33Test.java +++ b/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里面才会回调 diff --git a/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteCellHandler.java b/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteCellHandler.java index b92005c7..99618c8b 100644 --- a/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteCellHandler.java +++ b/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.metadata.holder.WriteTableHolder; +import com.alibaba.excel.write.handler.context.CellWriteHandlerContext; 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, - 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); - } - } + public void beforeCellCreate(CellWriteHandlerContext context) { + + } + + @Override + public void afterCellCreate(CellWriteHandlerContext context) { + + } + + @Override + public void afterCellDataConverted(CellWriteHandlerContext context) { + + } + + @Override + public void afterCellDispose(CellWriteHandlerContext context) { + } }