ஜாவாவில் பதிவு வரலாறு

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இருப்பினும், அதன் வளர்ச்சியின் போது, ​​லாக்கரை உருவாக்கியவர்கள் ஐபிஎம்மில் இருந்து லாகரின் மாறுபாட்டை அடிப்படையாக எடுத்துக் கொண்டனர் , இது அதன் வளர்ச்சியில் தாக்கத்தை ஏற்படுத்தியது. நல்ல செய்தி என்னவென்றால், லாகர் 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 முதல் லாகர் ரேப்பர் - ஜேசிஎல்: ஜகார்த்தா காமன்ஸ் லாக்கிங்

நீண்ட காலமாக லாக்கர்களிடையே ஒரே தரநிலை இல்லை, அது 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.