java - मैं एक स्टैक ट्रेस को एक स्ट्रिंग में कैसे परिवर्तित कर सकता हूं?




stack-trace tostring (18)

Throwable.getStackTrace() के परिणाम को स्ट्रिंगट्रैक को Throwable.getStackTrace() एक स्ट्रिंग में कनवर्ट करने का सबसे आसान तरीका क्या है?


Kotlin

थ्रोबल क्लास को विस्तारित करने से आपको स्ट्रिंग प्रॉपर्टी error.stackTraceString :

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


अपने अपवाद के ढेर को प्रदर्शित करने के लिए exp.printStackTrace() उपयोग करें।

try {
   int zero = 1 - 1;
   int a = 1/zero;
} catch (Exception e) {
    e.printStackTrace();
}

उचित लेखक को स्टैक ट्रेस भेजने के लिए Throwable.printStackTrace (PrintWriter pw) का उपयोग करें।

import java.io.StringWriter;
import java.io.PrintWriter;

// ...

StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
e.printStackTrace(pw);
String sStackTrace = sw.toString(); // stack trace as a string
System.out.println(sStackTrace);

गाला के उत्तर पर एक विस्तार जिसमें अपवाद के कारण भी शामिल होंगे:

private String extrapolateStackTrace(Exception ex) {
    Throwable e = ex;
    String trace = e.toString() + "\n";
    for (StackTraceElement e1 : e.getStackTrace()) {
        trace += "\t at " + e1.toString() + "\n";
    }
    while (e.getCause() != null) {
        e = e.getCause();
        trace += "Cause by: " + e.toString() + "\n";
        for (StackTraceElement e1 : e.getStackTrace()) {
            trace += "\t at " + e1.toString() + "\n";
        }
    }
    return trace;
}

चेतावनी: कारण शामिल नहीं है (जो आमतौर पर उपयोगी बिट है!)

public String stackTraceToString(Throwable e) {
    StringBuilder sb = new StringBuilder();
    for (StackTraceElement element : e.getStackTrace()) {
        sb.append(element.toString());
        sb.append("\n");
    }
    return sb.toString();
}

टिप्पणियों के पहले सेट में चालाक स्निपिंग बहुत मनोरंजक था, लेकिन यह वास्तव में उस पर निर्भर करता है जो आप करने की कोशिश कर रहे हैं। यदि आपके पास पहले से ही सही लाइब्रेरी नहीं है, तो कोड की 3 पंक्तियां (जैसे डी। Wroblewski के जवाब में) सही है। ओटीओएच, यदि आपके पास पहले से apache.commons लाइब्रेरी है (जैसा कि अधिकांश बड़ी परियोजनाएं होंगी), तो अमर का जवाब छोटा है। ठीक है, लाइब्रेरी प्राप्त करने में आपको दस मिनट लग सकते हैं और इसे सही तरीके से इंस्टॉल कर सकते हैं (यदि आप जानते हैं कि आप क्या कर रहे हैं तो एक से कम)। लेकिन घड़ी टिक रही है, इसलिए आपके पास समय बिताने का समय नहीं है। जरेक प्रिजगोदज्की की एक दिलचस्प चेतावनी थी - "अगर आपको नेस्टेड अपवादों की आवश्यकता नहीं है"।

लेकिन अगर मुझे पूर्ण स्टैक निशान, घोंसले और सभी की ज़रूरत है तो क्या होगा? उस स्थिति में, गुप्त apache.common के getFullStackTrace का उपयोग करना है ( http://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/exception/ExceptionUtils.html#getFullStackTrace%28java.lang.Throwable%29 देखें http://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/exception/ExceptionUtils.html#getFullStackTrace%28java.lang.Throwable%29 )

यह मेरे बेकन बचाया। धन्यवाद, अमर, संकेत के लिए!


निम्न कोड आपको एक String प्रारूप के साथ संपूर्ण स्टैकट्रेस प्राप्त करने की अनुमति देता है, बिना लॉग 4 जे या यहां तक ​​कि java.util.Logger जैसे API का उपयोग किए बिना:

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.
}

प्रिंटस्ट्रीम पर स्टैकट्रैक प्रिंट करें, फिर इसे स्ट्रिंग में कनवर्ट करें

// ...

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

मेरे लिए सबसे साफ और आसान तरीका था:

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

यदि आप जावा 8 का उपयोग कर रहे हैं, तो इसे आजमाएं

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

आप Throwable.java द्वारा प्रदान किए गए getStackTrace () फ़ंक्शन के लिए कोड पा सकते हैं:

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

और StackTraceElement के लिए, यह प्रदाता को स्ट्रिंग के रूप में:

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

तो बस "\ n" के साथ StackTraceElement में शामिल हों


यदि आप बाहरी पुस्तकालय का उपयोग नहीं करना चाहते हैं और आप एंड्रॉइड के लिए विकास नहीं कर रहे हैं, तो आप इस तरह 'एक्सटेंशन' विधि बना सकते हैं:

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.StringWriter; 
import java.io.PrintWriter;

//Two lines of code to get the exception into a StringWriter
StringWriter sw = new StringWriter();
new Throwable().printStackTrace(new PrintWriter(sw));

//And to actually print it
logger.info("Current stack trace is:\n" + sw.toString());

या, एक पकड़ ब्लॉक में

} catch (Throwable t) {
    StringWriter sw = new StringWriter();
    t.printStackTrace(new PrintWriter(sw));
    logger.info("Current stack trace is:\n" + sw.toString());
}

समाधान स्ट्रिंग डेटा प्रकार स्ट्रिंग करने के लिए सरणी के stackTrace को परिवर्तित करना है । निम्नलिखित उदाहरण देखें:

import java.util.Arrays;

try{

}catch(Exception ex){
    String stack = Arrays.toString(ex.getStackTrace());
    System.out.println("stack "+ stack);
}

स्ट्रिंग के लिए मुद्रण स्टैक ट्रेस

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

जब आप Throwable उदाहरण के बिना वर्तमान थ्रेड स्टैक ट्रेस मुद्रित करना चाहते हैं तो यह उपयोगी होता है - लेकिन ध्यान दें कि नए Throwable बनाने और वहां से स्टैक ट्रेस प्राप्त करना वास्तव में Thread.getStackTrace कॉल करने से तेज़ और सस्ता है।


java.io.* बिना java.io.* यह इस तरह किया जा सकता है।

String trace = e.toString() + "\n";                     

for (StackTraceElement e1 : e.getStackTrace()) {
    trace += "\t at " + e1.toString() + "\n";
}   

और फिर trace वैरिएबल आपके स्टैक ट्रेस रखता है। आउटपुट में प्रारंभिक कारण भी होता है, आउटपुट printStackTrace() समान होता है

उदाहरण, printStackTrace() उपज:

java.io.FileNotFoundException: / (Is a directory)
    at java.io.FileOutputStream.open0(Native Method)
    at java.io.FileOutputStream.open(FileOutputStream.java:270)
    at java.io.FileOutputStream.<init>(FileOutputStream.java:213)
    at java.io.FileOutputStream.<init>(FileOutputStream.java:101)
    at Test.main(Test.java:9)

stdout मुद्रित होने पर trace स्ट्रिंग रखती है

java.io.FileNotFoundException: / (Is a directory)
     at java.io.FileOutputStream.open0(Native Method)
     at java.io.FileOutputStream.open(FileOutputStream.java:270)
     at java.io.FileOutputStream.<init>(FileOutputStream.java:213)
     at java.io.FileOutputStream.<init>(FileOutputStream.java:101)
     at Test.main(Test.java:9)

Arrays.toString(thrown.getStackTrace())

परिणाम को स्ट्रिंग में बदलने का सबसे आसान तरीका है मैं स्टैक ट्रेस प्रिंट करने के लिए अपने प्रोग्राम में इसका उपयोग कर रहा हूं

LOGGER.log(Level.SEVERE, "Query Builder Issue Stack Trace : {0} ,Message : {1} objid {2}", new Object[]{Arrays.toString(e.getStackTrace()), e.getMessage(),objId});

private String getCurrentStackTraceString() {
    StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
    return Arrays.stream(stackTrace).map(StackTraceElement::toString)
            .collect(Collectors.joining("\n"));
}





tostring