这个问题看起来很尴尬但我们在检索
javabean的PropertyDescriptors时遇到了一个奇怪的行为.

以下是1.6,1.7和1.8的简单代码的执行结果,编译为1.6兼容.

Java 1.6执行：

java.beans.PropertyDescriptor@4ddc1428< – 不重要
java.beans.IndexedPropertyDescriptor@7174807e< – 是的我有一个索引属性 Java 1.7执行： java.beans.PropertyDescriptor中[名=类; propertyType = class java.lang.Class; readMethod = public final native java.lang.Class java.lang.Object.getClass()]< – 不重要
java.beans.IndexedPropertyDescriptor中[名=值; indexedPropertyType = class java.lang.String; indexedReadMethod = public java.lang.String JavaBean.getValues(int)]< – 是的我有一个索引属性 Java 1.8执行： java.beans.PropertyDescriptor中[名=类; propertyType = class java.lang.Class; readMethod = public final native java.lang.Class java.lang.Object.getClass()]< – 不重要
java.beans.PropertyDescriptor中[名=值; propertyType = interface java.util.List; readMethod = public java.util.List JavaBean.getValues()]< – 哎哟！这不再是索引属性了！ 为什么会改变？ javabean规范说明了如何使用索引访问属性.使用数组作为索引属性的容器并不是必须的.我错了吗？ 我阅读了规范和章节8.3.3讨论索引属性的设计模式,而不是严格的规则. 如何在不重构所有应用程序的情况下重新恢复以前的行为？ <旧的应用程序,很多代码要修改等等…… 谢谢你的回答, JavaBean类

import java.util.ArrayList;  
import java.util.List;  


public class JavaBean {  


  private List<String> values = new ArrayList<String>();  


  public String getValues(int index) {  
  return this.values.get(index);  
  }  


  public List<String> getValues() {  
  return this.values;  
  }  
}  

主要课程

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;

public class Test {
    public static void main(String[] args) throws IntrospectionException {
         PropertyDescriptor[] descs =
         Introspector.getBeanInfo(JavaBean.class).getPropertyDescriptors();
         for (PropertyDescriptor pd : descs) {
         System.out.println(pd);
         }
    }
}

最佳答案 从JavaBeans 1.01规范,第7.2节“索引属性”：

A component may also expose an indexed property as a single array value.

第8.3节描述了introspection在没有显式BeanInfo的情况下识别的设计模式.第8.3.3节说只有数组属性才会触发自动识别索引属性.

你在技术上是正确的;不一定要使用数组.但是如果你不这样做,规范说你必须提供自己的BeanInfo来将属性公开为索引属性.

因此,问题标题的答案是：是的,Java 1.8符合JavaBean规范.

我不确定为什么支持List属性.也许未来的JavaBeans规范将支持它们,而后者已被撤销.

至于你的最后一个问题：我认为你必须为每个具有List属性的类创建一个BeanInfo类.我希望你可以创建一个通用的超类来使它更容易,例如：

public abstract class ListRecognizingBeanInfo
extends SimpleBeanInfo {

    private final BeanDescriptor beanDesc;
    private final PropertyDescriptor[] propDesc;

    protected ListRecognizingBeanInfo(Class<?> beanClass)
    throws IntrospectionException {
        beanDesc = new BeanDescriptor(beanClass);

        List<PropertyDescriptor> desc = new ArrayList<>();

        for (Method method : beanClass.getMethods()) {
            int modifiers = method.getModifiers();
            Class<?> type = method.getReturnType();

            if (Modifier.isPublic(modifiers) &&
                !Modifier.isStatic(modifiers) &&
                !type.equals(Void.TYPE) &&
                method.getParameterCount() == 0) {

                String name = method.getName();
                String remainder;
                if (name.startsWith("get")) {
                    remainder = name.substring(3);
                } else if (name.startsWith("is") &&
                           type.equals(Boolean.TYPE)) {
                    remainder = name.substring(2);
                } else {
                    continue;
                }

                if (remainder.isEmpty()) {
                    continue;
                }

                String propName = Introspector.decapitalize(remainder);

                Method writeMethod = null;
                Method possibleWriteMethod =
                    findMethod(beanClass, "set" + remainder, type);
                if (possibleWriteMethod != null &&
                    possibleWriteMethod.getReturnType().equals(Void.TYPE)) {

                    writeMethod = possibleWriteMethod;
                }

                Class<?> componentType = null;
                if (type.isArray()) {
                    componentType = type.getComponentType();
                } else {
                    Type genType = method.getGenericReturnType();
                    if (genType instanceof ParameterizedType) {
                        ParameterizedType p = (ParameterizedType) genType;
                        if (p.getRawType().equals(List.class)) {
                            Type[] argTypes = p.getActualTypeArguments();
                            if (argTypes[0] instanceof Class) {
                                componentType = (Class<?>) argTypes[0];
                            }
                        }
                    }
                }

                Method indexedReadMethod = null;
                Method indexedWriteMethod = null;

                if (componentType != null) {
                    Method possibleReadMethod =
                        findMethod(beanClass, name, Integer.TYPE);
                    Class<?> idxType = possibleReadMethod.getReturnType();
                    if (idxType.equals(componentType)) {
                        indexedReadMethod = possibleReadMethod;
                    }

                    if (writeMethod != null) {
                        possibleWriteMethod =
                            findMethod(beanClass, writeMethod.getName(),
                                Integer.TYPE, componentType);
                        if (possibleWriteMethod != null &&
                            possibleWriteMethod.getReturnType().equals(
                                Void.TYPE)) {

                            indexedWriteMethod = possibleWriteMethod;
                        }
                    }
                }

                if (indexedReadMethod != null) {
                    desc.add(new IndexedPropertyDescriptor(propName,
                        method, writeMethod,
                        indexedReadMethod, indexedWriteMethod));
                } else {
                    desc.add(new PropertyDescriptor(propName,
                        method, writeMethod));
                }
            }
        }

        propDesc = desc.toArray(new PropertyDescriptor[0]);
    }

    private static Method findMethod(Class<?> cls,
                                     String name,
                                     Class<?>... paramTypes) {
        try {
            Method method = cls.getMethod(name, paramTypes);
            int modifiers = method.getModifiers();
            if (Modifier.isPublic(modifiers) &&
                !Modifier.isStatic(modifiers)) {

                return method;
            }
        } catch (NoSuchMethodException e) {
        }

        return null;
    }

    @Override
    public BeanDescriptor getBeanDescriptor() {
        return beanDesc;
    }

    @Override
    public PropertyDescriptor[] getPropertyDescriptors() {
        return propDesc;
    }
}