/** * Gets properly typed method argument. * @param parameterType * @param value * @return */ private <T> T getMethodArgument(Class<T> parameterType, Object value) { if (parameterType.isInstance(value)) { return parameterType.cast(value); } try { return new SimpleTypeConverter().convertIfNecessary(value, parameterType); } catch (ConversionNotSupportedException e) { if (String.class.equals(parameterType)) { return (T) String.valueOf(value); } throw new ApplicationRuntimeException("Unable to convert method argument type", e); } }
/** * Create a new DirectFieldAccessor for the given target object. * @param target the target object to access */ public DirectFieldAccessor(final Object target) { Assert.notNull(target, "Target object must not be null"); this.target = target; ReflectionUtils.doWithFields(this.target.getClass(), new ReflectionUtils.FieldCallback() { public void doWith(Field field) { // jlm - FIX SPR-8398: avoid to overwrite shadowed fileds if (!fieldMap.containsKey(field.getName())) { fieldMap.put(field.getName(), field); } } }); this.typeConverterDelegate = new SimpleTypeConverter(); registerDefaultEditors(); setExtractOldValueForEditor(true); }
private TypeConverter getConverter() { if (typeConverter == null) { SimpleTypeConverter simpleConverter = new SimpleTypeConverter(); beanFactory.copyRegisteredEditorsTo(simpleConverter); simpleConverter.setConversionService(beanFactory.getConversionService()); typeConverter = simpleConverter; } return typeConverter; }
/** * Return this binder's underlying SimpleTypeConverter. */ protected SimpleTypeConverter getSimpleTypeConverter() { if (this.typeConverter == null) { this.typeConverter = new SimpleTypeConverter(); if (this.conversionService != null) { this.typeConverter.setConversionService(this.conversionService); } } return this.typeConverter; }
/** * Look up the JNDI object and store it. */ @Override public void afterPropertiesSet() throws IllegalArgumentException, NamingException { super.afterPropertiesSet(); if (this.proxyInterfaces != null || !this.lookupOnStartup || !this.cache || this.exposeAccessContext) { // We need to create a proxy for this... if (this.defaultObject != null) { throw new IllegalArgumentException( "'defaultObject' is not supported in combination with 'proxyInterface'"); } // We need a proxy and a JndiObjectTargetSource. this.jndiObject = JndiObjectProxyFactory.createJndiObjectProxy(this); } else { if (this.defaultObject != null && getExpectedType() != null && !getExpectedType().isInstance(this.defaultObject)) { TypeConverter converter = (this.beanFactory != null ? this.beanFactory.getTypeConverter() : new SimpleTypeConverter()); try { this.defaultObject = converter.convertIfNecessary(this.defaultObject, getExpectedType()); } catch (TypeMismatchException ex) { throw new IllegalArgumentException("Default object [" + this.defaultObject + "] of type [" + this.defaultObject.getClass().getName() + "] is not of expected type [" + getExpectedType().getName() + "] and cannot be converted either", ex); } } // Locate specified JNDI object. this.jndiObject = lookupWithFallback(); } }
/** * Match the given qualifier annotations against the candidate bean definition. */ protected boolean checkQualifiers(BeanDefinitionHolder bdHolder, Annotation[] annotationsToSearch) { if (ObjectUtils.isEmpty(annotationsToSearch)) { return true; } SimpleTypeConverter typeConverter = new SimpleTypeConverter(); for (Annotation annotation : annotationsToSearch) { Class<? extends Annotation> type = annotation.annotationType(); boolean checkMeta = true; boolean fallbackToMeta = false; if (isQualifier(type)) { if (!checkQualifier(bdHolder, annotation, typeConverter)) { fallbackToMeta = true; } else { checkMeta = false; } } if (checkMeta) { boolean foundMeta = false; for (Annotation metaAnn : type.getAnnotations()) { Class<? extends Annotation> metaType = metaAnn.annotationType(); if (isQualifier(metaType)) { foundMeta = true; // Only accept fallback match if @Qualifier annotation has a value... // Otherwise it is just a marker for a custom qualifier annotation. if ((fallbackToMeta && StringUtils.isEmpty(AnnotationUtils.getValue(metaAnn))) || !checkQualifier(bdHolder, metaAnn, typeConverter)) { return false; } } } if (fallbackToMeta && !foundMeta) { return false; } } } return true; }
@Override public TypeConverter getTypeConverter() { TypeConverter customConverter = getCustomTypeConverter(); if (customConverter != null) { return customConverter; } else { // Build default TypeConverter, registering custom editors. SimpleTypeConverter typeConverter = new SimpleTypeConverter(); typeConverter.setConversionService(getConversionService()); registerCustomEditors(typeConverter); return typeConverter; } }
/** * Obtain a bean type converter from the BeanFactory that this bean * runs in. This is typically a fresh instance for each call, * since TypeConverters are usually <i>not</i> thread-safe. * <p>Falls back to a SimpleTypeConverter when not running in a BeanFactory. * @see ConfigurableBeanFactory#getTypeConverter() * @see org.springframework.beans.SimpleTypeConverter */ protected TypeConverter getBeanTypeConverter() { BeanFactory beanFactory = getBeanFactory(); if (beanFactory instanceof ConfigurableBeanFactory) { return ((ConfigurableBeanFactory) beanFactory).getTypeConverter(); } else { return new SimpleTypeConverter(); } }
@Bean public TypeConverter typeConverter() { SimpleTypeConverter tc = new SimpleTypeConverter(); tc.registerCustomEditor(LocalDateTime.class, new LocalDateTimePropertyEditor("yyyyMMdd_HHmmss")); tc.registerCustomEditor(LocalDate.class, new LocalDatePropertyEditor("yyyyMMdd")); return tc; }
@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { if (beanFactory instanceof ConfigurableBeanFactory) { Object typeConverter = ((ConfigurableBeanFactory) beanFactory).getTypeConverter(); if (typeConverter instanceof SimpleTypeConverter) { delegate = (SimpleTypeConverter) typeConverter; } } }
private JpqQueryRSQLVisitor(final Root<T> root, final CriteriaBuilder cb, final Class<A> enumType, final VirtualPropertyReplacer virtualPropertyReplacer) { this.root = root; this.cb = cb; this.enumType = enumType; this.virtualPropertyReplacer = virtualPropertyReplacer; simpleTypeConverter = new SimpleTypeConverter(); }
public static void setFieldValue(Field field, Object bean, Object value) throws IllegalAccessException { // Set it on the field field.setAccessible(true); // Perform type conversion if possible.. SimpleTypeConverter converter = new SimpleTypeConverter(); try { value = converter.convertIfNecessary(value, field.getType()); } catch (ConversionNotSupportedException e) { // If conversion isn't supported, ignore and try and set anyway. } field.set(bean, value); }
public TypeConverter getTypeConverter() { TypeConverter customConverter = getCustomTypeConverter(); if (customConverter != null) { return customConverter; } else { // Build default TypeConverter, registering custom editors. SimpleTypeConverter typeConverter = new SimpleTypeConverter(); typeConverter.setConversionService(getConversionService()); registerCustomEditors(typeConverter); return typeConverter; } }
public GoConfigFieldWriter(Field declaredField, Object value, SimpleTypeConverter converter, ConfigCache configCache, final ConfigElementImplementationRegistry registry) { this.configField = declaredField; this.value = value; this.configField.setAccessible(true); this.typeConverter = converter; this.configCache = configCache; this.registry = registry; }
public SpringBlueprintConverterService(ConversionService delegate, ConfigurableBeanFactory cbf) { this.delegate = delegate; this.cbf = cbf; this.typeConverter = new SimpleTypeConverter(); }
public Object getValue() throws Exception{ String strValue = ((JTextField) editor).getText(); SimpleTypeConverter stc = new SimpleTypeConverter(); return stc.convertIfNecessary(strValue, clazz); }
/** * Obtain the default TypeConverter for this method invoker. * <p>Called if no explicit TypeConverter has been specified. * The default implementation builds a * {@link org.springframework.beans.SimpleTypeConverter}. * Can be overridden in subclasses. */ protected TypeConverter getDefaultTypeConverter() { return new SimpleTypeConverter(); }
