public Class<?> getFieldType(String field) { return parseFieldExpression(fixedField(field), false).getValueType(boundObject); }
/** * Adds a special {@link DefaultMapping} that results in setting the target field on the model to an empty value * (typically null). * * @param mapper the mapper to add the mapping to * @param field the field for which a mapping is to be added * @param model the model */ protected void addEmptyValueMapping(DefaultMapper mapper, String field, Object model) { ParserContext parserContext = new SimpleParserContext(model.getClass()); Expression target = emptyValueExpressionParser.parseExpression(field, parserContext); try { Class<?> propertyType = target.getValueType(model); Expression source = new StaticExpression(getEmptyValue(propertyType)); DefaultMapping mapping = new DefaultMapping(source, target); if (logger.isDebugEnabled()) { logger.debug("Adding empty value mapping for parameter '" + field + "'"); } mapper.addMapping(mapping); } catch (EvaluationException e) { } }
private PropertyEditor findSpringConvertingPropertyEditor(String field, Class<?> valueType) { if (conversionService != null) { String converterId = null; if (field != null) { if (binderConfiguration != null) { converterId = binderConfiguration.getConverterId(field); } if (valueType == null) { valueType = parseFieldExpression(field, false).getValueType(boundObject); } } if (valueType != null) { BeanWrapper accessor = PropertyAccessorFactory.forBeanPropertyAccess(boundObject); TypeDescriptor typeDescriptor = accessor.getPropertyTypeDescriptor(field); return new ConvertingPropertyEditorAdapter(conversionService, converterId, typeDescriptor); } else { return null; } } else { return null; } }
"A ConversionService must be configured to use resolve custom converters to use during binding"); ConversionExecutor conversionExecutor = conversionService.getConversionExecutor(binding.getConverter(), String.class, target.getValueType(model)); mapping.setTypeConverter(conversionExecutor);
private Object getFormattedValue(String field) { Expression fieldExpression = parseFieldExpression(field, true); Class<?> valueType = fieldExpression.getValueType(boundObject); if (isCustomConverterConfigured(field) || avoidConversion(valueType)) { fieldExpression = parseFieldExpression(fieldExpression.getExpressionString(), false); } Object value = fieldExpression.getValue(boundObject); if ((value instanceof String) == false) { if (avoidConversion(valueType) == false) { PropertyEditor editor = findSpringConvertingPropertyEditor(field, valueType); if (editor != null) { editor.setValue(value); value = editor.getAsText(); } } } return value; }
protected MessageResolver createMessageResolver(MappingResult error) { String model = getModelExpression().getExpressionString(); String field = error.getMapping().getTargetExpression().getExpressionString(); Class<?> fieldType = error.getMapping().getTargetExpression().getValueType(getModelObject()); String[] messageCodes = messageCodesResolver.resolveMessageCodes(error.getCode(), model, field, fieldType); return new MessageBuilder().error().source(field).codes(messageCodes).resolvableArg(field) .defaultText(error.getCode() + " on " + field).build(); }
public Class getFieldType(String field) { return parseFieldExpression(field).getValueType(boundObject); }
public Class<?> getFieldType(String field) { return parseFieldExpression(fixedField(field), false).getValueType(boundObject); }
private void addEmptyValueMapping(DefaultMapper mapper, String field, Object model) { ParserContext parserContext = new FluentParserContext().evaluate(model.getClass()); Expression target = expressionParser.parseExpression(field, parserContext); try { Class propertyType = target.getValueType(model); Expression source = new StaticExpression(getEmptyValue(propertyType)); DefaultMapping mapping = new DefaultMapping(source, target); if (logger.isDebugEnabled()) { logger.debug("Adding empty value mapping for parameter '" + field + "'"); } mapper.addMapping(mapping); } catch (EvaluationException e) { } }
/** * Adds a special {@link DefaultMapping} that results in setting the target field on the model to an empty value * (typically null). * * @param mapper the mapper to add the mapping to * @param field the field for which a mapping is to be added * @param model the model */ protected void addEmptyValueMapping(DefaultMapper mapper, String field, Object model) { ParserContext parserContext = new SimpleParserContext(model.getClass()); Expression target = emptyValueExpressionParser.parseExpression(field, parserContext); try { Class<?> propertyType = target.getValueType(model); Expression source = new StaticExpression(getEmptyValue(propertyType)); DefaultMapping mapping = new DefaultMapping(source, target); if (logger.isDebugEnabled()) { logger.debug("Adding empty value mapping for parameter '" + field + "'"); } mapper.addMapping(mapping); } catch (EvaluationException e) { } }
public void testGetExpressionType() { String expressionString = "maximum"; Expression exp = parser.parseExpression(expressionString, null); TestBean context = new TestBean(); Class<?> clazz = exp.getValueType(context); assertTrue(int.class.equals(clazz) || Integer.class.equals(clazz)); }
public void testGetValueType() { String exp = "flag"; Expression e = parser.parseExpression(exp, null); assertEquals(boolean.class, e.getValueType(bean)); }
public void testGetValueTypeNullCollectionValue() { String exp = "list[0]"; Expression e = parser.parseExpression(exp, null); assertEquals(null, e.getValueType(bean)); }
private PropertyEditor findSpringConvertingPropertyEditor(String field, Class<?> valueType) { if (conversionService != null) { String converterId = null; if (field != null) { if (binderConfiguration != null) { converterId = binderConfiguration.getConverterId(field); } if (valueType == null) { valueType = parseFieldExpression(field, false).getValueType(boundObject); } } if (valueType != null) { BeanWrapper accessor = PropertyAccessorFactory.forBeanPropertyAccess(boundObject); TypeDescriptor typeDescriptor = accessor.getPropertyTypeDescriptor(field); return new ConvertingPropertyEditorAdapter(conversionService, converterId, typeDescriptor); } else { return null; } } else { return null; } }
public void testGetExpressionType() { String expressionString = "maximum"; Expression exp = parser.parseExpression(expressionString, null); TestBean context = new TestBean(); assertEquals(int.class, exp.getValueType(context)); }
private void addMapping(DefaultMapper mapper, Binding binding, Object model) { Expression source = new RequestParameterExpression(binding.getProperty()); ParserContext parserContext = new FluentParserContext().evaluate(model.getClass()); Expression target = expressionParser.parseExpression(binding.getProperty(), parserContext); DefaultMapping mapping = new DefaultMapping(source, target); mapping.setRequired(binding.getRequired()); if (binding.getConverter() != null) { ConversionExecutor conversionExecutor = conversionService.getConversionExecutor(binding.getConverter(), String.class, target.getValueType(model)); mapping.setTypeConverter(conversionExecutor); } if (logger.isDebugEnabled()) { logger.debug("Adding mapping for parameter '" + binding.getProperty() + "'"); } mapper.addMapping(mapping); }
public void rejectValue(String field, String errorCode, Object[] errorArgs, String defaultMessage) { field = fixedField(field); Class<?> fieldType; if (StringUtils.hasLength(field) && (expressionParser != null)) { FluentParserContext parserContext = new FluentParserContext().evaluate(boundObject.getClass()); fieldType = expressionParser.parseExpression(field, parserContext).getValueType(boundObject); } else { fieldType = null; } String[] messageCodes; if (StringUtils.hasLength(field)) { messageCodes = bindingErrorMessageCodesResolver .resolveMessageCodes(errorCode, objectName, field, fieldType); } else { messageCodes = bindingErrorMessageCodesResolver.resolveMessageCodes(errorCode, objectName); } messageContext.addMessage(new MessageBuilder().error().source(field).codes(messageCodes).args(errorArgs) .defaultText(defaultMessage).build()); }
public void rejectValue(String field, String errorCode, Object[] errorArgs, String defaultMessage) { field = fixedField(field); Class<?> fieldType; if (StringUtils.hasLength(field) && (expressionParser != null)) { FluentParserContext parserContext = new FluentParserContext().evaluate(boundObject.getClass()); fieldType = expressionParser.parseExpression(field, parserContext).getValueType(boundObject); } else { fieldType = null; } String[] messageCodes; if (StringUtils.hasLength(field)) { messageCodes = bindingErrorMessageCodesResolver .resolveMessageCodes(errorCode, objectName, field, fieldType); } else { messageCodes = bindingErrorMessageCodesResolver.resolveMessageCodes(errorCode, objectName); } messageContext.addMessage(new MessageBuilder().error().source(field).codes(messageCodes).args(errorArgs) .defaultText(defaultMessage).build()); }
private Object getFormattedValue(String field) { Expression fieldExpression = parseFieldExpression(field, true); Class<?> valueType = fieldExpression.getValueType(boundObject); if (isCustomConverterConfigured(field) || avoidConversion(valueType)) { fieldExpression = parseFieldExpression(fieldExpression.getExpressionString(), false); } Object value = fieldExpression.getValue(boundObject); if ((value instanceof String) == false) { if (avoidConversion(valueType) == false) { PropertyEditor editor = findSpringConvertingPropertyEditor(field, valueType); if (editor != null) { editor.setValue(value); value = editor.getAsText(); } } } return value; }
protected MessageResolver createMessageResolver(MappingResult error) { String model = getModelExpression().getExpressionString(); String field = error.getMapping().getTargetExpression().getExpressionString(); Class<?> fieldType = error.getMapping().getTargetExpression().getValueType(getModelObject()); String[] messageCodes = messageCodesResolver.resolveMessageCodes(error.getCode(), model, field, fieldType); return new MessageBuilder().error().source(field).codes(messageCodes).resolvableArg(field) .defaultText(error.getCode() + " on " + field).build(); }