Esempio n. 1
0
 /**
  * Creates an instance of the class using the default constructor.
  *
  * @since 0.2.06
  */
 @SuppressWarnings("cast")
 private static <T> T newInstanceFromDefaultConstructor(Class<T> type) {
   if (type == null) return null;
   if (logger.isDebugEnabled()) logger.debug("Instantiating " + type.getSimpleName());
   if (deprecated(type))
     escalator.escalate(
         "Instantiating a deprecated class: " + type.getName(), BeanUtil.class, null);
   try {
     return (T) type.newInstance();
   } catch (InstantiationException e) {
     throw ExceptionMapper.configurationException(e, type);
   } catch (IllegalAccessException e) {
     throw ExceptionMapper.configurationException(e, type);
   }
 }
Esempio n. 2
0
  /**
   * Returns the bean property descriptor of an attribute
   *
   * @param beanClass the class that holds the attribute
   * @param propertyName the name of the property
   * @return the attribute's property descriptor
   */
  public static PropertyDescriptor getPropertyDescriptor(Class<?> beanClass, String propertyName) {
    if (beanClass == null) throw new IllegalArgumentException("beanClass is null");
    String propertyId = beanClass.getName() + '#' + propertyName;
    PropertyDescriptor result = propertyDescriptors.get(propertyId);
    if (result != null) return result;
    // descriptor is new

    int separatorIndex = propertyName.indexOf('.');
    if (separatorIndex >= 0) {
      String localProperty = propertyName.substring(0, separatorIndex);
      String remoteProperty = propertyName.substring(separatorIndex + 1);
      Class<?> localPropertyType =
          getPropertyDescriptor(beanClass, localProperty).getPropertyType();
      result = getPropertyDescriptor(localPropertyType, remoteProperty);
    } else {
      try {
        BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
        PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor descriptor : descriptors) {
          String name = descriptor.getName();
          if (name.equals(propertyName)) {
            result = descriptor;
            break;
          }
        }
      } catch (IntrospectionException e) {
        throw ExceptionMapper.configurationException(e, propertyName);
      }
    }
    propertyDescriptors.put(propertyId, result);
    return result;
  }
Esempio n. 3
0
 /**
  * Instantiates the specified class.
  *
  * @param name the name of the class to instantiate
  * @return the Class instance
  */
 @SuppressWarnings({"unchecked", "rawtypes"})
 public static <T> Class<T> forName(String name) {
   Assert.notNull(name, "class name");
   Class type = simpleTypeMap.get(name);
   if (type != null) return type;
   else {
     try {
       return (Class<T>) getContextClassLoader().loadClass(name);
     } catch (ClassNotFoundException e) {
       throw ExceptionMapper.configurationException(e, name);
     } catch (NullPointerException e) {
       // this is raised by the Eclipse BundleLoader if it does not find the class
       throw ExceptionMapper.configurationException(e, name);
     }
   }
 }
Esempio n. 4
0
 /**
  * Sets an attribute value of an object.
  *
  * @param obj the object to modify
  * @param field the attribute to set
  * @param value the value to assign to the field
  */
 private static void setAttributeValue(Object obj, Field field, Object value) {
   try {
     field.set(obj, value);
   } catch (IllegalAccessException e) {
     throw ExceptionMapper.configurationException(e, field);
   }
 }
Esempio n. 5
0
 /**
  * Returns a Field object that represents an attribute of a class
  *
  * @param type the class that holds the attribute
  * @param name the name of the attribute
  * @return a Field object that represents the attribute
  */
 public static Field getField(Class<?> type, String name) {
   try {
     return type.getField(name);
   } catch (NoSuchFieldException e) {
     throw ExceptionMapper.configurationException(e, type.getName() + '.' + name);
   }
 }
Esempio n. 6
0
 public static <T> T newInstance(
     Constructor<T> constructor, boolean strict, Object... parameters) {
   if (!strict) parameters = convertArray(parameters, constructor.getParameterTypes());
   Class<T> type = constructor.getDeclaringClass();
   if (deprecated(type))
     escalator.escalate(
         "Instantiating a deprecated class: " + type.getName(), BeanUtil.class, null);
   try {
     return constructor.newInstance(parameters);
   } catch (InstantiationException e) {
     throw ExceptionMapper.configurationException(e, type);
   } catch (IllegalAccessException e) {
     throw ExceptionMapper.configurationException(e, type);
   } catch (InvocationTargetException e) {
     throw ExceptionMapper.configurationException(e, type);
   }
 }
Esempio n. 7
0
 /**
  * Returns a class' static attribute value
  *
  * @param objectType the class to query
  * @param attributeName the name of the attribute
  * @return the attribute value
  */
 public static Object getStaticAttributeValue(Class<?> objectType, String attributeName) {
   Field field = getField(objectType, attributeName);
   try {
     return field.get(null);
   } catch (IllegalAccessException e) {
     throw ExceptionMapper.configurationException(e, field);
   }
 }
Esempio n. 8
0
 @SuppressWarnings({"unchecked", "rawtypes"})
 public static Object invoke(Object target, Method method, boolean strict, Object... args) {
   try {
     Object[] params;
     Class<?>[] paramTypes = method.getParameterTypes();
     if (paramTypes.length == 0) {
       params = null;
     } else if (args.length == paramTypes.length) {
       // map one to one
       if (strict) {
         params = args;
       } else {
         params = new Object[paramTypes.length];
         for (int i = 0; i < paramTypes.length; i++) {
           Object arg = args[i];
           if (arg == null) params[i] = null;
           else {
             Converter converter =
                 ConverterManager.getInstance().createConverter(arg.getClass(), paramTypes[i]);
             params[i] = converter.convert(arg);
           }
         }
       }
     } else {
       // map varargs
       params = new Object[paramTypes.length];
       for (int i = 0; i < paramTypes.length - 1; i++)
         params[i] = (strict ? args[i] : AnyConverter.convert(args[i], paramTypes[i]));
       Class<?> varargsComponentType = paramTypes[paramTypes.length - 1].getComponentType();
       Object varargs =
           Array.newInstance(varargsComponentType, args.length - paramTypes.length + 1);
       for (int i = 0; i < args.length - paramTypes.length + 1; i++) {
         Object param = args[paramTypes.length - 1 + i];
         if (strict) param = AnyConverter.convert(param, varargsComponentType);
         Array.set(varargs, i, param);
       }
       params[params.length - 1] = varargs;
     }
     return method.invoke(target, params);
   } catch (IllegalAccessException e) {
     throw ExceptionMapper.configurationException(e, method);
   } catch (InvocationTargetException e) {
     throw ExceptionMapper.configurationException(e, method);
   }
 }
Esempio n. 9
0
 public static Object getPropertyValue(Object bean, String propertyName, boolean strict) {
   Method readMethod = null;
   try {
     PropertyDescriptor descriptor = getPropertyDescriptor(bean.getClass(), propertyName);
     if (descriptor == null) {
       if (strict)
         throw new ConfigurationError(
             "Property '" + propertyName + "' not found in class " + bean.getClass());
       else return null;
     }
     readMethod = descriptor.getReadMethod();
     return readMethod.invoke(bean);
   } catch (IllegalAccessException e) {
     throw ExceptionMapper.configurationException(e, readMethod);
   } catch (InvocationTargetException e) {
     throw ExceptionMapper.configurationException(e, readMethod);
   }
 }
Esempio n. 10
0
 /**
  * Returns an object's attribute value
  *
  * @param obj the object to query
  * @param attributeName the name of the attribute
  * @return the attribute value
  */
 public static Object getAttributeValue(Object obj, String attributeName) {
   if (obj == null) throw new IllegalArgumentException("Object may not be null");
   Field field = getField(obj.getClass(), attributeName);
   try {
     return field.get(obj);
   } catch (IllegalAccessException e) {
     throw ExceptionMapper.configurationException(e, field);
   }
 }
Esempio n. 11
0
 public static void setPropertyValue(
     Object bean,
     String propertyName,
     Object propertyValue,
     boolean required,
     boolean autoConvert) {
   Method writeMethod = null;
   try {
     Class<?> beanClass = bean.getClass();
     PropertyDescriptor propertyDescriptor = getPropertyDescriptor(beanClass, propertyName);
     if (propertyDescriptor == null)
       if (required)
         throw new ConfigurationError(
             beanClass + " does not have a property '" + propertyName + "'");
       else return;
     writeMethod = propertyDescriptor.getWriteMethod();
     if (writeMethod == null)
       throw new UnsupportedOperationException(
           "Cannot write read-only property '"
               + propertyDescriptor.getName()
               + "' of "
               + beanClass);
     Class<?> propertyType = propertyDescriptor.getPropertyType();
     if (propertyValue != null) {
       Class<?> argType = propertyValue.getClass();
       if (!propertyType.isAssignableFrom(argType)
           && !isWrapperTypeOf(propertyType, propertyValue)
           && !autoConvert)
         throw new IllegalArgumentException(
             "ArgumentType mismatch: expected "
                 + propertyType.getName()
                 + ", found "
                 + propertyValue.getClass().getName());
       else propertyValue = AnyConverter.convert(propertyValue, propertyType);
     }
     writeMethod.invoke(bean, propertyValue);
   } catch (IllegalAccessException e) {
     throw ExceptionMapper.configurationException(e, writeMethod);
   } catch (InvocationTargetException e) {
     throw ExceptionMapper.configurationException(e, writeMethod);
   }
 }
Esempio n. 12
0
 public static Object getFieldValue(Object target, String name, boolean strict) {
   Class<?> type = target.getClass();
   try {
     Field field = type.getField(name);
     return getFieldValue(field, target, strict);
   } catch (NoSuchFieldException e) {
     if (strict) throw ExceptionMapper.configurationException(e, type.getName() + '.' + name);
     else {
       escalator.escalate("Class '" + type + "' does not have a field '" + name + "'", type, name);
       return null;
     }
   }
 }
Esempio n. 13
0
 @SuppressWarnings({"unchecked", "rawtypes"})
 public static <T> T newInstance(Class<T> type, boolean strict, Object... parameters) {
   if (parameters.length == 0) return newInstanceFromDefaultConstructor(type);
   Constructor<T> constructorToUse = null;
   try {
     Constructor<T>[] constructors = (Constructor<T>[]) type.getConstructors();
     List<Constructor<T>> candidates = new ArrayList<Constructor<T>>(constructors.length);
     int paramCount = parameters.length;
     for (Constructor<T> constructor : constructors)
       if (constructor.getParameterTypes().length == paramCount) candidates.add(constructor);
     if (candidates.size() == 1) constructorToUse = candidates.get(0);
     else if (candidates.size() == 0)
       throw new ConfigurationError(
           "No constructor with " + paramCount + " parameters found for " + type);
     else {
       // there are several candidates - find the first one with matching types
       Class<?>[] paramTypes = new Class[parameters.length];
       for (int i = 0; i < parameters.length; i++) paramTypes[i] = parameters[i].getClass();
       for (Constructor c : type.getConstructors()) {
         if (typesMatch(c.getParameterTypes(), paramTypes)) {
           constructorToUse = c;
           break;
         }
       }
       // there is no ideal match
       if (constructorToUse == null) {
         if (strict)
           throw new NoSuchMethodException(
               "No appropriate constructor found: "
                   + type
                   + '('
                   + ArrayFormat.format(", ", paramTypes)
                   + ')');
         Exception mostRecentException = null;
         for (Constructor<T> candidate : candidates) {
           try {
             return newInstance(candidate, strict, parameters);
           } catch (Exception e) {
             mostRecentException = e;
             logger.warn("Exception in constructor call: " + candidate, e);
             continue; // ignore exception and try next constructor
           }
         }
         // no constructor could be called without exception
         String errMsg =
             (mostRecentException != null
                 ? "None of these constructors could be called without exception: "
                     + candidates
                     + ", latest exception: "
                     + mostRecentException
                 : type
                     + " has no appropriate constructor for the arguments "
                     + ArrayFormat.format(", ", parameters));
         throw new ConfigurationError(errMsg);
       }
     }
     if (!strict) parameters = convertArray(parameters, constructorToUse.getParameterTypes());
     return newInstance(constructorToUse, parameters);
   } catch (SecurityException e) {
     throw ExceptionMapper.configurationException(e, constructorToUse);
   } catch (NoSuchMethodException e) {
     throw ExceptionMapper.configurationException(e, type);
   }
 }