பதிவு: என்ன, எப்படி, எங்கே, எதனுடன்?

CodeGym சமூகத்தில் உள்ள அனைவருக்கும் வணக்கம்! இன்று பதிவு செய்வது பற்றி பேசலாம்:

1. அது என்ன, அது ஏன் இருக்கிறது, எப்போது பயன்படுத்த வேண்டும், எப்போது தவிர்க்க வேண்டும்.
2. ஜாவாவில் என்ன பதிவு செயலாக்கங்கள் உள்ளன, மேலும் இந்த அனைத்து பதிவு விருப்பங்களையும் நீங்கள் என்ன செய்ய வேண்டும்.
மற்றும் பதிவு நிலைகள். அப்பெண்டர் என்றால் என்ன, அதை எவ்வாறு சரியாக அமைப்பது என்பது பற்றி விவாதிப்போம்.
3. உள்நுழைவு முனைகள் மற்றும் அவற்றை எவ்வாறு சரியாக கட்டமைப்பது, இதனால் எல்லாம் நாம் விரும்பும் வழியில் செயல்படும்.

இந்த பொருள் பரந்த பார்வையாளர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. ஜாவாவைப் பற்றி தெரிந்துகொள்ளும் அனைவருக்கும் இது தெளிவாக இருக்கும், அதே போல் ஏற்கனவே வேலை செய்து கொண்டிருப்பவர்களுக்கும், ஆனால் நாம் logger.info("log something"); போகலாம்!

உங்களுக்கு ஏன் பதிவு தேவை?

பதிவுசெய்தல் சிக்கலைத் தீர்க்கும் சில உண்மையான நிகழ்வுகளைப் பார்ப்போம். எனது வேலையிலிருந்து ஒரு எடுத்துக்காட்டு இங்கே. ஒரு பயன்பாடு மற்ற சேவைகளுடன் ஒருங்கிணைக்கும் புள்ளிகள் உள்ளன. ஒரு வகையான "அலிபி" ஐ நிறுவ இந்த புள்ளிகளில் நான் உள்நுழைவதைப் பயன்படுத்துகிறேன் : ஒருங்கிணைப்பு வேலை செய்யவில்லை என்றால், எந்தப் பக்கத்தில் சிக்கல் உள்ளது என்பதைக் கண்டுபிடிப்பது எளிது. தரவுத்தளத்தில் சேமிக்கப்பட்டுள்ள முக்கியமான தகவல்களைப் பதிவு செய்வதும் விரும்பத்தக்கது. எடுத்துக்காட்டாக, நிர்வாகி பயனரை உருவாக்குதல். இது துல்லியமாக பதிவு செய்வது நல்லது.

ஜாவாவில் உள்நுழைவதற்கான கருவிகள்

ஜாவாவில் நன்கு அறியப்பட்ட பதிவு தீர்வுகளில், பின்வருவனவற்றை நாம் முன்னிலைப்படுத்தலாம்:

• பதிவு4j
• JUL — java.util.logging
• ஜேசிஎல் - ஜகார்த்தா காமன்ஸ் லாக்கிங்
• லாக்பேக்
• SLF4J — ஜாவாவுக்கான எளிய பதிவு முகப்பு

System.err.println

தொடக்கத்தில், System.err.println (கன்சோலில் பதிவு உள்ளீடுகளைக் காட்டுகிறது) இருந்தது. இன்றும் கூட, பிழைத்திருத்தத்தின் போது விரைவாக பதிவு செய்ய இந்த நுட்பம் பயன்படுத்தப்படுகிறது. நிச்சயமாக, இங்கே விவாதிக்க எந்த அமைப்புகளும் இல்லை, எனவே இந்த முறையை நினைவில் வைத்துக் கொள்ளுங்கள், நாங்கள் தொடர்வோம்.

பதிவு4j

டெவலப்பர்கள் தேவைக்காக உருவாக்கிய முழுமையான தீர்வு இது. இதன் விளைவாக நீங்கள் பயன்படுத்தக்கூடிய மிகவும் சுவாரஸ்யமான கருவியாகும். பல்வேறு சூழ்நிலைகள் காரணமாக, இந்த தீர்வு ஜே.டி.கே-யில் முடிவடையவில்லை, இது ஒட்டுமொத்த சமூகத்தையும் பெரிதும் வருத்தப்படுத்தியது. Log4j இல் உள்ளமைவு விருப்பங்கள் உள்ளன, அவை தொகுப்பில் உள்நுழைவதை இயக்கவும் com.example.typeமற்றும் துணை தொகுப்பில் அதை அணைக்கவும் அனுமதிக்கும் com.example.type.generic. இது உள்நுழையத் தேவையில்லாத குறியீட்டை விரைவாக விலக்குவதை சாத்தியமாக்குகிறது. Log4j இன் இரண்டு பதிப்புகள் உள்ளன என்பதை இங்கே கவனிக்க வேண்டியது அவசியம் : 1.2.x மற்றும் 2.xx, மேலும் அவை ஒன்றுக்கொன்று இணக்கமற்றவை . Log4j appender கருத்துகளைச் சேர்த்தது(பதிவுகளை எழுதப் பயன்படும் கருவி) மற்றும் தளவமைப்பு (பதிவு வடிவமைத்தல்). இது உங்களுக்குத் தேவையானதை மட்டும் பதிவு செய்து, உங்களுக்குத் தேவையானதைப் பதிவுசெய்ய உதவுகிறது. அப்பெண்டர் பற்றி சிறிது நேரம் கழித்து பேசுவோம்.

JUL — java.util.logging

இந்த தீர்வின் முக்கிய நன்மைகளில் ஒன்று JUL ஆனது JDK (Java Development Kit) இல் சேர்க்கப்பட்டுள்ளது. துரதிருஷ்டவசமாக, இது உருவாக்கப்பட்ட போது, ​​அதன் படைப்பாளிகள் பிரபலமான Log4j பயன்பாட்டை அடிப்படையாகக் கொள்ளவில்லை, மாறாக IBM இலிருந்து ஒரு தீர்வாக இருந்தது. அந்த முடிவு விளைவுகளை ஏற்படுத்தியது. இப்போது யாரும் JUL ஐப் பயன்படுத்துவதில்லை என்பதே உண்மை. JUL இல் உள்ள பதிவு நிலைகள் Logback, Log4j மற்றும் Slf4j ஆகியவற்றிலிருந்து வேறுபடுகின்றன. இது ஒருவரையொருவர் புரிந்துகொள்வதை கடினமாக்குகிறது. ஒரு லாகரை உருவாக்குவது அதிகமாகவோ அல்லது குறைவாகவோ ஒத்ததாகும். இதைச் செய்ய, நீங்கள் இறக்குமதி செய்ய வேண்டும்:

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

வகுப்பின் பெயர் கடந்துவிட்டதால், எங்கள் பதிவு எங்கிருந்து வரும் என்பது எங்களுக்குத் தெரியும். ஜாவா 8 இல் தொடங்கி, நீங்கள் கடந்து செல்லலாம் Supplier<String>. இது, முன்பு இருந்ததைப் போல, ஒவ்வொரு முறையும் இல்லாமல், நமக்கு உண்மையிலேயே தேவைப்படும்போது மட்டுமே ஒரு வரியைப் படித்து உருவாக்க உதவுகிறது. ஜாவா 8 இன் வெளியீட்டில் மட்டுமே டெவலப்பர்கள் முக்கியமான சிக்கல்களைத் தீர்த்து, JUL ஐ உண்மையிலேயே பயன்படுத்தக்கூடியதாக மாற்றினர். Supplier<String> msgSupplierஅதாவது, கீழே காட்டப்பட்டுள்ளபடி, அளவுருவுடன் கூடிய முறைகள் :

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

ஜேசிஎல் - ஜகார்த்தா காமன்ஸ் லாக்கிங்

நீண்ட காலமாக லாக்கிங் தொடர்பான தொழில் தரநிலை இல்லாததாலும், பலர் தங்கள் சொந்த தனிப்பயன் லாகர்களை உருவாக்கியதாலும், மற்றவர்களுக்கு மேல் பயன்படுத்தக்கூடிய பொதுவான ரேப்பரான JCL ஐ வெளியிட முடிவு செய்யப்பட்டது. ஏன்? சில நேரங்களில் திட்டத்தில் சேர்க்கப்பட்ட சார்புநிலைகள் திட்டத்தில் உள்ளதை விட வேறுபட்ட லாகரைப் பயன்படுத்துகின்றன. இதன் காரணமாக, அவை ட்ரான்சிட்டிவ் சார்புகளாக திட்டத்தில் சேர்க்கப்பட்டன, மேலும் இவை அனைத்தையும் ஒன்றாக இணைக்க முயற்சிக்கும்போது இது உண்மையான சிக்கல்களை உருவாக்கியது. துரதிர்ஷ்டவசமாக, ரேப்பர் மிகவும் செயல்பாட்டுடன் இல்லை மற்றும் எதையும் சேர்க்கவில்லை. எல்லோரும் JCL ஐப் பயன்படுத்தினால் அது வசதியாக இருக்கும். ஆனால் அது நடக்கவில்லை, எனவே JCL ஐப் பயன்படுத்துவது தற்போது சிறந்த யோசனையல்ல.

லாக்பேக்

திறந்த மூல பாதை முட்கள் நிறைந்தது... Log4j ஐ எழுதிய அதே டெவலப்பர், லாக்பேக்கை வாரிசு பதிவு கட்டமைப்பாக எழுதினார். இது Log4j போன்ற அதே கருத்தை அடிப்படையாகக் கொண்டது. லாக்பேக்கில் உள்ள வேறுபாடுகள்:

• மேம்பட்ட செயல்திறன்
• Slf4jக்கான சொந்த ஆதரவைச் சேர்த்தது
• விரிவாக்கப்பட்ட வடிகட்டுதல் விருப்பங்கள்

இயல்பாக, லாக்பேக்கிற்கு எந்த உள்ளமைவும் தேவையில்லை, மேலும் அனைத்து நிகழ்வுகளையும் 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>

SLF4J — ஜாவாவுக்கான எளிய பதிவு முகப்பு

2006 ஆம் ஆண்டில், Log4j இன் நிறுவனத் தந்தைகளில் ஒருவர் திட்டத்திலிருந்து விலகி, Slf4j (ஜாவாவுக்கான எளிய பதிவு முகப்பு), Log4j, JUL, காமன்-லாக்கிங் மற்றும் லாக்பேக் ஆகியவற்றிற்கான ரேப்பர் ஒன்றை உருவாக்கினார். நீங்கள் பார்க்கிறபடி, ஒரு ரேப்பரின் மேல் ஒரு ரேப்பரை உருவாக்கும் நிலைக்கு நாங்கள் முன்னேறிவிட்டோம்... இந்த விஷயத்தில், இது இரண்டு பகுதிகளாகப் பிரிக்கப்பட்டுள்ளது: பயன்பாட்டில் பயன்படுத்தப்படும் API மற்றும் தனித்தனியுடன் சேர்க்கப்படும் செயலாக்கம் ஒவ்வொரு வகை பதிவுக்கான சார்புகள். உதாரணமாக, slf4j-log4j12.jarமற்றும் slf4j-jdk14.jar. நீங்கள் சரியான செயலாக்கத்தை இணைக்க வேண்டும், அவ்வளவுதான்: உங்கள் முழு திட்டமும் அதைப் பயன்படுத்தும். Slf4j ஆனது பதிவு செய்வதற்கான சரங்களை வடிவமைப்பது போன்ற அனைத்து சமீபத்திய அம்சங்களையும் ஆதரிக்கிறது. முன்னதாக, இதுபோன்ற சிக்கல் இருந்தது. இது போன்ற ஒரு பதிவு உள்ளீட்டை உருவாக்குகிறோம் என்று வைத்துக் கொள்வோம்:

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

ஒருங்கிணைப்பு ஆபரேட்டர் காரணமாக, userபொருள் அமைதியாக ஒரு சரமாக மாறுகிறது user.toString(). இது நேரத்தை எடுக்கும் மற்றும் கணினியை மெதுவாக்குகிறது. நாங்கள் பயன்பாட்டை பிழைத்திருத்தம் செய்தால் அது சரியாக இருக்கலாம். இந்த வகுப்பிற்கான பதிவு நிலை INFO அல்லது அதற்கு மேற்பட்டதாக இருந்தால் நாங்கள் சிக்கல்களைச் சந்திக்கத் தொடங்குகிறோம். வேறு வார்த்தைகளில் கூறுவதானால், இந்த பதிவு உள்ளீட்டை (INFO அல்லது அதற்கு மேற்பட்டவற்றிற்கு) நாம் எழுதக்கூடாது, மேலும் சரம் இணைப்பினைப் பயன்படுத்தக்கூடாது. கோட்பாட்டில், பதிவு நூலகமே இதைத் தீர்க்க வேண்டும். இது நடக்கும்போது, ​​Log4j இன் முதல் பதிப்பில் இது மிகப்பெரிய சிக்கலாக மாறியது. இது ஒரு கண்ணியமான தீர்வை வழங்கவில்லை, மாறாக இது போன்ற ஒன்றைச் செய்ய பரிந்துரைத்தது:

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

அதாவது, பதிவு செய்வதற்கான ஒரு வரிக்கு பதிலாக, அவர்கள் 3 ஐ எழுத பரிந்துரைத்தனர்! உள்நுழைவு குறியீடு மாற்றங்களைக் குறைக்க வேண்டும், மேலும் மூன்று வரிகள் அந்த பொதுவான அணுகுமுறையை தெளிவாக மீறுகின்றன. Slf4j ஆனது JDK மற்றும் API உடன் பொருந்தக்கூடிய சிக்கல்களை கொண்டிருக்கவில்லை, எனவே ஒரு நல்ல தீர்வு உடனடியாக வெளிப்பட்டது:

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

{}முறைக்கு அனுப்பப்பட்ட வாதங்களுக்கான ஒதுக்கிடங்களைக் குறிக்கிறது . அதாவது, முதலாவது {}ஒத்திருக்கிறது user, இரண்டாவது {}ஒத்திருக்கிறது request.getRemoteAddr(). இவ்வாறு செய்வதன் மூலம், லாக் லெவலுக்குப் பதிவு உள்ளீட்டை எழுத வேண்டியிருந்தால் மட்டுமே சரம் இணைப்பினைச் செய்வோம். அதன் பிறகு, Sjf4j வேகமாக பிரபலமடையத் தொடங்கியது. தற்போது, ​​இது சிறந்த தீர்வாக உள்ளது. அதன்படி, ஒரு பிணைப்பைப் பயன்படுத்தி பதிவு செய்வதைப் பார்ப்போம் slf4j-log4j12.

என்ன பதிவு செய்ய வேண்டும்

நிச்சயமாக, நீங்கள் எல்லாவற்றையும் பதிவு செய்யக்கூடாது. இது பெரும்பாலும் அவசியமில்லை மற்றும் சில நேரங்களில் ஆபத்தானது. எடுத்துக்காட்டாக, நீங்கள் ஒருவரின் தனிப்பட்ட தரவைப் பதிவுசெய்து, அது எப்படியாவது கசிந்தால், உண்மையான சிக்கல்கள் இருக்கும், குறிப்பாக மேற்கத்திய சந்தைகளில் கவனம் செலுத்தும் திட்டங்களில். ஆனால் நீங்கள் கண்டிப்பாக உள்நுழைய வேண்டிய விஷயங்களும் உள்ளன :

1. விண்ணப்பத்தின் ஆரம்பம்/முடிவு. அப்ளிகேஷன் உண்மையில் ஆரம்பித்து எதிர்பார்த்தபடி முடிந்ததா என்பதை நாம் தெரிந்து கொள்ள வேண்டும்.
2. பாதுகாப்பு பிரச்சினைகள். ஒருவரின் கடவுச்சொல்லை யூகிக்கும் முயற்சிகள், நிர்வாகிகள் உள்நுழையும் நிகழ்வுகள் போன்றவற்றை இங்கே பதிவு செய்வது நல்லது.
3. குறிப்பிட்ட பயன்பாடு மாநிலங்கள் . எடுத்துக்காட்டாக, ஒரு வணிகச் செயல்பாட்டில் ஒரு மாநிலத்திலிருந்து மற்றொரு மாநிலத்திற்கு மாறுதல்.
4. தொடர்புடைய பதிவு நிலையுடன் சில பிழைத்திருத்தத் தகவல் .
5. சில SQL ஸ்கிரிப்டுகள். இது தேவைப்படும் போது நிஜ உலக வழக்குகள் உள்ளன. ஆனால் மீண்டும், பதிவு நிலைகளை திறமையாக சரிசெய்வதன் மூலம், நீங்கள் சிறந்த முடிவுகளை அடையலாம்.
6. விஷயங்கள் சரியாகச் செயல்படுகின்றனவா என்பதைச் சரிபார்க்கும் போது இயங்கும் இழைகள் பதிவுசெய்யப்படலாம்.

பதிவு செய்வதில் பிரபலமான பிழைகள்

இங்கே பல நுணுக்கங்கள் உள்ளன, ஆனால் சில பொதுவான தவறுகளை நாங்கள் குறிப்பாக குறிப்பிடுவோம்:

1. அதிகப்படியான பதிவு. கோட்பாட்டளவில் முக்கியமானதாக இருக்கும் ஒவ்வொரு அடியையும் நீங்கள் பதிவு செய்யக்கூடாது. இங்கே ஒரு நல்ல விதி: பதிவுகள் சுமையின் 10% ஐ விட அதிகமாக இருக்கக்கூடாது. இல்லையெனில், செயல்திறன் சிக்கல்கள் இருக்கும்.
2. எல்லா தரவையும் ஒரே கோப்பில் உள்நுழைதல். ஒரு கட்டத்தில், இது பதிவைப் படிப்பதை/எழுதுவதை மிகவும் கடினமாக்கும், சில அமைப்புகளுக்கு கோப்பு அளவு வரம்புகள் உள்ளன என்பதைக் குறிப்பிட தேவையில்லை.
3. தவறான பதிவு நிலைகளைப் பயன்படுத்துதல். ஒவ்வொரு பதிவு நிலைக்கும் தெளிவான எல்லைகள் உள்ளன, மேலும் அவை மதிக்கப்பட வேண்டும். ஒரு எல்லை தெளிவாக இல்லை என்றால், எந்த அளவைப் பயன்படுத்துவது என்பது குறித்து நீங்கள் ஒரு உடன்படிக்கைக்கு வரலாம்.

பதிவு நிலைகள்

பதிவு நிலைகள் என்றால் என்ன? பதிவு உள்ளீடுகளின் படிநிலையை எப்படியாவது உருவாக்க, சில மரபுகள் மற்றும் வரையறைகள் அவசியம். இதனால்தான் பதிவு நிலைகள் அறிமுகப்படுத்தப்பட்டன. பயன்பாட்டில் நிலை அமைக்கப்பட்டுள்ளது. ஒரு உள்ளீடு ஒரு குறிப்பிட்ட மட்டத்திற்குக் கீழே இருந்தால், அது பதிவு செய்யப்படவில்லை. எடுத்துக்காட்டாக, பயன்பாட்டை பிழைத்திருத்தம் செய்யும் போது நாங்கள் பயன்படுத்தும் பதிவுகள் எங்களிடம் உள்ளன. சாதாரண செயல்பாட்டின் போது (பயன்பாடு அதன் நோக்கத்திற்காக பயன்படுத்தப்படும் போது), அத்தகைய பதிவுகள் தேவையில்லை. எனவே, பிழைத்திருத்தத்தை விட பதிவு நிலை அதிகமாக உள்ளது. Log4j ஐப் பயன்படுத்தி பதிவு நிலைகளைப் பார்ப்போம். JUL தவிர, பிற தீர்வுகளும் அதே பதிவு நிலைகளைப் பயன்படுத்துகின்றன. இங்கே அவை குறைந்து வரும் வரிசையில் உள்ளன:

• ஆஃப்: பதிவு உள்ளீடுகள் எதுவும் பதிவு செய்யப்படவில்லை; எல்லாம் புறக்கணிக்கப்படுகிறது.
• FATAL: பயன்பாடு தொடர்ந்து இயங்குவதைத் தடுக்கும் பிழை. எடுத்துக்காட்டாக, "JVM அவுட் ஆஃப் மெமரி பிழை".
• பிழை: இந்த நிலையில் உள்ள பிழைகள் தீர்க்கப்பட வேண்டிய சிக்கல்களைக் குறிக்கின்றன. பிழையானது பயன்பாட்டை முழுவதுமாக நிறுத்தாது. பிற கோரிக்கைகள் சரியாக வேலை செய்யக்கூடும்.
• எச்சரிக்கை: எச்சரிக்கையைக் குறிக்கும் பதிவு உள்ளீடுகள். எதிர்பாராத ஒன்று நடந்தது, ஆனால் அமைப்பு சமாளித்து கோரிக்கையை நிறைவேற்றியது
• தகவல்: பயன்பாட்டில் முக்கியமான செயல்களைக் குறிக்கும் பதிவு உள்ளீடுகள். இவை பிழைகள் அல்லது எச்சரிக்கைகள் அல்ல. அவை எதிர்பார்க்கப்படும் அமைப்பு நிகழ்வுகள்.
• பிழைத்திருத்தம்: பதிவுகள் உள்ளீடுகள் பயன்பாட்டை பிழைத்திருத்தம் செய்ய வேண்டும். பயன்பாடு எதிர்பார்த்ததைச் சரியாகச் செய்கிறது என்பதை உறுதி செய்வதற்காக அல்லது பயன்பாட்டினால் எடுக்கப்பட்ட செயல்களை விவரிப்பதற்காக, அதாவது "உள்ளிட்ட முறை1".
• ட்ரேஸ்: பிழைத்திருத்தத்திற்கான குறைந்த முன்னுரிமை பதிவு உள்ளீடுகள். குறைந்த பதிவு நிலை.
• அனைத்தும்: பயன்பாட்டின் பதிவு உள்ளீடுகள் அனைத்தையும் எழுதுவதற்கான பதிவு நிலை.

INFO பதிவு நிலை பயன்பாட்டில் எங்காவது இயக்கப்பட்டுள்ளது, பின்னர் ஒவ்வொரு நிலைக்கான உள்ளீடுகளும் INFO முதல் FATAL வரை பதிவு செய்யப்படும். FATAL பதிவு நிலை அமைக்கப்பட்டால், அந்த நிலை கொண்ட பதிவு உள்ளீடுகள் மட்டுமே எழுதப்படும்.

பதிவுகளை பதிவு செய்தல் மற்றும் அனுப்புதல்: இணைப்பு

பதிவுகளை எழுத/அனுப்புவதற்கு ஏராளமான வாய்ப்புகளை வழங்கும் Log4j ஐப் பயன்படுத்தும் போது இவை அனைத்தும் எவ்வாறு செயல்படுகின்றன என்பதைக் கருத்தில் கொள்வோம்:

• ஒரு கோப்பில் எழுத -DailyRollingFileAppender
• கன்சோலில் தகவலை எழுத -ConsoleAppender
• ஒரு தரவுத்தளத்தில் பதிவுகளை எழுத -JDBCAppender
• TCP/IP மூலம் பதிவுகளை அனுப்புவதை நிர்வகிக்க —TelnetAppender
• பதிவு செய்தல் செயல்திறனை எதிர்மறையாக பாதிக்காது என்பதை உறுதி செய்வதற்காக -AsyncAppender

இன்னும் சில செயலாக்கங்கள் உள்ளன: முழுமையான பட்டியல் இங்கே கிடைக்கிறது . சொல்லப்போனால், உங்களுக்குத் தேவையான துணை இல்லை என்றால், பிரச்சனை இல்லை. Log4j ஆதரிக்கும் Appender இடைமுகத்தை செயல்படுத்துவதன் மூலம் உங்கள் சொந்த appender எழுதலாம் .

பதிவு முனைகள்

ஆர்ப்பாட்ட நோக்கங்களுக்காக, Log4j இலிருந்து செயல்படுத்தப்படும் Slf4j இடைமுகத்தைப் பயன்படுத்துவோம். லாகரை உருவாக்குவது மிகவும் எளிது: என்ற வகுப்பில் MainDemo, சில பதிவுகளைச் செய்யும், பின்வருவனவற்றைச் சேர்க்க வேண்டும்:

org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(MainDemo.class);

இது நமக்கு ஒரு லாகரை உருவாக்கும். பதிவு உள்ளீட்டைச் செய்ய, எந்தப் பதிவு நிலை பயன்படுத்தப்படும் என்பதைப் பிரதிபலிக்கும் பல முறைகள் உள்ளன. உதாரணத்திற்கு:

logger.trace("Method 1 started with argument={}", argument);
logger.debug("Database updated with script = {}", script);
logger.info("Application has started on port = {}", port);
logger.warn("Log4j didn't find the log4j.properties file. Please fix this.");
logger.error("Connection refused to host = {}", host);

நாங்கள் வகுப்பில் தேர்ச்சி பெற்றாலும், இறுதிப் பெயர் வகுப்பின் முழுப் பெயர், தொகுப்புகள் உட்பட. இது செய்யப்படுகிறது, பின்னர் நீங்கள் உள்நுழைவை முனைகளாகப் பிரிக்கலாம் மற்றும் ஒவ்வொரு முனைக்கும் பதிவு நிலை மற்றும் பின்னிணைப்பை உள்ளமைக்கலாம். எடுத்துக்காட்டாக, லாகர் வகுப்பில் உருவாக்கப்பட்டது com.github.romankh3.logginglecture.MainDemo. பதிவு முனைகளின் படிநிலையை உருவாக்குவதற்கான அடிப்படையை இந்தப் பெயர் வழங்குகிறது. முக்கிய முனை மேல்-நிலை ரூட்லாக்கர் ஆகும் . இது முழு பயன்பாட்டிற்கான அனைத்து பதிவு உள்ளீடுகளையும் பெறும் முனை ஆகும். மீதமுள்ள முனைகள் கீழே காட்டப்பட்டுள்ளபடி சித்தரிக்கப்படலாம்: குறிப்பிட்ட லாக்கிங் முனைகளுக்கு இணைப்புகள் கட்டமைக்கப்பட்டுள்ளன. இப்போது நாம் log4j.properties கோப்பைப் பார்க்கப் போகிறோம், அவற்றை எவ்வாறு கட்டமைப்பது என்பதற்கான உதாரணத்தைக் காணலாம்.

log4j.properties கோப்பிற்கான படிப்படியான வழிகாட்டி

எல்லாவற்றையும் ஒரு படியாக அமைத்து, சாத்தியமானவற்றைப் பார்ப்போம்:

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender

org.apache.log4j.ConsoleAppender செயல்படுத்தலைப் பயன்படுத்தும் கன்சோல் அப்பெண்டரை நாங்கள் பதிவு செய்கிறோம் என்று இந்த வரி கூறுகிறது. இந்த இணைப்பான் கன்சோலுக்கு தகவலை எழுதுகிறது. அடுத்து, மற்றொரு இணைப்பியை பதிவு செய்கிறோம். இது ஒரு கோப்பில் எழுதும்:

log4j.appender.FILE=org.apache.log4j.RollingFileAppender

இணைப்பிகள் இன்னும் கட்டமைக்கப்பட வேண்டும் என்பதை கவனத்தில் கொள்ள வேண்டும். எங்கள் இணைப்பாளர்களைப் பதிவுசெய்தவுடன், எந்தப் பதிவு நிலைகள் மற்றும் எந்த இணைப்பிகள் முனைகளில் பயன்படுத்தப்படும் என்பதை நாம் தீர்மானிக்க முடியும்.

log4j.rootLogger=DEBUG, CONSOLE, FILE

• log4j.rootLogger என்பது அனைத்து பதிவு உள்ளீடுகளையும் கொண்ட ரூட் முனையை உள்ளமைக்கிறோம் என்று பொருள்
• சம அடையாளத்திற்குப் பின் வரும் முதல் வார்த்தை, எழுதுவதற்கான குறைந்தபட்ச பதிவு அளவைக் குறிக்கிறது (எங்கள் விஷயத்தில், இது DEBUG ஆகும்)
• கமாவைத் தொடர்ந்து, பயன்படுத்த வேண்டிய அனைத்து இணைப்புகளையும் நாங்கள் குறிப்பிடுகிறோம்.

மேலும் குறிப்பிட்ட பதிவு முனையை உள்ளமைக்க, நீங்கள் இது போன்ற ஒரு உள்ளீட்டைப் பயன்படுத்துவீர்கள்:

log4j.logger.com.github.romankh3.logginglecture=TRACE, OWN, CONSOLE

ஒரு குறிப்பிட்ட முனையைக் குறிப்பிட எங்கே log4j.logger.பயன்படுத்தப்படுகிறது. எங்கள் விஷயத்தில், com.github.romankh3.logginglecture. இப்போது கன்சோல் அப்பெண்டரை உள்ளமைப்பது பற்றி பேசலாம்:

# CONSOLE appender customization
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.threshold=DEBUG
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[%-5p] : %c:%L : %m%n

அப்பெண்டர் வேலை செய்யத் தொடங்கும் குறிப்பிட்ட அளவை அமைக்க முடியும் என்பதை இங்கே காண்கிறோம். உண்மையில் என்ன நடக்கிறது என்பதற்கான உதாரணம் இங்கே உள்ளது: INFO நிலையுடன் கூடிய ஒரு செய்தி லாக்கிங் நோட் மூலம் பெறப்பட்டு, அதற்கு ஒதுக்கப்பட்ட இணைப்பிற்கு அனுப்பப்பட்டது என்று வைத்துக்கொள்வோம். அப்பெண்டரின் நுழைவாயில் எச்சரிக்கையாக அமைக்கப்பட்டால், அது பதிவு உள்ளீட்டைப் பெறுகிறது ஆனால் அதனுடன் எதுவும் செய்யாது. அடுத்து, செய்தி எந்த அமைப்பைப் பயன்படுத்தும் என்பதை நாம் தீர்மானிக்க வேண்டும். நான் உதாரணத்தில் PatternLayout ஐப் பயன்படுத்துகிறேன், ஆனால் வேறு பல விருப்பங்கள் உள்ளன. இந்த கட்டுரையில் அவற்றை நாங்கள் மறைக்க மாட்டோம். கோப்பு இணைப்பினை உள்ளமைப்பதற்கான எடுத்துக்காட்டு:

# File appender customization
log4j.appender.FILE=org.apache.log4j.RollingFileAppender
log4j.appender.FILE.File=./target/logging/logging.log
log4j.appender.FILE.MaxFileSize=1MB
log4j.appender.FILE.threshold=DEBUG
log4j.appender.FILE.MaxBackupIndex=2
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[ %-5p] - %c:%L - %m%n

பதிவு உள்ளீடுகள் எழுதப்படும் குறிப்பிட்ட கோப்பை நீங்கள் கட்டமைக்கலாம், இந்த வரியில் இருந்து பார்க்க முடியும்:

log4j.appender.FILE.File=./target/logging/logging.log

நுழைவு கோப்பில் எழுதப்பட்டுள்ளது logging.log. கோப்பு அளவு சிக்கல்களைத் தவிர்க்க, நீங்கள் அதிகபட்சமாக உள்ளமைக்கலாம், இந்த விஷயத்தில் 1MB ஆகும். MaxBackupIndexஎத்தனை பதிவு கோப்புகள் இருக்கும் என்பதைக் குறிக்கிறது. இதை விட அதிகமான கோப்புகளை உருவாக்க வேண்டும் என்றால், முதல் கோப்பு நீக்கப்படும். பதிவு கட்டமைக்கப்பட்ட ஒரு உண்மையான உதாரணத்தைப் பார்க்க, நீங்கள் GitHub இல் உள்ள பொது களஞ்சியத்திற்குச் செல்லலாம் .

நாங்கள் விவாதித்ததை வலுப்படுத்துங்கள்

நாங்கள் விவரித்த அனைத்தையும் நீங்களே செய்ய முயற்சிக்கவும்:

• மேலே உள்ள எங்கள் உதாரணத்தைப் போலவே உங்கள் சொந்த திட்டத்தை உருவாக்கவும்.
• மேவனை எப்படி பயன்படுத்துவது என்று உங்களுக்குத் தெரிந்தால், அதைப் பயன்படுத்தவும். இல்லையெனில், நூலகத்தை எவ்வாறு இணைப்பது என்பதை விவரிக்கும் இந்த டுடோரியலைப் படிக்கவும்.

சுருக்கமாக

1. ஜாவாவில் இருக்கும் லாக்கிங் தீர்வுகள் பற்றி பேசினோம்.
2. நன்கு அறியப்பட்ட அனைத்து பதிவு நூலகங்களும் ஒருவரால் எழுதப்பட்டது: டி
3. எதைப் பதிவு செய்ய வேண்டும், எதைப் பதிவு செய்யக்கூடாது என்பதை நாங்கள் கற்றுக்கொண்டோம்.
4. பதிவு நிலைகளைக் கண்டுபிடித்தோம்.
5. நாங்கள் பதிவு முனைகளுக்கு அறிமுகப்படுத்தப்பட்டோம்.
6. அப்பெண்டர் என்றால் என்ன, அது எதற்காக என்று பார்த்தோம்.
7. log4j.proterties கோப்பை படிப்படியாக உருவாக்கினோம்.

கூடுதல் பொருட்கள்

1. கோட்ஜிம்: லாகர் பாடம்
2. வாராந்திர கீக்லி: ஜாவா பதிவு. வணக்கம் உலகம்
3. குறியீட்டு திகில்: பதிவு செய்வதில் சிக்கல்
4. யூடியூப்: ஜாவா லாக்கிங் ஹெல் - அடிப்படைகளை புரிந்துகொள்வது. ஜாவா லாக்கிங் ஹெல் & அதிலிருந்து விலகி இருப்பது எப்படி
5. பதிவு4j: இணைப்பு
6. Log4j: தளவமைப்பு

எனது மற்ற கட்டுரையையும் பார்க்கவும்:

• IntelliJ ஐடியாவில் பிழைத்திருத்தம்: ஒரு தொடக்க வழிகாட்டி