Hi! Kapag nagsusulat ng mga aralin, lalo kong binibigyang-diin kung mayroong isang tiyak na paksa na magiging ganap na mahalaga sa totoong gawain. Kaya, MAKINIG! Ang paksang tatalakayin natin ngayon ay tiyak na magiging kapaki-pakinabang sa lahat ng iyong mga proyekto mula sa unang araw ng pagtatrabaho. Pag-uusapan natin ang tungkol sa Java Logging. Ang paksang ito ay hindi naman kumplikado (masasabi kong madali lang). Ngunit magkakaroon ka ng sapat na malinaw na mga bagay upang bigyan ng diin sa iyong unang trabaho, kaya mas mahusay na lubusan itong maunawaan ngayon :) Well, magsimula tayo.
Ano ang pag-log in sa Java?
Ang pag-log ay ang pagkilos ng pagtatala ng data tungkol sa pagpapatakbo ng isang programa. Ang lugar kung saan namin itinatala ang data na ito ay tinatawag na "log". Dalawang tanong kaagad ang lumitaw: anong data ang nakasulat at saan? Magsimula tayo sa "saan". Maaari kang magsulat ng data tungkol sa gawain ng isang programa sa maraming iba't ibang lugar. Halimbawa, sa panahon ng iyong pag-aaral, madalas mong System.out.println()upang mag-output ng data sa console. Talagang ito ay pag-log, kahit na sa pinakasimpleng anyo nito. Siyempre, hindi ito masyadong maginhawa para sa mga user o isang team ng suporta sa produkto: malinaw naman, ayaw nilang mag-install ng IDE at subaybayan ang console :) May mas karaniwang format para sa pag-record ng impormasyon: mga text file. Ang mga tao ay mas komportable sa pagbabasa ng data sa format na ito, at tiyak na ito ay mas maginhawa para sa pag-iimbak ng data! Ngayon ang pangalawang tanong: anong data ng programa ang dapat i-log? Iyan ay ganap na nakasalalay sa iyo! Ang sistema ng pag-log ng Java ay napaka-flexible. Maaari mo itong i-configure upang mai-log ang lahat ng ginagawa ng iyong programa. Sa isang banda, ito ay mabuti. Ngunit sa kabilang banda, isipin kung gaano kalaki ang mga log ng Facebook o Twitter kung isinulat nila ang lahat sa mga ito. Ang malalaking kumpanyang ito ay malamang na may kakayahang mag-imbak ng ganoong kalaking data. Ngunit isipin kung gaano kahirap maghanap ng impormasyon tungkol sa isang kritikal na error sa 500 gigabytes ng mga log ng teksto? Mas masahol pa iyon kaysa maghanap ng karayom sa isang dayami. Alinsunod dito, maaaring i-configure ang Java upang mag-log lamang ng data ng error. O kahit na mga kritikal na pagkakamali lamang! Iyon ay sinabi, hindi ganap na tumpak na pag-usapan ang katutubong sistema ng pag-log ng Java. Ang katotohanan ay ang mga programmer ay nangangailangan ng pag-log bago ang pagpapaandar na ito ay idinagdag sa wika. Sa oras na ipinakilala ng Java ang sarili nitong logging library, lahat ay gumagamit na ng log4j library. Ang kasaysayan ng pag-log in sa Java ay talagang napakahaba at nagbibigay-kaalaman. Sa madaling salita, may sariling logging library ang Java, ngunit halos walang gumagamit nito :) Nang maglaon, nang lumitaw ang iba't ibang logging library at nagsimulang gamitin ng mga programmer, lumitaw ang mga problema sa compatibility. Upang pigilan ang mga tao sa muling pag-imbento ng gulong sa isang dosenang iba't ibang mga aklatan na may iba't ibang mga interface, ang abstract SLF4J framework ("Service Logging Facade For Java") ay nilikha. Ito ay tinatawag na abstract, dahil kahit na gumamit ka at tumawag sa mga pamamaraan ng mga klase ng SLF4J, sa ilalim ng hood ay talagang ginagamit nila ang lahat ng mga balangkas ng pag-log na nauna: log4j, ang karaniwang java.util.logging, at iba pa. Kung sa isang punto kailangan mo ng ilang partikular na tampok ng Log4j na kulang sa ibang mga aklatan, ngunit ayaw mong direktang i-link ang iyong proyekto sa aklatang ito, gamitin lamang ang SLF4J. At pagkatapos ay hayaan itong tumawag sa mga pamamaraan ng Log4j. Kung magbago ang isip mo at magpasya na hindi mo na kailangan ang mga feature ng Log4j, kailangan mo lang i-configure ang "dito , at ang Log4j library dito . Susunod, i-unpack ang archive at gamitin ang IntelliJ IDEA upang idagdag ang mga JAR file sa classpath. Mga item sa menu: File -> Istraktura ng Proyekto -> Mga Aklatan Piliin ang mga kinakailangang JAR file at idagdag ang mga ito sa proyekto (ang mga archive na na-download namin ay naglalaman ng maraming JAR file — tingnan ang mga larawan para makita ang mga kailangan mo) Tandaan na ang pagtuturo na ito para sa mga estudyanteng iyon na hindi marunong gumamit ng Maven. Kung alam mo kung paano gamitin ang Maven, kadalasan ay mas mabuti (mas madali) na subukang magsimula doon. Kung gumagamit ka ng Maven , idagdag ang dependency na ito:
Malaki! Nalaman namin ang mga setting :) Tingnan natin kung paano gumagana ang SLF4J. Paano natin matitiyak na ang gawain ng programa ay naitala sa isang lugar? Para magawa ito, kailangan namin ng dalawang bagay: logger at appender. Magsimula tayo sa una. Ang logger ay isang bagay na nagbibigay ng ganap na kontrol sa pag-log. Napakadali ng paggawa ng logger: ginagawa namin ito gamit ang mga static na pamamaraan ng LoggerFactory.getLogger() . Ang parameter ng pamamaraan ay ang klase na ang operasyon ay mai-log. Patakbuhin natin ang ating code:
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!");
}
}
Output ng console:
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!
Ano ang nakikita natin dito? Una, may nakikita kaming mensahe ng error. Ito ay resulta ng katotohanan na ngayon ay kulang tayo sa mga kinakailangang setting. Alinsunod dito, ang aming logger ay kasalukuyang nakakapag-output lamang ng mga mensahe ng error (ERROR) at sa console lamang. Ang logger.info() na paraan ay hindi gumana. Ngunit ginawa ng logger.error() ! Sa console, nakikita namin ang kasalukuyang petsa, ang paraan kung saan naganap ang error ( main), ang salitang "ERROR", at ang aming mensahe! Ang ERROR ay ang antas ng pag-log. Sa pangkalahatan, kung ang isang log entry ay minarkahan ng salitang "ERROR", kung gayon ang isang error ay naganap sa puntong ito sa programa. Kung ang entry ay minarkahan ng salitang "INFO", kung gayon ang mensahe ay kumakatawan lamang sa kasalukuyang impormasyon tungkol sa normal na operasyon ng programa. Ang SLF4J library ay may maraming iba't ibang antas ng pag-log na nagbibigay-daan sa iyong i-configure ang pag-log nang may kakayahang umangkop. Napakadaling pangasiwaan ang lahat: nasa klase na ng Java Logger ang lahat ng kinakailangang lohika . Kailangan mo lamang tawagan ang mga nauugnay na pamamaraan. Kung gusto mong mag-log ng isang nakagawiang mensahe, tawagan ang logger.info() na paraan. Para sa isang mensahe ng error, gamitin ang logger.error() . Para sa isang babala, gamitin ang logger.warn()
Ngayon ay pag-usapan natin ang tungkol sa appender
Ang appender ay ang lugar kung saan napupunta ang iyong data. Sa isang paraan, ang kabaligtaran ng isang data source, ie "point B". Bilang default, ang data ay output sa console. Tandaan na sa nakaraang halimbawa hindi namin kailangang i-configure ang anuman: lumabas ang text sa console, at ang logger ng Log4j library ay makakapag-output lamang ng mga mensahe sa antas ng ERROR sa console. Malinaw, mas maginhawa para sa mga tao na magbasa at magsulat ng mga log sa isang text file. Upang baguhin ang default na gawi ng logger, kailangan naming i-configure ang aming file appender. Upang makapagsimula, kailangan mong lumikha ng log4j.xml file nang direkta sa src folder. Pamilyar ka na sa XML na format: kamakailan ay nagkaroon kami ng aral tungkol dito :) Narito ang mga nilalaman ng file:
Walang partikular na espesyal o mahirap dito :) Ngunit gayon pa man, tingnan natin ang nilalaman.
<Configuration status="INFO">
Ito ang tinatawag na StatusLogger. Ito ay walang kaugnayan sa aming logger at ginagamit sa mga panloob na proseso ng Log4j. Kung itinakda mo ang status="TRACE" sa halip na status="INFO", at ang lahat ng impormasyon tungkol sa panloob na gawain ng Log4j ay ipapakita sa console (Ang StatusLogger ay nagpapakita ng data sa console, kahit na ang aming appender ay isang file). Hindi natin ito kailangan ngayon, kaya hayaan na natin ito.
Dito ginagawa namin ang aming appender. Ang tag na <File> ay nagpapahiwatig na ito ay isang file appender. name="MyFileAppender" ay nagtatakda ng pangalan ng appender. fileName="C:\Users\Username\Desktop\testlog.txt" ay nagpapahiwatig ng path sa log file kung saan isusulat ang lahat ng data. append="true" ay nagpapahiwatig kung ang data ay dapat isulat sa dulo ng file. Sa aming kaso, ito mismo ang aming gagawin. Kung itinakda mo ang halaga sa false, ang mga lumang nilalaman ng log file ay tatanggalin sa tuwing magsisimula ang programa. <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>ay nagpapahiwatig ng mga setting ng pag-format. Dito maaari naming gamitin ang mga regular na expression upang i-customize kung paano na-format ang teksto sa aming log.
Dito ipinapahiwatig namin ang antas ng ugat. Itinakda namin ang antas ng "INFO", na nangangahulugan na ang lahat ng mga mensahe na ang mga antas ay mas mataas kaysa sa INFO (ayon sa talahanayan na aming tiningnan sa itaas) ay hindi mai-log. Ang aming programa ay magkakaroon ng 3 mensahe: isang INFO, isang WARN at isang ERROR. Sa kasalukuyang configuration, lahat ng 3 mensahe ay mai-log. Kung babaguhin mo ang root level sa ERROR, ang huling mensahe lang mula sa LOGGER.error() method call ang mapupunta sa log. Bukod pa rito, napupunta rin dito ang isang reference sa appender. Upang gumawa ng ganoong sanggunian, kailangan mong lumikha ng tag na <ApprenderRef> sa loob ng tag na <Root> at idagdag ang katangiang ref='your appender's name' dito. Kung sakaling nakalimutan mo, dito namin itinakda ang pangalan ng appender: <. At narito ang aming code!
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!");
}
}
}
Syempre, ito ay medyo nakakatakot (ang pagkuha ng RuntimeException ay isang kaduda-dudang ideya), ngunit ito ay perpekto para sa ating mga layunin :) Patakbuhin natin ang ating main() na pamamaraan nang 4 na beses nang sunud-sunod at tingnan ang ating testlog.txt file. Hindi mo kailangang likhain ito nang maaga: awtomatiko itong gagawin ng library. Lahat ay gumana! :) Ngayon ay mayroon kang naka-configure na logger. Maaari kang makipaglaro sa ilan sa iyong mga lumang programa, pagdaragdag ng mga tawag sa logger sa bawat pamamaraan. Pagkatapos ay tingnan ang resultang log :) Isinasaalang-alang nito ang paksa ng pag-log nang malalim. Mahirap basahin ang lahat sa isang upuan. Iyon ay sinabi, naglalaman ito ng maraming karagdagang kapaki-pakinabang na impormasyon. Halimbawa, matututunan mo kung paano i-configure ang logger upang makalikha ito ng bagong text file kung ang aming testlog.txt file ay umabot sa isang tiyak na laki :) At iyon ang nagtatapos sa aming klase! Ngayon ay naging pamilyar ka sa isang napakahalagang paksa, at ang kaalamang ito ay tiyak na makakatulong sa iyo sa iyong trabaho sa hinaharap. Hanggang sa muli! :)
iyon na hindi marunong gumamit ng Maven. Kung alam mo kung paano gamitin ang Maven, kadalasan ay mas mabuti (mas madali) na subukang magsimula doon. Kung gumagamit ka ng Maven , idagdag ang dependency na ito:
GO TO FULL VERSION