Bakit kailangan ang mga log sa Java

1.1 Panimula sa mga log

Ang log ay isang listahan ng mga kaganapan na naganap. Halos parang nautical journal o diary. Kaya naman, ang isang logger ay isang bagay kung saan maaari kang mag-log. Sa programming, kaugalian na mag-log halos lahat. At sa Java, lahat ay ganoon at kahit kaunti pa.

Ang katotohanan ay ang mga Java program ay napakadalas na malalaking application ng server na walang UI, console, at iba pa. Pinoproseso nila ang mga kahilingan mula sa libu-libong mga gumagamit nang sabay-sabay at kadalasan ay nangyayari ang iba't ibang mga error. Lalo na kapag ang iba't ibang mga thread ay nagsimulang makagambala sa bawat isa.

At, sa katunayan, ang tanging paraan upang makahanap ng mga bihirang kopyahin ang mga error at pagkabigo sa ganoong sitwasyon ay ang pagsulat sa log / file ng lahat ng nangyayari sa bawat thread.

Kadalasan, ang impormasyon ay nakasulat sa log tungkol sa mga parameter ng pamamaraan kung saan ito tinawag, lahat ng mga naharang na error, at maraming intermediate na impormasyon. Kung mas kumpleto ang log, mas madaling ibalik ang pagkakasunud-sunod ng mga kaganapan at subaybayan ang mga sanhi ng isang pagkabigo o error.

Ngunit kung mas malaki ang log, mas mahirap gawin ito. Minsan ang mga log ay umaabot ng ilang gigabytes bawat araw. Ito ay mabuti.

1.2 Nabigong mga log

Bilang mga unang log, ginamit ng mga developer ang simpleng output sa console . Maginhawang gawin ito sa panahon ng pag-debug ng application - kapag ang lahat ng mahalagang impormasyon at mga variable na halaga ay isinulat sa console. Ngunit ang naturang log ay ganap na hindi naaangkop sa panahon ng normal na operasyon ng application.

Una, ang application ay maaaring nais na mag-output ng isang bagay sa console mismo, at ang gumagamit ay hindi nais na makita ang impormasyon ng serbisyo na inilaan para sa programmer sa lahat.

Pangalawa, ang laki ng console buffer ay limitado, hindi ka makakasulat ng marami doon.

At sa wakas, pangatlo, ang impormasyon tungkol sa mga error sa programa na nakolekta sa mahabang panahon ay dapat ipadala sa mga developer ng programa. At ito ay pinaka-maginhawa upang isulat ang lahat ng impormasyong ito nang sabay-sabay sa isang file.

Mabilis na nalutas ng mga developer ang unang problema - nakabuo sila ng isa pang stream ng output - System.err. Maaari kang sumulat ng mga mensahe dito at ipapadala ang mga ito sa isang hiwalay na thread, at hindi sa karaniwang console.

At kahit na ang problema sa pagsulat sa isang file ay nalutas:

// Define the file to which we will write the log
System.setErr(new PrintStream(new File("log.txt")));
// Display messages
System.err.println("Message 1");
System.err.println("Message 2");
// Display an error message
try {
    throw new Exception("Error message");
} catch (Exception e) {
    e.printStackTrace();
}

Ngunit kahit na sa form na ito, hindi nito nalutas ang buong problema, kaya napagpasyahan na lumikha ng isang espesyal na library na magsusulat ng mga mensahe ng log sa isang file. Ginawa niya ito sa matalinong paraan at pinahintulutan ang kakayahang umangkop na i-configure ang mga filter para sa mga naka-log na kaganapan at data.

Ang buong proseso ng pag-log, sa katunayan, ay binubuo ng tatlong bahagi:

• Ang unang bahagi ay pangangalap ng impormasyon .
• Ang ikalawang bahagi ay ang pagsasala ng mga nakalap na impormasyon.
• Ang ikatlong bahagi ay ang pagtatala ng napiling impormasyon.

1.3 Panimula sa log4j logger

Ang unang tanyag na logger sa komunidad ng Java ay ang log4j. Ang pagsasama nito sa proyekto ay napakasimple, para dito kailangan mong magdagdag lamang ng ilang linya sa iyong pom.xml

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>2.2.17</version>
</dependency>

Ang pakikipag-ugnayan ng iyong programa sa naturang logger ay magiging ganito ang hitsura:

class Manager {
   private static final Logger logger = LoggerFactory.getLogger(Manager.class);

   public boolean processTask(Task task) {
        logger.debug("processTask id = " + task.getId());
        try {
            task.start();
            task.progress();
            task.complete();
            return true;
        } catch (Exception e) {
            logger.error("Unknown error", e);
            return false;
        }
    }
}

Tatlong bagay ang nangyayari dito:

Ang paglikha ng bagay ay naka-highlight sa berde Logger . Ang bagay nito ay naka-imbak sa isang static na variable para sa mas maginhawang trabaho dito. At din getLogger()ang impormasyon tungkol sa klase kung saan kinokolekta ang impormasyon ay ipinapasa sa pamamaraan.

Ang linyang naka-highlight sa asul ay kung saan kami nag-log ng impormasyon ng halaga lamang sa panahon ng pag-debug . Para dito, ginagamit ang isang espesyal na pamamaraan -debug()

At sa wakas , ang linya kung saan ise-save namin ang exception na lumitaw sa log ay naka-highlight sa pula . Ang mga pagbubukod ay mga potensyal na error, kaya ang error().