Cette section explique comment définir le chemin de compilation Java. Ce chemin de compilation est en fait le chemin d'accès aux classes, utilisé pour la compilation 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 compilation.
Le chemin de compilation 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 compilation n'implique pas le chemin d'exécution Java qui peut être défini séparément à partir du chemin de compilation. 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 compilation 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 = ... // get some project resource
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 compilation 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 compilation 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, //no source
null, //no source
false); //not exported
L'entrée de chemin de classe suivante dispose d'une connexion source :
IClassPathEntry libEntry = JavaCore.newLibraryEntry(
new Path("d:/lib/foo.jar"), // library location
new Path("d:/lib/foo_src.zip"), //source archive location
new Path("src"), //source archive root path
true); //exported
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); //exported
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"), // library location
new Path("SRC_HOME/foo_src.zip"), //source archive location
new Path("SRC_ROOT"), //source archive root path
true); //exported
JavaCore.setClasspathVariable("HOME", new Path("d:/myInstall"), null); // no progress
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"), // container 'JDKLIB' + hint 'default'
false); //not exported
JavaCore.setClasspathContainer(
new Path("JDKLIB/default"),
new IJavaProject[]{ myProject }, // value for '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'exclusion avant de déterminer si une ressource particulière se trouve dans le chemin de classe.