Problème de récupération de la classe supérieure

**amine1980** · 04/08/2015, 18h13

Bonjour,

J'ai une classe Java déclarée comme suit :

Code :

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

public class Categorie extends AbstractDomain<String> {//Code........}

Je souhaite récupérer la chaîne AbstractDomain<String>, donc j'ai essayé de récupérer la classe sous forme de type CompilationUnit et j'ai fait

Code :

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

getClass().getSuperclass()

mais ça ne fonctionne pas. J'obtiens

class org.eclipse.jdt.internal.core.Openable

Quelqu'un saurait-il m'indiquer comment récupérer la chaîne AbstractDomain<String>, sans passer par le lecture du fichier ligne par ligne ?

Merci d'avance pour votre aide.

**joel.drigo** · 04/08/2015, 18h55

Salut,

La méthode que tu utilises permet d'obtenir les classes de la hiérarchie de classes de CompilationUnit, pas de la classe représentée par la CompilationUnit.

Je ferais comme ça :

Code :

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

1
2
3
4
5
6
7
((List<TypeDeclaration>)compilationUnit.types()).stream()
                                                .filter(typeDec-> !typeDec.isInterface())
                                                .findFirst()
                                                .ifPresent(typeDec-> {
                                                   Type type = typeDec.getSuperclassType();
                                                   List<TypeParameter> parameters = (List<TypeParameter>)typeDec.typeParameters();
                                                });

Type représente la classe, parameters, la liste des paramètres (on peut en avoir plusieurs bien sûr...)

Ou en Java 7 et inférieur :

Code :

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

1
2
3
4
5
6
for(TypeDeclaration typeDec : (Iterable<TypeDeclaration>)compilationUnit.types() ) {
   if ( !typeDec.isInterface() ) {
      Type type = typeDec.getSuperclassType();
      List<TypeParameter> parameters = (List<TypeParameter>)typeDec.typeParameters();
   }
}

**amine1980** · 06/08/2015, 18h13

bonjour,

Merci pour votre réponse, j'utilise java 8 mais ça pas marché, j'ai fait ce code :

Code :

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

1
2
3
4
5
((List<TypeDeclaration>) sPojo.types()).stream().filter(typeDec -> !typeDec.isInterface()).findFirst()
				.ifPresent(typeDec -> {
					Type type = typeDec.getSuperclassType();
					List<TypeParameter> parameters = (List<TypeParameter>) typeDec.typeParameters();
				});

ça me donne l'erreur de compilation suivante :

Multiple markers at this line
- TypeDeclaration cannot be resolved to a type
- The method types() is undefined for the type CompilationUnit
- List cannot be resolved to a type
- List<TypeDeclaration> cannot be resolved to a type

J'ai essayé d'importer le "TypeDeclaration" mais il me donne aucun suggestion, faut-il ajouter un jar?
merci d'avance.

**joel.drigo** · 06/08/2015, 18h17

CompilationUnit, c'est bien une classe du plugin org.eclipse.jdt.core ?

**amine1980** · 06/08/2015, 18h48

Bonjour,

Oui voici le code de la classe :

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
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
package utilitaire;
 
import generatetiers.Activator;
import generationclasses.preferences.PreferenceConstants;
 
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jface.preference.IPreferenceStore;
 
@SuppressWarnings("restriction")
public final class Generateur {
 
	private static String NOM_PAKAGE_COUCHE_PERSISTENCE = ".persistence";
	private static String EXTENSION_JAVA = ".java";
	private static String SUFFIXE_PERSISTENCE = "DAO";
	private static String pakageParent;
	private static String pakageParentToCreate;
	private static String nomClasse;
	private static IPackageFragment fragment;
	private static IJavaProject currentJavaProject;
 
	/**
         * Méthode de génération de la couche Persistence du pojo passé en paramètre.
         * 
         * @param sPojo
         * @param sPackage
         * @return
         * @throws JavaModelException
         */
	public static void genererCouchePersistence(final IPackageFragmentRoot srcFolder, final CompilationUnit sPojo,
			final String sUnitPersis) {
 
		((List<TypeDeclaration>) sPojo.types()).stream().filter(typeDec -> !typeDec.isInterface()).findFirst()
				.ifPresent(typeDec -> {
					Type type = typeDec.getSuperclassType();
					List<TypeParameter> parameters = (List<TypeParameter>) typeDec.typeParameters();
				});
 
		try {
			setPackageAndClasse(sPojo, NOM_PAKAGE_COUCHE_PERSISTENCE, srcFolder);
			StringBuffer sContenu = new StringBuffer();
			sContenu.append("package ");
			sContenu.append(pakageParentToCreate).append(";\n\n");
			sContenu.append("import javax.inject.Inject;\n");
			sContenu.append("import javax.inject.Named;\n");
			sContenu.append("import javax.persistence.EntityManager;\n");
			sContenu.append("import fr.gfi.core.persistence.AbstractJPA;\n");
			sContenu.append("import fr.gfi.rh.PuRh;\n");
			sContenu.append("import ").append(pakageParent).append(".").append(nomClasse).append(";\n\n");
			sContenu.append("/**\n");
			sContenu.append("* Data access class for {@link ").append(nomClasse).append("} domain.\n");
			sContenu.append("*\n");
			sContenu.append("* @author ").append(getAutheurClasses()).append("\n");
			sContenu.append("*/\n");
			sContenu.append("@Named\n");
			sContenu.append("public class ").append(nomClasse + SUFFIXE_PERSISTENCE).append(" extends AbstractJPA<")
					.append(nomClasse).append(",").append("Long>  {\n");
			sContenu.append("// PuRh annotation is used to identify persistence unit for domain object.\n");
			sContenu.append("@Inject\n");
			sContenu.append("@" + sUnitPersis + "\n");
			sContenu.append("private EntityManager entityManager;\n");
			sContenu.append("@Override\n");
			sContenu.append("public EntityManager getEntityManager() {\n");
			sContenu.append("return this.entityManager;\n");
			sContenu.append("}\n");
			sContenu.append("}\n");
			fragment.createCompilationUnit(nomClasse + SUFFIXE_PERSISTENCE + EXTENSION_JAVA, sContenu.toString(), false, null);
		} catch (JavaModelException e) {
			writeMarkers("La couche persistence non générée:  " + nomClasse + SUFFIXE_PERSISTENCE + EXTENSION_JAVA
					+ " existe déjà.");
		}
 
	}
 
	/**
         * Fonction de fénération de la couche controle du pojo passé en paramètre.
         * 
         * @param srcFolder
         * @param sPojo
         * @throws JavaModelException
         */
	public static void genererCoucheControle(final IPackageFragmentRoot srcFolder, final CompilationUnit sPojo) {}
 
 
	/**
         * Fonction setter de nom du package, dossier et classes.
         * 
         * @param sPojo
         * @param couche
         * @param srcFolder
         * @throws JavaModelException
         */
	private static void setPackageAndClasse(final CompilationUnit sPojo, final String couche,
			final IPackageFragmentRoot srcFolder) throws JavaModelException {
 
		pakageParent = sPojo.getPackageDeclarations()[0].getElementName();
		pakageParentToCreate = pakageParent.substring(0, pakageParent.lastIndexOf(".")) + couche;
		nomClasse = sPojo.getElementName().substring(0, sPojo.getElementName().length() - 5);
		fragment = srcFolder.createPackageFragment(pakageParentToCreate, true, null);
		pakageDomaine = pakageParent.substring(0, pakageParent.lastIndexOf("."));
	}
 
	/**
         * Setter de java project courant.
         * 
         * @param current
         */
	public static void setCurrentJavaProject(final IJavaProject current) {
		currentJavaProject = current;
	}
 
	/**
         * Fonction d'ajout des warnings
         * 
         * @param type
         * @param message
         * @param numLigne
         */
	private static void writeMarkers(final String message) {
		try {
			IResource resource = currentJavaProject.getUnderlyingResource();
			IMarker marker = resource.createMarker(IMarker.PROBLEM);
			marker.setAttribute(IMarker.MESSAGE, message);
			marker.setAttribute(IMarker.PRIORITY, IMarker.PRIORITY_HIGH);
			marker.setAttribute(IMarker.SEVERITY, 1);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
 
	/**
         * Fonction de récupération de l'autheur
         * 
         * @return
         */
	private static String getAutheurClasses() {
		IPreferenceStore store = Activator.getDefault().getPreferenceStore();
		String autheur = store.getString(PreferenceConstants.AUTHEUR);
		return autheur;
	}
 
}

On' a bien l'import :

Code :

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

import org.eclipse.jdt.internal.core.CompilationUnit;

Merci d'avance pour votre aide.

**joel.drigo** · 06/08/2015, 18h51

Importe d'abord java.util.List. Eclipse a du mal à importer les classes paramétres d'une classe non importée.
Par contre, je ne comprends pas trop pourquoi il ne voit pas la méthode types() de CompilationUnit : peut-être à cause des autres erreurs, à corriger avant.

**amine1980** · 10/08/2015, 15h50

Bonjour,

J'ai corrigé toutes les erreurs mais ça marche pas.
Ce qui me parait un peut blizzard c’est que lorsqu'on inspecte la variable "CompilationUnit sPojo", on n'y trouve pas la méthode types(), par contre il y' a bien la méthode getAllType[] mais ça ne renvoie pas la ligne souhaitée.

Merci d'avance.

**joel.drigo** · 10/08/2015, 16h06

La classe CompilationUnit que tu utilises est org.eclipse.jdt.internal.core.CompilationUnit, une implémentation concrète que tu ne devrais pas utiliser (package internal) : tu devrais toujours manipuler ces objets par l'interface org.eclipse.jdt.core.ICompilationUnit.

La classe dont je parle est org.eclipse.jdt.core.dom.CompilationUnit, qui modélise un AST (Abstract Syntax Tree) de la classe.

Tu peux obtenir un AST à partir d'un IOpenable :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public CompilationUnit createAST(IOpenable input) throws JavaModelException, CoreException {
  CompilationUnit root;
  ASTParser parser=ASTParser.newParser(AST.JLS8);
  parser.setResolveBindings(true);
  if (input instanceof ICompilationUnit) {
    parser.setSource((ICompilationUnit)input);
  }
 else {
    parser.setSource((IClassFile)input);
  }
  //parser.setStatementsRecovery(useStatementsRecovery);
  root=(CompilationUnit)parser.createAST(null);
  return root;
}

Problème de récupération de la classe supérieure

Eclipse Platform

Discussions similaires

Partager

Partager