Errore CreateProcess = 206, il nome del file o l'estensione è troppo lungo quando si esegue il metodo main ()

Ho questo errore in eclipse helios:

Si è verificata un'eccezione durante l'esecuzione della riga di comando. Impossibile eseguire il programma "C: \ Program Files (x86) \ Java \ jre6 \ bin \ javaw.exe" (nella directory "C: \ Users \ motiver \ helios_workspace \ TimeTracker"): errore CreateProcess = 206, il nome del file o l'estensione è troppo lungo

Ho studiato un po 'ma la maggior parte dei problemi erano legati a DataNucleus quando lavoravo su Google App Engine. Ma non sto usando nulla che sia collegato in remoto a Google App Engine. Sto facendo un piccolo progetto con Servlet 3.0 su JBOSS 6. Sto usando Hibernate 4.1.2 per ORM e RESTEasy per esporre un servizio web. Ho creato un file util che ha un metodo main () che sostanzialmente elimina e ricrea lo schema. Eseguo il methos main () quando ho bisogno di un database pulito a scopo di test. Ha funzionato bene su Tomcat 7 ma ha smesso di funzionare quando sono passato a JBoss 6.

Qualsiasi suggerimento o soluzione sarebbe molto apprezzata.

Non esiste una soluzione semplice (come in un paio di clic o in un semplice comando) a questo problema.

Citando alcune risposte in questa segnalazione di bug in Eclipse.org , queste sono le soluzioni. Scegli quello che per te è meno doloroso:

• Riduci il percorso di classe
• Usa le directory invece dei file jar
• Usa un file jar compresso che contiene tutti gli altri jar, usa la variabile classpath all'interno del file manifest per puntare agli altri jar
• Usa un programma di caricamento classi speciale che legge il classpath da un file di configurazione
• Prova a utilizzare una delle patch allegate nel documento di segnalazione dei bug
• Usa un involucro proprio, ad esempio ant

Aggiornamento : dopo luglio 2014, c'è un modo migliore (grazie alla risposta di @ Brad-Mace di seguito :

Se hai creato il tuo file di build invece di usarlo Project -> Generate Javadocs, puoi aggiungerlo useexternalfile="yes"all'attività Javadoc, progettata specificamente per risolvere questo problema.

Se si crea il proprio file di configurazione, piuttosto che usare Project -> Generate Javadocssi può aggiungere useexternalfile="yes"al javadoccompito, che è stato progettato specificamente per risolvere questo problema.

Ho affrontato questo problema oggi e sono stato in grado di risolverlo utilizzando questo plugin Gradle

L' URL di GitHub è questo

SE tu, come me, non hai idea di cosa sia Gradle ma hai bisogno di eseguire un backend per fare il tuo lavoro di front-end, quello che devi fare è trovare il file build.gradle che viene chiamato per avviare il tuo server BE e aggiungerlo a la cima:

plugins {
  id "ua.eshepelyuk.ManifestClasspath" version "1.0.0"
}

Rispondere alla mia domanda qui in modo che la soluzione non venga sepolta nei commenti. Ho esportato il progetto come un jar eseguibile da eclipse e ho eseguito una riga di comando "java -jar MyJar.jar" e funziona perfettamente bene

Prova ad aggiornare la tua versione di Eclipse, il problema è stato risolto di recente (2013-03-12). Controlla la segnalazione di bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=327193

Questo non è specifico per eclipse, ma il modo in cui l'ho aggirato è stato creando un collegamento simbolico al mio repository Maven e puntandolo a qualcosa come "C: \ R". Quindi ho aggiunto quanto segue al mio file settings.xml:

<localRepository>C:\R</localRepository>

Il percorso del repository maven stava contribuendo ai problemi di lunghezza nella mia macchina Windows.

In intellij c'è un'opzione per 'accorciare la riga di comando', selezionare 'JAR manifest' o '@argFiles' risolverà il problema, in pratica metterà il tuo lungo percorso di classe in un file jar o in un file temporaneo

La domanda è vecchia, ma ancora valida. Mi imbatto in questa situazione spesso ogni volta che un nuovo membro si unisce al mio team o un nuovo segmento di codice viene aggiunto al codice esistente. La soluzione alternativa semplice che seguiamo è "Ridurre il classpath" spostando verso l'alto le directory.

Come già detto, questo non è specifico per eclipse. Ho riscontrato questo problema anche in IntelliJ Idea 14 e nel 2018.

Dopo una lunga ricerca, ho scoperto che la soluzione è impostare il file

fork = false

in javc del file di build ant.

<javac destdir="${build.dir}" fork="false" debug="on">
    <classpath .../>
    <src ... />
    <patternset ... />
</javac>

Ecco come appare il mio javac di formica ora. Per saperne di più sul fork, fare riferimento alla documentazione di ant.

Nel bug report Bug 327193 è considerato corretto, ma a me è capitato di recente con Eclipse Kepler 4.3.2.

Scarica la patch per Eclipse Juno o più recente:

https://bugs.eclipse.org/bugs/attachment.cgi?id=216593

1. Dopo il download, esegui il backup di eclipse / plugins / org.eclipse.jdt.launching_3. *. Jar esistente
2. Copia e incolla le classi nella patch in org.eclipse.jdt.launching JAR (sostituisci i file esistenti).
3. Riavvia Eclipse.

Prova questo:

java -jar -Dserver.port = 8080 build / libs / APP_NAME_HERE.jar

Per risolverlo:

Se stai usando Eclipse:

Sposta il repository .m2 in

c: \ Vai a Eclipse> Windows / Preferenze / Maven / Impostazioni utente -> Crea il tuo setting.xml con il suo contenuto:

<settings>
  <localRepository>c:/.m2/repository</localRepository>
</settings>

Se stai usando IntelliJ: vai su IntelliJ> fai clic con il pulsante destro del mouse su "pom.xml"> maven> crea "settings.xml"

con il suo contenuto:

<settings>
      xmlns="yourcontent"
      xmlns:xsi="yourcontent"
      xsi:schemaLocation="yourcontent.xsd">
  <localRepository>c:/.m2/repository</localRepository>
</settings>

Ho lo stesso errore, mentre invoco Maven.

La causa principale del mio problema era che classpathera enorme. L'aggiornamento del classpath ha risolto il problema.

Esistono diversi modi per aggiornare il percorso di classe grande come menzionato in questo: Come impostare un percorso di classe Java lungo in Windows?

1. Usa caratteri jolly
2. File di argomento
3. Vaso Pathing

Dato che sto usando Intellij, forniscono la possibilità di utilizzare il file di argomenti che ho usato.

Prova ad aggiungerlo nel gradle version 4.10.xfile build.gradle ( ) e controlla com.xxx.MainClassquesta è la classe in cui risiede il tuo metodo principale:

plugins {
  id "ua.eshepelyuk.ManifestClasspath" version "1.0.0"
}
apply plugin: 'application'
application {
    mainClassName = "com.xxx.MainClass"
}

La modifica di cui sopra deve risolvere il problema, esiste un altro modo in cui utilizzare lo script di run.shseguito potrebbe risolvere questo problema, ma sarà più una correzione della riga di comando, non in IntelliJ per l'avvio gradle bootRun.

succede a causa di DataNucleus a volte sovrascrivere gli argomenti con molti percorsi.

Devi sovrascriverli con questo:

-enhancerName ASM -api JDO -pu MediaToGo

Spero di aiutarti!

La risposta valida da questo thread è stata la risposta giusta per il mio caso speciale. Specificare il percorso della cartella ORM per datanucleus riduce sicuramente la compilazione del percorso java.

https://stackoverflow.com/a/1219427/1469481

Ho ricevuto l'errore di seguito quando eseguo " ant deploy "

Cannot run program "C:\java\jdk1.8.0_45\bin\java.exe": CreateProcess error=206, The filename or extension is too long

Risolto il problema eseguendo " ant clean " prima di esso.

Ho ricevuto lo stesso errore in Android Studio. Sono stato in grado di risolverlo eseguendo Build -> Clean Project nell'IDE.

Ciò è dovuto al nome lungo della directory del progetto, che ti dà un CLASSPATHtutto molto lungo . O è necessario ridurre i barattoli aggiunti a CLASSPATH(assicurarsi di rimuovere solo i barattoli non necessari) oppure il modo migliore è ridurre la directory del progetto e importare di nuovo il progetto. Questo ridurrà il CLASSPATH. Ha funzionato per me.

Ho avuto lo stesso problema, ma invece stavo usando netbeans.
Ho trovato una soluzione quindi la condivido qui perché non l'ho trovata da nessuna parte, quindi se hai questo problema su netbeans, prova questo:
(i nomi potrebbero essere disattivati ​​poiché il mio netbeans è in portoghese) Fai clic con il pulsante destro del mouse su progetto> proprietà > build> compilazione> Deseleziona Esegui compilazione su VM esterna.

Ho ricevuto lo stesso errore. Ho provato soluzioni come pulizia, ricostruzione, invalidateCache, riavvio ecc.Ma non funziona nulla.

Ho appena creato una nuova cartella con un nome breve e copiato tutti i file (cartella app, file gradle ecc.) In una nuova cartella. Applicazione aperta in Android Studio e funziona bene.

Nel mio caso l'errore veniva visualizzato perché la versione java del sistema era diversa dalla versione java intellijj / eclipse. Il sistema e l'utente avevano versioni java diff. Se si compila il codice utilizzando una versione e si tenta di eseguirlo utilizzando una versione diversa, verrà visualizzato un errore.

#The system java version is 1.7.131
$ java -version
java version "1.7.0_131"

Per farla breve, assicurati che il tuo codice sia compilato ed eseguito dalla stessa versione java.

Aggiungi di seguito al tuo file gradle:

plugins {`id" com.github.ManifestClasspath "versione" 0.1.0-RELEASE "
}

Vedi https://plugins.gradle.org/plugin/com.github.ManifestClasspath

Per correggere questo errore di seguito, ho fatto abbastanza ricerche, non ho ottenuto nessuna grande soluzione, ho preparato questo script e funziona bene, ho pensato di condividerlo con il pubblico e di utilizzarlo e di risparmiare tempo.

Errore CreateProcess = 206, il nome del file o l'estensione è troppo lungo

Se stai usando lo strumento di compilazione Gradle e il file eseguibile è posizionato nella directory build / libs della tua applicazione. run.sh-> crea questo file nella directory principale del tuo progetto, e copia sotto lo script in esso, quindi vai su git bash e digita run.sh, quindi inserisci. Spero che questo ti aiuti!

#!/bin/bash dir_name=`pwd` if [ $# == 1 ] && [ $1 == "debug" ] then port=$RANDOM quit=0 echo "Finding free port for debugging" while [ "$quit" -ne 1 ]; do netstat -anp | grep $port >> /dev/null if [ $? -gt 0 ]; then quit=1 else port=`expr $port + 1` fi done echo "Starting in Debug Mode on "$port gradle clean bootjar jar_name="build/libs/"`ls -l ./build/libs/|grep jar|grep -v grep|awk '{print $NF}'` #java -jar -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=$port $jar_name elif [ $# == 1 ] && [ $1 == 'help' ] then echo "please use this commands" echo "------------------------" echo "Start in Debug Mode: sh run.sh debug" echo "Start in Run Mode: sh run.sh" echo "------------------------" else gradle clean bootjar word_count=`ls -l ./build/libs/|grep jar|grep -v grep|wc -w` jar_name=`ls -l ./build/libs/|grep jar|grep -v grep|awk '{print $NF}'`
jar_path=build/libs/$jar_name echo $jar_name #java -jar $jar_path fi

Spero che questo ti aiuti!!

Sto usando una versione precedente dei plugin gradle e questo plugin ha risolto il problema per me.

Utilizzo (controlla l'origine per maggiori dettagli):

Crea snippet di script per plug-in DSL per Gradle 2.1 e versioni successive

plugins {
  id "com.github.ManifestClasspath" version "0.1.0-RELEASE"
}

Crea frammenti di script da utilizzare nelle versioni precedenti di Gradle o dove è richiesta la configurazione dinamica

buildscript {
  repositories {
    maven {
      url "https://plugins.gradle.org/m2/"
    }
  }
  dependencies {
    classpath "gradle.plugin.com.github.viswaramamoorthy:gradle-util-plugins:0.1.0-RELEASE"
  }
}

apply plugin: "com.github.ManifestClasspath"

In una macchina Windows, c'è una limitazione del nome del file jar / lunghezza del percorso nella riga di comando, a causa della quale viene visualizzato il messaggio di errore seguente, ho provato a cercare molto, anche se ho provato ad applicare la soluzione di cui sopra, per qualche motivo, non ha funzionato, ho trovato lo snippet funzionante per Gradle (gradle-4.10.2-all.zip)

Errore:

CreateProcess error=206, The filename or extension is too long

Usa questo gradle.buildframmento di codice di seguito per risolvere il problema precedente in IntelliJ o STS o eclissare qualsiasi cosa.

Gradle Code Fix:

apply plugin: 'application'

task pathingJar(type: Jar) {
    dependsOn configurations.runtime
    appendix = 'pathing'

    doFirst {
        manifest {
            attributes "Class-Path": configurations.runtimeClasspath.files.collect { it.getName() }.join(' ')
        }
    }
}

task copyToLib(type: Copy) {
    into "$buildDir/libs"
    from configurations.runtime
}

bootRun {
    systemProperties = System.properties
    //This below line is for if you have different profiles prod, dev etc...
    //systemProperty 'spring.profiles.active', 'dev'
    jvmArgs('-Djava.util.logging.config.file=none')
    mainClassName = "com.xxxx.Main"
    dependsOn pathingJar
    dependsOn copyToLib
    doFirst {
        classpath = files("$buildDir/classes/java/main", "$buildDir/resources/main", pathingJar.archivePath)
    }
}

Quante persone tristi sopra, ci sono molti plugin per gradle eseguire un bypass in questo problema come:

plugins {
  id "ua.eshepelyuk.ManifestClasspath" version "1.0.0"
}

o

plugins {
  id "com.github.ManifestClasspath" version "0.1.0-RELEASE"
}

Ma la soluzione migliore che ho trovato è stata uccidere il processo JVM e tutto è fatto.