Rediriger le lot stderr vers le fichier

J'ai un lot de fichiers qui s'exécute une application java. Je suis en train de le modifier, de sorte que, lorsqu'une exception se produit, il va écrire le STDERR dans un fichier.

Il ressemble à quelque chose comme ceci:

start java something.jar method %1 %2 2>> log.txt

Est-il une manière que je peux écrire les arguments %1 et %2 à la log.txt fichier? Je ne veux pas l'écrire dans le fichier de log à chaque fois que ce fichier de commandes est appelée, seulement lorsqu'une exception se produit.

J'ai essayé de chercher un moyen de rediriger STDERR dans une variable, mais je ne pouvais pas le comprendre. Idéalement, j'aimerais le fichier journal à ressembler à quelque chose comme:

Batch file called with parameters:
- "first arg"
- "second arg"
Exception: 
java.io.exception etc...

------------------------------------

Batch file called with parameters:
- "first arg"
- "second arg"
Exception: 
java.io.exception etc...

source d'informationauteur nivlam

3

Quelque chose comme ça pourrait fonctionner:

javastart.cmd
```
@echo off
set params=%*
for /f "delims=" %%e in ('java something.jar method %1 %2 ^>nul') do (
    echo Batch file called with parameters:>>log.txt
    echo - Args[]: %*>>log.txt
    echo - Arg[1]: %1>>log.txt
    echo - Arg[2]: %2>>log.txt
    echo Exception: %%e
)
```
Je ne suis pas un programmeur java moi-même, je ne peux pas tester cette sortie/de la situation, mais:

1: %* signifie que tous les paramètres, de la 1ère à la dernière (même %12 bien que ce n'est pas directement disponible.. ) quel que soit le formatage. Peut-être mieux d'utiliser ce que délimitent ces. Dans le même mauvais espacement/citer, vous avez le plein paramètres. J'ai ajouté une ligne dans le journal, de montrer toute la ligne alors les paramètres. Vous pouvez voir où le problème est que, si c'est une question de mauvais arguments.

2: l'envoi de la sortie standard (stdout) null (^>nul) ne garde que la sortie stderr, mis en %%e

3: ce qui est dans le ne partie seulement d'arriver, c'est le pour test instruction a rien en sortie, c'est à dire si %%e est réglé.

Avec ceux étant dit, vous avez pour tester le script et voir si l'exception est envoyé sur la sortie stderr ou, comme certains autres logiciels, à la sortie standard (stdout), même si une erreur s'est produite.

J'espère que cette aide.
2

La seule solution que je vois serait de rediriger stderr dans un fichier temporaire
```
java blah.jar %1 %2 2>stderr
```
et ensuite regarder si quelque chose a été écrit dans le fichier et écrit le journal dans ce cas.
```
for %%i in (stderr) do if %%~zi GTR 0 (
    echo Parameters: %1 %2 >>log.txt
    type stderr >> log.txt
)
```
Si les lots ne sont pas exécutés dans l'ordre, mais plutôt en même temps, vous devez trouver quelque chose à uniquify la variable temp:
```
set file=%time::=%
set /a file=file
set file=%file%%random%
java blah.jar %1 %2 2>stderr_%file%
for %%i in (stderr) do if %%~zi GTR 0 (
    echo Parameters: %1 %2 >>log.txt
    type stderr >> log.txt
)
```
Cela permettra d'éviter des affrontements entre plusieurs lots. Cependant, vous êtes en train de ne pas utiliser quoi que ce soit pour verrouiller l'écriture de votre fichier de log et les choses peuvent sembler hors de place alors que d'autres choses sont écrites (avec d'autres lots que vous pourriez obtenir de l'entrelacement dans le echo et type commandes ou, lorsque vous êtes à la redirection de la sortie de java pour le fichier en tant que bien, alors il peut se confondre avec sortie normale du programme java:
```
Paramètres: foo bar 
Certains régulière de sortie 
Paramètres: foo2 bar2 
Plus de sortie 
NullPointerException à Bla: Ce que nous voulions vraiment avoir le droit d'après les paramètres 
IOException à Bla: Cette exception appartient aux paramètres foo2 bar2 
```
Vous pouvez utiliser un autre fichier sémaphore pour l'écriture dans le journal pour éviter le lot sorties se mélangent: créer le fichier [copy nul file] lorsque vous voulez écrire pour le journal, le supprimer par la suite et avant de tenter de créer de vérifier si, effectivement, il est là et attendre jusqu'à ce qu'il disparaisse. Vous ne pouvez pas faire quelque chose sur la sortie standard (stdout) log être mélangé dans le fichier, même si, sauf que vous utilisez ce fichier temp approche pour stdout (et simplement type le stdout du journal de log.txt lorsque le programme Java fini, mais, encore une fois avec l'aide du sémaphore.
2

Je ne comprends pas exactement ce que vous demandez, mais voici quelques infos qui peuvent aider...

Vous pouvez rediriger stderr séparément à partir de la sortie standard dans un .cmd ou .le fichier bat. Pour rediriger stderr, utiliser quelque chose comme ceci:
```
MyCommand.exe > command.stdout.txt  2> command.stderr.txt
```
Ensuite, vous pouvez vérifier la command.stderr.txt pour le contenu, et si tout est présent, concaténer à la command.stdout.txt dans votre fichier de log. Ou vous pourriez concat en tout cas. Si vous le souhaitez vous pouvez également écho à la commande que vous avez exécuté, dans la version finale du fichier journal.

Vous pouvez également vérifier le code de sortie dans un fichier de commandes, à l'aide de l' %ERRORLEVEL% env var. Les fichiers Exe sont attendus pour définir ERRORLEVEL dans le cas d'une erreur. Je ne sais pas si java.exe ne ce. Il doit, s'il est un bon citoyen sur Windows. Ce pourrait être une autre façon de découvrir si l'application Java est sorti avec une condition d'erreur. Mais ce n'est pas une garantie que stderr n'ai rien eu. Par exemple, une application Java peut imprimer une exception et la trace de la pile, puis la sortie avec le code 0, ce qui indique la réussite. Auquel cas stderr aurait crasse, mais ERRORLEVEL serait de zéro.

MODIFIER: s/ERROR_LEVEL/ERRORLEVEL

Comment quelque chose comme cela (non testé):

@echo off
@echo Batch file called with parameters: >> log.txt
@echo - %1 >> log.txt
@echo - %2 >> log.txt
start java something.jar method %1 %2 2>> log.txt

Essayez d'utiliser ERRORLEVEL

java something.jar method %1 %2 2>> log.txt
IF %ERRORLEVEL% NEQ 0 GOTO Error

Error:
@ECHO There was an error
@ECHO Arg 1: %1 >> log.txt
@ECHO Arg 2: %2 >> log.txt

0

Un fichier de commandes comme ceci devrait faire l'affaire.

start_prog.cmd
```
CALL :Start_Prog arg1 arg2
GOTO :EOF

:Start_Prog
    something.py %1 %2 2>&1 1>nul | "C:\Python26\python.exe" format_output.py %1 %2 >>log.txt
    GOTO :EOF
```
Ici, je suis de passage stderr par l'intermédiaire d'un tuyau et le passage d'arguments en arguments. La sortie est ensuite ajouté à une log.txt fichier.

Jeter stdout
```
1>nul
```
Rediriger stderr vers stdout
```
2>&1
```
Tuyau de la sortie stderr dans un script pour le format de sortie, et de passer des arguments en arguments.
```
| "C:\Python26\python.exe" format_output.py %1 %2
```
Ajouter la sortie d'un "log.txt".
```
>>log.txt
```
Sur mon système j'ai besoin d'appeler python.exe sinon, le tuyau ne fonctionne pas.

Voici les deux fichiers que j'ai utilisé "something.py" et "format_output.py".

something.py
```
import sys
print >>sys.stdout, " ".join(sys.argv[1:])
print >>sys.stderr, "java.io.exception etc..."
```
format_output.py
```
import sys

print "Batch file called with parameters:"
for arg in sys.argv[1:]:
    print '- "{0}"'.format(arg)

print "Exception:"
for line in sys.stdin:
    print line
```
Et, enfin, voici la sortie.

log.txt
```
Batch file called with parameters:
- "arg1"
- "arg2"
Exception:
java.io.exception etc...
```
La seule chose qui manque, c'est que quelque chose est toujours écrit à la "log.txt" fichier.

Pour faire un peu le ménage en outre, je serais passé à écrire le fichier journal dans "format_output.py".

Vous pouvez alors ajouter une vérification pour voir si le stderr de votre programme est vide.

Vous devez vous connecter pour publier un commentaire.