[Classpath] Où se situe-t-il ?

**Deallyra** · 20/01/2010, 09h28

Bonjour,

On trouve pas mal de documentation sur "classpath" sur le net mais une bonne partie sont à la ramasse...

Pour le classpath, ils nous renseignent sur la variable d'environnement "path" ou alors sur le path des classes Java.

Pour notre projet, nous avons besoin de récupérer le chemin d'accès au classpath puis de lister les fichiers xml pour ensuite les lister.

Filtrer et lister selon un path, c'est ok.
Cependant, récupérer le chemin d'accès au classpath pour le lire...
Là je ne sais pas ce que cela donne...

Sauriez vous où récupérer le classpath ?

**adiGuba** · 20/01/2010, 09h45

Salut,

Le CLASSPATH, c'est comme la cuillère de Matrix : il n'existe pas

Plus sérieusement contrairement au PATH système, tu n'as pas une variable d'environnement qui comporte tous les chemins du classpath, car le classpath peut prendre plusieurs qui n'y sont pas forcément représentable. De plus cela dépend énormément de la manière dont tu lances

Il y a bien la variable système "java.class.path", mais elle comporte uniquement le classpath initial avant de lancer l'application, mais qui peut être très différent de celui de ton application...

Envoyé par Deallyra

Pour notre projet, nous avons besoin de récupérer le chemin d'accès au classpath puis de lister les fichiers xml pour ensuite les lister.

Ces fichiers XML sont où précisément ?
Ils ont toujours le même chemin ou tu dois parcourir tous les sous-répertoires ???

a++

**tchize_** · 20/01/2010, 09h45

le classpath est l'ensemble des ressources faisant partie de ton classloader. La mauvaise nouvelle c'est que c'est juste le résultat du fonctionnement du classloader, il n'y a pas nécessairement de "liste des paths" accessible. Tu peux bien sur y aller en force sur le classloader. Par exemple, si le classloader hérite de URLClassLoader, tu peux utiliser sa méthode getURLs.

Le problème c'est que:

1) les urls de type http:// ne sont pas scannables
2) quand on charge des jar avec des class-path: dans le MANIFEST.MF, ca commence vite à devenir complexe.

pourquoi as-tu besoin de lister les xml accessbile et te rend tu compte, si t'incorpore des librairies annexes, de la quantité de xml que tu risque de sortir?

Le mieux serait plutot de te baser sur la manière dont ton programme est installé pour déterminer tous les jar et à partir de là explorer ceux que tu désire.

Edit: en faisant un test sur un appli en prod: 227 xml de trouvés

**Deallyra** · 20/01/2010, 10h16

Plop et merci :3

Envoyé par adiGuba

Il y a bien la variable système "java.class.path", mais elle comporte uniquement le classpath initial avant de lancer l'application, mais qui peut être très différent de celui de ton application...

Ce qui explique certaines réponses que j'ai lues donc... Réponses incomplètes :/

Envoyé par adiGuba

Ces fichiers XML sont où précisément ?
Ils ont toujours le même chemin ou tu dois parcourir tous les sous-répertoires ???

En fait...
J'ai une application qui doit aller chercher tous les "Analysis Engine", les "Collection Reader", les "Types System" (...) de mon application.

Grossièrement, ce sont des fichiers XML reliés à des fichiers java permettant de réaliser des traitements spécifiques sur des fichiers.

Bref. Lorsque je lance mon application, j'ai besoin de lui donner la liste de ces fichiers disponibles.
Il peut s'agir de Jar qu'il a incorporé (et dans ce cas on se débrouillera pour rajouter le chemin au classpath) ou alors de fichiers déjà présents avant.
Aussi ils peuvent être un peu n'importe où sur son pc.

Envoyé par tchize_

pourquoi as-tu besoin de lister les xml accessbile et te rend tu compte, si t'incorpore des librairies annexes, de la quantité de xml que tu risque de sortir?

Je ne m'en rends pas encor complètement compte mais je vois bien que ça peut vite se révéler être assez lourd oui

**tchize_** · 20/01/2010, 10h53

en gros t'as besoin de trouver n'importe quoi, n'imprte ou?

Pour ceux qui sont dans le jar, si ils portent un nom précis (exemple META-INF/machin.xml), il y a moyen de demander au classlaoder de récupérer tous les "META-INF/machin.xml" du classpath sous forme d'une énumération d'urls. Pareil si le répertoire est connu.

Code :

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

Enumeration e = classloader.findRessources("/META-INF/");

devrait retourner tous les folder META-INF du classapth

**adiGuba** · 20/01/2010, 11h03

Si tu pouvais placer dans un même répertoire ce serait plus pratique (même si ce répertoire peut être compris dans plusieurs emplacement du classpath).

En effet tu peux utiliser getResources() pour récupérer toutes les ressources avec le même nom, par exemple pour obtenir tous les répertoire "xml" du classpath :

Code :

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

1
2
	ClassLoader classLoader = ClassLoader.getSystemClassLoader();
	Enumeration<URL> urls = classLoader.getResources("xml");

Ensuite il faut traiter chacune de ces URL selon leurs protocoles, sachant que tu peux avoir deux principaux protocoles :

file: si le répertoire fait partie d'un répertoire. L'URL correspond alors tout simplement au répertoire et tu peux le lister le plus simplement du monde.
jar:, et tu as alors une URL vers le répertoire à l'intérieur du jar, sous la forme jar:file:/chemin_vers_le.jar!/repertoire
Il faut alors décomposer l'URL pour récupérer uniquement l'URL vers le jar, afin de pouvoir le parcourir.

Attention car tu peux très bien avoir d'autres protocoles que tu ne devrais pas traiter...

a++

[edit] Grillet

**tchize_** · 20/01/2010, 11h05

Envoyé par adiGuba

[edit] Grillet

Grilled

**adiGuba** · 20/01/2010, 11h08

[mauvaise_foi] Sur mon clavier les touches 'T' et 'D' sont beaucoup plus proche que sur les autres claviers

[/mauvaise_foi]

**Deallyra** · 20/01/2010, 11h50

hihi

Bon, nous avions également exposé ce problème à notre encadrant et il nous a bien aidé...
En se basant sur le java.class.path qui, sur son système, est suffisant et opérationnel.

Code JAVA :

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
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
 
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
 
public class Main {
 
        private static List<URI> xmlFiles = new ArrayList<URI>();
 
        private static void add(JarFile jar) {
                Enumeration<JarEntry> entries = jar.entries();
               while (entries.hasMoreElements()) {
                   JarEntry entry = entries.nextElement();
                   if (!entry.isDirectory()) {
                           String name = entry.getName();
                           if (name.endsWith(".xml")) {
                                 try {
                                   ClassLoader cl = ClassLoader.getSystemClassLoader();
                                   URL url = cl.getResource(name);
                                   URI uri = url.toURI();
                                   xmlFiles.add(uri);
                                   System.out.println("The XML resource " + uri.toString() + "
has been added.");
                                 } catch (URISyntaxException e) {
                                         System.err.println(e.getMessage());
                                 }
                           }
                   }
               }
        }
 
        private static void add(File file) {
                if (file.isDirectory()) {
                        File[] files = file.listFiles();
                        for (File f : files) {
                                add(f);
                        }
                } else {
                        String name = file.getName();
                        if (name.endsWith(".xml")) {
                                try {
                                        URI uri = new URI(file.getAbsolutePath());
                                        xmlFiles.add(uri);
                                        System.out.println("The XML file " + file + " has been added.");
                                } catch (URISyntaxException e) {
                                        System.err.println(e.getMessage());
                                }
                        }
                }
        }
 
        /**
        String classPath = System.getProperty("java.class.path");
        String pathElements = classPath.split(System.getProperty("path.separator"));
        You can then loop through this array to examine each element to determine if it's a jar file.
        When you find a jar file, you can open it using a new JarFile, then use entries()        to get an Enumeration(ugh) of the jar entries. For each entry, you can get the name and see if it ends in ".xml" or whatever. If it does, get the InputStream
associated with the entry, read it, and do whatever you need to do with the data from the file.
Does that help?
         */
        public static void main(String[] args) {
 
                String classPath = System.getProperty("java.class.path");
                String pathSeparator = System.getProperty("path.separator");
                String[] pathElements = classPath.split(pathSeparator);
 
                System.out.println("The classpath = " + classPath);
                System.out.println();
 
                for (String pathElement : pathElements) {
                        try {
                                System.out.println("Checking '" + pathElement +"'");
                                JarFile jarFile = new JarFile(pathElement);
                                System.out.println("This classpath element is a jar file.");
                                add(jarFile);
                        }
                        catch (IOException e) {
                                System.out.println("This classpath element is not a jar file.");
                                File file = new File(pathElement);
                                if (file.exists()) {
                                        System.out.println("This classpath element exists.");
                                        if (file.isDirectory()) {
                                                System.out.println("This classpath element is a directory.");
                                                add(file);
                                        } else {
                                                System.out.println("This classpath element isn't a directory.");
                                        }
                                } else {
                                        System.out.println("This classpath element doesn't exists.");
                                }
                        }
                        catch (SecurityException e) {
                                System.out.println(" is not an accessible jar file.");
                        }
                        System.out.println();
                }
 
                System.out.println();
                System.out.println("XML files found are:");
                for (URI xmlFile : xmlFiles) {
                        System.out.println("  * " + xmlFile.toString());
                }
        }

Merci beaucoup pour votre aide

**adiGuba** · 20/01/2010, 13h20

Le problème avec java.class.path, c'est qu'il n'est utilisable que si tu lances l'application "manuellement", c'est à dire avec :

Code :

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

java ta.classe.Principal

Si tu lances un jar auto-executable (java -jar tonJar) ou que tu déploies via JWS cela ne fonctionnera plus ! (il vaut mieux savoir cela à l'avance).

a++

**Deallyra** · 20/01/2010, 14h15

Merci pour l'info

C'est une chose à laquelle je n'aurai pas pensé sans l'avoir vécue ^^

Cependant, je n'aurai pas ce problème puisque ce sera une application qui sera sur chaque poste (ou alors j'ai mal compris ce que tu voulais me dire mais je ne pense pas que ce soit le cas ^^ )

Toutes fois, même si moi je n'aurai pas ce problème, il est bon que ceux qui réutiliseront ce code (s'il est réutilisé) soient au courant.

Merci beaucoup de votre aide ^^

**tchize_** · 20/01/2010, 14h20

Envoyé par Deallyra

Cependant, je n'aurai pas ce problème puisque ce sera une application qui sera sur chaque poste (ou alors j'ai mal compris ce que tu voulais me dire mais je ne pense pas que ce soit le cas ^^ )

Il a dit "si application être empaquetée dans un jar, ton code être caca qui marchera pas"

**sinok** · 20/01/2010, 14h23

Envoyé par Deallyra

Merci pour l'info

C'est une chose à laquelle je n'aurai pas pensé sans l'avoir vécue ^^

Cependant, je n'aurai pas ce problème puisque ce sera une application qui sera sur chaque poste (ou alors j'ai mal compris ce que tu voulais me dire mais je ne pense pas que ce soit le cas ^^ )

Toutes fois, même si moi je n'aurai pas ce problème, il est bon que ceux qui réutiliseront ce code (s'il est réutilisé) soient au courant.

Merci beaucoup de votre aide ^^

Tu l'auras probablement ce problème, car la méthode standard de distribution d'une application est de la mettre sous forme d'un jar. Or si tu as un jar, cf ce que disait Adiguba.

[edit]Grillédtztrucmachin[/edit]

**Deallyra** · 20/01/2010, 14h27

ha m****

J'avais zappé le ou...

**Deallyra** · 20/01/2010, 14h44

Merci (beaucoup)+

En effet on distribuera le projet sous plusieurs formes dont le jar...
La seule solution actuellement envisagée sera de demander à l'utilisateur de renseigner l'accès aux archives jar contenant les fichiers dont il aura l'utilisation s'ils ne sont pas déjà contenus dans notre projet.
Pour l'instant, ce n'est pas notre priorité mais il va falloir y penser sérieusement en parallèle car ça pourrait être (non, en fait ce sera) bloquant en fin de parcours...

Merci Chrono-AbiGuba

Et _tchize ainsi que sinok pour appuyer sur mon erreur d'interprétation