Le modèle Java est l'ensemble de classes qui modélisent les objets associés à la création, l'édition et la génération d'un programme Java. Les classes du modèle Java sont définies dans org.eclipse.jdt.core.Elles implémentent des comportements Java spécifiques pour les ressources et décomposent ces dernières en éléments du modèle.
Le package org.eclipse.jdt.core définit les classes qui modélisent les éléments dont un programme Java est constitué. JDT utilise un modèle objet "en mémoire" pour représenter la structure d'un programme Java. Cette structure est dérivée du chemin de classe du projet. Ce modèle est hiérarchique. Les éléments d'un programme peuvent être décomposés en éléments enfants.
La manipulation des éléments Java est similaire à celle des objets ressource.Lorsque vous travaillez sur un élément Java, vous manipulez en réalité un descripteur (ou "handle") désignant un objet sous-jacent du modèle.Vous devez utiliser le protocole exists() pour déterminer si l'élément est réellement présent dans l'espace de travail.
Le tableau suivant répertorie les différentes sortes d'éléments Java.
Elément | Description |
---|---|
IJavaModel | Représente l'élément Java racine, qui correspond à l'espace de travail. Il s'agit du parent de tous les projets de nature Java. Il vous permet également d'accéder aux projets qui ne sont pas de nature Java. |
IJavaProject | Représente un projet Java dans l'espace de travail. (Enfant de IJavaModel) |
IPackageFragmentRoot | Représente un ensemble de fragments de package et établit le lien entre ces fragments et une ressource sous-jacente qui peut être un dossier, un fichier JAR ou un fichier ZIP. (Enfant de IJavaProject) |
IPackageFragment | Représente la partie de l'espace de travail qui correspond à un package entier ou à une portion de ce package. (Enfant de IPackageFragmentRoot) |
ICompilationUnit | Représente un fichier source Java (.java) (Enfant de IPackageFragment) |
IPackageDeclaration | Représente une déclaration de package dans une unité de compilation. (Enfant de ICompilationUnit) |
IImportContainer | Représente l'ensemble de déclarations d'importation de packages dans une unité de compilation. (Enfant de ICompilationUnit) |
IImportDeclaration | Représente une déclaration d'importation de package particulière. (Enfant de IImportContainer) |
IType | Représente soit un type source à l'intérieur d'une unité de compilation, soit un type binaire à l'intérieur d'un fichier classe. |
IField | Représente un champ à l'intérieur d'un type. (Enfant de IType ) |
IMethod | Représente une méthode ou un constructeur à l'intérieur d'un type. (Enfant de IType ) |
IInitializer | Représente un initialiseur statique ou d'instance à l'intérieur d'un type. (Enfant de IType ) |
IClassFile | Représente un type compilé (binaire). (Elément enfant de IPackageFragment.) |
Tous les éléments Java prennent en charge l'interface IJavaElement.
Certains des éléments sont visibles dans la vue Packages. Ils implémentent l'interface IOpenable, puisqu'ils doivent être ouverts avant de pouvoir être parcourus. La figure ci-dessous montre comment ces éléments sont représentés dans la vue Packages.
Les éléments Java qui implémentent IOpenable sont créés essentiellement à partir des informations trouvées dans les fichiers ressource sous-jacents.On en retrouve une représentation générique dans la vue Navigateur de ressources.
D'autres éléments correspondent aux composants qui constituent une unité de compilation Java. La figure ci-dessous montre une unité de compilation Java et un "décomposeur de contenu" qui affiche les éléments source de cette unité.
Ces éléments implémentent l'interface ISourceReference, puisqu'ils peuvent fournir le code source correspondant. (Lorsqu'ils sont sélectionnés dans le décomposeur de contenu, leur code source s'affiche dans l'éditeur Java.)
De nombreux éléments Java correspondent à des ressources génériques dans l'espace de travail. Lorsque vous voulez créer des éléments Java à partir d'une ressource générique, la classe JavaCore constitue le point de départ le plus judicieux. Le fragment de code suivant montre comment obtenir des éléments Java à partir des ressources qui leur correspondent.
private void createJavaElementsFrom(IProject myProject, IFolder myFolder, IFile myFile) { IJavaProject myJavaProject = JavaCore.create(myProject); if (myJavaProject == null) // le projet n'est pas configuré pour Java (il ne possède pas de nature Java) return; // obtention d'un fragment de package ou d'une racine de fragment de package IJavaElement myPackageFragment = JavaCore.create(myFolder); // obtention d'un fichier .java (unité de compilation, d'un fichier .class (fichier classe ou // d'un fichier .jar (racine de fragment de package) IJavaElement myJavaFile = JavaCore.create(myFile); }
Dès que vous disposez d'un élément Java, vous pouvez utiliser l'API de JDT pour traverser et demander le modèle.Vous pouvez également demander les ressources non Java contenues dans un élément Java.
private void createJavaElementsFrom(IProject myProject, IFolder myFolder, IFile myFile) { ... // obtention des ressources non Java contenues dans le projet. Object[] nonJavaChildren = myJavaProject.getNonJavaResources(); ...
Lorsque vous créez un projet Java à partir d'un projet simple, JavaCore vérifie si la configuration de ce projet inclut la nature Java. Le plug-in du JDT utilise une nature de projet pour spécifier qu'un projet possède un comportement Java. Cette nature (org.eclipse.jdt.core.JavaCore#NATURE_ID) est affectée au projet lorsqu'il est créé par l'assistant "Nouveau projet Java". Si la nature Java n'est pas configurée pour un projet, JavaCore renvoie la valeur null lors de la création du projet.
JavaCore sert aussi à gérer les chemins de classes (classpath) Java, y compris les endroits où trouver les codes source et les bibliothèques et les endroits où placer les fichiers binaires (.class) générés.
Quelles sont les caractéristiques particulières des projets Java ? Ils enregistrent leur chemin d'accès aux classes dans un fichier ".classpath" et ajoute le générateur de projet incrémentiel Java à leur spécification de génération. Autrement, il s'agit de projets classiques pour lesquels les plug-ins peuvent configurer d'autres natures (et d'autres générateurs incrémentiels). Les plug-ins qui doivent ajouter un comportement Java à la configuration des projets en plus de leur propre comportement utilisent en général l'élément NewJavaProjectWizardPage pour affecter la nature Java au projet en complément de leurs propres natures ou comportement personnalisés.
IJavaModel peut être considéré comme l'élément parent de tous les projets de l'espace de travail qui possèdent la nature de projet Java (et qui, par conséquent, peuvent être traités comme des éléments IJavaProject).