Comment puis-je convertir une trace de la pile d'une chaîne de caractères?

On peut utiliser la méthode suivante pour convertir un Exception trace de la pile à String. Cette classe est disponible dans Apache commons-lang, qui est la plus commune dépendant de la bibliothèque avec de nombreux modèles de sources ouvertes

org.apache.commons.lang.exception à la règle.ExceptionUtils.getStackTrace(Throwable)

Cela devrait fonctionner:

StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
String exceptionAsString = sw.toString();

Goyave est Throwables classe

Si vous avez la réelle Throwable exemple, Google Goyave fournit Throwables.getStackTraceAsString().

Exemple:

String s = Throwables.getStackTraceAsString ( myException ) ;

Pour moi la plus propre et la plus simple est:

import java.util.Arrays;
Arrays.toString(e.getStackTrace());

Le code suivant vous permet d'obtenir l'ensemble de la stackTrace avec un String format, sans l'aide d'Api comme log4J ou même java.util.Logger:

catch (Exception e) {
StackTraceElement[] stack = e.getStackTrace();
String exception = "";
for (StackTraceElement s : stack) {
exception = exception + s.toString() + "\n\t\t";
}
System.out.println(exception);
//then you can send the exception string to a external file.
}

Impression trace de la pile à chaîne

import java.io.PrintWriter;
import java.io.StringWriter;
public class StackTraceUtils {
public static String stackTraceToString(StackTraceElement[] stackTrace) {
StringWriter sw = new StringWriter();
printStackTrace(stackTrace, new PrintWriter(sw));
return sw.toString();
}
public static void printStackTrace(StackTraceElement[] stackTrace, PrintWriter pw) {
for(StackTraceElement stackTraceEl : stackTrace) {
pw.println(stackTraceEl);
}
}
}

C'est utile lorsque vous souhaitez imprimer le thread courant trace de la pile sans créer d'instance de Throwable - mais notez que la création de nouveaux Throwable et l'obtention de trace de la pile à partir de là est effectivement plus rapide et moins cher que d'appeler Thread.getStackTrace.

Imprimer la stacktrace à un PrintStream, puis de le convertir en une Chaîne de caractères

//...
catch (Exception e)
{
ByteArrayOutputStream out = new ByteArrayOutputStream(); 
e.printStackTrace(new PrintStream(out));
String str = new String(out.toByteArray());
System.out.println(str);
}

Intelligent, des tirs à la première série d'observations a été très amusant, mais cela dépend vraiment de ce que vous essayez de faire.
Si vous ne disposez pas déjà de la bibliothèque correcte, puis 3 lignes de code (comme dans D. Wroblewski de réponse) est parfait.
Otoh, que, si vous avez déjà apache.communes de la bibliothèque (comme la plupart des grands projets), puis Amar réponse est plus court.
OK, ça peut vous prendre dix minutes pour aller à la bibliothèque et à l'installer correctement (du moins si vous savez ce que vous faites). Mais le temps est compté, donc vous ne pouvez pas avoir du temps à perdre.
Jarek Przygódzki avait une intéressante mise en garde--"Si vous n'avez pas besoin exceptions imbriquées".

Mais si je ne besoin de toute la stack trace, imbriquées et tout? Dans ce cas, le secret est d'utiliser apache.commune de getFullStackTrace (voir http://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/exception/ExceptionUtils.html#getFullStackTrace%28java.lang.Throwable%29)

Il a sauvé mon bacon. Merci, Amar, pour l'astuce!

Kotlin

L'extension de la classe Throwable qui va vous donner la propriété de Chaîne error.stackTraceString:

val Throwable.stackTraceString: String
get() {
val sw = StringWriter()
val pw = PrintWriter(sw)
this.printStackTrace(pw)
return sw.toString()
}

si vous êtes à l'aide de java 8, essayez cette

Arrays.stream(e.getStackTrace())
.map(s->s.toString())
.collect(Collectors.joining("\n"));

vous pouvez trouver le code pour getStackTrace() fonction fournie par l'Throwable.java comme :

public StackTraceElement[] getStackTrace() {
return getOurStackTrace().clone();
}

et pour StackTraceElement, des prestataires de services informatiques toString comme:

public String toString() {
return getClassName() + "." + methodName +
(isNativeMethod() ? "(Native Method)" :
(fileName != null && lineNumber >= 0 ?
"(" + fileName + ":" + lineNumber + ")" :
(fileName != null ?  "("+fileName+")" : "(Unknown Source)")));
}

Donc juste rejoindre le StackTraceElement avec "\n"

Mon oneliner pour convertir la trace de la pile pour le joint multi-ligne de chaîne:

Stream.of(e.getStackTrace()).map((a) -> a.toString()).collect(Collectors.joining("\n", "[", "]"))

Facile de passer à l'enregistreur de données "comme est".

Si vous ne souhaitez pas utiliser une bibliothèque externe et vous n'êtes pas le développement de pour Android, vous pouvez créer une la "vulgarisation" de la méthode comme ceci:

public static String getStackTraceString(Throwable e) {
return getStackTraceString(e, "");
}
private static String getStackTraceString(Throwable e, String indent) {
StringBuilder sb = new StringBuilder();
sb.append(e.toString());
sb.append("\n");
StackTraceElement[] stack = e.getStackTrace();
if (stack != null) {
for (StackTraceElement stackTraceElement : stack) {
sb.append(indent);
sb.append("\tat ");
sb.append(stackTraceElement.toString());
sb.append("\n");
}
}
Throwable[] suppressedExceptions = e.getSuppressed();
//Print suppressed exceptions indented one level deeper.
if (suppressedExceptions != null) {
for (Throwable throwable : suppressedExceptions) {
sb.append(indent);
sb.append("\tSuppressed: ");
sb.append(getStackTraceString(throwable, indent + "\t"));
}
}
Throwable cause = e.getCause();
if (cause != null) {
sb.append(indent);
sb.append("Caused by: ");
sb.append(getStackTraceString(cause, indent));
}
return sb.toString();
}

 import java.io.PrintWriter;
import java.io.StringWriter;
public class PrintStackTrace {
public static void main(String[] args) {
try {
int division = 0 / 0;
} catch (ArithmeticException e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
String exceptionAsString = sw.toString();
System.out.println(exceptionAsString);
}
}
}

Lorsque vous exécutez le programme, la sortie sera quelque chose de similaire:

java.lang.ArithmeticException: / by zero
at PrintStackTrace.main(PrintStackTrace.java:9)

Avertissement: C'est peut-être un peu hors sujet, mais bon... 😉

Je ne sais pas ce que les affiches originales raison a été de vouloir la trace de la pile comme une chaîne de caractères dans la première place. Lorsque la trace de la pile devrait se retrouver dans une SLF4J/Logback JOURNAL, mais aucune exception n'a été ou devrait être jeté voici ce que je fais:

public void remove(List<String> ids) {
if(ids == null || ids.isEmpty()) {
LOG.warn(
"An empty list (or null) was passed to {}.remove(List). " +
"Clearly, this call is unneccessary, the caller should " + 
"avoid making it. A stacktrace follows.", 
getClass().getName(),
new Throwable ("Stacktrace")
);
return;
}
//actual work, remove stuff
}

Je l'aime parce qu'il ne nécessite pas une bibliothèque externe (autre que votre enregistrement en arrière-plan, qui sera mis en place la plupart du temps de toute façon, bien sûr).

J'ai écrit quelques méthodes pour ça il y a longtemps, alors je me suis dit pourquoi ne pas jeter mon grain de sel à ce.

/** @param stackTraceElements The elements to convert
* @return The resulting string */
public static final String stackTraceElementsToStr(StackTraceElement[] stackTraceElements) {
return stackTraceElementsToStr(stackTraceElements, "\n");
}
/** @param stackTraceElements The elements to convert
* @param lineSeparator The line separator to use
* @return The resulting string */
public static final String stackTraceElementsToStr(StackTraceElement[] stackTraceElements, String lineSeparator) {
return stackTraceElementsToStr(stackTraceElements, lineSeparator, "");
}
/** @param stackTraceElements The elements to convert
* @param lineSeparator The line separator to use
* @param padding The string to be used at the start of each line
* @return The resulting string */
public static final String stackTraceElementsToStr(StackTraceElement[] stackTraceElements, String lineSeparator, String padding) {
String str = "";
if(stackTraceElements != null) {
for(StackTraceElement stackTrace : stackTraceElements) {
str += padding + (!stackTrace.toString().startsWith("Caused By") ? "\tat " : "") + stackTrace.toString() + lineSeparator;
}
}
return str;
}
/** @param stackTraceElements The elements to convert
* @return The resulting string */
public static final String stackTraceCausedByElementsOnlyToStr(StackTraceElement[] stackTraceElements) {
return stackTraceCausedByElementsOnlyToStr(stackTraceElements, "\n");
}
/** @param stackTraceElements The elements to convert
* @param lineSeparator The line separator to use
* @return The resulting string */
public static final String stackTraceCausedByElementsOnlyToStr(StackTraceElement[] stackTraceElements, String lineSeparator) {
return stackTraceCausedByElementsOnlyToStr(stackTraceElements, lineSeparator, "");
}
/** @param stackTraceElements The elements to convert
* @param lineSeparator The line separator to use
* @param padding The string to be used at the start of each line
* @return The resulting string */
public static final String stackTraceCausedByElementsOnlyToStr(StackTraceElement[] stackTraceElements, String lineSeparator, String padding) {
String str = "";
if(stackTraceElements != null) {
for(StackTraceElement stackTrace : stackTraceElements) {
str += (!stackTrace.toString().startsWith("Caused By") ? "" : padding + stackTrace.toString() + lineSeparator);
}
}
return str;
}
/** @param e The {@link Throwable} to convert
* @return The resulting String */
public static final String throwableToStrNoStackTraces(Throwable e) {
return throwableToStrNoStackTraces(e, "\n");
}
/** @param e The {@link Throwable} to convert
* @param lineSeparator The line separator to use
* @return The resulting String */
public static final String throwableToStrNoStackTraces(Throwable e, String lineSeparator) {
return throwableToStrNoStackTraces(e, lineSeparator, "");
}
/** @param e The {@link Throwable} to convert
* @param lineSeparator The line separator to use
* @param padding The string to be used at the start of each line
* @return The resulting String */
public static final String throwableToStrNoStackTraces(Throwable e, String lineSeparator, String padding) {
if(e == null) {
return "null";
}
String str = e.getClass().getName() + ": ";
if((e.getMessage() != null) && !e.getMessage().isEmpty()) {
str += e.getMessage() + lineSeparator;
} else {
str += lineSeparator;
}
str += padding + stackTraceCausedByElementsOnlyToStr(e.getStackTrace(), lineSeparator, padding);
for(Throwable suppressed : e.getSuppressed()) {
str += padding + throwableToStrNoStackTraces(suppressed, lineSeparator, padding + "\t");
}
Throwable cause = e.getCause();
while(cause != null) {
str += padding + "Caused by:" + lineSeparator + throwableToStrNoStackTraces(e.getCause(), lineSeparator, padding);
cause = cause.getCause();
}
return str;
}
/** @param e The {@link Throwable} to convert
* @return The resulting String */
public static final String throwableToStr(Throwable e) {
return throwableToStr(e, "\n");
}
/** @param e The {@link Throwable} to convert
* @param lineSeparator The line separator to use
* @return The resulting String */
public static final String throwableToStr(Throwable e, String lineSeparator) {
return throwableToStr(e, lineSeparator, "");
}
/** @param e The {@link Throwable} to convert
* @param lineSeparator The line separator to use
* @param padding The string to be used at the start of each line
* @return The resulting String */
public static final String throwableToStr(Throwable e, String lineSeparator, String padding) {
if(e == null) {
return "null";
}
String str = padding + e.getClass().getName() + ": ";
if((e.getMessage() != null) && !e.getMessage().isEmpty()) {
str += e.getMessage() + lineSeparator;
} else {
str += lineSeparator;
}
str += padding + stackTraceElementsToStr(e.getStackTrace(), lineSeparator, padding);
for(Throwable suppressed : e.getSuppressed()) {
str += padding + "Suppressed: " + throwableToStr(suppressed, lineSeparator, padding + "\t");
}
Throwable cause = e.getCause();
while(cause != null) {
str += padding + "Caused by:" + lineSeparator + throwableToStr(e.getCause(), lineSeparator, padding);
cause = cause.getCause();
}
return str;
}

Exemple:

try(InputStream in = new FileInputStream(file)) {
...
} catch(IOException e) {
String exceptionToString = throwableToStr(e);
someLoggingUtility.println(exceptionToString);
...
}

Imprime:

java.io.FileNotFoundException: C:\test.txt (The system cannot find the file specified)
at java.io.FileInputStream.open0(Native Method)
at java.io.FileInputStream.open(Unknown Source)
at java.io.FileInputStream.<init>(Unknown Source)
at com.gmail.br45entei.Example.main(Example.java:32)