जावा अपवादों को पढ़ना और पार्स करना

Question

मेरे पास एक छोटी सी प्रणाली है, और मैं ऐसे उत्पाद की पेशकश करना चाहता हूं जो त्रुटियों/अपवादों का विश्लेषण कर सके और एक संभावित समाधान का सुझाव दे सके।

तो मैं एक तरह से एक जावा अपवाद पार्स करने के लिए चाहते हैं (के बाद से मैं उन्हें केवल लॉग में है [मैं वास्तविक प्रणाली को प्रभावित नहीं करना चाहती])।

यह पार्स करने के बाद, मैं एक DB में सहेजने और पहले से सहेजे गए अपवाद (कुछ प्रारूप में) की तुलना करने के लिए, ताकि मैं निकटता से मेल खाने अपवाद पा सकते हैं चाहता हूँ।

मैंने निम्नलिखित विचारों के बारे में सोचा: "डी पर ए पर बी पर एक्सएक्सप्शन" को एक्स [एक्सएक्सप्शन, ए, बी, सी, डी] के रूप में सहेजा जाएगा और मैं किसी भी तरह से अपने डीबी में खोज कर रहा हूं: [XException ,?,?,?] जो निकटतम है। उदाहरण के लिए: [XException, ए, जी, सी, डी] काफी अच्छा है।

इन विचारों के बारे में आप क्या सोचते हैं?

अपवादों का विश्लेषण करने के लिए कोई प्रभावशाली तरीका? दो अपवाद के बीच की दूरी को परिभाषित करने के

कुशल या बेहतर तरीके?

किसी भी ओपन सोर्स किया कि यह कर सकते हैं के बारे में जानें - मैं किसी भी नहीं मिला है saure।

धन्यवाद।

Answer 1

यह यहाँ काफी कड़ी मेहनत है, लेकिन कुछ वास्तविक जीवन जेनरेट कर दिए अपवाद पार्स करने का एक प्रदर्शन है।

• विधि को अजीब नामित विधियों को आज़माने और कवर करने के लिए जेनर_ $ कहा जाता है। मुझे यकीन है कि मैंने हालांकि सभी मामलों को शामिल नहीं किया है।
• उन्हें java.lang.StackTraceElement की सूची में पुनर्निर्मित करें क्योंकि यह नौकरी के लिए सही प्रकार लगता है।

कोड:

private static List<String> generate_$() { 
    List<String> returnValue = new LinkedList<String>(); 
    Exception[] exceptions = { new ClassCastException(), 
      new NullPointerException(), new IOException("foo") }; 
    for (Exception exception : exceptions) { 
     try { 
      throw exception; 
     } catch (Exception e) { 
      StringWriter writer = new StringWriter(); 
      e.printStackTrace(new PrintWriter(writer)); 
      returnValue.add(writer.getBuffer().toString()); 
     } 
    } 
    return returnValue; 
} 

public static void main(String[] args) { 
    List<String> examples = generate_$(); 
    for (String trace : examples) { 
     Pattern headLinePattern = Pattern.compile("([\\w\\.]+)(:.*)?"); 
     Matcher headLineMatcher = headLinePattern.matcher(trace); 
     if (headLineMatcher.find()) { 
      System.out.println("Headline: " + headLineMatcher.group(1)); 
      if (headLineMatcher.group(2) != null) { 
       System.out.println("Optional message " 
         + headLineMatcher.group(2)); 
      } 
     } 
     // "at package.class.method(source.java:123)" 
     Pattern tracePattern = Pattern 
       .compile("\\s*at\\s+([\\w\\.$_]+)\\.([\\w$_]+)(\\(.*java)?:(\\d+)\\)(\\n|\\r\\n)"); 
     Matcher traceMatcher = tracePattern.matcher(trace); 
     List<StackTraceElement> stackTrace = new ArrayList<StackTraceElement>(); 
     while (traceMatcher.find()) { 
      String className = traceMatcher.group(1); 
      String methodName = traceMatcher.group(2); 
      String sourceFile = traceMatcher.group(3); 
      int lineNum = Integer.parseInt(traceMatcher.group(4)); 
      stackTrace.add(new StackTraceElement(className, methodName, 
        sourceFile, lineNum)); 
     } 
     System.out.println("Stack: " + stackTrace); 

    } 
} 

आउटपुट:

Headline: java.lang.ClassCastException 
Stack: [com.adamish.ExceptionParse.generate_$((ExceptionParse.java:16), com.adamish.ExceptionParse.main((ExceptionParse.java:31)] 

Headline: java.lang.NullPointerException 
Stack: [com.adamish.ExceptionParse.generate_$((ExceptionParse.java:17), com.adamish.ExceptionParse.main((ExceptionParse.java:31)] 

Headline: java.io.IOException 
Optional message : foo 
Stack: [com.adamish.ExceptionParse.generate_$((ExceptionParse.java:17), com.adamish.ExceptionParse.main((ExceptionParse.java:31)] 

Answer 2

मुझे लगता है कि यह प्रश्न बहुत खुले अंत के रूप में बंद होने जा रहा है। SO उन प्रश्नों के लिए है जो स्पष्ट और निश्चित उत्तर दिए जा सकते हैं।

फिर भी, इससे पहले कि ऐसा होता है मैं कहना है कि यह एक बहुत अच्छा विचार की तरह लगता है और मुझे आशा है कि आप यह काम कर सकते हैं करना चाहते हैं। स्टैक ट्रेस के उन हिस्सों पर ध्यान देना सबसे अच्छा होगा जो स्पष्ट रूप से पैकेज, कक्षा और विधि नामों जैसे अपरिवर्तनीय जानकारी की पहचान करते हैं। आंशिक या पूर्ण मैचों का पता लगाने के लिए, मेरा सुझाव है कि आप ज्ञात अनुक्रमण और मिलान करने वाले एल्गोरिदम देखें। पाठ खोजों के लिए कुछ प्रसिद्ध एल्गोरिदम लागू किए जा सकते हैं, लेकिन "परमाणु" इकाइयों के साथ विधि नाम या पैकेज-योग्य वर्ग नाम होने के बजाय एकल अक्षर या शब्द।

गुड लक!

संपादित करें: बस कुछ और सोचा। आप कई कार्यान्वयन भाषाओं, ढांचे इत्यादि के ढेर निशान के लिए यथासंभव सामान्य रूप से अपना कार्यान्वयन करने पर ध्यान केंद्रित करना चाहेंगे। यह सॉफ्टवेयर को भविष्य के सबूत और व्यापक रूप से लागू करेगा।