Build Eclipse Java Project from Command Line

Question

Is there a way to compile an Eclipse-based Java project from the command line?

I'm trying to automate my build (using FinalBuilder not ant), and I'm neither a Java nor Eclipse expert. I can probably figure out how to do this with straight java command line options, but then the Eclipse project feels like a lot of wasted effort.

In the event that there is no way to compile an Eclipse project via the command line, is there a way to generate the required java command line from within Eclipse? Or are there some files I can poke around to find the compile steps it is doing behind the scenes?

---

Guys, I'm looking for an answer that does NOT include ant. Let me re-iterate the original question ....... Is there a way to build an Eclipse project from the command line?

I don't think this is an unreasonable question given that I can do something like this for visual studio:

devenv.exe /build "Debug|Any CPU" "C:\Projects\MyProject\source\MyProject.sln"

Solution 1

You can build an eclipse project via a workspace from the command line:

eclipsec.exe -noSplash -data "D:\Source\MyProject\workspace" -application org.eclipse.jdt.apt.core.aptBuild

It uses the jdt apt plugin to build your workspace automatically. This is also known as a 'Headless Build'. Damn hard to figure out. If you're not using a win32 exe, you can try this:

java -cp startup.jar -noSplash -data "D:\Source\MyProject\workspace" -application org.eclipse.jdt.apt.core.aptBuild

Update

Several years ago eclipse replaced startup.jar with the "equinox launcher"

https://wiki.eclipse.org/Equinox_Launcher

On Eclipse Mars (MacOX):

java -jar /Applications/Eclipse.app/Contents/Eclipse/plugins/org.eclipse.equinox.launcher_1.3.100.v20150511-1540.jar -noSplash -data "workspace" -application org.eclipse.jdt.apt.core.aptBuild

The -data parameter specifies the location of your workspace.

The version number for the equinox launcher will depend on what version of eclipse you have.

Solution 2

To complete André's answer, an ant solution could be like the one described in Emacs, JDEE, Ant, and the Eclipse Java Compiler, as in:

      <javac
          srcdir="${src}"
          destdir="${build.dir}/classes"> 
        <compilerarg 
           compiler="org.eclipse.jdt.core.JDTCompilerAdapter" 
           line="-warn:+unused -Xemacs"/>
        <classpath refid="compile.classpath" />
      </javac>

The compilerarg element also allows you to pass in additional command line args to the eclipse compiler.

You can find a full ant script example here which would be invoked in a command line with:

java -cp C:/eclipse-SDK-3.4-win32/eclipse/plugins/org.eclipse.equinox.launcher_1.0.100.v20080509-1800.jar org.eclipse.core.launcher.Main -data "C:\Documents and Settings\Administrator\workspace" -application org.eclipse.ant.core.antRunner -buildfile build.xml -verbose

---

BUT all that involves ant, which is not what Keith is after.

For a batch compilation, please refer to Compiling Java code, especially the section "Using the batch compiler"

The batch compiler class is located in the JDT Core plug-in. The name of the class is org.eclipse.jdt.compiler.batch.BatchCompiler. It is packaged into plugins/org.eclipse.jdt.core_3.4.0..jar. Since 3.2, it is also available as a separate download. The name of the file is ecj.jar.
Since 3.3, this jar also contains the support for jsr199 (Compiler API) and the support for jsr269 (Annotation processing). In order to use the annotations processing support, a 1.6 VM is required.

Running the batch compiler From the command line would give

java -jar org.eclipse.jdt.core_3.4.0<qualifier>.jar -classpath rt.jar A.java

or:

java -jar ecj.jar -classpath rt.jar A.java

All java compilation options are detailed in that section as well.

The difference with the Visual Studio command line compilation feature is that Eclipse does not seem to directly read its .project and .classpath in a command-line argument. You have to report all information contained in the .project and .classpath in various command-line options in order to achieve the very same compilation result.

So, then short answer is: "yes, Eclipse kind of does." ;)

Solution 3

After 27 years, I too, am uncomfortable developing in an IDE. I tried these suggestions (above) - and probably just didn't follow everything right -- so I did a web-search and found what worked for me at 'http://incise.org/android-development-on-the-command-line.html'.

The answer seemed to be a combination of all the answers above (please tell me if I'm wrong and accept my apologies if so).

As mentioned above, eclipse/adt does not create the necessary ant files. In order to compile without eclipse IDE (and without creating ant scripts):

1) Generate build.xml in your top level directory:

android list targets  (to get target id used below)

android update project --target target_id --name project_name  --path top_level_directory

   ** my sample project had a target_id of 1 and a project name of 't1', and 
   I am building from the top level directory of project
   my command line looks like android update project --target 1 --name t1 --path `pwd`

2) Next I compile the project. I was a little confused by the request to not use 'ant'. Hopefully -- requester meant that he didn't want to write any ant scripts. I say this because the next step is to compile the application using ant

 ant target

    this confused me a little bit, because i thought they were talking about the
    android device, but they're not.  It's the mode  (debug/release)
    my command line looks like  ant debug

3) To install the apk onto the device I had to use ant again:

 ant target install

    ** my command line looked like  ant debug install

4) To run the project on my android phone I use adb.

 adb shell 'am start -n your.project.name/.activity'

    ** Again there was some confusion as to what exactly I had to use for project 
    My command line looked like adb shell 'am start -n com.example.t1/.MainActivity'
    I also found that if you type 'adb shell' you get put to a cli shell interface
    where you can do just about anything from there.

3A) A side note: To view the log from device use:

 adb logcat

3B) A second side note: The link mentioned above also includes instructions for building the entire project from the command.

Hopefully, this will help with the question. I know I was really happy to find anything about this topic here.

Solution 4

The normal apporoach works the other way around: You create your build based upon maven or ant and then use integrations for your IDE of choice so that you are independent from it, which is esp. important when you try to bring new team members up to speed or use a contious integration server for automated builds. I recommend to use maven and let it do the heavy lifting for you. Create a pom file and generate the eclipse project via mvn eclipse:eclipse. HTH

Solution 5

This question contains some useful links on headless builds, but they are mostly geared towards building plugins. I'm not sure how much of it can be applied to pure Java projects.

View more solutions

Comments

[VonC]

Short answer: yes. Eclipse kind of does. Except you have to report all information contained in the .project and .classpath in various command-line options

[matbrgz]

It is possible to compile a workspace with Eclipse project using the ant4eclipse project, but it needs a lot of elbow grease as you need to do all the necessary steps manually based on the meta information you extract. I've done it for our inhouse projects, but I would not recommend it unless you REALLY need to! We did :-D

[VonC]

@Thorbjørn Ravn Andersen: thank you for this feedback. You could also post an answer in this thread illustrating the kind of "elbow grease" involved here ;)

[JR Lawhorne]

External (to Eclipse) build solutions like ant or maven are typically used for this, as noted in other responses.

[Keith G]

Even though I've long since moved on from this project and cannot verify whether or not this answer actually works, I'm changing the accepted answer to this one. Because it indicates that Eclipse does indeed have a command line switch.

[matbrgz]

well, what I hacked together based on ant4eclipse - which requires a projectSet.psf file - to emulate the "export runnable jar" functionality isn't pretty hence no answer. Besides, it is not running Eclipse, but emulating Eclipse using ant :D

[matbrgz]

It is frequently much nicer to emulate the current workflow instead of telling every developer to change their behaviour. Especially when Eclipse is much faster than ant.

[user3176001]

Just one thought - seems like this only works for pre-existing workspaces. I guess this makes it hard to, for example, checkout the project from source control and build it this way.

[Kieveli]

I believe my workspace was committed to the svn repository. It either had relative paths, or matching directory structures.

[Dikla]

How do you see the build results? I've tried this, and got output: "Building workspace", but I didn't get indication to whether the build succeeded or failed.

[reprogrammer]

You can also build your workspace via a command line ant script. See help.eclipse.org/indigo/…

[matbrgz]

Came across this old answer: We found the "emulate Eclipse build using Eclipse configuration files" to be too brittle in the long run and I will strongly advise others not to go that way. Use Maven projects instead.

[VonC]

@ThorbjørnRavnAndersen Ok. That is an old answer indeed.

[serv-inc]

if the project is already built (in debug mode f.ex.) you can use ant installd to install without building

[VonC]

@JeffPuckettII Thank you. I have restored the link.

[milahu]

"Eclipse does not seem to directly read its .project and .classpath in a command-line argument." - solutions? something like bnd buildx -eclipse some-project.bnd

[VonC]

@MilaNautikus 13 years later, that might have changed indeed. You can edit this answer.

[milahu]

parsing the .project and .classpath files should work with org.eclipse.jdt.apt.core.aptBuild, but that just does nothing. now i patch the build.xml file, to add libraries from the .classpath file, and run ant -buildfile build.xml, so no need for eclipse