Bonjour,

Je suis actuellement dans le développement d'une appli localisée.

De manière classique, j'ai externalisé les messages (pour les logs comme pour l'utilisateur) dans des fichiers au format properties que je récupère via un ResourceBundle.

Jusqu'à présent, j'utilisais la méthode String.format pour le formatage, mais je suis en train de reconsidérer la question pour utiliser MessageFormat.format.
La raison de ceci est le format plus lisible des champs variables pour les non-informaticiens...

Après quelques tests, le MessageFormat semble plus lent que le String.format (en moyenne 20% de temps en plus).

Je cherche donc un moyen d'optimiser l'utilisation du MessageFormat.
Après quelques tests, la seule solution que j'ai trouvée est la suivante:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    // Map synchronisée et faible
    private final Map<Key<String, Locale>, MessageFormat> formatters = Collections.<Key<String, Locale>, MessageFormat> synchronizedMap(new WeakHashMap<Key<String, Locale>, MessageFormat>());
 
    public String format(final Locale locale, final String pattern, final Object... params)
    {
        // Récupération du formatteur existant
        final Key<String, Locale> key = new Key<String, Locale>(pattern, locale);
        MessageFormat formatter = formatters.get(key);
 
        // Ou création si nécessaire
        if (formatter == null)
        {
            formatter = new MessageFormat(pattern, locale);
            formatters.put(key, formatter);
        }
 
        // MessageFormat n'est pas thread-safe
        synchronized (formatter)
        {
            return formatter.format(params);
        }
    }
Elle ne me satisfait pas complètement car la taille de la map peut très vite augmenter. Le choix d'une WeakHashMap permet de la purger régulièrement, mais cela oblige aussi à recréer régulièrement les formatteurs.

Voyez-vous une meilleure solution?
Celle proposée vous semble-t-elle saine?