జావా లాగింగ్

హాయ్! పాఠాలు వ్రాసేటప్పుడు, నిజమైన పనిలో ఖచ్చితంగా అవసరమైన నిర్దిష్ట అంశం ఉంటే నేను ప్రత్యేకంగా నొక్కి చెబుతాను. కాబట్టి, వినండి! ఈరోజు మేము కవర్ చేయబోయే అంశం ఉద్యోగంలో మొదటి రోజు నుండి మీ అన్ని ప్రాజెక్ట్‌లలో ఖచ్చితంగా ఉపయోగపడుతుంది. మేము జావా లాగింగ్ గురించి మాట్లాడబోతున్నాము. ఈ అంశం సంక్లిష్టంగా లేదు (నేను కూడా సులభంగా చెబుతాను). కానీ మీరు మీ మొదటి ఉద్యోగంలో ఒత్తిడికి గురిచేసేంత స్పష్టమైన విషయాలను కలిగి ఉంటారు, కాబట్టి ఇప్పుడే దాన్ని పూర్తిగా అర్థం చేసుకోవడం మంచిది :) సరే, ప్రారంభిద్దాం.

జావాలో లాగింగ్ అంటే ఏమిటి?

లాగింగ్ అనేది ప్రోగ్రామ్ యొక్క ఆపరేషన్ గురించి డేటాను రికార్డ్ చేసే చర్య. మనం ఈ డేటాను రికార్డ్ చేసే ప్రదేశాన్ని "లాగ్" అంటారు. వెంటనే రెండు ప్రశ్నలు తలెత్తుతాయి: ఏ డేటా వ్రాయబడింది మరియు ఎక్కడ? "ఎక్కడ" తో ప్రారంభిద్దాం. మీరు అనేక విభిన్న ప్రదేశాలలో ప్రోగ్రామ్ యొక్క పని గురించి డేటాను వ్రాయవచ్చు. ఉదాహరణకు, మీ అధ్యయన సమయంలో, మీరు తరచుగా System.out.println()కన్సోల్‌కు డేటాను అవుట్‌పుట్ చేయడానికి. ఇది నిజానికి లాగింగ్, అయినప్పటికీ దాని సరళమైన రూపంలో. వాస్తవానికి, వినియోగదారులు లేదా ఉత్పత్తి మద్దతు బృందానికి ఇది చాలా సౌకర్యవంతంగా ఉండదు: స్పష్టంగా, వారు IDEని ఇన్‌స్టాల్ చేసి, కన్సోల్‌ని పర్యవేక్షించడానికి ఇష్టపడరు :) సమాచారాన్ని రికార్డింగ్ చేయడానికి మరింత అనుకూలమైన ఫార్మాట్ ఉంది: టెక్స్ట్ ఫైల్‌లు. మానవులు ఈ ఫార్మాట్‌లో డేటాను చదవడం చాలా సౌకర్యంగా ఉంటుంది మరియు డేటాను నిల్వ చేయడానికి ఇది మరింత సౌకర్యవంతంగా ఉంటుంది! ఇప్పుడు రెండవ ప్రశ్న: ఏ ప్రోగ్రామ్ డేటాను లాగిన్ చేయాలి? అది పూర్తిగా మీ ఇష్టం! జావా లాగింగ్ సిస్టమ్ చాలా అనువైనది. మీ ప్రోగ్రామ్ చేసే ప్రతిదాన్ని లాగ్ చేయడానికి మీరు దీన్ని కాన్ఫిగర్ చేయవచ్చు. ఒక వైపు, ఇది మంచిది. అయితే మరోవైపు, ఫేస్‌బుక్ లేదా ట్విటర్‌ల లాగ్‌లు అన్నింటినీ అందులో రాస్తే ఎంత పెద్దవిగా ఉంటాయో ఊహించుకోండి. ఈ పెద్ద కంపెనీలు బహుశా చాలా డేటాను నిల్వ చేయగల సామర్థ్యాన్ని కలిగి ఉంటాయి. అయితే 500 గిగాబైట్ల టెక్స్ట్ లాగ్‌లలో ఒక క్లిష్టమైన లోపం గురించి సమాచారాన్ని కనుగొనడం ఎంత కష్టమో ఊహించండి? అది గడ్డివాములో సూది కోసం వెతకడం కంటే ఘోరంగా ఉంటుంది. దీని ప్రకారం, జావా దోష డేటాను మాత్రమే లాగ్ చేయడానికి కాన్ఫిగర్ చేయవచ్చు. లేదా కేవలం క్లిష్టమైన లోపాలు కూడా! జావా యొక్క స్థానిక లాగింగ్ సిస్టమ్ గురించి మాట్లాడటం పూర్తిగా ఖచ్చితమైనది కాదు. వాస్తవం ఏమిటంటే, ఈ ఫంక్షనాలిటీని భాషకు జోడించే ముందు ప్రోగ్రామర్‌లకు లాగింగ్ అవసరం. జావా తన స్వంత లాగింగ్ లైబ్రరీని ప్రవేశపెట్టే సమయానికి, ప్రతి ఒక్కరూ ఇప్పటికే log4j లైబ్రరీని ఉపయోగిస్తున్నారు. జావాలో లాగింగ్ చరిత్ర నిజానికి చాలా పొడవుగా మరియు సమాచారంగా ఉంది. సంక్షిప్తంగా, జావా దాని స్వంత లాగింగ్ లైబ్రరీని కలిగి ఉంది, కానీ దాదాపు ఎవరూ దీనిని ఉపయోగించరు :) తరువాత, అనేక విభిన్న లాగింగ్ లైబ్రరీలు కనిపించినప్పుడు మరియు ప్రోగ్రామర్లు ఉపయోగించడం ప్రారంభించినప్పుడు, అనుకూలత సమస్యలు తలెత్తాయి. విభిన్న ఇంటర్‌ఫేస్‌లతో డజను వేర్వేరు లైబ్రరీలలో చక్రాన్ని తిరిగి ఆవిష్కరించకుండా వ్యక్తులను ఆపడానికి, వియుక్త SLF4J ఫ్రేమ్‌వర్క్ ("జావా కోసం సర్వీస్ లాగింగ్ ముఖభాగం") సృష్టించబడింది. దీనిని అబ్‌స్ట్రాక్ట్ అంటారు, ఎందుకంటే మీరు SLF4J తరగతుల పద్ధతులను ఉపయోగించి మరియు కాల్ చేసినప్పటికీ, హుడ్ కింద అవి వాస్తవానికి ముందు వచ్చిన అన్ని లాగింగ్ ఫ్రేమ్‌వర్క్‌లను ఉపయోగిస్తాయి: log4j, ప్రామాణిక java.util.logging మరియు ఇతరాలు. ఏదో ఒక సమయంలో మీకు ఇతర లైబ్రరీలలో లేని Log4j యొక్క నిర్దిష్ట ఫీచర్ అవసరమైతే, కానీ మీరు మీ ప్రాజెక్ట్‌ను ఈ లైబ్రరీకి నేరుగా లింక్ చేయకూడదనుకుంటే, SLF4Jని ఉపయోగించండి. ఆపై అది 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!

మనం ఇక్కడ ఏమి చూస్తాము? మొదట, మనకు ఒక దోష సందేశం కనిపిస్తుంది. ఇప్పుడు మనకు అవసరమైన సెట్టింగ్‌లు లేకపోవడమే దీనికి కారణం. దీని ప్రకారం, మా లాగర్ ప్రస్తుతం దోష సందేశాలను (ERROR) మరియు కన్సోల్‌కు మాత్రమే అవుట్‌పుట్ చేయగలదు. logger.info () పద్ధతి పని చేయలేదు. కానీ logger.error() చేసింది! కన్సోల్‌లో, మేము ప్రస్తుత తేదీని, లోపం సంభవించిన పద్ధతిని చూస్తాము ( ప్రధాన), "ERROR" అనే పదం మరియు మా సందేశం! ERROR లాగింగ్ స్థాయి. సాధారణంగా, లాగ్ ఎంట్రీ "ERROR" అనే పదంతో గుర్తించబడితే, ప్రోగ్రామ్‌లో ఈ సమయంలో లోపం ఏర్పడింది. ఎంట్రీ "INFO" అనే పదంతో గుర్తించబడితే, అప్పుడు సందేశం కేవలం ప్రోగ్రామ్ యొక్క సాధారణ ఆపరేషన్ గురించి ప్రస్తుత సమాచారాన్ని సూచిస్తుంది. SLF4J లైబ్రరీ చాలా విభిన్న లాగింగ్ స్థాయిలను కలిగి ఉంది, అవి లాగింగ్‌ను సులభంగా కాన్ఫిగర్ చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. ఇవన్నీ నిర్వహించడం చాలా సులభం: అవసరమైన అన్ని లాజిక్‌లు ఇప్పటికే జావా లాగర్ క్లాస్‌లో ఉన్నాయి. మీరు సంబంధిత పద్ధతులను కాల్ చేయాలి. మీరు సాధారణ సందేశాన్ని లాగిన్ చేయాలనుకుంటే, 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">

ఇది StatusLogger అని పిలవబడేది. ఇది మా లాగర్‌తో సంబంధం లేనిది మరియు Log4j యొక్క అంతర్గత ప్రక్రియలలో ఉపయోగించబడుతుంది. మీరు status="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] %-5level %logger{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!");
       }
   }
}

అయితే, ఇది కొంచెం అసహ్యకరమైనది (రన్‌టైమ్ ఎక్సెప్షన్‌ను పట్టుకోవడం అనేది సందేహాస్పదమైన ఆలోచన), కానీ ఇది మా ప్రయోజనాల కోసం ఖచ్చితంగా సరిపోతుంది :) మన ప్రధాన() పద్ధతిని వరుసగా 4 సార్లు అమలు చేసి, మా testlog.txt ఫైల్‌ని చూద్దాం. మీరు దీన్ని ముందుగానే సృష్టించాల్సిన అవసరం లేదు: లైబ్రరీ దీన్ని స్వయంచాలకంగా చేస్తుంది. ప్రతిదీ పని చేసింది! :) ఇప్పుడు మీకు కాన్ఫిగర్ చేయబడిన లాగర్ ఉంది. మీరు ప్రతి పద్ధతికి లాగర్ కాల్‌లను జోడించడం ద్వారా మీ పాత ప్రోగ్రామ్‌లలో కొన్నింటితో ఆడుకోవచ్చు. అప్పుడు ఫలిత లాగ్‌ను చూడండి :) ఇది లోతుగా లాగింగ్ అనే అంశాన్ని పరిగణిస్తుంది. అన్నింటినీ ఒకే సిట్టింగ్‌లో చదవడం సవాలుగా ఉంటుంది. ఇది చాలా అదనపు ఉపయోగకరమైన సమాచారాన్ని కలిగి ఉందని పేర్కొంది. ఉదాహరణకు, లాగర్‌ను ఎలా కాన్ఫిగర్ చేయాలో మీరు నేర్చుకుంటారు, తద్వారా మా testlog.txt ఫైల్ నిర్దిష్ట పరిమాణానికి చేరుకున్నట్లయితే అది కొత్త టెక్స్ట్ ఫైల్‌ను సృష్టిస్తుంది :) మరియు అది మా తరగతిని ముగించింది! ఈ రోజు మీరు చాలా ముఖ్యమైన అంశంతో సుపరిచితులయ్యారు మరియు ఈ జ్ఞానం మీ భవిష్యత్ పనిలో ఖచ్చితంగా మీకు సహాయం చేస్తుంది. మరల సారి వరకు! :)