Hoe kan ik de huidige stacktracering in Java krijgen?

Hoe krijg ik de huidige stack tracein Java, zoals hoe je in .NET kunt do Environment.StackTrace?

Ik heb Thread.dumpStack()gevonden, maar het is niet wat ik wil – ik wil de stacktracering terugkrijgen, niet afdrukken.


Antwoord 1, autoriteit 100%

U kunt Thread.currentThread().getStackTrace().

Dat retourneert een array van StackTraceElements die de huidige stacktracering van een programma vertegenwoordigen.


Antwoord 2, autoriteit 23%

Thread.currentThread().getStackTrace();

is prima als het je niet uitmaakt wat het eerste element van de stapel is.

new Throwable().getStackTrace();

heeft een gedefinieerde positie voor uw huidige methode, als dat ertoe doet.


Antwoord 3, autoriteit 16%

for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
    System.out.println(ste);
}

Antwoord 4, autoriteit 5%

Thread.currentThread().getStackTrace();

is beschikbaar sinds JDK1.5.

Voor een oudere versie kunt u exception.printStackTrace()omleiden naar een StringWriter():

StringWriter sw = new StringWriter();
new Throwable("").printStackTrace(new PrintWriter(sw));
String stackTrace = sw.toString();

Antwoord 5, autoriteit 3%

Daar kun je de commons van Apache voor gebruiken:

String fullStackTrace = org.apache.commons.lang3.exception.ExceptionUtils.getStackTrace(e);

Antwoord 6, autoriteit 3%

Tony, als commentaar op het geaccepteerde antwoord, heeft gegeven wat het beste antwoord lijkt te zijn dat in feite de vraag van de OPbeantwoordt:

Arrays.toString(Thread.currentThread().getStackTrace()).replace( ',', '\n' );

… de OP heeft NIETgevraagd hoe een Stringuit de stacktracering van een Exception. En hoewel ik een grote fan ben van Apache Commons, is er bij zoiets simpels als het bovenstaande geen logische reden om een externe bibliotheek te gebruiken.


Antwoord 7, autoriteit 2%

Op Android is een veel eenvoudigere manier om dit te gebruiken:

import android.util.Log;
String stackTrace = Log.getStackTraceString(exception); 

Antwoord 8, autoriteit 2%

Een andere oplossing (slechts 3531 tekens):

new Exception().printStackTrace();   
new Error().printStackTrace();

Antwoord 9, autoriteit 2%

Om de stacktracering van alle threads te krijgen, kun je het jstack-hulpprogramma, JConsole, gebruiken of een kill -quit-signaal sturen (op een Posix-besturingssysteem).

Als u dit echter programmatisch wilt doen, kunt u ThreadMXBean proberen:

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
ThreadInfo[] infos = bean.dumpAllThreads(true, true);
for (ThreadInfo info : infos) {
  StackTraceElement[] elems = info.getStackTrace();
  // Print out elements, etc.
}

Zoals gezegd, als je alleen de stacktracering van de huidige thread wilt, is het een stuk eenvoudiger – gebruik gewoon Thread.currentThread().getStackTrace();


Antwoord 10

Ik ben gek, het is Thread.currentThread().getStackTrace();


Antwoord 11

In Java 9 is er een nieuwe manier:

public static void showTrace() {
  List<StackFrame> frames =
    StackWalker.getInstance( Option.RETAIN_CLASS_REFERENCE )
               .walk( stream  -> stream.collect( Collectors.toList() ) );
  for ( StackFrame stackFrame : frames )
    System.out.println( stackFrame );
}

Antwoord 12

Stacktrace ophalen:

StackTraceElement[] ste = Thread.currentThread().getStackTrace();

Stacktrace afdrukken (JAVA 8+):

Arrays.asList(ste).forEach(System.out::println);

Stacktrage afdrukken (JAVA 7):

StringBuilder sb = new StringBuilder();
for (StackTraceElement st : ste) {
    sb.append(st.toString() + System.lineSeparator());
}
System.out.println(sb);

Antwoord 13

Ik stel voor dat

 Thread.dumpStack()

is een eenvoudigere manier en heeft het voordeel dat er niet echt een uitzondering wordt gemaakt of kan worden gegooid als er helemaal geen probleem is, en is aanzienlijk meer ter zake.


Antwoord 14

Om te rijgen met guave:

Throwables.getStackTraceAsString(new Throwable())

Antwoord 15

Ik heb een hulpprogramma-methode die een string retourneert met de stacktrace:

static String getStackTrace(Throwable t) {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw, true);
    t.printStackTrace(pw);
    pw.flush();
    sw.flush();
    return sw.toString();
}

En log gewoon in zoals…

... 
catch (FileNotFoundException e) {
    logger.config(getStackTrace(e));
}

Antwoord 16

try {
}
catch(Exception e) {
    StackTraceElement[] traceElements = e.getStackTrace();
    //...
}

of

Thread.currentThread().getStackTrace()

Antwoord 17

Misschien kun je dit proberen:

catch(Exception e)
{
    StringWriter writer = new StringWriter();
    PrintWriter pw = new PrintWriter(writer);
    e.printStackTrace(pw);
    String errorDetail = writer.toString();
}

De string ‘errorDetail’ bevat de stacktrace.


Antwoord 18

StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();

Het laatste element van de array vertegenwoordigt de onderkant van de stapel, wat de minst recente methode-aanroep in de reeks is.

A StackTraceElement has getClassName(), getFileName(), getLineNumber() and getMethodName().

loop door StackTraceElement en verkrijg het gewenste resultaat.

for (StackTraceElement ste : stackTraceElements ) 
{
    //do your stuff here...
}

Antwoord 19

U kunt het jstack-hulpprogramma gebruiken als u de huidige call-stack van uw proces wilt controleren.

Usage:
    jstack [-l] <pid>
        (to connect to running process)
    jstack -F [-m] [-l] <pid>
        (to connect to a hung process)
    jstack [-m] [-l] <executable> <core>
        (to connect to a core file)
    jstack [-m] [-l] [[email protected]]<remote server IP or hostname>
        (to connect to a remote debug server)
Options:
    -F  to force a thread dump. Use when jstack <pid> does not respond (process is hung)
    -m  to print both java and native frames (mixed mode)
    -l  long listing. Prints additional information about locks
    -h or -help to print this help message

Antwoord 20

Ik heb antwoorden van hierboven gebruikt en opmaak toegevoegd

public final class DebugUtil {
    private static final String SEPARATOR = "\n";
    private DebugUtil() {
    }
    public static String formatStackTrace(StackTraceElement[] stackTrace) {
        StringBuilder buffer = new StringBuilder();
        for (StackTraceElement element : stackTrace) {
            buffer.append(element).append(SEPARATOR);
        }
        return buffer.toString();
    }
    public static String formatCurrentStacktrace() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        return formatStackTrace(stackTrace);
    }
}

Antwoord 21

Dit is een oud bericht, maar hier is mijn oplossing:

Thread.currentThread().dumpStack();

Meer info en meer methoden daar:
http://javarevisited .blogspot.fr/2013/04/how-to-get-current-stack-trace-in-java-thread.html


Antwoord 22

Voor mensen die gewoon de huidige stacktrace naar hun logs willen, zou ik gaan voor:

getLogger().debug("Message", new Throwable());

Proost

Other episodes