propertyutilsbean.java

osworkflow修改版本

   * no matter which property reference format is used, with no
   * type conversions.
   *
   * @param bean Bean whose property is to be extracted
   * @param name Possibly indexed and/or nested name of the property
   *             to be extracted
   * @throws IllegalAccessException    if the caller does not have
   *                                   access to the property accessor method
   * @throws IllegalArgumentException  if <code>bean</code> or
   *                                   <code>name</code> is null
   * @throws InvocationTargetException if the property accessor method
   *                                   throws an exception
   * @throws NoSuchMethodException     if an accessor method for this
   *                                   propety cannot be found
   */
  public Object getProperty(Object bean, String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException
  {

    return (getNestedProperty(bean, name));

  }

  /**
   * <p>Retrieve the property descriptor for the specified property of the
   * specified bean, or return <code>null</code> if there is no such
   * descriptor.  This method resolves indexed and nested property
   * references in the same manner as other methods in this class, except
   * that if the last (or only) name element is indexed, the descriptor
   * for the last resolved property itself is returned.</p>
   * <p/>
   * <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
   *
   * @param bean Bean for which a property descriptor is requested
   * @param name Possibly indexed and/or nested name of the property for
   *             which a property descriptor is requested
   * @throws IllegalAccessException    if the caller does not have
   *                                   access to the property accessor method
   * @throws IllegalArgumentException  if <code>bean</code> or
   *                                   <code>name</code> is null
   * @throws IllegalArgumentException  if a nested reference to a
   *                                   property returns null
   * @throws InvocationTargetException if the property accessor method
   *                                   throws an exception
   * @throws NoSuchMethodException     if an accessor method for this
   *                                   propety cannot be found
   */
  public PropertyDescriptor getPropertyDescriptor(Object bean, String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException
  {

    if(bean == null)
    {
      throw new IllegalArgumentException("No bean specified");
    }
    if(name == null)
    {
      throw new IllegalArgumentException("No name specified");
    }

    // Resolve nested references
    while(true)
    {
      int period = findNextNestedIndex(name);
      if(period < 0)
      {
        break;
      }
      String next = name.substring(0, period);
      int indexOfINDEXED_DELIM = next.indexOf(PropertyUtils.INDEXED_DELIM);
      int indexOfMAPPED_DELIM = next.indexOf(PropertyUtils.MAPPED_DELIM);
      if(indexOfMAPPED_DELIM >= 0 && (indexOfINDEXED_DELIM < 0 || indexOfMAPPED_DELIM < indexOfINDEXED_DELIM))
      {
        bean = getMappedProperty(bean, next);
      }
      else
      {
        if(indexOfINDEXED_DELIM >= 0)
        {
          bean = getIndexedProperty(bean, next);
        }
        else
        {
          bean = getSimpleProperty(bean, next);
        }
      }
      if(bean == null)
      {
        throw new IllegalArgumentException("Null property value for '" + name.substring(0, period) + "'");
      }
      name = name.substring(period + 1);
    }

    // Remove any subscript from the final name value
    int left = name.indexOf(PropertyUtils.INDEXED_DELIM);
    if(left >= 0)
    {
      name = name.substring(0, left);
    }
    left = name.indexOf(PropertyUtils.MAPPED_DELIM);
    if(left >= 0)
    {
      name = name.substring(0, left);
    }

    // Look up and return this property from our cache
    // creating and adding it to the cache if not found.
    if((bean == null) || (name == null))
    {
      return (null);
    }

    PropertyDescriptor descriptors[] = getPropertyDescriptors(bean);
    if(descriptors != null)
    {

      for(int i = 0; i < descriptors.length; i++)
      {
        if(name.equals(descriptors[i].getName()))
          return (descriptors[i]);
      }
    }

    PropertyDescriptor result = null;
    Map mappedDescriptors = getMappedPropertyDescriptors(bean);
    if(mappedDescriptors == null)
    {
      mappedDescriptors = new HashMap();
      mappedDescriptorsCache.put(bean.getClass(), mappedDescriptors);
    }
    result = (PropertyDescriptor)mappedDescriptors.get(name);
    if(result == null)
    {
      // not found, try to create it
      try
      {
        result = new MappedPropertyDescriptor(name, bean.getClass());
      }
      catch(IntrospectionException ie)
      {
      }
      if(result != null)
      {
        mappedDescriptors.put(name, result);
      }
    }

    return result;

  }

  private int findNextNestedIndex(String expression)
  {
    // walk back from the end to the start
    // and find the first index that
    int bracketCount = 0;
    for(int i = 0, size = expression.length(); i < size; i++)
    {
      char at = expression.charAt(i);
      switch(at)
      {
        case PropertyUtils.NESTED_DELIM:
          if(bracketCount < 1)
          {
            return i;
          }
          break;

        case PropertyUtils.MAPPED_DELIM:
        case PropertyUtils.INDEXED_DELIM:
          // not bothered which
          ++bracketCount;
          break;

        case PropertyUtils.MAPPED_DELIM2:
        case PropertyUtils.INDEXED_DELIM2:
          // not bothered which
          --bracketCount;
          break;
      }
    }
    // can't find any
    return -1;
  }

  /**
   * <p>Retrieve the property descriptors for the specified class,
   * introspecting and caching them the first time a particular bean class
   * is encountered.</p>
   * <p/>
   * <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
   *
   * @param beanClass Bean class for which property descriptors are requested
   * @throws IllegalArgumentException if <code>beanClass</code> is null
   */
  public PropertyDescriptor[] getPropertyDescriptors(Class beanClass)
  {

    if(beanClass == null)
    {
      throw new IllegalArgumentException("No bean class specified");
    }

    // Look up any cached descriptors for this bean class
    PropertyDescriptor descriptors[] = null;
    descriptors = (PropertyDescriptor[])descriptorsCache.get(beanClass);
    if(descriptors != null)
    {
      return (descriptors);
    }

    // Introspect the bean and cache the generated descriptors
    BeanInfo beanInfo = null;
    try
    {
      beanInfo = Introspector.getBeanInfo(beanClass);
    }
    catch(IntrospectionException e)
    {
      return (new PropertyDescriptor[0]);
    }
    descriptors = beanInfo.getPropertyDescriptors();
    if(descriptors == null)
    {
      descriptors = new PropertyDescriptor[0];
    }
    descriptorsCache.put(beanClass, descriptors);
    return (descriptors);

  }

  /**
   * <p>Retrieve the property descriptors for the specified bean,
   * introspecting and caching them the first time a particular bean class
   * is encountered.</p>
   * <p/>
   * <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
   *
   * @param bean Bean for which property descriptors are requested
   * @throws IllegalArgumentException if <code>bean</code> is null
   */
  public PropertyDescriptor[] getPropertyDescriptors(Object bean)
  {

    if(bean == null)
    {
      throw new IllegalArgumentException("No bean specified");
    }
    return (getPropertyDescriptors(bean.getClass()));

  }

  /**
   * <p>Return the Java Class repesenting the property editor class that has
   * been registered for this property (if any).  This method follows the
   * same name resolution rules used by <code>getPropertyDescriptor()</code>,
   * so if the last element of a name reference is indexed, the property
   * editor for the underlying property's class is returned.</p>
   * <p/>
   * <p>Note that <code>null</code> will be returned if there is no property,
   * or if there is no registered property editor class.  Because this
   * return value is ambiguous, you should determine the existence of the
   * property itself by other means.</p>
   * <p/>
   * <p><strong>FIXME</strong> - Does not work with DynaBeans.</p>
   *
   * @param bean Bean for which a property descriptor is requested
   * @param name Possibly indexed and/or nested name of the property for
   *             which a property descriptor is requested
   * @throws IllegalAccessException    if the caller does not have
   *                                   access to the property accessor method
   * @throws IllegalArgumentException  if <code>bean</code> or
   *                                   <code>name</code> is null
   * @throws IllegalArgumentException  if a nested reference to a
   *                                   property returns null
   * @throws InvocationTargetException if the property accessor method
   *                                   throws an exception
   * @throws NoSuchMethodException     if an accessor method for this
   *                                   propety cannot be found
   */
  public Class getPropertyEditorClass(Object bean, String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException
  {

    if(bean == null)
    {
      throw new IllegalArgumentException("No bean specified");
    }
    if(name == null)
    {
      throw new IllegalArgumentException("No name specified");
    }

    PropertyDescriptor descriptor = getPropertyDescriptor(bean, name);
    if(descriptor != null)
    {
      return (descriptor.getPropertyEditorClass());
    }
    else
    {
      return (null);
    }

  }

  /**
   * Return the Java Class representing the property type of the specified
   * property, or <code>null</code> if there is no such property for the
   * specified bean.  This method follows the same name resolution rules
   * used by <code>getPropertyDescriptor()</code>, so if the last element
   * of a name reference is indexed, the type of the property itself will
   * be returned.  If the last (or only) element has no property with the
   * specified name, <code>null</code> is returned.
   *
   * @param bean Bean for which a property descriptor is requested
   * @param name Possibly indexed and/or nested name of the property for
   *             which a property descriptor is requested
   * @throws IllegalAccessException    if the caller does not have
   *                                   access to the property accessor method
   * @throws IllegalArgumentException  if <code>bean</code> or
   *                                   <code>name</code> is null
   * @throws IllegalArgumentException  if a nested reference to a
   *                                   property returns null
   * @throws InvocationTargetException if the property accessor method
   *                                   throws an exception
   * @throws NoSuchMethodException     if an accessor method for this
   *                                   propety cannot be found
   */
  public Class getPropertyType(Object bean, String name) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException
  {

    if(bean == null)
    {
      throw new IllegalArgumentException("No bean specified");
    }
    if(name == null)
    {
      throw new IllegalArgumentException("No name specified");
    }

    PropertyDescriptor descriptor = getPropertyDescriptor(bean, name);
    if(descriptor == null)
    {
      return (null);
    }
    else if(descriptor instanceof IndexedPropertyDescriptor)
    {
      return (((IndexedPropertyDescriptor)descriptor).getIndexedPropertyType());
    }
    else if(descriptor instanceof MappedPropertyDescriptor)
    {