ජාවා හි වර්තමාන තොග හෝඩුවාව ලබා ගන්නේ කෙසේද?

.NET හි ඔබට කළ හැකි ආකාරයට ජාවා හි වර්තමාන තොග හෝඩුවාව ලබා ගන්නේ Environment.StackTraceකෙසේද?

මා සොයා ගත් Thread.dumpStack()නමුත් එය මට අවශ්‍ය දේ නොවේ - මට අවශ්‍ය වන්නේ තොග හෝඩුවාව නැවත ලබා ගැනීමට මිස මුද්‍රණය නොකිරීමට ය.

ඔබට භාවිතා කළ හැකිය Thread.currentThread().getStackTrace().

එමඟින් StackTraceElementවැඩසටහනක වර්තමාන සිරස් හෝඩුවාව නිරූපණය කරන s පෙළක් ලැබේ .

Thread.currentThread().getStackTrace();

තොගයේ පළමු අංගය කුමක්දැයි ඔබ නොසලකන්නේ නම් හොඳයි.

new Throwable().getStackTrace();

එය වැදගත් නම්, ඔබගේ වර්තමාන ක්‍රමය සඳහා නිශ්චිත ස්ථානයක් ඇත.

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

Thread.currentThread().getStackTrace();

JDK1.5 සිට ලබා ගත හැකිය.

පැරණි අනුවාදය සඳහා, ඔබව හරවා හැක exception.printStackTrace()වෙත StringWriter():

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

ඒ සඳහා ඔබට Apache ගේ කොමන්ස් භාවිතා කළ හැකිය:

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

ඇන්ඩ්‍රොයිඩ් හි මෙය භාවිතා කිරීම වඩා පහසු ක්‍රමයකි:

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

සියළුම නූල්වල සිරස් හෝඩුවාව ලබා ගැනීම සඳහා ඔබට jstack උපයෝගීතාව, JConsole භාවිතා කළ හැකිය, නැතහොත් kill ාතන-සං signal ා යැවිය හැකිය (පොසික්ස් මෙහෙයුම් පද්ධතියක).

කෙසේ වෙතත්, ඔබට මෙය ක්‍රමලේඛිකව කිරීමට අවශ්‍ය නම් ඔබට ThreadMXBean භාවිතා කිරීමට උත්සාහ කළ හැකිය:

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
ThreadInfo[] infos = bean.dumpAllThreads(true, true);

for (ThreadInfo info : infos) {
  StackTraceElement[] elems = info.getStackTrace();
  // Print out elements, etc.
}

සඳහන් කළ පරිදි, ඔබට අවශ්‍ය වන්නේ වත්මන් නූල්වල සිරස් හෝඩුවාවක් පමණි නම් එය වඩා පහසුය - භාවිතා කරන්න Thread.currentThread().getStackTrace();

තවත් විසඳුමක් ( අක්ෂර 35 31 ක් පමණි ):

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

ටෝනි, පිළිගත් පිළිතුරට අදහස් දැක්වීමක් ලෙස , OP හි ප්‍රශ්නයට සැබවින්ම පිළිතුරු සපයන හොඳම පිළිතුර ලෙස පෙනෙන දේ ලබා දී ඇත :

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

... OP වෙතින් තොග හෝඩුවාවක් ලබා ගන්නේ කෙසේදැයි විමසුවේ නැත . මම Apache Commons හි විශාල රසිකයෙක් වුවද, ඉහත තරම් සරල දෙයක් ඇති විට බාහිර පුස්තකාලයක් භාවිතා කිරීමට තර්කානුකූල හේතුවක් නොමැත.StringException

මෝඩයා, ඒ Thread.currentThread().getStackTrace();

ස්ටැක්ට්‍රේස් ලබා ගැනීම:

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

මුද්‍රණ ස්ටැක්ට්‍රේස් (ජාවා 8+):

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

මුද්‍රණ සිරස් (ජාවා 7):

StringBuilder sb = new StringBuilder();

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

මම ඒක යෝජනා කරනවා

  Thread.dumpStack()

පහසු ක්‍රමයක් වන අතර කිසියම් ගැටළුවක් නොමැති විට ව්‍යතිරේකයක් හෝ ඉවත දැමිය හැකි දෙයක් සැබවින්ම නොකිරීමේ වාසියක් ඇති අතර එය සැලකිය යුතු ලෙස කාරණයකි.

ජාවා 9 හි නව ක්‍රමයක් තිබේ:

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 );
}

මට උපයෝගීතා ක්‍රමයක් ඇත, එය ස්ටැක්ට්‍රේස් සමඟ නූලක් ලබා දෙයි:

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();
}

ඒ වගේම ලොග් වෙන්න ...

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

ගුආ සමඟ නූල් කිරීමට:

Throwables.getStackTraceAsString(new Throwable())

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

හෝ

Thread.currentThread().getStackTrace()

සමහර විට ඔබට මෙය උත්සාහ කළ හැකිය:

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

'ErrorDetail' නූලෙහි සිරස් තලය අඩංගු වේ.

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

අරාවෙහි අවසාන මූලද්‍රව්‍යය තොගයේ පතුල නියෝජනය කරයි, එය අනුක්‍රමයේ අවම මෑත කාලීන ක්‍රමවේදය වේ.

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

StackTraceElement හරහා ලූප් කර ඔබේ අපේක්ෂිත ප්‍රති .ලය ලබා ගන්න.

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

මම ඉහළින් පිළිතුරු භාවිතා කර ආකෘතිකරණය එකතු කළෙමි

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);
    }
}

ඔබගේ ක්‍රියාවලියේ වත්මන් ඇමතුම් තොගය පරීක්ෂා කිරීමට අවශ්‍ය නම් ඔබට jstack උපයෝගීතාව භාවිතා කළ හැකිය.

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] [server_id@]<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

මෙය පැරණි තනතුරකි, නමුත් මෙන්න මගේ විසඳුම:

Thread.currentThread().dumpStack();

වැඩි විස්තර සහ එහි තවත් ක්‍රම: http://javarevisited.blogspot.fr/2013/04/how-to-get-current-stack-trace-in-java-thread.html