1.1 लॉगचा परिचय
लॉग ही घडलेल्या घटनांची यादी आहे. जवळजवळ एक नॉटिकल जर्नल किंवा डायरी सारखे. बरं, त्यानुसार, लॉगर एक ऑब्जेक्ट आहे ज्याद्वारे आपण लॉग करू शकता. प्रोग्रामिंगमध्ये, जवळजवळ प्रत्येक गोष्ट लॉग करण्याची प्रथा आहे. आणि जावामध्ये, सर्व काही असेच आहे आणि आणखी थोडे.
वस्तुस्थिती अशी आहे की जावा प्रोग्राम्स बहुतेक वेळा UI, कन्सोल इत्यादीशिवाय मोठे सर्व्हर अनुप्रयोग असतात. ते एकाच वेळी हजारो वापरकर्त्यांच्या विनंतीवर प्रक्रिया करतात आणि अनेकदा विविध त्रुटी येतात. विशेषत: जेव्हा वेगवेगळे धागे एकमेकांमध्ये व्यत्यय आणू लागतात.
आणि, खरं तर, अशा परिस्थितीत क्वचितच पुनरुत्पादित त्रुटी आणि अपयश शोधण्याचा एकमेव मार्ग म्हणजे लॉग / फाइलवर प्रत्येक थ्रेडमध्ये घडणारी प्रत्येक गोष्ट लिहिणे.
बर्‍याचदा, लॉगवर माहिती लिहिली जाते त्या पद्धतीच्या पॅरामीटर्सबद्दल ज्याद्वारे ते कॉल केले गेले होते, सर्व व्यत्यय आणलेल्या त्रुटी आणि बरीच मध्यवर्ती माहिती. लॉग जितका अधिक पूर्ण होईल तितका घटनांचा क्रम पुनर्संचयित करणे आणि अपयश किंवा त्रुटीची कारणे शोधणे सोपे आहे.
परंतु लॉग जितका मोठा असेल तितके त्याच्यासह कार्य करणे अधिक कठीण आहे. कधीकधी लॉग दररोज अनेक गीगाबाइट्सपर्यंत पोहोचतात. हे ठीक आहे.
1.2 अयशस्वी लॉग
प्रथम लॉग म्हणून, विकासकांनी कन्सोलवर फक्त आउटपुट वापरले . अनुप्रयोग डीबगिंग दरम्यान हे करणे सोयीचे आहे - जेव्हा सर्व महत्वाची माहिती आणि चल मूल्ये कन्सोलवर लिहिली जातात. परंतु अनुप्रयोगाच्या सामान्य ऑपरेशन दरम्यान असा लॉग पूर्णपणे लागू होत नाही.
प्रथम, अनुप्रयोगास कन्सोलवर काहीतरी आउटपुट करायचे आहे आणि वापरकर्त्यास प्रोग्रामरसाठी अभिप्रेत असलेली सेवा माहिती अजिबात पाहू इच्छित नाही.
दुसरे म्हणजे, कन्सोल बफरचा आकार मर्यादित आहे, आपण तेथे जास्त लिहू शकत नाही.
आणि शेवटी, तिसरे म्हणजे, प्रोग्रामच्या त्रुटींबद्दल माहिती जी दीर्घ कालावधीत संकलित केली जाते ती प्रोग्राम विकसकांना पाठविली पाहिजे. आणि ही सर्व माहिती एकाच वेळी फाईलवर लिहिणे सर्वात सोयीचे आहे.
विकसकांनी त्वरीत पहिली समस्या सोडवली - ते आणखी एक आउटपुट प्रवाह घेऊन आले - System.err. तुम्ही त्यावर संदेश लिहू शकता आणि ते एका वेगळ्या थ्रेडवर पाठवले जातील, मानक कन्सोलवर नाही.
आणि फाइलवर लिहिण्याची समस्या देखील सोडवली गेली:
// Define the file to which we will write the log
System.setErr(new PrintStream(new File("log.txt")));
// Display messages
System.err.println("Message 1");
System.err.println("Message 2");
// Display an error message
try {
throw new Exception("Error message");
} catch (Exception e) {
e.printStackTrace();
}परंतु या फॉर्ममध्येही, संपूर्ण समस्येचे निराकरण झाले नाही, म्हणून एक विशेष लायब्ररी तयार करण्याचा निर्णय घेण्यात आला जो फाइलवर लॉग संदेश लिहू शकेल. तिने हे स्मार्ट पद्धतीने केले आणि लॉग केलेले इव्हेंट आणि डेटासाठी फिल्टर कॉन्फिगर करण्याची लवचिकता दिली.
संपूर्ण लॉगिंग प्रक्रियेत, खरेतर, तीन भाग असतात:
- पहिला भाग म्हणजे माहिती गोळा करणे .
- दुसरा भाग गोळा केलेल्या माहितीचे फिल्टरिंग आहे.
- तिसरा भाग म्हणजे निवडलेल्या माहितीचे रेकॉर्डिंग .
1.3 log4j लॉगरचा परिचय
जावा समुदायातील पहिला लोकप्रिय लॉगर होता log4j. प्रोजेक्टमध्ये ते समाविष्ट करणे खूप सोपे आहे, यासाठी तुम्हाला तुमच्या pom.xml मध्ये फक्त दोन ओळी जोडणे आवश्यक आहे.
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>2.2.17</version>
</dependency>अशा लॉगरसह आपल्या प्रोग्रामची परस्परसंवाद यासारखे काहीतरी दिसेल:
class Manager {
private static final Logger logger = LoggerFactory.getLogger(Manager.class);
public boolean processTask(Task task) {
logger.debug("processTask id = " + task.getId());
try {
task.start();
task.progress();
task.complete();
return true;
} catch (Exception e) {
logger.error("Unknown error", e);
return false;
}
}
}येथे तीन गोष्टी घडतात:
ऑब्जेक्टची निर्मिती हिरव्या रंगात हायलाइट केली आहे Logger . त्याचा ऑब्जेक्ट त्याच्यासोबत सोयीस्कर पुढील कामासाठी स्थिर व्हेरिएबलमध्ये संग्रहित केला जातो. आणि getLogger()ज्या वर्गात माहिती संकलित केली जाते त्या वर्गाची माहिती देखील या पद्धतीला दिली जाते.
निळ्या रंगात ठळक केलेली ओळ आहे जिथे आपण केवळ डीबगिंग दरम्यान मूल्याची माहिती लॉग करतो . यासाठी, एक विशेष पद्धत वापरली जाते -debug()
आणि शेवटी , आपण लॉगमध्ये उद्भवलेला अपवाद जतन करतो ती ओळ लाल रंगात हायलाइट केली जाते . अपवाद संभाव्य त्रुटी आहेत, म्हणून error().