Exemplo n.º 1
1
    @Override
    public List<T> handle(ResultSet rs) throws SQLException {
      List<T> list = new LinkedList<>();
      while (rs.next()) {
        try {
          T t = this.clz.newInstance();
          BeanInfo beanInfo = Introspector.getBeanInfo(this.clz, Object.class);
          PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();

          Map<String, Object> map = new HashMap<String, Object>();
          for (PropertyDescriptor pd : descriptors) {
            String propertyName = pd.getName();
            Class<?> propertyType = pd.getPropertyType();
            if (propertyType.isAnnotationPresent(Entry.class)) {
              propertyName = propertyName + "_id";
            }
            Object value = rs.getObject(propertyName);
            if (propertyType.isAnnotationPresent(Entry.class)) {
              value = getObject(value, propertyType);
            }
            map.put(pd.getName(), value);
          }
          BeanUtils.copyProperties(t, map);
          list.add(t);

        } catch (InstantiationException
            | IllegalAccessException
            | IntrospectionException
            | InvocationTargetException e) {
          e.printStackTrace();
        }
      }
      return list;
    }
 /**
  * @see
  *     org.kuali.kfs.module.cam.document.service.AssetPaymentService#adjustPaymentAmounts(org.kuali.kfs.module.cam.businessobject.AssetPayment,
  *     boolean, boolean)
  */
 public void adjustPaymentAmounts(
     AssetPayment assetPayment, boolean reverseAmount, boolean nullPeriodDepreciation)
     throws IllegalAccessException, InvocationTargetException {
   LOG.debug("Starting - adjustAmounts() ");
   PropertyDescriptor[] propertyDescriptors =
       PropertyUtils.getPropertyDescriptors(AssetPayment.class);
   for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
     Method readMethod = propertyDescriptor.getReadMethod();
     if (readMethod != null
         && propertyDescriptor.getPropertyType() != null
         && KualiDecimal.class.isAssignableFrom(propertyDescriptor.getPropertyType())) {
       KualiDecimal amount = (KualiDecimal) readMethod.invoke(assetPayment);
       Method writeMethod = propertyDescriptor.getWriteMethod();
       if (writeMethod != null && amount != null) {
         // Reset periodic depreciation expenses
         if (nullPeriodDepreciation
             && Pattern.matches(
                 CamsConstants.SET_PERIOD_DEPRECIATION_AMOUNT_REGEX,
                 writeMethod.getName().toLowerCase())) {
           Object[] nullVal = new Object[] {null};
           writeMethod.invoke(assetPayment, nullVal);
         } else if (reverseAmount) {
           // reverse the amounts
           writeMethod.invoke(assetPayment, (amount.negated()));
         }
       }
     }
   }
   LOG.debug("Finished - adjustAmounts()");
 }
Exemplo n.º 3
0
  private static void copyCollection(
      Object target,
      String[] effectiveProperties,
      String[] ignoreProperties,
      Boolean nullBeCopied,
      PropertyDescriptor targetPd,
      Object sourceValue,
      Method writeMethod)
      throws IllegalAccessException, InvocationTargetException, UtilException,
          ClassNotFoundException, InstantiationException, NoSuchFieldException {
    Method targetReadMethod = targetPd.getReadMethod();
    Collection targetValue = (Collection) targetReadMethod.invoke(target, null);
    List tempList = new ArrayList();
    if (sourceValue == null) {
      writeMethod.invoke(target, sourceValue);
      return;
    }
    if (targetValue == null) {
      if (Set.class.isAssignableFrom(targetPd.getPropertyType())) {
        targetValue = new HashSet();
      } else if (List.class.isAssignableFrom(targetPd.getPropertyType())) {
        targetValue = new ArrayList();
      } else {
        return;
      }
    }
    Object[] sourceArray = ((Collection) sourceValue).toArray();
    Object[] targetArray = targetValue.toArray();
    for (int i = 0; i < sourceArray.length; i++) {
      if (targetValue.contains(sourceArray[i])) {
        for (int j = 0; j < targetArray.length; j++) {
          if (sourceArray[i].equals(targetArray[j])) {
            copyProperties(
                sourceArray[i],
                targetArray[j],
                effectiveProperties,
                ignoreProperties,
                nullBeCopied);
            tempList.add(targetArray[j]);
            break;
          }
        }
      } else {
        Object tempTarget = Class.forName(sourceArray[i].getClass().getName()).newInstance();
        // 基本类型直接赋值
        if (sourceArray[i].getClass().isPrimitive() || sourceArray[i] instanceof String) {
          tempTarget = sourceArray[i];
        } else {
          copyProperties(
              sourceArray[i], tempTarget, effectiveProperties, ignoreProperties, nullBeCopied);
        }

        tempList.add(tempTarget);
      }
    }
    targetValue.clear();
    targetValue.addAll(tempList);
    return;
  }
Exemplo n.º 4
0
 private static Class resolveType(PropertyDescriptor d) {
   if (TypeResolver.isIntegerType(d.getPropertyType())) {
     return Integer.class;
   } else if (TypeResolver.isLongType(d.getPropertyType())) {
     return Long.class;
   } else if (TypeResolver.isBooleanType(d.getPropertyType())) {
     return Boolean.class;
   } else {
     return d.getPropertyType();
   }
 }
  /**
   * Create a new CachedIntrospectionResults instance for the given class.
   *
   * @param beanClass the bean class to analyze
   * @throws BeansException in case of introspection failure
   */
  private CachedIntrospectionResults(Class beanClass) throws BeansException {
    try {
      if (logger.isTraceEnabled()) {
        logger.trace("Getting BeanInfo for class [" + beanClass.getName() + "]");
      }
      this.beanInfo = Introspector.getBeanInfo(beanClass);

      // Immediately remove class from Introspector cache, to allow for proper
      // garbage collection on class loader shutdown - we cache it here anyway,
      // in a GC-friendly manner. In contrast to CachedIntrospectionResults,
      // Introspector does not use WeakReferences as values of its WeakHashMap!
      Class classToFlush = beanClass;
      do {
        Introspector.flushFromCaches(classToFlush);
        classToFlush = classToFlush.getSuperclass();
      } while (classToFlush != null);

      if (logger.isTraceEnabled()) {
        logger.trace("Caching PropertyDescriptors for class [" + beanClass.getName() + "]");
      }
      this.propertyDescriptorCache = new HashMap();

      // This call is slow so we do it once.
      PropertyDescriptor[] pds = this.beanInfo.getPropertyDescriptors();
      for (int i = 0; i < pds.length; i++) {
        PropertyDescriptor pd = pds[i];
        if (logger.isTraceEnabled()) {
          logger.trace(
              "Found bean property '"
                  + pd.getName()
                  + "'"
                  + (pd.getPropertyType() != null
                      ? " of type [" + pd.getPropertyType().getName() + "]"
                      : "")
                  + (pd.getPropertyEditorClass() != null
                      ? "; editor [" + pd.getPropertyEditorClass().getName() + "]"
                      : ""));
        }
        if (JdkVersion.isAtLeastJava15()) {
          pd =
              new GenericTypeAwarePropertyDescriptor(
                  beanClass,
                  pd.getName(),
                  pd.getReadMethod(),
                  pd.getWriteMethod(),
                  pd.getPropertyEditorClass());
        }
        this.propertyDescriptorCache.put(pd.getName(), pd);
      }
    } catch (IntrospectionException ex) {
      throw new FatalBeanException(
          "Cannot get BeanInfo for object of class [" + beanClass.getName() + "]", ex);
    }
  }
Exemplo n.º 6
0
 private Class<? extends Object> getPropertyTypeWithClass(
     Class<? extends Object> clazz, String dataName) throws Exception {
   if (clazz == null) throw new IllegalArgumentException();
   int delim = dataName.indexOf('.');
   if (delim < 0) {
     PropertyDescriptor pd = OgnlRuntime.getPropertyDescriptor(clazz, dataName);
     if (pd == null) throw new IllegalArgumentException();
     return pd.getPropertyType();
   } else {
     PropertyDescriptor pd =
         OgnlRuntime.getPropertyDescriptor(clazz, dataName.substring(0, delim));
     if (pd == null) throw new IllegalArgumentException();
     return getPropertyTypeWithClass(pd.getPropertyType(), dataName.substring(delim + 1));
   }
 }
Exemplo n.º 7
0
  /**
   * This is a 'smart' (perform checks for some special cases) update function which should be used
   * to copy of the properties for objects of the catalog and configuration.
   *
   * @param <T> the type of the bean to update
   * @param info the bean instance to update
   * @param properties the list of string of properties to update
   * @param values the list of new values to update
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   * @throws NoSuchMethodException
   */
  public static <T> void smartUpdate(
      final T info, final List<String> properties, final List<Object> values)
      throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    final Iterator<String> itPropertyName = properties.iterator();
    final Iterator<Object> itValue = values.iterator();
    while (itPropertyName.hasNext() && itValue.hasNext()) {
      String propertyName = itPropertyName.next();
      final Object value = itValue.next();

      PropertyDescriptor pd = PropertyUtils.getPropertyDescriptor(info, propertyName);
      // return null if there is no such descriptor
      if (pd == null) {
        // this is a special case used by the NamespaceInfoImpl setURI
        // the propertyName coming from the ModificationProxy is set to 'uRI'
        // lets set it to uri
        propertyName = propertyName.toUpperCase();
        pd = PropertyUtils.getPropertyDescriptor(info, propertyName);
        if (pd == null) {
          return;
        }
      }
      if (pd.getWriteMethod() != null) {
        PropertyUtils.setProperty(info, propertyName, value);
      } else {
        // T interface do not declare setter method for this property
        // lets use getter methods to get the property reference
        final Object property = PropertyUtils.getProperty(info, propertyName);

        // check type of property to apply new value
        if (Collection.class.isAssignableFrom(pd.getPropertyType())) {
          final Collection<?> liveCollection = (Collection<?>) property;
          liveCollection.clear();
          liveCollection.addAll((Collection) value);
        } else if (Map.class.isAssignableFrom(pd.getPropertyType())) {
          final Map<?, ?> liveMap = (Map<?, ?>) property;
          liveMap.clear();
          liveMap.putAll((Map) value);
        } else {
          if (CatalogUtils.LOGGER.isLoggable(java.util.logging.Level.SEVERE))
            CatalogUtils.LOGGER.severe(
                "Skipping unwritable property "
                    + propertyName
                    + " with property type "
                    + pd.getPropertyType());
        }
      }
    }
  }
Exemplo n.º 8
0
  public Optional<String> beanValue(String pattern) {
    if (fieldvalue.isPresent()) return fieldvalue;
    try {
      if (bean == null) return Optional.absent();
      Object o = PropertyUtils.getProperty(bean, this.fieldname);
      PropertyDescriptor pd = PropertyUtils.getPropertyDescriptor(bean, this.fieldname);
      Class c = pd.getPropertyType();
      if (c == String.class) {

      } else if (c == Integer.class || c == int.class) {

      } else if (c == Long.class || c == long.class) {

      } else if (c == Float.class || c == float.class) {

      } else if (c == Boolean.class || c == boolean.class) {

      } else if (c == Date.class) {

      } else if (Enum.class.isAssignableFrom(c)) {

      }
      return Optional.of((String) o);
    } catch (IllegalAccessException e) {
    } catch (InvocationTargetException e) {
    } catch (NoSuchMethodException e) {
    }
    return Optional.absent();
  }
Exemplo n.º 9
0
 public TypeWrapper(Class c) throws IntrospectionException {
   Map<String, Field> fields = new HashMap();
   loadFields(c, fields);
   BeanInfo bi = Introspector.getBeanInfo(c, Object.class);
   PropertyDescriptor[] props = bi.getPropertyDescriptors();
   for (int i = 0; i < props.length; i++) {
     PropertyDescriptor pd = props[i];
     Annotation[] ann = null;
     Field f = fields.get(pd.getName());
     if (f != null) {
       f.getAnnotations();
     }
     Class type = pd.getPropertyType();
     boolean arrayFlag = type.isArray();
     PropertyInfo pi =
         new PropertyInfo(
             pd.getName(),
             ann,
             (arrayFlag ? type.getComponentType() : type),
             arrayFlag,
             pd.getReadMethod(),
             pd.getWriteMethod());
     this.properties.put(pi.getName(), pi);
   }
 }
Exemplo n.º 10
0
 public static void mapping(Object object, Map<String, ? extends Object> parameter)
     throws IllegalAccessException, InvocationTargetException {
   PropertyDescriptor[] pds = getDescriptors(object.getClass());
   for (int i = 0; i < pds.length; i++) {
     PropertyDescriptor pd = pds[i];
     Object obj = parameter.get(pd.getName());
     Object value = obj;
     Class<?> cls = pd.getPropertyType();
     if (obj instanceof String) {
       String string = (String) obj;
       if (!StringUtil.isEmpty(string)) {
         string = ConfigUtil.filter(string);
       }
       if (isPrimitiveType(cls)) {
         value = convert(cls, string);
       }
     } else if (obj instanceof BeanConfig) {
       value = createBean((BeanConfig) obj);
     } else if (obj instanceof BeanConfig[]) {
       List<Object> list = new ArrayList<Object>();
       for (BeanConfig beanconfig : (BeanConfig[]) obj) {
         list.add(createBean(beanconfig));
       }
       value = list.toArray();
     }
     if (cls != null) {
       if (value != null) {
         Method method = pd.getWriteMethod();
         if (method != null) {
           method.invoke(object, new Object[] {value});
         }
       }
     }
   }
 }
Exemplo n.º 11
0
 /**
  * 将bean装换为一个map(能将枚举转换为int)
  *
  * @param bean
  * @return
  */
 @SuppressWarnings({"unchecked", "rawtypes"})
 public static Map buildMap(Object bean) {
   if (bean == null) {
     return null;
   }
   try {
     Map map = describe(bean);
     PropertyDescriptor[] pds = BEANUTILSBEAN.getPropertyUtils().getPropertyDescriptors(bean);
     for (PropertyDescriptor pd : pds) {
       Class type = pd.getPropertyType();
       if (type.isEnum()) {
         Object value = BEANUTILSBEAN.getPropertyUtils().getSimpleProperty(bean, pd.getName());
         Enum enums = EnumUtils.valueOf(type, String.valueOf(value));
         map.put(pd.getName(), enums == null ? -1 : enums.ordinal());
       } else if (type == java.util.Date.class) { // 防止是Timestamp
         Object value = BEANUTILSBEAN.getPropertyUtils().getSimpleProperty(bean, pd.getName());
         if (value != null) {
           Calendar cal = Calendar.getInstance();
           cal.setTime((java.util.Date) value);
           map.put(pd.getName(), cal.getTime());
         }
       }
     }
     return map;
   } catch (Throwable e) {
     LOGGER.error("BeanUtil 创建Map失败:", e);
     throw new RuntimeException(e);
   }
 }
Exemplo n.º 12
0
  /**
   * Creates a new object and initializes its fields from the ResultSet.
   *
   * @param rs The result set.
   * @param type The bean type (the return type of the object).
   * @param props The property descriptors.
   * @param columnToProperty The column indices in the result set.
   * @return An initialized object.
   * @throws java.sql.SQLException if a database error occurs.
   */
  private Object createBean(
      ResultSet rs, Class type, PropertyDescriptor[] props, int[] columnToProperty)
      throws SQLException {

    Object bean = this.newInstance(type);

    for (int i = 1; i < columnToProperty.length; i++) {

      if (columnToProperty[i] == PROPERTY_NOT_FOUND) {
        continue;
      }

      PropertyDescriptor prop = props[columnToProperty[i]];
      Class propType = prop.getPropertyType();

      Object value = this.processColumn(rs, i, propType);

      if (propType != null && value == null && propType.isPrimitive()) {
        value = primitiveDefaults.get(propType);
      }

      this.callSetter(bean, prop, value);
    }

    return bean;
  }
Exemplo n.º 13
0
  public List gleanAutowiringRequirements(
      Map compositionContext, PlexusContainer container, ClassRealm componentRealm) {
    PropertyDescriptor[] propertyDescriptors =
        (PropertyDescriptor[]) compositionContext.get(PROPERTY_DESCRIPTORS);

    List requirements = new ArrayList();

    for (int i = 0; i < propertyDescriptors.length; i++) {
      PropertyDescriptor pd = propertyDescriptors[i];

      String role = pd.getPropertyType().getName();

      ComponentDescriptor componentDescriptor =
          container.getComponentDescriptor(role, componentRealm);

      if (componentDescriptor != null) {
        ComponentRequirement requirement = new ComponentRequirement();

        requirement.setRole(role);

        requirements.add(requirement);
      }
    }

    return requirements;
  }
Exemplo n.º 14
0
  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;
        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;
  }
Exemplo n.º 15
0
  /**
   * setArgStringValue purpose.
   *
   * <p>Stores a human friendly version.
   *
   * @param name
   * @param value
   * @return
   */
  public boolean addArgStringValue(String name, String value) {
    PropertyDescriptor pd = getPropertyDescriptor(name);

    if (pd == null) {
      return false;
    }

    if ((value == null) || value.equals("")) {
      args.remove(name);

      return false;
    }

    Class cl = pd.getPropertyType();
    ArgumentConfig ac = new ArgumentConfig();
    ac.setName(name);

    try {
      String argType = ArgHelper.getArgumentType(cl);
      ac.setValue(ArgHelper.getArgumentInstance(argType, value));
    } catch (ValidationException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();

      return false;
    }

    args.put(name, ac);

    return true;
  }
Exemplo n.º 16
0
  /**
   * Perform one setter operation with the provided value.
   *
   * @param instance Instance of class under test to operate on.
   * @param property Property being tested
   * @param field Field being tested
   * @param testVal Test value to use.
   * @return Optional that will contain an error message if the test failed, otherwise empty.
   * @throws InvocationTargetException
   * @throws IllegalAccessException
   */
  private Optional<String> testSetterWithVal(
      T instance, PropertyDescriptor property, Field field, Object testVal)
      throws InvocationTargetException, IllegalAccessException {

    Objects.requireNonNull(instance, "Instance of target class required.");
    boolean status = true;
    property.getWriteMethod().invoke(instance, testVal);

    Object expected, actual;
    if (property.getPropertyType().isPrimitive()) {
      expected = String.valueOf(testVal);
      actual = String.valueOf(field.get(instance));
      status = expected.equals(actual);
    } else {

      expected = testVal;
      actual = field.get(instance);

      if (expected == null) {
        status = actual == null;
      } else {
        status = expected.equals(actual);
      }
    }
    if (status == false) {
      return Optional.of(
          String.format(
              "Failed during setter test: %s.  Expected: %s  Actual: %s",
              property.getWriteMethod(), expected, actual));
    }
    return Optional.empty();
  }
 /**
  * The value of the property <code>pd</code> of <code>pb</code>, if
  *
  * <ul>
  *   <li>it is readable
  *   <li>it is a {@link PersistentBean}
  * </ul>
  *
  * <code>null</code> otherwise (also if there is an exception reading).
  */
 @MethodContract(
     pre = {@Expression("pb != null"), @Expression("pd != null")},
     post = {})
 private PersistentBean<?> relatedPeristentBean(PersistentBean<?> pb, PropertyDescriptor pd) {
   assert pb != null;
   assert pd != null;
   PersistentBean<?> result = null;
   if (PersistentBean.class.isAssignableFrom(pd.getPropertyType())) {
     Method rm = pd.getReadMethod();
     if (rm != null) {
       // found a property that returns a related bean; get it
       try {
         result = (PersistentBean<?>) rm.invoke(pb);
       } catch (IllegalArgumentException iaExc) {
         assert false
             : "Should not happen, since there are no arguments, and the implicit argument is "
                 + "not null and of the correct type";
       } catch (IllegalAccessException e) {
         assert false : "IllegalAccessException should not happen: " + e;
       } catch (InvocationTargetException e) {
         assert false : "InvocationTargetException should not happen: " + e;
       } catch (NullPointerException e) {
         assert false : "NullPointerException should not happen: " + e;
       }
       /* ExceptionInInitializerError can occur with invoke, but we do not
       take into account errors */
     }
   }
   return result;
 }
Exemplo n.º 18
0
  /**
   * Examines a property's type to see which method should be used to parse the property's value.
   *
   * @param desc The description of the property
   * @param value The value of the XML attribute containing the prop value
   * @return The value stored in the element
   * @throws IOException If there is an error reading the document
   */
  public Object getObjectValue(PropertyDescriptor desc, String value) throws IOException {
    // Find out what kind of property it is
    Class type = desc.getPropertyType();

    // If it's an array, get the base type
    if (type.isArray()) {
      type = type.getComponentType();
    }

    // For native types, object wrappers for natives, and strings, use the
    // basic parse routine
    if (type.equals(Integer.TYPE)
        || type.equals(Long.TYPE)
        || type.equals(Short.TYPE)
        || type.equals(Byte.TYPE)
        || type.equals(Boolean.TYPE)
        || type.equals(Float.TYPE)
        || type.equals(Double.TYPE)
        || Integer.class.isAssignableFrom(type)
        || Long.class.isAssignableFrom(type)
        || Short.class.isAssignableFrom(type)
        || Byte.class.isAssignableFrom(type)
        || Boolean.class.isAssignableFrom(type)
        || Float.class.isAssignableFrom(type)
        || Double.class.isAssignableFrom(type)) {
      return parseBasicType(type, value);
    } else if (String.class.isAssignableFrom(type)) {
      return value;
    } else if (java.util.Date.class.isAssignableFrom(type)) {
      // If it's a date, use the date parser
      return parseDate(value, JOXDateHandler.determineDateFormat());
    } else {
      return null;
    }
  }
Exemplo n.º 19
0
  public static Object buildBean(Class<?> beanClass, Map<String, String> values) {
    try {
      Object obj = null;

      if (beanClass.isInterface()) {
        @SuppressWarnings("unchecked")
        Class<? extends OpenEngSBModel> model = (Class<? extends OpenEngSBModel>) beanClass;
        obj = ekbService.createEmptyModelObject(model);
      } else {
        obj = beanClass.newInstance();
      }

      BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
      PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
      for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
        if (propertyDescriptor.getWriteMethod() == null
            || !Modifier.isPublic(propertyDescriptor.getWriteMethod().getModifiers())) {
          continue;
        }
        String value = values.get(propertyDescriptor.getName());
        Object ob = convertToCorrectClass(propertyDescriptor.getPropertyType(), value);
        propertyDescriptor.getWriteMethod().invoke(obj, ob);
      }
      return obj;
    } catch (Exception e) {
      throw new IllegalArgumentException(e);
    }
  }
Exemplo n.º 20
0
  /**
   * 为对象设置属性
   *
   * @param bean 目标对象
   * @param name 属性的名字
   * @param value 将要设置的属性值
   */
  public static void setProperty(Object bean, String name, String value) {
    Class<?> clazz = bean.getClass();
    PropertyDescriptor propertyDescriptor = findPropertyDescriptor(clazz, name);
    if (propertyDescriptor == null) {
      try {
        throw new Exception(
            "propertyDescriptor is null clazz:" + clazz.getName() + " property name:" + name);
      } catch (Exception e) {
        e.printStackTrace();
      }
    }

    Class<?> type = propertyDescriptor.getPropertyType();
    Object newValue = converValue(type, value);
    Method writeMethod = propertyDescriptor.getWriteMethod();
    try {
      writeMethod.invoke(bean, newValue);
    } catch (IllegalArgumentException e) {
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    } catch (InvocationTargetException e) {
      e.printStackTrace();
    }
  }
Exemplo n.º 21
0
  @Override
  public Map<String, String> saveOrUpdataReturnCasecadeID(
      String objectType, HttpServletRequest request) throws Exception {

    Map<String, String> map = QueryUtil.getRequestParameterMapNoAjax(request);
    Object targetObject = Class.forName(objectType).newInstance();
    String jsonString = map.get(this.getType(objectType).getSimpleName());
    String cascadeTypes = map.get("cascadeType");

    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
    mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    Class<?> clazz = this.getType(objectType);
    targetObject = mapper.readValue(jsonString, clazz);
    Serializable id = this.commDao.saveOrUpdata(objectType, targetObject);

    Object target = this.findById(objectType, id.toString());

    Map<String, String> returenIDs = new HashMap<String, String>();
    returenIDs.put("id", id.toString());

    if (cascadeTypes != null) {
      String[] s = cascadeTypes.split(",");
      for (int i = 0; i < s.length; i++) {
        PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, s[i]);
        Method method = pd.getReadMethod();
        Object childTarget = method.invoke(target);
        PropertyDescriptor pdID = BeanUtils.getPropertyDescriptor(pd.getPropertyType(), "id");
        String childTargetID = pdID.getReadMethod().invoke(childTarget).toString();
        returenIDs.put(s[i], childTargetID);
      }
    }

    return returenIDs;
  }
 /**
  * The upstream {@link PersistentBean PersistentBeans} starting from {@code pb}. These are the
  * beans that are simple properties of {@code pb}. Upstream means in most cases (this is all that
  * is implemented at this time) the beans reachable via a to-one association.
  */
 @MethodContract(
     pre = @Expression("_pb != null"),
     post = {
       @Expression("result != null"),
       @Expression(
           "for (PropertyDescriptor pd : getPropertyDescriptors(_pb)) {"
               + "PersistentBean.class.isAssignableFrom(pd.propertyType) && propertyValue(_pb, pd.name) != null ? "
               + "result.contains(propertyValue(_pb, pd.name))"
               + "}"),
       @Expression(
           "for (PersistentBean pbr : result) {"
               + "exists (PropertyDescriptor pd : getPropertyDescriptors(_pb)) {"
               + "pbr == propertyValue(_pb, pd.name)"
               + "}"
               + "}")
     })
 public static Set<PersistentBean<?>> directUpstreamPersistentBeans(PersistentBean<?> pb) {
   assert preArgumentNotNull(pb, "pb");
   Set<PersistentBean<?>> result = new HashSet<PersistentBean<?>>();
   PropertyDescriptor[] pds = getPropertyDescriptors(pb);
   for (int i = 0; i < pds.length; i++) {
     PropertyDescriptor pd = pds[i];
     if (PersistentBean.class.isAssignableFrom(pd.getPropertyType())) {
       PersistentBean<?> upstreamCandidate = propertyValue(pb, pd.getName());
       if (upstreamCandidate != null) {
         result.add(upstreamCandidate);
       }
     }
   }
   return result;
 }
Exemplo n.º 23
0
  /**
   * Get the appropriate editor for the given property.
   *
   * @param prop Property to get editor for.
   * @return Editor to use, or null if none found.
   */
  private PropertyEditor getEditorForProperty(PropertyDescriptor prop) {
    PropertyEditor retval = null;
    Class type = prop.getPropertyEditorClass();
    if (type != null) {
      try {
        retval = (PropertyEditor) type.newInstance();
      } catch (Exception ex) {
        ex.printStackTrace();
      }
    }
    // Handle case where there is no special editor
    // associated with the property. In that case we ask the
    // PropertyEditor manager for the editor registered for the
    // given property type.
    if (retval == null) {
      Class t = prop.getPropertyType();
      if (t != null) {
        retval = PropertyEditorManager.findEditor(t);
      }
    }

    // In the worse case we resort to the generic editor for Object types.
    if (retval == null) {
      retval = PropertyEditorManager.findEditor(Object.class);
    }

    return retval;
  }
Exemplo n.º 24
0
 private void refresh() {
   if (this.value == null) {
     this.setEnabled(false);
     return;
   }
   this.setEnabled(true);
   for (final PropertyDescriptor pd : this.beanInfo.getPropertyDescriptors()) {
     final JTextField field = this.fieldMap.get(pd.getName());
     PropertyEditor editor = pd.createPropertyEditor(this.getValue());
     if (editor == null) {
       editor = PropertyEditorManager.findEditor(pd.getPropertyType());
     }
     if (editor == null) {
       continue;
     }
     Object propertyValue = null;
     try {
       propertyValue = pd.getReadMethod().invoke(this.getValue());
     } catch (final Exception e) {
       // Just continue
       continue;
     }
     field.setText(propertyValue != null ? propertyValue.toString() : "null");
   }
 }
Exemplo n.º 25
0
  /**
   * Compares this <code>PropertyDescriptor</code> against the specified object. Returns true if the
   * objects are the same. Two <code>PropertyDescriptor</code>s are the same if the read, write,
   * property types, property editor and flags are equivalent.
   *
   * @since 1.4
   */
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }
    if (obj != null && obj instanceof PropertyDescriptor) {
      PropertyDescriptor other = (PropertyDescriptor) obj;
      Method otherReadMethod = other.getReadMethod();
      Method otherWriteMethod = other.getWriteMethod();

      if (!compareMethods(getReadMethod(), otherReadMethod)) {
        return false;
      }

      if (!compareMethods(getWriteMethod(), otherWriteMethod)) {
        return false;
      }

      if (getPropertyType() == other.getPropertyType()
          && getPropertyEditorClass() == other.getPropertyEditorClass()
          && bound == other.isBound()
          && constrained == other.isConstrained()
          && writeMethodName == other.writeMethodName
          && readMethodName == other.readMethodName) {
        return true;
      }
    }
    return false;
  }
Exemplo n.º 26
0
 public static Object parseWithIntrospection(
     String elementName, Class<?> objectClass, XmlPullParser parser) throws Exception {
   boolean done = false;
   Object object = objectClass.newInstance();
   while (!done) {
     int eventType = parser.next();
     if (eventType == XmlPullParser.START_TAG) {
       String name = parser.getName();
       String stringValue = parser.nextText();
       PropertyDescriptor descriptor = new PropertyDescriptor(name, objectClass);
       // Load the class type of the property.
       Class<?> propertyType = descriptor.getPropertyType();
       // Get the value of the property by converting it from a
       // String to the correct object type.
       Object value = decode(propertyType, stringValue);
       // Set the value of the bean.
       descriptor.getWriteMethod().invoke(object, value);
     } else if (eventType == XmlPullParser.END_TAG) {
       if (parser.getName().equals(elementName)) {
         done = true;
       }
     }
   }
   return object;
 }
Exemplo n.º 27
0
  private List setProperty(
      Object component,
      ComponentDescriptor descriptor,
      ComponentRequirement requirementDescriptor,
      PropertyDescriptor propertyDescriptor,
      PlexusContainer container,
      ClassRealm lookupRealm)
      throws CompositionException {
    Requirement requirement =
        findRequirement(
            component,
            propertyDescriptor.getPropertyType(),
            container,
            requirementDescriptor,
            lookupRealm);

    try {
      Method writeMethod = propertyDescriptor.getWriteMethod();

      Object[] params = new Object[1];

      params[0] = requirement.getAssignment();

      Statement statement = new Statement(component, writeMethod.getName(), params);

      statement.execute();
    } catch (Exception e) {
      reportErrorCannotAssignRequiredComponent(descriptor, requirementDescriptor, e);
    }

    return requirement.getComponentDescriptors();
  }
  /** add by xiongcf 得到指定属性名的类型 * */
  public Class getDestType(Object bean, String name) {

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

    // Return the requested result
    if (bean instanceof DynaBean) {
      // All DynaBean properties are writeable
      return null;
    } else {
      try {
        PropertyDescriptor desc = getPropertyDescriptor(bean, name);
        if (desc != null) {
          Class c = desc.getPropertyType();
          return c;
        } else {
          return null;
        }
      } catch (IllegalAccessException e) {
        return null;
      } catch (InvocationTargetException e) {
        return null;
      } catch (NoSuchMethodException e) {
        return null;
      }
    }
  }
Exemplo n.º 29
0
    private ObjectConverter generateConverter(Class cls) {
      BeanInfo beanInfo = null;

      try {
        beanInfo = Introspector.getBeanInfo(cls);
      } catch (IntrospectionException e) {
        throw new RuntimeException(e);
      }

      PropertyDescriptor[] props = beanInfo.getPropertyDescriptors();
      List<ObjectConverterEntry> list = new ArrayList<ObjectConverterEntry>();

      for (int i = 0, length = props.length; i < length; i++) {
        PropertyDescriptor prop = props[i];
        if ("class".equals(prop.getName())) {
          continue;
        }

        list.add(
            new ObjectConverterEntry(
                prop.getName(), prop.getReadMethod(), getType(prop.getPropertyType())));
      }

      return new ObjectConverter(cls, list.toArray(new ObjectConverterEntry[list.size()]));
    }
Exemplo n.º 30
0
 private void setAttributes(
     JrdsElement probeNode, Object o, Map<String, PropertyDescriptor> beans, Object... context)
     throws IllegalArgumentException, InvocationTargetException {
   // Resolve the beans
   for (JrdsElement attrNode : probeNode.getChildElementsByName("attr")) {
     String name = attrNode.getAttribute("name");
     PropertyDescriptor bean = beans.get(name);
     if (bean == null) {
       logger.error("Unknonw bean " + name);
       continue;
     }
     String textValue = Util.parseTemplate(attrNode.getTextContent(), context);
     logger.trace(Util.delayedFormatString("Fond attribute %s with value %s", name, textValue));
     try {
       Constructor<?> c = bean.getPropertyType().getConstructor(String.class);
       Object value = c.newInstance(textValue);
       bean.getWriteMethod().invoke(o, value);
     } catch (IllegalArgumentException e) {
       throw new InvocationTargetException(e, HostBuilder.class.getName());
     } catch (SecurityException e) {
       throw new InvocationTargetException(e, HostBuilder.class.getName());
     } catch (InstantiationException e) {
       throw new InvocationTargetException(e, HostBuilder.class.getName());
     } catch (IllegalAccessException e) {
       throw new InvocationTargetException(e, HostBuilder.class.getName());
     } catch (InvocationTargetException e) {
       throw new InvocationTargetException(e, HostBuilder.class.getName());
     } catch (NoSuchMethodException e) {
       throw new InvocationTargetException(e, HostBuilder.class.getName());
     }
   }
 }