Examples with IntrospectionException java.beans.IntrospectionException used on opensource projects

Example 81 with IntrospectionException

use of java.beans.IntrospectionException in project querydsl by querydsl.

the class CollQuerySerializer method getAccessor.

private Method getAccessor(Class<?> owner, String property) {
    try {
        BeanInfo beanInfo = Introspector.getBeanInfo(owner);
        PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor pd : descriptors) {
            if (pd.getName().equals(property)) {
                return pd.getReadMethod();
            }
        }
        return null;
    } catch (IntrospectionException e) {
        return null;
    }
}

Example 82 with IntrospectionException

use of java.beans.IntrospectionException in project querydsl by querydsl.

the class BeanMap method initialise.

private void initialise() {
    if (getBean() == null) {
        return;
    }
    Class<?> beanClass = getBean().getClass();
    try {
        //BeanInfo beanInfo = Introspector.getBeanInfo( bean, null );
        BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        if (propertyDescriptors != null) {
            for (int i = 0; i < propertyDescriptors.length; i++) {
                PropertyDescriptor propertyDescriptor = propertyDescriptors[i];
                if (propertyDescriptor != null) {
                    String name = propertyDescriptor.getName();
                    Method readMethod = propertyDescriptor.getReadMethod();
                    Method writeMethod = propertyDescriptor.getWriteMethod();
                    Class<?> aType = propertyDescriptor.getPropertyType();
                    if (readMethod != null) {
                        readMethods.put(name, readMethod);
                    }
                    if (writeMethods != null) {
                        writeMethods.put(name, writeMethod);
                    }
                    types.put(name, aType);
                }
            }
        }
    } catch (IntrospectionException e) {
    }
}

Example 83 with IntrospectionException

use of java.beans.IntrospectionException in project Mycat-Server by MyCATApache.

the class ObjectUtil method copyProperties.

public static void copyProperties(Object fromObj, Object toObj) {
    Class<? extends Object> fromClass = fromObj.getClass();
    Class<? extends Object> toClass = toObj.getClass();
    try {
        BeanInfo fromBean = Introspector.getBeanInfo(fromClass);
        BeanInfo toBean = Introspector.getBeanInfo(toClass);
        PropertyDescriptor[] toPd = toBean.getPropertyDescriptors();
        List<PropertyDescriptor> fromPd = Arrays.asList(fromBean.getPropertyDescriptors());
        for (PropertyDescriptor propertyDescriptor : toPd) {
            propertyDescriptor.getDisplayName();
            PropertyDescriptor pd = fromPd.get(fromPd.indexOf(propertyDescriptor));
            if (pd.getDisplayName().equals(propertyDescriptor.getDisplayName()) && !pd.getDisplayName().equals("class") && propertyDescriptor.getWriteMethod() != null) {
                propertyDescriptor.getWriteMethod().invoke(toObj, pd.getReadMethod().invoke(fromObj, null));
            }
        }
    } catch (IntrospectionException e) {
        throw new RuntimeException(e);
    } catch (IllegalArgumentException e) {
        throw new RuntimeException(e);
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
        throw new RuntimeException(e);
    }
}

Example 84 with IntrospectionException

use of java.beans.IntrospectionException in project config by typesafehub.

the class ConfigBeanImpl method createInternal.

/**
     * This is public ONLY for use by the "config" package, DO NOT USE this ABI
     * may change.
     * @param <T> type of the bean
     * @param config config to use
     * @param clazz class of the bean
     * @return the bean instance
     */
public static <T> T createInternal(Config config, Class<T> clazz) {
    if (((SimpleConfig) config).root().resolveStatus() != ResolveStatus.RESOLVED)
        throw new ConfigException.NotResolved("need to Config#resolve() a config before using it to initialize a bean, see the API docs for Config#resolve()");
    Map<String, AbstractConfigValue> configProps = new HashMap<String, AbstractConfigValue>();
    Map<String, String> originalNames = new HashMap<String, String>();
    for (Map.Entry<String, ConfigValue> configProp : config.root().entrySet()) {
        String originalName = configProp.getKey();
        String camelName = ConfigImplUtil.toCamelCase(originalName);
        // the camel one wins
        if (originalNames.containsKey(camelName) && !originalName.equals(camelName)) {
        // if we aren't a camel name to start with, we lose.
        // if we are or we are the first matching key, we win.
        } else {
            configProps.put(camelName, (AbstractConfigValue) configProp.getValue());
            originalNames.put(camelName, originalName);
        }
    }
    BeanInfo beanInfo = null;
    try {
        beanInfo = Introspector.getBeanInfo(clazz);
    } catch (IntrospectionException e) {
        throw new ConfigException.BadBean("Could not get bean information for class " + clazz.getName(), e);
    }
    try {
        List<PropertyDescriptor> beanProps = new ArrayList<PropertyDescriptor>();
        for (PropertyDescriptor beanProp : beanInfo.getPropertyDescriptors()) {
            if (beanProp.getReadMethod() == null || beanProp.getWriteMethod() == null) {
                continue;
            }
            beanProps.add(beanProp);
        }
        // Try to throw all validation issues at once (this does not comprehensively
        // find every issue, but it should find common ones).
        List<ConfigException.ValidationProblem> problems = new ArrayList<ConfigException.ValidationProblem>();
        for (PropertyDescriptor beanProp : beanProps) {
            Method setter = beanProp.getWriteMethod();
            Class<?> parameterClass = setter.getParameterTypes()[0];
            ConfigValueType expectedType = getValueTypeOrNull(parameterClass);
            if (expectedType != null) {
                String name = originalNames.get(beanProp.getName());
                if (name == null)
                    name = beanProp.getName();
                Path path = Path.newKey(name);
                AbstractConfigValue configValue = configProps.get(beanProp.getName());
                if (configValue != null) {
                    SimpleConfig.checkValid(path, expectedType, configValue, problems);
                } else {
                    if (!isOptionalProperty(clazz, beanProp)) {
                        SimpleConfig.addMissing(problems, expectedType, path, config.origin());
                    }
                }
            }
        }
        if (!problems.isEmpty()) {
            throw new ConfigException.ValidationFailed(problems);
        }
        // Fill in the bean instance
        T bean = clazz.newInstance();
        for (PropertyDescriptor beanProp : beanProps) {
            Method setter = beanProp.getWriteMethod();
            Type parameterType = setter.getGenericParameterTypes()[0];
            Class<?> parameterClass = setter.getParameterTypes()[0];
            String configPropName = originalNames.get(beanProp.getName());
            // Is the property key missing in the config?
            if (configPropName == null) {
                // If so, continue if the field is marked as @{link Optional}
                if (isOptionalProperty(clazz, beanProp)) {
                    continue;
                }
                // Otherwise, raise a {@link Missing} exception right here
                throw new ConfigException.Missing(beanProp.getName());
            }
            Object unwrapped = getValue(clazz, parameterType, parameterClass, config, configPropName);
            setter.invoke(bean, unwrapped);
        }
        return bean;
    } catch (InstantiationException e) {
        throw new ConfigException.BadBean(clazz.getName() + " needs a public no-args constructor to be used as a bean", e);
    } catch (IllegalAccessException e) {
        throw new ConfigException.BadBean(clazz.getName() + " getters and setters are not accessible, they must be for use as a bean", e);
    } catch (InvocationTargetException e) {
        throw new ConfigException.BadBean("Calling bean method on " + clazz.getName() + " caused an exception", e);
    }
}

Example 85 with IntrospectionException

use of java.beans.IntrospectionException in project spring-framework by spring-projects.

the class PropertyDescriptorUtils method findIndexedPropertyType.

/**
	 * See {@link java.beans.IndexedPropertyDescriptor#findIndexedPropertyType}.
	 */
public static Class<?> findIndexedPropertyType(String name, Class<?> propertyType, Method indexedReadMethod, Method indexedWriteMethod) throws IntrospectionException {
    Class<?> indexedPropertyType = null;
    if (indexedReadMethod != null) {
        Class<?>[] params = indexedReadMethod.getParameterTypes();
        if (params.length != 1) {
            throw new IntrospectionException("Bad indexed read method arg count: " + indexedReadMethod);
        }
        if (params[0] != Integer.TYPE) {
            throw new IntrospectionException("Non int index to indexed read method: " + indexedReadMethod);
        }
        indexedPropertyType = indexedReadMethod.getReturnType();
        if (indexedPropertyType == Void.TYPE) {
            throw new IntrospectionException("Indexed read method returns void: " + indexedReadMethod);
        }
    }
    if (indexedWriteMethod != null) {
        Class<?>[] params = indexedWriteMethod.getParameterTypes();
        if (params.length != 2) {
            throw new IntrospectionException("Bad indexed write method arg count: " + indexedWriteMethod);
        }
        if (params[0] != Integer.TYPE) {
            throw new IntrospectionException("Non int index to indexed write method: " + indexedWriteMethod);
        }
        if (indexedPropertyType != null) {
            if (indexedPropertyType.isAssignableFrom(params[1])) {
                // Write method's property type potentially more specific
                indexedPropertyType = params[1];
            } else if (params[1].isAssignableFrom(indexedPropertyType)) {
            // Proceed with read method's property type
            } else {
                throw new IntrospectionException("Type mismatch between indexed read and write methods: " + indexedReadMethod + " - " + indexedWriteMethod);
            }
        } else {
            indexedPropertyType = params[1];
        }
    }
    if (propertyType != null && (!propertyType.isArray() || propertyType.getComponentType() != indexedPropertyType)) {
        throw new IntrospectionException("Type mismatch between indexed and non-indexed methods: " + indexedReadMethod + " - " + indexedWriteMethod);
    }
    return indexedPropertyType;
}