完成填充支持样式

src/main/java/com/alibaba/excel/annotation/ExcelProperty.java

@@ -54,7 +54,7 @@ public @interface ExcelProperty {
      *
      * @return Converter
      */
-    Class<? extends Converter> converter() default AutoConverter.class;
+    Class<? extends Converter<?>> converter() default AutoConverter.class;
 
     /**
      *

src/main/java/com/alibaba/excel/context/WriteContextImpl.java

@@ -10,7 +10,9 @@ import com.alibaba.excel.enums.WriteTypeEnum;
 import com.alibaba.excel.exception.ExcelGenerateException;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.data.WriteCellData;
+import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.support.ExcelTypeEnum;
+import com.alibaba.excel.util.ClassUtils;
 import com.alibaba.excel.util.DateUtils;
 import com.alibaba.excel.util.FileUtils;
 import com.alibaba.excel.util.NumberDataFormatterUtils;
@@ -244,17 +246,21 @@ public class WriteContextImpl implements WriteContext {
         for (Map.Entry<Integer, Head> entry : headMap.entrySet()) {
             Head head = entry.getValue();
             int columnIndex = entry.getKey();
-            WriteHandlerUtils.beforeCellCreate(this, row, head, columnIndex, relativeRowIndex, Boolean.TRUE);
+            ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(null,
+                currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), head.getFieldName());
+
+            WriteHandlerUtils.beforeCellCreate(this, row, head, columnIndex, relativeRowIndex, Boolean.TRUE,
+                excelContentProperty);
 
             Cell cell = row.createCell(columnIndex);
 
-            WriteHandlerUtils.afterCellCreate(this, cell, head, relativeRowIndex, Boolean.TRUE);
+            WriteHandlerUtils.afterCellCreate(this, cell, head, relativeRowIndex, Boolean.TRUE, excelContentProperty);
 
             WriteCellData<String> writeCellData = new WriteCellData<>(head.getHeadNameList().get(relativeRowIndex));
             cell.setCellValue(writeCellData.getStringValue());
 
-            WriteHandlerUtils.afterCellDispose(this, writeCellData, cell, head, relativeRowIndex,
+            WriteHandlerUtils.afterCellDispose(this, writeCellData, cell, head, relativeRowIndex, Boolean.TRUE,
-                Boolean.TRUE);
+                excelContentProperty);
         }
     }
 

src/main/java/com/alibaba/excel/metadata/Head.java

@@ -1,5 +1,6 @@
 package com.alibaba.excel.metadata;
 
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -22,6 +23,10 @@ public class Head {
      * Column index of head
      */
     private Integer columnIndex;
+    /**
+     * It only has values when passed in {@link Sheet#setClazz(Class)} and {@link Table#setClazz(Class)}
+     */
+    private Field field;
     /**
      * It only has values when passed in {@link Sheet#setClazz(Class)} and {@link Table#setClazz(Class)}
      */
@@ -38,10 +43,12 @@ public class Head {
      * Whether to specify a name
      */
     private Boolean forceName;
+
     /**
      * column with
      */
     private ColumnWidthProperty columnWidthProperty;
+
     /**
      * Loop merge
      */
@@ -50,22 +57,15 @@ public class Head {
      * Head style
      */
     private StyleProperty headStyleProperty;
-    /**
-     * Content style
-     */
-    private StyleProperty contentStyleProperty;
     /**
      * Head font
      */
     private FontProperty headFontProperty;
-    /**
-     * Content font
-     */
-    private FontProperty contentFontProperty;
 
-    public Head(Integer columnIndex, String fieldName, List<String> headNameList, Boolean forceIndex,
+    public Head(Integer columnIndex, Field field, String fieldName, List<String> headNameList, Boolean forceIndex,
         Boolean forceName) {
         this.columnIndex = columnIndex;
+        this.field = field;
         this.fieldName = fieldName;
         if (headNameList == null) {
             this.headNameList = new ArrayList<>();

src/main/java/com/alibaba/excel/metadata/data/WriteCellData.java

@@ -8,6 +8,7 @@ import java.util.List;
 
 import com.alibaba.excel.enums.CellDataTypeEnum;
 import com.alibaba.excel.util.ListUtils;
+import com.alibaba.excel.write.metadata.fill.AnalysisCell;
 import com.alibaba.excel.write.metadata.style.WriteCellStyle;
 
 import lombok.Data;
@@ -43,6 +44,7 @@ public class WriteCellData<T> extends CellData<T> {
      * hyper link
      */
     private HyperlinkData hyperlinkData;
+
     /**
      * style
      */
@@ -54,6 +56,11 @@ public class WriteCellData<T> extends CellData<T> {
      */
     private CellStyle originCellStyle;
 
+    /**
+     * Only in the case of the fill is not null
+     */
+    private AnalysisCell analysisCell;
+
     public WriteCellData(String stringValue) {
         this(CellDataTypeEnum.STRING, stringValue);
     }

src/main/java/com/alibaba/excel/metadata/property/ExcelContentProperty.java

@@ -3,7 +3,6 @@ package com.alibaba.excel.metadata.property;
 import java.lang.reflect.Field;
 
 import com.alibaba.excel.converters.Converter;
-import com.alibaba.excel.metadata.Head;
 
 import lombok.Data;
 
@@ -12,18 +11,30 @@ import lombok.Data;
  */
 @Data
 public class ExcelContentProperty {
+    public static final ExcelContentProperty EMPTY = new ExcelContentProperty();
+
     /**
      * Java filed
      */
     private Field field;
-    /**
-     * Excel head
-     */
-    private Head head;
     /**
      * Custom defined converters
      */
     private Converter<?> converter;
+    /**
+     * date time format
+     */
     private DateTimeFormatProperty dateTimeFormatProperty;
+    /**
+     * number format
+     */
     private NumberFormatProperty numberFormatProperty;
+    /**
+     * Content style
+     */
+    private StyleProperty contentStyleProperty;
+    /**
+     * Content font
+     */
+    private FontProperty contentFontProperty;
 }

src/main/java/com/alibaba/excel/metadata/property/ExcelHeadProperty.java

@@ -8,15 +8,11 @@ import java.util.Map;
 import java.util.TreeMap;
 
 import com.alibaba.excel.annotation.ExcelProperty;
-import com.alibaba.excel.annotation.format.DateTimeFormat;
-import com.alibaba.excel.annotation.format.NumberFormat;
-import com.alibaba.excel.converters.AutoConverter;
-import com.alibaba.excel.converters.Converter;
 import com.alibaba.excel.enums.HeadKindEnum;
-import com.alibaba.excel.exception.ExcelCommonException;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.Holder;
 import com.alibaba.excel.util.ClassUtils;
+import com.alibaba.excel.util.FieldUtils;
 import com.alibaba.excel.util.MapUtils;
 import com.alibaba.excel.util.StringUtils;
 import com.alibaba.excel.write.metadata.holder.AbstractWriteHolder;
@@ -38,7 +34,7 @@ public class ExcelHeadProperty {
     /**
      * Custom class
      */
-    private Class headClazz;
+    private Class<?> headClazz;
     /**
      * The types of head
      */
@@ -51,24 +47,14 @@ public class ExcelHeadProperty {
      * Configuration header information
      */
     private Map<Integer, Head> headMap;
-    /**
-     * Configuration column information
-     */
-    private Map<Integer, ExcelContentProperty> contentPropertyMap;
-    /**
-     * Configuration column information
-     */
-    private Map<String, ExcelContentProperty> fieldNameContentPropertyMap;
     /**
      * Fields ignored
      */
     private Map<String, Field> ignoreMap;
 
-    public ExcelHeadProperty(Holder holder, Class headClazz, List<List<String>> head) {
+    public ExcelHeadProperty(Holder holder, Class<?> headClazz, List<List<String>> head) {
         this.headClazz = headClazz;
         headMap = new TreeMap<>();
-        contentPropertyMap = new TreeMap<>();
-        fieldNameContentPropertyMap = MapUtils.newHashMap();
         ignoreMap = MapUtils.newHashMap();
         headKind = HeadKindEnum.NONE;
         headRowNumber = 0;
@@ -80,8 +66,7 @@ public class ExcelHeadProperty {
                         continue;
                     }
                 }
-                headMap.put(headIndex, new Head(headIndex, null, head.get(i), Boolean.FALSE, Boolean.TRUE));
+                headMap.put(headIndex, new Head(headIndex, null, null, head.get(i), Boolean.FALSE, Boolean.TRUE));
-                contentPropertyMap.put(headIndex, null);
                 headIndex++;
             }
             headKind = HeadKindEnum.STRING;
@@ -148,39 +133,20 @@ public class ExcelHeadProperty {
     private void initOneColumnProperty(int index, Field field, Boolean forceIndex) {
         ExcelProperty excelProperty = field.getAnnotation(ExcelProperty.class);
         List<String> tmpHeadList = new ArrayList<String>();
+        String fieldName = FieldUtils.resolveCglibFieldName(field);
         boolean notForceName = excelProperty == null || excelProperty.value().length <= 0
             || (excelProperty.value().length == 1 && StringUtils.isEmpty((excelProperty.value())[0]));
         if (headMap.containsKey(index)) {
             tmpHeadList.addAll(headMap.get(index).getHeadNameList());
         } else {
             if (notForceName) {
-                tmpHeadList.add(field.getName());
+                tmpHeadList.add(fieldName);
             } else {
                 Collections.addAll(tmpHeadList, excelProperty.value());
             }
         }
-        Head head = new Head(index, field.getName(), tmpHeadList, forceIndex, !notForceName);
+        Head head = new Head(index, field, fieldName, tmpHeadList, forceIndex, !notForceName);
-        ExcelContentProperty excelContentProperty = new ExcelContentProperty();
-        if (excelProperty != null) {
-            Class<? extends Converter> convertClazz = excelProperty.converter();
-            if (convertClazz != AutoConverter.class) {
-                try {
-                    Converter converter = convertClazz.newInstance();
-                    excelContentProperty.setConverter(converter);
-                } catch (Exception e) {
-                    throw new ExcelCommonException("Can not instance custom converter:" + convertClazz.getName());
-                }
-            }
-        }
-        excelContentProperty.setHead(head);
-        excelContentProperty.setField(field);
-        excelContentProperty
-            .setDateTimeFormatProperty(DateTimeFormatProperty.build(field.getAnnotation(DateTimeFormat.class)));
-        excelContentProperty
-            .setNumberFormatProperty(NumberFormatProperty.build(field.getAnnotation(NumberFormat.class)));
         headMap.put(index, head);
-        contentPropertyMap.put(index, excelContentProperty);
-        fieldNameContentPropertyMap.put(field.getName(), excelContentProperty);
     }
 
     public boolean hasHead() {

src/main/java/com/alibaba/excel/read/listener/ModelBuildEventListener.java

@@ -8,14 +8,14 @@ import com.alibaba.excel.enums.HeadKindEnum;
 import com.alibaba.excel.exception.ExcelDataConvertException;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.data.ReadCellData;
-import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.read.metadata.holder.ReadSheetHolder;
 import com.alibaba.excel.read.metadata.property.ExcelReadHeadProperty;
 import com.alibaba.excel.util.BeanMapUtils;
+import com.alibaba.excel.util.ClassUtils;
 import com.alibaba.excel.util.ConverterUtils;
-import com.alibaba.excel.util.FieldUtils;
 import com.alibaba.excel.util.MapUtils;
 
+import net.sf.cglib.beans.BeanMap;
 import org.apache.commons.collections4.CollectionUtils;
 
 /**
@@ -92,22 +92,23 @@ public class ModelBuildEventListener implements ReadListener<Map<Integer, ReadCe
         }
         Map<Integer, Head> headMap = excelReadHeadProperty.getHeadMap();
         Map<String, Object> map = MapUtils.newHashMapWithExpectedSize(headMap.size());
-        Map<Integer, ExcelContentProperty> contentPropertyMap = excelReadHeadProperty.getContentPropertyMap();
+        BeanMap dataMap = BeanMapUtils.create(resultModel);
         for (Map.Entry<Integer, Head> entry : headMap.entrySet()) {
             Integer index = entry.getKey();
+            Head head = entry.getValue();
+            String fieldName = head.getFieldName();
             if (!cellDataMap.containsKey(index)) {
                 continue;
             }
             ReadCellData<?> cellData = cellDataMap.get(index);
-            ExcelContentProperty excelContentProperty = contentPropertyMap.get(index);
+            Object value = ConverterUtils.convertToJavaObject(cellData, head.getField(),
-            Object value = ConverterUtils.convertToJavaObject(cellData, excelContentProperty.getField(),
+                ClassUtils.declaredExcelContentProperty(dataMap, readSheetHolder.excelReadHeadProperty().getHeadClazz(),
-                excelContentProperty, readSheetHolder.converterMap(), context,
+                    fieldName), readSheetHolder.converterMap(), context, context.readRowHolder().getRowIndex(), index);
-                context.readRowHolder().getRowIndex(), index);
             if (value != null) {
-                map.put(FieldUtils.resolveCglibFieldName(excelContentProperty.getField()), value);
+                map.put(fieldName, value);
             }
         }
-        BeanMapUtils.create(resultModel).putAll(map);
+        dataMap.putAll(map);
         return resultModel;
     }
 

src/main/java/com/alibaba/excel/read/processor/DefaultAnalysisEventProcessor.java

@@ -11,7 +11,6 @@ import com.alibaba.excel.exception.ExcelAnalysisException;
 import com.alibaba.excel.exception.ExcelAnalysisStopException;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.data.ReadCellData;
-import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.read.listener.ReadListener;
 import com.alibaba.excel.read.metadata.holder.ReadRowHolder;
 import com.alibaba.excel.read.metadata.property.ExcelReadHeadProperty;
@@ -118,15 +117,11 @@ public class DefaultAnalysisEventProcessor implements AnalysisEventProcessor {
         Map<Integer, String> dataMap = ConverterUtils.convertToStringMap(cellDataMap, analysisContext);
         ExcelReadHeadProperty excelHeadPropertyData = analysisContext.readSheetHolder().excelReadHeadProperty();
         Map<Integer, Head> headMapData = excelHeadPropertyData.getHeadMap();
-        Map<Integer, ExcelContentProperty> contentPropertyMapData = excelHeadPropertyData.getContentPropertyMap();
         Map<Integer, Head> tmpHeadMap = new HashMap<Integer, Head>(headMapData.size() * 4 / 3 + 1);
-        Map<Integer, ExcelContentProperty> tmpContentPropertyMap =
-            new HashMap<Integer, ExcelContentProperty>(contentPropertyMapData.size() * 4 / 3 + 1);
         for (Map.Entry<Integer, Head> entry : headMapData.entrySet()) {
             Head headData = entry.getValue();
             if (headData.getForceIndex() || !headData.getForceName()) {
                 tmpHeadMap.put(entry.getKey(), headData);
-                tmpContentPropertyMap.put(entry.getKey(), contentPropertyMapData.get(entry.getKey()));
                 continue;
             }
             List<String> headNameList = headData.getHeadNameList();
@@ -146,12 +141,10 @@ public class DefaultAnalysisEventProcessor implements AnalysisEventProcessor {
                 if (headName.equals(headString)) {
                     headData.setColumnIndex(stringKey);
                     tmpHeadMap.put(stringKey, headData);
-                    tmpContentPropertyMap.put(stringKey, contentPropertyMapData.get(entry.getKey()));
                     break;
                 }
             }
         }
         excelHeadPropertyData.setHeadMap(tmpHeadMap);
-        excelHeadPropertyData.setContentPropertyMap(tmpContentPropertyMap);
     }
 }

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

@@ -1,6 +1,5 @@
 package com.alibaba.excel.util;
 
-import java.lang.ref.SoftReference;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
@@ -10,16 +9,26 @@ import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
 
 import com.alibaba.excel.annotation.ExcelIgnore;
 import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
 import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.annotation.write.style.ContentFontStyle;
+import com.alibaba.excel.annotation.write.style.ContentStyle;
+import com.alibaba.excel.converters.AutoConverter;
+import com.alibaba.excel.converters.Converter;
 import com.alibaba.excel.exception.ExcelCommonException;
 import com.alibaba.excel.metadata.Holder;
+import com.alibaba.excel.metadata.property.ExcelContentProperty;
+import com.alibaba.excel.metadata.property.FontProperty;
+import com.alibaba.excel.metadata.property.StyleProperty;
 import com.alibaba.excel.write.metadata.holder.WriteHolder;
 
+import net.sf.cglib.beans.BeanMap;
+
 /**
  * Class utils
  *
@@ -27,7 +36,150 @@ import com.alibaba.excel.write.metadata.holder.WriteHolder;
  **/
 public class ClassUtils {
 
-    public static final Map<Class<?>, SoftReference<FieldCache>> FIELD_CACHE = new ConcurrentHashMap<>();
+    public static final Map<Class<?>, FieldCache> FIELD_CACHE = new ConcurrentHashMap<>();
+
+    /**
+     * The cache configuration information for each of the class
+     */
+    public static final Map<Class<?>, Map<String, ExcelContentProperty>> CLASS_CONTENT_CACHE
+        = new ConcurrentHashMap<>();
+
+    /**
+     * The cache configuration information for each of the class
+     */
+    public static final Map<String, ExcelContentProperty> CONTENT_CACHE = new ConcurrentHashMap<>();
+
+    /**
+     * Calculate the configuration information for the class
+     *
+     * @param dataMap
+     * @param headClazz
+     * @param fieldName
+     * @return
+     */
+    public static ExcelContentProperty declaredExcelContentProperty(Map<?, ?> dataMap, Class<?> headClazz,
+        String fieldName) {
+        Class<?> clazz = null;
+        if (dataMap instanceof BeanMap) {
+            Object bean = ((BeanMap)dataMap).getBean();
+            if (bean != null) {
+                clazz = bean.getClass();
+            }
+        }
+        return getExcelContentProperty(clazz, headClazz, fieldName);
+    }
+
+    private static ExcelContentProperty getExcelContentProperty(Class<?> clazz, Class<?> headClass, String fieldName) {
+        return CONTENT_CACHE.computeIfAbsent(buildKey(clazz, headClass, fieldName), key -> {
+            ExcelContentProperty excelContentProperty = Optional.ofNullable(declaredFieldContentMap(clazz))
+                .map(map -> map.get(fieldName))
+                .orElse(null);
+            ExcelContentProperty headExcelContentProperty = Optional.ofNullable(declaredFieldContentMap(headClass))
+                .map(map -> map.get(fieldName))
+                .orElse(null);
+            ExcelContentProperty combineExcelContentProperty = new ExcelContentProperty();
+
+            combineExcelContentProperty(combineExcelContentProperty, headExcelContentProperty);
+            if (clazz != headClass) {
+                combineExcelContentProperty(combineExcelContentProperty, excelContentProperty);
+            }
+            return combineExcelContentProperty;
+        });
+
+    }
+
+    public static void combineExcelContentProperty(ExcelContentProperty combineExcelContentProperty,
+        ExcelContentProperty excelContentProperty) {
+        if (excelContentProperty == null) {
+            return;
+        }
+        if (excelContentProperty.getField() != null) {
+            combineExcelContentProperty.setField(excelContentProperty.getField());
+        }
+        if (excelContentProperty.getConverter() != null) {
+            combineExcelContentProperty.setConverter(excelContentProperty.getConverter());
+        }
+        if (excelContentProperty.getDateTimeFormatProperty() != null) {
+            combineExcelContentProperty.setDateTimeFormatProperty(excelContentProperty.getDateTimeFormatProperty());
+        }
+        if (excelContentProperty.getNumberFormatProperty() != null) {
+            combineExcelContentProperty.setNumberFormatProperty(excelContentProperty.getNumberFormatProperty());
+        }
+        if (excelContentProperty.getContentStyleProperty() != null) {
+            combineExcelContentProperty.setContentStyleProperty(excelContentProperty.getContentStyleProperty());
+        }
+        if (excelContentProperty.getContentFontProperty() != null) {
+            combineExcelContentProperty.setContentFontProperty(excelContentProperty.getContentFontProperty());
+        }
+    }
+
+    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 Map<String, ExcelContentProperty> declaredFieldContentMap(Class<?> clazz) {
+        if (clazz == null) {
+            return null;
+        }
+        return CLASS_CONTENT_CACHE.computeIfAbsent(clazz, key -> {
+            List<Field> tempFieldList = new ArrayList<>();
+            Class<?> tempClass = clazz;
+            while (tempClass != null) {
+                Collections.addAll(tempFieldList, tempClass.getDeclaredFields());
+                // Get the parent class and give it to yourself
+                tempClass = tempClass.getSuperclass();
+            }
+
+            ContentStyle parentContentStyle = clazz.getAnnotation(ContentStyle.class);
+            ContentFontStyle parentContentFontStyle = clazz.getAnnotation(ContentFontStyle.class);
+            Map<String, ExcelContentProperty> fieldContentMap = MapUtils.newHashMapWithExpectedSize(
+                tempFieldList.size());
+            for (Field field : tempFieldList) {
+                ExcelContentProperty excelContentProperty = new ExcelContentProperty();
+                excelContentProperty.setField(field);
+
+                ExcelProperty excelProperty = field.getAnnotation(ExcelProperty.class);
+                if (excelProperty != null) {
+                    Class<? extends Converter<?>> convertClazz = excelProperty.converter();
+                    if (convertClazz != AutoConverter.class) {
+                        try {
+                            Converter<?> converter = convertClazz.newInstance();
+                            excelContentProperty.setConverter(converter);
+                        } catch (Exception e) {
+                            throw new ExcelCommonException(
+                                "Can not instance custom converter:" + convertClazz.getName());
+                        }
+                    }
+                }
+
+                ContentStyle contentStyle = field.getAnnotation(ContentStyle.class);
+                if (contentStyle == null) {
+                    contentStyle = parentContentStyle;
+                }
+                excelContentProperty.setContentStyleProperty(StyleProperty.build(contentStyle));
+
+                ContentFontStyle contentFontStyle = field.getAnnotation(ContentFontStyle.class);
+                if (contentFontStyle == null) {
+                    contentFontStyle = parentContentFontStyle;
+                }
+                excelContentProperty.setContentFontProperty(FontProperty.build(contentFontStyle));
+                fieldContentMap.put(field.getName(), excelContentProperty);
+            }
+            return fieldContentMap;
+        });
+    }
 
     /**
      * Parsing filed in the class
@@ -41,7 +193,7 @@ public class ClassUtils {
      */
     public static void declaredFields(Class<?> clazz, Map<Integer, Field> sortedAllFiledMap,
         Map<Integer, Field> indexFiledMap, Map<String, Field> ignoreMap, Boolean needIgnore, Holder holder) {
-        FieldCache fieldCache = getFieldCache(clazz);
+        FieldCache fieldCache = declaredFields(clazz);
         if (fieldCache == null) {
             return;
         }
@@ -92,45 +244,31 @@ public class ClassUtils {
         declaredFields(clazz, sortedAllFiledMap, null, null, needIgnore, writeHolder);
     }
 
-    private static FieldCache getFieldCache(Class<?> clazz) {
+    private static FieldCache declaredFields(Class<?> clazz) {
         if (clazz == null) {
             return null;
         }
-        SoftReference<FieldCache> fieldCacheSoftReference = FIELD_CACHE.get(clazz);
+        return FIELD_CACHE.computeIfAbsent(clazz, key -> {
-        if (fieldCacheSoftReference != null && fieldCacheSoftReference.get() != null) {
+            List<Field> tempFieldList = new ArrayList<>();
-            return fieldCacheSoftReference.get();
+            Class<?> tempClass = clazz;
-        }
+            // When the parent class is null, it indicates that the parent class (Object class) has reached the top
-        synchronized (clazz) {
+            // level.
-            fieldCacheSoftReference = FIELD_CACHE.get(clazz);
+            while (tempClass != null) {
-            if (fieldCacheSoftReference != null && fieldCacheSoftReference.get() != null) {
+                Collections.addAll(tempFieldList, tempClass.getDeclaredFields());
-                return fieldCacheSoftReference.get();
+                // Get the parent class and give it to yourself
+                tempClass = tempClass.getSuperclass();
             }
-            declaredFields(clazz);
+            // Screening of field
-        }
+            Map<Integer, List<Field>> orderFiledMap = new TreeMap<Integer, List<Field>>();
-        return FIELD_CACHE.get(clazz).get();
+            Map<Integer, Field> indexFiledMap = new TreeMap<Integer, Field>();
-    }
+            Map<String, Field> ignoreMap = new HashMap<String, Field>(16);
 
-    private static void declaredFields(Class<?> clazz) {
+            ExcelIgnoreUnannotated excelIgnoreUnannotated = clazz.getAnnotation(ExcelIgnoreUnannotated.class);
-        List<Field> tempFieldList = new ArrayList<>();
+            for (Field field : tempFieldList) {
-        Class<?> tempClass = clazz;
+                declaredOneField(field, orderFiledMap, indexFiledMap, ignoreMap, excelIgnoreUnannotated);
-        // When the parent class is null, it indicates that the parent class (Object class) has reached the top
+            }
-        // level.
+            return new FieldCache(buildSortedAllFiledMap(orderFiledMap, indexFiledMap), indexFiledMap, ignoreMap);
-        while (tempClass != null) {
+        });
-            Collections.addAll(tempFieldList, tempClass.getDeclaredFields());
-            // Get the parent class and give it to yourself
-            tempClass = tempClass.getSuperclass();
-        }
-        // Screening of field
-        Map<Integer, List<Field>> orderFiledMap = new TreeMap<Integer, List<Field>>();
-        Map<Integer, Field> indexFiledMap = new TreeMap<Integer, Field>();
-        Map<String, Field> ignoreMap = new HashMap<String, Field>(16);
-
-        ExcelIgnoreUnannotated excelIgnoreUnannotated = clazz.getAnnotation(ExcelIgnoreUnannotated.class);
-        for (Field field : tempFieldList) {
-            declaredOneField(field, orderFiledMap, indexFiledMap, ignoreMap, excelIgnoreUnannotated);
-        }
-        FIELD_CACHE.put(clazz, new SoftReference<FieldCache>(
-            new FieldCache(buildSortedAllFiledMap(orderFiledMap, indexFiledMap), indexFiledMap, ignoreMap)));
     }
 
     private static Map<Integer, Field> buildSortedAllFiledMap(Map<Integer, List<Field>> orderFiledMap,

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

@@ -6,6 +6,7 @@ import java.util.Map;
 import com.alibaba.excel.context.WriteContext;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.data.WriteCellData;
+import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.write.handler.CellWriteHandler;
 import com.alibaba.excel.write.handler.RowWriteHandler;
 import com.alibaba.excel.write.handler.SheetWriteHandler;
@@ -116,7 +117,7 @@ public class WriteHandlerUtils {
     }
 
     public static void beforeCellCreate(WriteContext writeContext, Row row, Head head, Integer columnIndex,
-        Integer relativeRowIndex, Boolean isHead) {
+        Integer relativeRowIndex, Boolean isHead, ExcelContentProperty excelContentProperty) {
         List<WriteHandler> handlerList =
             writeContext.currentWriteHolder().writeHandlerMap().get(CellWriteHandler.class);
         if (handlerList == null || handlerList.isEmpty()) {
@@ -124,7 +125,7 @@ public class WriteHandlerUtils {
         }
         CellWriteHandlerContext context = new CellWriteHandlerContext(writeContext, writeContext.writeWorkbookHolder(),
             writeContext.writeSheetHolder(), writeContext.writeTableHolder(), row, null, columnIndex, relativeRowIndex,
-            head, null, null, isHead);
+            head, null, null, isHead, excelContentProperty);
         for (WriteHandler writeHandler : handlerList) {
             if (writeHandler instanceof CellWriteHandler) {
                 ((CellWriteHandler)writeHandler).beforeCellCreate(context);
@@ -133,7 +134,7 @@ public class WriteHandlerUtils {
     }
 
     public static void afterCellCreate(WriteContext writeContext, Cell cell, Head head, Integer relativeRowIndex,
-        Boolean isHead) {
+        Boolean isHead, ExcelContentProperty excelContentProperty) {
         List<WriteHandler> handlerList =
             writeContext.currentWriteHolder().writeHandlerMap().get(CellWriteHandler.class);
         if (handlerList == null || handlerList.isEmpty()) {
@@ -141,7 +142,7 @@ public class WriteHandlerUtils {
         }
         CellWriteHandlerContext context = new CellWriteHandlerContext(writeContext, writeContext.writeWorkbookHolder(),
             writeContext.writeSheetHolder(), writeContext.writeTableHolder(), cell.getRow(), cell,
-            cell.getColumnIndex(), relativeRowIndex, head, null, null, isHead);
+            cell.getColumnIndex(), relativeRowIndex, head, null, null, isHead, excelContentProperty);
         for (WriteHandler writeHandler : handlerList) {
             if (writeHandler instanceof CellWriteHandler) {
                 ((CellWriteHandler)writeHandler).afterCellCreate(context);
@@ -150,8 +151,7 @@ public class WriteHandlerUtils {
     }
 
     public static void afterCellDataConverted(WriteContext writeContext, WriteCellData<?> cellData, Cell cell,
-        Head head,
+        Head head, Integer relativeRowIndex, Boolean isHead, ExcelContentProperty excelContentProperty) {
-        Integer relativeRowIndex, Boolean isHead) {
         List<WriteHandler> handlerList =
             writeContext.currentWriteHolder().writeHandlerMap().get(CellWriteHandler.class);
         if (handlerList == null || handlerList.isEmpty()) {
@@ -160,7 +160,7 @@ public class WriteHandlerUtils {
         List<WriteCellData<?>> cellDataList = cellData == null ? null : ListUtils.newArrayList(cellData);
         CellWriteHandlerContext context = new CellWriteHandlerContext(writeContext, writeContext.writeWorkbookHolder(),
             writeContext.writeSheetHolder(), writeContext.writeTableHolder(), cell.getRow(), cell,
-            cell.getColumnIndex(), relativeRowIndex, head, cellDataList, cellData, isHead);
+            cell.getColumnIndex(), relativeRowIndex, head, cellDataList, cellData, isHead, excelContentProperty);
         for (WriteHandler writeHandler : handlerList) {
             if (writeHandler instanceof CellWriteHandler) {
                 ((CellWriteHandler)writeHandler).afterCellDataConverted(context);
@@ -169,14 +169,13 @@ public class WriteHandlerUtils {
     }
 
     public static void afterCellDispose(WriteContext writeContext, WriteCellData<?> cellData, Cell cell, Head head,
-        Integer relativeRowIndex, Boolean isHead) {
+        Integer relativeRowIndex, Boolean isHead, ExcelContentProperty excelContentProperty) {
         List<WriteCellData<?>> cellDataList = cellData == null ? null : ListUtils.newArrayList(cellData);
-        afterCellDispose(writeContext, cellDataList, cell, head, relativeRowIndex, isHead);
+        afterCellDispose(writeContext, cellDataList, cell, head, relativeRowIndex, isHead, excelContentProperty);
     }
 
     public static void afterCellDispose(WriteContext writeContext, List<WriteCellData<?>> cellDataList, Cell cell,
-        Head head,
+        Head head, Integer relativeRowIndex, Boolean isHead, ExcelContentProperty excelContentProperty) {
-        Integer relativeRowIndex, Boolean isHead) {
         List<WriteHandler> handlerList =
             writeContext.currentWriteHolder().writeHandlerMap().get(CellWriteHandler.class);
         if (handlerList == null || handlerList.isEmpty()) {
@@ -188,7 +187,7 @@ public class WriteHandlerUtils {
         }
         CellWriteHandlerContext context = new CellWriteHandlerContext(writeContext, writeContext.writeWorkbookHolder(),
             writeContext.writeSheetHolder(), writeContext.writeTableHolder(), cell.getRow(), cell,
-            cell.getColumnIndex(), relativeRowIndex, head, cellDataList, cellData, isHead);
+            cell.getColumnIndex(), relativeRowIndex, head, cellDataList, cellData, isHead, excelContentProperty);
         for (WriteHandler writeHandler : handlerList) {
             if (writeHandler instanceof CellWriteHandler) {
                 ((CellWriteHandler)writeHandler).afterCellDispose(context);

src/main/java/com/alibaba/excel/write/executor/AbstractExcelWriteExecutor.java

@@ -56,7 +56,8 @@ public abstract class AbstractExcelWriteExecutor implements ExcelWriteExecutor {
             value = ((String)value).trim();
         }
         WriteCellData<?> cellData = convert(currentWriteHolder, clazz, targetType, cell, value, excelContentProperty);
-        WriteHandlerUtils.afterCellDataConverted(writeContext, cellData, cell, head, relativeRowIndex, Boolean.FALSE);
+        WriteHandlerUtils.afterCellDataConverted(writeContext, cellData, cell, head, relativeRowIndex, Boolean.FALSE,
+            excelContentProperty);
 
         // Fill in picture information
         fillImage(cell, cellData.getImageDataList());

src/main/java/com/alibaba/excel/write/executor/ExcelWriteAddExecutor.java

@@ -110,13 +110,20 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
 
     private void doAddBasicTypeToExcel(RowData oneRowData, Head head, Row row, int relativeRowIndex, int dataIndex,
         int cellIndex) {
-        WriteHandlerUtils.beforeCellCreate(writeContext, row, head, cellIndex, relativeRowIndex, Boolean.FALSE);
+        ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(null,
+            writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(),
+            head == null ? null : head.getFieldName());
+
+        WriteHandlerUtils.beforeCellCreate(writeContext, row, head, cellIndex, relativeRowIndex, Boolean.FALSE,
+            excelContentProperty);
         Cell cell = WorkBookUtil.createCell(row, cellIndex);
-        WriteHandlerUtils.afterCellCreate(writeContext, cell, head, relativeRowIndex, Boolean.FALSE);
+        WriteHandlerUtils.afterCellCreate(writeContext, cell, head, relativeRowIndex, Boolean.FALSE,
+            excelContentProperty);
         Object value = oneRowData.get(dataIndex);
         WriteCellData<?> cellData = converterAndSet(writeContext.currentWriteHolder(),
             FieldUtils.getFieldClass(value), null, cell, value, null, head, relativeRowIndex);
-        WriteHandlerUtils.afterCellDispose(writeContext, cellData, cell, head, relativeRowIndex, Boolean.FALSE);
+        WriteHandlerUtils.afterCellDispose(writeContext, cellData, cell, head, relativeRowIndex, Boolean.FALSE,
+            excelContentProperty);
     }
 
     private void addJavaObjectToExcel(Object oneRowData, Row row, int relativeRowIndex,
@@ -128,24 +135,25 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
         // If it's a class it needs to be cast by type
         if (HeadKindEnum.CLASS.equals(writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadKind())) {
             Map<Integer, Head> headMap = writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadMap();
-            Map<Integer, ExcelContentProperty> contentPropertyMap =
+            for (Map.Entry<Integer, Head> entry : headMap.entrySet()) {
-                writeContext.currentWriteHolder().excelWriteHeadProperty().getContentPropertyMap();
-            for (Map.Entry<Integer, ExcelContentProperty> entry : contentPropertyMap.entrySet()) {
                 int cellIndex = entry.getKey();
-                ExcelContentProperty excelContentProperty = entry.getValue();
+                Head head = entry.getValue();
-                String name = FieldUtils.resolveCglibFieldName(excelContentProperty.getField());
+                String name = head.getFieldName();
                 if (!beanMap.containsKey(name)) {
                     continue;
                 }
-                Head head = headMap.get(cellIndex);
+                ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(beanMap,
-                WriteHandlerUtils.beforeCellCreate(writeContext, row, head, cellIndex, relativeRowIndex, Boolean.FALSE);
+                    currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), name);
+                WriteHandlerUtils.beforeCellCreate(writeContext, row, head, cellIndex, relativeRowIndex, Boolean.FALSE,
+                    excelContentProperty);
                 Cell cell = WorkBookUtil.createCell(row, cellIndex);
-                WriteHandlerUtils.afterCellCreate(writeContext, cell, head, relativeRowIndex, Boolean.FALSE);
+                WriteHandlerUtils.afterCellCreate(writeContext, cell, head, relativeRowIndex, Boolean.FALSE,
+                    excelContentProperty);
                 Object value = beanMap.get(name);
-                WriteCellData<?> cellData = converterAndSet(currentWriteHolder,
+                WriteCellData<?> cellData = converterAndSet(currentWriteHolder, head.getField().getType(),
-                    excelContentProperty.getField().getType(),
                     null, cell, value, excelContentProperty, head, relativeRowIndex);
-                WriteHandlerUtils.afterCellDispose(writeContext, cellData, cell, head, relativeRowIndex, Boolean.FALSE);
+                WriteHandlerUtils.afterCellDispose(writeContext, cellData, cell, head, relativeRowIndex, Boolean.FALSE,
+                    excelContentProperty);
                 beanMapHandledSet.add(name);
                 maxCellIndex = Math.max(maxCellIndex, cellIndex);
             }
@@ -160,21 +168,26 @@ public class ExcelWriteAddExecutor extends AbstractExcelWriteExecutor {
         initSortedAllFiledMapFieldList(oneRowData.getClass(), sortedAllFiledMap);
         for (Map.Entry<Integer, Field> entry : sortedAllFiledMap.entrySet()) {
             Field field = entry.getValue();
-            String filedName = field.getName();
+            String filedName = FieldUtils.resolveCglibFieldName(field);
             boolean uselessData = !beanMap.containsKey(filedName) || beanMapHandledSet.contains(filedName)
                 || ignoreMap.containsKey(filedName);
             if (uselessData) {
                 continue;
             }
             Object value = beanMap.get(filedName);
-            WriteHandlerUtils.beforeCellCreate(writeContext, row, null, maxCellIndex, relativeRowIndex, Boolean.FALSE);
+            ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(beanMap,
+                currentWriteHolder.excelWriteHeadProperty().getHeadClazz(), filedName);
+            WriteHandlerUtils.beforeCellCreate(writeContext, row, null, maxCellIndex, relativeRowIndex, Boolean.FALSE,
+                excelContentProperty);
             // fix https://github.com/alibaba/easyexcel/issues/1870
             // If there is data, it is written to the next cell
             Cell cell = WorkBookUtil.createCell(row, maxCellIndex++);
-            WriteHandlerUtils.afterCellCreate(writeContext, cell, null, relativeRowIndex, Boolean.FALSE);
+            WriteHandlerUtils.afterCellCreate(writeContext, cell, null, relativeRowIndex, Boolean.FALSE,
+                excelContentProperty);
             WriteCellData<?> cellData = converterAndSet(currentWriteHolder,
                 FieldUtils.getFieldClass(beanMap, filedName, value), null, cell, value, null, null, relativeRowIndex);
-            WriteHandlerUtils.afterCellDispose(writeContext, cellData, cell, null, relativeRowIndex, Boolean.FALSE);
+            WriteHandlerUtils.afterCellDispose(writeContext, cellData, cell, null, relativeRowIndex, Boolean.FALSE,
+                excelContentProperty);
         }
     }
 

src/main/java/com/alibaba/excel/write/executor/ExcelWriteFillExecutor.java

@@ -18,6 +18,7 @@ import com.alibaba.excel.exception.ExcelGenerateException;
 import com.alibaba.excel.metadata.data.WriteCellData;
 import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.util.BeanMapUtils;
+import com.alibaba.excel.util.ClassUtils;
 import com.alibaba.excel.util.FieldUtils;
 import com.alibaba.excel.util.ListUtils;
 import com.alibaba.excel.util.MapUtils;
@@ -189,19 +190,21 @@ public class ExcelWriteFillExecutor extends AbstractExcelWriteExecutor {
             dataMap = BeanMapUtils.create(oneRowData);
         }
         WriteSheetHolder writeSheetHolder = writeContext.writeSheetHolder();
-        Map<String, ExcelContentProperty> fieldNameContentPropertyMap =
-            writeContext.currentWriteHolder().excelWriteHeadProperty().getFieldNameContentPropertyMap();
         for (AnalysisCell analysisCell : analysisCellList) {
-            Cell cell = getOneCell(analysisCell, fillConfig);
             if (analysisCell.getOnlyOneVariable()) {
                 String variable = analysisCell.getVariableList().get(0);
                 if (!dataMap.containsKey(variable)) {
                     continue;
                 }
                 Object value = dataMap.get(variable);
+                ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(dataMap,
+                    writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(), variable);
+                Cell cell = getOneCell(analysisCell, fillConfig, excelContentProperty);
+
                 WriteCellData<?> cellData = converterAndSet(writeSheetHolder,
-                    FieldUtils.getFieldClass(dataMap, variable, value),
+                    FieldUtils.getFieldClass(dataMap, variable, value), null, cell, value, excelContentProperty, null,
-                    null, cell, value, fieldNameContentPropertyMap.get(variable), null, relativeRowIndex);
+                    relativeRowIndex);
+                cellData.setAnalysisCell(analysisCell);
 
                 // Restyle
                 if (fillConfig.getAutoStyle()) {
@@ -210,20 +213,26 @@ public class ExcelWriteFillExecutor extends AbstractExcelWriteExecutor {
                         .ifPresent(cellData::setOriginCellStyle);
                 }
 
-                WriteHandlerUtils.afterCellDispose(writeContext, cellData, cell, null, relativeRowIndex, Boolean.FALSE);
+                WriteHandlerUtils.afterCellDispose(writeContext, cellData, cell, null, relativeRowIndex, Boolean.FALSE,
+                    excelContentProperty);
             } else {
                 StringBuilder cellValueBuild = new StringBuilder();
                 int index = 0;
                 List<WriteCellData<?>> cellDataList = new ArrayList<>();
+                Cell cell = getOneCell(analysisCell, fillConfig, ExcelContentProperty.EMPTY);
+
                 for (String variable : analysisCell.getVariableList()) {
                     cellValueBuild.append(analysisCell.getPrepareDataList().get(index++));
                     if (!dataMap.containsKey(variable)) {
                         continue;
                     }
                     Object value = dataMap.get(variable);
+                    ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(dataMap,
+                        writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(), variable);
                     WriteCellData<?> cellData = convert(writeSheetHolder,
                         FieldUtils.getFieldClass(dataMap, variable, value), CellDataTypeEnum.STRING, cell, value,
-                        fieldNameContentPropertyMap.get(variable));
+                        excelContentProperty);
+                    cellData.setAnalysisCell(analysisCell);
                     cellDataList.add(cellData);
                     CellDataTypeEnum type = cellData.getType();
                     if (type != null) {
@@ -253,7 +262,7 @@ public class ExcelWriteFillExecutor extends AbstractExcelWriteExecutor {
                 }
 
                 WriteHandlerUtils.afterCellDispose(writeContext, cellDataList, cell, null, relativeRowIndex,
-                    Boolean.FALSE);
+                    Boolean.FALSE, ExcelContentProperty.EMPTY);
             }
         }
     }
@@ -269,7 +278,8 @@ public class ExcelWriteFillExecutor extends AbstractExcelWriteExecutor {
         return relativeRowIndex;
     }
 
-    private Cell getOneCell(AnalysisCell analysisCell, FillConfig fillConfig) {
+    private Cell getOneCell(AnalysisCell analysisCell, FillConfig fillConfig,
+        ExcelContentProperty excelContentProperty) {
         Sheet cachedSheet = writeContext.writeSheetHolder().getCachedSheet();
         if (WriteTemplateAnalysisCellTypeEnum.COMMON.equals(analysisCell.getCellType())) {
             return cachedSheet.getRow(analysisCell.getRowIndex()).getCell(analysisCell.getColumnIndex());
@@ -310,7 +320,7 @@ public class ExcelWriteFillExecutor extends AbstractExcelWriteExecutor {
         }
 
         Row row = createRowIfNecessary(sheet, cachedSheet, lastRowIndex, fillConfig, analysisCell, isOriginalCell);
-        Cell cell = createCellIfNecessary(row, lastColumnIndex);
+        Cell cell = createCellIfNecessary(row, lastColumnIndex, excelContentProperty);
 
         if (isOriginalCell) {
             Map<AnalysisCell, CellStyle> collectionFieldStyleMap = collectionFieldStyleCache.computeIfAbsent(
@@ -320,14 +330,15 @@ public class ExcelWriteFillExecutor extends AbstractExcelWriteExecutor {
         return cell;
     }
 
-    private Cell createCellIfNecessary(Row row, Integer lastColumnIndex) {
+    private Cell createCellIfNecessary(Row row, Integer lastColumnIndex, ExcelContentProperty excelContentProperty) {
         Cell cell = row.getCell(lastColumnIndex);
         if (cell != null) {
             return cell;
         }
-        WriteHandlerUtils.beforeCellCreate(writeContext, row, null, lastColumnIndex, null, Boolean.FALSE);
+        WriteHandlerUtils.beforeCellCreate(writeContext, row, null, lastColumnIndex, null, Boolean.FALSE,
+            excelContentProperty);
         cell = row.createCell(lastColumnIndex);
-        WriteHandlerUtils.afterCellCreate(writeContext, cell, null, null, Boolean.FALSE);
+        WriteHandlerUtils.afterCellCreate(writeContext, cell, null, null, Boolean.FALSE, excelContentProperty);
         return cell;
     }
 

src/main/java/com/alibaba/excel/write/handler/context/CellWriteHandlerContext.java

@@ -5,6 +5,7 @@ import java.util.List;
 import com.alibaba.excel.context.WriteContext;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.data.WriteCellData;
+import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
 import com.alibaba.excel.write.metadata.holder.WriteTableHolder;
 import com.alibaba.excel.write.metadata.holder.WriteWorkbookHolder;
@@ -73,4 +74,8 @@ public class CellWriteHandlerContext {
      * Nullable.It is null in the case of fill data.
      */
     private Boolean head;
+    /**
+     * Field annotation configuration information.
+     */
+    private ExcelContentProperty excelContentProperty;
 }

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

@@ -29,10 +29,13 @@ public class FillStyleCellWriteHandler implements CellWriteHandler {
     @Override
     public void afterCellDispose(CellWriteHandlerContext context) {
         List<WriteCellData<?>> cellDataList = context.getCellDataList();
-        if (CollectionUtils.isEmpty(cellDataList)) {
+        if (CollectionUtils.size(cellDataList) != 1) {
+            return;
+        }
+        WriteCellData<?> cellData = context.getFirstCellData();
+        if (cellData.getAnalysisCell() != null && !cellData.getAnalysisCell().getOnlyOneVariable()) {
             return;
         }
-        WriteCellData<?> cellData = cellDataList.get(0);
         WriteCellStyle writeCellStyle = cellData.getWriteCellStyle();
         CellStyle originCellStyle = cellData.getOriginCellStyle();
         if (writeCellStyle == null && originCellStyle == null) {

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

@@ -18,6 +18,7 @@ import com.alibaba.excel.event.NotRepeatExecutor;
 import com.alibaba.excel.event.Order;
 import com.alibaba.excel.metadata.AbstractHolder;
 import com.alibaba.excel.metadata.Head;
+import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.metadata.property.LoopMergeProperty;
 import com.alibaba.excel.metadata.property.OnceAbsoluteMergeProperty;
 import com.alibaba.excel.metadata.property.RowHeightProperty;
@@ -78,6 +79,7 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
      * Whether to automatically merge headers.Default is true.
      */
     private Boolean automaticMergeHead;
+
     /**
      * Ignore the custom columns.
      */
@@ -195,7 +197,7 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
         }
         if (writeBasicParameter.getCustomConverterList() != null
             && !writeBasicParameter.getCustomConverterList().isEmpty()) {
-            for (Converter converter : writeBasicParameter.getCustomConverterList()) {
+            for (Converter<?> converter : writeBasicParameter.getCustomConverterList()) {
                 getConverterMap().put(ConverterKeyBuild.buildKey(converter.supportJavaTypeKey()), converter);
             }
         }
@@ -216,8 +218,7 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
             if (head.getColumnWidthProperty() != null) {
                 hasColumnWidth = true;
             }
-            if (head.getHeadStyleProperty() != null || head.getHeadFontProperty() != null
+            if (head.getHeadStyleProperty() != null || head.getHeadFontProperty() != null) {
-                || head.getContentStyleProperty() != null || head.getContentFontProperty() != null) {
                 hasStyle = true;
             }
             dealLoopMerge(handlerList, head);
@@ -227,9 +228,9 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
             dealColumnWidth(handlerList);
         }
 
-        if (hasStyle) {
+        //if (hasStyle) {
             dealStyle(handlerList);
-        }
+        //}
 
         dealRowHigh(handlerList);
         dealOnceAbsoluteMerge(handlerList);
@@ -244,14 +245,16 @@ public abstract class AbstractWriteHolder extends AbstractHolder implements Writ
 
             @Override
             protected WriteCellStyle headCellStyle(CellWriteHandlerContext context) {
-                //return WriteCellStyle.build(head.getHeadStyleProperty(), head.getHeadFontProperty());
+                ExcelContentProperty excelContentProperty = context.getExcelContentProperty();
-                return null;
+                return WriteCellStyle.build(excelContentProperty.getContentStyleProperty(),
+                    excelContentProperty.getContentFontProperty());
             }
 
             @Override
             protected WriteCellStyle contentCellStyle(CellWriteHandlerContext context) {
-                //return WriteCellStyle.build(head.getContentStyleProperty(), head.getContentFontProperty());
+                ExcelContentProperty excelContentProperty = context.getExcelContentProperty();
-                return null;
+                return WriteCellStyle.build(excelContentProperty.getContentStyleProperty(),
+                    excelContentProperty.getContentFontProperty());
             }
         };
         handlerList.add(styleStrategy);

src/main/java/com/alibaba/excel/write/property/ExcelWriteHeadProperty.java

@@ -7,11 +7,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import com.alibaba.excel.annotation.write.style.ColumnWidth;
-import com.alibaba.excel.annotation.write.style.ContentFontStyle;
 import com.alibaba.excel.annotation.write.style.ContentLoopMerge;
 import com.alibaba.excel.annotation.write.style.ContentRowHeight;
-import com.alibaba.excel.annotation.write.style.ContentStyle;
 import com.alibaba.excel.annotation.write.style.HeadFontStyle;
 import com.alibaba.excel.annotation.write.style.HeadRowHeight;
 import com.alibaba.excel.annotation.write.style.HeadStyle;
@@ -20,8 +17,6 @@ import com.alibaba.excel.enums.HeadKindEnum;
 import com.alibaba.excel.metadata.CellRange;
 import com.alibaba.excel.metadata.Head;
 import com.alibaba.excel.metadata.Holder;
-import com.alibaba.excel.metadata.property.ColumnWidthProperty;
-import com.alibaba.excel.metadata.property.ExcelContentProperty;
 import com.alibaba.excel.metadata.property.ExcelHeadProperty;
 import com.alibaba.excel.metadata.property.FontProperty;
 import com.alibaba.excel.metadata.property.LoopMergeProperty;
@@ -29,49 +24,43 @@ import com.alibaba.excel.metadata.property.OnceAbsoluteMergeProperty;
 import com.alibaba.excel.metadata.property.RowHeightProperty;
 import com.alibaba.excel.metadata.property.StyleProperty;
 
+import lombok.Data;
+
 /**
  * Define the header attribute of excel
  *
  * @author jipengfei
  */
+@Data
 public class ExcelWriteHeadProperty extends ExcelHeadProperty {
 
     private RowHeightProperty headRowHeightProperty;
     private RowHeightProperty contentRowHeightProperty;
     private OnceAbsoluteMergeProperty onceAbsoluteMergeProperty;
 
-    public ExcelWriteHeadProperty(Holder holder, Class headClazz, List<List<String>> head) {
+    public ExcelWriteHeadProperty(Holder holder, Class<?> headClazz, List<List<String>> head) {
         super(holder, headClazz, head);
         if (getHeadKind() != HeadKindEnum.CLASS) {
             return;
         }
         this.headRowHeightProperty =
-            RowHeightProperty.build((HeadRowHeight)headClazz.getAnnotation(HeadRowHeight.class));
+            RowHeightProperty.build(headClazz.getAnnotation(HeadRowHeight.class));
         this.contentRowHeightProperty =
-            RowHeightProperty.build((ContentRowHeight)headClazz.getAnnotation(ContentRowHeight.class));
+            RowHeightProperty.build(headClazz.getAnnotation(ContentRowHeight.class));
         this.onceAbsoluteMergeProperty =
-            OnceAbsoluteMergeProperty.build((OnceAbsoluteMerge)headClazz.getAnnotation(OnceAbsoluteMerge.class));
+            OnceAbsoluteMergeProperty.build(headClazz.getAnnotation(OnceAbsoluteMerge.class));
 
-        ColumnWidth parentColumnWidth = (ColumnWidth)headClazz.getAnnotation(ColumnWidth.class);
+        HeadStyle parentHeadStyle = headClazz.getAnnotation(HeadStyle.class);
-        HeadStyle parentHeadStyle = (HeadStyle)headClazz.getAnnotation(HeadStyle.class);
+        HeadFontStyle parentHeadFontStyle = headClazz.getAnnotation(HeadFontStyle.class);
-        HeadFontStyle parentHeadFontStyle = (HeadFontStyle)headClazz.getAnnotation(HeadFontStyle.class);
-        ContentStyle parentContentStyle = (ContentStyle)headClazz.getAnnotation(ContentStyle.class);
-        ContentFontStyle parentContentFontStyle = (ContentFontStyle)headClazz.getAnnotation(ContentFontStyle.class);
 
-        for (Map.Entry<Integer, ExcelContentProperty> entry : getContentPropertyMap().entrySet()) {
+        for (Map.Entry<Integer, Head> entry : getHeadMap().entrySet()) {
             Integer index = entry.getKey();
-            ExcelContentProperty excelContentPropertyData = entry.getValue();
+            Head headData = entry.getValue();
-            if (excelContentPropertyData == null) {
+            if (headData == null) {
                 throw new IllegalArgumentException(
                     "Passing in the class and list the head, the two must be the same size.");
             }
-            Field field = excelContentPropertyData.getField();
+            Field field = headData.getField();
-            Head headData = getHeadMap().get(index);
-            ColumnWidth columnWidth = field.getAnnotation(ColumnWidth.class);
-            if (columnWidth == null) {
-                columnWidth = parentColumnWidth;
-            }
-            headData.setColumnWidthProperty(ColumnWidthProperty.build(columnWidth));
 
             HeadStyle headStyle = field.getAnnotation(HeadStyle.class);
             if (headStyle == null) {
@@ -85,46 +74,10 @@ public class ExcelWriteHeadProperty extends ExcelHeadProperty {
             }
             headData.setHeadFontProperty(FontProperty.build(headFontStyle));
 
-            ContentStyle contentStyle = field.getAnnotation(ContentStyle.class);
-            if (contentStyle == null) {
-                contentStyle = parentContentStyle;
-            }
-            headData.setContentStyleProperty(StyleProperty.build(contentStyle));
-
-            ContentFontStyle contentFontStyle = field.getAnnotation(ContentFontStyle.class);
-            if (contentFontStyle == null) {
-                contentFontStyle = parentContentFontStyle;
-            }
-            headData.setContentFontProperty(FontProperty.build(contentFontStyle));
-
             headData.setLoopMergeProperty(LoopMergeProperty.build(field.getAnnotation(ContentLoopMerge.class)));
         }
     }
 
-    public RowHeightProperty getHeadRowHeightProperty() {
-        return headRowHeightProperty;
-    }
-
-    public void setHeadRowHeightProperty(RowHeightProperty headRowHeightProperty) {
-        this.headRowHeightProperty = headRowHeightProperty;
-    }
-
-    public RowHeightProperty getContentRowHeightProperty() {
-        return contentRowHeightProperty;
-    }
-
-    public void setContentRowHeightProperty(RowHeightProperty contentRowHeightProperty) {
-        this.contentRowHeightProperty = contentRowHeightProperty;
-    }
-
-    public OnceAbsoluteMergeProperty getOnceAbsoluteMergeProperty() {
-        return onceAbsoluteMergeProperty;
-    }
-
-    public void setOnceAbsoluteMergeProperty(OnceAbsoluteMergeProperty onceAbsoluteMergeProperty) {
-        this.onceAbsoluteMergeProperty = onceAbsoluteMergeProperty;
-    }
-
     /**
      * Calculate all cells that need to be merged
      *

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

@@ -21,7 +21,7 @@ public class FillStyleAnnotatedData {
     @ContentFontStyle(bold = BooleanEnum.TRUE, color = 16)
     private Double number;
     @ContentStyle(fillPatternType = FillPatternTypeEnum.SOLID_FOREGROUND, fillForegroundColor = 17)
-    @ContentFontStyle(bold = BooleanEnum.TRUE, color = 18)
+    @ContentFontStyle(bold = BooleanEnum.TRUE, color = 58)
     private Date date;
     @ContentStyle(fillPatternType = FillPatternTypeEnum.SOLID_FOREGROUND, fillForegroundColor = 12)
     @ContentFontStyle(bold = BooleanEnum.TRUE, color = 18)

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

@@ -63,26 +63,26 @@ public class FillStyleAnnotatedTest {
         XSSFCell cell0 = row.getCell(0);
         Assert.assertEquals("张三", cell0.getStringCellValue());
         Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("FF00B050", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assert.assertEquals("FFFFFF00", cell0.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF7030A0", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assert.assertEquals("FF808000", cell0.getCellStyle().getFont().getXSSFColor().getARGBHex());
         Assert.assertTrue(cell0.getCellStyle().getFont().getBold());
 
         XSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals("5", cell1.getStringCellValue());
+        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
         Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("FF92D050", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assert.assertEquals("FFFF0000", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF4BACC6", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assert.assertEquals("FF800000", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertFalse(cell1.getCellStyle().getFont().getBold());
+        Assert.assertTrue(cell1.getCellStyle().getFont().getBold());
 
         XSSFCell cell2 = row.getCell(2);
         Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
         Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("FFFFC000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assert.assertEquals("FF008000", cell2.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FFC0504D", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assert.assertEquals("FF003300", cell2.getCellStyle().getFont().getXSSFColor().getARGBHex());
         Assert.assertTrue(cell2.getCellStyle().getFont().getBold());
 
         XSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5岁了", cell3.getStringCellValue());
+        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
         Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
         Assert.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
         Assert.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
@@ -116,28 +116,28 @@ public class FillStyleAnnotatedTest {
         HSSFCell cell0 = row.getCell(0);
         Assert.assertEquals("张三", cell0.getStringCellValue());
         Assert.assertEquals(49, cell0.getCellStyle().getDataFormat());
-        Assert.assertEquals("0:8080:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assert.assertEquals("FFFF:FFFF:0", cell0.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:0:8080", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assert.assertEquals("8080:8080:0", cell0.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
         Assert.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals("5", cell1.getStringCellValue());
+        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
         Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
-        Assert.assertEquals("9999:CCCC:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assert.assertEquals("FFFF:0:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:8080:8080", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assert.assertEquals("8080:0:0", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertFalse(cell1.getCellStyle().getFont(workbook).getBold());
+        Assert.assertTrue(cell1.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell2 = row.getCell(2);
         Assert.assertEquals("2020-01-01 01:01:01", DateUtils.format(cell2.getDateCellValue(), "yyyy-MM-dd HH:mm:ss"));
         Assert.assertEquals("yyyy-MM-dd HH:mm:ss", cell2.getCellStyle().getDataFormatString());
-        Assert.assertEquals("FFFF:CCCC:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assert.assertEquals("0:8080:0", cell2.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:0:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook).getHexString());
+        Assert.assertEquals("0:3333:0", cell2.getCellStyle().getFont(workbook).getHSSFColor(workbook).getHexString());
         Assert.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5岁了", cell3.getStringCellValue());
+        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
         Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
         Assert.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
         Assert.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)

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

@@ -72,7 +72,7 @@ public class FillStyleDataTest {
         Assert.assertTrue(cell0.getCellStyle().getFont().getBold());
 
         XSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals("5", cell1.getStringCellValue());
+        Assert.assertEquals("5.2", cell1.getStringCellValue());
         Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
         Assert.assertEquals("FF92D050", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
         Assert.assertEquals("FF4BACC6", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
@@ -86,7 +86,7 @@ public class FillStyleDataTest {
         Assert.assertTrue(cell2.getCellStyle().getFont().getBold());
 
         XSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5岁了", cell3.getStringCellValue());
+        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
         Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
         Assert.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
         Assert.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
@@ -126,7 +126,7 @@ public class FillStyleDataTest {
         Assert.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals("5", cell1.getStringCellValue());
+        Assert.assertEquals("5.2", cell1.getStringCellValue());
         Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
         Assert.assertEquals("9999:CCCC:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
         Assert.assertEquals("0:8080:8080", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
@@ -141,7 +141,7 @@ public class FillStyleDataTest {
         Assert.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5岁了", cell3.getStringCellValue());
+        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
         Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
         Assert.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
         Assert.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
@@ -187,7 +187,7 @@ public class FillStyleDataTest {
         Assert.assertTrue(cell0.getCellStyle().getFont().getBold());
 
         XSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals("5", cell1.getStringCellValue());
+        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
         Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
         Assert.assertEquals("FFFF0000", cell1.getCellStyle().getFillForegroundColorColor().getARGBHex());
         Assert.assertEquals("FF800000", cell1.getCellStyle().getFont().getXSSFColor().getARGBHex());
@@ -201,28 +201,27 @@ public class FillStyleDataTest {
         Assert.assertTrue(cell2.getCellStyle().getFont().getBold());
 
         XSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5岁了", cell3.getStringCellValue());
+        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
         Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("FF0000FF", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assert.assertEquals("FFFF0000", cell3.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF000080", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assert.assertEquals("FFEEECE1", cell3.getCellStyle().getFont().getXSSFColor().getARGBHex());
         Assert.assertTrue(cell3.getCellStyle().getFont().getBold());
 
         XSSFCell cell4 = row.getCell(4);
         Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
         Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFFFF00", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assert.assertEquals("FFC00000", cell4.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF808000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assert.assertEquals("FF000000", cell4.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell4.getCellStyle().getFont().getBold());
+        Assert.assertFalse(cell4.getCellStyle().getFont().getBold());
 
         XSSFCell cell5 = row.getCell(5);
         Assert.assertEquals("空", cell5.getStringCellValue());
         Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("FF008080", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
+        Assert.assertEquals("FFF79646", cell5.getCellStyle().getFillForegroundColorColor().getARGBHex());
-        Assert.assertEquals("FF003366", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
+        Assert.assertEquals("FF8064A2", cell5.getCellStyle().getFont().getXSSFColor().getARGBHex());
-        Assert.assertTrue(cell5.getCellStyle().getFont().getBold());
+        Assert.assertFalse(cell5.getCellStyle().getFont().getBold());
     }
 
-
     @Test
     public void t12FillStyleHandler03() throws Exception {
         fillStyleHandler(fileStyleHandler03, fileStyleTemplate03);
@@ -242,7 +241,7 @@ public class FillStyleDataTest {
         Assert.assertTrue(cell0.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell1 = row.getCell(1);
-        Assert.assertEquals("5", cell1.getStringCellValue());
+        Assert.assertEquals(5.2, cell1.getNumericCellValue(), 1);
         Assert.assertEquals(0, cell1.getCellStyle().getDataFormat());
         Assert.assertEquals("FFFF:0:0", cell1.getCellStyle().getFillForegroundColorColor().getHexString());
         Assert.assertEquals("8080:0:0", cell1.getCellStyle().getFont(workbook).getHSSFColor(workbook)
@@ -257,32 +256,32 @@ public class FillStyleDataTest {
         Assert.assertTrue(cell2.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell3 = row.getCell(3);
-        Assert.assertEquals("张三今年5岁了", cell3.getStringCellValue());
+        Assert.assertEquals("张三今年5.2岁了", cell3.getStringCellValue());
         Assert.assertEquals(0, cell3.getCellStyle().getDataFormat());
-        Assert.assertEquals("0:0:FFFF", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assert.assertEquals("FFFF:0:0", cell3.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:0:8080", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assert.assertEquals("FFFF:FFFF:9999", cell3.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
         Assert.assertTrue(cell3.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell4 = row.getCell(4);
         Assert.assertEquals("{.name}忽略，张三", cell4.getStringCellValue());
         Assert.assertEquals(0, cell4.getCellStyle().getDataFormat());
-        Assert.assertEquals("FFFF:FFFF:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assert.assertEquals("9999:3333:0", cell4.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("8080:8080:0", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assert.assertEquals("3333:3333:3333", cell4.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell4.getCellStyle().getFont(workbook).getBold());
+        Assert.assertFalse(cell4.getCellStyle().getFont(workbook).getBold());
 
         HSSFCell cell5 = row.getCell(5);
         Assert.assertEquals("空", cell5.getStringCellValue());
         Assert.assertEquals(0, cell5.getCellStyle().getDataFormat());
-        Assert.assertEquals("0:8080:8080", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
+        Assert.assertEquals("9999:3333:0", cell5.getCellStyle().getFillForegroundColorColor().getHexString());
-        Assert.assertEquals("0:3333:6666", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
+        Assert.assertEquals("CCCC:9999:FFFF", cell5.getCellStyle().getFont(workbook).getHSSFColor(workbook)
             .getHexString());
-        Assert.assertTrue(cell5.getCellStyle().getFont(workbook).getBold());
+        Assert.assertFalse(cell5.getCellStyle().getFont(workbook).getBold());
     }
 
     private void fillStyleHandler(File file, File template) throws Exception {
-        EasyExcel.write(file, FillData.class).withTemplate(template).sheet()
+        EasyExcel.write(file, FillStyleData.class).withTemplate(template).sheet()
             .registerWriteHandler(new AbstractVerticalCellStyleStrategy() {
 
                 @Override

update.md

@@ -2,6 +2,7 @@
 * 升级到正式版
 * 修复填充样式可能丢失的问题 [Issue #2124](https://github.com/alibaba/easyexcel/issues/2124)
 * 修复填充数据为空 可能NPE的bug
+* 修复填充样式可能不生效bug
 
 # 3.0.0-beta3