జావాలో లాగర్ అంటే ఏమిటి మరియు మీరు దాన్ని ఎందుకు ఉపయోగిస్తున్నారు?

జావాలోని లాగర్ పై ఈ వ్యాసం ప్రాజెక్టులను సృష్టించేటప్పుడు పరిష్కారాలను లాగింగ్ చేయడానికి ఉపయోగించే జావా లాగింగ్ API పై సమగ్ర గైడ్.

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



ఈ వ్యాసంలో ఈ క్రింది విషయాలు కవర్ చేయబడతాయి:



    1. లాగింగ్ అవసరం
    2. భాగాలు లాగింగ్
    3. లాగర్ అంటే ఏమిటి?
    4. అపెండర్ లేదా హ్యాండ్లర్లు
    5. లేఅవుట్ లేదా ఫార్మాటర్లు

ముందు, మేము జావాలో లాగింగ్ చేయడానికి లోతుగా మునిగిపోతాము, లాగింగ్ యొక్క అవసరాన్ని అర్థం చేసుకుందాం.

లాగింగ్ అవసరం

అనువర్తనాలను రూపొందించేటప్పుడు, డీబగ్ చేయాల్సిన లోపాలను మేము తరచుగా ఎదుర్కొంటాము. కాబట్టి, లాగ్‌ల సహాయంతో, లోపాలు మరియు అసాధారణ పరిస్థితుల రికార్డుతో అనువర్తనంలో ఏమి జరుగుతుందో దాని గురించి మేము సులభంగా సమాచారాన్ని పొందవచ్చు. ఇప్పుడు, ఇది మీ మనస్సును తాకవచ్చు, అందులో System.out.print () స్టేట్‌మెంట్‌ను ఎందుకు ఉపయోగించకూడదు . సరే, ఈ స్టేట్‌మెంట్‌లతో సమస్య ఏమిటంటే లాగ్ సందేశాలు కన్సోల్‌లో మాత్రమే ముద్రించబడతాయి. కాబట్టి, మీరు కన్సోల్‌ను మూసివేసిన తర్వాత, స్వయంచాలకంగా, అన్ని లాగ్‌లు పోతాయి. అందువల్ల, లాగ్‌లు శాశ్వతంగా నిల్వ చేయబడవు మరియు అవి ఒక్కొక్కటిగా ప్రదర్శించబడతాయి, ఎందుకంటే ఇది ఒకే-థ్రెడ్ వాతావరణం.



c ++ లో సూచన ద్వారా కాల్ చేయండి

అటువంటి సమస్యలను నివారించడానికి, జావాలో లాగింగ్ సహాయంతో సరళీకృతం చేయబడిందిAPI ద్వారా అందించబడిందిjava.util.loggingప్యాకేజీ, మరియుorg.apache.log4j. *ప్యాకేజీ.

భాగాలు లాగింగ్

జావా లాగింగ్ భాగాలు డెవలపర్‌కు లాగ్‌లను సృష్టించడానికి, లాగ్‌లను సంబంధిత గమ్యస్థానానికి పంపించడానికి మరియు సరైన ఆకృతిని నిర్వహించడానికి సహాయపడతాయి. ఈ క్రింది మూడు భాగాలు:

  • లాగర్స్ - లాగ్ రికార్డులను సంగ్రహించి, సంబంధిత అపెండర్‌కు పంపించే బాధ్యత.
  • అనుబంధాలు లేదా హ్యాండ్లర్లు - గమ్యస్థానానికి లాగ్ ఈవెంట్‌లను రికార్డ్ చేయడానికి వారు బాధ్యత వహిస్తారు. అవుట్‌పుట్‌లను పంపే ముందు అనుబంధాలను లేఅవుట్ల సహాయంతో ఈవెంట్‌లను ఫార్మాట్ చేస్తుంది.
  • లేఅవుట్లు లేదా ఫార్మాటర్లు - లాగ్ ఎంట్రీలో డేటా కనిపించినప్పుడు అది ఎలా ఉంటుందో నిర్ణయించే బాధ్యత.

మూడు భాగాల పని కోసం మీరు ఈ క్రింది చిత్రాన్ని చూడవచ్చు:



లాగింగ్ భాగాలు - జావాలో లాగర్ - ఎడురేకా

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

ఇప్పుడు, జావాలో లోతుగా ఉన్న లాగర్ ఏమిటో అర్థం చేసుకుందాం.

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

జావాలోని లాగర్‌లు లాగ్ ఈవెంట్‌లను ప్రేరేపించే వస్తువులు, అవి సృష్టించబడతాయి మరియు అవి అప్లికేషన్ యొక్క కోడ్‌లో పిలువబడతాయి, ఇక్కడ అవి లాగ్ ఈవెంట్‌లను ఒక అపెండర్ అయిన తదుపరి భాగానికి పంపే ముందు ఉత్పత్తి చేస్తాయి. వివిధ సంఘటనలకు ప్రతిస్పందించడానికి లేదా సోపానక్రమంలో లాగర్‌లను ఉపయోగించడానికి మీరు ఒకే తరగతిలో బహుళ లాగర్‌లను ఉపయోగించవచ్చు. క్రమానుగత డాట్-వేరుచేసిన నేమ్‌స్పేస్‌ను ఉపయోగించి వీటిని సాధారణంగా పిలుస్తారు. అలాగే, అన్ని లాగర్ పేర్లు తరగతి లేదా లాగిన్ అయిన భాగం యొక్క ప్యాకేజీ పేరు మీద ఆధారపడి ఉండాలి.

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

క్రొత్త లాగర్ సృష్టించండి

జావాలో క్రొత్త లాగర్ను సృష్టించే విధానం చాలా సులభం. మీరు ఉపయోగించాలిLogger.getLogger ()పద్ధతి. దిgetLogger () లాగర్ పేరును గుర్తిస్తుంది మరియు స్ట్రింగ్‌ను పరామితిగా తీసుకుంటుంది. కాబట్టి, లాగర్ ముందే ఉనికిలో ఉంటే, ఆ లాగర్ తిరిగి ఇవ్వబడుతుంది, లేకపోతే కొత్త లాగర్ సృష్టించబడుతుంది.

సింటాక్స్:

స్టాటిక్ లాగర్ లాగర్ = లాగర్.జెట్ లాగర్ (SampleClass.class.getName ())

ఇక్కడ, శాంపిల్ క్లాస్ అంటే లాగర్ ఆబ్జెక్ట్ మనకు లభించే తరగతి పేరు.

ఉదాహరణ:

పబ్లిక్ క్లాస్ కస్టమర్ {ప్రైవేట్ స్టాటిక్ ఫైనల్ లాగర్ LOGGER = Logger.getLogger (Customer.class) పబ్లిక్ శూన్యత getCustomerDetails () {}}

జావాలో లాగర్ను ఎలా సృష్టించాలో ఇప్పుడు నేను మీకు చెప్పాను, లాగింగ్లో అందుబాటులో ఉన్న వివిధ స్థాయిలను చూద్దాం.

లాగ్ స్థాయిలు

లాగ్‌లను వాటి తీవ్రత లేదా అప్లికేషన్ యొక్క స్థిరత్వంపై ప్రభావం ద్వారా వర్గీకరించడానికి లాగ్ స్థాయిలు ఉపయోగించబడతాయి. దిorg.apache.log4j. *ప్యాకేజీ మరియుjava.util.loggingరెండూ వివిధ స్థాయిల లాగింగ్‌ను అందిస్తాయి. వాటిలో ప్రతి ఒక్కటి ఒక్కొక్కటిగా పరిశీలిద్దాం.

org.apache.log4j. *ప్యాకేజీ అవరోహణ క్రమంలో క్రింది స్థాయిలను అందిస్తుంది:

  • FATAL
  • లోపం
  • హెచ్చరిక
  • INFO
  • డీబగ్

java.util.loggingప్యాకేజీ అవరోహణ క్రమంలో క్రింది స్థాయిలను అందిస్తుంది:

  • SEVERE (అత్యధిక స్థాయి)
  • హెచ్చరిక
  • INFO
  • కాన్ఫిగ్ చేయండి
  • ఫైన్
  • ఫైనర్
  • ఫైనెస్ట్ (తక్కువ స్థాయి)

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

ఉపయోగించి జావాలో లాగిన్ అవ్వడానికి ఉదాహరణorg.apache.log4j. *ప్యాకేజీ:

org.apache.log4j.Logger పబ్లిక్ క్లాస్ కస్టమర్ {స్టాటిక్ లాగర్ లాగర్ = లాగర్.జెట్ లాగర్ (కస్టమర్ క్లాస్) పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {logger.error ('ERROR') logger.warn ('హెచ్చరిక' ) logger.fatal ('FATAL') logger.debug ('డీబగ్') logger.info ('INFO') System.out.println ('తుది అవుట్‌పుట్')}}

కాబట్టి మీ అవుట్పుట్ ఉంటేమా లో రూట్ లాగర్ WARN- స్థాయి log4j.properties ఫైల్, అప్పుడు WARN కన్నా ఎక్కువ ప్రాధాన్యత కలిగిన అన్ని దోష సందేశాలు క్రింద ముద్రించబడతాయి:

నుండి సెట్ లెవెల్ () పద్ధతిని ఉపయోగించడం ద్వారా మీరు స్థాయిని కూడా సెట్ చేయవచ్చుjava.util.loggingప్యాకేజీ క్రింది విధంగా:

logger.setLevel (Level.WARNING)

ఉపయోగించి జావాలో లాగిన్ అవ్వడానికి ఉదాహరణjava.util.loggingప్యాకేజీ:

ప్యాకేజీ ఎడ్యురేకా దిగుమతి java.io.IOException దిగుమతి java.util.logging.Level దిగుమతి java.util.logging.Logger దిగుమతి java.util.logging. * తరగతి EdurekaLogger {ప్రైవేట్ ఫైనల్ స్టాటిక్ లాగర్ LOGGER = Logger.getLogger (Logger.GLOBAL_LOGGER_NAME) void sampleLog () {LOGGER.log (Level.WARNING, 'Edureka కు స్వాగతం!')}} పబ్లిక్ క్లాస్ కస్టమర్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] args) {EdurekaLogger obj = new EdurekaLogger () obj.sampleLog () LogManager slg = LogManager.getLogManager () లాగర్ లాగ్ = slg.getLogger (Logger.GLOBAL_LOGGER_NAME) log.log (Level.WARNING, 'హాయ్! ఎడురేకా నుండి స్వాగతం')}}

ఉపయోగించి మీ అప్లికేషన్‌లో లాగింగ్‌ను ప్రారంభించడానికిorg.apache.log4j. *ప్యాకేజీ లేదాjava.util.loggingప్యాకేజీ, మీరు లక్షణాల ఫైల్‌ను కాన్ఫిగర్ చేయాలి. జావాలోని లాగర్ పై ఈ వ్యాసంలో, ఈ రెండింటి యొక్క ప్రాపర్టీస్ ఫైల్ గురించి చర్చిద్దాం.

లాగ్ 4 జె మరియు జావా యుటిల్ ప్యాకేజీ యొక్క గుణాలు ఫైల్

నమూనా Log4j గుణాలు ఫైల్:

# రూట్ లాగర్ ఎంపికను ప్రారంభించండి log4j.rootLogger = INFO, file, stdout # ఫైల్ log4j.appender.file = org.apache.log4j.RollingFileAppender log4j.appender.file.File = E: loglogging.log log4j.appender. file.MaxFileSize = 10MB log4j.appender.file.MaxBackupIndex = 5 log4j.appender.file.layout = org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern =% d {yyyy-mm-dd HH : ss}% -5p% c {1}:% L -% m% n # కన్సోల్‌లో ముద్రించడానికి అపెండర్లను అటాచ్ చేయండి log4j.appender.stdout = org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target = System.out log4j.appender.stdout.layout = org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern =% d {yyyy-MM-dd HH: mm: ss}% -5p% c {1}:% L -% m% n
  • Log4j ప్రాపర్టీస్ ఫైల్ ప్రాజెక్ట్ యొక్క src ఫోల్డర్ లోపల సృష్టించబడుతుంది.
  • log4j.appender.file = org.apache.log4j.RollingFileAppender -> అన్ని లాగ్‌లను ఫైల్‌లో ప్రింట్ చేస్తుంది
  • log4j.appender.stdout = org.apache.log4j.ConsoleAppender -> కన్సోల్‌లోని అన్ని లాగ్‌లను ప్రింట్ చేస్తుంది
  • log4j.appender.file.File = D: loglogging.log -> లాగ్ ఫైల్ స్థానాన్ని పేర్కొంటుంది
  • log4j.appender.file.MaxFileSize = 10MB -> లాగ్ ఫైల్ యొక్క గరిష్ట పరిమాణం 10MB కి
  • log4j.appender.file.MaxBackupIndex = 5 -> బ్యాకప్ ఫైళ్ల సంఖ్యను 5 కి పరిమితం చేస్తుంది
  • log4j.appender.file.layout = org.apache.log4j.PatternLayout -> లాగ్ ఫైల్‌కు లాగ్‌లు ముద్రించే నమూనాను పేర్కొంటుంది.
  • log4j.appender.file.layout.ConversionPattern =% d {yyyy-MM-dd HH: mm: ss}% -5p% c {1}:% L -% m% n -> డిఫాల్ట్ మార్పిడి నమూనాను సెట్ చేస్తుంది.

నమూనా జావా యుటిల్ ప్యాకేజీ గుణాలు ఫైల్

హ్యాండ్లర్లు = java.util.logging.ConsoleHandler .level = హెచ్చరిక # అవుట్పుట్ డిఫాల్ట్ డైరెక్టరీ java.util.logging.FileHandler.pattern =% h / java% u.log java.util.logging.FileHandler.limit = 60000 java.util.logging.FileHandler.count = 1 java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter # లాగ్‌ల స్థాయి హెచ్చరిక మరియు అంతకంటే ఎక్కువ పరిమితం చేయబడుతుంది. java.util.logging.ConsoleHandler.level = హెచ్చరిక java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

ఇక్కడ,

  • java.util.logging.FileHandler.pattern =% h / java% u.log -> లాగ్ ఫైళ్లు దీనికి వ్రాయబడతాయిసి: TEMPjava1.log
  • java.util.logging.FileHandler.limit = 50000 ->లాగర్ ఏదైనా ఒక ఫైల్‌కు బైట్లలో వ్రాసే గరిష్ట మొత్తం.
  • java.util.logging.FileHandler.count = 1 -> అవుట్పుట్ ఫైళ్ళ సంఖ్యను పేర్కొంటుంది
  • java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter -> ఆకృతీకరణకు ఉపయోగించే ఫార్మాటర్ గురించి ప్రస్తావించారు. ఇక్కడ XML ఫార్మాటర్ ఉపయోగించబడుతుంది.
  • java.util.logging.ConsoleHandler.level = హెచ్చరిక -> డిఫాల్ట్ లాగ్ స్థాయిని హెచ్చరికకు సెట్ చేస్తుంది
  • java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter ->పేర్కొంటుందిఫార్మాటర్అందరూ ఉపయోగించుకోవాలికన్సోల్హ్యాండ్లర్‘లు. ఇక్కడ, సింపుల్ ఫార్మాటర్ ఉపయోగించబడుతుంది.

లాగింగ్ ఈవెంట్‌లు

ఈవెంట్లను లాగిన్ చేయడానికి , మీరు ఈవెంట్‌లను సులభంగా ఫైల్ చేయడానికి ఒక స్థాయిని కేటాయించారని నిర్ధారించుకోవాలి. ఒక స్థాయిని కేటాయించడానికి మరియు సందేశాన్ని పేర్కొనడానికి మీరు ఈ క్రింది పద్ధతులను ఉపయోగించవచ్చు:

విధానం 1:

logger.log (Level.INFO, “డిస్ప్లే సందేశం”)
ఇక్కడ, స్థాయి INFO మరియు ముద్రించాల్సిన సందేశం 'డిస్ప్లే మెసేజ్'.

విధానం 2:

logger.info (“సందేశాన్ని ప్రదర్శించు”)

జావాలో లాగర్, INFO స్థాయిలో లేదా అంతకంటే ఎక్కువ ఉన్న సంఘటనలను మాత్రమే లాగ్ చేస్తుందని నిర్ధారించుకోవడానికి, మీరు వీటిని ఉపయోగించవచ్చు setLevel () పైన చర్చించిన పద్ధతి.

ఇప్పుడు, జావాలో లాగర్ను ఎలా ఉపయోగించాలో నేను చర్చించాను, లాగ్ 4 జె ఆర్కిటెక్చర్ యొక్క తదుపరి భాగాన్ని చర్చిద్దాం, అనగా అపెండర్లు.

అపెండర్ లేదా హ్యాండ్లర్లు

లాగ్ ఈవెంట్‌లను గమ్యస్థానానికి రికార్డ్ చేయడానికి అపెండర్ లేదా హ్యాండ్లర్లు బాధ్యత వహిస్తారు. ప్రతి లాగర్ బహుళ హ్యాండ్లర్లకు ప్రాప్యతను కలిగి ఉంటుంది మరియు లాగర్ నుండి లాగ్ సందేశాన్ని అందుకుంటుంది. అప్పుడు, అపెండర్‌లు ఈవెంట్‌లను ఫార్మాట్ చేయడానికి మరియు సంబంధిత గమ్యస్థానానికి పంపడానికి ఫార్మాటర్లు లేదా లేఅవుట్‌లను ఉపయోగిస్తారు.

సెట్‌లెవెల్ (లెవెల్.ఓఎఫ్ఎఫ్) పద్ధతిని ఉపయోగించి అపెండర్‌ను ఆపివేయవచ్చు. లో రెండు అత్యంత ప్రామాణిక హ్యాండ్లర్లుjava.util.loggingప్యాకేజీ క్రింది విధంగా ఉన్నాయి:

  • ఫైల్హ్యాండ్లర్: ఫైల్‌కు లాగ్ సందేశాన్ని రాయండి
  • కన్సోల్హ్యాండ్లర్: లాగ్ సందేశాన్ని కన్సోల్‌కు వ్రాస్తుంది

మీ మంచి అవగాహన కోసం, ప్రాపర్టీస్ విభాగంలో కొంతమంది అపెండర్లను వివరించాను.

లేఅవుట్ లేదా ఫార్మాటర్లు

లాగ్ ఈవెంట్‌లో డేటాను ఫార్మాట్ చేయడానికి మరియు మార్చడానికి ఫార్మాటర్‌ల లేఅవుట్ ఉపయోగించబడుతుంది.లాగింగ్ ఫ్రేమ్‌వర్క్‌లు HTML, XML, సిస్‌లాగ్, JSON, సాదా వచనం మరియు ఇతర లాగ్‌ల కోసం లేఅవుట్‌లను అందిస్తాయి.

  1. సింపుల్ ఫార్మాటర్ : ప్రాథమిక సమాచారంతో వచన సందేశాలను ఉత్పత్తి చేస్తుంది.
  2. XML ఫార్మాటర్ : లాగ్ కోసం XML సందేశాన్ని ఉత్పత్తి చేస్తుంది

మీ మంచి అవగాహన కోసం, నేను ప్రాపర్టీస్ విభాగంలో కొన్ని లేఅవుట్‌లను వివరించాను.దీనితో, “లాగర్ ఇన్ జావా” లో ఈ బ్లాగ్ చివరకి వచ్చాము. ఈ వ్యాసంలో మీకు నేర్పించిన విషయాలతో మీరు స్పష్టంగా ఉన్నారని నేను ఆశిస్తున్నాను.

చూడండి ప్రపంచవ్యాప్తంగా 250,000 కంటే ఎక్కువ సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “లాగర్ ఇన్ జావా” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.