Compilazione del codice Java

I plug-in di JDT comprendono un compilatore Java incrementale e batch per la generazione di file .class Java dal codice origine. Nessuna API è direttamente fornita dal compilatore. Questa viene installata come generatore su progetti Java. La compilazione viene attivata utilizzando meccanismi di creazione della piattaforma standard.

Il meccanismo di creazione della piattaforma viene dettagliatamente descritto nella sezione relativa ai generatori di progetti incrementali.

Compilazione del codice

È possibile compilare in modo programmatico i file origine Java in un progetto utilizzando l'API di generazione.

   IProject myProject;
   IProgressMonitor myProgressMonitor;
   myProject.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, myProgressMonitor);

Per un progetto Java, questa richiama il generatore incrementale di progetto Java (insieme a qualsiasi altro generatore incrementale di progetto aggiunto alla specifica di generazione del progetto). I file .class generati vengono scritti nella cartella di output designata. Nella cartella di output vengono copiati anche altri file di risorse. 

Nel caso di una generazione di batch completa, tutti i file .class della cartella di output vengono 'ripuliti' per garantire che non vengano rilevati file non aggiornati. Questa operazione viene controllata mediante un'opzione del generatore principale JDT (CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER).  L'impostazione predefinita per questa opzione è ripulire le cartelle di output.  A meno che questa opzione non venga reimpostata, accertarsi di inserire tutti i file .class per i quali non sono presenti file di origine corrispondenti in cartelle di file di classe separate nel percorso classi e non nella cartella di output.

I generatori incrementali e di batch possono essere configurati con altre opzioni che controllano le risorse copiate nella cartella di output.  L'esempio di seguito riportato mostra come impostare un filtro di risorse in modo che i file che terminano con '.ignore' e le cartelle denominate 'META-INF' non vengano copiate nella cartella di output:

   Hashtable options = JavaCore.getOptions();
   options.put(JavaCore.CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, "*.ignore,META-INF/");
   JavaCore.setOptions(options);

I nomi file vengono filtrati se corrispondono a uno dei modelli forniti. Intere cartelle vengono filtrate se i relativi nomi corrispondono a uno dei nomi di cartella forniti terminanti con un separatore di percorso.

È anche possibile configurare i generatori di batch e incrementali in modo che generino un unico errore quando il file .classpath presenta errori. Questa opzione è attiva per impostazione predefinita ed elimina numerosi errori.  Per un elenco completo delle opzioni correlate al generatore e delle relative impostazioni predefinite, consultare la sezione relativa alle opzioni del generatore principale JDT.

Il compilatore può essere configurato anche mediante le opzioni JavaCore.  Ad esempio, è possibile definire la gravità che deve essere utilizzata per i diversi tipi di problemi rilevati durante la compilazione.  Per un elenco completo delle opzioni correlate al compilatore e delle relative impostazioni predefinite, consultare la sezione relativa alle opzioni del compilatore principale JDT.

Quando si configurano programmaticamente le opzioni per il generatore o il compilatore, è necessario determinare l'ambito dell'opzione.  Ad esempio, l'impostazione di un filtro di risorse può essere applicata solo ad un determinato progetto.   Nell'esempio di seguito riportato viene impostato lo stesso filtro di risorse illustrato precedentemente, ma solo per un singolo progetto.

   
   Hashtable options = myProject.getOptions(false);  // visualizzare solo le opzioni impostate nel progetto
   options.put(JavaCore.CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, "*.ignore,META-INF/");
   myProject.setOptions(options);

Utilizzo dell'adattatore javac ant

Utilizzando l'adattatore javac, è possibile utilizzare il compilatore Eclipse all'interno di uno script Ant. Per utilizzare il compilatore Eclipse, è sufficiente semplicemente definire la proprietà build.compiler nello script. Di seguito viene riportato un breve esempio.
<?xml version="1.0" encoding="UTF-8" ?>
<project name="compile" default="main" basedir="../.">

	<property name="build.compiler" value="org.eclipse.jdt.core.JDTCompilerAdapter"/>

	<property name="root" value="${basedir}/src"/>

	<property name="destdir" value="d:/temp/bin" />

	<target name="main">
		<javac srcdir="${root}" destdir="${destdir}" debug="on" nowarn="on" extdirs="d:/extdirs" source="1.4">
		    <classpath>
		      <pathelement location="${basedir}/../org.eclipse.jdt.core/bin"/>
		    </classpath>
		</javac>		
	</target>
</project>
La sintassi utilizzata per l'attività javac ant si trova nella documentazione relativa alle attività javac ant. L'adattatore corrente supporta l'attività Javac Ant 1.4.1. La versione 1.5 sarà disponibile quando verrà rilasciato Ant 1.5.

Determinazione dei problemi

Il JDT di base definisce un indicatore specializzato (tipo di indicatore "org.eclipse.jdt.core.problem") per evidenziare problemi di compilazione. Per scoprire in modo programmatico i problemi rilevati dal compilatore, utilizzare il protocollo degli indicatori di piattaforma standard. Per una panoramica sull'utilizzo degli indicatori, fare riferimento alla sezione relativa agli indicatori di risorse.

Il seguente frammento di codice rileva tutti gli indicatori di problemi Java all'interno di un'unità di compilazione.

   public IMarker[] findJavaProblemMarkers(ICompilationUnit cu) 
      throws CoreException {
      IResource javaSourceFile = cu.getUnderlyingResource();
      IMarker[] markers = 
         javaSourceFile.findMarkers(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER,
            true, IResource.DEPTH_INFINITE);
   }

Gli indicatori di problemi Java vengono conservati dal generatore di progetto Java e vengono automaticamente rimossi nel momento in cui i problemi vengono risolti e il codice origine Java viene nuovamente compilato.

Il valore id del problema è impostato da una delle costanti in IProblem . L'id del problema è affidabile, tuttavia il messaggio è localizzato, pertanto è possibile modificarlo in base alla locale predefinita. Le costanti definite in IProblem si descrivono autonomamente.

Per raccogliere i problemi rilevati durante un'operazione Java, è necessario definire un'implementazione di IProblemRequestor. È possibile riconciliare le copie di lavoro con la rilevazione dei problemi se è stato fornito un IProblemRequestor per la creazione della copia di lavoro. A questo scopo, è possibile utilizzare il metodo reconcile. Ad esempio:

  ICompilationUnit unit = ..; // richiamare un'unità di compilazione
			
  // creare il richiedente per la raccolta dei problemi rilevati
  IProblemRequestor problemRequestor = new IProblemRequestor() {
    public void acceptProblem(IProblem problem) {
      System.out.println(problem.getID() + ": " + problem.getMessage());
    }
    public void beginReporting() {}
    public void endReporting() {}
    public boolean isActive() {	return true; } // se attivo, rileva i problemi
  };
    
  // utilizzare la copia di lavoro per conservare l'originale con l'errore
  IWorkingCopy workingCopy = (IWorkingCopy)unit.getWorkingCopy(null, null, problemRequestor);
  ((IOpenable)workingCopy).getBuffer().setContents("public class X extends Zork {}");

  // riconciliazione trigger			
  workingCopy.reconcile(true, null);
È possibile aggiungere un'azione ai problemi riportati nel metodo acceptProblem(IProblem). In questo esempio, il problema riportato è che Zork non può essere risolto oppure non è una superclasse valida e il relativo id è IProblem.SuperclassNotFound.

Copyright IBM Corporation e altri 2000, 2003. Tutti i diritti riservati.