recuperer une variable d'environnement

j'ai réussi a bidouillé un truc lol
pour faire marché mon application je modifie mon classpath pour qu'il pointe vers le dossier sources avec toute les .class

mon fichier ini etant proche du classpath j'utiilise

Code:

String classpath = System.getProperty("java.class.path");

puis effectuer un traitement pour renvoyer le path du fichier ini en question :)

Attention de ne pas trop jouer avec le Classpath ca risque de te poser des problèmes...

Tant qu'a modifier quelque chose pourquoi ne pas utiliser l'option -D de java pour lui passer une propriété ???

a++

Le classpath je le modifie pas que pour ça. En faite, il est réglé d'une certaine façon pour que on application tourne, et je detourne son utlisation premiere mais je ne le modifie pas vraiment.
:)

Du coups si ton fichier est dans le ClassPath tu peux simplement utilisé getClass().getResource() pour le charger...

Sinon si jamais ca interresse quelqu'un, j'ai retrouvé le code pour le getenv en utilisant le builtin set. Ca devrait marcher sur la plupart système Windows et Unix-like, mais je ne le garantis pas ;)

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
 
public class Env {
 
    /** Singleton */
    private static final Env instance = new Env();
    /** Map qui contiend les variables d'environnements. */
    private TreeMap values = new TreeMap();
    /** Erreur recu lors du chargement des variables d'environnements. */
    private Throwable error = null;
 
 
    /** 
     * Constructeur privé.
     * @see Env#getEnv()
     */
    private Env() {
        try {
            loadSystemEnvironemment(); // throw IOException
        } catch (Throwable t) {
            this.error = t;
        }
    }
 
    /**
     * Accesseur pour l'instance unique de la classe Env (singleton)
     * @return Le singleton <b>Env</b>
     */
    public static Env getEnv() {
        return Env.instance;
    }
 
    /**
     * Indique si la recherche est case sensitive ou non.
     * La valeur par défaut dépend du système (<b>true</b> sous Windows, <b>false</b> sinon)
     * @return Booléen qui indique si la recherche est insensible à la case.
     */
    public boolean isIgnoreCase() {
        return this.values.comparator()!=null;
    }
 
    /**
     * Modifie la méthode de recherche des clef en mode  insensible à la case ou non.
     * @param ignorecase true si on veut ignorer la case, false sinon.
     */
    public void setIgnoreCase(boolean ignorecase) {
        if (ignorecase!=isIgnoreCase()) {
            // sauvegarde des valeurs de la Map
            Map backup = this.values;
            Comparator comparator = null; // comparaison case-sensitive
            if (ignorecase) {
                // Pour ignorer la case on utilise ce comparator :
                comparator = String.CASE_INSENSITIVE_ORDER; // comparaison case-insensitive
            }
            // On cree une nouvelle TreeMap avec le comparator :
            this.values = new TreeMap(comparator);
            // Et on rajoute tous les éléments en backup :
            if (backup!=null) {
                this.values.putAll(backup);
            }
        }
    }
 
    /**
     * Retourne la variable d'environnement associé à ce nom.
     * @param name Nom de la variable d'environement.
     * @return La valeur associé à cette variable d'environnement, ou <b>null</b> si elle n'existe pas.
     */
    public String get(String name) {
        return (String) this.values.get(name);
    }
 
    /**
     * Retourne une Map non-modifiable contenant la liste des variables d'environnements.
     * @return Map <String, String> non modifiable.
     */
    public Map get() {
        return Collections.unmodifiableMap(this.values);
    }
 
    /**
     * Retourne la liste des noms des variables d'environements tels qu'elles sont définit.
     * @return Tableau de nom des variables (non-null).
     */
    public String[] names() {
        return (String[]) this.values.keySet().toArray(new String[0]);
    }
 
    /**
     * Retourne l'exception obtenu lors du chargement des variables d'environements.
     * @return L'erreur obtenu, ou <b>null</b> si tout est OK.
     */
    public Throwable error() {
        return this.error;
    }
 
    /**
     * Exécution de la méthode 'set' qui renvoit la liste des variables d'environnements.
     * @throws IOException Erreur d'execution du processus.
     */
    private void loadSystemEnvironemment() throws IOException {
        // On récupère le nom de l'OS pour déterminer la commande à exécuter :
        String system = System.getProperty("os.name");
        final String command;
 
        // On détermine la commande selon le système :
        if (system.startsWith("Windows")) {
            // Systeme Windows
            if (system.equals("Windows 95") || system.equals("Windows 98") || system.equals("Windows Me")) {
                // Windows 9x/Me
                command = "command.com /C set";
            } else {
                // Windows NT/2000/XP
                command = "cmd.exe /C set";
            }
            // comparaison en mode case insensitive :
            setIgnoreCase(true);
 
        } else {
            // Autres systèmes (Unix-like)
            command = "/bin/sh set";
        }
 
        // On lance la commande :
        Process p = Runtime.getRuntime().exec(command);
        try {
            // On ferme les flux 'inutiles' :
            p.getOutputStream().close();
            p.getErrorStream().close();
 
            // On envoit directement le flux de 
            BufferedReader pOut = new BufferedReader(new InputStreamReader(p.getInputStream()));
            try {
                String line;
                // Pour toutes les lignes :
                while ( (line=pOut.readLine()) != null) {
                    // on découpe la chaine
                    int index = line.indexOf('=');
                    if (index>0) {
                        // et on ajoute le tout dans une Map
                        String key = line.substring(0, index);
                        String value = line.substring(index+1);
                        // On ajoute la clef/valeur
                        this.values.put(key, value);
                    }
                }
            } finally {
                // fermeture du flux
                pOut.close();
            }
        } finally {
            // Destruction du process s'il n'est pas déjà terminé...
            p.destroy();
        }
    }
}

Merci, je vais prendre le code même si je l'utilise pas de suite, ça peut etre trés utile :).