జావాలో లాగ్ హిస్టరీ

2.1 మొదటి లాగర్ - log4j

మీకు ఇప్పటికే తెలిసినట్లుగా, లాగ్‌ల చరిత్ర System.err.println()కన్సోల్‌కు రికార్డ్ అవుట్‌పుట్‌తో ప్రారంభమైంది. ఇది ఇప్పటికీ డీబగ్గింగ్ కోసం చురుకుగా ఉపయోగించబడుతుంది, ఉదాహరణకు, Intellij IDEA కన్సోల్‌కు దోష సందేశాలను ప్రదర్శించడానికి దీన్ని ఉపయోగిస్తుంది. కానీ ఈ ఎంపికకు ఎటువంటి సెట్టింగ్‌లు లేవు, కాబట్టి ముందుకు వెళ్దాం.

మొదటి మరియు అత్యంత జనాదరణ పొందిన లాగర్‌ని పిలుస్తారు Log4j. ఇది మంచి మరియు అత్యంత అనుకూలీకరించదగిన పరిష్కారం. వివిధ పరిస్థితుల కారణంగా, ఈ నిర్ణయం జెడికెలోకి ఎప్పుడూ రాలేదు, ఇది మొత్తం సమాజాన్ని చాలా కలవరపెట్టింది.

ఈ లాగర్ కేవలం లాగిన్ చేయలేకపోయింది, ఇది ప్రోగ్రామర్‌ల కోసం ప్రోగ్రామర్లచే సృష్టించబడింది మరియు లాగింగ్‌కు సంబంధించి నిరంతరం తలెత్తే సమస్యలను పరిష్కరించడానికి వారిని అనుమతించింది.

మీకు ఇప్పటికే తెలిసినట్లుగా, లాగ్‌లు చివరికి వ్రాయబడ్డాయి, తద్వారా కొంతమంది వాటిని చదివి, ప్రోగ్రామ్ యొక్క ఆపరేషన్ సమయంలో ఏమి జరిగిందో అర్థం చేసుకోవడానికి ప్రయత్నిస్తారు - ఏమి మరియు ఎప్పుడు ఊహించిన విధంగా తప్పు జరిగింది.

దీని కోసం మూడు విషయాలు ఉన్నాయి log4j:

• ఉపప్యాకేజీ లాగింగ్;
• అనుబంధాల సమితి (ఫలితాలు);
• హాట్ రీలోడ్ సెట్టింగ్‌లు.

ముందుగా, సెట్టింగులను log4jఒక ప్యాకేజీలో లాగింగ్ ఎనేబుల్ చేసి మరొక ప్యాకేజీలో డిసేబుల్ చేసే విధంగా వ్రాయవచ్చు. ఉదాహరణకు, లో లాగిన్ చేయడాన్ని ఎనేబుల్ చేయడం సాధ్యమైంది com.codegym.server, కానీ లో దాన్ని నిలిపివేయడం com.codegym.server.payment. ఇది లాగ్ నుండి అనవసరమైన సమాచారాన్ని త్వరగా తొలగించడం సాధ్యం చేసింది.

రెండవది, log4jఇది ఒకేసారి అనేక లాగ్ ఫైల్‌లకు లాగింగ్ ఫలితాలను వ్రాయడానికి అనుమతించింది. మరియు ప్రతిదానికి అవుట్‌పుట్ ఒక్కొక్కటిగా కాన్ఫిగర్ చేయబడవచ్చు. ఉదాహరణకు, ఒక ఫైల్‌లో తీవ్రమైన లోపాల గురించి సమాచారాన్ని మాత్రమే వ్రాయడం సాధ్యమైంది, మరొకటి - నిర్దిష్ట మాడ్యూల్ నుండి లాగ్‌లు మరియు మూడవది - నిర్దిష్ట సమయం కోసం లాగ్‌లు.

ప్రతి లాగ్ ఫైల్ ఒక నిర్దిష్ట రకం ఆశించిన సమస్యకు ట్యూన్ చేయబడింది. ఇది గిగాబైట్ లాగ్ ఫైల్‌లను మాన్యువల్‌గా చూడటం ఆనందించని ప్రోగ్రామర్‌ల జీవితాన్ని చాలా సులభతరం చేస్తుంది.

చివరగా, మూడవదిగా, log4jప్రోగ్రామ్ నడుస్తున్నప్పుడు దాన్ని పునఃప్రారంభించకుండా నేరుగా లాగ్ సెట్టింగులను మార్చడానికి ఇది అనుమతించింది. నిర్దిష్ట లోపంపై అదనపు సమాచారాన్ని కనుగొనడానికి లాగ్‌ల పనిని సరిచేయడానికి అవసరమైనప్పుడు ఇది చాలా సులభమైంది.

ముఖ్యమైనది! లాగ్ యొక్క రెండు వెర్షన్లు ఉన్నాయి log4j: 1.2.x మరియు 2.xx , అవి ఒకదానికొకటి అనుకూలంగా లేవు .

మీరు కోడ్‌ని ఉపయోగించి లాగర్‌ని ప్రాజెక్ట్‌కి కనెక్ట్ చేయవచ్చు:

<dependencies>
  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.17.2</version>
  </dependency>

  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.17.2</version>
  </dependency>
</dependencies>

2.2 మొదటి అధికారిక లాగర్ - JUL: java.util.logging

జావా కమ్యూనిటీలో లాగర్‌ల జూ కనిపించిన తర్వాత, డెవలపర్‌లు JDKఅందరూ ఉపయోగించే ఒక ప్రామాణిక లాగర్‌ను తయారు చేయాలని నిర్ణయించుకున్నారు. లాగర్ ఈ విధంగా కనిపించింది JUL: ప్యాకేజీ java.util.logging.

అయినప్పటికీ, దాని అభివృద్ధి సమయంలో, లాగర్ యొక్క సృష్టికర్తలు log4jదాని అభివృద్ధిని ప్రభావితం చేసిన IBM నుండి లాగర్ యొక్క రూపాంతరాన్ని కాకుండా ఒక ప్రాతిపదికగా తీసుకున్నారు. శుభవార్త ఏమిటంటే లాగర్ JULచేర్చబడింది JDK, చెడ్డ వార్త ఏమిటంటే కొంతమంది దీనిని ఉపయోగిస్తున్నారు.

డెవలపర్లు "మరొక యూనివర్సల్ స్టాండర్డ్" నుJUL తయారు చేయడమే కాకుండా , దాని కోసం వారి స్వంత లాగింగ్ స్థాయిలను కూడా చేసారు, ఇది ఆ సమయంలో ప్రసిద్ధ లాగర్లు ఆమోదించిన వాటికి భిన్నంగా ఉంది.

మరియు అది ఒక పెద్ద సమస్య. అన్నింటికంటే, ఉత్పత్తులు Javaతరచుగా పెద్ద సంఖ్యలో లైబ్రరీల నుండి సేకరించబడతాయి మరియు అలాంటి ప్రతి లైబ్రరీకి దాని స్వంత లాగర్ ఉంటుంది. కాబట్టి అప్లికేషన్‌లో ఉన్న అన్ని లాగర్‌లను కాన్ఫిగర్ చేయడం అవసరం.

లాగర్ చాలా బాగుంది అయినప్పటికీ. లాగర్‌ని సృష్టించడం ఎక్కువ లేదా తక్కువ. దీన్ని చేయడానికి, మీరు దిగుమతి చేసుకోవాలి:

java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggingJul.class.getName());

లాగింగ్ ఎక్కడ నుండి వస్తుందో తెలుసుకోవడానికి తరగతి పేరు ప్రత్యేకంగా పాస్ చేయబడింది.

విడుదలతో మాత్రమే, డెవలపర్లు ముఖ్యమైన సమస్యలను పరిష్కరించారు, దాని తర్వాత ఇది JULఉపయోగించడానికి నిజంగా సౌకర్యవంతంగా ఉంటుంది. దీనికి ముందు, ఇది ఒక రకమైన రెండవ-రేటు లాగర్.

ఈ లాగర్ లాంబ్డా వ్యక్తీకరణలు మరియు లేజీ మూల్యాంకనానికి కూడా మద్దతు ఇస్తుంది. ప్రారంభించి Java 8, మీరు పాస్ చేయవచ్చు Supplier<String>. ఇది నిజంగా అవసరమైన సమయంలో మాత్రమే స్ట్రింగ్‌ను చదవడానికి మరియు సృష్టించడానికి సహాయపడుతుంది మరియు ఇది మునుపటిలా ప్రతిసారీ కాదు.

వాదనతో కూడిన పద్ధతులు Supplier<String> msgSupplierఇలా కనిపిస్తాయి:

public void info(Supplier msgSupplier) {
   log(Level.INFO, msgSupplier);
}

2.3 మొదటి లాగర్ రేపర్ - JCL: జకార్తా కామన్స్ లాగింగ్

చాలా కాలంగా లాగర్‌లలో ఒకే ప్రమాణం లేదు, అది JULఒకటిగా మారాలి, కానీ అది అధ్వాన్నంగా ఉంది log4j, కాబట్టి ఒకే ప్రమాణం ఎప్పుడూ కనిపించలేదు. కానీ లాగర్‌ల మొత్తం జూ కనిపించింది, వాటిలో ప్రతి ఒక్కటి ఒకే విధంగా మారాలని కోరుకుంది.

అయినప్పటికీ, సాధారణ జావా డెవలపర్‌లు దాదాపు ప్రతి లైబ్రరీకి దాని స్వంత లాగర్‌ను కలిగి ఉండటాన్ని ఇష్టపడలేదు మరియు ఏదో ఒకవిధంగా ప్రత్యేక పద్ధతిలో కాన్ఫిగర్ చేయాలి. అందువల్ల, సంఘం ఇతర లాగర్‌లపై ప్రత్యేక రేపర్‌ను రూపొందించాలని నిర్ణయించుకుంది - ఈ విధంగాJCL: jakarta commons logging

ఇక మ ళ్లీ లీడ ర్ కావాల ని క్రియేట్ చేసిన ప్ర యోజ నం ఒక్క టి కూడా కాలేదు. మీరు విజేతను సృష్టించలేరు, మీరు విజేతగా మాత్రమే మారగలరు. ఫంక్షనాలిటీ JCLచాలా పేలవంగా ఉంది మరియు ఎవరూ దానిని ఉపయోగించాలనుకోలేదు. లాగర్, అన్ని లాగర్‌లను భర్తీ చేయడానికి రూపొందించబడింది, అది JULఉపయోగించబడనందున అదే విధిని ఎదుర్కొంది.

అపాచీ కమ్యూనిటీ విడుదల చేసిన అనేక లైబ్రరీలకు ఇది జోడించబడినప్పటికీ, లాగర్‌ల జూ మాత్రమే పెరిగింది.

2.4 మొదటి చివరి లాగర్ - లాగ్‌బ్యాక్

అయితే అంతే కాదు. డెవలపర్ log4jఅతను తెలివైనవాడని నిర్ణయించుకున్నాడు (అలాగే, చాలా మంది ప్రజలు అతని లాగర్‌ను ఉపయోగించారు) మరియు log4jఇతర లాగర్‌ల ప్రయోజనాలను మిళితం చేసే కొత్త మెరుగైన లాగర్‌ను వ్రాయాలని నిర్ణయించుకున్నారు.

కొత్త లాగర్‌ని పిలిచారు Logback. ఈ లాగర్ ప్రతి ఒక్కరూ ఉపయోగించే భవిష్యత్ సింగిల్ లాగర్‌గా మారాలి. ఇది లో ఉన్న అదే ఆలోచనపై ఆధారపడింది log4j.

మీరు కోడ్‌ని ఉపయోగించి ఈ లాగర్‌ని ప్రాజెక్ట్‌కి కనెక్ట్ చేయవచ్చు:

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.6</version>
</dependency>

తేడాలు ఉన్నాయి Logback:

• మెరుగైన పనితీరు;
• స్థానిక మద్దతు జోడించబడింది slf4j;
• విస్తరించిన వడపోత ఎంపిక.

ఈ లాగర్ యొక్క మరొక ప్రయోజనం ఏమిటంటే ఇది చాలా మంచి డిఫాల్ట్ సెట్టింగ్‌లను కలిగి ఉంది. మరియు మీరు లాగర్‌లో ఏదైనా మార్చాలనుకుంటే మాత్రమే దాన్ని కాన్ఫిగర్ చేయాలి. అలాగే, సెట్టింగ్‌ల ఫైల్ కార్పొరేట్ సాఫ్ట్‌వేర్‌కు మెరుగ్గా స్వీకరించబడింది - దాని అన్ని కాన్ఫిగరేషన్‌లు ఇలా సెట్ చేయబడ్డాయి xml/.

డిఫాల్ట్‌గా, Logbackదీనికి ఎలాంటి సెట్టింగ్‌లు అవసరం లేదు మరియు స్థాయి DEBUGమరియు అంతకంటే ఎక్కువ అన్ని లాగ్‌లను రికార్డ్ చేస్తుంది. మీకు భిన్నమైన ప్రవర్తన అవసరమైతే, దానిని కాన్ఫిగరేషన్ ద్వారా కాన్ఫిగర్ చేయవచ్చు xml:

<configuration>
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>app.log</file>
        <encoder>
            <pattern>%d{HH:mm:ss,SSS} %-5p [%c] - %m%n</pattern>
        </encoder>
    </appender>
    <logger name="org.hibernate.SQL" level="DEBUG" />
    <logger name="org.hibernate.type.descriptor.sql" level="TRACE" />
    <root level="info">
        <appender-ref ref="FILE" />
    </root>
</configuration>

2.5 తాజా యూనివర్సల్ లాగర్ - SLF4J: జావా కోసం సింపుల్ లాగింగ్ ముఖభాగం

గోల్డెన్ మీన్‌ని కనుగొనడానికి ఎంతకాలం ఉంటుంది...

2006లో, సృష్టికర్తలలో ఒకరు log4jప్రాజెక్ట్ నుండి నిష్క్రమించారు మరియు యూనివర్సల్ లాగర్‌ని సృష్టించడానికి మళ్లీ ప్రయత్నించాలని నిర్ణయించుకున్నారు. కానీ ఈసారి అది కొత్త లాగర్ కాదు, కొత్త సార్వత్రిక ప్రమాణం (ర్యాపర్) వివిధ లాగర్‌లు కలిసి సంభాషించడానికి అనుమతించింది.

ఈ లాగర్‌ని పిలిచారు slf4j — Simple Logging Facade for Java, ఇది చుట్టుముట్టే log4j, JUL, common-loggins and logback. ఈ లాగర్ నిజమైన సమస్యను పరిష్కరించింది - లాగర్‌ల జంతుప్రదర్శనశాలను నిర్వహించడం, కాబట్టి ప్రతి ఒక్కరూ వెంటనే దాన్ని ఉపయోగించడం ప్రారంభించారు.

మనకోసం మనం సృష్టించుకున్న సమస్యలను వీరోచితంగా పరిష్కరిస్తాం. మీరు చూడగలిగినట్లుగా, పురోగతి మేము రేపర్‌పై రేపర్‌ను సృష్టించే స్థాయికి చేరుకుంది ...

చుట్టు కూడా రెండు భాగాలను కలిగి ఉంటుంది:

• API, ఇది అప్లికేషన్లలో ఉపయోగించబడుతుంది;
• ప్రతి లాగర్‌కు ప్రత్యేక డిపెండెన్సీలుగా జోడించబడే అమలులు.

మీరు కోడ్‌ని ఉపయోగించి లాగర్‌ని ప్రాజెక్ట్‌కి కనెక్ట్ చేయవచ్చు:

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.17.2</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.17.2</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.17.2</version>
</dependency>

సరైన అమలును కనెక్ట్ చేయడానికి ఇది సరిపోతుంది మరియు అంతే: మొత్తం ప్రాజెక్ట్ దానితో పని చేస్తుంది.

2.6 slf4jలో ఆప్టిమైజేషన్

Slf4jలాగింగ్ కోసం స్ట్రింగ్ ఫార్మాటింగ్ వంటి అన్ని కొత్త ఫీచర్లకు మద్దతు ఇస్తుంది . ఇంతకు ముందు ఇలాంటి సమస్య ఉండేది. మీరు లాగ్‌కు సందేశాన్ని ప్రింట్ చేయాలనుకుంటున్నారని అనుకుందాం:

log.debug("User " + user + " connected from " + request.getRemoteAddr());

ఈ కోడ్‌తో సమస్య ఉంది. మీ అప్లికేషన్ పని చేస్తుందని అనుకుందాం productionమరియు లాగ్‌కు ఏదీ వ్రాయలేదు DEBUG-messages, అయినప్పటికీ, పద్ధతి log.debug()ఇప్పటికీ పిలువబడుతుంది మరియు దానిని పిలిచినప్పుడు, క్రింది పద్ధతులు కూడా పిలువబడతాయి:

• user.toString();
• request.getRemoteAddr();

ఈ పద్ధతులను కాల్ చేయడం అప్లికేషన్‌ను నెమ్మదిస్తుంది. డీబగ్గింగ్ సమయంలో మాత్రమే వారి కాల్ అవసరం, కానీ వారు ఏమైనప్పటికీ పిలుస్తారు.

లాజిక్ కోణం నుండి, ఈ సమస్యను లాగింగ్ లైబ్రరీలోనే పరిష్కరించాలి. మరియు log4j యొక్క మొదటి సంస్కరణలో పరిష్కారం వచ్చింది:

if (log.isDebugEnabled()) {
    log.debug("User " + user + " connected from " + request.getRemoteAddr());
}

లాగ్ కోసం ఒక లైన్ బదులుగా, ఇప్పుడు అది మూడు వ్రాయవలసి వచ్చింది. ఇది కోడ్ యొక్క రీడబిలిటీని నాటకీయంగా దిగజార్చింది మరియు ప్రజాదరణను తగ్గించింది log4j.

లాగర్ slf4jస్మార్ట్ లాగింగ్‌ను అందించడం ద్వారా పరిస్థితిని కొద్దిగా మెరుగుపరచగలిగారు. ఇది ఇలా కనిపించింది:

log.debug("User {} connected from {}", user, request.getRemoteAddr());

ఇక్కడ {}పద్ధతిలో ఆమోదించబడిన వాదనల చొప్పించడాన్ని సూచిస్తుంది. అంటే, మొదటిది {}వినియోగదారుకు అనుగుణంగా ఉంటుంది, {}రెండవది request.getRemoteAddr().

లాగింగ్ స్థాయి లాగింగ్‌ని అనుమతించినట్లయితే మాత్రమే ఈ పారామితులు ఒకే సందేశంలోకి సంగ్రహించబడతాయి. ఖచ్చితమైనది కాదు, కానీ అన్ని ఇతర ఎంపికల కంటే మెరుగైనది.

ఆ తరువాత, SLF4Jఇది జనాదరణలో వేగంగా పెరగడం ప్రారంభించింది, ప్రస్తుతానికి ఇది ఉత్తమ పరిష్కారం.

కాబట్టి, మేము బండిల్ ఉదాహరణను ఉపయోగించి లాగింగ్‌ను పరిశీలిస్తాము slf4j-log4j12.