Comment définir un long chemin de classe Java dans Windows?

Je suis en train de lancer un particulier JUnit test à la main sur un Windows XP en ligne de commande, ce qui a un nombre anormalement élevé d'éléments dans le chemin de classe. J'ai essayé plusieurs variantes, telles que:

set CLASS_PATH=C:\path\a\b\c;C:\path\e\f\g;....
set CLASS_PATH=%CLASS_PATH%;C:\path2\a\b\c;C:\path2\e\f\g;....
...
C:\apps\jdk1.6.0_07\bin\java.exe -client oracle.jdevimpl.junit.runner.TestRunner com.myco.myClass.MyTest testMethod

(D'autres variantes de la définition de la variable classpath sur une seule ligne, la définition de la classpath via-classpath comme un argument de java"). Il vient toujours vers le bas de la console de vomir mains avec cette erreur:

The input line is too long.
The syntax of the command is incorrect.

C'est un test JUnit test d'un assez vaste projet de l'héritage, donc pas de suggestions sur la réorganisation de ma structure de répertoire à quelque chose de plus raisonnable, ces types de solutions sont pour l'instant. J'essayais juste de gen en place d'un test rapide à l'encontre de ce projet et l'exécuter sur la ligne de commande, et la console est l'obstruction de moi. À l'aide!

InformationsquelleAutor Ogre Psalm33 | 2008-10-14
  1. 53

    La ligne de commande de Windows est très restrictif à cet égard. Une solution de contournement consiste à créer un "cheminement de pot". C'est un bocal contenant seulement un Manifest.mf fichier, dont le Class-Path spécifie le disque chemins de votre longue liste de pots, etc. Maintenant, il suffit d'ajouter ce cheminement pot à votre ligne de commande classpath. C'est généralement plus pratique que de les emballer les ressources réelles ensemble.

    Que je m'en souvienne, le disque chemins peuvent être par rapport à la cheminement pot lui-même. Ainsi, le Manifest.mf pourrait ressembler à quelque chose comme ceci:

    Class-Path: this.jar that.jar ../lib/other.jar

    Si votre cheminement pot contient principalement des fondamentaux de ressources, alors il ne change pas trop souvent, mais vous aurez probablement encore envie de générer quelque part dans votre construction. Par exemple:

    <jar destfile="pathing.jar">
  <manifest>
    <attribute name="Class-Path" value="this.jar that.jar ../lib/other.jar"/>
  </manifest>
</jar>
    • Le ManifestClassPath tâche à la disposition de Fourmi depuis la version 1.7 peut être utilisé pour générer une propriété appropriée pour la Classe-attribut de Chemin d'accès à partir d'une Fourmi Chemin.
    • Ai-je besoin de faire quelque chose, par exemple, de s'assurer que ce pot est chargé? Ou la JVM analyser tous les pots fournis sur le chemin de classe pour un tel manifeste? Aussi, est-il portable sur l'ensemble des machines virtuelles? Quel est le minimum de la version de Java qui prend en charge ce?
    • J'ai essayé ceci, mais le Manifeste.mf permet de relativiser les URLs pour les autres Pots et des répertoires.
    • le nombre maximal de caractères dans le classpath liste par ligne EST de 72. ALORS, quelle est la limite de la Classe de Chemin dans le Manifeste.MF fichier???
    • Notez que c'est ce que Maven Infaillible par défaut, mais une récente mise à jour Java fait-ce plus difficile.
    InformationsquelleAutor Chris Noe
  2. 20

    Depuis Java 6, vous pouvez utiliser classpath des caractères génériques.

    Exemple: foo/*, fait référence à tous .les fichiers jar dans le répertoire foo

    • ce ne sera pas correspondre à la catégorie fichiers (uniquement les fichiers jar). Pour correspondre à la fois à utiliser: foo;foo/* ou foo/*;foo. L'ordre détermine ce qui est chargé en premier.
    • La recherche n'est PAS récursive
    • Cela semble être de nouveau dans la version 6 de Java.
    • Hey, c'est cool--je ne savais pas à ce sujet. C'est certainement une option très pratique, surtout si (comme dans notre cas), la classe est pleine de bocaux, dont beaucoup sont dans le même répertoire.
    • Mais cela ne veut pas fournir récursive de la traversée.
    • Cela semble comme un "Lien Seule Réponse". Vous devez fournir plus de détails sur la façon d'aller à ce sujet.
    InformationsquelleAutor johnstok
  3. 6

    Utiliser Un Argument de "Fichier" sur l'île de Java 9+

    En Java 9+, l'exécutable java prend en charge de fournir des arguments par l'intermédiaire d'un fichier. Voir
    https://docs.oracle.com/javase/9/tools/java.htm#JSWOR-GUID-4856361B-8BFD-4964-AE84-121F5F6CF111.

    Ce mécanisme est explicitement destiné à résoudre le problème de l'OS limitations sur commande longueurs:

    Vous pouvez raccourcir ou de simplifier la commande java en utilisant l'argument @fichiers
    pour spécifier un fichier texte qui contient des arguments, tels que les options et les
    les noms de classe, transmis à la commande java. Cela vous permet de créer java
    les commandes de n'importe quelle longueur sur n'importe quel système d'exploitation.

    Dans la ligne de commande, utilisez le signe arobase (@) préfixe pour identifier un
    argument fichier qui contient les options java et les noms de classe. Lorsque l'
    commande java rencontre un fichier commençant par le signe arobase (@) , il
    développe le contenu de ce fichier dans une liste d'arguments, comme ils
    serait spécifié sur la ligne de commande.

    C'est la "bonne" solution, si vous exécutez la version 9 ou plus. Ce mécanisme modifie simplement la façon dont l'argument est fourni à la JVM, et est donc 100% compatible avec n'importe quel cadre ou à l'application, indépendamment de la façon dont ils le font classloading c'est à dire qu'il est complètement équivalente à fournir simplement l'argument sur la ligne de commande comme d'habitude. Ce n'est pas vrai pour manifester à base de solutions de contournement pour ce système d'exploitation limitation.

    Un exemple de ceci est:

    De la commande d'origine:

    java -cp c:\foo\bar.jar;c:\foo\baz.jar

    peut être réécrite comme:

    java @c:\path\to\cparg

    où c:\path\to\cparg est un fichier qui contient:

    -cp c:\foo\bar.jar;c:\foo\baz.jar

    Cet argument de "fichier" permet également l'insertion de caractères de continuité et de cotation de la bonne utilisation des espaces dans les chemins par exemple

    -cp "\
c:\foo\bar.jar;\
c:\foo\baz.jar"

    Gradle

    Si vous rencontrez ce problème dans Gradle, voir ce plugin, qui convertit votre chemin de classe automatiquement dans un argument de "fichier" et prévoit que la JVM lors exec ou test de tâches de Windows. Sur Linux ou d'autres systèmes d'exploitation, il ne fait rien par défaut, si une option de valeur de configuration peut être utilisé pour appliquer la transformation, indépendamment de l'OS.

    https://github.com/redocksoft/classpath-to-file-gradle-plugin

    (disclaimer: je suis l'auteur)

    Voir aussi cette Gradle question-et nous espérons que cette fonctionnalité sera finalement intégrée dans Gradle de base: https://github.com/gradle/gradle/issues/1989.

    InformationsquelleAutor Raman
  4. 4

    (Je suppose que vous n'avez pas vraiment dire, de DOS, mais se réfèrent à cmd.exe.)

    Je pense qu'il est moins celui de la limitation que dans un environnement de taille/variable d'environnement limite de taille. Sur XP, individuelles variables d'environnement peuvent être 8k en taille, tout l'environnement est limitée à 64 ko. Je ne peux pas vous voir frapper à cette limite.

    Il y a une limite sur windows qui limite la longueur d'une ligne de commande sur windows nt+ c'est 8k pour cmd.exe. Un ensemble de commande est soumis à cette restriction. Peut-il être que vous avez plus de 8k valeur de répertoires dans votre commande? Vous pouvez être hors de la chance, alors - même si vous les diviser comme Nick Berardi suggéré.

    • Oups, oui, de la vieille école est de s'infiltrer à travers. Oui, cmd.exe.
    InformationsquelleAutor Tomalak
  5. 1

    Si j'étais à votre place, je voudrais télécharger la jonction de l'utilitaire à partir de MS : http://technet.microsoft.com/en-us/sysinternals/bb896768.aspx et puis la carte de votre
    "C:\path" pour dire "z:\" \ " et "c:\path2" pour dire "y:\". De cette façon, vous serez en réduisant les 4 caractères par article dans votre classpath. 

    set CLASS_PATH=C:\path\a\b\c;C:\path\e\f\g;
set CLASS_PATH=%CLASS_PATH%;C:\path2\a\b\c;C:\path2\e\f\g;

    Maintenant, votre chemin de classe seront les suivants : 

    set CLASS_PATH=z\a\b\c;z\e\f\g;
set CLASS_PATH=%CLASS_PATH%;y:\a\b\c;y:\e\f\g;

    Il pourrait faire plus en fonction de vos réels classpath.

    • La jonction est un front-end pour ce en NTFS. mklink /D en est une autre, peut-être déjà présentes dans les versions ultérieures de Windows.
    • mlink ne semble pas être inclus dans windows 7. la jonction est inclus dans windows 7(de l'entreprise).
    InformationsquelleAutor anjanb
  6. 1

    Grâce à Raman pour l'introduction d'une nouvelle solution à un cheminement problème pour Java 9+. J'ai fait un hack pour bootRun tâche qui permet d'utiliser tout déjà évaluées par gradle pour exécuter java avec l'argument de fichiers. Pas très élégant mais de travail.

    //Fix long path problem on Windows by utilizing java Command-Line Argument Files 
//https://docs.oracle.com/javase/9/tools/java.htm#JSWOR-GUID-4856361B-8BFD-4964-AE84-121F5F6CF111 
//The task creates the command-line argument file with classpath
//Then we specify the args parameter with path to command-line argument file and main class
//Then we clear classpath and main parameters
//As arguments are applied after applying classpath and main class last step 
//is done to cheat gradle plugin: we will skip classpath and main and manually
//apply them through args
//Hopefully at some point gradle will do this automatically 
//https://github.com/gradle/gradle/issues/1989 

if (Os.isFamily(Os.FAMILY_WINDOWS)) {
    bootRun {
        doFirst {
            def argumentFilePath = "build/javaArguments.txt"
            def argumentFile = project.file(argumentFilePath)
            def writer = argumentFile.newPrintWriter()
            writer.print('-cp ')
            writer.println(classpath.join(';'))
            writer.close()

            args = ["@${argumentFile.absolutePath}", main]
            classpath = project.files()
            main = ''
        }
    }
}
    InformationsquelleAutor user1921819
  7. 0

    Je pense que vous êtes jusqu'à la crique sans pagaie ici.
    La ligne de commande a une limite d'arguments à l'appel d'un programme.

    J'ai 2 sugestion vous pourriez essayer.
    Tout d'abord, avant l'exécution des tests junit, vous pouvez laisser un script/ant_task créer des Pots de différentes classes sur le chemin de la classe.
    Ensuite, vous pouvez placer les Pots sur le chemin de classe, qui devrait être plus court.

    Une autre façon vous pourriez faire est d'essayer de créer un antscript pour exécuter JUNIT,
    dans ANT il ne devrait pas être une limite pour classpath entrées.

    InformationsquelleAutor Huibert Gill
  8. 0

    Comme HuibertGill mentionne, je voudrais conclure en un script Ant juste de sorte que vous n'avez pas à gérer tout cela, vous-même.

    InformationsquelleAutor matt b
  9. 0

    Vous pouvez essayer ce

    @echo off
set A=D:\jdk1.6.0_23\bin
set B=C:\Documents and Settings74205\Desktop\JavaProj
set PATH="%PATH%;%A%;"
set CLASSPATH="%CLASSPATH%;%B%;"

    aller à une invite de commande et exécutez deux fois(aucune idée de pourquoi....je dois le faire sur une machine windows XP)
    aussi les chemins r de la session d'invite de commande

    InformationsquelleAutor Shivananda Sahu
  10. 0

    Il n'y a pas de solution à la question difficile de faire le chemin plus court en déplaçant les fichiers jar dans un dossier comme "C:\jars".

    • Incorrect. Il y AVAIT une autre solution, mais vous ne savez pas ce que c'était, ou vous avez décidé de ne pas l'utiliser. Cependant, ce que vous avez fait était certainement Une solution ... qui peut fonctionner dans certains cas.
    InformationsquelleAutor Snehal Masne
  11. -2

    Avez-vous essayé de les empiler?

    set CLASS_PATH = c:\path
set ALT_A = %CLASS_PATH%\a\b\c;
set ALT_B = %CLASS_PATH%\e\f\g;
...

set ALL_PATHS = %CLASS_PATH%;%ALT_A%;%ALT_B%
    • Nous avons essayé quelques variantes de ce, en vain. CMD semble remplacer toutes ces %ALT_A%, etc à la volée et le chemin vents est trop longue pour la poignée, ce qui me donne la même erreur.
    InformationsquelleAutor Nick Berardi