Note: Ce billet a été mis à jour le 28/09/2009 pour présenter une conception alternative de l'EnumModel.

Les enums sont très pratiques pour représenter des collections finies d'éléments : saisons, jours de la semaine... Il est donc fréquent de devoir saisir ou afficher de telles valeurs dans les applications web - et de manière internationalisée si possible.
Voyons comment Wicket permet de répondre à ce besoin.

Internationaliser les Enums

Pour notre exemple, nous utiliserons un Enum représentant les saisons :

public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

Wicket propose un puissant mécanisme d'internationalisation hiérarchique : en fonction d'une clé logique, une traduction correspondante est recherchée au niveau du composant courant, puis de son composant parent, etc. jusqu'à l'Application elle-même si nécessaire.

La question est donc : comment générer une clé unique pour chaque constante d'un Enum ?
La solution la plus évidente est d'utiliser le nom complet (FQN, ex: "net.thecodersbreakfast.wickettips.model.WINTER") de chaque constante de l'Enum, ce qui éviterait tout conflit de nommage.

Le code suivant permet de déterminer le FQN d'un Enum donné :

Season enumValue = Season.WINTER;
String messageKey = enumValue.getDeclaringClass().getCanonicalName() + "." + enumValue.name();

Afin d'éviter de copier/coller ce code partout où l'internationalisation d'un Enum est requise, et afin de pouvoir changer d'algorithme si nécessaire, nous allons utiliser le pattern Strategy et l'encapsuler dans une classe.
Mais afin d'éviter que Wicket ne la sérialise en même temps que les composants l'utilisant, nous mettrons en place une architecture inspirée de la classe java.util.Locale :

public abstract class EnumMessageKeyProvider {
	private static EnumMessageKeyProvider provider = new DefaultEnumResourceKeyProvider();
 
	public static EnumMessageKeyProvider getDefault() {
		return EnumMessageKeyProvider.provider;
	}
 
	public static void setDefault(EnumMessageKeyProvider provider) {
		EnumMessageKeyProvider.provider = provider;
	}
 
	public abstract <T extends Enum<T>> String computeMessageKey(T enumValue);
 
	public static <T extends Enum<T>> String getMessageKey(T enumValue) {
		return EnumMessageKeyProvider.provider.computeMessageKey(enumValue);
	}
}

public class DefaultEnumResourceKeyProvider extends EnumMessageKeyProvider {
	@Override
	public <T extends Enum<T>> String computeMessageKey(T enumValue) {
		return enumValue.getDeclaringClass().getCanonicalName() + "." + enumValue.name();
	}
}

L'internationalisation d'un Enum est alors très simple :

Season enumValue = Season.WINTER;
String key = EnumMessageKeyProvider.getMessageKey(enumValue);

Et pour changer d'algorithme, il suffit d'écrire une Stratégie différente...

public class SimpleNameEnumResourceKeyProvider extends EnumMessageKeyProvider {
	@Override
	public <T extends Enum<T>> String computeMessageKey(T enumValue) {
		return enumValue.getDeclaringClass().getCanonicalName() + "#" + enumValue.name();
	}
}

... et de l'enregistrer auprès de l'EnumMessageKeyProvider, par exemple au cours du processus d'initialisation de l'application Wicket :

public class WicketTipsApplication extends WebApplication {
	@Override
	protected void init() {
		EnumMessageKeyProvider.setDefault(new TestEnumResourceKeyProvider());
	}
	(...)
}

Afficher un Enum internationalisé

Le composant le plus fréquemment utilisé pour afficher une information est le Label. Ce qu'il affiche est déterminé par le Model qui lui est passé en paramètre.
Voyons donc comment développer un Modèle spécialisé dans l'affichage (internationalisé évidemment) d'un Enum.

Approche par sous-classement

Nous partirons ici sur la base d'un PropertyModel. En plus des deux paramètres standard (l'objet cible et sa propriété à afficher), nous aurons besoin d'un Component qui servira à lancer le processus d'internationalisation.

public class EnumPropertyModel<T extends Enum<T>> extends PropertyModel<String> {
 
	private Component component;
 
	public EnumPropertyModel(Object modelObject, String expression, Component resourceProvider) {
		super(modelObject, expression);
		this.component = resourceProvider;
	}
 
	@Override
	public String getObject() {
		final String expression = propertyExpression();
		final Object target = getTarget();
		if (target != null) {
			T enumValue = (T) PropertyResolver.getValue(expression, target);
			String key = EnumMessageKeyProvider.getMessageKey(enumValue);
			return component.getString(key);
		}
		return null;
	}
}

Ce modèle peut ensuite être utilisé avec un Label :

public class HomePage extends WebPage {
	private Season season = Season.SPRING;
	public HomePage() {
		add(new Label("label", new EnumPropertyModel<Season>(this, "season", this)));
	}
}

Approche par composition

Il est encore plus intéressant d'adopter une approche par composition, c'est-à-dire de concevoir notre modèle comme le décorateur d'un modèle existant. Par exemple, notre Modèle pourra internationaliser un Enum préalablement extrait d'un objet métier par un PropertyModel.

Notre Modèle effectuant une transformation de type unidirectionnelle (Enum vers String), nous le ferons étendre AbstractReadOnlyModel. Comme précédemment, il nécessite le passage en paramètre d'un Component pour lancer le processus d'internationalisation :

public class EnumModel<T extends Enum<T>> extends AbstractReadOnlyModel<String> {
 
	private IModel<T> model;
	private Component component;
 
	public EnumModel(IModel<T> model, Component component) {
		this.model = model;
		this.component = component;
	}
 
	@Override
	public String getObject() {
		String key = EnumMessageKeyProvider.getMessageKey(model.getObject());
		return component.getString(key);
	}
}

Il s'utilise de la façon suivante :

public class HomePage extends WebPage {
	private Season season = Season.SPRING;
	public HomePage() {
		// En décomposant : 
		IModel<Season> seasonEnumModel = new PropertyModel<Season>(this, "season");
		IModel<String> seasonStringModel = new EnumModel<Season>(seasonEnumModel, this);
		add(new Label("label", seasonStringModel));
 
		// Ou en une seule ligne :
		add(new Label("label", new EnumModel<Season>(new PropertyModel<Season>(this, "season"), this)));
	}
}

Notez que cette approche est très souple, elle permet d'internationaliser un Enum quelle que soit sa source : PropertyModel, LoadableDetachableModel, ou même un simple IModel...

Sélection d'un Enum avec un DropDownChoice

Maintenant que nous savons afficher un Enum internationalisé, voyons comment le sélectionner à l'aide d'un DropDownChoice personnalisé.

Le composant DropDownChoice respecte le modèle MVC :

• DropDownChoice est le Contrôleur.
• Le modèle qu'il prend en paramètre représente sans surprise le Modèle,
• Un ChoiceRenderer est utilisé pour générer les balises <option> en HTML (valeur et label)

Habituellement, c'est le Modèle qui fournit les différents éléments sélectionnables. Comme nous manipulons un Enum, nous les connaissons déjà : nous allons donc redéfinir la méthode "getChoices()" du composant DropDownChoice :

public class EnumDropDownChoice<T extends Enum<T>> extends DropDownChoice<T> {
 
	public EnumDropDownChoice(String id, IModel<T> model) {
		super(id);
		setModel(model);
		setChoiceRenderer(new EnumChoiceRenderer<T>(this));
	}
 
	public EnumDropDownChoice(String id, IModel<T> model, EnumChoiceRenderer<T> choiceRenderer) {
		super(id);
		setModel(model);
		setChoiceRenderer(choiceRenderer);
	}
 
	@Override
	public List<? extends T> getChoices() {
		return Arrays.asList(getModelObject().getDeclaringClass().getEnumConstants());
	}
}

Quant au ChoiceRenderer, il utilisera évidemment l'identifiant de l'Enum comme identifiant HTML, et sa valeur internationalisée comme label :

public class EnumChoiceRenderer<T extends Enum<T>> implements IChoiceRenderer<T> {
 
	/** The Component used a the root of the I18N search process */
	private final Component resourceProvider;
 
	public EnumChoiceRenderer(final Component resourceProvider) {
		this.resourceProvider = resourceProvider;
	}
 
	@Override
	public Object getDisplayValue(final T value) {
		final String key = EnumMessageKeyProvider.getMessageKey(value);
		return resourceProvider.getString(key);
	}
 
	@Override
	public String getIdValue(final T object, final int index) {
		final Enum<?> enumValue = object;
		return enumValue.name();
	}
}

Notre composant personnalisé s'utilise strictement comme un DropDownChoice normal :

public class HomePage extends WebPage {
	private Season season = Season.SPRING;
	public HomePage() {
		Form<Void> form = new Form<Void>("form");
		form.add(new EnumDropDownChoice<Season>("season", new PropertyModel<Season>(this, "season")));
		add(form);
		add(new Label("label", new EnumPropertyModel<Season>(this, "season", this)));
	}
}

En action

Le code source complet est disponible en annexe de ce billet. Je vous encourage à jouer avec pour voir les composants décrits ici en action. Deux liens ont également été rajoutés pour permettre de choisir une Locale (française ou anglaise) et constater que l'internationalisation a bien lieu.

Note : l'exemple utilise Gradle comme système de build ; exécutez simplement la commande suivante pour compiler et lancer l'application web (Jetty inside) :

gradle jettyRun

Puis ouvrez votre navigateur à l'adresse suivante :

http://localhost:8080/Wicket-tips/