root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

binding system refactoring - work in progress

This commit is contained in:
Keith Donald 2009-07-18 16:18:22 +00:00
parent 8e2797153b
commit 8d3fbc5df8
26 changed files with 1464 additions and 931 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
org.springframework.context/src/main/java/org/springframework/ui/binding/Binder.java
View File

@ -21,7 +21,7 @@ import java.util.Map;
* Binds user-entered values to properties of a model object.
* @author Keith Donald
* @since 3.0
* @see #addBinding(String)
* @see #bind(String)
* @see #getBinding(String)
* @see #bind(Map)
*/
@ -32,26 +32,6 @@ public interface Binder {
*/
Object getModel();
/**
* Add a binding to a model property.
* The property may be a path to a member property like "name", or a nested property like "address.city" or "addresses.city".
* If the property path is nested and traverses a collection or Map, do not use indexes.
* The property path should express the model-class property structure like addresses.city, not an object structure like addresses[0].city.
* Examples:
* <pre>
* name - bind to property 'name'
* addresses - bind to property 'addresses', presumably a List&lt;Address&gt; e.g. allowing property expressions like addresses={ 12345 Macy Lane, 1977 Bel Aire Estates } and addresses[0]=12345 Macy Lane
* addresses.city - bind to property 'addresses.city', for all indexed addresses in the collection e.g. allowing property expressions like addresses[0].city=Melbourne
* address.city - bind to property 'address.city'
* favoriteFoodByFoodGroup - bind to property 'favoriteFoodByFoodGroup', presumably a Map<FoodGroup, Food>; e.g. allowing favoriteFoodByFoodGroup={ DAIRY=Milk, MEAT=Steak } and favoriteFoodByFoodGroup['DAIRY']=Milk
* favoriteFoodByFoodGroup.name - bind to property 'favoriteFoodByFoodGroup.name', for all keyed Foods in the map; e.g. allowing favoriteFoodByFoodGroup['DAIRY'].name=Milk
* </pre>
* @param propertyPath the model property path
* @return a BindingConfiguration object, allowing additional configuration of the newly added binding
* @throws IllegalArgumentException if no such property path exists on the model
*/
public BindingConfiguration addBinding(String propertyPath);
/**
* Get a binding to a model property..
* @param property the property path

137
org.springframework.context/src/main/java/org/springframework/ui/binding/Binding.java
View File

@ -15,59 +15,128 @@
*/
package org.springframework.ui.binding;
import org.springframework.ui.alert.Alert;
/**
* A binding between a user interface element and a model property.
* A binding between a source element and a model property.
* @author Keith Donald
* @since 3.0
*/
public interface Binding {
/**
* The name of the bound model property.
* The bound value to display in the UI.
* Is the formatted model value if not dirty.
* Is the buffered value if dirty.
*/
String getProperty();
Object getValue();
/**
* The type of the underlying property associated with this binding.
* If this Binding is read-only.
* A read-only Binding cannot have source values applied and cannot be committed.
*/
Class<?> getType();
/**
* The formatted property value to display in the user interface.
*/
String getValue();
/**
* Set the property to the value provided.
* The value may be a formatted String, a formatted String[] if a collection binding, or an Object of a type that can be coersed to the underlying property type.
* @param value the new value to bind
* @return a summary of the result of the binding
* @throws BindException if an unrecoverable exception occurs
*/
BindingResult setValue(Object value);
boolean isReadOnly();
/**
* Formats a candidate model property value for display in the user interface.
* @param potentialValue a possible value
* @return the formatted value to display in the user interface
* Apply the source value to this binding.
* The source value is parsed, validated, and stored in the binding's value buffer.
* Sets 'dirty' status to true.
* Sets 'valid' status to false if the source value is not valid.
* @param sourceValue
* @throws IllegalStateException if read only
*/
String format(Object potentialValue);
void applySourceValue(Object sourceValue);
/**
* True if there is an uncommitted value in the binding buffer.
* Set to true after applying a source value.
* Set to false after a commit.
*/
boolean isDirty();
/**
* False if dirty and the buffered value is invalid.
* False if dirty and the buffered value appears valid but could not be committed.
* True otherwise.
*/
boolean isValid();
/**
* Commit the buffered value to the model.
* @throws IllegalStateException if not dirty, not valid, or read-only
*/
void commit();
/**
* Is this a collection binding?
* If so, a client may call {@link #getCollectionValues()} to get the collection element values for display in the user interface.
* In this case, the client typically allocates one indexed field to each value.
* A client may then call {@link #setValues(String[])} to update model property values from those fields.
* Alternatively, a client may call {@link #getValue()} to render the collection as a single value for display in a single field, such as a large text area.
* The client would then call {@link #setValue(Object)} to update that single value from the field.
* An Alert that communicates the current status of this Binding.
*/
boolean isCollection();
Alert getStatusAlert();
/**
* Access raw model values.
*/
Model getModel();
/**
* Get a Binding to a nested property value.
* @param nestedProperty the nested property name, such as "foo"; should not be a property path like "foo.bar"
* @return the binding to the nested property
*/
Binding getBinding(String nestedProperty);
/**
* When a collection binding, the formatted values to display in the user interface.
* If not a collection binding, throws an IllegalStateException.
* @throws IllegalStateException
* If bound to an indexable Collection, either a {@link java.util.List} or an array.
*/
String[] getCollectionValues();
boolean isIndexable();
/**
* If a List, get a Binding to a element in the List.
* @param index the element index
* @return the indexed binding
*/
Binding getIndexedBinding(int index);
/**
* If bound to a {@link java.util.Map}.
*/
boolean isMap();
/**
* If a Map, get a Binding to a value in the Map.
* @param key the map key
* @return the keyed binding
*/
Binding getKeyedBinding(Object key);
/**
* Format a potential model value for display.
* If an indexable binding, expects the model value to be a potential collection element & uses the configured element formatter.
* If a map binding, expects the model value to be a potential map value & uses the configured map value formatter.
* @param potentialValue the potential value
* @return the formatted string
*/
String formatValue(Object potentialModelValue);
/**
* For accessing the raw bound model object.
* @author Keith Donald
*/
public interface Model {
/**
* Read the raw model value.
*/
Object getValue();
/**
* The model value type.
*/
Class<?> getValueType();
/**
* Set the model value.
* @throws IllegalStateException if this binding is read-only
*/
void setValue(Object value);
}
}

19
org.springframework.context/src/main/java/org/springframework/ui/binding/config/BindingRule.java Normal file
View File

@ -0,0 +1,19 @@
package org.springframework.ui.binding.config;
import org.springframework.ui.format.Formatter;
public interface BindingRule {
String getPropertyPath();
Formatter<?> getFormatter();
boolean isRequired();
boolean isCollectionBinding();
Formatter<?> getKeyFormatter();
Formatter<?> getValueFormatter();
}

19
org.springframework.context/src/main/java/org/springframework/ui/binding/BindingConfiguration.java → org.springframework.context/src/main/java/org/springframework/ui/binding/config/BindingRuleConfiguration.java
View File

@ -13,25 +13,29 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.ui.binding;
package org.springframework.ui.binding.config;
import org.springframework.ui.binding.support.GenericBinder;
import org.springframework.ui.format.Formatter;
/**
* A fluent interface for configuring a newly added binding.
* @author Keith Donald
* @see GenericBinder#addBinding(String)
*/
public interface BindingConfiguration {
public interface BindingRuleConfiguration {
/**
* Set the Formatter to use to format bound property values.
* If a collection property, the formatter is used to format collection element values.
* If a collection property, this formatter is used to format the Collection as a String.
* Default is null.
*/
BindingConfiguration formatWith(Formatter<?> formatter);
BindingRuleConfiguration formatWith(Formatter<?> formatter);
/**
* If a collection property, set the Formatter to use to format indexed collection elements.
* Default is null.
*/
BindingRuleConfiguration formatElementsWith(Formatter<?> formatter);
/**
* Mark the binding as required.
* A required binding will generate an exception if no sourceValue is provided to a bind invocation.
@ -44,5 +48,6 @@ public interface BindingConfiguration {
* addresses.city=required - will generate an exception if 'addresses[n].city' is not present in the source values map, for every address[n].
* </pre>
*/
BindingConfiguration required();
BindingRuleConfiguration required();
}

9
org.springframework.context/src/main/java/org/springframework/ui/binding/config/BindingRules.java Normal file
View File

@ -0,0 +1,9 @@
package org.springframework.ui.binding.config;
import java.util.List;
public interface BindingRules extends List<BindingRule> {
Class<?> getModelType();
}

120
org.springframework.context/src/main/java/org/springframework/ui/binding/config/BindingRulesBuilder.java Normal file
View File

@ -0,0 +1,120 @@
package org.springframework.ui.binding.config;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import org.springframework.core.GenericCollectionTypeResolver;
import org.springframework.util.Assert;
/**
* Builder for constructing the rules for binding to a model.
* @author Keith Donald
* @param <M> the model type
*/
public class BindingRulesBuilder {
private BindingRules bindingRules;
/**
* Creates a new BindingRuleBuilder.
* @param modelType the type of model to build binding rules against
*/
public BindingRulesBuilder(Class<?> modelType) {
Assert.notNull(modelType, "The model type is required");
bindingRules = new ArrayListBindingRules(modelType);
}
/**
* Creates a rule for binding to the model property.
* @param propertyPath the model property path
* @return allows additional binding configuration options to be specified fluently
* @throws IllegalArgumentException if the property path is invalid given the modelType
*/
public BindingRuleConfiguration bind(String propertyPath) {
boolean collectionBinding = validate(propertyPath);
ConfigurableBindingRule rule = new ConfigurableBindingRule(propertyPath);
if (collectionBinding) {
rule.markCollectionBinding();
}
bindingRules.add(rule);
return rule;
}
/**
* The built list of binding rules.
* Call after recording {@link #bind(String)} instructions.
*/
public BindingRules getBindingRules() {
return bindingRules;
}
private boolean validate(String propertyPath) {
boolean collectionBinding = false;
String[] props = propertyPath.split("\\.");
if (props.length == 0) {
props = new String[] { propertyPath };
}
Class<?> modelType = bindingRules.getModelType();
for (int i = 0; i < props.length; i ++) {
String prop = props[i];
PropertyDescriptor[] propDescs = getBeanInfo(modelType).getPropertyDescriptors();
boolean found = false;
for (PropertyDescriptor propDesc : propDescs) {
if (prop.equals(propDesc.getName())) {
found = true;
Class<?> propertyType = propDesc.getPropertyType();
if (Collection.class.isAssignableFrom(propertyType)) {
modelType = GenericCollectionTypeResolver.getCollectionReturnType(propDesc.getReadMethod());
if (i == (props.length - 1)) {
collectionBinding = true;
}
} else if (Map.class.isAssignableFrom(propertyType)) {
modelType = GenericCollectionTypeResolver.getMapValueReturnType(propDesc.getReadMethod());
if (i == (props.length - 1)) {
collectionBinding = true;
}
} else {
modelType = propertyType;
}
break;
}
}
if (!found) {
if (props.length > 1) {
throw new IllegalArgumentException("No property named '" + prop + "' found on model class [" + modelType.getName() + "] as part of property path '" + propertyPath + "'");
} else {
throw new IllegalArgumentException("No property named '" + prop + "' found on model class [" + modelType.getName() + "]");
}
}
}
return collectionBinding;
}
private BeanInfo getBeanInfo(Class<?> clazz) {
try {
return Introspector.getBeanInfo(clazz);
} catch (IntrospectionException e) {
throw new IllegalStateException("Unable to introspect model type " + clazz);
}
}
@SuppressWarnings("serial")
static class ArrayListBindingRules extends ArrayList<BindingRule> implements BindingRules {
private Class<?> modelType;
public ArrayListBindingRules(Class<?> modelType) {
this.modelType = modelType;
}
public Class<?> getModelType() {
return modelType;
}
}
}

68
org.springframework.context/src/main/java/org/springframework/ui/binding/config/ConfigurableBindingRule.java Normal file
View File

@ -0,0 +1,68 @@
package org.springframework.ui.binding.config;
import org.springframework.ui.format.Formatter;
public class ConfigurableBindingRule implements BindingRuleConfiguration, BindingRule {
private String propertyPath;
private Formatter<?> formatter;
private boolean required;
private boolean collectionBinding;
private Formatter<?> elementFormatter;
public ConfigurableBindingRule(String propertyPath) {
this.propertyPath = propertyPath;
}
// implementing BindingRuleConfiguration
public BindingRuleConfiguration formatWith(Formatter<?> formatter) {
this.formatter = formatter;
return this;
}
public BindingRuleConfiguration required() {
this.required = true;
return this;
}
public BindingRuleConfiguration formatElementsWith(Formatter<?> formatter) {
this.elementFormatter = formatter;
return this;
}
// implementing BindingRule
public String getPropertyPath() {
return propertyPath;
}
public Formatter<?> getFormatter() {
return formatter;
}
public boolean isRequired() {
return required;
}
public boolean isCollectionBinding() {
return collectionBinding;
}
public void markCollectionBinding() {
this.collectionBinding = true;
}
public Formatter<?> getValueFormatter() {
return elementFormatter;
}
public Formatter<?> getKeyFormatter() {
return null;
}
}

76
org.springframework.context/src/main/java/org/springframework/ui/binding/support/ArrayListBindingResults.java Normal file
View File

@ -0,0 +1,76 @@
/**
*
*/
package org.springframework.ui.binding.support;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.springframework.ui.binding.BindingResult;
import org.springframework.ui.binding.BindingResults;
class ArrayListBindingResults implements BindingResults {
private List<BindingResult> results;
public ArrayListBindingResults() {
results = new ArrayList<BindingResult>();
}
public ArrayListBindingResults(int size) {
results = new ArrayList<BindingResult>(size);
}
public void add(BindingResult result) {
results.add(result);
}
// implementing Iterable
public Iterator<BindingResult> iterator() {
return results.iterator();
}
// implementing BindingResults
public BindingResults successes() {
ArrayListBindingResults results = new ArrayListBindingResults();
for (BindingResult result : this) {
if (!result.isFailure()) {
results.add(result);
}
}
return results;
}
public BindingResults failures() {
ArrayListBindingResults results = new ArrayListBindingResults();
for (BindingResult result : this) {
if (result.isFailure()) {
results.add(result);
}
}
return results;
}
public BindingResult get(int index) {
return results.get(index);
}
public List<String> properties() {
List<String> properties = new ArrayList<String>(results.size());
for (BindingResult result : this) {
properties.add(result.getProperty());
}
return properties;
}
public int size() {
return results.size();
}
public String toString() {
return "[BindingResults = " + results.toString() + "]";
}
}

40
org.springframework.context/src/main/java/org/springframework/ui/binding/support/BindingStatusResult.java Normal file
View File

@ -0,0 +1,40 @@
/**
*
*/
package org.springframework.ui.binding.support;
import org.springframework.ui.alert.Alert;
import org.springframework.ui.alert.Severity;
import org.springframework.ui.binding.BindingResult;
class BindingStatusResult implements BindingResult {
private String property;
private Object sourceValue;
private Alert bindingStatusAlert;
public BindingStatusResult(String property, Object sourceValue, Alert alert) {
this.property = property;
this.sourceValue = sourceValue;
this.bindingStatusAlert = alert;
}
public String getProperty() {
return property;
}
public Object getSourceValue() {
return sourceValue;
}
public boolean isFailure() {
return bindingStatusAlert.getSeverity().compareTo(Severity.INFO) > 1;
}
public Alert getAlert() {
return bindingStatusAlert;
}
}

50
org.springframework.context/src/main/java/org/springframework/ui/binding/support/CollectionTypeDescriptor.java Normal file
View File

@ -0,0 +1,50 @@
/**
*
*/
package org.springframework.ui.binding.support;
import org.springframework.util.ObjectUtils;
public class CollectionTypeDescriptor {
private Class<?> collectionType;
private Class<?> elementType;
/**
* Creates a new generic collection property type
* @param collectionType the collection type
* @param elementType the element type
*/
public CollectionTypeDescriptor(Class<?> collectionType, Class<?> elementType) {
this.collectionType = collectionType;
this.elementType = elementType;
}
/**
* The collection type.
*/
public Class<?> getCollectionType() {
return collectionType;
}
/**
* The element type.
*/
public Class<?> getElementType() {
return elementType;
}
public boolean equals(Object o) {
if (!(o instanceof CollectionTypeDescriptor)) {
return false;
}
CollectionTypeDescriptor type = (CollectionTypeDescriptor) o;
return collectionType.equals(type.collectionType)
&& ObjectUtils.nullSafeEquals(elementType, type.elementType);
}
public int hashCode() {
return collectionType.hashCode() + elementType.hashCode();
}
}

62
org.springframework.context/src/main/java/org/springframework/ui/binding/support/DefaultBindingConfiguration.java
View File

@ -1,62 +0,0 @@
/*
* Copyright 2004-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.ui.binding.support;
import org.springframework.ui.binding.BindingConfiguration;
import org.springframework.ui.format.Formatter;
final class DefaultBindingConfiguration implements BindingConfiguration {
private String propertyPath;
private Formatter<?> formatter;
private boolean required;
/**
* Creates a new Binding configuration.
* @param property the property to bind to
* @param formatter the formatter to use to format property values
*/
public DefaultBindingConfiguration(String propertyPath) {
this.propertyPath = propertyPath;
}
// implementing BindingConfiguration
public BindingConfiguration formatWith(Formatter<?> formatter) {
this.formatter = formatter;
return this;
}
public BindingConfiguration required() {
this.required = true;
return this;
}
public String getPropertyPath() {
return propertyPath;
}
public Formatter<?> getFormatter() {
return formatter;
}
public boolean isRequired() {
return required;
}
}

30
org.springframework.context/src/main/java/org/springframework/ui/binding/support/DefaultFormatter.java Normal file
View File

@ -0,0 +1,30 @@
/**
*
*/
package org.springframework.ui.binding.support;
import java.text.ParseException;
import java.util.Locale;
import org.springframework.ui.format.Formatter;
class DefaultFormatter implements Formatter<Object> {
public static final Formatter<Object> INSTANCE = new DefaultFormatter();
public String format(Object object, Locale locale) {
if (object == null) {
return "";
} else {
return object.toString();
}
}
public Object parse(String formatted, Locale locale) throws ParseException {
if (formatted == "") {
return null;
} else {
return formatted;
}
}
}

715
org.springframework.context/src/main/java/org/springframework/ui/binding/support/GenericBinder.java
View File

@ -15,86 +15,34 @@
*/
package org.springframework.ui.binding.support;
import java.lang.reflect.Array;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.springframework.context.ApplicationListener;
import org.springframework.context.MessageSource;
import org.springframework.context.expression.MapAccessor;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.core.GenericTypeResolver;
import org.springframework.core.convert.ConversionFailedException;
import org.springframework.core.convert.TypeConverter;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.core.convert.support.DefaultTypeConverter;
import org.springframework.core.style.StylerUtils;
import org.springframework.expression.AccessException;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.EvaluationException;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionException;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.SpelEvaluationException;
import org.springframework.expression.spel.SpelMessage;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParserConfiguration;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.expression.spel.support.StandardTypeConverter;
import org.springframework.ui.alert.Alert;
import org.springframework.ui.alert.Severity;
import org.springframework.ui.binding.Binder;
import org.springframework.ui.binding.Binding;
import org.springframework.ui.binding.BindingConfiguration;
import org.springframework.ui.binding.BindingResult;
import org.springframework.ui.binding.BindingResults;
import org.springframework.ui.binding.MissingSourceValuesException;
import org.springframework.ui.binding.NoSuchBindingException;
import org.springframework.ui.format.AnnotationFormatterFactory;
import org.springframework.ui.format.Formatter;
import org.springframework.ui.message.MessageBuilder;
import org.springframework.ui.message.ResolvableArgument;
import org.springframework.util.Assert;
/**
* A generic {@link Binder binder} suitable for use in most environments.
* @author Keith Donald
* @since 3.0
* @see #addBinding(String)
* @see #registerFormatter(Class, Formatter)
* @see #registerFormatterFactory(AnnotationFormatterFactory)
* @see #setFormatterRegistry(FormatterRegistry)
* @see #setMessageSource(MessageSource)
* @see #setTypeConverter(TypeConverter)
* @see #bind(Map)
*/
@SuppressWarnings("unchecked")
public class GenericBinder implements Binder {
private static final String[] EMPTY_STRING_ARRAY = new String[0];
private Object model;
public Set<BindingFactory> bindingFactories;
private FormatterRegistry formatterRegistry = new GenericFormatterRegistry();
private ExpressionParser expressionParser;
private Map<String, Binding> bindings;
private TypeConverter typeConverter;
private static Formatter defaultFormatter = new DefaultFormatter();
private MessageSource messageSource;
/**
@ -104,78 +52,10 @@ public class GenericBinder implements Binder {
public GenericBinder(Object model) {
Assert.notNull(model, "The model to bind to is required");
this.model = model;
bindingFactories = new LinkedHashSet<BindingFactory>();
int parserConfig = SpelExpressionParserConfiguration.CreateObjectIfAttemptToReferenceNull
| SpelExpressionParserConfiguration.GrowListsOnIndexBeyondSize;
expressionParser = new SpelExpressionParser(parserConfig);
bindings = new HashMap<String, Binding>();
typeConverter = new DefaultTypeConverter();
}
/**
* Add a binding to a model property.
* The property may be a path to a member property like "name", or a nested property like "address.city" or "addresses.city".
* If the property path is nested and traverses a collection or Map, do not use indexes.
* The property path should express the model-class property structure like addresses.city, not an object structure like addresses[0].city.
* Examples:
* <pre>
* name - bind to property 'name'
* addresses - bind to property 'addresses', presumably a List&lt;Address&gt; e.g. allowing property expressions like addresses={ 12345 Macy Lane, 1977 Bel Aire Estates } and addresses[0]=12345 Macy Lane
* addresses.city - bind to property 'addresses.city', for all indexed addresses in the collection e.g. allowing property expressions like addresses[0].city=Melbourne
* address.city - bind to property 'address.city'
* favoriteFoodByFoodGroup - bind to property 'favoriteFoodByFoodGroup', presumably a Map<FoodGroup, Food>; e.g. allowing favoriteFoodByFoodGroup={ DAIRY=Milk, MEAT=Steak } and favoriteFoodByFoodGroup['DAIRY']=Milk
* favoriteFoodByFoodGroup.name - bind to property 'favoriteFoodByFoodGroup.name', for all keyed Foods in the map; e.g. allowing favoriteFoodByFoodGroup['DAIRY'].name=Milk
* </pre>
* @param propertyPath the model property path
* @return a BindingConfiguration object, allowing additional configuration of the newly added binding
* @throws IllegalArgumentException if no such property path exists on the model
*/
public BindingConfiguration addBinding(String propertyPath) {
DefaultBindingConfiguration configuration = new DefaultBindingConfiguration(propertyPath);
bindingFactories.add(new BindingFactory(configuration));
return configuration;
}
/**
* Register a Formatter to format the model properties of a specific property type.
* Convenience method that calls {@link FormatterRegistry#add(Class, Formatter)} internally.
* The type may be a marker annotation type; if so, the Formatter will be used on properties having that marker annotation.
* @param propertyType the model property type
* @param formatter the formatter
*/
public void registerFormatter(Class<?> propertyType, Formatter<?> formatter) {
formatterRegistry.add(propertyType, formatter);
}
/**
* Register a Formatter to format the model properties of a specific property type.
* Convenience method that calls {@link FormatterRegistry#add(GenericCollectionPropertyType, Formatter)} internally.
* @param propertyType the model property type
* @param formatter the formatter
*/
public void registerFormatter(GenericCollectionPropertyType propertyType, Formatter<?> formatter) {
formatterRegistry.add(propertyType, formatter);
}
/**
* Register a FormatterFactory that creates Formatter instances as required to format model properties annotated with a specific annotation.
* Convenience method that calls {@link FormatterRegistry#add(AnnotationFormatterFactory)} internally.
* @param factory the formatter factory
*/
public void registerFormatterFactory(AnnotationFormatterFactory<?, ?> factory) {
formatterRegistry.add(factory);
}
/**
* Configures the registry of Formatters to query when no explicit Formatter has been registered for a Binding.
* Allows Formatters to be applied by property type and by property annotation.
* @param registry the formatter registry
*/
public void setFormatterRegistry(FormatterRegistry formatterRegistry) {
Assert.notNull(formatterRegistry, "The FormatterRegistry is required");
this.formatterRegistry = formatterRegistry;
}
/**
* Configure the MessageSource that resolves localized {@link BindingResult} alert messages.
* @param messageSource the message source
@ -190,44 +70,53 @@ public class GenericBinder implements Binder {
* For a setValue attempt, the TypeConverter will be asked to perform a conversion if the value parsed by the Binding's Formatter is not assignable to the target property type.
* For a getValue attempt, the TypeConverter will be asked to perform a conversion if the property type does not match the type T required by the Binding's Formatter.
* @param typeConverter the type converter used by the binding system, which is based on Spring EL
* @see EvaluationContext#getTypeConverter()
*/
public void setTypeConverter(TypeConverter typeConverter) {
Assert.notNull(messageSource, "The TypeConverter is required");
Assert.notNull(typeConverter, "The TypeConverter is required");
this.typeConverter = typeConverter;
}
// implementing BindingFactory
// implementing Binder
public Object getModel() {
return model;
}
public Binding getBinding(String property) {
for (BindingFactory factory: bindingFactories) {
if (factory.hasBindingFor(property)) {
return factory.getBinding(property);
PropertyPath path = new PropertyPath(property);
Binding binding = bindings.get(path.getFirstElement().getValue());
if (binding == null) {
binding = new PropertyBinding(path.getFirstElement().getValue(), model, typeConverter);
bindings.put(path.getFirstElement().getValue(), binding);
}
for (PropertyPathElement element : path.getNestedElements()) {
if (element.isIndex()) {
if (binding.isMap()) {
binding = binding.getKeyedBinding(element.getValue());
} else if (binding.isIndexable()) {
binding = binding.getIndexedBinding(element.getIntValue());
} else {
throw new IllegalArgumentException("Attempted to index a property that is not a Collection or Map");
}
} else {
binding = binding.getBinding(element.getValue());
}
}
throw new NoSuchBindingException(property);
return binding;
}
// implementing Binder
public BindingResults bind(Map<String, ? extends Object> sourceValues) {
sourceValues = filter(sourceValues);
checkRequired(sourceValues);
ArrayListBindingResults results = new ArrayListBindingResults(sourceValues.size());
for (Map.Entry<String, ? extends Object> sourceValue : sourceValues.entrySet()) {
String property = sourceValue.getKey();
Object value = sourceValue.getValue();
results.add(getBinding(property).setValue(value));
Binding binding = getBinding(sourceValue.getKey());
results.add(bind(sourceValue, binding));
}
return results;
}
// subclassing hooks
/**
* Hook subclasses may use to filter the source values to bind.
* This hook allows the binder to pre-process the source values before binding occurs.
@ -241,549 +130,19 @@ public class GenericBinder implements Binder {
}
// internal helpers
private void checkRequired(Map<String, ? extends Object> sourceValues) {
List<String> missingRequired = new ArrayList<String>();
for (BindingFactory factory : bindingFactories) {
if (factory.configuration.isRequired()) {
boolean found = false;
for (String property : sourceValues.keySet()) {
if (factory.hasBindingFor(property)) {
found = true;
}
}
if (!found) {
missingRequired.add(factory.getPropertyPath());
}
private BindingResult bind(Map.Entry<String, ? extends Object> sourceValue, Binding binding) {
String property = sourceValue.getKey();
Object value = sourceValue.getValue();
if (binding.isReadOnly()) {
return new PropertyNotWriteableResult(property, value, messageSource);
} else {
binding.applySourceValue(value);
if (binding.isValid()) {
binding.commit();
}
}
if (!missingRequired.isEmpty()) {
throw new MissingSourceValuesException(missingRequired, sourceValues);
return new BindingStatusResult(property, value, binding.getStatusAlert());
}
}
private EvaluationContext createEvaluationContext() {
StandardEvaluationContext context = new StandardEvaluationContext();
context.setRootObject(model);
context.addPropertyAccessor(new MapAccessor());
context.setTypeConverter(new StandardTypeConverter(typeConverter));
return context;
}
public class BindingFactory {
private DefaultBindingConfiguration configuration;
public BindingFactory(DefaultBindingConfiguration configuration) {
this.configuration = configuration;
}
public String getPropertyPath() {
return configuration.getPropertyPath();
}
public boolean hasBindingFor(String property) {
String propertyPath = propertyPath(property);
return configuration.getPropertyPath().equals(propertyPath);
}
public Binding getBinding(String property) {
Expression propertyExpression;
try {
propertyExpression = expressionParser.parseExpression(property);
} catch (org.springframework.expression.ParseException e) {
throw new IllegalArgumentException(
"Unable to get model binding; cannot parse property expression from property string ["
+ property + "]", e);
}
return new BindingImpl(propertyExpression, configuration.getFormatter());
}
private String propertyPath(String property) {
StringBuilder sb = new StringBuilder(property);
int searchIndex = 0;
while (searchIndex != -1) {
int keyStart = sb.indexOf("[", searchIndex);
searchIndex = -1;
if (keyStart != -1) {
int keyEnd = sb.indexOf("]", keyStart + 1);
if (keyEnd != -1) {
sb.delete(keyStart, keyEnd + 1);
searchIndex = keyEnd + 1;
}
}
}
return sb.toString();
}
}
class BindingImpl implements Binding {
private Expression property;
private Formatter formatter;
public BindingImpl(Expression property, Formatter formatter) {
this.property = property;
this.formatter = formatter;
}
// implementing Binding
public String getProperty() {
return property.getExpressionString();
}
public String getValue() {
Object value;
try {
value = property.getValue(createEvaluationContext());
} catch (ExpressionException e) {
throw new IllegalStateException("Failed to get property expression value - this should not happen", e);
}
// TODO if collection we want to format as a single string, need collection formatter
return format(value);
}
public BindingResult setValue(Object value) {
if (value instanceof String) {
return setStringValue((String) value);
} else if (value instanceof String[]) {
return setStringValues((String[]) value);
} else {
return setObjectValue(value);
}
}
public String format(Object selectableValue) {
Formatter formatter = getFormatter();
Class<?> formattedType = getFormattedObjectType(formatter.getClass());
selectableValue = typeConverter.convert(selectableValue, formattedType);
return formatter.format(selectableValue, LocaleContextHolder.getLocale());
}
public boolean isCollection() {
Class type = getType();
TypeDescriptor<?> typeDesc = TypeDescriptor.valueOf(type);
return typeDesc.isCollection() || typeDesc.isArray();
}
public String[] getCollectionValues() {
Object multiValue;
try {
multiValue = property.getValue(createEvaluationContext());
} catch (EvaluationException e) {
throw new IllegalStateException("Failed to get property expression value - this should not happen", e);
}
if (multiValue == null) {
return EMPTY_STRING_ARRAY;
}
TypeDescriptor<?> type = TypeDescriptor.valueOf(multiValue.getClass());
String[] formattedValues;
if (type.isCollection()) {
Collection<?> values = ((Collection<?>) multiValue);
formattedValues = (String[]) Array.newInstance(String.class, values.size());
copy(values, formattedValues);
} else if (type.isArray()) {
formattedValues = (String[]) Array.newInstance(String.class, Array.getLength(multiValue));
copy((Iterable<?>) multiValue, formattedValues);
} else {
throw new IllegalStateException();
}
return formattedValues;
}
// public impl only
public Class<?> getType() {
Class<?> type;
try {
type = property.getValueType(createEvaluationContext());
} catch (EvaluationException e) {
throw new IllegalArgumentException(
"Failed to get property expression value type - this should not happen", e);
}
return type;
}
// internal helpers
private BindingResult setStringValue(String formatted) {
Object parsed;
try {
// if binding to a collection we may want collection formatter to convert String to Collection
// alternatively, we could map value to a single element e.g. String -> Address via AddressFormatter, which would bind to addresses[0]
// probably want to give preference to collection formatter if one is registered
Formatter formatter = getFormatter();
parsed = formatter.parse(formatted, LocaleContextHolder.getLocale());
} catch (ParseException e) {
return new InvalidFormat(property.getExpressionString(), formatted, e);
}
return setValue(parsed, formatted);
}
private BindingResult setStringValues(String[] formatted) {
Formatter formatter = getFormatter();
Class parsedType = getFormattedObjectType(formatter.getClass());
if (parsedType == null) {
parsedType = String.class;
}
Object parsed = Array.newInstance(parsedType, formatted.length);
for (int i = 0; i < formatted.length; i++) {
Object parsedValue;
try {
parsedValue = formatter.parse(formatted[i], LocaleContextHolder.getLocale());
} catch (ParseException e) {
return new InvalidFormat(property.getExpressionString(), formatted, e);
}
Array.set(parsed, i, parsedValue);
}
return setValue(parsed, formatted);
}
private BindingResult setObjectValue(Object value) {
return setValue(value, value);
}
private Formatter getFormatter() {
if (formatter != null) {
return formatter;
} else {
TypeDescriptor type;
try {
type = property.getValueTypeDescriptor(createEvaluationContext());
} catch (EvaluationException e) {
throw new IllegalArgumentException(
"Failed to get property expression value type descriptor - this should not happen", e);
}
Formatter formatter = formatterRegistry.getFormatter(type);
return formatter != null ? formatter : defaultFormatter;
}
}
private void copy(Iterable<?> values, String[] formattedValues) {
int i = 0;
for (Object value : values) {
formattedValues[i] = format(value);
i++;
}
}
private BindingResult setValue(Object parsedValue, Object userValue) {
try {
property.setValue(createEvaluationContext(), parsedValue);
return new Success(property.getExpressionString(), userValue);
} catch (EvaluationException e) {
return new EvaluationError(property.getExpressionString(), userValue, e);
}
}
private Class getFormattedObjectType(Class formatterClass) {
// TODO consider caching this info
Class classToIntrospect = formatterClass;
while (classToIntrospect != null) {
Type[] ifcs = classToIntrospect.getGenericInterfaces();
for (Type ifc : ifcs) {
if (ifc instanceof ParameterizedType) {
ParameterizedType paramIfc = (ParameterizedType) ifc;
Type rawType = paramIfc.getRawType();
if (Formatter.class.equals(rawType)) {
Type arg = paramIfc.getActualTypeArguments()[0];
if (arg instanceof TypeVariable) {
arg = GenericTypeResolver.resolveTypeVariable((TypeVariable) arg, formatterClass);
}
if (arg instanceof Class) {
return (Class) arg;
}
}
else if (ApplicationListener.class.isAssignableFrom((Class) rawType)) {
return getFormattedObjectType((Class) rawType);
}
}
else if (ApplicationListener.class.isAssignableFrom((Class) ifc)) {
return getFormattedObjectType((Class) ifc);
}
}
classToIntrospect = classToIntrospect.getSuperclass();
}
return null;
}
}
static class DefaultFormatter implements Formatter {
public String format(Object object, Locale locale) {
if (object == null) {
return "";
} else {
return object.toString();
}
}
public Object parse(String formatted, Locale locale) throws ParseException {
if (formatted == "") {
return null;
} else {
return formatted;
}
}
}
static class ArrayListBindingResults implements BindingResults {
private List<BindingResult> results;
public ArrayListBindingResults() {
results = new ArrayList<BindingResult>();
}
public ArrayListBindingResults(int size) {
results = new ArrayList<BindingResult>(size);
}
public void add(BindingResult result) {
results.add(result);
}
// implementing Iterable
public Iterator<BindingResult> iterator() {
return results.iterator();
}
// implementing BindingResults
public BindingResults successes() {
ArrayListBindingResults results = new ArrayListBindingResults();
for (BindingResult result : this) {
if (!result.isFailure()) {
results.add(result);
}
}
return results;
}
public BindingResults failures() {
ArrayListBindingResults results = new ArrayListBindingResults();
for (BindingResult result : this) {
if (result.isFailure()) {
results.add(result);
}
}
return results;
}
public BindingResult get(int index) {
return results.get(index);
}
public List<String> properties() {
List<String> properties = new ArrayList<String>(results.size());
for (BindingResult result : this) {
properties.add(result.getProperty());
}
return properties;
}
public int size() {
return results.size();
}
public String toString() {
return "[BindingResults = " + results.toString() + "]";
}
}
class InvalidFormat implements BindingResult {
private String property;
private Object sourceValue;
private ParseException cause;
public InvalidFormat(String property, Object sourceValue, ParseException cause) {
this.property = property;
this.sourceValue = sourceValue;
this.cause = cause;
}
public String getProperty() {
return property;
}
public Object getSourceValue() {
return sourceValue;
}
public boolean isFailure() {
return true;
}
public Alert getAlert() {
return new AbstractAlert() {
public String getCode() {
return "invalidFormat";
}
public Severity getSeverity() {
return Severity.ERROR;
}
public String getMessage() {
MessageBuilder builder = new MessageBuilder(messageSource);
builder.code(getCode());
builder.arg("label", new ResolvableArgument(property));
builder.arg("value", sourceValue);
builder.arg("errorOffset", cause.getErrorOffset());
builder.defaultMessage("Failed to bind to property '" + property + "'; the user value "
+ StylerUtils.style(sourceValue) + " has an invalid format and could no be parsed");
return builder.build();
}
};
}
public String toString() {
return getAlert().toString();
}
}
class Success implements BindingResult {
private String property;
private Object sourceValue;
public Success(String property, Object sourceValue) {
this.property = property;
this.sourceValue = sourceValue;
}
public String getProperty() {
return property;
}
public Object getSourceValue() {
return sourceValue;
}
public boolean isFailure() {
return false;
}
public Alert getAlert() {
return new AbstractAlert() {
public String getCode() {
return "bindSuccess";
}
public Severity getSeverity() {
return Severity.INFO;
}
public String getMessage() {
MessageBuilder builder = new MessageBuilder(messageSource);
builder.code("bindSuccess");
builder.arg("label", new ResolvableArgument(property));
builder.arg("value", sourceValue);
builder.defaultMessage("Successfully bound user value " + StylerUtils.style(sourceValue)
+ " to property '" + property + "'");
return builder.build();
}
};
}
public String toString() {
return getAlert().toString();
}
}
class EvaluationError implements BindingResult {
private String property;
private Object sourceValue;
private EvaluationException cause;
public EvaluationError(String property, Object sourceValue, EvaluationException cause) {
this.property = property;
this.sourceValue = sourceValue;
this.cause = cause;
}
public String getProperty() {
return property;
}
public Object getSourceValue() {
return sourceValue;
}
public boolean isFailure() {
return true;
}
public Alert getAlert() {
return new AbstractAlert() {
public String getCode() {
SpelMessage spelCode = ((SpelEvaluationException) cause).getMessageCode();
if (spelCode == SpelMessage.EXCEPTION_DURING_PROPERTY_WRITE) {
return "conversionFailed";
} else {
return "couldNotSetValue";
}
}
public Severity getSeverity() {
return Severity.FATAL;
}
public String getMessage() {
SpelMessage spelCode = ((SpelEvaluationException) cause).getMessageCode();
if (spelCode == SpelMessage.EXCEPTION_DURING_PROPERTY_WRITE) {
AccessException accessException = (AccessException) cause.getCause();
if (accessException.getCause() != null) {
Throwable cause = accessException.getCause();
if (cause instanceof SpelEvaluationException
&& ((SpelEvaluationException) cause).getMessageCode() == SpelMessage.TYPE_CONVERSION_ERROR) {
// TODO this could be a ConverterExecutorNotFoundException if no suitable converter was found
cause.getCause().printStackTrace();
ConversionFailedException failure = (ConversionFailedException) cause.getCause();
MessageBuilder builder = new MessageBuilder(messageSource);
builder.code("conversionFailed");
builder.arg("label", new ResolvableArgument(property));
builder.arg("value", sourceValue);
builder.defaultMessage("Failed to bind to property '" + property + "'; user value "
+ StylerUtils.style(sourceValue) + " could not be converted to property type ["
+ failure.getTargetType().getName() + "]");
return builder.build();
}
}
}
MessageBuilder builder = new MessageBuilder(messageSource);
builder.code("couldNotSetValue");
builder.arg("label", new ResolvableArgument(property));
builder.arg("value", sourceValue);
builder.defaultMessage("Failed to bind to property '" + property + "'; reason = "
+ cause.getLocalizedMessage());
return builder.build();
}
};
}
public String toString() {
return getAlert().toString();
}
}
static abstract class AbstractAlert implements Alert {
public String toString() {
return getCode() + " - " + getMessage();
}
}
}

307
org.springframework.context/src/main/java/org/springframework/ui/binding/support/PropertyBinding.java Normal file
View File

@ -0,0 +1,307 @@
/**
*
*/
package org.springframework.ui.binding.support;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.text.ParseException;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.core.GenericCollectionTypeResolver;
import org.springframework.core.GenericTypeResolver;
import org.springframework.core.MethodParameter;
import org.springframework.core.convert.TypeConverter;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.ui.alert.Alert;
import org.springframework.ui.binding.Binding;
import org.springframework.ui.format.Formatter;
import org.springframework.util.ReflectionUtils;
@SuppressWarnings("unchecked")
public class PropertyBinding implements Binding {
private String property;
private Object model;
private Formatter valueFormatter = DefaultFormatter.INSTANCE;
private Formatter mapKeyFormatter = DefaultFormatter.INSTANCE;
private Formatter indexedValueFormatter = DefaultFormatter.INSTANCE;
private PropertyDescriptor propertyDescriptor;
private TypeConverter typeConverter;
private Object sourceValue;
// TODO make a ValueBuffer
private Object bufferedValue;
public PropertyBinding(String property, Object model, TypeConverter typeConverter) {
this.propertyDescriptor = findPropertyDescriptor(property, model);
this.property = property;
this.model = model;
this.typeConverter = typeConverter;
}
public Object getValue() {
if (isDirty()) {
// TODO null check isn't good enough
if (bufferedValue != null) {
return formatValue(bufferedValue);
} else {
return sourceValue;
}
} else {
return formatValue(getModel().getValue());
}
}
public void applySourceValue(Object sourceValue) {
if (isReadOnly()) {
throw new IllegalStateException("Property is read-only");
}
this.sourceValue = sourceValue;
if (sourceValue instanceof String) {
try {
this.bufferedValue = valueFormatter.parse((String) sourceValue, getLocale());
} catch (ParseException e) {
}
} else if (sourceValue instanceof String[]) {
String[] sourceValues = (String[]) sourceValue;
Class<?> parsedType = getFormattedObjectType(indexedValueFormatter.getClass());
if (parsedType == null) {
parsedType = String.class;
}
Object parsed = Array.newInstance(parsedType, sourceValues.length);
boolean parseError = false;
for (int i = 0; i < sourceValues.length; i++) {
Object parsedValue;
try {
parsedValue = indexedValueFormatter.parse(sourceValues[i], LocaleContextHolder.getLocale());
Array.set(parsed, i, parsedValue);
} catch (ParseException e) {
parseError = true;
}
}
if (!parseError) {
bufferedValue = parsed;
}
}
}
public boolean isDirty() {
return sourceValue != null || bufferedValue != null;
}
public boolean isValid() {
if (!isDirty()) {
return true;
} else {
if (bufferedValue == null) {
return false;
} else {
return true;
}
}
}
public void commit() {
if (!isDirty()) {
throw new IllegalStateException("Binding not dirty; nothing to commit");
}
if (!isValid()) {
throw new IllegalStateException("Binding is invalid; only commit valid bindings");
}
try {
getModel().setValue(bufferedValue);
this.bufferedValue = null;
} catch (Exception e) {
}
}
public Model getModel() {
return new Model() {
public Object getValue() {
return ReflectionUtils.invokeMethod(propertyDescriptor.getReadMethod(), model);
}
public Class<?> getValueType() {
return propertyDescriptor.getPropertyType();
}
public void setValue(Object value) {
if (isReadOnly()) {
throw new IllegalStateException("Property is read-only");
}
TypeDescriptor targetType = new TypeDescriptor(new MethodParameter(propertyDescriptor.getWriteMethod(), 0));
if (value != null && typeConverter.canConvert(value.getClass(), targetType)) {
value = typeConverter.convert(value, targetType);
}
ReflectionUtils.invokeMethod(propertyDescriptor.getWriteMethod(), model, value);
}
};
}
public Alert getStatusAlert() {
return null;
}
public Binding getBinding(String nestedProperty) {
assertScalarProperty();
if (getValue() == null) {
createValue();
}
return new PropertyBinding(nestedProperty, getValue(), typeConverter);
}
public boolean isIndexable() {
return getModel().getValueType().isArray() || List.class.isAssignableFrom(getModel().getValueType());
}
public Binding getIndexedBinding(int index) {
assertListProperty();
//return new IndexedBinding(index, (List) getValue(), getCollectionTypeDescriptor(), typeConverter);
return null;
}
public boolean isMap() {
return Map.class.isAssignableFrom(getModel().getValueType());
}
public Binding getKeyedBinding(Object key) {
assertMapProperty();
if (key instanceof String) {
try {
key = mapKeyFormatter.parse((String) key, getLocale());
} catch (ParseException e) {
throw new IllegalArgumentException("Invald key", e);
}
}
//TODO return new KeyedPropertyBinding(key, (Map) getValue(), getMapTypeDescriptor());
return null;
}
public boolean isReadOnly() {
return propertyDescriptor.getWriteMethod() != null && !markedNotEditable();
}
public String formatValue(Object value) {
Class<?> formattedType = getFormattedObjectType(valueFormatter.getClass());
value = typeConverter.convert(value, formattedType);
return valueFormatter.format(value, getLocale());
}
// internal helpers
private PropertyDescriptor findPropertyDescriptor(String property, Object model) {
PropertyDescriptor[] propDescs = getBeanInfo(model.getClass()).getPropertyDescriptors();
for (PropertyDescriptor propDesc : propDescs) {
if (propDesc.getName().equals(property)) {
return propDesc;
}
}
throw new IllegalArgumentException("No property '" + property + "' found on model ["
+ model.getClass().getName() + "]");
}
private BeanInfo getBeanInfo(Class<?> clazz) {
try {
return Introspector.getBeanInfo(clazz);
} catch (IntrospectionException e) {
throw new IllegalStateException("Unable to introspect model type " + clazz);
}
}
private Locale getLocale() {
return LocaleContextHolder.getLocale();
}
private void createValue() {
try {
Object value = getModel().getValueType().newInstance();
getModel().setValue(value);
} catch (InstantiationException e) {
throw new IllegalStateException("Could not lazily instantiate model of type [" + getModel().getValueType().getName()
+ "] to access property" + property, e);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Could not lazily instantiate model of type [" + getModel().getValueType().getName()
+ "] to access property" + property, e);
}
}
private Class getFormattedObjectType(Class formatterClass) {
Class classToIntrospect = formatterClass;
while (classToIntrospect != null) {
Type[] ifcs = classToIntrospect.getGenericInterfaces();
for (Type ifc : ifcs) {
if (ifc instanceof ParameterizedType) {
ParameterizedType paramIfc = (ParameterizedType) ifc;
Type rawType = paramIfc.getRawType();
if (Formatter.class.equals(rawType)) {
Type arg = paramIfc.getActualTypeArguments()[0];
if (arg instanceof TypeVariable) {
arg = GenericTypeResolver.resolveTypeVariable((TypeVariable) arg, formatterClass);
}
if (arg instanceof Class) {
return (Class) arg;
}
} else if (Formatter.class.isAssignableFrom((Class) rawType)) {
return getFormattedObjectType((Class) rawType);
}
} else if (Formatter.class.isAssignableFrom((Class) ifc)) {
return getFormattedObjectType((Class) ifc);
}
}
classToIntrospect = classToIntrospect.getSuperclass();
}
return null;
}
@SuppressWarnings("unused")
private CollectionTypeDescriptor getCollectionTypeDescriptor() {
Class<?> elementType = GenericCollectionTypeResolver.getCollectionReturnType(propertyDescriptor
.getReadMethod());
return new CollectionTypeDescriptor(getModel().getValueType(), elementType);
}
private void assertScalarProperty() {
if (isIndexable()) {
throw new IllegalArgumentException("Is a Collection but should be a scalar");
}
if (isMap()) {
throw new IllegalArgumentException("Is a Map but should be a scalar");
}
}
private void assertListProperty() {
if (!isIndexable()) {
throw new IllegalStateException("Not a List property binding");
}
}
private void assertMapProperty() {
if (!isIndexable()) {
throw new IllegalStateException("Not a Map property binding");
}
}
private boolean markedNotEditable() {
return false;
}
}

67
org.springframework.context/src/main/java/org/springframework/ui/binding/support/PropertyNotWriteableResult.java Normal file
View File

@ -0,0 +1,67 @@
/**
*
*/
package org.springframework.ui.binding.support;
import org.springframework.context.MessageSource;
import org.springframework.core.style.StylerUtils;
import org.springframework.ui.alert.Alert;
import org.springframework.ui.alert.Severity;
import org.springframework.ui.binding.BindingResult;
import org.springframework.ui.message.MessageBuilder;
import org.springframework.ui.message.ResolvableArgument;
class PropertyNotWriteableResult implements BindingResult {
private String property;
private Object sourceValue;
private MessageSource messageSource;
public PropertyNotWriteableResult(String property, Object sourceValue, MessageSource messageSource) {
this.property = property;
this.sourceValue = sourceValue;
this.messageSource = messageSource;
}
public String getProperty() {
return property;
}
public Object getSourceValue() {
return sourceValue;
}
public boolean isFailure() {
return true;
}
public Alert getAlert() {
return new Alert() {
public String getCode() {
return "propertyNotWriteable";
}
public Severity getSeverity() {
return Severity.WARNING;
}
public String getMessage() {
MessageBuilder builder = new MessageBuilder(messageSource);
builder.code("bindSuccess");
builder.arg("label", new ResolvableArgument(property));
builder.arg("value", sourceValue);
// TODO lazily create default message
builder.defaultMessage("Successfully bound user value " + StylerUtils.style(sourceValue)
+ " to property '" + property + "'");
return builder.build();
}
};
}
public String toString() {
return getAlert().toString();
}
}

44
org.springframework.context/src/main/java/org/springframework/ui/binding/support/PropertyPath.java Normal file
View File

@ -0,0 +1,44 @@
/**
*
*/
package org.springframework.ui.binding.support;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class PropertyPath {
private List<PropertyPathElement> elements = new ArrayList<PropertyPathElement>();
public PropertyPath(String propertyPath) {
// a.b.c[i].d[key].e
String[] props = propertyPath.split("\\.");
if (props.length == 0) {
props = new String[] { propertyPath };
}
for (String prop : props) {
if (prop.startsWith("[")) {
int end = prop.indexOf(']');
String index = prop.substring(0, end);
elements.add(new PropertyPathElement(index, true));
} else {
elements.add(new PropertyPathElement(prop, false));
}
}
}
public PropertyPathElement getFirstElement() {
return elements.get(0);
}
public List<PropertyPathElement> getNestedElements() {
if (elements.size() > 1) {
return elements.subList(1, elements.size() - 1);
} else {
return Collections.emptyList();
}
}
}

28
org.springframework.context/src/main/java/org/springframework/ui/binding/support/PropertyPathElement.java Normal file
View File

@ -0,0 +1,28 @@
/**
*
*/
package org.springframework.ui.binding.support;
public class PropertyPathElement {
private String value;
private boolean index;
public PropertyPathElement(String value, boolean index) {
this.value = value;
this.index = index;
}
public boolean isIndex() {
return index;
}
public String getValue() {
return value;
}
public int getIntValue() {
return Integer.parseInt(value);
}
}

6
org.springframework.context/src/main/java/org/springframework/ui/binding/support/WebBinder.java
View File

@ -72,7 +72,7 @@ public class WebBinder extends GenericBinder {
} else if (field.startsWith(presentPrefix)) {
field = field.substring(presentPrefix.length());
if (!sourceValues.containsKey(field) && !sourceValues.containsKey(defaultPrefix + field)) {
value = getEmptyValue((BindingImpl) getBinding(field));
value = getEmptyValue((PropertyBinding) getBinding(field));
filteredValues.put(field, value);
}
} else {
@ -82,8 +82,8 @@ public class WebBinder extends GenericBinder {
return filteredValues;
}
protected Object getEmptyValue(BindingImpl binding) {
Class<?> type = binding.getType();
protected Object getEmptyValue(PropertyBinding binding) {
Class<?> type = binding.getModel().getValueType();
if (boolean.class.equals(type) || Boolean.class.equals(type)) {
return Boolean.FALSE;
} else {

85
org.springframework.context/src/main/java/org/springframework/ui/lifecycle/BindAndValidateLifecycle.java
View File

@ -1,88 +1,7 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.ui.lifecycle;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public interface BindAndValidateLifecycle {
import org.springframework.ui.alert.AlertContext;
import org.springframework.ui.binding.Binder;
import org.springframework.ui.binding.BindingResult;
import org.springframework.ui.binding.BindingResults;
import org.springframework.ui.validation.ValidationFailure;
import org.springframework.ui.validation.Validator;
/**
* Implementation of the model bind and validate lifecycle.
* @author Keith Donald
* @since 3.0
*/
public final class BindAndValidateLifecycle {
private Binder binder;
private Validator validator;
private ValidationDecider validationDecider = ValidationDecider.ALWAYS_VALIDATE;
private final AlertContext alertContext;
/**
* Create a new bind and validate lifecycle.
* @param binder the binder to use for model binding
* @param validator the validator to use for model validation
* @param alertContext a context for adding binding and validation-related alerts
*/
public BindAndValidateLifecycle(Binder binder, Validator validator, AlertContext alertContext) {
this.binder = binder;
this.validator = validator;
this.alertContext = alertContext;
}
public void execute();
/**
* Configures the strategy that determines if validation should execute after binding.
* @param validationDecider the validation decider
*/
public void setValidationDecider(ValidationDecider validationDecider) {
this.validationDecider = validationDecider;
}
/**
* Execute the bind and validate lifecycle.
* Any bind or validation errors are recorded as alerts against the {@link AlertContext}.
* @param sourceValues the source values to bind and validate
*/
public void execute(Map<String, ? extends Object> sourceValues) {
BindingResults bindingResults = binder.bind(sourceValues);
List<ValidationFailure> validationFailures = validate(bindingResults);
for (BindingResult result : bindingResults.failures()) {
alertContext.add(result.getProperty(), result.getAlert());
}
for (ValidationFailure failure : validationFailures) {
alertContext.add(failure.getProperty(), failure.getAlert());
}
}
private List<ValidationFailure> validate(BindingResults bindingResults) {
if (validator != null && validationDecider.shouldValidateAfter(bindingResults)) {
return validator.validate(binder.getModel(), bindingResults.successes().properties());
} else {
return Collections.emptyList();
}
}
}

5
org.springframework.context/src/main/java/org/springframework/ui/lifecycle/BindAndValidateLifecycleFactory.java Normal file
View File

@ -0,0 +1,5 @@
package org.springframework.ui.lifecycle;
public interface BindAndValidateLifecycleFactory {
BindAndValidateLifecycle getLifecycle(Object model);
}

88
org.springframework.context/src/main/java/org/springframework/ui/lifecycle/BindAndValidateLifecycleImpl.java Normal file
View File

@ -0,0 +1,88 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.ui.lifecycle;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.springframework.ui.alert.AlertContext;
import org.springframework.ui.binding.Binder;
import org.springframework.ui.binding.BindingResult;
import org.springframework.ui.binding.BindingResults;
import org.springframework.ui.validation.ValidationFailure;
import org.springframework.ui.validation.Validator;
/**
* Implementation of the model bind and validate lifecycle.
* @author Keith Donald
* @since 3.0
*/
public final class BindAndValidateLifecycleImpl {
private Binder binder;
private Validator validator;
private ValidationDecider validationDecider = ValidationDecider.ALWAYS_VALIDATE;
private final AlertContext alertContext;
/**
* Create a new bind and validate lifecycle.
* @param binder the binder to use for model binding
* @param validator the validator to use for model validation
* @param alertContext a context for adding binding and validation-related alerts
*/
public BindAndValidateLifecycleImpl(Binder binder, Validator validator, AlertContext alertContext) {
this.binder = binder;
this.validator = validator;
this.alertContext = alertContext;
}
/**
* Configures the strategy that determines if validation should execute after binding.
* @param validationDecider the validation decider
*/
public void setValidationDecider(ValidationDecider validationDecider) {
this.validationDecider = validationDecider;
}
/**
* Execute the bind and validate lifecycle.
* Any bind or validation errors are recorded as alerts against the {@link AlertContext}.
* @param sourceValues the source values to bind and validate
*/
public void execute(Map<String, ? extends Object> sourceValues) {
BindingResults bindingResults = binder.bind(sourceValues);
List<ValidationFailure> validationFailures = validate(bindingResults);
for (BindingResult result : bindingResults.failures()) {
alertContext.add(result.getProperty(), result.getAlert());
}
for (ValidationFailure failure : validationFailures) {
alertContext.add(failure.getProperty(), failure.getAlert());
}
}
private List<ValidationFailure> validate(BindingResults bindingResults) {
if (validator != null && validationDecider.shouldValidateAfter(bindingResults)) {
return validator.validate(binder.getModel(), bindingResults.successes().properties());
} else {
return Collections.emptyList();
}
}
}

2
org.springframework.context/src/main/java/org/springframework/ui/lifecycle/ValidationDecider.java
View File

@ -21,7 +21,7 @@ import org.springframework.ui.binding.BindingResults;
* Decides if validation should run for an execution of the bind and validate lifecycle.
* @author Keith Donald
* @since 3.0
* @see BindAndValidateLifecycle#execute(java.util.Map)
* @see BindAndValidateLifecycleImpl#execute(java.util.Map)
*/
interface ValidationDecider {

314
org.springframework.context/src/test/java/org/springframework/ui/binding/config/BindingRuleBuilderTests.java Normal file
View File

@ -0,0 +1,314 @@
package org.springframework.ui.binding.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.math.BigDecimal;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.junit.Ignore;
import org.junit.Test;
import org.springframework.ui.format.Formatter;
import org.springframework.ui.format.number.CurrencyFormatter;
public class BindingRuleBuilderTests {
@Test
@Ignore
public void createBindingRules() {
BindingRulesBuilder builder = new BindingRulesBuilder(TestBean.class);
// TODO ability to add nested rules?
// TODO ability to format map keys and values?
builder.bind("string");
builder.bind("integer").required();
builder.bind("currency").formatWith(new CurrencyFormatter()).required();
builder.bind("addresses").formatWith(new AddressListFormatter()).formatElementsWith(new AddressFormatter()).required();
builder.bind("addresses.street");
builder.bind("addresses.city");
builder.bind("addresses.state");
builder.bind("addresses.zip");
builder.bind("favoriteFoodsByGroup").formatWith(new FavoriteFoodGroupMapFormatter()).formatElementsWith(new FoodEntryFormatter());
builder.bind("favoriteFoodsByGroup.name");
List<BindingRule> rules = builder.getBindingRules();
assertEquals(10, rules.size());
assertEquals("string", rules.get(0).getPropertyPath());
assertNull(rules.get(0).getFormatter());
assertFalse(rules.get(0).isRequired());
assertFalse(rules.get(0).isCollectionBinding());
assertNull(rules.get(0).getValueFormatter());
assertEquals("integer", rules.get(1).getPropertyPath());
assertNull(rules.get(1).getFormatter());
assertTrue(rules.get(1).isRequired());
assertFalse(rules.get(1).isCollectionBinding());
assertNull(rules.get(1).getValueFormatter());
assertEquals("currency", rules.get(2).getPropertyPath());
assertTrue(rules.get(2).getFormatter() instanceof CurrencyFormatter);
assertFalse(rules.get(2).isRequired());
assertFalse(rules.get(2).isCollectionBinding());
assertNull(rules.get(2).getValueFormatter());
assertEquals("addresses", rules.get(3).getPropertyPath());
assertTrue(rules.get(3).getFormatter() instanceof AddressListFormatter);
assertFalse(rules.get(3).isRequired());
assertTrue(rules.get(3).isCollectionBinding());
assertTrue(rules.get(3).getValueFormatter() instanceof AddressFormatter);
assertTrue(rules.get(8).getFormatter() instanceof FavoriteFoodGroupMapFormatter);
assertFalse(rules.get(8).isRequired());
assertTrue(rules.get(8).isCollectionBinding());
assertTrue(rules.get(8).getValueFormatter() instanceof FoodEntryFormatter);
}
@Test(expected=IllegalArgumentException.class)
public void createBindingRulesInvalidProperty() {
BindingRulesBuilder builder = new BindingRulesBuilder(TestBean.class);
builder.bind("bogus");
}
@Test(expected=IllegalArgumentException.class)
public void createBindingRulesInvalidNestedCollectionProperty() {
BindingRulesBuilder builder = new BindingRulesBuilder(TestBean.class);
builder.bind("addresses.bogus");
}
@Test(expected=IllegalArgumentException.class)
public void createBindingRulesInvalidNestedMapProperty() {
BindingRulesBuilder builder = new BindingRulesBuilder(TestBean.class);
builder.bind("favoriteFoodsByGroup.bogus");
}
public static enum FooEnum {
BAR, BAZ, BOOP;
}
public static enum FoodGroup {
DAIRY, VEG, FRUIT, BREAD, MEAT
}
public static class TestBean {
private String string;
private int integer;
private Date date;
private FooEnum foo;
private BigDecimal currency;
private List<FooEnum> foos;
private List<Address> addresses;
private Map<FoodGroup, Food> favoriteFoodsByGroup;
private Address primaryAddress;
public TestBean() {
}
public String getString() {
return string;
}
public void setString(String string) {
this.string = string;
}
public int getInteger() {
return integer;
}
public void setInteger(int integer) {
this.integer = integer;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public FooEnum getFoo() {
return foo;
}
public void setFoo(FooEnum foo) {
this.foo = foo;
}
public BigDecimal getCurrency() {
return currency;
}
public void setCurrency(BigDecimal currency) {
this.currency = currency;
}
public List<FooEnum> getFoos() {
return foos;
}
public void setFoos(List<FooEnum> foos) {
this.foos = foos;
}
public List<Address> getAddresses() {
return addresses;
}
public void setAddresses(List<Address> addresses) {
this.addresses = addresses;
}
public Map<FoodGroup, Food> getFavoriteFoodsByGroup() {
return favoriteFoodsByGroup;
}
public void setFavoriteFoodsByGroup(Map<FoodGroup, Food> favoriteFoodsByGroup) {
this.favoriteFoodsByGroup = favoriteFoodsByGroup;
}
public Address getPrimaryAddress() {
return primaryAddress;
}
public void setPrimaryAddress(Address primaryAddress) {
this.primaryAddress = primaryAddress;
}
}
public static class Food {
private String name;
public Food(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public static class Address {
private String street;
private String city;
private String state;
private String zip;
private String country;
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getZip() {
return zip;
}
public void setZip(String zip) {
this.zip = zip;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
}
public static class AddressFormatter implements Formatter<Address> {
public String format(Address address, Locale locale) {
return address.getStreet() + ":" + address.getCity() + ":" + address.getState() + ":" + address.getZip();
}
public Address parse(String formatted, Locale locale) throws ParseException {
Address address = new Address();
String[] fields = formatted.split(":");
address.setStreet(fields[0]);
address.setCity(fields[1]);
address.setState(fields[2]);
address.setZip(fields[3]);
return address;
}
}
public static class AddressListFormatter implements Formatter<List<Address>> {
public String format(List<Address> addresses, Locale locale) {
StringBuilder builder = new StringBuilder();
for (Address address : addresses) {
builder.append(new AddressFormatter().format(address, locale));
builder.append(",");
}
return builder.toString();
}
public List<Address> parse(String formatted, Locale locale) throws ParseException {
String[] fields = formatted.split(",");
List<Address> addresses = new ArrayList<Address>(fields.length);
for (String field : fields) {
addresses.add(new AddressFormatter().parse(field, locale));
}
return addresses;
}
}
public static class FavoriteFoodGroupMapFormatter implements Formatter<Map<FoodGroup, Food>> {
public String format(Map<FoodGroup, Food> map, Locale locale) {
StringBuilder builder = new StringBuilder();
return builder.toString();
}
public Map<FoodGroup, Food> parse(String formatted, Locale locale) throws ParseException {
Map<FoodGroup, Food> map = new HashMap<FoodGroup, Food>();
return map;
}
}
public static class FoodEntryFormatter implements Formatter<Map.Entry<FoodGroup, Food>> {
public String format(Map.Entry<FoodGroup, Food> food, Locale locale) {
return null;
}
public Map.Entry<FoodGroup, Food> parse(String formatted, Locale locale) throws ParseException {
return null;
}
}
}

62
org.springframework.context/src/test/java/org/springframework/ui/binding/support/GenericBinderTests.java
View File

@ -9,6 +9,7 @@ import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
@ -26,6 +27,7 @@ import org.springframework.ui.binding.BindingResult;
import org.springframework.ui.binding.BindingResults;
import org.springframework.ui.binding.MissingSourceValuesException;
import org.springframework.ui.binding.NoSuchBindingException;
import org.springframework.ui.binding.config.BindingRulesBuilder;
import org.springframework.ui.format.AnnotationFormatterFactory;
import org.springframework.ui.format.Formatted;
import org.springframework.ui.format.Formatter;
@ -41,12 +43,9 @@ public class GenericBinderTests {
private TestBean bean;
private GenericBinder binder;
@Before
public void setUp() {
bean = new TestBean();
binder = new GenericBinder(bean);
LocaleContextHolder.setLocale(Locale.US);
}
@ -55,12 +54,16 @@ public class GenericBinderTests {
LocaleContextHolder.setLocale(null);
}
@Test
public void testPlaceholder() {
}
/*
@Test
public void bindSingleValuesWithDefaultTypeConverterConversion() {
binder.addBinding("string");
binder.addBinding("integer");
binder.addBinding("foo");
GenericBinder binder = new GenericBinder(bean);
Map<String, String> values = new LinkedHashMap<String, String>();
values.put("string", "test");
values.put("integer", "3");
@ -87,10 +90,7 @@ public class GenericBinderTests {
@Test
public void bindSingleValuesWithDefaultTypeConversionFailure() {
binder.addBinding("string");
binder.addBinding("integer");
binder.addBinding("foo");
GenericBinder binder = new GenericBinder(bean);
Map<String, String> values = new LinkedHashMap<String, String>();
values.put("string", "test");
// bad value
@ -104,14 +104,20 @@ public class GenericBinderTests {
@Test
public void bindSingleValuePropertyFormatter() throws ParseException {
binder.addBinding("date").formatWith(new DateFormatter());
BindingRulesBuilder builder = new BindingRulesBuilder(TestBean.class);
builder.bind("date").formatWith(new DateFormatter());;
GenericBinder binder = new GenericBinder(bean, builder.getBindingRules());
binder.bind(Collections.singletonMap("date", "2009-06-01"));
assertEquals(new DateFormatter().parse("2009-06-01", Locale.US), bean.getDate());
}
@Test
public void bindSingleValuePropertyFormatterParseException() {
binder.addBinding("date").formatWith(new DateFormatter());
BindingRulesBuilder builder = new BindingRulesBuilder(TestBean.class);
builder.bind("date").formatWith(new DateFormatter());
GenericBinder binder = new GenericBinder(bean, builder.getBindingRules());
BindingResults results = binder.bind(Collections.singletonMap("date", "bogus"));
assertEquals(1, results.size());
assertTrue(results.get(0).isFailure());
@ -120,22 +126,17 @@ public class GenericBinderTests {
@Test
public void bindSingleValueWithFormatterRegistedByType() throws ParseException {
binder.addBinding("date");
binder.registerFormatter(Date.class, new DateFormatter());
BindingRulesBuilder builder = new BindingRulesBuilder(TestBean.class);
builder.bind("date").formatWith(new DateFormatter());
GenericBinder binder = new GenericBinder(bean, builder.getBindingRules());
GenericFormatterRegistry formatterRegistry = new GenericFormatterRegistry();
formatterRegistry.add(Date.class, new DateFormatter());
binder.bind(Collections.singletonMap("date", "2009-06-01"));
assertEquals(new DateFormatter().parse("2009-06-01", Locale.US), bean.getDate());
}
@Test
public void bindSingleValueWithFormatterRegisteredByAnnotation() throws ParseException {
binder.addBinding("currency");
GenericFormatterRegistry registry = new GenericFormatterRegistry();
registry.add(CurrencyFormat.class, new CurrencyFormatter());
binder.setFormatterRegistry(registry);
binder.bind(Collections.singletonMap("currency", "$23.56"));
assertEquals(new BigDecimal("23.56"), bean.getCurrency());
}
@Test
public void bindSingleValueWithAnnotationFormatterFactoryRegistered() throws ParseException {
binder.addBinding("currency");
@ -163,7 +164,7 @@ public class GenericBinderTests {
public void getBindingCustomFormatter() {
binder.addBinding("currency").formatWith(new CurrencyFormatter());
Binding b = binder.getBinding("currency");
assertFalse(b.isCollection());
assertFalse(b.isIndexable());
assertEquals("", b.getValue());
b.setValue("$23.56");
assertEquals("$23.56", b.getValue());
@ -195,7 +196,7 @@ public class GenericBinderTests {
public void getBindingMultiValued() {
binder.addBinding("foos");
Binding b = binder.getBinding("foos");
assertTrue(b.isCollection());
assertTrue(b.isIndexable());
assertEquals(0, b.getCollectionValues().length);
b.setValue(new String[] { "BAR", "BAZ", "BOOP" });
assertEquals(FooEnum.BAR, bean.getFoos().get(0));
@ -213,7 +214,7 @@ public class GenericBinderTests {
binder.addBinding("foos");
bean.setFoos(Arrays.asList(new FooEnum[] { FooEnum.BAR }));
Binding b = binder.getBinding("foos[0]");
assertFalse(b.isCollection());
assertFalse(b.isIndexable());
assertEquals("BAR", b.getValue());
b.setValue("BAZ");
assertEquals("BAZ", b.getValue());
@ -223,7 +224,7 @@ public class GenericBinderTests {
public void getBindingMultiValuedTypeConversionFailure() {
binder.addBinding("foos");
Binding b = binder.getBinding("foos");
assertTrue(b.isCollection());
assertTrue(b.isIndexable());
assertEquals(0, b.getCollectionValues().length);
BindingResult result = b.setValue(new String[] { "BAR", "BOGUS", "BOOP" });
assertTrue(result.isFailure());
@ -456,7 +457,8 @@ public class GenericBinderTests {
Binding b = binder.getBinding("currency");
assertEquals("$5.00", b.format(new BigDecimal("5")));
}
*/
public static enum FooEnum {
BAR, BAZ, BOOP;
}

10
org.springframework.context/src/test/java/org/springframework/ui/binding/support/WebBinderTests.java
View File

@ -12,6 +12,7 @@ import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.ui.binding.BindingResults;
@ -36,16 +37,11 @@ public class WebBinderTests {
}
@Test
@Ignore
public void bindUserValuesCreatedFromUserMap() throws ParseException {
binder.addBinding("string");
binder.addBinding("integer");
binder.addBinding("date").formatWith(new DateFormatter());
binder.addBinding("bool");
binder.addBinding("currency");
binder.addBinding("addresses");
GenericFormatterRegistry registry = new GenericFormatterRegistry();
registry.add(CurrencyFormat.class, new CurrencyFormatter());
binder.setFormatterRegistry(registry);
//binder.setFormatterRegistry(registry);
Map<String, String> userMap = new LinkedHashMap<String, String>();
userMap.put("string", "test");
userMap.put("_integer", "doesn't matter");

10
org.springframework.context/src/test/java/org/springframework/ui/lifecycle/BindAndValidateLifecycleTests.java
View File

@ -9,6 +9,7 @@ import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.springframework.ui.alert.Alert;
import org.springframework.ui.alert.Alerts;
@ -26,7 +27,7 @@ import edu.emory.mathcs.backport.java.util.Collections;
public class BindAndValidateLifecycleTests {
private BindAndValidateLifecycle lifecycle;
private BindAndValidateLifecycleImpl lifecycle;
private TestBean model;
@ -37,11 +38,8 @@ public class BindAndValidateLifecycleTests {
model = new TestBean();
alertContext = new DefaultAlertContext();
WebBinder binder = new WebBinder(model);
binder.addBinding("string");
binder.addBinding("integer");
binder.addBinding("foo");
Validator validator = new TestBeanValidator();
lifecycle = new BindAndValidateLifecycle(binder, validator, alertContext);
lifecycle = new BindAndValidateLifecycleImpl(binder, validator, alertContext);
}
static class TestBeanValidator implements Validator {
@ -133,6 +131,7 @@ public class BindAndValidateLifecycleTests {
}
@Test
@Ignore
public void testExecuteLifecycleNoErrors() {
Map<String, Object> userMap = new HashMap<String, Object>();
userMap.put("string", "test");
@ -143,6 +142,7 @@ public class BindAndValidateLifecycleTests {
}
@Test
@Ignore
public void testExecuteLifecycleBindingErrors() {
Map<String, Object> userMap = new HashMap<String, Object>();
userMap.put("string", "test");