La présente section explique comment définir le chemin de génération Java.Ce chemin de génération est en fait le chemin d'accès aux classes, utilisé pour la génération d'un projet Java (IJavaProject).
Un chemin de classe est tout simplement un tableau d'entrées de chemin d'accès aux classes (IClassPathEntry) décrivant les types disponibles.Les types peuvent apparaître sous forme source ou binaire et l'ordre des entrées dans le chemin définit l'ordre de recherche pour résoudre les types au cours d'une génération.
Le chemin de génération Java est reflété dans la structure d'un élément de projet Java.Vous pouvez rechercher un projet pour ses racines de fragments de package (IPackageFragmentRoot). Chaque entrée du chemin de classe mappe vers une ou plusieurs racines de fragments de package, chacune contenant un ensemble de fragments de package.
Cette discussion sur le chemin de génération n'implique pas le chemin d'exécution Java qui peut être défini séparément à partir du chemin de génération.Pour plus d'informations sur le chemin de classe d'exécution, reportez-vous à la rubriques Exécution du code Java.
Il est possible de modifier le chemin de génération d'un projet à l'aide d'un
programme en utilisant
setRawClasspath sur l'élément Java du projet correspondant.Le code suivant définit le chemin de classe d'une ressource de projet :
IProject project = ... // obtention des ressources du projet
IJavaProject javaProject = JavaCore.create(project);
IClasspathEntry[] newClasspath = ...;
javaProject.setRawClasspath(newClasspath, someProgressMonitor);
Remarque : L'utilisation du terme chemin de classe "brut" (raw) est destinée à mettre l'accent sur le fait que des variables utilisées pour décrire les emplacements des entrées n'ont pas été résolues.
Le chemin de génération Java est conservé dans un fichier appelé .classpath dans la structure de fichiers du projet.Ce fichier permet de partager les paramètres du chemin de génération Java avec d'autres par le biais d'un référentiel de code source. N'éditez pas ce fichier manuellement car il risque d'être corrompu.
Les entrées du chemin de classe peuvent être définies à l'aide des méthodes de fabrique définies sur JavaCore.Les entrées du chemin de classe peuvent faire référence à l'un des éléments suivants :
L'exemple suivant illustre une entrée de chemin de classe qui indique le
dossier source 'src' du projet 'MyProject' :
IClassPathEntry srcEntry = JavaCore.newSourceEntry(new Path("/MyProject/src"));
L'exemple suivant illustre une entrée de chemin de classe qui indique le
dossier de fichiers classe 'lib' de 'MyProject' :
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("/MyProject/lib"),
null, //aucune source
null, //aucune source
false); //non exporté
L'entrée de chemin de classe suivante dispose d'une connexion source :
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("d:/lib/foo.jar"), // emplacement de la bibliothèque
new Path("d:/lib/foo_src.zip"), //emplacement de l'archive source
new Path("src"), //chemin de la racine de l'archive source
true); //exporté
Le chemin racine de l'archive source décrit l'emplacement de la racine au sein de l'archive source.Si sa valeur est null, la racine de l'archive est induite de façon dynamique.
L'entrée de chemin de classe suivante indique un projet prérequis 'MyFramework'.
IClassPathEntry prjEntry = JavaCore.newProjectEntry(new Path("/MyFramework"), true); //exporté
Il est possible d'enregistrer un initialiseur de variable de chemin de classe appelé par le biais du point d'extension org.eclipse.jdt.core.classpathVariableInitializer lorsque l'espace de travail est démarré.
L'entrée de chemin de classe suivante indique une bibliothèque dont
l'emplacement est conservé dans la variable 'HOME'. La connexion source est
définie à l'aide des variables 'SRC_HOME' et 'SRC_ROOT' :
IClassPathEntry varEntry = JavaCore.newVariableEntry(
new Path("HOME/foo.jar"), // emplacement de la bibliothèque
new Path("SRC_HOME/foo_src.zip"), //emplacement de l'archive source
new Path("SRC_ROOT"), //chemin racine de l'archive source
true); //exporté
JavaCore.setClasspathVariable("HOME", new Path("d:/myInstall"), null); // aucune progression
Il est possible d'enregistrer un initialiseur de conteneur de chemins d'accès aux classes qui est appelé par le biais du point d'extension org.eclipse.jdt.core.classpathContainerInitializer lorsque le conteneur doit être lié.
L'entrée de chemin de classe suivante indique un conteneur de bibliothèque
de classes système :
IClassPathEntry varEntry = JavaCore.newContainerEntry(
new Path("JDKLIB/default"), // conteneur 'JDKLIB' + hint 'default'
false); //non exporté
JavaCore.setClasspathContainer(
new Path("JDKLIB/default"),
new IJavaProject[]{ myProject }, // valeur de 'myProject'
new IClasspathContainer[] {
new IClasspathContainer() {
public IClasspathEntry[] getClasspathEntries() {
return new IClasspathEntry[]{
JavaCore.newLibraryEntry(new Path("d:/rt.jar"), null, null, false);
};
}
public String getDescription() { return "Basic JDK library container"; }
public int getKind() { return IClasspathContainer.K_SYSTEM; }
public IPath getPath() { return new Path("JDKLIB/basic"); }
}
},
null);
Un schéma d'exclusion peut être affecté à une entrée source de chemin de classe, empêchant certaines ressources d'un dossier source d'être visibles dans le chemin de classe.L'utilisation d'un schéma permet de filtrer les parties spécifiées de l'arborescence de ressources.Chaque chemin de schéma d'exclusion est relatif à l'entrée du chemin de classe et utilise un mécanisme similaire à Ant.Les schémas d'exclusion peuvent être utilisés pour spécifier les dossiers source imbriqués tant que le schéma externe exclut le schéma interne.
Pour plus de détails sur les schémas d'exclusion, reportez-vous à getExclusionPatterns().
L'API de projet Java isOnClasspath vérifie les schémas d'inclusion et d'exclusion avant de déterminer si une ressource particulière se trouve dans le chemin d'accès aux classes.
Remarques :
IPath sourceFolder = new Path("/MyProject/src"); IPath outputLocation = sourceFolder.append("bin"); IClassPathEntry srcEntry = JavaCore.newSourceEntry( sourceFolder, // emplacement du dossier source new Path[] { outputLocation }, // dossier imbriqué exclu outputLocation); // emplacement de sortie
Un schéma d'inclusion peut également être attribué à une entrée de source de chemin de classe,qui définit de manière explicite les ressources afin qu'elles soient visibles sur le chemin de classe. Lorsque aucun schéma d'inclusion n'est spécifié, l'entrée de la source inclut tous les fichiers pertinents de l'arborescence de ressources ayant pour racine ce chemin d'entrée de source. L'indication d'un ou de plusieurs schémas d'inclusion signifie que seules les parties indiquées de l'arborescence des ressources doivent être indiquées. Chaque chemin indiqué doit être un chemin relatif et sera interprété en fonction de chemin de l'entrée source. Vous devez respecter l'utilisation des majuscules et des minuscules dans le masque de fichiers. Un fichier correspondant à un ou plusieurs masques est inclus dans la racine de fragment de package correspondant sauf s'il est exclu par un ou plusieurs schémas d'exclusion de l'entrée.
Pour obtenir plus d'informations sur la syntaxe et la sémantique des schémas de chemin, reportez-vous à getExclusionPatterns(). L'absence de schéma d'inclusion équivaut du point de vue sémantique au schéma d'inclusion explicite **
.
L'API de projet Java isOnClasspath vérifie les schémas d'inclusion et d'exclusion avant de déterminer si une ressource particulière se trouve dans le chemin d'accès aux classes.
Exemples :
src/**
lui-même inclut tous les fichiers sous un dossier racine nommé
src
.
src/**
et tests/**
incluent tous les fichiers sous les dossiers racine nommés src
et tests
.
src/**
ainsi que le schéma d'exclusion
src/**/Foo.java
incluent tous les fichiers sous un dossier racine
nommé src
, sauf les fichiers nommés Foo.java
.