@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; }
public static BeanDescription describe(Class beanClass) { BeanDescription beanDescription = knownBeanDescriptions.get(beanClass.getName()); if (beanDescription != null) { return beanDescription; } try { beanDescription = new BeanDescription(); PropertyDescriptor[] descriptors = PropertyUtils.getPropertyDescriptors(beanClass); for (PropertyDescriptor descriptor : descriptors) { if (descriptor.getReadMethod() == null || descriptor.getWriteMethod() == null) { continue; } beanDescription.description.put(descriptor.getName(), descriptor); beanDescription.readMethodToDescriptor.put( descriptor.getReadMethod().getName(), descriptor); beanDescription.writeMethodToDescriptor.put( descriptor.getWriteMethod().getName(), descriptor); beanDescription.readMethodToPropertyName.put( descriptor.getReadMethod().getName(), descriptor.getName()); beanDescription.writeMethodToPropertyName.put( descriptor.getWriteMethod().getName(), descriptor.getName()); } knownBeanDescriptions.put(beanClass.getName(), beanDescription); return beanDescription; } catch (Throwable t) { throw new RuntimeException(t); } }
/** * Test setter and getter call and make sure they match. * * <p> * * @param property the property to be set * @param setValue the value to be set * @param qName qualified name for error reporting */ private static void testProperty( Object target, PropertyDescriptor property, Object setValue, String qName) { // flag indicating whether a comparison should be done at the end boolean expectMatch = true; // call setter (if exists) if (property.getWriteMethod() != null) { invokeMethod(target, property.getWriteMethod(), new Object[] {setValue}, qName); } else { Assert.assertFalse(true, "Property " + qName + " does not have the required setter."); expectMatch = false; } // call getter (if exists) Object getValue = null; if (property.getReadMethod() != null) { getValue = invokeMethod(target, property.getReadMethod(), null, qName); } else { Assert.assertFalse(true, "Property " + qName + " does not have the required getter."); expectMatch = false; } // if expecting a match, compare // if they are not the same instance, assert that they have equality if (expectMatch && setValue != getValue) Assert.assertEquals( getValue, setValue, "Values did not match for getter/setter call on field " + qName); }
private static HashMap<String, Object> inspectObject(Object o) throws IntrospectionException { if (inspections.containsKey(o.getClass())) { return inspections.get(o.getClass()); } PropertyDescriptor[] pds = Introspector.getBeanInfo(o.getClass()).getPropertyDescriptors(); HashMap<String, Object> values = new HashMap<String, Object>(); for (PropertyDescriptor pd : pds) { if (pd.getName().equals("class") || (pd.getReadMethod() == null) || (pd.getWriteMethod() == null) || ((pd.getReadMethod().getModifiers() & Modifier.PUBLIC) == 0) || ((pd.getWriteMethod().getModifiers() & Modifier.PUBLIC) == 0)) { continue; } values.put(pd.getName(), pd); } for (Field field : o.getClass().getFields()) { if (((field.getModifiers() & Modifier.PUBLIC) != 0) && ((field.getModifiers() & Modifier.FINAL) == 0) && ((field.getModifiers() & Modifier.STATIC) == 0) && (values.get(field.getName()) == null)) { values.put(field.getName(), field); } } inspections.put(o.getClass(), values); return values; }
/** * Gets the value of property from the bean object. * * @param bean the object of bean class whose property is to access. * @param property the name of property. * @return the value of property. * @throws IntrospectionException * @throws IllegalArgumentException * @throws IllegalAccessException * @throws InvocationTargetException */ public static final Object getPropertyValue(Object bean, String property) throws IntrospectionException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { Object propertyValue = null; PropertyDescriptor descriptor = getPropertyDescriptor(bean.getClass(), property); if (descriptor != null && descriptor.getReadMethod() != null) { propertyValue = descriptor.getReadMethod().invoke(bean, null); } return propertyValue; }
@Override public boolean matches(Object argument) { if (equalTo(object).matches(argument)) { // short circuit: equal is always equivalent return true; } if (argument != null && object.getClass() == argument.getClass()) { BeanInfo beanInfo = null; try { beanInfo = Introspector.getBeanInfo(object.getClass()); } catch (IntrospectionException shouldNeverHappen) { throw new Error(shouldNeverHappen); } for (PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) { if (pd.getReadMethod() == null) { continue; } Object value1 = null; try { value1 = pd.getReadMethod().invoke(object); } catch (RuntimeException e) { throw e; } catch (Exception e) { new Error(e); } Object value2 = null; try { value2 = pd.getReadMethod().invoke(object); } catch (RuntimeException e) { // prevent us from wrapping RuntimExceptions unnecessarily throw e; } catch (Exception shouldNeverHappen) { new Error(shouldNeverHappen); } if (!equalTo(value1).matches(value2)) { return false; } } return true; } return false; }
public static Class<?> determineGenericsType(PropertyDescriptor propDescriptor) { Class<?> result = null; // Try getter and setter to determine the Generics type in case one does not exist if (propDescriptor.getWriteMethod() != null) { result = determineGenericsType(propDescriptor.getWriteMethod(), false); } if (result == null && propDescriptor.getReadMethod() != null) { result = determineGenericsType(propDescriptor.getReadMethod(), true); } return result; }
public static Map<String, Method> getGetters(Class<?> clazz) { BeanInfo beanInfo; Map<String, Method> methodMap = new HashMap<String, Method>(); try { beanInfo = Introspector.getBeanInfo(clazz); for (PropertyDescriptor prop : beanInfo.getPropertyDescriptors()) { if (prop.getReadMethod() != null) { methodMap.put(prop.getName(), prop.getReadMethod()); } } } catch (IntrospectionException e) { methodMap = null; } return methodMap; }
/** * bean转化成字符串 * * @param bean * @param beanName * @return beanStr */ public static String convertBean2Str(Object bean, String beanName) { StringBuffer str = new StringBuffer(); Class<? extends Object> type = bean.getClass(); try { BeanInfo beanInfo = Introspector.getBeanInfo(type); PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (int i = 0; i < propertyDescriptors.length; i++) { PropertyDescriptor descriptor = propertyDescriptors[i]; String propertyName = descriptor.getName(); if (!propertyName.equals("class")) { Method readMethod = descriptor.getReadMethod(); Object result = readMethod.invoke(bean, new Object[0]); if (result != null && StringUtils.trim(result.toString()).length() != 0) { str.append("&") .append(beanName) .append(".") .append(propertyName) .append("=") .append(result); } } } } catch (Exception e) { log.error(e.getMessage(), e); } return str.indexOf("&") != -1 ? str.substring(1) : str.toString(); }
public Object doGetValue() { try { Method readMethod = propertyDescriptor.getReadMethod(); if (readMethod == null) { throw new BindingException( propertyDescriptor.getName() + " property does not have a read method."); // $NON-NLS-1$ } if (!readMethod.isAccessible()) { readMethod.setAccessible(true); } return readMethod.invoke(object, null); } catch (InvocationTargetException e) { /* * InvocationTargetException wraps any exception thrown by the * invoked method. */ throw new RuntimeException(e.getCause()); } catch (Exception e) { if (BeansObservables.DEBUG) { Policy.getLog() .log( new Status( IStatus.WARNING, Policy.JFACE_DATABINDING, IStatus.OK, "Could not read value of " + object + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$ } return null; } }
public static Map<String, Object> copyPropertyValues( Object fromObj, Set<String> excludeProperties) { excludeProperties = (excludeProperties == null) ? new HashSet<String>() : excludeProperties; excludeProperties.add( "class"); // be sure we don't include 'class', which appears in every object Map<String, Object> retVal = new HashMap<String, Object>(); Class<?> fromClazz = fromObj.getClass(); PropertyDescriptor[] propDescs; try { propDescs = Introspector.getBeanInfo(fromClazz).getPropertyDescriptors(); for (PropertyDescriptor propDesc : propDescs) { String propName = propDesc.getName(); if (excludeProperties.contains(propName)) continue; Method getter = propDesc.getReadMethod(); try { Object val = getter.invoke(fromObj); retVal.put(propName, val); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { // log.error("Error reading property " + propName, e); } } } catch (IntrospectionException e) { // log.error("Error copying property values."); } return retVal; }
/** * Analyzes the bean and returns a map containing the property-values. Works similar to {@link * BeanUtils#describe(Object)} but does not convert everything to strings. * * @throws IllegalArgumentException if the bean cannot be analyzed properly. Probably because some * getter throw an Exception */ public static Map<String, Object> buildObjectAttributeMap(Object bean) throws IllegalArgumentException { BeanInfo beanInfo; try { beanInfo = Introspector.getBeanInfo(bean.getClass(), Object.class); } catch (IntrospectionException e1) { throw new IllegalArgumentException(e1); } Map<String, Object> result; result = Maps.newHashMap(); for (PropertyDescriptor pDesc : beanInfo.getPropertyDescriptors()) { String name = pDesc.getName(); Object propertyValue; try { propertyValue = pDesc.getReadMethod().invoke(bean); } catch (IllegalAccessException e) { // this should never happen since the Introspector only returns accessible read-methods LOGGER.error("WTF: got property descriptor with inaccessible read-method"); throw new IllegalStateException(e); } catch (InvocationTargetException e) { ReflectionUtils.handleInvocationTargetException(e); throw new IllegalStateException("Should never get here"); } if (propertyValue != null) { result.put(name, propertyValue); } } return result; }
private static String[] getPropertyNames(Class<?> clazz, boolean only4Copy) { List<String> ret_all = new ArrayList<String>(); List<String> ret = new ArrayList<String>(); Field[] fields = CE.of(clazz).getFields(Object.class); for (Field fld : fields) { if (fld.getModifiers() == Modifier.PUBLIC) { ret.add(fld.getName()); } ret_all.add(fld.getName()); } BeanInfo info = null; try { info = Introspector.getBeanInfo(clazz); } catch (IntrospectionException e) { } if (info != null) { PropertyDescriptor[] properties = info.getPropertyDescriptors(); for (int i = 0; i < properties.length; i++) { PropertyDescriptor pd = properties[i]; if (ret_all.contains(pd.getName()) && !ret.contains(pd.getName())) { if (!only4Copy || (pd.getReadMethod() != null && pd.getWriteMethod() != null)) ret.add(properties[i].getName()); } } } return ret.toArray(new String[ret.size()]); }
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); } }
private Object invokeAttribute(PropertyDescriptor pd, MethodInvocation invocation) throws JMException, IOException { String attributeName = JmxUtils.getAttributeName(pd, this.useStrictCasing); MBeanAttributeInfo inf = (MBeanAttributeInfo) this.allowedAttributes.get(attributeName); // If no attribute is returned, we know that it is not defined in the // management interface. if (inf == null) { throw new InvalidInvocationException( "Attribute '" + pd.getName() + "' is not exposed on the management interface"); } if (invocation.getMethod().equals(pd.getReadMethod())) { if (inf.isReadable()) { return this.server.getAttribute(this.objectName, attributeName); } else { throw new InvalidInvocationException("Attribute '" + attributeName + "' is not readable"); } } else if (invocation.getMethod().equals(pd.getWriteMethod())) { if (inf.isWritable()) { server.setAttribute( this.objectName, new Attribute(attributeName, invocation.getArguments()[0])); return null; } else { throw new InvalidInvocationException("Attribute '" + attributeName + "' is not writable"); } } else { throw new IllegalStateException( "Method [" + invocation.getMethod() + "] is neither a bean property getter nor a setter"); } }
public boolean isMapped(PropertyDescriptor pd) { if (pd.getReadMethod() == null) { return false; } return true; }
/** * 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; }
public void makeApiAvailableToScripts(final Binding binding, final Object cla) { final Method[] declaredMethods = cla.getClass().getDeclaredMethods(); for (Method method : declaredMethods) { final String name = method.getName(); final int modifiers = method.getModifiers(); if (Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers)) { binding.setVariable(name, new MethodClosure(cla, name)); } } PropertyDescriptor[] propertyDescriptors; try { propertyDescriptors = Introspector.getBeanInfo(cla.getClass()).getPropertyDescriptors(); for (PropertyDescriptor pd : propertyDescriptors) { final Method readMethod = pd.getReadMethod(); if (readMethod != null) { if (isDeclared(cla, readMethod)) { binding.setVariable(pd.getName(), invokeMethod(readMethod, cla)); } } } } catch (IntrospectionException e1) { // ignore } }
private void handleCandidateWriteMethod(Method method) throws IntrospectionException { int nParams = method.getParameterTypes().length; String propertyName = propertyNameFor(method); Class<?> propertyType = method.getParameterTypes()[nParams - 1]; PropertyDescriptor existingPd = findExistingPropertyDescriptor(propertyName, propertyType); if (nParams == 1) { if (existingPd == null) { this.propertyDescriptors.add(new SimplePropertyDescriptor(propertyName, null, method)); } else { existingPd.setWriteMethod(method); } } else if (nParams == 2) { if (existingPd == null) { this.propertyDescriptors.add( new SimpleIndexedPropertyDescriptor(propertyName, null, null, null, method)); } else if (existingPd instanceof IndexedPropertyDescriptor) { ((IndexedPropertyDescriptor) existingPd).setIndexedWriteMethod(method); } else { this.propertyDescriptors.remove(existingPd); this.propertyDescriptors.add( new SimpleIndexedPropertyDescriptor( propertyName, existingPd.getReadMethod(), existingPd.getWriteMethod(), null, method)); } } else { throw new IllegalArgumentException( "Write method must have exactly 1 or 2 parameters: " + method); } }
public static Map<String, String> getEntityPropertiesToStringMap( Object entity, Map<String, String> fieldClassMapping, String... entityIdentifier) { Map<String, String> propertiesMap = new HashMap<String, String>(); StringBuffer sb = new StringBuffer(); if (entityIdentifier.length > 0) { for (String ei : entityIdentifier) { sb.append(ei + "."); } } String prefixStr = sb.toString(); PropertyDescriptor[] pds = BeanUtils.getPropertyDescriptors(entity.getClass()); for (PropertyDescriptor pd : pds) { Method readMethod = pd.getReadMethod(); if (null == readMethod) continue; Class<?> returnType = readMethod.getReturnType(); Object returnValue = null; try { returnValue = readMethod.invoke(entity); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } if (null != returnValue) { String value = ""; if (returnType.isAssignableFrom(Set.class)) { continue; } else if (isTenwaEntity(returnType)) { String fieldName = null; if (null != fieldClassMapping) { fieldName = fieldClassMapping.get(returnType.getSimpleName()); } if (StringUtils.isBlank(fieldName)) { fieldName = "id"; } Method method = BeanUtils.getPropertyDescriptor(returnType, fieldName).getReadMethod(); // System.out.println("####:"+method.getName()+","+returnValue); try { value = StringUtil.nullToString(method.invoke(returnValue)); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } } else { if (returnType.getSimpleName().equalsIgnoreCase("double")) { value = MathUtil.decimal((Double) returnValue, 8); } else { value = returnValue.toString(); } } propertiesMap.put(prefixStr + pd.getName().toLowerCase(), value); } } return propertiesMap; }
public static void copyProperties(Object target, Object source, String[] ignoreProperties) { if (target instanceof Map) { throw new UnsupportedOperationException("target is Map unsuported"); } PropertyDescriptor[] targetPds = getPropertyDescriptors(target.getClass()); List ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null; for (int i = 0; i < targetPds.length; i++) { PropertyDescriptor targetPd = targetPds[i]; if (targetPd.getWriteMethod() != null && (ignoreProperties == null || (!ignoreList.contains(targetPd.getName())))) { try { if (source instanceof Map) { Map map = (Map) source; if (map.containsKey(targetPd.getName())) { Object value = map.get(targetPd.getName()); setProperty(target, targetPd, value); } } else { PropertyDescriptor sourcePd = getPropertyDescriptors(source.getClass(), targetPd.getName()); if (sourcePd != null && sourcePd.getReadMethod() != null) { Object value = getProperty(source, sourcePd); setProperty(target, targetPd, value); } } } catch (Throwable ex) { throw new IllegalArgumentException( "Could not copy properties on:" + targetPd.getDisplayName(), ex); } } } }
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"); } }
String getPrincipalProperty(Object principal, String property) throws TemplateModelException { try { BeanInfo beanInfo = Introspector.getBeanInfo(principal.getClass()); // Loop through the properties to get the string value of the specified property for (PropertyDescriptor propertyDescriptor : beanInfo.getPropertyDescriptors()) { if (propertyDescriptor.getName().equals(property)) { Object value = propertyDescriptor.getReadMethod().invoke(principal, (Object[]) null); return String.valueOf(value); } } // property not found, throw throw new TemplateModelException( "Property [" + property + "] not found in principal of type [" + principal.getClass().getName() + "]"); } catch (Exception ex) { throw new TemplateModelException( "Error reading property [" + property + "] from principal of type [" + principal.getClass().getName() + "]", ex); } }
public ResourceInfo.MethodInfo[] getMethodDescriptors() { Set<java.lang.reflect.Method> accessors = new HashSet<java.lang.reflect.Method>(); for (PropertyDescriptor p : getPropertyDescriptors()) { accessors.add(p.getReadMethod()); accessors.add(p.getWriteMethod()); } for (MethodDescriptor o : getRemoteMethodDescriptors()) { accessors.add(o.getMethod()); } TreeSet<MethodDescriptor> methods = new TreeSet<MethodDescriptor>( new Comparator<MethodDescriptor>() { public int compare(MethodDescriptor a, MethodDescriptor b) { return a.getName().compareTo(b.getName()); } }); methods.addAll(Arrays.asList(info.getMethodDescriptors())); Iterator<MethodDescriptor> iter = methods.iterator(); while (iter.hasNext()) { MethodDescriptor m = iter.next(); if (accessors.contains(m.getMethod())) { iter.remove(); } } return MethodInfo.wrap(methods); }
public static <T extends Annotation> T getAnnotation( PropertyDescriptor pd, Class<T> annotationType) { Method readMethod = pd.getReadMethod(); Preconditions.checkNotNull(readMethod); T column = AnnotationUtils.findAnnotation(readMethod, annotationType); return column; }
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()])); }
private void fixNullOutputsForSOAP(CrownCounselIndexGetList_Properties fromClient) { // Transform null to "null" Class c = fromClient.getClass(); java.beans.BeanInfo beanInfo = null; try { beanInfo = java.beans.Introspector.getBeanInfo(c); } catch (Exception e) { } java.beans.PropertyDescriptor[] properties = beanInfo.getPropertyDescriptors(); for (int i = 0; i < properties.length; i++) { java.beans.PropertyDescriptor property = properties[i]; java.lang.reflect.Method readMethod = property.getReadMethod(); java.lang.reflect.Method writeMethod = property.getWriteMethod(); if ((readMethod != null) && (writeMethod != null)) { String currentvalue = new String(""); if (readMethod.getReturnType() == currentvalue.getClass()) { try { currentvalue = (String) (readMethod.invoke(fromClient, null)); } catch (java.lang.reflect.InvocationTargetException a1) // Null argument { try { Object[] args1 = new Object[1]; args1[0] = new String("null"); writeMethod.invoke(fromClient, args1); } catch (Exception e2) { } } catch (Exception e1) { } } else { } } } }
public void setBeanInfo() { BeanInfo info = null; try { info = Introspector.getBeanInfo(bean.getClass()); } catch (IntrospectionException ex) { ex.printStackTrace(); } for (PropertyDescriptor pd : info.getPropertyDescriptors()) { if (!pd.getName().equals("class")) { try { Object value = null; if (properties.get(pd.getName()) != null) { value = properties.get(pd.getName()); if (value.equals("false") || value.equals("true")) { pd.getWriteMethod().invoke(bean, new Object[] {Boolean.valueOf((String) value)}); } else { pd.getWriteMethod().invoke(bean, new Object[] {value}); } } else { value = pd.getReadMethod().invoke(bean, new Object[] {}); pd.getWriteMethod().invoke(bean, new Object[] {value}); } } catch (IllegalArgumentException ex) { ex.printStackTrace(); } catch (IllegalAccessException ex) { ex.printStackTrace(); } catch (InvocationTargetException ex) { ex.printStackTrace(); } } } }
/** * Returns a CSV line for the given LoggingObject - containing all properties in the exact same * way as in the config file - excluding those which could not be retrieved, i.e. for which no * PropertyDescriptor could be created * * @param loggingObject the LoggingObject for which a CSV line should be created * @return the CSV line representing the given LoggingObject */ public String getCSVRow(LoggingObject loggingObject, boolean anonymize, Long resourceableId) { List<String> loggingObjectList = new ArrayList<String>(); for (Iterator<PropertyDescriptor> it = orderedExportedPropertyDescriptors.iterator(); it.hasNext(); ) { PropertyDescriptor pd = it.next(); String strValue = ""; try { Object value = pd.getReadMethod().invoke(loggingObject, (Object[]) null); if (value != null) { strValue = String.valueOf(value); } if (anonymize && anonymizedProperties.contains(pd.getName())) { // do anonymization strValue = makeAnonymous(String.valueOf(value), resourceableId); } } catch (IllegalArgumentException e) { // nothing to do } catch (IllegalAccessException e) { // nothing to do } catch (InvocationTargetException e) { // nothing to do } loggingObjectList.add(strValue); } return StringHelper.formatAsCSVString(loggingObjectList); }
private Object getEntityId(Object obj, HibernateTemplate ht) throws IllegalAccessException, InvocationTargetException { ClassMetadata cm = ht.getSessionFactory().getClassMetadata(superClass); String idCol = cm.getIdentifierPropertyName(); PropertyDescriptor idPropDescr = BeanUtils.getPropertyDescriptor(superClass, idCol); return idPropDescr.getReadMethod().invoke(obj); }