Wie kann ich den Eclipse build path und classpath von Ant-build-Datei?

Habe ich nie eine wirklich saubere Art und Weise, es zu tun, aber ein "hackish" Weg, es zu tun ist, um zu manipulieren .classpath Datei eclipse verwendet (diese enthält die build-Pfad).

Also die .classpath ist zu haben, Sachen in der es wie folgt:

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

So könnte man, zum Beispiel, schreiben Sie eine Art batch-Skript, etc. das würde das Lesen Ihrer ant-Datei-Abhängigkeiten und setzen Sie Sie in die Finsternis .classpath-Datei (im richtigen format, natürlich).

Aber persönlich bin ich nie Narr mit solchen Dingen. Was ich mache ist einfach alle jars mein Projekt muss in einem Ordner, und dann in mein ant-Datei habe ich einen Pfad wie folgt eingerichtet:

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

test_reflib muss nur definiert werden, wo dieser Ordner enthält alle die Gläser.

Dann auf der eclipse-Seite können Sie nur ein "Add jars" und navigieren Sie zu diesem Ordner und wählen Sie einfach alle die Gläser. Was noch cooler ist, dass jedes mal, wenn Sie drop neue Gläser in diesem Ordner, klicken Sie einfach auf der root-Ebene in das eclipse-Projekt und zu "Aktualisieren", und Bearbeiten Sie dann den build path und klicken Sie auf add jar erneut, und es wird nur zeigen Ihnen die Gläser, die Sie noch nicht Hinzugefügt build path noch (also die neue jar-Datei, die Sie gerade gelöscht in dem Ordner).

Dieser offensichtlich nicht allzu gut funktionieren, wenn Sie teilen sich die Gläser an einem zentralen Ort, aber es funktioniert sehr gut für kleinere Projekte, wo Sie können einfach kopieren Sie die Gläser über einen zentralen Ordner für das Projekt.

Schrieb ich einen Ant-Task generiert eine Sonnenfinsternis .userlibraries-Datei. Sie können importieren Sie die erzeugte Datei zum erstellen einer Anwender-Bibliothek in Eclipse. Und dann verwenden Sie diese Benutzer-Bibliothek als Teil Ihrer build-Pfad.

Mit dem task fügen Sie diese an Ihre ant-build-Datei:

<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. Es erfordert ant.jar zum ausführen und kompilieren:

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:[email protected]">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);
    }
}

Haben wir generiert von Eclipse .classpath und .Projekt-Dateien aus Ant für ein großes Projekt mit zentral-Gläsern (100+) (nicht mitgerechnet src Gläser und javadocs). Ähnlich wie die build.xml Links von hier mit dem offensichtlichen Zusatz von src-und javadoc-Attribute.