Plugin / Properties

Version imprimable

03/01/2013, 11h03
Targan

Plugin / Properties

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 ;)
03/01/2013, 11h28
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:

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.
03/01/2013, 11h41
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 :(
03/01/2013, 16h31
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.
03/01/2013, 16h57
tchize_

Non, c'est même une bonne pratique de centraliser toutes tes clés, quand c'est possible.
08/01/2013, 18h26
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.
08/01/2013, 19h09
tchize_
Citation:

Envoyé par Targan

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

Citation:

Envoyé par Targan

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:

1 2 machin.bidule.truc=.... mahcin.bidule.truc=....
09/01/2013, 11h30
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

Citation:

Envoyé par Targan

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:

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:

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

Code:

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 :aie:

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

Code:

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.

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:

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:

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