コード例 #1
0
  public static void main(String[] args)
      throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    Company com = new Company();

    com.setName("");
    com.getName();

    // simple
    BeanUtils.setProperty(com, "name", "Jack");
    BeanUtils.getProperty(com, "name");

    // indexed
    BeanUtils.setProperty(com, "product[1]", "NOTES SERVER");
    BeanUtils.getProperty(com, "product[1]");

    // mapped
    HashMap am = new HashMap();
    am.put("1", "10010");
    am.put("2", "10010");
    BeanUtils.setProperty(com, "telephone", am);
    BeanUtils.getProperty(com, "telephone(2)");

    // combined
    BeanUtils.getProperty(com, "employee[1].name");

    // copyProperty
    Company com2 = new Company();
    BeanUtils.copyProperties(com2, com);

    // converter
    BeanUtils.setProperty(com, "date", new Date());

    BeanUtils.setProperty(com, "date", "2013-10-01");

    ConvertUtils.register(
        new Converter() {

          public <T> T convert(Class<T> type, Object value) {
            // TODO Auto-generated method stub
            return null;
          }
        },
        Date.class);

    // DynamicBean
    LazyDynaMap dynaBean = new LazyDynaMap();

    dynaBean.set("foo", "bar");
    dynaBean.set("customer", "title", "Rose");
    dynaBean.set("address", 0, "address1");
    System.out.println(dynaBean.get("address", 0));
    Map map = dynaBean.getMap();
    System.out.println(map.toString());

    // returnNull
    dynaBean.setReturnNull(true);

    // Restricted
    dynaBean.setRestricted(true);
  }
コード例 #2
0
  /**
   * Constructs a PropertyConnector that synchronizes the two bound bean properties as specified by
   * the given pairs of bean and associated property name. If <code>Bean1#property1Name</code>
   * changes it updates <code>Bean2#property2Name</code> and vice versa. If a bean does not provide
   * support for bound properties, changes will not be observed. If a bean property is read-only,
   * this connector will not listen to the other bean's property and so won't update the read-only
   * property.
   *
   * <p>In case you don't need the PropertyConnector instance, you better use the static method
   * {@link #connect(Object, String, Object, String)}. This constructor may confuse developers if
   * you just use the side effects performed in the constructor; this is because it is quite
   * unconventional to instantiate an object that you never use.
   *
   * @param bean1 the bean that owns the first property
   * @param property1Name the name of the first property
   * @param bean2 the bean that owns the second property
   * @param property2Name the name of the second property
   * @throws NullPointerException if a bean or property name is <code>null</code>
   * @throws IllegalArgumentException if the beans are identical and the property name are equal, or
   *     if both properties are read-only
   */
  public PropertyConnector(Object bean1, String property1Name, Object bean2, String property2Name) {
    if (bean1 == null) throw new NullPointerException("Bean1 must not be null.");
    if (bean2 == null) throw new NullPointerException("Bean2 must not be null.");
    if (property1Name == null) throw new NullPointerException("PropertyName1 must not be null.");
    if (property2Name == null) throw new NullPointerException("PropertyName2 must not be null.");
    if ((bean1 == bean2) && (property1Name.equals(property2Name)))
      throw new IllegalArgumentException(
          "Cannot connect a bean property to itself on the same bean.");

    this.bean1 = bean1;
    this.bean2 = bean2;
    this.bean1Class = bean1.getClass();
    this.bean2Class = bean2.getClass();
    this.property1Name = property1Name;
    this.property2Name = property2Name;

    property1Descriptor = getPropertyDescriptor(bean1Class, property1Name);
    property2Descriptor = getPropertyDescriptor(bean2Class, property2Name);

    // Used to check if property2 shall be observed,
    // i.e. if a listener shall be registered with property2.
    boolean property1Writable = property1Descriptor.getWriteMethod() != null;

    // Used to check if property1 shall be observed,
    // i.e. if a listener shall be registered with property1.
    boolean property2Writable = property2Descriptor.getWriteMethod() != null;
    // Reject to connect to read-only properties
    if (!property1Writable && !property2Writable)
      throw new IllegalArgumentException("Cannot connect two read-only properties.");

    boolean property1Observable = BeanUtils.supportsBoundProperties(bean1Class);
    boolean property2Observable = BeanUtils.supportsBoundProperties(bean2Class);
    // We do not reject the case where two unobservable beans
    // are connected; this allows a hand-update using #updateProperty1
    // and #updateProperty2.

    // Observe property1 if and only if bean1 provides support for
    // bound bean properties, and if updates can be written to property2.
    if (property1Observable && property2Writable) {
      property1ChangeHandler =
          new PropertyChangeHandler(bean1, property1Descriptor, bean2, property2Descriptor);
      addPropertyChangeHandler(bean1, bean1Class, property1ChangeHandler);
    } else {
      property1ChangeHandler = null;
    }

    // Observe property2 if and only if bean2 provides support for
    // bound bean properties, and if updates can be written to property1.
    if (property2Observable && property1Writable) {
      property2ChangeHandler =
          new PropertyChangeHandler(bean2, property2Descriptor, bean1, property1Descriptor);
      addPropertyChangeHandler(bean2, bean2Class, property2ChangeHandler);
    } else {
      property2ChangeHandler = null;
    }
  }
コード例 #3
0
ファイル: MapUtils.java プロジェクト: SudhaRao/MyServices
  public static Map createMapUsingProperty(Object[] array, String fieldName)
      throws ApplicationException {
    if (array == null) {
      return null;
    }

    try {
      Map result = new HashMap();
      for (int i = 0; i < array.length; i++) {
        Object current = array[i];
        if (current != null) {
          Object key = BeanUtils.invokeGetter(current, fieldName);
          result.put(key, current);
        }
      }

      return result;
    } catch (Throwable th) {
      LOG.log(Level.SEVERE, th.getMessage(), th);
      throw new ApplicationException(
          "An error occurred while creating a map using property "
              + fieldName
              + ":"
              + th.getMessage());
    }
  }
コード例 #4
0
 @Test
 public void clearClassLoaderForSystemClassLoader() throws Exception {
   BeanUtils.getPropertyDescriptors(ArrayList.class);
   assertTrue(CachedIntrospectionResults.strongClassCache.containsKey(ArrayList.class));
   CachedIntrospectionResults.clearClassLoader(ArrayList.class.getClassLoader());
   assertFalse(CachedIntrospectionResults.strongClassCache.containsKey(ArrayList.class));
 }
コード例 #5
0
 /**
  * Looks up, lazily initializes and returns a <code>PropertyDescriptor</code> for the given Java
  * Bean and property name.
  *
  * @param beanClass the Java Bean class used to lookup the property from
  * @param propertyName the name of the property
  * @return the descriptor for the given bean and property name
  * @throws PropertyNotFoundException if the property could not be found
  */
 private static PropertyDescriptor getPropertyDescriptor(Class<?> beanClass, String propertyName) {
   try {
     return BeanUtils.getPropertyDescriptor(beanClass, propertyName);
   } catch (IntrospectionException e) {
     throw new PropertyNotFoundException(propertyName, beanClass, e);
   }
 }
コード例 #6
0
ファイル: PropertiesUtils.java プロジェクト: zzzzzmh/oa-test
  private static void invokeMethod(
      Object object, Method method, Class parameterType, String propertyValue) {
    logger.debug("match method : {}, {}", method, propertyValue);

    if (parameterType == String.class) {
      BeanUtils.safeInvokeMethod(object, method, propertyValue);
    } else if ((parameterType == Integer.class) || (parameterType == int.class)) {
      BeanUtils.safeInvokeMethod(object, method, Integer.parseInt(propertyValue));
    } else if ((parameterType == Long.class) || (parameterType == long.class)) {
      BeanUtils.safeInvokeMethod(object, method, Long.parseLong(propertyValue));
    } else if ((parameterType == Boolean.class) || (parameterType == boolean.class)) {
      BeanUtils.safeInvokeMethod(object, method, Boolean.valueOf(propertyValue));
    } else {
      logger.info("cannot process parameterType : [" + parameterType + "]");
    }
  }
コード例 #7
0
 private void setValueSilently(
     Object sourceBean,
     PropertyDescriptor sourcePropertyDescriptor,
     Object targetBean,
     PropertyDescriptor targetPropertyDescriptor,
     Object newValue) {
   Object targetValue = BeanUtils.getValue(targetBean, targetPropertyDescriptor);
   if (targetValue == newValue) {
     return;
   }
   if (property1ChangeHandler != null) {
     removePropertyChangeHandler(bean1, bean1Class, property1ChangeHandler);
   }
   if (property2ChangeHandler != null) {
     removePropertyChangeHandler(bean2, bean2Class, property2ChangeHandler);
   }
   try {
     // Set the new value in the target bean.
     BeanUtils.setValue(targetBean, targetPropertyDescriptor, newValue);
   } catch (PropertyVetoException e) {
     // Silently ignore this situation here, will be handled below.
   }
   // The target bean setter may have modified the new value.
   // Read the value set in the target bean.
   targetValue = BeanUtils.getValue(targetBean, targetPropertyDescriptor);
   // If the new value and the value read differ,
   // update the source bean's value.
   // This ignores that the source bean setter may modify the value again.
   // But we won't end in a loop.
   if (!BindingUtils.equals(targetValue, newValue)) {
     boolean sourcePropertyWritable = sourcePropertyDescriptor.getWriteMethod() != null;
     if (sourcePropertyWritable) {
       try {
         BeanUtils.setValue(sourceBean, sourcePropertyDescriptor, targetValue);
       } catch (PropertyVetoException e) {
         // Ignore. The value set is a modified variant
         // of a value that had been accepted before.
       }
     }
   }
   if (property1ChangeHandler != null) {
     addPropertyChangeHandler(bean1, bean1Class, property1ChangeHandler);
   }
   if (property2ChangeHandler != null) {
     addPropertyChangeHandler(bean2, bean2Class, property2ChangeHandler);
   }
 }
コード例 #8
0
 public static List<String> getInstancePropertyNames(ClassNode cNode) {
   List<PropertyNode> pList = BeanUtils.getAllProperties(cNode, false, false, true);
   List<String> result = new ArrayList<String>(pList.size());
   for (PropertyNode pNode : pList) {
     result.add(pNode.getName());
   }
   return result;
 }
コード例 #9
0
 /** Map the argument text into Boolean.TRUE or Boolean.FALSE using Boolean.valueOf. */
 @Override
 public void setAsText(final String text) {
   if (BeanUtils.isNull(text)) {
     setValue(null);
     return;
   }
   Object newValue = Boolean.valueOf(text);
   setValue(newValue);
 }
コード例 #10
0
 public AuthenticationManager(AbstractResource properties, AbstractResource configuration)
     throws RemoteException {
   try {
     BeanUtils utils = new BeanUtils(configuration, properties);
     this.auth = utils.getAuthenticationProvider();
     Set<QName> set = this.auth.getSupportedAuthenticationProfiles();
     if ((set == null) || (set.size() < 1)) {
       throw new Exception(
           "The authentication provider must support at least 1 valid authentication profile.");
     } else if (!AuthenticationProfile.isValid(set)) {
       throw new Exception(
           "The authentication provider supports an unknown authentication profile.");
     }
   } catch (Exception ex) {
     throw new RemoteException(
         "Error instantiating AuthenticationProvider: " + ex.getMessage(), ex);
   }
 }
コード例 #11
0
  /**
   * Returns the value of the property named in the transformer's constructor for the object
   * provided. If any object in the property path leading up to the target property is <code>null
   * </code> then the outcome will be based on the value of the <code>ignoreNull</code> attribute.
   * By default, <code>ignoreNull</code> is <code>false</code> and would result in an <code>
   * IllegalArgumentException</code> if an object in the property path leading up to the target
   * property is <code>null</code>.
   *
   * @param object The object to be transformed.
   * @return The value of the property named in the transformer's constructor for the object
   *     provided.
   * @throws IllegalArgumentException If an IllegalAccessException, InvocationTargetException, or
   *     NoSuchMethodException is thrown when trying to access the property specified on the object
   *     provided. Or if an object in the property path provided is <code>null</code> and <code>
   *     ignoreNull</code> is set to <code>false</code>.
   */
  public Object transform(Object object) {

    Object propertyValue = null;

    try {
      propertyValue = PropertyUtils.getProperty(object, propertyName);
    } catch (IllegalArgumentException e) {
      final String errorMsg =
          "Problem during transformation. Null value encountered in property path...";

      if (ignoreNull) {
        log.warn("WARNING: " + errorMsg + e);
      } else {
        IllegalArgumentException iae = new IllegalArgumentException(errorMsg);
        if (!BeanUtils.initCause(iae, e)) {
          log.error(errorMsg, e);
        }
        throw iae;
      }
    } catch (IllegalAccessException e) {
      final String errorMsg = "Unable to access the property provided.";
      IllegalArgumentException iae = new IllegalArgumentException(errorMsg);
      if (!BeanUtils.initCause(iae, e)) {
        log.error(errorMsg, e);
      }
      throw iae;
    } catch (InvocationTargetException e) {
      final String errorMsg = "Exception occurred in property's getter";
      IllegalArgumentException iae = new IllegalArgumentException(errorMsg);
      if (!BeanUtils.initCause(iae, e)) {
        log.error(errorMsg, e);
      }
      throw iae;
    } catch (NoSuchMethodException e) {
      final String errorMsg = "No property found for name [" + propertyName + "]";
      IllegalArgumentException iae = new IllegalArgumentException(errorMsg);
      if (!BeanUtils.initCause(iae, e)) {
        log.error(errorMsg, e);
      }
      throw iae;
    }

    return propertyValue;
  }
コード例 #12
0
 /**
  * A property in the observed bean has changed. First checks, if this listener should handle the
  * event, because the event's property name is the one to be observed or the event indicates
  * that any property may have changed. In case the event provides no new value, it is read from
  * the source bean.
  *
  * @param evt the property change event to be handled
  */
 public void propertyChange(PropertyChangeEvent evt) {
   String sourcePropertyName = sourcePropertyDescriptor.getName();
   if ((evt.getPropertyName() == null) || (evt.getPropertyName().equals(sourcePropertyName))) {
     Object newValue = evt.getNewValue();
     if (newValue == null) {
       newValue = BeanUtils.getValue(sourceBean, sourcePropertyDescriptor);
     }
     setValueSilently(
         sourceBean, sourcePropertyDescriptor, targetBean, targetPropertyDescriptor, newValue);
   }
 }
コード例 #13
0
ファイル: Conversions.java プロジェクト: ThrawnCA/boon
  @SuppressWarnings("unchecked")
  public static <T> T toPrimitiveArrayIfPossible(Class<T> clz, Object value) {
    if (clz == Typ.intArray) {
      return (T) iarray(value);
    } else if (clz == Typ.byteArray) {
      return (T) barray(value);
    } else if (clz == Typ.charArray) {
      return (T) carray(value);
    } else if (clz == Typ.shortArray) {
      return (T) sarray(value);
    } else if (clz == Typ.longArray) {
      return (T) larray(value);
    } else if (clz == Typ.floatArray) {
      return (T) farray(value);
    } else if (clz == Typ.doubleArray) {
      return (T) darray(value);
    } else if (value.getClass() == clz) {
      return (T) value;
    } else {
      int index = 0;
      Object newInstance = Array.newInstance(clz.getComponentType(), Boon.len(value));
      Iterator<Object> iterator = iterator(Typ.object, value);
      while (iterator.hasNext()) {

        Object item = iterator.next();

        if (clz.getComponentType().isAssignableFrom(item.getClass())) {

          BeanUtils.idx(newInstance, index, item);

        } else {

          item = coerce(clz.getComponentType(), item);

          BeanUtils.idx(newInstance, index, item);
        }
        index++;
      }
      return (T) newInstance;
    }
  }
コード例 #14
0
 /**
  * Find a default editor for the given type.
  *
  * @param requiredType the type to find an editor for
  * @return the corresponding editor, or {@code null} if none
  */
 private PropertyEditor findDefaultEditor(Class<?> requiredType) {
   PropertyEditor editor = null;
   if (requiredType != null) {
     // No custom editor -> check BeanWrapperImpl's default editors.
     editor = this.propertyEditorRegistry.getDefaultEditor(requiredType);
     if (editor == null && String.class != requiredType) {
       // No BeanWrapper default editor -> check standard JavaBean editor.
       editor = BeanUtils.findEditorByConvention(requiredType);
     }
   }
   return editor;
 }
コード例 #15
0
 @Override
 public void setAsText(final String text) {
   if (BeanUtils.isNull(text)) {
     setValue(null);
   } else {
     try {
       setValue(new BigDecimal(text));
     } catch (NumberFormatException e) {
       throw new IllegalArgumentException("Failed to parse");
     }
   }
 }
コード例 #16
0
ファイル: Conversions.java プロジェクト: ThrawnCA/boon
 public static Object toArrayGuessType(Collection<?> value) {
   Class<?> componentType = Reflection.getComponentType(value);
   Object array = Array.newInstance(componentType, value.size());
   @SuppressWarnings("unchecked")
   Iterator<Object> iterator = (Iterator<Object>) value.iterator();
   int index = 0;
   while (iterator.hasNext()) {
     BeanUtils.idx(array, index, iterator.next());
     index++;
   }
   return array;
 }
コード例 #17
0
 /** {@inheritDoc} */
 @Override
 Object getProperty(SqlProcessContext ctx, Object obj, String item) {
   String prefix = null;
   String suffix = null;
   String name = null;
   int ix = item.indexOf("?");
   if (ix >= 0) {
     prefix = item.substring(0, ix);
     suffix = item.substring(ix + 1);
     name = prefix + suffix;
   } else {
     ix = item.indexOf("@");
     if (ix >= 0) {
       prefix = item.substring(0, ix);
       suffix = SqlProcessContext.getFeature(item.substring(ix + 1));
       name = prefix + suffix;
     } else {
       name = item;
     }
   }
   Object result = (BeanUtils.checkProperty(obj, name)) ? BeanUtils.getProperty(obj, name) : null;
   if (result != null || prefix == null || suffix == null) return result;
   suffix = SqlUtils.firstLowerCase(suffix);
   Object o = (BeanUtils.checkProperty(obj, suffix)) ? BeanUtils.getProperty(obj, suffix) : null;
   if (o == null || !(o instanceof Map)) {
     suffix = SqlProcessContext.getFeature(SqlFeature.OPERATOR_ATTRIBUTE_IN_MAP);
     o = (BeanUtils.checkProperty(obj, suffix)) ? BeanUtils.getProperty(obj, suffix) : null;
     if (o == null || !(o instanceof Map)) {
       return null;
     }
   }
   Map map = (Map) o;
   return map.get(prefix);
 }
コード例 #18
0
 /**
  * Initialize the mapping metadata for the given class.
  *
  * @param mappedClass the mapped class.
  */
 protected void initialize(Class<?> mappedClass) {
   this.mappedClass = mappedClass;
   this.mappedFields = new HashMap<>();
   PropertyDescriptor[] pds = BeanUtils.getPropertyDescriptors(mappedClass);
   for (PropertyDescriptor pd : pds) {
     if (pd.getWriteMethod() != null || pd.getReadMethod() != null) {
       this.mappedFields.put(pd.getName().toLowerCase(), pd);
       String underscoredName = underscoreName(pd.getName());
       if (!pd.getName().toLowerCase().equals(underscoredName)) {
         this.mappedFields.put(underscoredName, pd);
       }
     }
   }
 }
コード例 #19
0
 @Override
 protected IDatabaseConnection getConnection() throws Exception {
   Connection conn = dataSource.getConnection();
   IDatabaseConnection connection =
       new DatabaseConnection(
           conn,
           dbType.equalsIgnoreCase("oracle") ? testProperties.getProperty("db.username") : null);
   DatabaseConfig config = connection.getConfig();
   if (containsProperty(testProperties, DATATYPE_FACTORY)) {
     Class clazz = Class.forName(testProperties.getProperty(DATATYPE_FACTORY));
     config.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, BeanUtils.getInstance(clazz));
   }
   return connection;
 }
コード例 #20
0
 /**
  * Find a default editor for the given type.
  *
  * @param requiredType the type to find an editor for
  * @param descriptor the JavaBeans descriptor for the property
  * @return the corresponding editor, or <code>null</code> if none
  */
 protected PropertyEditor findDefaultEditor(Class requiredType, TypeDescriptor typeDescriptor) {
   PropertyEditor editor = null;
   if (typeDescriptor instanceof PropertyTypeDescriptor) {
     PropertyDescriptor pd = ((PropertyTypeDescriptor) typeDescriptor).getPropertyDescriptor();
     editor = pd.createPropertyEditor(this.targetObject);
   }
   if (editor == null && requiredType != null) {
     // No custom editor -> check BeanWrapperImpl's default editors.
     editor = this.propertyEditorRegistry.getDefaultEditor(requiredType);
     if (editor == null && !String.class.equals(requiredType)) {
       // No BeanWrapper default editor -> check standard JavaBean editor.
       editor = BeanUtils.findEditorByConvention(requiredType);
     }
   }
   return editor;
 }
コード例 #21
0
  /**
   * Extract the values for all attributes in the struct.
   *
   * <p>Utilizes public setters and result set metadata.
   *
   * @see java.sql.ResultSetMetaData
   */
  public Object fromStruct(STRUCT struct) throws SQLException {
    Assert.state(this.mappedClass != null, "Mapped class was not specified");
    Object mappedObject = BeanUtils.instantiateClass(this.mappedClass);
    BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(mappedObject);
    initBeanWrapper(bw);

    ResultSetMetaData rsmd = struct.getDescriptor().getMetaData();
    Object[] attr = struct.getAttributes();
    int columnCount = rsmd.getColumnCount();
    for (int index = 1; index <= columnCount; index++) {
      String column = JdbcUtils.lookupColumnName(rsmd, index).toLowerCase();
      PropertyDescriptor pd = (PropertyDescriptor) this.mappedFields.get(column);
      if (pd != null) {
        Object value = attr[index - 1];
        if (logger.isDebugEnabled()) {
          logger.debug(
              "Mapping column '"
                  + column
                  + "' to property '"
                  + pd.getName()
                  + "' of type "
                  + pd.getPropertyType());
        }
        if (bw.isWritableProperty(pd.getName())) {
          try {
            bw.setPropertyValue(pd.getName(), value);
          } catch (Exception e) {
            e.printStackTrace();
          }
        } else {
          // Если нету сеттера для проперти не нужно кидать ошибку!
          logger.warn(
              "Unable to access the setter for "
                  + pd.getName()
                  + ".  Check that "
                  + "set"
                  + StringUtils.capitalize(pd.getName())
                  + " is declared and has public access.");
        }
      }
    }

    return mappedObject;
  }
コード例 #22
0
ファイル: CSAEvaluator.java プロジェクト: Genssiz/CloudAid
  // Adds to each Service template the general criteria for the CSA
  // (each service template can have is own set of criteria, but if a global criteria is defined
  // each component must use it.)
  private void generalizeCSACriteria() {
    ArrayList<ServiceTemplate> comps = new ArrayList<ServiceTemplate>();
    ArrayList<Criterion> crit = new ArrayList<Criterion>();

    comps = this.data.getServiceTemplates();
    crit = this.data.getCriteria();

    for (ServiceTemplate c : comps) {
      for (Criterion cr : crit) {
        try {
          Criterion temp = (Criterion) BeanUtils.cloneBean(cr);
          c.addCrit(temp);
        } catch (IllegalAccessException
            | InstantiationException
            | InvocationTargetException
            | NoSuchMethodException e) {
          e.printStackTrace();
        }
      }
    }
  }
コード例 #23
0
ファイル: CSAEvaluator.java プロジェクト: Genssiz/CloudAid
  // Adds to each service template the general requirements for the CSA
  // (if a part of the CSA does not fulfill the requirement the whole will not fullfill it either)
  private void generalizeCSARequirements() {
    ArrayList<ServiceTemplate> comps = new ArrayList<ServiceTemplate>();
    ArrayList<Requirement> reqs = new ArrayList<Requirement>();

    comps = this.data.getServiceTemplates();
    reqs = this.data.getRequirements();

    for (ServiceTemplate c : comps) {
      for (Requirement r : reqs) {
        Requirement temp = new Requirement();
        try {
          BeanUtils.copyProperties(temp, r);
          // System.out.println(r.toString());
          // System.out.println(temp.toString());
          c.addReq(temp);
        } catch (IllegalAccessException | InvocationTargetException e) {
          e.printStackTrace();
        }
      }
    }
  }
コード例 #24
0
 @Override
 public <T extends Annotation> T getAnnotationOnField(String name, Class<T> clz) {
   FieldEx field = BeanUtils.getField(obj.getClass(), name);
   if (field == null) return null;
   return field.getAnnotation(clz);
 }
コード例 #25
0
ファイル: Di.java プロジェクト: propn/golf
 /**
  * @param args
  * @throws Exception
  */
 public static void main(String[] args) throws Exception {
   BeanUtils.registBean("com.propn.golf.ioc");
   Di di = BeanUtils.getInstance(Di.class);
   di.ipaa.sayHello();
   di.ipab.sayHello();
 }
コード例 #26
0
 /** {@inheritDoc} */
 @Override
 Class<?> getFieldType(SqlProcessContext ctx, Class<?> attributeType, String attributeName) {
   if (attributeName.indexOf("@") >= 0 || attributeName.indexOf("?") >= 0) return String.class;
   return BeanUtils.getFieldType(attributeType, attributeName);
 }
コード例 #27
0
 /**
  * Used to remove this class' PropertyChangeHandler from the given bean if it is not {@code null}.
  *
  * @param bean the bean to remove the property change listener from
  * @param listener the property change listener to be removed
  * @throws PropertyUnboundException if the bean does not support bound properties
  * @throws PropertyNotBindableException if the property change handler cannot be removed
  *     successfully
  */
 private static void removePropertyChangeHandler(
     Object bean, Class<?> beanClass, PropertyChangeListener listener) {
   if (bean != null) {
     BeanUtils.removePropertyChangeListener(bean, beanClass, listener);
   }
 }
コード例 #28
0
 /**
  * Reads the value of the first bean property and sets it as new value of the second bean
  * property.
  *
  * @see #updateProperty1()
  */
 public void updateProperty2() {
   Object property1Value = BeanUtils.getValue(bean1, property1Descriptor);
   setValueSilently(bean1, property1Descriptor, bean2, property2Descriptor, property1Value);
 }
コード例 #29
0
 public DbConnection(Connection connection, String schema) throws DatabaseUnitException {
   super(
       ((PoolableConnection) ((Connection) BeanUtils.getProperty(connection, "delegate")))
           .getDelegate());
   wrapperConnection = connection;
 }
コード例 #30
0
  /**
   * Convert the value to the required type (if necessary from a String), for the specified
   * property.
   *
   * @param propertyName name of the property
   * @param oldValue the previous value, if available (may be <code>null</code>)
   * @param newValue the proposed new value
   * @param requiredType the type we must convert to (or <code>null</code> if not known, for example
   *     in case of a collection element)
   * @param typeDescriptor the descriptor for the target property or field
   * @return the new value, possibly the result of type conversion
   * @throws IllegalArgumentException if type conversion failed
   */
  @SuppressWarnings("unchecked")
  public <T> T convertIfNecessary(
      String propertyName,
      Object oldValue,
      Object newValue,
      Class<T> requiredType,
      TypeDescriptor typeDescriptor)
      throws IllegalArgumentException {

    Object convertedValue = newValue;

    // Custom editor for this type?
    PropertyEditor editor =
        this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);

    // No custom editor but custom ConversionService specified?
    ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
    if (editor == null && conversionService != null && convertedValue != null) {
      TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(convertedValue);
      TypeDescriptor targetTypeDesc = typeDescriptor.forElementType(requiredType);
      if (conversionService.canConvert(sourceTypeDesc, targetTypeDesc)) {
        return (T) conversionService.convert(convertedValue, sourceTypeDesc, targetTypeDesc);
      }
    }

    // Value not of required type?
    if (editor != null
        || (requiredType != null && !ClassUtils.isAssignableValue(requiredType, convertedValue))) {
      if (requiredType != null
          && Collection.class.isAssignableFrom(requiredType)
          && convertedValue instanceof String
          && typeDescriptor.getMethodParameter() != null) {
        Class elemType =
            GenericCollectionTypeResolver.getCollectionParameterType(
                typeDescriptor.getMethodParameter());
        if (elemType != null && Enum.class.isAssignableFrom(elemType)) {
          convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
        }
      }
      if (editor == null) {
        editor = findDefaultEditor(requiredType, typeDescriptor);
      }
      convertedValue = doConvertValue(oldValue, convertedValue, requiredType, editor);
    }

    if (requiredType != null) {
      // Try to apply some standard type conversion rules if appropriate.

      if (convertedValue != null) {
        if (requiredType.isArray()) {
          // Array required -> apply appropriate conversion of elements.
          if (convertedValue instanceof String
              && Enum.class.isAssignableFrom(requiredType.getComponentType())) {
            convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
          }
          return (T)
              convertToTypedArray(convertedValue, propertyName, requiredType.getComponentType());
        } else if (convertedValue instanceof Collection) {
          // Convert elements to target type, if determined.
          convertedValue =
              convertToTypedCollection(
                  (Collection) convertedValue, propertyName, requiredType, typeDescriptor);
        } else if (convertedValue instanceof Map) {
          // Convert keys and values to respective target type, if determined.
          convertedValue =
              convertToTypedMap((Map) convertedValue, propertyName, requiredType, typeDescriptor);
        }
        if (convertedValue.getClass().isArray() && Array.getLength(convertedValue) == 1) {
          convertedValue = Array.get(convertedValue, 0);
        }
        if (String.class.equals(requiredType)
            && ClassUtils.isPrimitiveOrWrapper(convertedValue.getClass())) {
          // We can stringify any primitive value...
          return (T) convertedValue.toString();
        } else if (convertedValue instanceof String && !requiredType.isInstance(convertedValue)) {
          if (!requiredType.isInterface() && !requiredType.isEnum()) {
            try {
              Constructor strCtor = requiredType.getConstructor(String.class);
              return (T) BeanUtils.instantiateClass(strCtor, convertedValue);
            } catch (NoSuchMethodException ex) {
              // proceed with field lookup
              if (logger.isTraceEnabled()) {
                logger.trace(
                    "No String constructor found on type [" + requiredType.getName() + "]", ex);
              }
            } catch (Exception ex) {
              if (logger.isDebugEnabled()) {
                logger.debug(
                    "Construction via String failed for type [" + requiredType.getName() + "]", ex);
              }
            }
          }
          String trimmedValue = ((String) convertedValue).trim();
          if (requiredType.isEnum() && "".equals(trimmedValue)) {
            // It's an empty enum identifier: reset the enum value to null.
            return null;
          }

          convertedValue = attemptToConvertStringToEnum(requiredType, trimmedValue, convertedValue);
        }
      }

      if (!ClassUtils.isAssignableValue(requiredType, convertedValue)) {
        // Definitely doesn't match: throw IllegalArgumentException/IllegalStateException
        StringBuilder msg = new StringBuilder();
        msg.append("Cannot convert value of type [")
            .append(ClassUtils.getDescriptiveType(newValue));
        msg.append("] to required type [")
            .append(ClassUtils.getQualifiedName(requiredType))
            .append("]");
        if (propertyName != null) {
          msg.append(" for property '").append(propertyName).append("'");
        }
        if (editor != null) {
          msg.append(": PropertyEditor [")
              .append(editor.getClass().getName())
              .append("] returned inappropriate value");
          throw new IllegalArgumentException(msg.toString());
        } else {
          msg.append(": no matching editors or conversion strategy found");
          throw new IllegalStateException(msg.toString());
        }
      }
    }

    return (T) convertedValue;
  }