Today i will explain three types of value binding:
- “direct” value binding (one setter / getter for each value)
- “list based” value binding (one setter / getter for a list of values)
- “map based” value binding (one setter / getter for a map of values)
Direct value binding
This is the classic usage of value binding in jsf, the following facelets-snippet is self-explanatory:
<h:inputText value="#{bean.foo}"/>
<h:inputText value="#{bean.bar}"/>
Our bean have a setter and a getter for foo and bar:
class Bean {
private String foo, bar;
public String getFoo() ...
public void setFoo(String) ...
public String getBar() ...
public void setBar(String) ...
}
List based value binding
I use this to avoid setter and getter for similar values/properties, i.e.
<h:inputText value="#{bean.product[0]}"/>
<h:inputText value="#{bean.product[1]}"/>
<h:inputText value="#{bean.product[2]}"/>
...
With the “classic” value binding i have to write a lot of getter/setter (product0, product1, product2,…). But with list based value binding its much easier.
class Bean {
private static final int MAX_NUMBER_OF_PRODUCTS = 5;
private final Product[] products = new Product[MAX_NUMBER_OF_PRODUCTS];
public Bean () {
for (int i = 0; i < MAX_NUMBER_OF_PRODUCTS; i++) {
products[i] = null;
}
}
public List<Product> getProduct() {
return Arrays.asList(Product);
}
}
The initialization of the internal array/list is necessary for correct working! During runtime jsf will access each value via index (0, 1, 2, …), a uninitialized list will throw a IndexOutOfBounds Exception.
Map based value binding
I used this type of value binding in a generic “CRUD list” view to implement filtering in a rich:dataTable. I want a selectbox for each “filterable” column:
<rich:column>
<f:facet name="header">
<h:selectOneMenu value="#{bean.filterValue['foo']}">
<f:selectItems value="#{bean.filterValues['foo']}" />
</h:selectOneMenu>
</f:facet>
...
</rich:column>
<rich:column>
<f:facet name="header">
<h:selectOneMenu value="#{bean.filterValue['bar']}">
<f:selectItems value="#{bean.filterValues['bar']}" />
</h:selectOneMenu>
</f:facet>
...
</rich:column>
To get this to work we need a “customized” map implementation:
class ArrayMap<K, T> extends HashMap<K, T> {
private static final long serialVersionUID = -5766406097936988242L;
@Override
public T get(final Object theKey) {
if (!containsKey(theKey)) {
// to avoid typos in the ui we throw a exception if a "unknown" value-name is used
throw new IllegalArgumentException(String.format("The given value-name '%s' is not available", theKey));
}
return super.get(theKey);
}
public void set(final K key, final T value) {
super.put(key, value);
}
}
This ArrayMap have a getter and a setter (the “normal” Map have only get and put), for jsf value binding we need a set and a get.
Here is the final filter – bean:
class FilterBean {
/**
* Contain all available filter-values for each supported filter-name.
*/
private final Map<String, List<SelectItem>> filterValues = new ArrayMap<String, List<SelectItem>>();
/**
* Contain the current filter-value for each supported filter-name.
*/
private final ArrayMap<String, Object> filterValue = new ArrayMap<String, Object>();
/*
* Constructor.
*/
public FilterBean() {
initFilterValue();
}
/**
* @return a map of lists with {@link SelectItem}s
*/
public Map<String, List<SelectItem>> getFilterValues() {
return filterValues;
}
/**
* @return the map of filter values
*/
public ArrayMap<String, Object> getFilterValue() {
return filterValue;
}
/**
* Prepare <tt>filterValue</tt>, add all supported filter-names to the list.
*/
private void initFilterValue() {
filterValue.set("foo", null);
filterValue.set("bar", null);
}
/**
* Prepare <tt>filterValues</tt>, the given list contains all rows for the datatable. Each filter-selectbox must
* show a unique list of available filter-values (per supported filter column).
*/
public synchronized void initFilterValues(final List<T> theInitialFilterList) {
filterValues.clear();
filterValues.put("foo", getFilterSelectItemsFoo(theInitialFilterList));
filterValues.put("bar", getFilterSelectItemsBar(theInitialFilterList));}
}
}
The method initFilterValues(final List<T>) will be triggered from a external bean. Then the filter-bean can create a list of SelectItems for each filter-column.
If the User select a value from such a filter-list the value binding will call our ArrayMap.set method.
Try it 
. Tested for FF3 and IE6.
) is on the same level with the node-icon (
). That’s very hard to fix this with CSS (it’s possible but i prefer my strange solution 
Unschön wird es wenn man einen rich:modalPanel als Edit-Dialog einsetzt und diesen wiederverwendet.
