Spring ExtendedBeanInfo

/**
 * beanInfo 接口
 */
private final BeanInfo delegate;

/**
 * 属性描述集合
 */
private final Set<PropertyDescriptor> propertyDescriptors = new TreeSet<>(new PropertyDescriptorComparator());

// 变量赋值
this.delegate = delegate;
// 获取属性列表
for (PropertyDescriptor pd : delegate.getPropertyDescriptors()) {
   try {
      // 放入属性描述符容器中
      this.propertyDescriptors.add(pd instanceof IndexedPropertyDescriptor ?
            new SimpleIndexedPropertyDescriptor((IndexedPropertyDescriptor) pd) :
            new SimplePropertyDescriptor(pd));
   }
   catch (IntrospectionException ex) {
      // Probably simply a method that wasn't meant to follow the JavaBeans pattern...
      if (logger.isDebugEnabled()) {
         logger.debug("Ignoring invalid bean property '" + pd.getName() + "': " + ex.getMessage());
      }
   }
}

this.propertyDescriptors.add(pd instanceof IndexedPropertyDescriptor ?
      new SimpleIndexedPropertyDescriptor((IndexedPropertyDescriptor) pd) :
      new SimplePropertyDescriptor(pd));

static class SimpleIndexedPropertyDescriptor extends IndexedPropertyDescriptor {
   /**
    * 可读函数
    */
   @Nullable
   private Method readMethod;

   /**
    * 可写函数
    */
   @Nullable
   private Method writeMethod;

   /**
    * 属性类型
    */
   @Nullable
   private Class<?> propertyType;

   @Nullable
   private Method indexedReadMethod;

   @Nullable
   private Method indexedWriteMethod;

   @Nullable
   private Class<?> indexedPropertyType;

   @Nullable
   private Class<?> propertyEditorClass;
}

static class SimplePropertyDescriptor extends PropertyDescriptor {
   /**
    * 可读函数
    */
   @Nullable
   private Method readMethod;

   /**
    * 可写函数
    */
   @Nullable
   private Method writeMethod;

   /**
    * 属性类型
    */
   @Nullable
   private Class<?> propertyType;

   /**
    * 属性编辑器类型
    */
   @Nullable
   private Class<?> propertyEditorClass;
}

// 函数描述符
MethodDescriptor[] methodDescriptors = delegate.getMethodDescriptors();
if (methodDescriptors != null) {
   // 寻找函数进行循环
   for (Method method : findCandidateWriteMethods(methodDescriptors)) {
      try {
         // 处理可写函数
         handleCandidateWriteMethod(method);
      }
      catch (IntrospectionException ex) {
         // We're only trying to find candidates, can easily ignore extra ones here...
         if (logger.isDebugEnabled()) {
            logger.debug("Ignoring candidate write method [" + method + "]: " + ex.getMessage());
         }
      }
   }
}

private List<Method> findCandidateWriteMethods(MethodDescriptor[] methodDescriptors) {
   List<Method> matches = new ArrayList<>();
   for (MethodDescriptor methodDescriptor : methodDescriptors) {
      Method method = methodDescriptor.getMethod();
      if (isCandidateWriteMethod(method)) {
         matches.add(method);
      }
   }
   // Sort non-void returning write methods to guard against the ill effects of
   // non-deterministic sorting of methods returned from Class#getDeclaredMethods
   // under JDK 7. See https://bugs.java.com/view_bug.do?bug_id=7023180
   matches.sort((m1, m2) -> m2.toString().compareTo(m1.toString()));
   return matches;
}

/**
 * 判断函数是否可写
 */
public static boolean isCandidateWriteMethod(Method method) {
   String methodName = method.getName();
   int nParams = method.getParameterCount();
   return (methodName.length() > 3 && methodName.startsWith("set") && Modifier.isPublic(method.getModifiers()) &&
         (!void.class.isAssignableFrom(method.getReturnType()) || Modifier.isStatic(method.getModifiers())) &&
         (nParams == 1 || (nParams == 2 && int.class == method.getParameterTypes()[0])));
}

// 参数数量
int nParams = method.getParameterCount();
// 属性名称
String propertyName = propertyNameFor(method);
// 参数类型
Class<?> propertyType = method.getParameterTypes()[nParams - 1];
// 寻找属性描述符
PropertyDescriptor existingPd = findExistingPropertyDescriptor(propertyName, propertyType);

/**
 * 提取函数的后半段字符 .
 * getName => Name
 * setName => Name
 * @param method
 * @return
 */
private String propertyNameFor(Method method) {
   return Introspector.decapitalize(method.getName().substring(3));
}

@Nullable
private PropertyDescriptor findExistingPropertyDescriptor(String propertyName, Class<?> propertyType) {
   // 循环现有的 属性描述符列表
   for (PropertyDescriptor pd : this.propertyDescriptors) {
      // 待测类型
      final Class<?> candidateType;
      // 属性名称
      final String candidateName = pd.getName();
      // 类型判断
      if (pd instanceof IndexedPropertyDescriptor) {
         IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
         // 从IndexedPropertyDescriptor获取属性类型
         candidateType = ipd.getIndexedPropertyType();
         if (candidateName.equals(propertyName) &&
               (candidateType.equals(propertyType) || candidateType.equals(propertyType.getComponentType()))) {
            return pd;
         }
      }
      else {
         // 设置 待测类型. 从属性描述符中虎丘属性类型
         candidateType = pd.getPropertyType();
         if (candidateName.equals(propertyName) &&
               (candidateType.equals(propertyType) || propertyType.equals(candidateType.getComponentType()))) {
            return pd;
         }
      }
   }
   return null;
}

// 参数数量等于1的情况处理
if (nParams == 1) {
   if (existingPd == null) {
      this.propertyDescriptors.add(new SimplePropertyDescriptor(propertyName, null, method));
   }
   else {
      existingPd.setWriteMethod(method);
   }
}
// 参数数量等于2的情况处理
else if (nParams == 2) {
   if (existingPd == null) {
      this.propertyDescriptors.add(
            new SimpleIndexedPropertyDescriptor(propertyName, null, null, null, method));
   }
   else if (existingPd instanceof IndexedPropertyDescriptor) {
      ((IndexedPropertyDescriptor) existingPd).setIndexedWriteMethod(method);
   }
   else {
      this.propertyDescriptors.remove(existingPd);
      this.propertyDescriptors.add(new SimpleIndexedPropertyDescriptor(
            propertyName, existingPd.getReadMethod(), existingPd.getWriteMethod(), null, method));
   }
}
else {
   throw new IllegalArgumentException("Write method must have exactly 1 or 2 parameters: " + method);
}