Come si imposta il percorso di generazione Eclipse e il percorso classe da un file di build Ant?

Question

C'è un sacco di discussioni su Ant e Eclipse, ma nessuna risposta precedente sembra aiutarmi.

Ecco l'affare: sto cercando di creare un programma Java che compaia correttamente con Ant dalla riga di comando. (Per confondere ulteriormente le cose, il programma che sto tentando di compilare è Ant stesso.)

Quello che voglio veramente fare è portare questo progetto in Eclipse e farlo compilare in Eclipse in modo tale che i tipi di binding e le associazioni di variabili (nomenclatura da Eclipse JDT) sono stati risolti correttamente. Ho bisogno di questo perché ho bisogno di eseguire un'analisi statica sul codice che è costruito su Eclipse JDT. Il modo normale in cui porto un progetto Java in Eclipse in modo che Eclipse lo costruisca e risolva tutti i binding è quello di importare semplicemente le directory di origine in un progetto Java e quindi dirgli di usare la directory src/main/come "directory di origine" ".

Sfortunatamente, farlo con Ant causa il fallimento della compilazione con numerosi errori di compilazione. Mi sembra che il file di build Ant stia configurando il percorso della classe e il percorso di compilazione correttamente (possibilmente escludendo alcuni file sorgente) ed Eclipse non ha questa informazione.

C'è un modo per prendere il percorso classe &, creare informazioni sul percorso incorporate in un file di build Ant e fornire tali informazioni a Eclipse per inserire i suoi file .project e .classpath? Ho provato, creando un nuovo progetto da un file di build esistente (un'opzione nel menu File) ma questo non aiuta. Il progetto ha ancora gli stessi errori di compilazione.

Grazie, Nels

Answer 1

non ho mai trovato un modo davvero pulito per farlo, ma in un modo "hacker" per farlo è quello di manipolare gli usi di file .classpath Eclipse (questo contiene il percorso di generazione) .

Così il .classpath sta per avere roba in questo modo:

<classpathentry kind="lib" path="C:/jboss-4.2.3.GA/client/jboss-system-client.jar"/> 

Così si potrebbe, ad esempio, scrivere una sorta di script batch, ecc, che avrebbe letto le vostre dipendenze fra i file di formiche e mettere nel file .classpath di eclissi (nel formato corretto, ovviamente).

Ma personalmente, non mi diverto mai con queste cose. Quello che faccio è solo mettere tutti i barattoli mie esigenze di progetto in una cartella, e poi nel mio file formica ho un percorso impostato in questo modo:

<path id="all_libs"> 
    <fileset dir="test_reflib"> 
     <include name="**/*.jar"/> 
    </fileset> 
</path> 

test_reflib ha solo bisogno di essere definito ovunque questa cartella è che contiene tutti i vasi.

Quindi, sul lato dell'eclisse si può semplicemente fare un "Aggiungi giare" e navigare in questa stessa cartella e scegliere solo tutti i vasi. Ciò che è ancora più interessante è che ogni volta che si rilasciano nuovi jar in questa cartella, basta fare clic sul livello principale nel progetto eclipse e fare "Aggiorna", quindi modificare il percorso di generazione e fare nuovamente clic su aggiungi jar e mostrerà solo i barattoli che non hai ancora aggiunto al percorso di generazione (cioè il nuovo jar che hai appena inserito nella cartella).

Questo ovviamente non funziona molto bene se si condividono i barattoli in una posizione centrale, ma funziona piuttosto bene per i progetti più piccoli in cui è possibile copiare tutti i vasi in una cartella centralizzata per il progetto.

Answer 2

Dalla distribuzione della formica grezza, eseguire prima "ant-f fetch.xml" (o simile) per scaricare un sacco di dipendenze necessarie. Aggiungi questi al tuo progetto Eclipse e vedi se aiuta.

Answer 3

Abbiamo generato file .classpath e .project di Eclipse da Ant per un progetto di grandi dimensioni con jar posizionati centralmente (100+) (senza contare src jars e javadocs). Simile al build.xml collegato da here con l'ovvia aggiunta degli attributi src e javadoc.

Answer 4

Uso l'edera per gestire i miei classpath ANT, consiglio vivamente di imparare come funziona.

C'è un eclipse plugin che gestirà il classpath eclisse dalla stessa ivy.xml file ANT usa per definire sia le dipendenze.

Answer 5

Ho scritto un Task Ant che genera un file .userlibraries di Eclipse. È possibile importare il file generato per creare una libreria utente in Eclipse. E quindi utilizzare questa libreria utente come parte del percorso di generazione.

Per utilizzare il compito aggiungere questo al file Ant:

<target name="createEclipseUserLibraries" 
     description="Creates classpath and bootclasspatch that can be imported into Eclipse"> 
    <taskdef name="createEclipseUserLibraries" 
      classname="com.forumsys.tools.CreateEclipseUserLibraries" 
      classpathref="yourclasspathref"/> 
    <createEclipseUserLibraries classpathref="classpathref" bootclasspathref="bootclasspathref"/> 
</target> 

Ant Task. Richiede ant.jar per eseguire e compilare:

import java.io.BufferedOutputStream; 
import java.io.File; 
import java.io.FileOutputStream; 
import java.io.IOException; 

import org.apache.tools.ant.BuildException; 
import org.apache.tools.ant.Project; 
import org.apache.tools.ant.Task; 
import org.apache.tools.ant.types.Path; 
import org.apache.tools.ant.types.Reference; 

/** 
* A custom tag to create a file the eclipse can import to setup a user libraries. 
* 
* Created: Mar 29, 2014 9:44:09 AM 
* 
* @author <a href="mailto:jslopez@gmail.com">Javier S. López</a> 
* @version 1.0 
*/ 
public class CreateEclipseUserLibraries extends Task { 
    public static final String UTF8_ENCODING = "UTF-8"; 
    public static final String DEFAULT_BOOT_CLASSPATH_LIBRARY_NAME = "SYSTEM_LIBRARY"; 
    public static final String DEFAULT_CLASSPATH_LIBRARY_NAME = "LIBRARY"; 
    public static final String DEFAULT_DESTINATION = "Eclipse.userlibraries"; 
    private static final String INDENT = " "; 
    private Path _classpath; 
    private Path _bootClasspath; 
    private String _bootClasspathLibraryName = DEFAULT_BOOT_CLASSPATH_LIBRARY_NAME; 
    private String _classpathLibraryName = DEFAULT_CLASSPATH_LIBRARY_NAME; 
    private String _destination = DEFAULT_DESTINATION; 

    public void setClasspath(final Path classpath) { 
     if (_classpath == null) { 
      _classpath = classpath; 
     } else { 
      _classpath.append(classpath); 
     } 
    } 

    public void setClasspathRef(final Reference reference) { 
     if (_classpath == null) { 
      final Project antProject = getProject(); 
      _classpath = new Path(antProject); 
     } 
     _classpath.setRefid(reference); 
    } 

    public void setBootClasspath(final Path bootClasspath) { 
     if (_bootClasspath == null) { 
      _bootClasspath = bootClasspath; 
     } else { 
      _bootClasspath.append(bootClasspath); 
     } 
    } 

    public void setBootClasspathRef(final Reference reference) { 
     if (_bootClasspath == null) { 
      final Project antProject = getProject(); 
      _bootClasspath = new Path(antProject); 
     } 
     _bootClasspath.setRefid(reference); 
    } 

    public void setClasspathLibraryName(final String name) { 
     if (!isEmpty(name)) { 
      _classpathLibraryName = name; 
     } 
    } 

    public void setBootClasspathLibraryName(final String name) { 
     if (!isEmpty(name)) { 
      _bootClasspathLibraryName = name; 
     } 
    } 

    public void setDestination(final String argDestination) { 
     if (!isEmpty(argDestination)) { 
      _destination = argDestination; 
     } 
    } 

    @Override 
    public void execute() throws BuildException { 
     if (_classpath == null) { 
      throw new BuildException("classpath or classpathref attribute must be set"); 
     } 

     if (_bootClasspath == null) { 
      throw new BuildException("bootclasspath or bootclasspathref attribute must be set"); 
     } 
     try { 
      createUserLibrariesFile(); 
     } catch (final IOException e) { 
      throw new BuildException(e.getMessage(), e); 
     } 
    } 

    /** 
    * @throws IOException 
    * 
    */ 
    private void createUserLibrariesFile() throws IOException { 
     final StringBuilder stringBuilder = new StringBuilder(); 
     stringBuilder.append("<?final xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>"); 
     stringBuilder.append("\n"); 
     stringBuilder.append("<eclipse-userlibraries version=\"2\">").append("\n"); 
     createBootClasspathLibrary(stringBuilder); 
     createClasspathLibrary(stringBuilder); 
     stringBuilder.append("</eclipse-userlibraries>"); 

     final Project antProject = getProject(); 
     final File baseDir = antProject.getBaseDir(); 
     final File file = new File(baseDir, _destination); 
     if (file.exists()) { 
      file.delete(); 
     } 
     final boolean append = false; 
     BufferedOutputStream bos = null; 
     try { 
      final FileOutputStream fos = new FileOutputStream(file, append); 
      bos = new BufferedOutputStream(fos); 
      bos.write(stringBuilder.toString().getBytes(UTF8_ENCODING)); 
      bos.flush(); 
     } finally { 
      if (bos != null) { 
       bos.close(); 
      } 
     } 
    } 

    /** 
    * @param stringBuilder 
    * 
    */ 
    private void createBootClasspathLibrary(final StringBuilder stringBuilder) { 
     createLibrary(stringBuilder, _bootClasspathLibraryName, true, _bootClasspath); 
    } 

    /** 
    * @param stringBuilder 
    */ 
    private void createClasspathLibrary(final StringBuilder stringBuilder) { 
     createLibrary(stringBuilder, _classpathLibraryName, false, _classpath); 
    } 

    /** 
    * @param stringBuilder 
    * @param bootClasspathLibraryName 
    * @param b 
    * @param bootClasspath 
    */ 
    private void createLibrary(final StringBuilder stringBuilder, final String libraryName, 
     final boolean isSystemLibrary, final Path path) { 
     stringBuilder.append(INDENT).append("<library name=\"").append(libraryName); 
     stringBuilder.append("\" systemlibrary=\"").append(Boolean.toString(isSystemLibrary)).append("\">\n"); 
     final String[] paths = path.list(); 
     final Project antProject = getProject(); 
     final File baseDir = antProject.getBaseDir(); 
     final String baseDirName = baseDir.getName(); 

     for (final String strPath : paths) { 
      final int index = strPath.indexOf(baseDirName); 
      //Only include the relative path 
      if (index != -1) { 
       stringBuilder.append(INDENT).append(INDENT); 
       stringBuilder.append("<archive path=\"").append(
        strPath.substring(index - 1)).append("\"/>\n"); 
      } 
     } 

     stringBuilder.append(INDENT).append("</library>\n"); 
    } 

    public static final boolean isEmpty(final String str) { 
     return (str == null) || (str.length() == 0); 
    } 
}