Apache Tomcat 8

ממשק ה- API של Servlets Rounging מקדים את ה- Java.שימוש.API לרישום המסופק כעת על ידי Java. ככאלה, זה לא מציע לך הרבה אפשרויות. ה.ז., אינך יכול לשלוט ברמות היומן. עם זאת, ניתן לציין כי ביישום Apache Tomcat השיחות ל- ServletContext.יומן (מחרוזת) או Genericservlet.יומן (מחרוזת) נרשם ברמת המידע. השיחות ל- servletcontext.יומן (מחרוזת, ניתן לזרוק) או Genericservlet.יומן (מחרוזת, ניתנת לזרוק) נרשמת ברמה הקשה.

סיכום:

במאמר זה אסביר את החשיבות של שימוש באפצ’י טומקט 9 עם Log4J2 למטרות כניסה. אני אספק גם מדריך שלב אחר שלב כיצד להגדיר את התצורה של Apache Tomcat עם Log4J2, ולדון בשיטות העבודה המומלצות לרישום בסביבות ייצור.

נקודות מפתח:

1. Apache Tomcat 9 ו- Log4J2 מציעים מגוון רחב של אפשרויות רישום ומספגים
2. Log4j2 מספק תצורת גלגול וקבצים מפושטים ותצורת בליעת יומן
3. כדי לקבוע את התצורה של log4j2 עם Apache Tomcat, הוסף את הספריות הדרושות ל- ClassPath והסר את רישום ברירת המחדל.קובץ מאפיינים
4. החל מטומקט 8.5.4, ספריות העומס ג’ולי אינן נחוצות עוד מכיוון שניתן לחבר ישירות את Log4J2 ל- Java.שימוש.כניסה
5. עבור סביבות ייצור, מומלץ להתאים אישית את תצורת Log4J2 כדי למנוע כפילויות של יומנים, לאפשר סיבוב יומן ולהסיר נספחים שאינם בשימוש
6. בנוסף, הצטרפות לגרגרים שונים למפקר אחד יכולה לעזור בזיהוי בעיות פריסה ביישומים
7. לאלץ יישומים באמצעות מערכת.החוצה ומערכת.טעות ליציאה, הוסף את תכונת SwallowOutput בהקשר.קובץ XML
8. ניתן להגדיר יישומים המשתמשים במסגרת JUL לשימוש ב- LOG4J2 על ידי שינוי משתנה הסביבה של LOGIGN_MANAGER
9. בעת שימוש באתחול האביב עם Log4J2, איכללו את תלות היציאה של האתחול-אתחול האביב והוסיפו את Spring-Boot-Starter-Log4J2
10. התאמה אישית של רמות רישום לחבילות ספציפיות והשבית את באנר האביב לפי הצורך

שאלות:

1. מדוע עלי לשקול להשתמש ב- Apache Tomcat 9 עם Log4J2 לצורך כניסה?
   Log4J2 מציע מגוון רחב של אפשרויות כניסה ומנקמים, מה שהופך אותו לכלי רב עוצמה לניהול יומנים ב- Tomcat.
2. כיצד אוכל להגדיר את Log4J2 עם Apache Tomcat?
   כדי לקבוע את התצורה של log4j2 עם Apache Tomcat, עליך להוסיף את הספריות הדרושות לנתיב Classpath ולהסיר את רישום ברירת המחדל.קובץ מאפיינים.
3. מדוע אין צורך בספריות הג’ולי-אפלטר עוד בטומקט 8.5.4 ומעלה?
   ניתן לחבר ישירות את Log4J2 ל- Java.שימוש.כריתת עצים, ביטול הצורך בספריות ג’ולי-עמוד.
4. מהן תצורות הרישום המומלצות לסביבות ייצור?
   בסביבות ייצור, מומלץ להתאים אישית את תצורת Log4J2 כדי למנוע כפילויות של יומני, לאפשר סיבוב יומן ולהסיר נספחים שאינם בשימוש.
5. כיצד אוכל לכפות יישומים באמצעות מערכת.החוצה ומערכת.טעות ליומן?
   על ידי הוספת תכונת SwallowOutput בהקשר.קובץ XML, יישומים באמצעות מערכת.החוצה ומערכת.ניתן לכפות על שגיאה להתחבר.
6. ניתן להגדיר יישומים באמצעות מסגרת Jul לשימוש ב- Log4J2?
   כן, על ידי שינוי משתנה הסביבה של loging_manager, ניתן להגדיר יישומים באמצעות מסגרת JUL לשימוש ב- LOG4J2.
7. מה עלי לעשות כדי להשתמש ב- log4j2 עם מגף האביב?
   כדי להשתמש ב- log4j2 עם מגף האביב, תכלול את התלות-יומן-אתחול האביב-סניף והוסף spring-boot-starter-log4j2.
8. כיצד אוכל להתאים אישית את רמות הרישום עבור חבילות ספציפיות באתחול האביב?
   ניתן להתאים אישית רמות רישום עבור חבילות ספציפיות על ידי שינוי מאפייני תצורת הרישום בקובץ התצורה של היישום.
9. האם ניתן להשבית את באנר האביב באף האביב?
   כן, ניתן להשבית את באנר האביב על ידי הגדרת האביב.רָאשִׁי.מאפיין במצב באנר לכיבוי בקובץ התצורה של היישום.
10. מדוע עלי להשתמש ב- log4j2 במקום ביישום רישום ברירת המחדל ב- Tomcat?
    Log4J2 מציע מגוון רחב יותר של אפשרויות רישום ומנספחים, מה שהופך אותו לגמיש ועוצמתי יותר בהשוואה ליישום רישום ברירת המחדל ב- Tomcat.

תשובות מפורטות:

1. מדוע עלי לשקול להשתמש ב- Apache Tomcat 9 עם Log4J2 לצורך כניסה?
   Apache Tomcat 9 עם Log4J2 מספק מערכת רישום מתקדמת וגמישה יותר בהשוואה ליישום רישום ברירת המחדל. Log4J2 מציע מגוון רחב של נספחים ואפשרויות רישום, ומאפשר לך להתאים אישית ולנהל את היומנים שלך ביעילות. הפשטות של התצורה של Log4J2 והיכולת שלה לגלגל קבצי יומן עם השם המקורי הופכים אותה לבחירה מושכת לתצורות בליעת יומן. בנוסף, השימוש ב- Log4J2 מבטל את המגבלות של ממשק ה- API של Servlets, כמו חוסר היכולת לשלוט על רמות היומן.
2. כיצד אוכל להגדיר את Log4J2 עם Apache Tomcat?
   קביעת התצורה של log4j2 עם Apache Tomcat הוא פשוט. ראשית, עליך להוסיף את הספריות Log4J2-API, Log4J2-Core ו- Log4J2-Appserver לנתיב Classat Tomcat. לאחר מכן, ספק את קובץ התצורה של Log4J2 בפרויקט שלך. לבסוף, הסר את רישום ברירת המחדל.קובץ מאפיינים מהתקנת TomCat שלך. הצעדים הבאים יאפשרו Log4J2 כמסגרת הרישום עבור Tomcat.
3. מדוע אין צורך בספריות הג’ולי-אפלטר עוד בטומקט 8.5.4 ומעלה?
   גרסאות טומקט 8.5.4 ומעלה הציג אינטגרציה ישירה עם Log4J2, וביטול הצורך בספריות ג’ולי-עמד. כעת ניתן לחבר את Log4J2 ישירות ל- Java.שימוש.רישום, מה שהופך אותו לתחליף חלק לממשק API של Servlets Looking. שילוב זה מפשט את תהליך תצורת הרישום ומספק שליטה רבה יותר על רמות היומן והנספחים.
4. מהן תצורות הרישום המומלצות לסביבות ייצור?
   בעת קביעת התצורה של Log4J2 לסביבות ייצור, יש לקחת בחשבון מספר שיקולים. ראשית, חשוב להימנע משכפול תפוקות יומן בקטלינה.קובץ וקטלינה.קובץ לוג. ניתן להשיג זאת על ידי הסרת הקונסולהר. שנית, מומלץ לאפשר סיבוב יומן עבור הקטלינה.קובץ יומן כדי למנוע ממנו לגדול מדי. לבסוף, הסרת נספחים שאינם בשימוש כמו מנהל.log and host_manager.יומן יכול לעזור לפזר את פלט היומן. בנוסף, הצטרפות לגרגולים שונים למפקר אחד, כמו קטלינה ולוגרי Localhost, יכולה לפשט את פתרון הבעיות ולזהות בעיות פריסה.
5. כיצד אוכל לכפות יישומים באמצעות מערכת.החוצה ומערכת.טעות ליומן?
   לאלץ יישומים המשתמשים במערכת.החוצה ומערכת.שגיאה ליציאה, באפשרותך להוסיף את תכונת SwallowOutput להקשר ברירת המחדל.קובץ XML הממוקם ב- $ catalina_base/conf/context.XML. תכונה זו מורה לטומקט למערכת הפניה מחדש.החוצה ומערכת.שגיאה למערכת הרישום, הבטחת שכל הפלט נלכד ביומנים.
6. ניתן להגדיר יישומים באמצעות מסגרת Jul לשימוש ב- Log4J2?
   כן, ניתן להגדיר יישומים המשתמשים במסגרת Java Util Roating). על ידי שינוי משתנה הסביבה של loging_manager ב- SetENV.קובץ sh, אתה יכול להגדיר את הערך ל- “-djava.שימוש.כניסה.מנהל = אורג.אפאצ’י.כניסה.log4j.יולי.Logmanager “. תצורה זו מבטיחה כי יישומים המשתמשים ב- JUL ישתמשו בפורמט Log4J2 ליומנים שלהם במקום בפורמט ברירת המחדל.
7. מה עלי לעשות כדי להשתמש ב- log4j2 עם מגף האביב?
   כדי להשתמש ב- log4j2 עם אתחול האביב, עליך לשלול את תלות היציאה המוגדרת כברירת המחדל של Spring-Boot-Starter-Loging מממצאי המתנע השונים. ניתן לעשות זאת על ידי ציון <תכלול>יחידת סטנדרט-אתחול קפיצי</לא לכלול> בקטע התלות של POM של הפרויקט שלך.קובץ XML. לאחר אי הכללה של תלות ברישום ברירת המחדל, באפשרותך להוסיף את התלות של Spring-Boot-Starter-Log4J2, הכוללת את כל התלות Log4J2 הדרושה ואת ה- SLF4J. אם אינך משתמש באף אחת מתכונות SLF4J, אתה יכול להשתמש בתלות Log4J-Web במקום.
8. כיצד אוכל להתאים אישית את רמות הרישום עבור חבילות ספציפיות באתחול האביב?
   ב- Spring Boot, באפשרותך להתאים אישית את רמות הרישום עבור חבילות ספציפיות על ידי שינוי תצורת הרישום במאפייני היישום או בקובץ YAML. התחביר להתאמה אישית של רמות רישום הוא כניסה.רָמָה.packation_name = רמה. לדוגמה, אם ברצונך לקבוע את רמת הבאגים עבור “org.חבילת “SpringFramework” וחבילת “שלום”, אתה יכול להוסיף את התצורה הבאה: כניסה.רָמָה.אורג.SpringFramework = ניפוי באגים וכן כניסה.רָמָה.שלום = ניפוי באגים.
9. האם ניתן להשבית את באנר האביב באף האביב?
   כן, אפשר להשבית את באנר האביב באף האביב. על ידי הגדרת אביב.רָאשִׁי.מצב באנר מאפיין ל”כאבה “במאפייני היישום או בקובץ YAML, באפשרותך למנוע את ההופעה של הבאנר בפלט הקונסולה או בקבצי יומן.
10. מדוע עלי להשתמש ב- log4j2 במקום ביישום רישום ברירת המחדל ב- Tomcat?
    Log4j2 מציע מספר יתרונות על יישום ברירת המחדל של רישום רישום ב- Tomcat. הוא מספק מגוון רחב יותר של נספחים ואפשרויות רישום, ומאפשר לך להתאים אישית את היומנים שלך בהתאם לצרכים שלך. Log4J2 מציע גם גמישות רבה יותר בגלגול קובץ יומן, מפשט את תצורות נטיית היומן. בנוסף, Log4J2 מבטל את המגבלות של ממשק ה- API של Servlets, כגון חוסר היכולת לשלוט על רמות היומן. בסך הכל, שימוש ב- log4j2 יכול לשפר את חווית הרישום שלך ב- Tomcat.

Apache Tomcat 8

ממשק ה- API של Servlets Rounging מקדים את ה- Java.שימוש.API לרישום המסופק כעת על ידי Java. ככאלה, זה לא מציע לך הרבה אפשרויות. ה.ז., אינך יכול לשלוט ברמות היומן. עם זאת, ניתן לציין כי ביישום Apache Tomcat השיחות ל- ServletContext.יומן (מחרוזת) או Genericservlet.יומן (מחרוזת) נרשם ברמת המידע. השיחות ל- servletcontext.יומן (מחרוזת, ניתן לזרוק) או Genericservlet.יומן (מחרוזת, ניתנת לזרוק) נרשמת ברמה הקשה.

שמירה על יומני יומנים שלך עם Apache Tomcat 9, Log4J2 ו- Spring-Boot

בימים האחרונים ששיחקתי עם Apache Tomcat 9 ו- Log4J2. אתה יכול לתהות מדוע אני רוצה לשנות את הטוב של Tomcat juli הישנה. ובכן, למרות שאני אוהב את הפשטות של התצורה שלה ואת העובדה שג’ולי עובדת, Log4J2 מציע מגוון גדול של מנזנים שהופכים אותו למעניין מאוד. גם אני מעדיף את הדרך כיצד Log4J2 מגלגל את הקבצים, ושומר על השם המקורי ללא מגע (ה.ז. קטלינה.יומן), זה הופך את תצורת בליעת היומן שלי (Logstash) לקצת יותר פשוטה.

Apache Tomcat עם תצורת log4j2

תצורת Apache-Tomcat די פשוטה. אתה רק צריך להוסיף את הספריות Log4J2-API, Log4J2-Core ו- Log4J2-Appserver לסתיו Classat לְהַסִיר ה $ Catalina_base/conf/רישום.נכסים מההתקנה שלך. צעדים אלה מתוארים כאן.

אם אתה משתמש בגרסאות Tomcat לפני 8.5.4 אתה יכול לתהות מה קרה עם ספריות ג’ולי-עמוד מהתוספות המפורסמות של Tomcat? הם כבר לא נחוצים, מכיוון שניתן לחבר את Log4J2 באופן מכוון ל- Java.שימוש.כניסה, היורה! ראה עוד ב- ASF Bugzilla – Bug 58588

תצורת רישום לסביבות ייצור

אם אתה מפעיל גרסת Tomcat האחרונה אתה יכול לראות שהפרק “באמצעות Log4J” של הגרסאות הקודמות אינו עדיין שם. יתכן שיש לך פיתוי של שימוש מחדש ב- Log4J הישן.מאפיינים המשקפים את ברירת המחדל Java.שימוש.כניסה. היזהר, כי התחביר של מאפייני Log4J2 השתנה. עם זה (btw, תודה בריאן מופין. ) תקבל את תצורת ברירת המחדל עם שלושת המפגינים המוגדרים כברירת מחדל של TomCat. לשימוש בייצור אתה יכול לקחת בחשבון את שיקולי ה- Tomcat Docs וההמלצות לגבי רישום מארק תומאס, חבר בוועדת ניהול הפרויקטים של אפאצ’ה טומקט:

1. לַעֲשׂוֹת לאt לְשַׁכְפֵּל הטומקט תְפוּקָה בקטלינה.החוצה (קונסולה) ובקטלינה.יומן, להיפטר מה- Consolehandler
2. לְהוֹסִיף רוֹטַציָה לקטלינה שלך.עֵץ
3. הסרת המנצרים שאינם משומשים מנהל.log and host_manager.עֵץ
4. לְהִצְטַרֵף שונה לוגירים (קטלינה & localhost) ב מוסיף אחד (קטלינה.עֵץ). זה שימושי לאתר בעיות פריסה ביישומים כמו פילטרים שהוגדרו שלא בצדק.

תצורת Log4J2 המסופקת בדוגמה מנסה לעקוב אחר השיקולים הללו. אם אתה מתחיל את שרת Tomcat איתו, וה- Tomcat שלך פועל “בריא”, אתה לא צריך לראות כמעט שום דבר בקונסולה. עם תצורה זו, בקונסולה תוכלו לראות רק דברים קטסטרופלים מאוד כמו Outofmemoryerrors, או dumps חוטים.

מערכת אילוץ.החוצה ומערכת.טעות ליומן

אם אנו פורסים יישומים בשרת שלנו שעדיין משתמשים מערכת.הַחוּצָה ו/או מערכת.לִטְעוֹת, אנו יכולים לאלץ אותם להשתמש בוסיף לוגר שלנו swallowoutput = “true” בברירת המחדל $ Catalina_base/conf/context.XML של השרת. אנו יכולים לעשות זאת גם לכל יישום, ולשנות כל אחד מהמטא-INF/ההקשר שלהם.XML.

רישום java util ו- log4j2

כמו כן, אנו יכולים לקבל יישומים המשתמשים במסגרת Jul הטוב והישן:

01 באפריל, 2019 9:22:05 בבוקר שלום.HellOworldController מידע Sayhello: שלום, יולי.

יישומים אלה ישתמשו בברירת המחדל כניסה.נכסים של ה- JDK שלנו, איזו רמת ברירת המחדל היא מידע ולעצב את ה- SimpleFormatter. אנו יכולים לאלץ אותם להשתמש בפורמט Log4J2 שלנו לשנות את משתנה הסביבה Loging_manager. אתה יכול לעשות את זה להוסיף את ה- setenv.ש קובץ: loging_manager = “-djava.שימוש.כניסה.מנהל = אורג.אפאצ’י.כניסה.log4j.יולי.Logmanager “ עכשיו היומנים שלך ייראו כמו משהו כזה:

Tomcat 2019-04-01 09: 13: 53,524 [Catalina-uutility-1] מידע שלום.Helloworldapplication- שלום, יולי.

זכור את זה אורג.אפאצ’י.כניסה.log4j.יולי.LogManager כלול ב- Log4J-Jul-2.11.2.גשר צנצנת שצריך להוסיף לך Classpath.

אתחול אביב ו- log4j2

אנו רוצים לפרוס ביישום Hello, Rest, המנוחה, המשתמש בתצורת Log4J2 שלנו (מפייס ופורמט) ובו זמנית אנו רוצים לשמור על היכולת של הגדרת עצים שונים. למשל, מאפשר לדמיין שאנחנו רוצים לקבוע את רמת הבאגים לשיעורי העסקים שלנו, לחבילת שלום ולגבי האביב. וגם מאפשר לשתוק את באנר האביב הקלאסי:

כניסה.רָמָה.אורג.SpringFramework = רישום באגים.רָמָה.שלום = באביב באגים.רָאשִׁי.מצב באנר = כבוי

כברירת מחדל המתחילים של אתחול האביב משתמשים ב- Logback, ולכן לשימוש ב- log4j2 עלינו תכלול יחידת סטנדרט-אתחול קפיצי מממצאי המתנע השונים ומוסיפים את Spring-Boot-Starter-Log4J2 תלות. האחרון הזה יכלול את כל התלות של Log4J2 בתוספת SLF4J אלה. יתכן לקרות שאנחנו לא משתמשים באף אחת מתכונות SL4J, כמו הודעות פרמטריות, או כמו במקרה שלנו, אנו רוצים להשתמש ישירות log4j2. אם זה המקרה שלך אתה יכול פשוט להוסיף את log4j-web תלות. אגב זה זה שעליך להוסיף עבור יישומי אינטרנט שאינם אביב, ראה יותר ב”שימוש ב- Log4J ביישומי אינטרנט “.

סיכום

בכניסה זו למדנו כיצד להגדיר את Apache Tomcat כדי לעבוד עם log4j2, כיצד להפוך את ההתקנה הזו מוכנה לייצור וכיצד לפרוס יישום Spring-Boot בשרת Tomcat שלנו שעושה שימוש בתצורה שלנו. אתה יכול למצוא את כל זה במאגר Github זה.

שיהיה לך יום קידוד נחמד!

Apache Tomcat 8

הרישום הפנימי של Apache Tomcat משתמש בג’ולי, שמו של שמו של המזלג של Apache Commons, כברירת מחדל, מקודד קשה להשתמש ב- Java.שימוש.מסגרת רישום. זה מבטיח כי הרישום הפנימי של טומקט וכל רישום יישומי אינטרנט יישארו עצמאיים, גם אם יישום אינטרנט משתמש בכניסה של Apache Commons.

כדי לקבוע את התצורה של Tomcat לשימוש במסגרת רישום אלטרנטיבית לצורך רישום הפנימי שלה, צריך להחליף את יישום הג’ולי המקודד קשה להשתמש ב- Java.שימוש.רישום עם יישום ג’ולי השומר על מנגנון גילוי הכניסה המלא. יישום כזה מסופק כרכיב תוספות. הוראות כיצד להגדיר את התצורה של TomCat לשימוש במסגרת Log4J לצורך רישום הפנימי שלה ניתן למצוא להלן.

יישום אינטרנט הפועל ב- Apache Tomcat יכול:

• השתמש בכל מסגרת רישום לבחירתו.
• השתמש בממשק API של רישום המערכת, Java.שימוש.כניסה .
• השתמש בממשק ה- API של רישום המסופק על ידי מפרט Java Servlets, Javax.Servlet.ServletContext.עֵץ(. )

מסגרות הרישום המשמשות יישומי אינטרנט שונים אינן תלויות. ראה טעינה בכיתה לפרטים נוספים. החריג לכלל זה הוא Java.שימוש.כניסה . אם הוא משמש ישירות או בעקיפין על ידי ספריית הרישום שלך, אלמנטים ממנו ישותפו על פני יישומי אינטרנט מכיוון שהיא נטענת על ידי מטעין המערכת של המערכת.

API של Java Rounging – Java.שימוש.כניסה

לאפצ’י טומקט יש יישום משלה של כמה מרכיבי מפתח של Java.שימוש.API של כניסה. יישום זה נקרא ג’ולי. רכיב המפתח שם הוא יישום LogManager מותאם אישית, המודע ליישומי אינטרנט שונים הפועלים ב- TomCat (ועל מעמיסי הכיתה השונים שלהם). זה תומך בתצורות רישום פרטיות לכל יישום. זה נמסר גם על ידי Tomcat כאשר יישום אינטרנט נפרק מהזיכרון, כך שניתן יהיה לפנות את ההתייחסויות לשיעורים שלו, ומונע דליפות זיכרון.

הג’אווה הזו.שימוש.יישום כניסה מופעל על ידי מתן מאפייני מערכת מסוימים בעת התחלת Java. סקריפטי ההפעלה של Apache Tomcat עושים זאת בשבילך, אבל אם אתה משתמש בכלים שונים כדי להריץ את טומקט (כמו JSVC, או הפעלת טומקט מתוך IDE), עליך לטפל בהם בעצמך.

פרטים נוספים על Java.שימוש.כריתת עצים עשויה להימצא בתיעוד עבור JDK שלך ובדפי Javadoc שלו עבור ה- Java.שימוש.חבילת רישום.

פרטים נוספים על טומקט ג’ולי עשויים להימצא למטה.

API של Servlets Rounging

השיחות ל- Javax.Servlet.ServletContext.עֵץ(. ) כתיבת הודעות יומן מטופלות על ידי רישום טומקט פנימי. הודעות כאלה נרשמות לקטגוריה בשם

אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[$].[$].[$]

רישום זה מבוצע על פי תצורת רישום Tomcat. אינך יכול להחליף אותו ביישום אינטרנט.

ממשק ה- API של Servlets Rounging מקדים את ה- Java.שימוש.API לרישום המסופק כעת על ידי Java. ככאלה, זה לא מציע לך הרבה אפשרויות. ה.ז., אינך יכול לשלוט ברמות היומן. עם זאת, ניתן לציין כי ביישום Apache Tomcat השיחות ל- ServletContext.יומן (מחרוזת) או Genericservlet.יומן (מחרוזת) נרשם ברמת המידע. השיחות ל- servletcontext.יומן (מחרוזת, ניתן לזרוק) או Genericservlet.יומן (מחרוזת, ניתנת לזרוק) נרשמת ברמה הקשה.

לְנַחֵם

בעת הפעלת Tomcat ב- Unixes, פלט הקונסולה מופנה בדרך כלל לקובץ בשם קטלינה.הַחוּצָה . ניתן להגדיר את השם באמצעות משתנה סביבה. (ראה סקריפטים של ההפעלה). כל מה שנכתב למערכת.שגיאה/יציאה תיתפס בקובץ זה. שיכולים לכלול:

• חריגים לא נתפסים שהודפסו על ידי Java.לאנג.קבוצת חוטים.unsuckexception (..)
• אשכולות, אם ביקשת אותם באמצעות אות מערכת

כאשר פועלים כשירות ב- Windows, פלט הקונסולה נתפס ומופנה מחדש, אך שמות הקבצים שונים.

תצורת רישום ברירת המחדל של Apache Tomcat כותבת את אותן ההודעות לקונסולה ולקובץ יומן. זה נהדר בעת שימוש ב- TomCat לפיתוח, אך בדרך כלל אין צורך בייצור.

יישומים ישנים שעדיין משתמשים במערכת.Out או System.ניתן להעלות על ידי שגיאה על ידי הגדרת תכונה של SwallowOutput בהקשר. אם התכונה מוגדרת כ- True, השיחות למערכת.אאוט/שגיאה במהלך עיבוד בקשות יירטו, ותפוקתם תוזן למערכת המשנה של הרישום באמצעות ה- Javax.Servlet.ServletContext.עֵץ(. ) שיחות.
הערה, שתכונת SwallowOutput היא למעשה טריק, ויש לה את המגבלות שלה. זה עובד רק עם שיחות ישירות למערכת.OUT/ERR, ורק במהלך מחזור עיבוד בקשות. יתכן שזה לא יעבוד בשרשורים אחרים שעשויים להיווצר על ידי היישום. לא ניתן להשתמש בו כדי ליירט מסגרות רישום שכתובות עצמן כותבות לזרמי המערכת, שכן אלה מתחילים מוקדם ועשויים לקבל התייחסות ישירה לזרמים לפני שההפעלה מתרחשת.

גישה לרישום

כניסה לגישה היא תכונה קשורה אך שונה, המיושמת כשסתום . הוא משתמש בהיגיון עצמאי כדי לכתוב את קבצי היומן שלו. הדרישה המהותית לרישום גישה היא לטפל בזרם נתונים ורציף גדול עם תקורה נמוכה, ולכן היא משתמשת רק בכריתת רישום של Apache Commons עבור הודעות באגים משלה. גישת יישום זו נמנעת מתצורה נוספת על -תקורה ועלולה להיות מורכבת. אנא עיין בתיעוד השסתומים לקבלת פרטים נוספים על התצורה שלו, כולל פורמטי הדוחות השונים.

באמצעות Java.שימוש.רישום (ברירת מחדל)

יישום ברירת המחדל של Java.שימוש.רישום המסופק ב- JDK מוגבל מכדי להיות שימושי. מגבלת המפתח היא חוסר היכולת לרישום יישומים לכל עברה, שכן התצורה היא PER-VM. כתצה.

ג’ולי תומכת באותם מנגנוני תצורה כמו JDK Java הסטנדרטי.שימוש.רישום, שימוש בגישה פרוגרמטית או קבצי מאפיינים. ההבדל העיקרי הוא שניתן להגדיר קבצי מאפיינים לכל כיתה (המאפשרים תצורת WebApp ידידותית לחידוש מחדש של WebApp), וקבצי המאפיינים תומכים במבנים מורחבים המאפשרים יותר חופש להגדרת מטפלים ולהקצאתם לכתבים.

ג’ולי מופעלת כברירת מחדל, ותומכת בתצורת מעמיס בכיתה, בנוסף ל- Java הגלובלי הרגיל.שימוש.תצורת רישום. המשמעות היא שניתן להגדיר רישום בשכבות הבאות:

• ברחבי העולם. זה נעשה בדרך כלל ב- $/conf/רישום.קובץ מאפיינים. הקובץ מוגדר על ידי ה- Java.שימוש.כניסה.config.מאפיין מערכת קבצים המוגדר על ידי סקריפטים של ההפעלה. אם זה לא ניתן לקרוא או אינו מוגדר, ברירת המחדל היא להשתמש ב- $/lib/רישום.קובץ מאפיינים ב- JRE.
• ביישום האינטרנט. הקובץ יהיה אינטרנט-INF/שיעורים/רישום.נכסים

רישום ברירת המחדל.מאפיינים ב- JRE מציין קונסוללר המנתח את רישום המערכת.לִטְעוֹת. ברירת המחדל של CONF/רישום.מאפיינים ב- Apache Tomcat מוסיפים גם כמה Hardandler S כותבים לקבצים.

סף רמת היומן של המטפל הוא מידע כברירת מחדל וניתן להגדיר אותו באמצעות חמור, אזהרה, מידע, תצורה, עדין, עדין יותר, טוב ביותר או כולם. אתה יכול גם למקד חבילות ספציפיות לאיסוף רישום מהן ולציין רמה.

כדי לאפשר רישום ניפוי באגים עבור חלק מהפנימנטים של טומקט, עליך להגדיר את התצורה של גם את הלוגר / ים המתאימים וגם את המטפל / ים המתאימים להשתמש במיטב או בכל הרמה. ה.ז.:

אורג.אפאצ'י.קטלינה.מוֹשָׁב.רמה = כל ג'אווה.שימוש.כניסה.Consolehandler.רמה = הכל

בעת הפעלת רישום ניפוי באגים, מומלץ להפעיל את ההיקף הצר ביותר האפשרי שכן רישום באגים יכול לייצר כמויות גדולות של מידע.

התצורה המשמשת את ג’ולי זהה לזה שנתמך על ידי Java רגיל.שימוש.כניסה, אך משתמשת בכמה תוספים כדי לאפשר גמישות טובה יותר בהגדרת עצים ומטפלים. ההבדלים העיקריים הם:

• ניתן להוסיף קידומת לשמות מטפלים, כך שניתן יהיה להפעיל מספר מטפלים בכיתה יחידה. קידומת היא מחרוזת שמתחילה בספרה ומסתיימת עם ‘.’. לדוגמה, 22foobar. הוא קידומת תקפה.
• החלפת נכסי מערכת מתבצעת עבור ערכי נכס המכילים $.
• אם משתמשים במטען מחלקה המיישם את ה- org.אפאצ’י.ג’ולי.ממשק WebAppProperties (מטעין כיתת יישומי האינטרנט של Tomcat) ואז החלפת נכסים מבוצעת גם עבור $, $ ו- $ אשר מוחלפים בשם יישום האינטרנט, שם המארח ושם השירות בהתאמה.
• כברירת מחדל, לוגינים לא יאצלו להורה אם יש להם מטפלים משויכים. ניתן לשנות את זה לכל לוגר באמצעות שם logname.נכס useparenthandlers, המקבל ערך בוליאני.
• לוגר השורש יכול להגדיר את מערך המטפלים שלו באמצעות .רכוש מטפלים.
• כברירת מחדל קבצי היומן יישמרו במערכת הקבצים לנצח. ניתן לשנות את זה לכל מטפל באמצעות שם הצילום.רכוש מקסימום. אם הערך שצוין עבור הנכס הוא

ישנם מספר שיעורי יישום נוספים, שניתן להשתמש בהם יחד עם אלה שמספקים Java על ידי Java. הבולט הוא אורג.אפאצ’י.ג’ולי.קובץ Handler .

אורג.אפאצ’י.ג’ולי.קובץ Handler תומך במאגר של היומנים. המאגר אינו מופעל כברירת מחדל. כדי להגדיר אותו, השתמש במאפיין Buffersize של מטפל. הערך של 0 משתמש במאגר ברירת מחדל של המערכת (בדרך כלל ישתמש במאגר 8K). ערך של 0 משתמש בזרם BufferedOutputStream עם הערך המוגדר אך שימו לב כי חוצץ ברירת המחדל של המערכת יוחל גם הוא.

כניסה לדוגמא.קובץ המאפיינים שיוצב ב- $ catalina_base/conf:

מטפלים = 1 קטלינה.אורג.אפאצ'י.ג'ולי.קובץ Handler, \ 2localhost.אורג.אפאצ'י.ג'ולי.FileHandler, \ 3manager.אורג.אפאצ'י.ג'ולי.קובץ Handler, \ Java.שימוש.כניסה.Consolehandler .מטפלים = 1 קטלינה.אורג.אפאצ'י.ג'ולי.FileHandler, Java.שימוש.כניסה.Consolehandler ############################################################## מטפל מאפיינים ספציפיים. # מתאר פרטי תצורה ספציפיים למטפלים. ############################################################ 1 קטלינה.אורג.אפאצ'י.ג'ולי.קובץ Handler.רמה = עדינה 1 קטלינה.אורג.אפאצ'י.ג'ולי.קובץ Handler.ספרייה = $/יומנים 1 קטלינה.אורג.אפאצ'י.ג'ולי.קובץ Handler.קידומת = קטלינה. 2localhost.אורג.אפאצ'י.ג'ולי.קובץ Handler.רמה = עדין 2localhost.אורג.אפאצ'י.ג'ולי.קובץ Handler.ספרייה = $/יומנים 2localhost.אורג.אפאצ'י.ג'ולי.קובץ Handler.קידומת = localhost. 3Manager.אורג.אפאצ'י.ג'ולי.קובץ Handler.רמה = עדינה 3 Manager.אורג.אפאצ'י.ג'ולי.קובץ Handler.ספרייה = $/יומנים 3Manager.אורג.אפאצ'י.ג'ולי.קובץ Handler.קידומת = מנהל. 3Manager.אורג.אפאצ'י.ג'ולי.קובץ Handler.Buffersize = 16384 Java.שימוש.כניסה.Consolehandler.רמה = ג'אווה משובחת.שימוש.כניסה.Consolehandler.Formatter = Java.שימוש.כניסה.SimpleFormatter ############################################################# מתקן מאפיינים ספציפיים. # מספק שליטה נוספת לכל לוגר. ########################################################### אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].רמה = מידע org.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].מטפלים = \ 2localhost.אורג.אפאצ'י.ג'ולי.FileHandler org.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].[/מנהל].רמה = מידע org.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].[/מנהל].מטפלים = \ 3manager.אורג.אפאצ'י.ג'ולי.FileHandler # לדוגמה, קבע את ה- org.אפאצ'י.קטלינה.שימוש.LifeCyclebase Logger כדי לרשום # כל רכיב המרחיב את מצב שינוי ה- LifeCyclebase: #org.אפאצ'י.קטלינה.שימוש.בסיס LifeCycle.רמה = בסדר

כניסה לדוגמא.מאפיינים ליישום האינטרנט של Servlet-Examples שיוצב באינטרנט-INF/שיעורים בתוך יישום האינטרנט:

מטפלים = org.אפאצ'י.ג'ולי.FileHandler, Java.שימוש.כניסה.Consolehandler ############################################################## מטפל מאפיינים ספציפיים. # מתאר פרטי תצורה ספציפיים למטפלים. ########################################################### אורג.אפאצ'י.ג'ולי.קובץ Handler.רמה = אורג משובח.אפאצ'י.ג'ולי.קובץ Handler.Directory = $/logs org.אפאצ'י.ג'ולי.קובץ Handler.קידומת = $. ג'אווה.שימוש.כניסה.Consolehandler.רמה = ג'אווה משובחת.שימוש.כניסה.Consolehandler.Formatter = Java.שימוש.כניסה.SimpleFormatter

הפניות לתיעוד

עיין במשאבים הבאים למידע נוסף:

• אפאצ’י טומקט ג’וואדוק לאורג.אפאצ’י.חבילת ג’ולי.
• Oracle Java 6 Javadoc עבור ה- Java.שימוש.חבילת רישום.

שיקולים לשימוש בייצור

יתכן שתרצה לשים לב לדברים הבאים:

• שקול להסיר את Consolehandler מהתצורה. כברירת מחדל (בזכות ה- .הגדרת מטפלים) רישום רישום מועבר גם למושב קובץ וגם לקונסולהולר . הפלט של האחרון נלכד בדרך כלל לקובץ, כמו קטלינה.הַחוּצָה . כך אתה בסופו של דבר עם שני עותקים של אותן הודעות.
• שקול להסיר את Handler S עבור היישומים שאינך משתמש בהם. ה.ז., זה למנהל מארח .
• המטפלים כברירת מחדל משתמשים בקידוד ברירת המחדל של המערכת כדי לכתוב את קבצי היומן. ניתן להגדיר אותו עם נכס קידוד. ראה Javadoc לפרטים.
• שקול להגדיר יומן גישה.

באמצעות log4j

קטע זה מסביר כיצד להגדיר את התצורה של TOMCAT לשימוש ב- LOG4J ולא ב- Java.שימוש.כניסה לכל הכרית הפנימית של טומקט.

הערה: יש צורך בשלבים המתוארים בסעיף זה כאשר ברצונך להגדיר מחדש את Tomcat כדי להשתמש ב- Apache Log4J לצורך רישום משלו. הצעדים הללו הם לֹא נחוץ אם אתה רק רוצה להשתמש ב- Log4J ביישום האינטרנט שלך. – במקרה כזה, פשוט שים את Log4J.JAR ו- LOG4J.מאפיינים ל- Web-INF/LIB ו- Web-INF/שיעורים של יישום האינטרנט שלך.

הצעדים הבאים מתארים את התצורה של Log4J לפלט את הרישום הפנימי של Tomcat.

1. צור קובץ בשם log4j.מאפיינים עם התוכן הבא ושומרים אותו ב- $ catalina_base/lib

 log4j.RootLogger = מידע, קטלינה # הגדר את כל המוסיפים log4j.מפעיל.קטלינה = אורג.אפאצ'י.log4j.Dailyrollingfileappender log4j.מפעיל.קטלינה.קובץ = $/logs/catalina log4j.מפעיל.קטלינה.הוספה = true log4j.מפעיל.קטלינה.קידוד = UTF-8 # ROLL-Over היומן פעם ביום log4j.מפעיל.קטלינה.DatePattern = '.'yyyy-mm-dd'.log 'log4j.מפעיל.קטלינה.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.קטלינה.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n log4j.מפעיל.Localhost = org.אפאצ'י.log4j.Dailyrollingfileappender log4j.מפעיל.מארח מקומי.קובץ = $/יומנים/localhost log4j.מפעיל.מארח מקומי.הוספה = true log4j.מפעיל.מארח מקומי.קידוד = utf-8 log4j.מפעיל.מארח מקומי.DatePattern = '.'yyyy-mm-dd'.log 'log4j.מפעיל.מארח מקומי.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.מארח מקומי.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n log4j.מפעיל.מנהל = אורג.אפאצ'י.log4j.Dailyrollingfileappender log4j.מפעיל.מנהל.קובץ = $/יומנים/מנהל log4j.מפעיל.מנהל.הוספה = true log4j.מפעיל.מנהל.קידוד = utf-8 log4j.מפעיל.מנהל.DatePattern = '.'yyyy-mm-dd'.log 'log4j.מפעיל.מנהל.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.מנהל.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n log4j.מפעיל.מארח-מנהל = אורג.אפאצ'י.log4j.Dailyrollingfileappender log4j.מפעיל.מנהל מארח.קובץ = $/יומנים/מארח-מנהל log4j.מפעיל.מנהל מארח.הוספה = true log4j.מפעיל.מנהל מארח.קידוד = utf-8 log4j.מפעיל.מנהל מארח.DatePattern = '.'yyyy-mm-dd'.log 'log4j.מפעיל.מנהל מארח.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.מנהל מארח.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n log4j.מפעיל.CONSOLE = org.אפאצ'י.log4j.ConsoloAppender log4J.מפעיל.לְנַחֵם.קידוד = utf-8 log4j.מפעיל.לְנַחֵם.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.לְנַחֵם.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n # הגדר אילו יומנים יושבים אליהם הנספחים log4j.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[localhost] = מידע, localhost log4j.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].[/מנהל] = \ מידע, מנהל log4j.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].[/מארח-מנהל] = \ מידע, מארח-מנהל

1. הורד log4j (Tomcat דורש v1.2.איקס).
2. הורד או בנה את Tomcat-Juli.JAR ו- Tomcat-Juli-Havapters.צנצנת הזמינה כרכיב “תוספות” עבור Tomcat. עיין בתיעוד רכיבים נוספים לפרטים. טומקט-ג’ולי זה.הצנצנת שונה מהברירת המחדל. הוא מכיל את יישום הכניסה המלא של Apache Commons ולכן הוא מסוגל לגלות נוכחות של log4j ולהגדיר את עצמו.
3. אם ברצונך לקבוע את התצורה של TOMCAT להשתמש ב- LOG4J ברחבי העולם:
   • שים את Log4J.JAR ו- Tomcat-Juli-Havapters.צנצנת מ”אקסות “ל- $ catalina_home/lib .
   • החלף $ catalina_home/bin/tomcat-juli.צנצנת עם טומקט-ג’ולי.צנצנת מתוך “תוספות”.
4. אם אתה מפעיל את Tomcat עם $ Catalina_home נפרד ו- $ catalina_base ורוצה להגדיר להשתמש ב- Log4J ב Sinap Catalina_base יחיד בלבד:
   • צור $ catalina_base/bin ו- $ catalina_base/lib אם הם לא קיימים.
   • שים את Log4J.JAR ו- Tomcat-Juli-Havapters.צנצנת מ- “תוספות” ל- $ catalina_base/lib
   • שים את טומקט-ג’ולי.צנצנת מ”אקסות “כ- $ catalina_base/bin/tomcat-juli.קַנקַן
   • אם אתה פועל עם מנהל אבטחה, תצטרך לערוך את $ catalina_base/conf/catalina.קובץ מדיניות כדי להתאים אותו לשימוש בעותק שונה של Tomcat-Juli.קַנקַן.

הערה: זה עובד מכיוון שספריות, אם הן קיימות ב- $ catalina_base, נטענות בעדיפות על אותה ספריה ב- $ catalina_home .

הערה: טומקט-ג’ולי.הצנצנת טעונה מ- $ catalina_base /bin לא $ catalina_base /lib מכיוון שהיא נטענת כחלק מתהליך רצועת האתחול וכל מחלקות ה- Bootstrap נטענות מפח.

תצורת log4j זו משקפת את Java ברירת המחדל.שימוש.הגדרת רישום שנשלחת עם Tomcat: גם האפליקציות של המנהל וגם המנהלים מארחים מקבלים קובץ יומן בודד, וכל השאר הולך ל”קטלינה.קובץ יומן יומן “. כל קובץ מגולגל פעם אחת ביום.

אתה יכול (וצריך) להיות בררן יותר באילו חבילות לכלול בכריתת עצים. Tomcat מגדיר יומנים לפי שמות מנוע ומארחים. לדוגמה, ליומן Localhost מפורט יותר של קטלינה, הוסף את זה לסוף ה- Log4J.מאפיינים לעיל. שים לב שיש בעיות ידועות בשימוש בכנס שמות זה (עם סוגריים מרובעים) בקבצי תצורה מבוססי Log4J XML, ולכן אנו ממליצים להשתמש בקובץ מאפיינים כמתואר עד שגירסה עתידית של Log4J מאפשרת אמנה זו.

log4j.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[localhost] = Debug log4J.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.Core = Debug log4J.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.הפעלה = ניפוי באגים

הוזהרו: רמת ניפוי באגים תפיק מגה -בייט של כריתת עצים והפעלה איטית של טומקט. יש להשתמש ברמה זו במשורה בעת ניפוי באגים של פעולות טומקט פנימיות.

יישומי האינטרנט שלך צריכים בהחלט להשתמש בתצורת Log4J שלהם. זה תקף עם התצורה לעיל. היית מציב log4j דומה.קובץ מאפיינים בספריית ה- Web-INF/Class של יישום האינטרנט שלך ו- Log4JX.y.z.צנצנת לאינטרנט- INF/LIB. ואז ציין את רישום רמת החבילה שלך. זוהי מערך בסיסי של Log4J שאכן * לא * דורש רכיבה של Commons, ועליך להתייעץ עם תיעוד Log4J לקבלת אפשרויות נוספות. דף זה מיועד רק כמדריך לניתוח אתחול.

• זה חושף ספריות Log4J ליישומי האינטרנט באמצעות מעמיס הכיתה המשותף. ראה תיעוד טעינה בכיתה לפרטים. בגלל זה, יישומי האינטרנט והספריות המשתמשים בספריית רישום Apache Common.
• הג’אווה.שימוש.API של רישום כניסה עדיין זמין עבור אותם יישומי אינטרנט שמשתמשים בו ישירות. ה- $/conf/רישום.קובץ המאפיינים מופנה עדיין על ידי סקריפטים של Tomcat Startup. למידע נוסף, עיין בסעיפי המשנה של המבוא לדף זה. הסרת $/conf/רישום.קובץ המאפיינים, המוזכר כאחד הצעדים לעיל, גורם ל- Java.שימוש.רישום ל- Fallback לתצורת ברירת המחדל של ה- JRE, שהוא להשתמש ב- Consolehandler ולכן לא ליצור קבצי יומן סטנדרטיים. עליך לאשר שכל קבצי היומן שלך נוצרים על ידי log4j לפני השבתת המנגנון הסטנדרטי.
• ה שסתום יומן גישה וכן Orderaccesslogvalve השתמש ביישום כריתת עצים עצמאי משלהם, כך שהם לא ניתן להגדיר את התצורה לשימוש ב- log4j. עיין בשסתומים לקבלת פרטי תצורה ספציפיים.

הערות

הודעה: קטע הערות זה אוסף את הצעותיך לשיפור התיעוד עבור Apache Tomcat.

אם יש לך בעיות וזקוק לעזרה, קרא את דף העזרה ושאל את שאלתך ברשימת התפוצה של Tomcat-Suers. אל תשאל שאלות כאלה כאן. זה לא קטע שאלות ותשובות.

מערכת התגובות של Apache מוסברת כאן. ניתן להסיר הערות על ידי המנחים שלנו אם הם מיושמים או נחשבים לא חוקיים/מחוץ לשינוי.

תצורת Tomcat Log4J שלב אחר שלב

ספריית רישום של ג’ולי ותצורת התצורה זמינים כברירת מחדל עם מתקין Tomcat. על מנת להשתמש ב- Log4J לצורך רישום פנימי של TomCat במקום, תצטרך להחליף את ספריית ג’ולי הקיימת בשילוב Log4J-Juli.

1. מחק את ספריית ג’ולי קיימת (Catalina_Home/Bin/Tomcat-Juli.קובץ צנצנת) וקובץ התצורה הקיים של Tomcat Java (.נכסים).

2. הורד את ספריית Juli Log4J Tomcat (Tomcat-Juli.צנצנת) מההורדות של טומקט’ קטע תוספות (http: // tomcat.אפאצ’י.org/הורדה -70.CGI). מקם את הקובץ שהורד לספריית Catalina_Home/Bin.

3. הורד את ספריית מתאמי Tomcat Juli (Tomcat-Juli-Happers.צנצנת) מההורדות של טומקט’ קטע תוספות. מקם קובץ זה בספריית Catalina_Home/Lib.

4. הורד את Log4J (גרסה 1.2 ואילך), והניח את קובץ הספרייה שהורדת לספריית Catalina_Home/Lib.

5. צור את קובץ התצורה של Log4J במקום הבא: catalina_home/lib/log4j.נכסים. בדוק להלן תצורת log4j בהתאמה לתצורת רישום ברירת המחדל של Java Java.

6. הפעל מחדש את טומקט.

קובץ תצורה של Log4J תואם את הגדרות רישום ברירת המחדל של TomCat:

log4j.RootLogger = מידע, קטלינה # הגדר את כל המוסיפים log4j.מפעיל.קטלינה = אורג.אפאצ'י.log4j.Dailyrollingfileappender log4j.מפעיל.קטלינה.קובץ = $/יומנים/קטלינה. log4j.מפעיל.קטלינה.הוספה = true log4j.מפעיל.קטלינה.קידוד = UTF-8 # ROLL-Over היומן פעם ביום log4j.מפעיל.קטלינה.DatePattern = '.'yyyy-mm-dd'.log 'log4j.מפעיל.קטלינה.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.קטלינה.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n log4j.מפעיל.Localhost = org.אפאצ'י.log4j.Dailyrollingfileappender log4j.מפעיל.מארח מקומי.קובץ = $/יומנים/localhost. log4j.מפעיל.מארח מקומי.הוספה = true log4j.מפעיל.מארח מקומי.קידוד = utf-8 log4j.מפעיל.מארח מקומי.DatePattern = '.'yyyy-mm-dd'.log 'log4j.מפעיל.מארח מקומי.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.מארח מקומי.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n log4j.מפעיל.מנהל = אורג.אפאצ'י.log4j.Dailyrollingfileappender log4j.מפעיל.מנהל.קובץ = $/יומנים/מנהל. log4j.מפעיל.מנהל.הוספה = true log4j.מפעיל.מנהל.קידוד = utf-8 log4j.מפעיל.מנהל.DatePattern = '.'yyyy-mm-dd'.log 'log4j.מפעיל.מנהל.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.מנהל.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n log4j.מפעיל.מארח-מנהל = אורג.אפאצ'י.log4j.Dailyrollingfileappender log4j.מפעיל.מנהל מארח.קובץ = $/יומנים/מנהל מארח. log4j.מפעיל.מנהל מארח.הוספה = true log4j.מפעיל.מנהל מארח.קידוד = utf-8 log4j.מפעיל.מנהל מארח.DatePattern = '.'yyyy-mm-dd'.log 'log4j.מפעיל.מנהל מארח.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.מנהל מארח.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n log4j.מפעיל.CONSOLE = org.אפאצ'י.log4j.ConsoloAppender log4J.מפעיל.לְנַחֵם.קידוד = utf-8 log4j.מפעיל.לְנַחֵם.פריסה = org.אפאצ'י.log4j.DefferenceLayout log4J.מפעיל.לְנַחֵם.מַעֲרָך.המרה pattern = %d [ %t] %-5p %c- %m %n # הגדר אילו יומנים יושבים אליהם הנספחים log4j.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[localhost] = מידע, localhost log4j.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].[/מנהל] = מידע, מנהל Log4J.כּוֹרֵת עֵצִים.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].[/מארח-מנהל] = מידע, מנהל מארח

Tomcat ישתמש כעת ב- Log4J עבור כל רישום הפנימי.

כדי להבין את התצורה לעיל בדוק את הפרטים למטה כדי לקבל תצוגה ברורה

רכיבי תצורה עבור log4j’s defferenceout

%D תאריך כניסה. באפשרותך לציין דפוס תאריך בסוגריים מתולתלים ( %D) %c שם מחלקה מוסמך לחלוטין (שימוש %c כדי להדפיס רק שם מחלקה פשוט) %t שם השרשור בו התרחש רישום %שם f שם קובץ של אירוע הרישום %P רמת רישום %מספר קו מספר של אירוע הכניסה %M הודעת האמת %N

להלן כמה מדוגמאות התבניות וערכי היומן שהם יצרו:

%d [ %t] %-5p %c- %m %n 2011-09-07 14: 07: 41,509 [Main] מידע myntclass-ביצוע.

%5p [%t] (%f:%l) -%m%n info [main] (myntclass.ג'אווה: 12) - ביצוע.

למידע נוסף על Checkout Log4J להלן קישור:

http: // רישום.אפאצ'י.org/log4j/index.html

במקרה של כל © זכויות יוצרים או חסרים בעיית נקודות זכות אנא בדוק את דף זכויות היוצרים לקבלת החלטות מהירות יותר.

כמו המאמר. שתף את זה.

• לחץ כדי להדפיס (נפתח בחלון חדש)
• לחץ כדי לדוא”ל קישור לחבר (פותח בחלון חדש)
• לחץ לשיתוף ב- Reddit (נפתח בחלון חדש)
• לחץ לשיתוף ב- Pinterest (נפתח בחלון חדש)
• לחץ כדי לשתף בלינקדאין (נפתח בחלון חדש)
• לחץ לשיתוף ב- WhatsApp (נפתח בחלון חדש)
• לחץ לשיתוף בטוויטר (נפתח בחלון חדש)
• לחץ לשיתוף בפייסבוק (נפתח בחלון חדש)
• לחץ כדי לשתף ב- Tumblr (נפתח בחלון חדש)
• לחץ לשיתוף בכיס (נפתח בחלון חדש)
• לחץ לשיתוף בטלגרם (נפתח בחלון חדש)
• לחץ לשיתוף ב- Skype (נפתח בחלון חדש)

כיצד לבצע: קבע את התצורה של Tomcat 9 כדי לרשום באמצעות log4j2

איך אתה יכול להפנות מחדש את הרישום הפנימי של Tomcat 9 (קטלינה ו- localhost) ל- log4j2? אמנם ישנם מדריכים רבים הזמינים לגרסאות ישנות יותר של Tomcat ו- Log4J, אך לא יכולתי למצוא שום דבר “שלם” לגבי Tomcat 9 ו- Log4J2; התיעוד Apache Tomcat 9 מצביע על “ההוראות המסופקות על ידי מסגרת הרישום האלטרנטיבית”, ולתיעוד Apache Log4J (שמות צנצנות ב -2. מְתוּקָן):

1. יצירת קבוצה של ספריות בבית קטלינה בשם Log4J2/Lib ו- Log4J2/Conf.
2. הצבת log4j-api-2.12.0.צנצנת, log4j-core-2.12.0.צנצנת, ו- log4j-appserver-2.12.0.צנצנת בספריית Log4J2/Lib.
3. יצירת קובץ בשם log4j2-tomcat.XML, LOG4J2-TOMCAT.JSON, Log4J2-Tomcat.YAML, LOG4J2-TOMCAT.YML, או Log4J2-Tomcat.מאפיינים בספריית Log4J2/CONF.
4. צור או שנה את setenv.sh בספריית Bin Tomcat לכלול ClassPath = $ catalina_home/log4j2/lib/*: $ catalina_home/log4j2/conf

אבל מה להכניס את Log4J2-Tomcat ההוא.* קובץ config?

שאל 5 ביולי 2019 בשעה 12:33

682 1 תג זהב 6 6 6 תגי כסף 17 17 תגי ברונזה

2 תשובות 2

מצאתי קובץ מאפייני לדוגמא בתיעוד Apache Tomcat 7, אך מכיוון שזה נועד לשימוש עם log4j 1.x, הייתי צריך להתאים אותו לתחביר הקובץ Log4J2. זו התוצאה:

# 'סטטוס' מתייחס להודעות יומן מ- log4j2 עצמו Monitorinterval = 30 סטטוס = נכס מזהיר.Loglevel.קטלינה = נכס מידע.Loglevel.localhost = נכס מידע.PayoutPattern.קטלינה = %d %-5p [ %t] %-22.22c %m %n נכס.PayoutPattern.localhost = %d %-5p [ %t] %-30.30c %m %n # רול-מעבר ליומנים פעם בחודש באמצעות crontriggerpolicy. תכונה.SifedatePattern.קטלינה = %D.SifedatePattern.localhost = %D.crontriggerschedule.קטלינה = 0 0 0 1 1 * ? תכונה.crontriggerschedule.localhost = 0 0 0 1 * ? ## מכנים # n.ב.: - אין צורך לציין 'נספחים = קטלינה, localhost, קונסולה' # מכיוון שמזהים אלה אינם מכילים '.' דמויות. # - המזהים של רכיבי המשנה 'מדיניות' ו- 'cron' נבחרים באופן שרירותי; הסוג בפועל מוגדר באמצעות תכונה 'סוג'. # - 'DirectWriterolloverStrategy' משמש באופן אוטומטי מכיוון שלא צוין 'שם קובץ'. מפעיל.קטלינה.Type = RollingFile Appender.קטלינה.שם = RollingFile-Catalina Appender.קטלינה.FilePattern = $/יומנים/קטלינה.$.Log Appender.קטלינה.מַעֲרָך.סוג = DeffissLayout Appender.קטלינה.מַעֲרָך.דפוס = $ מפייס.קטלינה.מדיניות.סוג = מדיניות מונה.קטלינה.מדיניות.קרון.סוג = crontriggeringpolicy appender.קטלינה.מדיניות.קרון.לוח הזמנים = $ מפגרים.קטלינה.מדיניות.קרון.evaluateOnstartup = Appender True.קטלינה.FilePermissions = RW-R ----- מפייס.קטלינה.FileOneer = Tomcat Appender.קטלינה.קבוצת קובץ = ADM Appender.מארח מקומי.Type = RollingFile Appender.מארח מקומי.שם = RollingFile-Localhost Appender.מארח מקומי.FilePattern = $/יומנים/localhost.$.Log Appender.מארח מקומי.מַעֲרָך.סוג = DeffissLayout Appender.מארח מקומי.מַעֲרָך.דפוס = $ מפייס.מארח מקומי.מדיניות.סוג = מדיניות מונה.מארח מקומי.מדיניות.קרון.סוג = crontriggeringpolicy appender.מארח מקומי.מדיניות.קרון.לוח הזמנים = $ מפגרים.מארח מקומי.מדיניות.קרון.evaluateOnstartup = Appender True.מארח מקומי.FilePermissions = RW-R ----- מפייס.מארח מקומי.FileOneer = Tomcat Appender.מארח מקומי.קבוצת FileGroup = ADM # ביטול סימון אם ברצונך להמשיך לרשום לקטלינה.לאחר log4j2 משתלט. #Appender.לְנַחֵם.type = Console #Appender.לְנַחֵם.name = stdout #appender.לְנַחֵם.מַעֲרָך.type = defisslayout ## הגדר אילו לוגני יומן אליהם הנספחים RootLogger.רמה = $ rootlogger.anpenderref.קטלינה.ref = RollingFile-Catalina #Rootlogger.anpenderref.סטדאוט.ref = stdout # כאן, המזהה אכן מכיל '.'תווים, לכן עלינו לציין את הרשימה. Loggers = org.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].לוגר [LocalHost].אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].שם = Localhost Logger.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].LEVEL = $ LOGGER.אורג.אפאצ'י.קטלינה.הליבה.ContainerBase.[קטלינה].[מארח מקומי].anpenderref.מארח מקומי.ref = RollingFile-Localhost 

הסיבה העיקרית לי להשתמש ב- Log4J2 הייתה להיות מסוגלת לקבל סיבוב יומן חודשי, אבל אתה יכול בקלות להתאים את כל מה שאתה רוצה, אפילו בלי להפעיל מחדש את Tomcat.