Discussion :

[Targan]

Bonjour,

existe t il un plugin qui permet de lister les clés des fichiers de properties qui ne seraient pas utilisés dans un projet ?

J'ai plusieurs fichiers properties pour l'internationalisation de l'appli, et j'aimerai faire du ménage....

Ne me dites pas qu'il faut faire un search manuel via l'EDI.

Par avance merci

[tchize_]

le problème, c'est que je ne vois pas trop comment un plugin arriverais à déterminer à coup sur si c'est utilisé ou non

En effet, si tu as ce code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

String details = myResources.getString("com.company.components."+composant.getName()+".details");

L'opération commence à être hardue

Maintenant, si tu as le même shéma d'appel partous, tu peux extraire toutes les clés de ton code avec un outil comme sed et finalement comparer la sortie avec tes ressources bundle.

[Targan]

Ne serait ce que pour les clés complètes en dur cela aurait été bien qu'un plugin automatise un peu la recherche....

Je me vois mal faire des recherches à la main via l'EDI

[Targan]

Serait il envisageable alors de créer une class static avec toutes les clés utilisées afin d'identifier plus rapidement les variables non utilisées ?

ou serait ce débile ?

Merci.

[tchize_]

Non, c'est même une bonne pratique de centraliser toutes tes clés, quand c'est possible.

[Targan]

Bonjour,

désolé je reviens sur le sujet...mais...quelles sont les bonnes pratiques justement pour la gestion des fichiers de properties d'internationnalisation ?

A titre d'info, j'ai un framework de présentation (Zk) qui gère automatiquement le chargement des fichiers properties en fonction de la locale. Par contre, cela demande d'encoder les fichiers en UTF8 pour la gestion des caractères accentués, ce qui est hyper pénible qd on bosse sur Netbeans (pas moyen de convertir le fichier contrairement à Eclipse via config).

Bref, qu'est ce que cela apporte de centraliser les clés en tant que constantes dans une classe statique...

Merci.

nb: si vous avez de bons liens je suis preneur, je fais déjà des recherches mais je ne trouve rien de concluant.

[tchize_]

A titre d'info, j'ai un framework de présentation (Zk) qui gère automatiquement le chargement des fichiers properties en fonction de la locale. Par contre, cela demande d'encoder les fichiers en UTF8 pour la gestion des caractères accentués, ce qui est hyper pénible qd on bosse sur Netbeans (pas moyen de convertir le fichier contrairement à Eclipse via config).

Les ressource bundle, c'est toujours et exclusivement de l'iso-8859-1, a moins que tu n'appelle manuellement le constructeur PropertyResourceBundle en lui passant un Reader, ce que personne ne fait jamais . Les caractères qui ne sont pas dans ce range doivent être échappés par des séquences \uxxxx

Bref, qu'est ce que cela apporte de centraliser les clés en tant que constantes dans une classe statique...

On a directement une vue sur toutes les clés qui sont utilisée
Quand quelqu'un utilise une clé, il ne risque pas de faire une faute de frappe et que tu te retrouver avec deux clés

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
machin.bidule.truc=....
mahcin.bidule.truc=....

[Targan]

Avec Zk, on accède aux propriétés via une classe static que le framework gère lui même. Et a priori ils ont un chargement "particulier" car on est vraiment contraint d'encoder en UTF8 les fichiers properties.
J'avoue que c'est un peu pénible


Pour centraliser les clés, généralement vous faites cela dans une classe abstraite en y listant toutes les clés comme des constantes ? ou est ce que vous faites cela via des enum ? ou encore une autre façon ?

Existe t il des outils pour gérer au mieux tout cela ?

Désolé de poser autant de questions, je reste débutant en java et j'avoue être (trop) perfectionniste....

Merci tchize_ en tout cas

[tchize_]

Pour centraliser les clés, généralement vous faites cela dans une classe abstraite en y listant toutes les clés comme des constantes ? ou est ce que vous faites cela via des enum ? ou encore une autre façon ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public class Translation {
   public static final String MACHIN_LABEL = "com.company.machin.label";
   public static final String MACHIN_DESCRIPTION = "com.company.machin.description";
   ....
   // et tant qu'à faire, regroupons la logique avec
   public static String getMessage(String key){
   // ....
   }
   public static String getMessage(String key, Object params...){
   // ....
   }
}

et finalement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

String toDisplay = Translation.getMessage(Translation.MACHIN_DESCRIPTION);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

String erreur = Translation.getMessage(Translation.MACHIN_ERREUR,errorCode,errorServer);

Je n'ai jamais utilisé d'enums. On arrive vite à une centaines de clés différentes pour un programme un peux complexe et j'ai en général peur que tant d'enum commencent à encombrer la mémoire

[Targan]

J'ai trouvé ce bout de code sur le net (SOF pour ne pas le citer), qu'en pense tu ?

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
public class Constant {
 
    private Constant() {
        throw new AssertionError();
    }
 
    public interface ConstantType {}
 
    public enum StringConstant implements ConstantType {
        DB_HOST("localhost");
        // other String constants come here
 
        private String value;
        /*private StringConstant(String value) {
            this.value = value;
        }*/
        public String value() {
            return value;
        }
    }
 
    public enum IntConstant implements ConstantType {
        DB_PORT(3128), 
        MAX_PAGE_SIZE(100);
        // other int constants come here
 
        private int value;
        private IntConstant(int value) {
            this.value = value;
        }
        public int value() {
            return value;
        }
    }
}

du coup tu peux appeler ta clé de properties par Constant.StringConstant.DB_HOST.value()
C'est un peu plus "objet".
L'intérêt que je vois avec l'enum est aussi de pouvoir appeler un "contains" pour vérifier l'existence d'une clé...

Quel est ton avis sur le sujet ?

Merci.

[tchize_]

C'est circonvoluté pour arriver à l'enum et n'a rien à voir avec ton problème (on est plus proche là d'une configuration)


Si je dois faire des enums c'est plutot comme ça

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
public enum Translation {
   MACHIN_LABEL("com.company.machin.label"),
   MACHIN_DESCRIPTION("com.company.machin.description");
 
   private String key;
   public Translation(String key){
     this.key=key;
   }
   public String getMessage(){
       return leResourceBundle.getString(key);
   }
   public String getMessage(Object params...){
      return new MessageFormat(getMessage()).format(params);
   }
}

et l'appel:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

String erreur = Translation.MACHIN_ERREUR.getMessage(errorCode,errorServer);