Discussion :

[Patrice Henrio]

Bonjour,
Je travaille sous Eclipse.
J'ai deux projets A et B. Le projet B utilise le projet A qui lui-même utilise des ressources dont le chemin d'accès est relatif au projet A.

Voici un exemple de code
ClasseA

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
public class ClasseA
{
 
	public ClasseA()
	{
		File f = new File("donnees" + File.separator + "fichier.txt");
		try
		{
			System.out.println(chargerContenuTexte(f));
		}
		catch (IOException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
	public static void main(String[] args)
	{
		new ClasseA();
	}
    public String chargerContenuTexte (File fic) throws IOException
    {
        StringBuilder  chTmp ;
        BufferedReader lect  = null ;
 
        try
        {
            // Initialisations
            chTmp = new StringBuilder() ;
            lect  = new BufferedReader (new InputStreamReader (new FileInputStream (fic))) ;
 
            // Lire le fichier
            String ligne ;
            while ((ligne = lect.readLine()) != null)
            {
                chTmp.append (ligne) ;
                chTmp.append ("\n") ;
            }
 
            // Fermer le fichier
            lect.close() ;
            lect = null ;
        }
        finally
        {
            if (lect != null)
            {
                try { lect.close() ; }
                catch (Throwable e) {}
            }
        }
 
        // Renvoyer le texte
        return chTmp.toString() ;
    }
}

L'exécution de la main de la classe A donne bien le résultat attendu : affichage sur la console du contenu du fichier.
Bien sûr, le fichier existe dans le répertoire donnees qui lui-même se trouve à la racine du projet (même niveau que src)

ClasseB

Code :

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

1
2
3
4
5
6
7
8
9
 
public class ClasseB
{
	public static void main(String[] args)
	{
		ClasseA a = new ClasseA();
 
	}
}

Bien entendu j'ai indiqué dans les propriétés du ProjetB qu'il utilisait ProjetA (project/properties/Java Build Path/Projects/add)

Lorsque je lance la main de ProjetB, Eclipse me renvoie l'erreur (normale)
java.io.FileNotFoundException: donnees\fichier.txt (Le chemin d’accès spécifié est introuvable)

En effet le chemin est recherché à partir du répertoire du projet en cours.

Comment faire tourner ProjetB sans toucher à ProjetA ? (et sans copier le répertoire donnees de ProjetA à ProjetB bien sûr)

[Mickael_Istria]

C'est pas tant un problème Eclipse, mais plutôt un problème de Java.
En fait, quand tu veux accéder un fichier à l'intérieur d'un projet, et que ce fichier sera plus tard à l'intérieur du jar, il faut que tu utilises getClass().getResource() ou getClass().getResourceAsStream() qui cherche à l'intérieur du classpath.

[Gueritarish]

Salut,

Il s'agit d'un problème de classpath. Tu peux jeter un oeil sur la FAQ à ce sujet.
Il ne faut pas confondre Build Path et Class Path.

un Class Path est par défaut élaboré à partir du Build Path

Mais il faut savoir que ce Class Path est placé au répertoire bin du projet.
Donc, dans ton cas, il faut juste ajouter ton dossier "donnees" au classpath de ta configuration de lancement. Pour cela, j'ai un peu modifié ton code (comme indiqué par Mickael):

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
37
38
39
40
41
42
43
44
45
public class ClasseA {
 
  public ClasseA() {
    try {
      System.out.println(chargerContenuTexte(getClass().getResourceAsStream(
          "/donnees/fichier.txt")));
    } catch (final IOException e) {
      e.printStackTrace();
    }
  }
 
  public static void main(final String[] args) {
    new ClasseA();
  }
 
  public String chargerContenuTexte(final InputStream aInputStream)
      throws IOException {
    StringBuilder chTmp;
    BufferedReader lect = null;
 
    try {
      // Initialisations
      chTmp = new StringBuilder();
      lect = new BufferedReader(new InputStreamReader(aInputStream));
 
      // Lire le fichier
      String ligne;
      while ((ligne = lect.readLine()) != null) {
        chTmp.append(ligne);
        chTmp.append("\n");
      }
    } finally {
      // Fermer le fichier
      if (lect != null) {
        try {
          lect.close();
        } catch (final Throwable e) {
        }
      }
    }
 
    // Renvoyer le texte
    return chTmp.toString();
  }
}

Autre remarque, il te faut fermer le flux dans le finally. C'est à ça qu'il sert.
Ensuite, pour changer ta configuration de lancement, tu vas dans Run > Run configurations... Là, tu sélectionnes ta configuration dans la partie "Java Application". Puis, dans l'onglet "Classpath", tu sélectionnes l'entrée "User Entries" et là, tu cliques sur le bouton "Advanced...". Dans la popup affichée, tu choisis "Add Folders" et tu cliques sur "Ok". Tu sélectionnes le dossier de ton projet "ProjetA". Et voilà, tu peux exécuter pour tester.

Après, il te suffit de faire la même chose pour la configuration de lancement de ton "ProjetB".

Voilà, à+
Gueritarish

[Patrice Henrio]

Merci de vos réponses. Je vais tester tout cela.
Pour ce qui concerne la méthode chargerContenuTexte, j'ai fait au plus vite pour montrer l'essentiel du problème. Merci cependant du rappel pour finally.

C'est la première fois que je trouve une explication claire de getRessource et du classpath.

[Patrice Henrio]

Effectivement ça marche nickel maintenant. cependant j'y vois un inconvénient auquel vous saurez sans doute répondre.
J'utilise CVS pour maintenir un projet avec Sourceforge.net. En plaçant les données dans bin je ne peux plus les synchroniser car de mémoire je crois que ce répertoire ne fait pas partie des dossiers synchronisés. Ou alors il faut dupliquer les données ce qui revient à les recopier dans projetB.

[Gueritarish]

Euh... On est d'accord que c'est un problème de Class Path et uniquement de Class Path. Ton dossier ne doit en aucun cas se retrouver dans bin.
C'est une très mauvaise idée. Il suffit qu'Eclipse fasse un clean des projets de ton workspace pour qu'il efface le contenu de bin pour le reconstruire...
C'est pour ça qu'il faut que tu modifies le Class Path de tes configurations de lancement.
Et là, tu n'auras plus de problèmes avec CVS.

Voilà, à+
Gueritarish

[Patrice Henrio]

Euh... On est d'accord que c'est un problème de Class Path et uniquement de Class Path. Ton dossier ne doit en aucun cas se retrouver dans bin.
C'est une très mauvaise idée. Il suffit qu'Eclipse fasse un clean des projets de ton workspace pour qu'il efface le contenu de bin pour le reconstruire...
C'est pour ça qu'il faut que tu modifies le Class Path de tes configurations de lancement.
Et là, tu n'auras plus de problèmes avec CVS.

Voilà, à+
Gueritarish

J'ai regardé sur les faq eclipse et je ne vois pas comment ajouter des ressources au class path. Je vois comment ajouter des classes, des jar, d'autres projets mais pas des ressources sous forme de fichier. Très clairement comment ajouter un répertoire donnees qui n'est ni un jar (interne ou externe), ni une variable, ni un répertoire de classe (interne ou externe), ni une librairie.

[Mickael_Istria]

En fait, tout ce qui est dans un dossier de source et qui n'est pas un .java devient une resource dans le classpath du project/du jar.
Donc tu mets ton fichier file.txt dans le "src/" (ou src/main/resources" si tu fais du Maven) et tu y accede avec getClass().getResourceAsStream("/file.txt").

[Gueritarish]

C'est parce qu'il te faut l'ajouter à ta configuration de lancement. C'est cette configuration que tu utilises quand tu veux exécuter ton application. Si tu regardes plus haut, je t'ai indiqué comment faire:

Ensuite, pour changer ta configuration de lancement, tu vas dans Run > Run configurations... Là, tu sélectionnes ta configuration dans la partie "Java Application". Puis, dans l'onglet "Classpath", tu sélectionnes l'entrée "User Entries" et là, tu cliques sur le bouton "Advanced...". Dans la popup affichée, tu choisis "Add Folders" et tu cliques sur "Ok". Tu sélectionnes le dossier de ton projet "ProjetA". Et voilà, tu peux exécuter pour tester.

Après, il te suffit de faire la même chose pour la configuration de lancement de ton "ProjetB".

Voilà, à+
Gueritarish

[Patrice Henrio]

En fait, tout ce qui est dans un dossier de source et qui n'est pas un .java devient une resource dans le classpath du project/du jar.
Donc tu mets ton fichier file.txt dans le "src/" (ou src/main/resources" si tu fais du Maven) et tu y accede avec getClass().getResourceAsStream("/file.txt").

Merci beaucoup.
Ca marche en effet.
Suis-je idiot mais comment se fait-il que ce point soit très rarement abordé de manière compréhensible ? Au vu du nombre de questions relatives au classpath, il me semble que les tutoriels sur ce sujet devraient indiquer que pour que les ressources soient accessibles de partout il suffit de mettre ces ressources dans le dossier src du projet au lieu de ce message sibylllin pour un néophyte :

Le Class Path est ce qui constitue le référencement des fichiers, répertoires, bibliothèques (jar), c'est-à-dire toute ressource nécessaire à l'exécution d'un programme Java au sein d'Eclipse. Il correspond bien évidemment au paramètre -classpath que l'on peut utiliser lors de l'appel des programmes Java, en ligne de commande.

Lors d'une première exécution de votre application Java, un Class Path est déterminé automatiquement. On peut toutefois le constituer spécifiquement et manuellement, à partir du menu Run > Run Configurations..., puis en ajoutant une configuration d'exécution de type Java Application (par exemple). Ainsi, une fois la configuration initiée (soit manuellement, soit lors de la première exécution de l'application), il est possible de l'ajuster en fonction de besoins particuliers, via l'onglet Classpath. Un Class Path est donc partie intégrante d'une configuration d'exécution d'un programme Java, au sein d'Eclipse.

[Patrice Henrio]

Bon finalement j'avais en effet pas tout compris, même après les diverses réponses qui m'ont été fournies.

Donc je résume.

Dans Eclipse un projet B référence un projet A. A utilise des ressources qui sont dans un répertoire C.
Pour utiliser ces ressources dans un projet, soit directement (A) soit indirectement (B) il faut modifier le classpath par défaut de éclipse.

Pour ce faire : cliquer droite sur le projet, choisir run as, puis run configuration.
Aller dans l'onglet classpath
cliquer sur user entries
cliquer sur advanced
cliquer sur add folder
ajouter le répertoire C.

Il faut faire cela dans chaque projet utilisant les ressources (ici A et B). C'est exactement ce qu'avait dit Gueritarish et que je n'avais pas compris.

Attention l'accès aux ressources se fera via la méthode getResourceAsStream(f) où f est la chaîne représentant la ressource. Elle s'utilise sous la forme this.getClass().getResourceAsStream(f).

Une entrée dans la FAQ d'Eclipse de cette explication ne me paraîtrait pas saugrenue.

Merci beaucoup à tous ceux qui m'ont permis de progresser sur ce point et merci surtout de leur patience.

Remarque : si on ne place pas C dans le classpath de A, il y aura une erreur lors de l'accès aux ressources au lancement de A. Mais si on lance B, pour lequel le classpath intègre bien le répertoire C il n'y aura pas d'erreur malgré l'appel au constructeur de classeA.

[Mickael_Istria]

Une entrée dans la FAQ d'Eclipse de cette explication ne me paraîtrait pas saugrenue.

Le concept de classpath peut paraître compliqué, mais c'est en fait une des bases de Java. Ce qu'il faut avoir en tête, c'est quel est le classpath lors de l'exécution de ton application (== quels sont les jars et les chemins dans lesquels ton application va chercher les classes et les ressources), et par conséquent, quelles ressources il va savoir trouver (toutes celles qui sont dans le classpath).

Pour la doc Eclipse, tout est la: http://help.eclipse.org/juno/index.j...build-path.htm
Eclipse a un concept de "build path" qui est en fait la projection du concept de classpath dans un IDE. Ce qui est dans ton build path sera (à l'exception des fichiers sources qui seront compilés) dans ton jar et donc disponible lors de l'exécution.