जावा लॉगिंग

नमस्ते! पाठ लिखते समय, मैं विशेष रूप से इस बात पर जोर देता हूं कि क्या कोई विशिष्ट विषय है जो वास्तविक कार्य में नितांत आवश्यक होगा। तो, सुनो! आज हम जिस विषय पर चर्चा करेंगे, वह रोजगार के पहले दिन से ही आपके सभी प्रोजेक्ट्स में निश्चित रूप से काम आएगा। हम जावा लॉगिंग के बारे में बात करने जा रहे हैं। यह विषय बिल्कुल जटिल नहीं है (मैं आसान भी कहूंगा)। लेकिन आपके पास अपनी पहली नौकरी पर जोर देने के लिए पर्याप्त स्पष्ट चीजें होंगी, इसलिए इसे अभी पूरी तरह से समझना बेहतर होगा :) अच्छा, चलिए शुरू करते हैं।

जावा में लॉगिंग क्या है?

लॉगिंग एक प्रोग्राम के संचालन के बारे में डेटा रिकॉर्ड करने का कार्य है। जिस स्थान पर हम इस डेटा को रिकॉर्ड करते हैं उसे "लॉग" कहा जाता है। दो प्रश्न तुरंत उठते हैं: क्या डेटा लिखा गया है और कहाँ लिखा गया है? आइए "कहां" से शुरू करें। आप कई अलग-अलग जगहों पर प्रोग्राम के काम के बारे में डेटा लिख ​​सकते हैं। उदाहरण के लिए, अपनी पढ़ाई के दौरान, आप अक्सर System.out.println()कंसोल में डेटा आउटपुट करने के लिए। यह वास्तव में लॉगिंग है, यद्यपि यह अपने सरलतम रूप में है। बेशक, यह उपयोगकर्ताओं या उत्पाद समर्थन टीम के लिए बहुत सुविधाजनक नहीं है: जाहिर है, वे एक आईडीई स्थापित नहीं करना चाहेंगे और कंसोल की निगरानी करेंगे :) रिकॉर्डिंग जानकारी के लिए एक अधिक प्रथागत प्रारूप है: पाठ फ़ाइलें। मनुष्य इस प्रारूप में डेटा पढ़ने में अधिक सहज हैं, और निश्चित रूप से यह डेटा संग्रहीत करने के लिए कहीं अधिक सुविधाजनक है! अब दूसरा प्रश्न: कौन सा प्रोग्राम डेटा लॉग किया जाना चाहिए? यह पूरी तरह आप पर निर्भर है! जावा का लॉगिंग सिस्टम बहुत लचीला है। आप अपने प्रोग्राम द्वारा की जाने वाली हर चीज को लॉग इन करने के लिए इसे कॉन्फ़िगर कर सकते हैं। एक ओर, यह अच्छा है। लेकिन दूसरी ओर, कल्पना करें कि फेसबुक या ट्विटर के लॉग कितने बड़े होंगे यदि उनमें सब कुछ लिखा गया हो। इन बड़ी कंपनियों के पास शायद इतना डेटा स्टोर करने की क्षमता है। लेकिन कल्पना कीजिए कि 500 ​​गीगाबाइट टेक्स्ट लॉग में एक महत्वपूर्ण त्रुटि के बारे में जानकारी प्राप्त करना कितना मुश्किल होगा? यह भूसे के ढेर में सुई खोजने से भी बुरा होगा। तदनुसार, जावा को केवल त्रुटि डेटा लॉग करने के लिए कॉन्फ़िगर किया जा सकता है। या यहाँ तक कि सिर्फ गंभीर त्रुटियाँ! उस ने कहा, जावा के देशी लॉगिंग सिस्टम के बारे में बात करना पूरी तरह से सही नहीं है। तथ्य यह है कि इस कार्यक्षमता को भाषा में जोड़ने से पहले प्रोग्रामर को लॉगिंग की आवश्यकता थी। जब तक जावा ने अपनी स्वयं की लॉगिंग लाइब्रेरी पेश की, तब तक हर कोई पहले से ही log4j लाइब्रेरी का उपयोग कर रहा था। जावा में लॉगिंग का इतिहास वास्तव में बहुत लंबा और जानकारीपूर्ण है। संक्षेप में, जावा की अपनी लॉगिंग लाइब्रेरी है, लेकिन लगभग कोई भी इसका उपयोग नहीं करता :) बाद में, जब कई अलग-अलग लॉगिंग लाइब्रेरी दिखाई दीं और प्रोग्रामरों द्वारा उपयोग की जाने लगीं, तो अनुकूलता की समस्या उत्पन्न हुई। लोगों को अलग-अलग इंटरफेस के साथ एक दर्जन अलग-अलग पुस्तकालयों में पहिया को फिर से शुरू करने से रोकने के लिए, अमूर्त SLF4J फ्रेमवर्क ("सर्विस लॉगिंग फेकाडे फॉर जावा") बनाया गया था। इसे अमूर्त कहा जाता है, क्योंकि भले ही आप SLF4J कक्षाओं के तरीकों का उपयोग करते हैं और कॉल करते हैं, हुड के तहत वे वास्तव में सभी लॉगिंग फ्रेमवर्क का उपयोग करते हैं जो पहले आए थे: log4j, मानक java.util.logging, और अन्य। यदि किसी बिंदु पर आपको अन्य पुस्तकालयों में लॉग 4 जे की कुछ विशिष्ट विशेषता की आवश्यकता है, लेकिन आप अपनी परियोजना को इस पुस्तकालय से सीधे लिंक नहीं करना चाहते हैं, तो बस एसएलएफ 4 जे का उपयोग करें। और फिर इसे Log4j विधियों को कॉल करने दें। यदि आप अपना विचार बदलते हैं और निर्णय लेते हैं कि अब आपको Log4j सुविधाओं की आवश्यकता नहीं है, तो आपको केवल "यहाँ , और Log4j पुस्तकालय यहाँ । अगला, संग्रह को अनपैक करें और JAR फ़ाइलों को क्लासपाथ में जोड़ने के लिए IntelliJ IDEA का उपयोग करें। मेनू आइटम: फ़ाइल -> प्रोजेक्ट संरचना -> पुस्तकालय आवश्यक JAR फ़ाइलों का चयन करें और उन्हें प्रोजेक्ट में जोड़ें (हमारे द्वारा डाउनलोड किए गए संग्रह में कई JAR फ़ाइलें हैं - आपको जो चाहिए उसे देखने के लिए चित्र देखें) ध्यान दें कि यह निर्देश उन छात्रों के लिए है जो मावेन का उपयोग करना नहीं जानते। यदि आप जानते हैं कि मावेन का उपयोग कैसे किया जाता है, तो वहां से शुरू करने का प्रयास करना आमतौर पर बेहतर (बहुत आसान) होता है। यदि आप मेवेन का उपयोग करते हैं , तो इस निर्भरता को जोड़ें:

    	<dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.14.0</version>
    	</dependency>

महान! हमने सेटिंग्स का पता लगाया :) आइए देखें कि SLF4J कैसे काम करता है। हम कैसे सुनिश्चित करें कि कार्यक्रम का काम कहीं दर्ज है? ऐसा करने के लिए, हमें दो चीजों की आवश्यकता है: लकड़हारा और परिशिष्ट। पहले से शुरू करते हैं। लकड़हारा एक वस्तु है जो लॉगिंग का पूर्ण नियंत्रण प्रदान करता है। लकड़हारा बनाना बहुत आसान है: हम इसे स्थिर LoggerFactory.getLogger() विधियों का उपयोग करके करते हैं। विधि पैरामीटर वह वर्ग है जिसका ऑपरेशन लॉग किया जाएगा। आइए अपना कोड चलाएं:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyTestClass {

   public static final Logger LOGGER = LoggerFactory.getLogger(MyTestClass.class);

   public static void main(String[] args) {

       LOGGER.info("Test log entry!!!");
       LOGGER.error("An error occurred!");
   }
}

कंसोल आउटपुट:

ERROR StatusLogger No Log4j 2 configuration file found. Using default configuration (logging only errors to the console), or user programmatically provided configurations. Set system property 'log4j2.debug' to show Log4j 2 internal initialization logging. See https://logging.apache.org/log4j/2.x/manual/configuration.html for instructions on how to configure Log4j 2 15:49:08.907 [main] ERROR MyTestClass - An error occurred!

हम यहाँ क्या देखते हैं? सबसे पहले, हम एक त्रुटि संदेश देखते हैं। यह इस तथ्य का परिणाम है कि अब हमारे पास आवश्यक सेटिंग्स की कमी है। तदनुसार, हमारा लकड़हारा वर्तमान में केवल त्रुटि संदेश (त्रुटि) और केवल कंसोल को आउटपुट करने में सक्षम है। logger.info () विधि काम नहीं करती थी। लेकिन लकड़हारा.त्रुटि () ने किया! कंसोल पर, हम वर्तमान दिनांक देखते हैं, वह विधि जहाँ त्रुटि हुई ( main), शब्द "त्रुटि", और हमारा संदेश! ERROR लॉगिंग स्तर है। सामान्य तौर पर, यदि एक लॉग प्रविष्टि "त्रुटि" शब्द के साथ चिह्नित है, तो कार्यक्रम में इस बिंदु पर एक त्रुटि हुई है। यदि प्रविष्टि "INFO" शब्द से चिह्नित है, तो संदेश केवल कार्यक्रम के सामान्य संचालन के बारे में वर्तमान जानकारी का प्रतिनिधित्व करता है। SLF4J लाइब्रेरी में कई अलग-अलग लॉगिंग स्तर हैं जो आपको लॉगिंग को लचीले ढंग से कॉन्फ़िगर करने देते हैं। यह सब प्रबंधित करना बहुत आसान है: सभी आवश्यक तर्क पहले से ही Java Logger क्लास में हैं। आपको केवल प्रासंगिक तरीकों को कॉल करने की आवश्यकता है। अगर आप नियमित संदेश लॉग करना चाहते हैं, तो logger.info() विधि को कॉल करें। त्रुटि संदेश के लिए, logger.error() का उपयोग करें । चेतावनी के लिए, logger.warn() का उपयोग करें

अब बात करते हैं एपेंडर की

एक परिशिष्ट वह स्थान है जहां आपका डेटा जाता है। एक तरह से डेटा स्रोत के विपरीत, यानी "बिंदु बी"। डिफ़ॉल्ट रूप से, डेटा कंसोल पर आउटपुट होता है। ध्यान दें कि पिछले उदाहरण में हमें कुछ भी कॉन्फ़िगर करने की आवश्यकता नहीं थी: पाठ कंसोल में दिखाई दिया, और Log4j लाइब्रेरी का लकड़हारा केवल ERROR- स्तर के संदेशों को कंसोल पर आउटपुट कर सकता है। जाहिर है, लोगों के लिए टेक्स्ट फ़ाइल में लॉग पढ़ना और लिखना अधिक सुविधाजनक है। लकड़हारे के डिफ़ॉल्ट व्यवहार को बदलने के लिए, हमें अपने फ़ाइल एपेंडर को कॉन्फ़िगर करने की आवश्यकता है। आरंभ करने के लिए, आपको सीधे src फ़ोल्डर में एक log4j.xml फ़ाइल बनानी होगी। आप पहले से ही XML प्रारूप से परिचित हैं: हमारे पास हाल ही में इसके बारे में एक पाठ था :) फ़ाइल की सामग्री यहां दी गई है:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO">
   <Appenders>
       <File name="MyFileAppender" fileName="C:\Users\Username\Desktop\testlog.txt" immediateFlush="false" append="false">
           <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
       </File>
   </Appenders>
   <Loggers>
       <Root level="INFO">
           <AppenderRef ref="MyFileAppender"/>
       </Root>
   </Loggers>
</Configuration>

यहाँ कुछ भी विशेष या कठिन नहीं है :) लेकिन फिर भी, सामग्री के माध्यम से चलते हैं।

<Configuration status="INFO">

यह तथाकथित स्टेटसलॉगर है। यह हमारे लकड़हारे से संबंधित नहीं है और इसका उपयोग Log4j की आंतरिक प्रक्रियाओं में किया जाता है। यदि आप स्थिति = "INFO" के बजाय स्थिति = "TRACE" सेट करते हैं, और Log4j के आंतरिक कार्य के बारे में सभी जानकारी कंसोल पर प्रदर्शित की जाएगी (StatusLogger कंसोल पर डेटा प्रदर्शित करता है, भले ही हमारा एपेंडर एक फ़ाइल हो)। हमें अभी इसकी आवश्यकता नहीं है, इसलिए इसे ऐसे ही रहने दें।

<Appenders>
   <File name="MyFileAppender" fileName="C:\Users\Evgeny\Desktop\testlog.txt" append="true">
       <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
   </File>
</Appenders>

यहां हम अपना एपेंडर बनाते हैं। < फ़ाइल> टैग इंगित करता है कि यह एक फ़ाइल एपेंडर होगा। नाम = "MyFileAppender" एपेंडर का नाम सेट करता है। fileName="C:\Users\Username\Desktop\testlog.txt" लॉग फ़ाइल का पथ इंगित करता है जहां सभी डेटा लिखा जाएगा। परिशिष्ट = "सत्य" इंगित करता है कि फ़ाइल के अंत में डेटा लिखा जाना चाहिए या नहीं। हमारे मामले में, ठीक यही हम करेंगे। यदि आप मान को गलत पर सेट करते हैं, तो लॉग फ़ाइल की पुरानी सामग्री हर बार प्रोग्राम शुरू होने पर हटा दी जाएगी। <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>स्वरूपण सेटिंग्स को इंगित करता है। यहां हम रेगुलर एक्सप्रेशन का उपयोग यह अनुकूलित करने के लिए कर सकते हैं कि हमारे लॉग में टेक्स्ट को कैसे स्वरूपित किया जाता है।

<Loggers>
       <Root level="INFO">
           <AppenderRef ref="MyFileAppender"/>
       </Root>
</Loggers>

यहां हम रूट लेवल का संकेत देते हैं। हमने "INFO" स्तर निर्धारित किया है, जिसका अर्थ है कि वे सभी संदेश जिनका स्तर INFO से अधिक है (ऊपर दी गई तालिका के अनुसार) लॉग नहीं किया जाएगा। हमारे कार्यक्रम में 3 संदेश होंगे: एक सूचना, एक चेतावनी और एक त्रुटि। वर्तमान कॉन्फ़िगरेशन के साथ, सभी 3 संदेशों को लॉग किया जाएगा। यदि आप रूट स्तर को ERROR में बदलते हैं, तो LOGGER.error() विधि कॉल से केवल अंतिम संदेश लॉग में समाप्त हो जाएगा। इसके अतिरिक्त, परिशिष्ट का एक संदर्भ भी यहाँ जाता है। ऐसा संदर्भ बनाने के लिए, आपको <ApprenderRef> टैग को <Root> टैग के अंदर बनाना होगा और उसमें ref='your appender's name' विशेषता जोड़नी होगी। यदि आप भूल गए हैं, तो हम यहीं पर परिशिष्ट का नाम सेट करते हैं: <. और यहाँ हमारा कोड है!

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyTestClass {

   public static final Logger LOGGER = LoggerFactory.getLogger(MyTestClass.class);

   public static void main(String[] args) {

       LOGGER.info("The program is starting!!!");

       try {
           LOGGER.warn("Attention! The program is trying to divide a number by another.
           System.out.println(12/0);
       } catch (ArithmeticException x) {

           LOGGER.error("Error! Division by zero!");
       }
   }
}

बेशक, यह थोड़ा अजीब है (एक रनटाइम अपवाद को पकड़ना एक संदिग्ध विचार है), लेकिन यह हमारे उद्देश्यों के लिए एकदम सही है :) चलो अपनी मुख्य () विधि को लगातार 4 बार चलाते हैं और हमारी testlog.txt फ़ाइल को देखते हैं। आपको इसे पहले से बनाने की आवश्यकता नहीं है: पुस्तकालय यह स्वचालित रूप से करेगा। सब कुछ काम कर गया! :) अब आपके पास एक कॉन्फ़िगर किया हुआ लकड़हारा है। आप अपने कुछ पुराने कार्यक्रमों के साथ खेल सकते हैं, प्रत्येक विधि में लॉगर कॉल जोड़ सकते हैं। फिर परिणामी लॉग को देखें :) यह लॉगिंग के विषय पर गहराई से विचार करता है। इसे एक बैठक में पूरा पढ़ना चुनौतीपूर्ण होगा। उस ने कहा, इसमें बहुत सी अतिरिक्त उपयोगी जानकारी शामिल है। उदाहरण के लिए, यदि हमारी testlog.txt फ़ाइल एक निश्चित आकार तक पहुँचती है तो आप लकड़हारे को कॉन्फ़िगर करना सीखेंगे ताकि यह एक नई पाठ फ़ाइल बना सके :) और यह हमारी कक्षा का समापन करता है! आज आप एक बहुत ही महत्वपूर्ण विषय से परिचित हुए, और यह ज्ञान आपके भविष्य के कार्यों में निश्चित रूप से सहायक होगा। अगली बार तक! :)