支持GraalVM AOT

[Songzhizong]

easyexcel在GraalVM AOT运行时会抛异常无法正常工作，希望能够解决这个问题。

[Aschrius]

附议!

[lmm1990]

同求，需要剔除cjlib
我的做法是将对象数据用jackson转成Map<String,Object> graalvm aot环境已经支持了

[Oniokey]

附议！

[psxjoy]

link #14

[xbo2018]

package org.springframework.cglib.beans;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.*;

/**

• 适配Spring CGLib 1.3版的NoCglibBeanMap

• 继承原BeanMap抽象类，无CGLib依赖，纯Java原生内省+反射实现
  */
  @SuppressWarnings({"rawtypes", "unchecked"})
  public class NoCglibBeanMap extends BeanMap {
  // 缓存Bean的属性描述符（key：属性名，value：属性描述符）
  private final Map<String, PropertyDescriptor> propertyDescriptorMap;
  // 缓存Bean的属性名集合（不可变，符合原版本keySet固定的约定）
  private final Set keySet;
  // Bean的Class类型（用于校验newInstance的Bean兼容性）
  private final Class<?> beanClass;
  // 属性过滤规则（REQUIRE_GETTER/REQUIRE_SETTER）
  private final int require;

  // ===================== 构造方法（适配原版本） =====================
  /**

  • 空构造（适配父类空构造）
    */
    public NoCglibBeanMap() {
    this.beanClass = null;
    this.require = 0;
    this.propertyDescriptorMap = Collections.emptyMap();
    this.keySet = Collections.emptySet();
    }

  /**

  • 带Bean的构造（核心构造，适配父类Bean构造）
  • @param bean 目标Bean实例
    */
    public NoCglibBeanMap(Object bean) {
    this(bean, 0); // 默认不过滤属性（require=0）
    }

  /**

  • 带Bean和require的构造（适配Generator的require配置）
  • @param bean 目标Bean实例
  • @param require 属性过滤规则（REQUIRE_GETTER/REQUIRE_SETTER）
    */
    public NoCglibBeanMap(Object bean, int require) {
    super(bean); // 调用父类构造，初始化bean成员变量
    if (bean == null) {
    throw new IllegalArgumentException("Class of bean unknown");
    }
    this.beanClass = bean.getClass();
    this.require = require;
    this.propertyDescriptorMap = new HashMap<>();
    this.keySet = new LinkedHashSet<>();
    // 初始化属性描述符和keySet
    initPropertyDescriptors();
    }

  // ===================== 核心初始化逻辑 =====================
  /**

  • 初始化属性描述符：通过Java内省获取Bean的所有属性，按require过滤
    */
    private void initPropertyDescriptors() {
    try {
    // 获取BeanInfo（排除Object类的属性，避免获取Object的toString/hashCode等方法）
    BeanInfo beanInfo = Introspector.getBeanInfo(this.beanClass, Object.class);
    PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();

     // 遍历属性描述符，按require过滤
     for (PropertyDescriptor pd : descriptors) {
         String propName = pd.getName();
         // 检查是否满足require过滤规则
         if (isMeetRequire(pd)) {
             propertyDescriptorMap.put(propName, pd);
             keySet.add(propName);
         }
     }
    

    } catch (IntrospectionException e) {
    throw new RuntimeException("Failed to introspect bean class: " + beanClass.getName(), e);
    }
    }

  /**

  • 检查属性是否满足require过滤规则

  • @param pd 属性描述符

  • @return true=满足规则，false=不满足（不加入keySet）
    */
    private boolean isMeetRequire(PropertyDescriptor pd) {
    // 无过滤规则，直接通过
    if (require == 0) {
    return true;
    }

    // 检查是否满足GETTER要求
    boolean hasGetter = (require & REQUIRE_GETTER) == 0 || pd.getReadMethod() != null;
    // 检查是否满足SETTER要求
    boolean hasSetter = (require & REQUIRE_SETTER) == 0 || pd.getWriteMethod() != null;

    return hasGetter && hasSetter;
    }

  // ===================== 实现父类抽象方法 =====================
  /**

  • 创建新的BeanMap实例，绑定新的Bean（适配原版本抽象方法）
    */
    @OverRide
    public BeanMap newInstance(Object bean) {
    // 校验Bean类型兼容性（与当前BeanMap的beanClass一致）
    if (bean != null && !this.beanClass.isAssignableFrom(bean.getClass())) {
    throw new IllegalArgumentException("Bean class " + bean.getClass().getName() + " is not compatible with " + this.beanClass.getName());
    }
    return new NoCglibBeanMap(bean, this.require);
    }

  /**

  • 获取指定属性的类型（适配原版本抽象方法）
    */
    @OverRide
    public Class getPropertyType(String name) {
    if (name == null || !propertyDescriptorMap.containsKey(name)) {
    return null;
    }
    return propertyDescriptorMap.get(name).getPropertyType();
    }

  /**

  • 从指定Bean中获取指定key的属性值（核心抽象方法）
    */
    @OverRide
    public Object get(Object bean, Object key) {
    // 基础参数校验
    if (bean == null || key == null || !(key instanceof String)) {
    return null;
    }
    String propName = (String) key;
    PropertyDescriptor pd = propertyDescriptorMap.get(propName);

    // 无该属性，返回null（符合原版本约定）
    if (pd == null) {
    return null;
    }

    // 获取getter方法，无getter返回null（符合原版本“写只读属性返回null”的约定）
    Method getter = pd.getReadMethod();
    if (getter == null) {
    return null;
    }

    // 反射调用getter
    try {
    return getter.invoke(bean);
    } catch (Exception e) {
    throw new RuntimeException("Failed to get property [" + propName + "] from bean", e);
    }
    }

  /**

  • 给指定Bean设置指定key的属性值（核心抽象方法）
    */
    @OverRide
    public Object put(Object bean, Object key, Object value) {
    // 基础参数校验
    if (bean == null || key == null || !(key instanceof String)) {
    return null;
    }
    String propName = (String) key;
    PropertyDescriptor pd = propertyDescriptorMap.get(propName);

    // 无该属性，返回null（符合原版本约定）
    if (pd == null) {
    return null;
    }

    // 获取setter方法，无setter忽略（符合原版本“设置只读属性被忽略”的约定）
    Method setter = pd.getWriteMethod();
    if (setter == null) {
    return null;
    }

    // 获取旧值
    Object oldValue = get(bean, key);

    // 反射调用setter（处理参数类型适配）
    try {
    // 处理基本类型自动装箱（如int <-> Integer）
    Object adaptedValue = adaptValueToPropertyType(value, pd.getPropertyType());
    setter.invoke(bean, adaptedValue);
    return oldValue;
    } catch (Exception e) {
    throw new RuntimeException("Failed to set property [" + propName + "] to bean", e);
    }
    }

  // ===================== 重写关键方法（优化性能/符合约定） =====================
  /**

  • 重写keySet方法：返回固定的属性名集合（不可变，符合原版本约定）
    */
    @OverRide
    public Set keySet() {
    return Collections.unmodifiableSet(keySet);
    }

  // ===================== 辅助方法（类型适配） =====================
  /**

  • 适配值到属性类型（处理基本类型/包装类型转换）
    */
    private Object adaptValueToPropertyType(Object value, Class<?> propertyType) {
    if (value == null) {
    // 基本类型不允许null，抛出异常
    if (propertyType.isPrimitive()) {
    throw new IllegalArgumentException("Cannot set null to primitive type [" + propertyType.getName() + "]");
    }
    return null;
    }

    // 类型匹配，直接返回
    if (propertyType.isInstance(value)) {
    return value;
    }

    // 处理基本类型与包装类型转换（如Integer -> int）
    if (propertyType.isPrimitive()) {
    if (propertyType == int.class && value instanceof Integer) {
    return value;
    } else if (propertyType == long.class && value instanceof Long) {
    return value;
    } else if (propertyType == boolean.class && value instanceof Boolean) {
    return value;
    } else if (propertyType == double.class && value instanceof Double) {
    return value;
    } else if (propertyType == float.class && value instanceof Float) {
    return value;
    } else if (propertyType == short.class && value instanceof Short) {
    return value;
    } else if (propertyType == byte.class && value instanceof Byte) {
    return value;
    } else if (propertyType == char.class && value instanceof Character) {
    return value;
    } else {
    throw new IllegalArgumentException("Cannot convert " + value.getClass().getName() + " to primitive type " + propertyType.getName());
    }
    }

    // 其他类型不支持转换，抛出异常
    throw new IllegalArgumentException("Value type " + value.getClass().getName() + " is not compatible with property type " + propertyType.getName());
    }

  // ===================== 静态工厂方法（替代原create方法） =====================
  /**

  • 适配原版本的create静态方法，创建NoCglibBeanMap实例
    */
    public static BeanMap create(Object bean) {
    return new NoCglibBeanMap(bean);
    }

  /**

  • 带require参数的工厂方法（适配原Generator的require配置）
    */
    public static BeanMap create(Object bean, int require) {
    return new NoCglibBeanMap(bean, require);
    }
    }

[bengbengbalabalabeng]

@xbo2018 Hi.

I tried performance test on 100k records shows a ~800x performance gap:

• BeanMap: ~5.8 ms
• NoCglibBeanMap: ~4,600 ms

Click To Review Full Code

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
@Fork(1)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 5, time = 1)
public class BeanMapBenchmark {

    @Param({"10000", "50000", "100000"})
    private int size;

    private TypeTestObject[] sourceBeans;
    private int[] newIntValues;

    private static final String KEY_GET = "testString";
    private static final String KEY_PUT = "testPrimitiveInt";

    @Setup(Level.Trial)
    public void setup() {
        sourceBeans = new TypeTestObject[size];
        newIntValues = new int[size];

        for (int i = 0; i < size; i++) {
            sourceBeans[i] = TypeTestObject.builder()
                    .testString("Data Row " + i)
                    .testPrimitiveInt(i)
                    .build();

            newIntValues[i] = i + 9999;
        }
    }

    @Benchmark
    public void cglib_Create_And_Get(Blackhole bh) {
        for (int i = 0; i < size; i++) {
            TypeTestObject bean = sourceBeans[i];

            BeanMap map = BeanMap.create(bean);

            bh.consume(map.get(bean, KEY_GET));
        }
    }

    @Benchmark
    public void reflect_Create_And_Get(Blackhole bh) {
        for (int i = 0; i < size; i++) {
            TypeTestObject bean = sourceBeans[i];

            BeanMap map = NoCglibBeanMap.create(bean);

            bh.consume(map.get(bean, KEY_GET));
        }
    }

    @Benchmark
    public void cglib_Create_And_Put(Blackhole bh) {
        for (int i = 0; i < size; i++) {
            TypeTestObject bean = sourceBeans[i];

            BeanMap map = BeanMap.create(bean);

            bh.consume(map.put(bean, KEY_PUT, newIntValues[i]));
        }
    }

    @Benchmark
    public void reflect_Create_And_Put(Blackhole bh) {
        for (int i = 0; i < size; i++) {
            TypeTestObject bean = sourceBeans[i];

            BeanMap map = NoCglibBeanMap.create(bean);

            bh.consume(map.put(bean, KEY_PUT, newIntValues[i]));
        }
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(BeanMapBenchmark.class.getSimpleName())
                .build();
        new Runner(opt).run();
    }
}

Output:

Benchmark                                (size)  Mode  Cnt     Score     Error  Units
BeanMapBenchmark.cglib_Create_And_Get     10000  avgt    5     0.542 ±   0.390  ms/op
BeanMapBenchmark.cglib_Create_And_Get     50000  avgt    5     2.693 ±   0.498  ms/op
BeanMapBenchmark.cglib_Create_And_Get    100000  avgt    5     5.854 ±   2.103  ms/op
BeanMapBenchmark.cglib_Create_And_Put     10000  avgt    5     0.558 ±   0.189  ms/op
BeanMapBenchmark.cglib_Create_And_Put     50000  avgt    5     3.041 ±   0.949  ms/op
BeanMapBenchmark.cglib_Create_And_Put    100000  avgt    5     5.696 ±   0.231  ms/op
BeanMapBenchmark.reflect_Create_And_Get   10000  avgt    5   458.933 ± 107.278  ms/op
BeanMapBenchmark.reflect_Create_And_Get   50000  avgt    5  2281.279 ± 472.617  ms/op
BeanMapBenchmark.reflect_Create_And_Get  100000  avgt    5  4642.381 ± 911.832  ms/op
BeanMapBenchmark.reflect_Create_And_Put   10000  avgt    5   484.927 ± 193.778  ms/op
BeanMapBenchmark.reflect_Create_And_Put   50000  avgt    5  2324.239 ± 518.657  ms/op
BeanMapBenchmark.reflect_Create_And_Put  100000  avgt    5  4524.777 ± 634.290  ms/op

The performance of NoCglibBeanMap implementation drops significantly in large-scale data scenarios.