Simple Wicket ChoiceRenderer for any kind of Object

There are times in which rendering a Choice inside of a DropDown or RadioChoice component is just a matter of exposing some values stored inside the object associated to the choice item.

Maybe we can have no localization requirements or, more commonly, maybe our data has no localization issues at all.. think, for example, at a simple use case like the following:

public class Company implements java.io.Serializable {
    private Integer id;  //primary key
    private String  name; //company name
    public Company(Integer id, String name ) {
        this.id = id; this.name=name;
    }
    //other properties, plus getters & setters....
}

Now, you want to show the list of available Companies inside of a DropDownChoice:

//RendererExample.html
<select wicket:id="companySelection" />

//RendererExample.java
public class RendererExample extends WebPage {
   //list of available choices (just a hard-coded example)
   private List<Company> companies = Arrays.asList(
            new Company(1001,"APPLE"),
            new Company(1002, "MICROSOFT") );
   //will hold selected value
   private Company selectedCompany;
   public RendererExample() {
     add( new DropDownChoice( "companySelection",
             new PropertyModel( this, "selectedCompany" ),
             companies );
   }
}

Without giving any Renderer to the DropDownChoice, we will end up with a list of Object dumps, because Wicket will use the Company ‘toString’ method to render the label of each option and its position inside the list to render the ‘value’ part of the option:

DropDownChoice without a renderer

Now we have two routes to take:
1) implement the “toString()” method on the Company object to return what we want to display
2) use a Renderer
I naturally prefer the second option, primarily because I don’t like to mix display logic inside a data object;

Here we can immediately see a common pattern.. if we want to use as id/label two properties of our data object, why don’t create a a common ChoiceRenderer that we can reuse over and over on different data object ?
Here’s the basic implementation:

import org.apache.commons.beanutils.BeanUtils;
import org.apache.wicket.markup.html.form.IChoiceRenderer;

/**
 * Simple property-based ChoiceRenderer.
 * Use the given property names as the source to obtain the
 * respective ID and LABEL strings used to render the Choice
 * to the Hosting component.
 *
 * Example:
 * 
 *   //somewhere, in SomePersistentData.java file...
 *   public class SomePersistentData implements Serializable {
 *      private Integer id;
 *      private String  description;
 *      //plus, getters and setters....
 *   }
 *
 *   //extract Objects from DB
 *   List values = myService.findDataElements();
 *
 *   add( new DropDownChoice( "myWicketId",
 *            new PropertyModel(myDataObject, "propertyName" ),
 *            values,
 *            new PropertyChoiceRenderer( "id", "description" ) ))
 * 
 * @author Davide Alberto Molin (davide.molin@gmail.com)
 */
public class PropertyChoiceRenderer<T> implements IChoiceRenderer {

    //name of the property used to extract the ID for the choice option
    private String idProperty;
    //name of the property used to extract the LABEL for the choice option
    private String valueProperty;

    public PropertyChoiceRenderer( String idProperty, String valueProperty )
    {
        this.idProperty = idProperty;
        this.valueProperty = valueProperty;
    }

    public Object getDisplayValue(T object)
    {
        return getPropertyValue( object, valueProperty );
    }

    public String getIdValue(T object, int index )
    {
        return getPropertyValue( object, idProperty ).toString();
    }

    private Object getPropertyValue( T object, String property )
    {
        try
        {
            return BeanUtils.getProperty( object, property );
        }
        catch( Exception err )
        {
            //in case of exception, fall back to simple toString...
            return object.toString();
        }
    }
}

That’s all. Put it in your code and you’ll have a reusable yet simple ChoiceRenderer:

     add( new DropDownChoice( "companySelection",
             new PropertyModel( this, "selectedCompany" ),
             companies,
             new PropertyChoiceRenderer( "id", "name" ) );
   }

And that’s what you get:

DropDownChoice with our PropertyRenderer

Obviously, this is a basic implementation, open to modifications; You can get rid of the generic T in the code using “Object” on the IChoiceRendere import if you see no reason to have it; Again, if you want to retain the index of the item as the option value, just add another constructor that takes only the property used for the label and modify the getIdValue() in order to use the index value if the idProperty is null..

Advertisement