जावा लॉगिंग

हाय! धडे लिहिताना, मी विशेषत: एखादा विशिष्ट विषय असल्यास त्यावर जोर देतो जो वास्तविक कार्यात पूर्णपणे आवश्यक असेल. तर, ऐका! आज आम्ही ज्या विषयावर चर्चा करणार आहोत तो रोजगाराच्या पहिल्या दिवसापासून तुमच्या सर्व प्रकल्पांमध्ये नक्कीच उपयोगी पडेल. आपण Java Logging बद्दल बोलणार आहोत. हा विषय अजिबात क्लिष्ट नाही (मी अगदी सोपा म्हणेन). पण तुमच्या पहिल्या कामावर ताण देण्यासाठी तुमच्याकडे पुरेशा स्पष्ट गोष्टी असतील, त्यामुळे आत्ताच ते नीट समजून घेणे चांगले आहे :) बरं, चला सुरुवात करूया.

Java मध्ये लॉग इन करणे म्हणजे काय?

लॉगिंग हे प्रोग्रामच्या ऑपरेशनबद्दल डेटा रेकॉर्ड करण्याची क्रिया आहे. ज्या ठिकाणी आपण हा डेटा रेकॉर्ड करतो त्याला "लॉग" म्हणतात. दोन प्रश्न लगेच उद्भवतात: कोणता डेटा लिहिला आहे आणि कुठे? चला "कुठे" ने सुरुवात करूया. तुम्ही प्रोग्रामच्या कामाचा डेटा वेगवेगळ्या ठिकाणी लिहू शकता. उदाहरणार्थ, तुमच्या अभ्यासादरम्यान तुम्ही अनेकदा System.out.println()कन्सोलवर डेटा आउटपुट करण्यासाठी. हे खरंच लॉगिंग आहे, जरी त्याच्या सर्वात सोप्या स्वरूपात. अर्थात, हे वापरकर्त्यांसाठी किंवा उत्पादन समर्थन संघासाठी फारसे सोयीचे नाही: अर्थातच, ते IDE स्थापित करू इच्छित नाहीत आणि कन्सोलचे निरीक्षण करू इच्छित नाहीत :) माहिती रेकॉर्ड करण्यासाठी अधिक प्रचलित स्वरूप आहे: मजकूर फाइल्स. या फॉरमॅटमध्‍ये डेटा वाचण्‍यासाठी माणसे अधिक सोयीस्कर आहेत आणि डेटा संग्रहित करण्‍यासाठी ते अधिक सोयीचे आहे! आता दुसरा प्रश्न: कोणता प्रोग्राम डेटा लॉग केला पाहिजे? ते सर्वस्वी तुमच्यावर अवलंबून आहे! Java ची लॉगिंग प्रणाली अतिशय लवचिक आहे. तुमचा प्रोग्राम करत असलेल्या सर्व गोष्टी लॉग करण्यासाठी तुम्ही ते कॉन्फिगर करू शकता. एकीकडे, हे चांगले आहे. पण दुसरीकडे, कल्पना करा की फेसबुक किंवा ट्विटरच्या लॉगमध्ये सर्वकाही लिहिले तर ते किती मोठे असेल. या मोठ्या कंपन्यांकडे कदाचित इतका डेटा संग्रहित करण्याची क्षमता आहे. परंतु 500 गीगाबाइट्स मजकूर लॉगमध्ये एका गंभीर त्रुटीबद्दल माहिती शोधणे किती कठीण असेल याची कल्पना करा? ते गवताच्या गंजीत सुई शोधण्यापेक्षा वाईट असेल. त्यानुसार, Java फक्त त्रुटी डेटा लॉग करण्यासाठी कॉन्फिगर केले जाऊ शकते. किंवा अगदी गंभीर चुका! ते म्हणाले, Java च्या मूळ लॉगिंग सिस्टमबद्दल बोलणे पूर्णपणे अचूक नाही. वस्तुस्थिती अशी आहे की ही कार्यक्षमता भाषेमध्ये जोडण्यापूर्वी प्रोग्रामरना लॉगिंगची आवश्यकता होती. Java ने स्वतःची लॉगिंग लायब्ररी सुरू केली तोपर्यंत, प्रत्येकजण आधीच log4j लायब्ररी वापरत होता. Java मध्ये लॉग इन करण्याचा इतिहास खरं तर खूप मोठा आणि माहितीपूर्ण आहे. थोडक्यात, जावाची स्वतःची लॉगिंग लायब्ररी आहे, परंतु जवळजवळ कोणीही ते वापरत नाही :) नंतर, जेव्हा अनेक भिन्न लॉगिंग लायब्ररी दिसू लागल्या आणि प्रोग्रामरद्वारे वापरल्या जाऊ लागल्या, तेव्हा सुसंगतता समस्या उद्भवल्या. लोकांना वेगवेगळ्या इंटरफेससह डझनभर वेगवेगळ्या लायब्ररींमध्ये चाक पुन्हा शोधण्यापासून रोखण्यासाठी, अमूर्त SLF4J फ्रेमवर्क ("जावासाठी सर्व्हिस लॉगिंग फॅकेड") तयार केले गेले. याला अ‍ॅबस्ट्रॅक्ट म्हणतात, कारण जरी तुम्ही SLF4J क्लासेसच्या पद्धती वापरल्या आणि कॉल केल्या तरीही, ते प्रत्यक्षात आधी आलेले सर्व लॉगिंग फ्रेमवर्क वापरतात: log4j, मानक java.util.logging आणि इतर. एखाद्या वेळी तुम्हाला Log4j च्या काही विशिष्ट वैशिष्ट्यांची आवश्यकता असल्यास इतर लायब्ररींमध्ये अभाव असल्यास, परंतु तुम्ही या लायब्ररीशी तुमचा प्रकल्प थेट लिंक करू इच्छित नसल्यास, फक्त SLF4J वापरा. आणि मग त्याला Log4j पद्धती म्हणू द्या. जर तुम्ही तुमचा विचार बदलला आणि ठरवले की तुम्हाला यापुढे Log4j वैशिष्ट्यांची आवश्यकता नाही, तर तुम्हाला फक्त "पुन्हा कॉन्फिगर करणे आवश्यक आहे.येथे , आणि Log4j लायब्ररी येथे आहे . पुढे, संग्रह अनपॅक करा आणि JAR फाइल्स क्लासपाथमध्ये जोडण्यासाठी IntelliJ IDEA वापरा. मेनू आयटम: फाइल -> प्रोजेक्ट स्ट्रक्चर -> लायब्ररी आवश्यक JAR फाईल्स निवडा आणि त्या प्रोजेक्टमध्ये जोडा (आम्ही डाउनलोड केलेल्या आर्काइव्हमध्ये अनेक JAR फाइल्स आहेत — तुम्हाला आवश्यक असलेल्या फोटो पाहण्यासाठी चित्रे पहा) लक्षात घ्या की ही सूचना त्या विद्यार्थ्यांसाठी आहे आम्हाला लॉगिंग का आवश्यक आहे - 2

. ज्यांना मावेन कसे वापरायचे हे माहित नाही. तुम्हाला Maven कसे वापरायचे हे माहित असल्यास, तेथे प्रारंभ करण्याचा प्रयत्न करणे सहसा चांगले (खूप सोपे) आहे. तुम्ही Maven वापरत असल्यास , हे अवलंबित्व जोडा:

<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!

आम्ही येथे काय पाहतो? प्रथम, आम्हाला एक त्रुटी संदेश दिसतो. हे या वस्तुस्थितीचा परिणाम आहे की आता आमच्याकडे आवश्यक सेटिंग्जची कमतरता आहे. त्यानुसार, आमचा लॉगर सध्या फक्त एरर मेसेज (ERROR) आउटपुट करण्यास सक्षम आहे आणि फक्त कन्सोलवर. logger.info () पद्धत काम करत नाही. पण logger.error() ने केले! कन्सोलवर, आम्हाला वर्तमान तारीख, त्रुटी आली ती पद्धत ( मुख्य), शब्द "त्रुटी", आणि आमचा संदेश! ERROR ही लॉगिंग पातळी आहे. सर्वसाधारणपणे, जर लॉग एंट्रीला "ERROR" शब्दाने चिन्हांकित केले असेल, तर प्रोग्राममध्ये या टप्प्यावर एक त्रुटी आली आहे. जर एंट्री "INFO" शब्दाने चिन्हांकित केली असेल, तर संदेश फक्त प्रोग्रामच्या सामान्य ऑपरेशनबद्दल वर्तमान माहिती दर्शवतो. SLF4J लायब्ररीमध्ये बरेच भिन्न लॉगिंग स्तर आहेत जे तुम्हाला लवचिकपणे लॉगिंग कॉन्फिगर करू देतात. हे सर्व व्यवस्थापित करणे खूप सोपे आहे: सर्व आवश्यक तर्कशास्त्र आधीपासूनच Java Logger वर्गात आहे. आपल्याला फक्त संबंधित पद्धतींना कॉल करण्याची आवश्यकता आहे. तुम्हाला नियमित संदेश लॉग करायचा असल्यास, logger.info() पद्धतीवर कॉल करा. त्रुटी संदेशासाठी, logger.error() वापरा . चेतावणीसाठी, logger.warn() वापरा

आता ऍपेंडरबद्दल बोलूया

अपेंडर म्हणजे तुमचा डेटा जिथे जातो. एका प्रकारे, डेटा स्त्रोताच्या उलट, म्हणजे "बिंदू B". डीफॉल्टनुसार, डेटा कन्सोलवर आउटपुट केला जातो. लक्षात घ्या की मागील उदाहरणामध्ये आम्हाला काहीही कॉन्फिगर करावे लागले नाही: मजकूर कन्सोलमध्ये दिसला आणि Log4j लायब्ररीचा लॉगर कन्सोलमध्ये फक्त त्रुटी-स्तरीय संदेश आउटपुट करू शकतो. अर्थात, मजकूर फाइलमधील लॉग वाचणे आणि लिहिणे लोकांसाठी अधिक सोयीचे आहे. लॉगरचे डीफॉल्ट वर्तन बदलण्यासाठी, आम्हाला आमची फाईल ऍपेंडर कॉन्फिगर करणे आवश्यक आहे. प्रारंभ करण्यासाठी, तुम्हाला थेट 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" ऐवजी status="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>

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

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

येथे आम्ही मूळ पातळी दर्शवितो. आम्ही "INFO" पातळी सेट केली आहे, याचा अर्थ सर्व संदेश ज्यांचे स्तर INFO पेक्षा जास्त आहेत (आम्ही वर पाहिलेल्या सारणीनुसार) लॉग केले जाणार नाहीत. आमच्या प्रोग्राममध्ये 3 संदेश असतील: एक माहिती, एक चेतावणी आणि एक त्रुटी. सध्याच्या कॉन्फिगरेशनसह, सर्व 3 संदेश लॉग केले जातील. तुम्ही रूट लेव्हल ERROR मध्ये बदलल्यास, लॉगमध्ये फक्त LOGGER.error() मेथड कॉलचा शेवटचा मेसेज येईल. याव्यतिरिक्त, परिशिष्टाचा संदर्भ देखील येथे जातो. असा संदर्भ तयार करण्यासाठी, तुम्हाला <Root> टॅगमध्ये <ApprenderRef> टॅग तयार करावा लागेल आणि त्यात 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!");
       }
   }
}

अर्थात, हे थोडे विचित्र आहे (एक RuntimeException पकडणे ही एक शंकास्पद कल्पना आहे), परंतु ती आमच्या उद्देशांसाठी योग्य आहे :) चला आमची main() पद्धत सलग ४ वेळा चालवू आणि testlog.txt फाइल पाहू. तुम्हाला ते आगाऊ तयार करण्याची गरज नाही: लायब्ररी हे आपोआप करेल. सर्व काही काम केले! :) आता तुमच्याकडे कॉन्फिगर केलेला लॉगर आहे. प्रत्येक पद्धतीमध्ये लॉगर कॉल जोडून तुम्ही तुमच्या काही जुन्या प्रोग्राम्ससह खेळू शकता. नंतर परिणामी लॉग पहा :) हे लॉग इन खोलीच्या विषयावर विचार करते. हे सर्व एकाच बैठकीत वाचणे आव्हानात्मक असेल. ते म्हणाले, त्यात बरीच अतिरिक्त उपयुक्त माहिती आहे. उदाहरणार्थ, तुम्ही लॉगर कसे कॉन्फिगर करायचे ते शिकाल जेणेकरून आमची testlog.txt फाइल विशिष्ट आकारापर्यंत पोहोचल्यास ती नवीन मजकूर फाइल तयार करेल :) आणि त्यामुळे आमचा वर्ग संपेल! आज तुम्‍हाला एका अतिशय महत्‍त्‍वाच्‍या विषयाची ओळख झाली आहे आणि हे ज्ञान तुमच्‍या भावी कार्यात तुम्‍हाला नक्कीच उपयोगी पडेल. पुढच्या वेळे पर्यंत! :)