在Java中检测Kotlin数组及适配Javapoet处理Kotlin注解

针对你遇到的Kotlin注解在JavaPoet中复制时的类型不兼容问题，分三个核心问题给出解决方案：

1. 如何在Java中检测对象是否为Kotlin数组？ #

Kotlin的Array<*>在Java中以代理类（如com.sun.proxy.$ProxyXX）形式存在，无法直接通过instanceof或isArray()检测。可通过以下方式判断：

public static boolean isKotlinArray(Object obj) {
    if (obj == null) return false;
    // 遍历接口判断是否实现kotlin.Array
    for (Class<?> iface : obj.getClass().getInterfaces()) {
        if ("kotlin.Array".equals(iface.getName())) {
            return true;
        }
    }
    // 直接通过Kotlin Array类验证（处理类找不到的边界情况）
    try {
        Class<?> kotlinArrayClass = Class.forName("kotlin.Array");
        return kotlinArrayClass.isInstance(obj);
    } catch (ClassNotFoundException e) {
        return false;
    }
}

2. 如何将Kotlin数组转换为Java数组？ #

Kotlin的Array接口自带toArray()方法，可通过反射调用完成转换：

public static Object[] convertKotlinArrayToJavaArray(Object kotlinArray) throws Exception {
    if (!isKotlinArray(kotlinArray)) {
        throw new IllegalArgumentException("输入不是Kotlin数组");
    }
    Method toArrayMethod = kotlinArray.getClass().getMethod("toArray");
    return (Object[]) toArrayMethod.invoke(kotlinArray);
}

注：Kotlin基本类型数组（如IntArray）直接对应Java基本类型数组（int[]），可直接强转，无需额外处理。

3. 通用适配Kotlin注解与Java的Class/数组 #

要让Kotlin注解能像Java注解一样被JavaPoet处理，可从两个维度入手：

方案一：自定义AnnotationSpec克隆逻辑 #

重写递归克隆注解的逻辑，自动完成KClass转Class、Kotlin数组转Java数组的转换：

public static AnnotationSpec cloneKotlinAnnotation(Annotation annotation) {
    AnnotationSpec.Builder builder = AnnotationSpec.builder(annotation.annotationType());
    for (Method method : annotation.annotationType().getDeclaredMethods()) {
        try {
            Object rawValue = method.invoke(annotation);
            Object convertedValue = convertAnnotationValue(rawValue);
            // 根据值类型选择JavaPoet占位符
            if (convertedValue instanceof Class) {
                builder.addMember(method.getName(), "$T", convertedValue);
            } else if (convertedValue instanceof Object[]) {
                builder.addMember(method.getName(), "$L", Arrays.toString((Object[]) convertedValue));
            } else {
                builder.addMember(method.getName(), "$L", convertedValue);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return builder.build();
}

private static Object convertAnnotationValue(Object value) throws Exception {
    if (value == null) return null;
    
    // KClass转Class
    if (value instanceof KClass) {
        Method getJavaClassMethod = value.getClass().getMethod("getJavaClass");
        return getJavaClassMethod.invoke(value);
    }
    
    // Kotlin数组转Java数组，递归转换内部元素
    if (isKotlinArray(value)) {
        Object[] javaArray = convertKotlinArrayToJavaArray(value);
        for (int i = 0; i < javaArray.length; i++) {
            javaArray[i] = convertAnnotationValue(javaArray[i]);
        }
        return javaArray;
    }
    
    // Java数组递归转换内部元素
    if (value.getClass().isArray()) {
        int length = Array.getLength(value);
        Object[] javaArray = new Object[length];
        for (int i = 0; i < length; i++) {
            javaArray[i] = convertAnnotationValue(Array.get(value, i));
        }
        return javaArray;
    }
    
    return value;
}

方案二：优化Kotlin注解定义 #

编写Kotlin注解时，通过以下方式提升Java兼容性：

• 类类型参数使用KClass<*>并添加@JvmSuppressWildcards，避免泛型通配符导致的Java调用问题
• 若需完全兼容Java工具，可直接使用Class<*>作为参数类型（Kotlin中需用Class<*>!表示可空的Java类）

示例Kotlin注解定义：

annotation class OpenApi(
    val apiClass: KClass<*> = Unit::class,
    @JvmSuppressWildcards
    val tags: Array<KClass<*>> = []
)

内容的提问来源于stack exchange，提问作者Travis Parks