Créer un projet Java Eclipse à partir de la ligne de commande

Existe-t-il un moyen de compiler un projet Java basé sur Eclipse à partir de la ligne de commande?

J'essaye d'automatiser ma construction (en utilisant FinalBuilder pas ant), et je ne suis ni un expert Java ni Eclipse. Je peux probablement comprendre comment faire cela avec des options de ligne de commande java droites, mais le projet Eclipse semble être beaucoup d'efforts inutiles.

Dans le cas où il n'y a aucun moyen de compiler un projet Eclipse via la ligne de commande, existe-t-il un moyen de générer la ligne de commande java requise à partir d'Eclipse? Ou y a-t-il des fichiers que je peux fouiller pour trouver les étapes de compilation qu'il effectue dans les coulisses?

Les gars, je cherche une réponse qui n'inclut PAS la fourmi. Permettez-moi de réitérer la question d'origine ... Existe-t-il un moyen de créer un projet Eclipse à partir de la ligne de commande?

Je ne pense pas que ce soit une question déraisonnable étant donné que je peux faire quelque chose comme ça pour Visual Studio:

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

Vous pouvez créer un projet eclipse via un espace de travail à partir de la ligne de commande:

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

Il utilise le jdt aptplugin pour créer automatiquement votre espace de travail. Ceci est également connu sous le nom de «construction sans tête». Merde difficile à comprendre. Si vous n'utilisez pas d'exe win32, vous pouvez essayer ceci:

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

Mettre à jour

Il y a plusieurs années, l'éclipse a été remplacée startup.jarpar le "lanceur d'équinoxe"

https://wiki.eclipse.org/Equinox_Launcher

Sur 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

Le -dataparamètre spécifie l'emplacement de votre espace de travail.

Le numéro de version du lanceur Equinox dépendra de la version d'Eclipse dont vous disposez.

Pour compléter la réponse d'André, une solution ant pourrait être comme celle décrite dans Emacs, JDEE, Ant et le compilateur Java Eclipse , comme dans:

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

L'élément compilerarg vous permet également de transmettre des arguments de ligne de commande supplémentaires au compilateur eclipse.

Vous pouvez trouver ici un exemple de script ant complet qui serait appelé dans une ligne de commande avec:

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

MAIS tout ce qui concerne la fourmi, ce n'est pas ce que Keith cherche.

Pour une compilation par lots, veuillez vous référer à Compilation de code Java , en particulier la section " Utilisation du compilateur par lots "

La classe du compilateur par lots se trouve dans le plug-in JDT Core. Le nom de la classe est org.eclipse.jdt.compiler.batch.BatchCompiler. Il est packagé dans plugins / org.eclipse.jdt.core_3.4.0..jar. Depuis la version 3.2, il est également disponible en téléchargement séparé. Le nom du fichier est ecj.jar.
Depuis la version 3.3, ce fichier jar contient également le support de jsr199 (API du compilateur) et le support de jsr269 (traitement des annotations). Pour utiliser la prise en charge du traitement des annotations, une machine virtuelle 1.6 est requise.

Exécuter le compilateur par lots à partir de la ligne de commande donnerait

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

ou:

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

Toutes les options de compilation java sont également détaillées dans cette section.

La différence avec la fonctionnalité de compilation de ligne de commande Visual Studio est qu'Eclipse ne semble pas lire directement ses .project et .classpath dans un argument de ligne de commande . Vous devez rapporter toutes les informations contenues dans le .project et le .classpath dans diverses options de ligne de commande afin d'obtenir le même résultat de compilation.

Donc, la réponse courte est: "oui, c'est en quelque sorte Eclipse." ;)

Après 27 ans, moi aussi, je suis mal à l'aise de développer dans un IDE. J'ai essayé ces suggestions (ci-dessus) - et je n'ai probablement pas tout suivi correctement - alors j'ai fait une recherche sur le Web et j'ai trouvé ce qui fonctionnait pour moi sur ' http://incise.org/android-development-on-the- command-line.html '.

La réponse semblait être une combinaison de toutes les réponses ci-dessus (veuillez me dire si je me trompe et accepter mes excuses si oui).

Comme mentionné ci-dessus, eclipse / adt ne crée pas les fichiers ant nécessaires. Pour compiler sans EDI eclipse (et sans créer de scripts ant):

1) Générez build.xml dans votre répertoire de niveau supérieur:

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) Ensuite, je compile le projet. J'étais un peu confus par la demande de ne pas utiliser «fourmi». Espérons que le demandeur voulait dire qu'il ne voulait pas écrire de scripts de fourmis. Je dis cela car la prochaine étape consiste à compiler l'application en utilisant 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) Pour installer l'apk sur l'appareil, j'ai dû utiliser à nouveau fourmi:

 ant target install

    ** my command line looked like  ant debug install

4) Pour exécuter le projet sur mon téléphone Android, j'utilise 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) Remarque: pour afficher le journal de l'utilisation de l'appareil:

 adb logcat

3B) Une deuxième note latérale: Le lien mentionné ci-dessus comprend également des instructions pour construire l'ensemble du projet à partir de la commande.

Espérons que cela aidera à résoudre la question. Je sais que j'étais vraiment heureux de trouver quelque chose sur ce sujet ici.

L'approach normal fonctionne dans l'autre sens: vous créez votre build basé sur maven ou ant , puis utilisez des intégrations pour votre IDE de choix afin que vous en soyez indépendant, ce qui est esp. important lorsque vous essayez de mettre à niveau les nouveaux membres de l'équipe ou d'utiliser un serveur d'intégration contious pour les builds automatisés. Je recommande d'utiliser maven et de le laisser faire le gros du travail à votre place. Créez un fichier pom et générez le projet eclipse via mvn eclipse: eclipse. HTH

Cette question contient des liens utiles sur les versions sans tête, mais ils sont principalement destinés à la création de plugins. Je ne sais pas dans quelle mesure cela peut être appliqué à des projets Java purs.

Je voulais juste ajouter mes deux cents à cela. J'ai essayé de faire comme @Kieveli suggéré pour non win32 (répété ci-dessous) mais cela n'a pas fonctionné pour moi (sur CentOS avec Eclipse: Luna):

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

Sur ma configuration particulière sur CentOS en utilisant Eclipse (Luna), cela a fonctionné:

$ECLIPSE_HOME/eclipse -nosplash -application org.eclipse.jdt.apt.core.aptBuild  startup.jar -data ~/workspace

La sortie devrait ressembler à ceci:

Building workspace
Building '/RemoteSystemsTempFiles'
Building '/test'
Invoking 'Java Builder' on '/test'.
Cleaning output folder for test
Build done
Building workspace
Building '/RemoteSystemsTempFiles'
Building '/test'
Invoking 'Java Builder' on '/test'.
Preparing to build test
Cleaning output folder for test
Copying resources to the output folder
Analyzing sources
Compiling test/src/com/company/test/tool
Build done

Je ne sais pas trop pourquoi il l'a apparemment fait deux fois, mais cela semble fonctionner.

Salut Juste un ajout aux commentaires de VonC. J'utilise le compilateur ecj pour compiler mon projet. c’était par surprise que certaines classes ne soient pas trouvées. Mais le projet fonctionnait bien avec le compilateur javac.

J'ai donc juste ajouté les classes dans le classpath (que nous devons passer en argument) et maintenant cela fonctionne bien ... :)

Kulbir Singh

Réponse courte. Non. Eclipse n'a pas de commutateur de ligne de commande comme Visual Studio pour créer un projet.