జావాలో లాగ్‌లు ఎందుకు అవసరం

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().