ஜாவா பதிவு

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

ஜாவாவில் உள்நுழைவது என்றால் என்ன?

பதிவுசெய்தல் என்பது ஒரு நிரலின் செயல்பாட்டைப் பற்றிய தரவைப் பதிவு செய்யும் செயலாகும். இந்தத் தரவை நாம் பதிவு செய்யும் இடம் "பதிவு" என்று அழைக்கப்படுகிறது. இரண்டு கேள்விகள் உடனடியாக எழுகின்றன: என்ன தரவு எழுதப்பட்டது, எங்கே? "எங்கே" என்று ஆரம்பிக்கலாம். ஒரு நிரலின் வேலையைப் பற்றிய தரவை நீங்கள் பல்வேறு இடங்களில் எழுதலாம். எடுத்துக்காட்டாக, உங்கள் படிப்பின் போது, ​​நீங்கள் அடிக்கடி System.out.println()கன்சோலில் தரவை வெளியிடுவதற்கு. இது மிகவும் எளிமையான வடிவத்தில் இருந்தாலும், உண்மையில் லாக்கிங் ஆகும். நிச்சயமாக, பயனர்கள் அல்லது தயாரிப்பு ஆதரவு குழுவிற்கு இது மிகவும் வசதியானது அல்ல: வெளிப்படையாக, அவர்கள் ஒரு IDE ஐ நிறுவி கன்சோலைக் கண்காணிக்க விரும்பவில்லை :) தகவலைப் பதிவுசெய்வதற்கு மிகவும் வழக்கமான வடிவம் உள்ளது: உரை கோப்புகள். மனிதர்கள் இந்த வடிவத்தில் தரவைப் படிக்க மிகவும் வசதியாக இருக்கிறார்கள், நிச்சயமாக இது தரவைச் சேமிப்பதற்கு மிகவும் வசதியானது! இப்போது இரண்டாவது கேள்வி: என்ன நிரல் தரவு பதிவு செய்யப்பட வேண்டும்? அது முற்றிலும் உங்களுடையது! ஜாவாவின் பதிவு அமைப்பு மிகவும் நெகிழ்வானது. உங்கள் நிரல் செய்யும் அனைத்தையும் பதிவு செய்ய நீங்கள் அதை உள்ளமைக்கலாம். ஒருபுறம், இது நல்லது. ஆனால் மறுபுறம், பேஸ்புக் அல்லது ட்விட்டரின் பதிவுகள் எவ்வளவு பெரியதாக இருக்கும் என்று கற்பனை செய்து பாருங்கள். இந்த பெரிய நிறுவனங்களுக்கு அந்த அளவு டேட்டாவைச் சேமிக்கும் திறன் இருக்கலாம். ஆனால் 500 ஜிகாபைட் உரை பதிவுகளில் ஒரு முக்கியமான பிழை பற்றிய தகவலைக் கண்டுபிடிப்பது எவ்வளவு கடினம் என்று கற்பனை செய்து பாருங்கள்? அது வைக்கோலில் ஊசியைத் தேடுவதை விட மோசமாக இருக்கும். அதன்படி, பிழை தரவுகளை மட்டும் பதிவு செய்ய ஜாவாவை கட்டமைக்க முடியும். அல்லது முக்கியமான பிழைகள் கூட! ஜாவாவின் நேட்டிவ் லாக்கிங் சிஸ்டத்தைப் பற்றி பேசுவது முற்றிலும் துல்லியமாக இல்லை. உண்மை என்னவென்றால், இந்த செயல்பாடு மொழியில் சேர்க்கப்படுவதற்கு முன்பு புரோகிராமர்களுக்கு பதிவு தேவைப்பட்டது. ஜாவா தனது சொந்த பதிவு நூலகத்தை அறிமுகப்படுத்திய நேரத்தில், அனைவரும் ஏற்கனவே log4j நூலகத்தைப் பயன்படுத்தினர். ஜாவாவில் உள்நுழைவதற்கான வரலாறு உண்மையில் மிக நீண்டது மற்றும் தகவலறிந்ததாகும். சுருக்கமாக, ஜாவாவிற்கு அதன் சொந்த பதிவு நூலகம் உள்ளது, ஆனால் கிட்டத்தட்ட யாரும் அதைப் பயன்படுத்துவதில்லை :) பின்னர், பல்வேறு பதிவு நூலகங்கள் தோன்றி, புரோகிராமர்களால் பயன்படுத்தத் தொடங்கியபோது, ​​பொருந்தக்கூடிய சிக்கல்கள் எழுந்தன. வெவ்வேறு இடைமுகங்களைக் கொண்ட ஒரு டஜன் வெவ்வேறு நூலகங்களில் சக்கரத்தை மீண்டும் கண்டுபிடிப்பதைத் தடுக்க, சுருக்கமான SLF4J கட்டமைப்பு ("ஜாவாவுக்கான சேவை பதிவு முகப்பு") உருவாக்கப்பட்டது. இது சுருக்கம் என்று அழைக்கப்படுகிறது, ஏனென்றால் நீங்கள் SLF4J வகுப்புகளின் முறைகளைப் பயன்படுத்தினாலும், அழைத்தாலும், அவை உண்மையில் முன்பு வந்த அனைத்து பதிவு கட்டமைப்புகளையும் பயன்படுத்துகின்றன: log4j, நிலையான java.util.logging மற்றும் பிற. சில சமயங்களில் மற்ற நூலகங்களில் இல்லாத Log4j இன் சில குறிப்பிட்ட அம்சம் உங்களுக்குத் தேவைப்பட்டால், இந்த நூலகத்துடன் உங்கள் திட்டத்தை நேரடியாக இணைக்க விரும்பவில்லை என்றால், SLF4J ஐப் பயன்படுத்தவும். பின்னர் அது Log4j முறைகளை அழைக்கட்டும். நீங்கள் உங்கள் எண்ணத்தை மாற்றி, இனி Log4j அம்சங்கள் தேவையில்லை என்று முடிவு செய்தால், ""இங்கே , மற்றும் Log4j நூலகம் இங்கே . அடுத்து, காப்பகத்தைத் திறந்து, ஜார் கோப்புகளை கிளாஸ்பாத்தில் சேர்க்க IntelliJ IDEA ஐப் பயன்படுத்தவும். மெனு உருப்படிகள்: கோப்பு -> திட்ட அமைப்பு -> நூலகங்கள் தேவையான JAR கோப்புகளைத் தேர்ந்தெடுத்து திட்டத்தில் சேர்க்கவும் (நாங்கள் பதிவிறக்கிய காப்பகங்களில் பல JAR கோப்புகள் உள்ளன - உங்களுக்குத் தேவையானவற்றைப் பார்க்க படங்களைப் பார்க்கவும்) அந்த மாணவர்களுக்கான இந்த அறிவுறுத்தலைக் கவனியுங்கள். Maven ஐ எப்படி பயன்படுத்துவது என்று தெரியாதவர்கள். Maven ஐ எவ்வாறு பயன்படுத்துவது என்பது உங்களுக்குத் தெரிந்தால், அங்கு தொடங்க முயற்சிப்பது நல்லது (மிகவும் எளிதானது). நீங்கள் Maven ஐப் பயன்படுத்தினால் , இந்த சார்புநிலையைச் சேர்க்கவும்:

    	<dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.14.0</version>
    	</dependency>

நன்று! அமைப்புகளை கண்டுபிடித்தோம் :) SLF4J எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம். நிரலின் வேலை எங்காவது பதிவு செய்யப்பட்டுள்ளதா என்பதை எவ்வாறு உறுதிப்படுத்துவது? இதைச் செய்ய, நமக்கு இரண்டு விஷயங்கள் தேவை: லாகர் மற்றும் அப்பண்டர். முதலில் இருந்து ஆரம்பிக்கலாம். லாகர் என்பது லாக்கிங்கின் முழுக் கட்டுப்பாட்டை வழங்கும் ஒரு பொருளாகும். லாகரை உருவாக்குவது மிகவும் எளிதானது: நிலையான LoggerFactory.getLogger() முறைகளைப் பயன்படுத்தி இதைச் செய்கிறோம். முறை அளவுரு என்பது அதன் செயல்பாடு பதிவு செய்யப்படும் வகுப்பாகும். எங்கள் குறியீட்டை இயக்குவோம்:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyTestClass {

   public static final Logger LOGGER = LoggerFactory.getLogger(MyTestClass.class);

   public static void main(String[] args) {

       LOGGER.info("Test log entry!!!");
       LOGGER.error("An error occurred!");
   }
}

கன்சோல் வெளியீடு:

ERROR StatusLogger No Log4j 2 configuration file found. Using default configuration (logging only errors to the console), or user programmatically provided configurations. Set system property 'log4j2.debug' to show Log4j 2 internal initialization logging. See https://logging.apache.org/log4j/2.x/manual/configuration.html for instructions on how to configure Log4j 2 15:49:08.907 [main] ERROR MyTestClass - An error occurred!

நாம் இங்கே என்ன பார்க்கிறோம்? முதலில், ஒரு பிழை செய்தியைப் பார்க்கிறோம். இப்போது எங்களிடம் தேவையான அமைப்புகள் இல்லை என்பதன் விளைவு இது. அதன்படி, எங்கள் லாகர் தற்போது பிழை செய்திகளை (ERROR) மற்றும் கன்சோலுக்கு மட்டுமே வெளியிட முடியும். logger.info () முறை வேலை செய்யவில்லை. ஆனால் logger.error() செய்தது! கன்சோலில், தற்போதைய தேதி, பிழை ஏற்பட்ட முறையைப் பார்க்கிறோம் ( முக்கிய), "ERROR" என்ற வார்த்தை மற்றும் எங்கள் செய்தி! பிழை என்பது பதிவு நிலை. பொதுவாக, ஒரு பதிவு உள்ளீடு "ERROR" என்ற வார்த்தையால் குறிக்கப்பட்டிருந்தால், நிரலில் இந்த கட்டத்தில் பிழை ஏற்பட்டது. உள்ளீடு "INFO" என்ற வார்த்தையால் குறிக்கப்பட்டிருந்தால், செய்தியானது நிரலின் இயல்பான செயல்பாட்டைப் பற்றிய தற்போதைய தகவலைக் குறிக்கிறது. SLF4J நூலகத்தில் பல்வேறு பதிவு நிலைகள் உள்ளன, அவை உள்நுழைவை நெகிழ்வாக உள்ளமைக்க அனுமதிக்கின்றன. எல்லாவற்றையும் நிர்வகிப்பது மிகவும் எளிதானது: தேவையான அனைத்து தர்க்கங்களும் ஏற்கனவே ஜாவா லாகர் வகுப்பில் உள்ளன. நீங்கள் பொருத்தமான முறைகளை அழைக்க வேண்டும். நீங்கள் ஒரு வழக்கமான செய்தியை பதிவு செய்ய விரும்பினால், logger.info() முறையை அழைக்கவும். பிழை செய்திக்கு, logger.error() ஐப் பயன்படுத்தவும் . எச்சரிக்கைக்கு, logger.warn() ஐப் பயன்படுத்தவும்

இப்போது அப்பெண்டர் பற்றி பேசலாம்

உங்கள் தரவு செல்லும் இடம் ஒரு appender ஆகும். ஒரு வகையில், தரவு மூலத்தின் எதிர், அதாவது "புள்ளி B". முன்னிருப்பாக, தரவு கன்சோலுக்கு வெளியீடு ஆகும். முந்தைய எடுத்துக்காட்டில் நாம் எதையும் உள்ளமைக்க வேண்டியதில்லை என்பதை நினைவில் கொள்க: கன்சோலில் உரை தோன்றியது, மேலும் Log4j நூலகத்தின் லாகர் கன்சோலுக்கு பிழை-நிலை செய்திகளை மட்டுமே வெளியிட முடியும். வெளிப்படையாக, மக்கள் ஒரு உரை கோப்பில் பதிவுகளைப் படிக்கவும் எழுதவும் மிகவும் வசதியானது. லாகரின் இயல்புநிலை நடத்தையை மாற்ற, எங்கள் கோப்பு இணைப்பினை உள்ளமைக்க வேண்டும். தொடங்குவதற்கு, நீங்கள் log4j.xml கோப்பை நேரடியாக src கோப்புறையில் உருவாக்க வேண்டும். நீங்கள் ஏற்கனவே XML வடிவமைப்பை நன்கு அறிந்திருக்கிறீர்கள்: சமீபத்தில் அதைப் பற்றிய பாடம் ஒன்றைப் பெற்றுள்ளோம் :) கோப்பின் உள்ளடக்கங்கள் இதோ:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO">
   <Appenders>
       <File name="MyFileAppender" fileName="C:\Users\Username\Desktop\testlog.txt" immediateFlush="false" append="false">
           <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
       </File>
   </Appenders>
   <Loggers>
       <Root level="INFO">
           <AppenderRef ref="MyFileAppender"/>
       </Root>
   </Loggers>
</Configuration>

இங்கே குறிப்பாக சிறப்பு அல்லது கடினமான எதுவும் இல்லை :) ஆனால் இன்னும், உள்ளடக்கத்தைப் பார்ப்போம்.

<Configuration status="INFO">

இதுவே StatusLogger எனப்படும். இது எங்கள் லாகருடன் தொடர்பில்லாதது மற்றும் Log4j இன் உள் செயல்முறைகளில் பயன்படுத்தப்படுகிறது. நீங்கள் status="INFO" என்பதற்குப் பதிலாக status="TRACE" என அமைத்தால், Log4j இன் உள் வேலை பற்றிய அனைத்துத் தகவல்களும் கன்சோலில் காட்டப்படும் (StatusLogger ஆனது கன்சோலில் தரவைக் காண்பிக்கும், அது ஒரு கோப்பாக இருந்தாலும் கூட). இப்போது தேவை இல்லை, அப்படியே விட்டுவிடுவோம்.

<Appenders>
   <File name="MyFileAppender" fileName="C:\Users\Evgeny\Desktop\testlog.txt" append="true">
       <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
   </File>
</Appenders>

இங்கே நாம் நமது இணைப்பியை உருவாக்குகிறோம். <File> குறிச்சொல் இது ஒரு கோப்பு இணைப்பாக இருக்கும் என்பதைக் குறிக்கிறது. name="MyFileAppender" என்பது இணைப்பின் பெயரை அமைக்கிறது. fileName="C:\Users\Username\Desktop\testlog.txt" என்பது அனைத்து தரவுகளும் எழுதப்படும் பதிவு கோப்பிற்கான பாதையை குறிக்கிறது. append="true" என்பது கோப்பின் முடிவில் தரவு எழுதப்பட வேண்டுமா என்பதைக் குறிக்கிறது. எங்கள் விஷயத்தில், இதைத்தான் நாங்கள் செய்வோம். நீங்கள் மதிப்பை தவறானதாக அமைத்தால், ஒவ்வொரு முறை நிரல் தொடங்கப்படும்போதும் பதிவு கோப்பின் பழைய உள்ளடக்கங்கள் நீக்கப்படும். <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>வடிவமைப்பு அமைப்புகளைக் குறிக்கிறது. எங்கள் பதிவில் உரை எவ்வாறு வடிவமைக்கப்படுகிறது என்பதைத் தனிப்பயனாக்க இங்கே வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தலாம்.

<Loggers>
       <Root level="INFO">
           <AppenderRef ref="MyFileAppender"/>
       </Root>
</Loggers>

இங்கே நாம் ரூட் அளவைக் குறிப்பிடுகிறோம். நாங்கள் "INFO" அளவை அமைத்துள்ளோம், அதாவது INFO ஐ விட அதிகமாக உள்ள அனைத்து செய்திகளும் (நாம் மேலே பார்த்த அட்டவணையின்படி) பதிவு செய்யப்படாது. எங்கள் திட்டத்தில் 3 செய்திகள் இருக்கும்: ஒரு தகவல், ஒரு எச்சரிக்கை மற்றும் ஒரு பிழை. தற்போதைய உள்ளமைவுடன், அனைத்து 3 செய்திகளும் பதிவு செய்யப்படும். நீங்கள் ரூட் நிலையை ERROR என மாற்றினால், LOGGER.error() முறை அழைப்பிலிருந்து வரும் கடைசி செய்தி மட்டுமே பதிவில் முடிவடையும். கூடுதலாக, இணைப்பாளரைப் பற்றிய குறிப்பும் இங்கே செல்கிறது. அத்தகைய குறிப்பை உருவாக்க, நீங்கள் <Root> குறிச்சொல்லின் உள்ளே <ApprenderRef> குறிச்சொல்லை உருவாக்கி அதில் ref='your appender's name' பண்புக்கூறைச் சேர்க்க வேண்டும். நீங்கள் மறந்திருந்தால், இங்குதான் இணைப்பாளரின் பெயரை அமைப்போம்: <. இதோ எங்கள் குறியீடு!

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyTestClass {

   public static final Logger LOGGER = LoggerFactory.getLogger(MyTestClass.class);

   public static void main(String[] args) {

       LOGGER.info("The program is starting!!!");

       try {
           LOGGER.warn("Attention! The program is trying to divide a number by another.
           System.out.println(12/0);
       } catch (ArithmeticException x) {

           LOGGER.error("Error! Division by zero!");
       }
   }
}

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