להב - ספר הדרכה שלם
1. סקירה כללית
להב היא מסגרת זעירה של Java 8+ MVC, שנבנתה מאפס עם כמה יעדים ברורים: להיות עצמאי, פרודוקטיבי, אלגנטי, אינטואיטיבי ומהיר במיוחד.
מסגרות רבות ושונות היוו השראה לעיצובו: ה- Express של Node, הבקבוק של פייתון והמקרון / מרטיני של Golang.
להב הוא גם חלק מפרויקט גדול יותר שאפתני, Let's Blade. הוא כולל אוסף הטרוגני של ספריות קטנות אחרות, החל מדור Captcha וכלה בהמרת JSON, מתבניות לחיבור פשוט של בסיס נתונים.
עם זאת, במדריך זה נתמקד ב- MVC בלבד.
2. תחילת העבודה
ראשית, בואו ניצור פרויקט ריק של Maven ונוסיף את התלות האחרונה ב- Blade MVC ב pom.xml:
com.bladejava blade-mvc 2.0.14. שחרור 2.1. איגוד יישום להב
מכיוון שהאפליקציה שלנו תיווצר כ- JAR, לא יהיה לה / lib כמו במלחמה. כתוצאה מכך, הדבר מוביל אותנו לבעיה כיצד לספק את להב- mvc JAR, יחד עם כל JAR אחר שנצטרך, לאפליקציה שלנו.
הדרכים השונות לעשות זאת, כל אחת עם יתרונות וחסרונות, מוסברות במדריך כיצד ליצור צנצנת הפעלה עם Maven.
לצורך הפשטות, נשתמש ב- תוסף הרכבה של Maven טֶכנִיקָה, שמתפוצץ כל JAR המיובא ב pom.xml ובהמשך מצרף את כל השיעורים יחד ב- JAR יחיד.
2.2. הפעלת יישום להב
להב מבוסס על נטי, מסגרת יישומי רשת אסינכרונית המונעת על ידי אירועים. לכן, כדי להריץ את היישום מבוסס הלהב שלנו איננו זקוקים לשום יישומים חיצוני או למיכל Servlet; ה- JRE יספיק:
java -jar target / sample-blade-app.jar לאחר מכן, היישום יהיה נגיש בכתובת // localhost: 9000 כתובת אתר.
3. הבנת האדריכלות
האדריכלות של להב היא מאוד פשוטה:
זה תמיד עוקב אחר אותו מעגל חיים:
- נטי מקבלת בקשה
- תוכנת התיווך מבוצעת (אופציונלי)
- WebHooks מבוצעים (אופציונלי)
- ניתוב מתבצע
- התגובה נשלחת ללקוח
- לנקות
נחקור את הפונקציות לעיל בסעיפים הבאים.
4. ניתוב
בקיצור, ניתוב ב- MVC הוא המנגנון המשמש ליצירת כריכה בין כתובת URL לבקר.
להב מספק שני סוגים של מסלולים: מסלול בסיסי ומסומן.
4.1. מסלולים בסיסיים
מסלולים בסיסיים מיועדים לתוכנות קטנות מאוד, כמו שירותי מיקרו או יישומי אינטרנט מינימליים:
Blade.of () .get ("/ basic-routes-example", ctx -> ctx.text ("GET called")) .post ("/ basic-routes-example", ctx -> ctx.text (" POST נקרא ")) .put (" / basic-routes-example ", ctx -> ctx.text (" PUT called ")) .delete (" / basic-routes-example ", ctx -> ctx.text (" DELETE נקרא ")). Start (App.class, args); שם השיטה בה משתמשים לרישום מסלול תואם לפועל ה- HTTP שישמש להעברת הבקשה. פשוטו כמשמעו.
במקרה זה, אנו מחזירים טקסט, אך אנו יכולים גם לעבד דפים, כפי שנראה בהמשך במדריך זה.
4.2. מסלולים מוסברים
בהחלט, למקרי שימוש מציאותיים יותר אנו יכולים להגדיר את כל המסלולים הדרושים לנו באמצעות הערות. עלינו להשתמש בכיתות נפרדות לשם כך.
קודם כל, עלינו ליצור בקר דרך ה- @נָתִיב ביאור, שייסרק על ידי להב במהלך ההפעלה.
לאחר מכן עלינו להשתמש בהערת המסלול הקשורה לשיטת HTTP אותה אנו רוצים ליירט:
@Path class class RouteExampleController {@GetRoute ("/ routes-example") public String get () {return "get.html"; } @ PostRoute ("/ routes-example") פוסט מחרוזת ציבורי () {return "post.html"; } @ PutRoute ("/ routes-example") put מחרוזת ציבורי () {return "put.html"; } @ DeleteRoute ("/ routes-example") מחיקת מחרוזת ציבורית () {return "delete.html"; }} אנחנו יכולים גם להשתמש בפשטות @מַסלוּל ביאור וציין את שיטת HTTP כפרמטר:
@Route (value = "/ דוגמה אחרת למסלול", שיטה = HttpMethod.GET) ציבורי מחרוזת anotherGet () {להחזיר "get.html"; } מצד שני, אם לא נשים פרמטר מתודה כלשהו, המסלול יירט כל קריאת HTTP לכתובת אתר זו, לא משנה הפועל.
4.3. הזרקת פרמטר
ישנן מספר דרכים להעביר פרמטרים למסלולים שלנו. בואו לחקור אותם עם כמה דוגמאות מהתיעוד.
- פרמטר טופס:
@GetRoute ("/ home") בטל ציבור formParam (@Param שם מחרוזת) {System.out.println ("שם:" + שם); } - פרמטר רגוע:
@GetRoute ("/ users /: uid") public public restfulParam (@PathParam Integer uid) {System.out.println ("uid:" + uid); } - פרמטר להעלאת קבצים:
@PostRoute ("/ העלאה") file public fileParam (@MultipartParam FileItem fileItem) {בייט [] file = fileItem.getData (); } - פרמטר כותרת:
@GetRoute ("/ header") headerParam פומבי (@HeaderParam מחרוזת) {System.out.println ("מפנה:" + מפנה); } - פרמטר קובצי cookie:
@GetRoute ("/ cookie") cookieParam חלל ציבורי (@CookieParam מחרוזת myCookie) {System.out.println ("myCookie:" + myCookie); } - פרמטר גוף:
@PostRoute ("/ bodyParam") body void publicParam (משתמש משתמש @BodyParam) {System.out.println ("משתמש:" + user.toString ()); } - פרמטר אובייקט ערך, הנקרא על ידי שליחת התכונות שלו למסלול:
@PostRoute ("/ voParam") חלל ציבורי voParam (משתמש משתמש @Param) {System.out.println ("משתמש:" + user.toString ()); } 5. משאבים סטטיים
להב יכול גם לשרת משאבים סטטיים במידת הצורך, פשוט על ידי הצבתם בתוך ה- / משאבים / סטטי תיקיה.
לדוגמא, ה src / main / resources / static / app.css יהיה זמין ב //localhost:9000/static/app.css.
5.1. התאמה אישית של הנתיבים
אנו יכולים לכוון התנהגות זו על ידי הוספת נתיב סטטי אחד או יותר באופן פרוגרמטי:
blade.addStatics ("/ custom-static"); את אותה התוצאה ניתן להשיג באמצעות תצורה, על ידי עריכת הקובץ src / main / resources / application.properties:
mvc.statics = / custom-static 5.2. הפעלת רישום משאבים
אנו יכולים לאפשר רישום של תוכן של תיקיה סטטית, תכונה שבוטלה כברירת מחדל מסיבות אבטחה:
blade.showFileList (נכון); או בתצורה:
mvc.statics.show-list = נכון כעת אנו יכולים לפתוח את // localhost: 9000 / custom-static / כדי להציג את תוכן התיקיה.
5.3. שימוש ב- WebJars
כפי שנראה במדריך מבוא ל- WebJars, משאבים סטטיים ארוזים כ- JAR הם גם אפשרות קיימא.
להב חושף אותם אוטומטית תחת / webjars / נָתִיב.
לדוגמה, בואו נייבא את Bootstrap ב pom.xml:
org.webjars bootstrap 4.2.1 כתוצאה מכך, זה יהיה זמין תחת //localhost:9000/webjars/bootstrap/4.2.1/css/bootstrap.css
6. בקשת HTTP
מאז להב אינו מבוסס על מפרט Servlet, אובייקטים כמו הממשק שלו בַּקָשָׁה והמעמד שלה HttpRequest שונים במקצת מאלה שהתרגלנו אליהם.
6.1. פרמטרים של טופס
בעת קריאת פרמטרים של טפסים, Blade עושה שימוש נהדר בתוכנות Java אופציונאלי בתוצאות שיטות השאילתה (כל השיטות להלן מחזירות אופציונאלי לְהִתְנַגֵד):
- שאילתה (שם מחרוזת)
- queryInt (שם מחרוזת)
- queryLong (שם מחרוזת)
- queryDouble (שם מחרוזת)
הם זמינים גם עם ערך חיסרון:
- שאילתת מחרוזת (שם מחרוזת, מחרוזת defaultValue)
- int queryInt (שם מחרוזת, int defaultValue)
- שאילתה ארוכה (שם מחרוזת, ערך ברירת מחדל ארוך)
- שאילתה כפולה כפול (שם מחרוזת, ערך ברירת מחדל כפול)
אנו יכולים לקרוא פרמטר טופס דרך המאפיין האוטומטי:
@PostRoute ("/ save") formParams בטל ציבורי (שם משתמש מחרוזת @Param) {// ...} או מה- בַּקָשָׁה לְהִתְנַגֵד:
@PostRoute ("/ שמור") form בטל ציבוריParams (בקשת בקשה) {מחרוזת username = request.query ("שם משתמש", "Baeldung"); } 6.2. נתוני JSON
בואו נסתכל כעת כיצד ניתן למפות אובייקט JSON ל- POJO:
תלתל -X POST // localhost: 9000 / משתמשים -H 'סוג תוכן: יישום / json' \ -d '{"name": "Baeldung", "site": "baeldung.com"}' POJO (מסומן עם Lombok לקריאות):
משתמש בכיתה ציבורית {@ Getter @Setter פרטי מחרוזת; אתר מחרוזת פרטי @ Getter @ Set; } שוב, הערך זמין כנכס שהוזרק:
@PostRoute ("/ משתמשים") bodyParams הריק ציבורי (משתמש משתמש @BodyParam) {// ...} ומן ה בַּקָשָׁה:
@PostRoute ("/ משתמשים") bodyParams ללא ריק (בקשת בקשה) {String bodyString = request.bodyToString (); } 6.3. פרמטרים RESTful
פרמטרים של RESTFul בכתובות אתרים יפות כמו localhost: 9000 / משתמש / 42 הם גם אזרחים מהשורה הראשונה:
@GetRoute ("/ user /: id") משתמש ריק ציבורי (@PathParam מספר שלם) {// ...} כרגיל, אנו יכולים להסתמך על ה- בַּקָשָׁה חפץ בעת הצורך:
@GetRoute ("/ user") משתמש בטל ציבורי (בקשת בקשה) {Integer id = request.pathInt ("id"); } ברור שאותה שיטה זמינה עבור ארוך ו חוּט סוגים מדי.
6.4. מיזוג נתונים
להב תומך בפרמטרים מחייבים JSON וטופס ומחבר אותם לאובייקט המודל באופן אוטומטי:
@PostRoute ("/ משתמשים") bodyParams ריק / ציבורי (משתמש משתמש) {} 6.5. מאפייני בקשה והפעלה
ה- API לקריאה וכתיבה של אובייקטים ב- בַּקָשָׁה ו מוֹשָׁב הם צלולים.
השיטות עם שני פרמטרים, המייצגות מפתח וערך, הן המוטציות בהן אנו יכולים להשתמש כדי לאחסן את הערכים שלנו בהקשרים השונים:
מושב מושב = request.session (); request.attribute ("בקשת ערך", "ערך בקשה כלשהו"); session.attribute ("session-val", 1337); מצד שני, אותן שיטות המקבלות רק את פרמטר המפתח הן הגישות:
מחרוזת requestVal = request.attribute ("בקשת שווי"); מחרוזת sessionVal = session.attribute ("session-val"); // זה מספר שלם תכונה מעניינת היא סוג ההחזרה הגנרי שלהם T, אשר חוסך מאיתנו את הצורך ללהק את התוצאה.
6.6. כותרות
כותרות הבקשה, להפך, ניתן לקרוא רק מהבקשה:
כותרת מחרוזת 1 = request.header ("a-header"); כותרת מחרוזת 2 = request.header ("a-safe-header", "עם ערך ברירת מחדל"); מפה allHeaders = request.headers (); 6.7. כלי עזר
שיטות השירות הבאות זמינות גם מהקופסה, והן ברורות כל כך שאין צורך בהסברים נוספים:
- isIE בוליאנית ()
- isAjax בוליאני ()
- מחרוזת contentType ()
- מחרוזת userAgent ()
6.8. קריאת עוגיות
בוא נראה איך ה בַּקָשָׁה אובייקט עוזר לנו להתמודד עם קובצי Cookie, במיוחד בעת קריאת ה- אופציונאלי:
CookieRaw אופציונלי (שם מחרוזת); אנחנו יכולים לקבל את זה גם בתור חוּט על ידי ציון ערך ברירת מחדל להחלה אם קובץ Cookie אינו קיים:
עוגיית מחרוזת (שם מחרוזת, ערך מחרוזת default); לבסוף, כך נוכל לקרוא את כל העוגיות בבת אחת (מקשים הם שמות העוגיות, ערכים הם הערכים של קובצי Cookie):
עוגיות מפה = request.cookies (); 7. תגובת HTTP
מקביל למה שנעשה עם ה- בַּקָשָׁה, אנו יכולים להשיג התייחסות ל- תְגוּבָה התנגד פשוט על ידי הכרזתו כפרמטר של שיטת הניתוב:
@GetRoute ("/") בית חלל ציבורי (תגובת תגובה) {} 7.1. פלט פשוט
אנו יכולים לשלוח פלט פשוט למתקשר באמצעות אחת משיטות הפלט השימושיות, יחד עם קוד HTTP 200 וסוג התוכן המתאים.
ראשית, אנו יכולים לשלוח טקסט רגיל:
response.text ("שלום עולם!");שנית, אנו יכולים לייצר HTML:
response.html ("");שלישית, אנו יכולים גם ליצור XML:
response.xml ("שלום עולם!");לבסוף, אנו יכולים להפיק JSON באמצעות a חוּט:
response.json ("{\" התשובה \ ": 42}"); ואפילו מ- POJO, המנצל את ההמרה האוטומטית של JSON:
משתמש משתמש = משתמש חדש ("Baeldung", "baeldung.com"); response.json (משתמש); 7.2. פלט קבצים
הורדת קובץ מהשרת לא יכולה להיות דקה יותר:
תגובה.download ("the-file.txt", "/path/to/the/file.txt"); הפרמטר הראשון מגדיר את שם הקובץ שיוריד, ואילו השני (א קוֹבֶץ אובייקט, כאן בנוי עם חוּט) מייצג את הנתיב לקובץ בפועל בשרת.
7.3. טיוח תבניות
להב יכול גם לעבד דפים באמצעות מנוע תבנית:
response.render ("admin / users.html"); ספריית ברירת המחדל של התבניות היא src / main / resources / templates /מכאן שהקו אחד הקודם יחפש את הקובץ src / main / resources / templates / admin / users.html.
עוד נלמד על כך בהמשך תבניות סָעִיף.
7.4. הפניה מחדש
הפניה מחדש משמעותה שליחת קוד HTTP 302 לדפדפן, יחד עם כתובת URL למעקב עם GET שני.
אנו יכולים להפנות למסלול אחר, או גם לכתובת אתר חיצונית:
response.redirect ("/ target-route"); 7.5. כתיבת עוגיות
אנחנו צריכים להיות רגילים לפשטות של להב בשלב זה. בואו נראה כיצד נוכל לכתוב קובץ Cookie שלא חלף בשורת קוד אחת:
response.cookie ("שם קובץ cookie", "ערך כלשהו כאן"); ואכן, הסרת עוגיה היא פשוטה באותה מידה:
response.removeCookie ("שם קובץ cookie"); 7.6. פעולות אחרות
סוף - סוף, ה תְגוּבָה האובייקט מספק לנו מספר שיטות אחרות לבצע פעולות כמו כתיבת כותרות, הגדרת סוג התוכן, הגדרת קוד המצב וכו '.
בואו נסתכל במהירות על כמה מהם:
- מצב תגובה (מצב int)
- כותרות מפה ()
- התגובה notFound ()
- עוגיות מפה ()
- תגובה contentType (מחרוזת contentType)
- גוף ריק (נתוני @NonNull [] נתונים)
- כותרת תגובה (שם מחרוזת, ערך מחרוזת)
8. WebHooks
WebHook הוא מיירט שדרכו אנו יכולים הפעל קוד לפני ואחרי ביצוע שיטת ניתוב.
אנו יכולים ליצור WebHook על ידי יישום ה- WebHook ממשק פונקציונלי ועוקף את לפני() שיטה:
ממשק ציבורי @FunctionalInterface WebHook {בוליאני לפני (RouteContext ctx); ברירת מחדל בוליאנית לאחר (RouteContext ctx) {return true; }} כמו שאנו יכולים לראות, לאחר() היא שיטת ברירת מחדל, ומכאן שנעקוף אותה רק בעת הצורך.
8.1. מיירט כל בקשה
ה @אפונה ביאור אומר את המסגרת לסרוק את הכיתה עם מיכל ה- IoC.
כתוצאה מכך, WebHook שמאושר אליו יעבוד באופן גלובלי ויירט בקשות לכל כתובת אתר:
מחלקה ציבורית @Bean BaeldungHook מיישמת את WebHook {@Override בוליאני ציבורי לפני (RouteContext ctx) {System.out.println ("[BaeldungHook] נקרא לפני שיטת Route"); לחזור אמיתי; }} 8.2. צמצום לכתובת אתר
אנו יכולים ליירט גם כתובות אתרים ספציפיות כדי לבצע קוד סביב שיטות המסלול האלה בלבד:
Blade.of () .before ("/ user / *", ctx -> System.out.println ("Before:" + ctx.uri ())); .start (App.class, טוען); 8.3. תיווך
Middlewares הם בראש סדר העדיפויות של WebHooks, שמבוצעים לפני כל WebHook רגיל:
מחלקה ציבורית BaeldungMiddleware מיישמת את WebHook {@Override בוליאני ציבורי לפני (הקשר הקשר RouteContext) {System.out.println ("[BaeldungMiddleware] נקרא לפני שיטת Route ושאר WebHooks"); לחזור אמיתי; }} הם פשוט צריכים להיות מוגדרים ללא @אפונה ביאור, ואז נרשם בהצהרה באמצעות להשתמש():
Blade.of () .use (חדש BaeldungMiddleware ()) .start (App.class, args); בנוסף, להב מגיע עם אמצעי האחסון המובנים הבאים הקשורים לאבטחה, ששמם צריך להיות מובן מאליו:
- BasicAuthMiddleware
- CorsMiddleware
- XssMiddleware
- CsrfMiddleware
9. תצורה
ב- Blade, התצורה היא אופציונלית לחלוטין, מכיוון שהכל עובד מחוץ לקופסה על פי מוסכמה. עם זאת, אנו יכולים להתאים אישית את הגדרות ברירת המחדל ולהציג תכונות חדשות בתוך ה- src / main / resources / application.properties קוֹבֶץ.
9.1. קריאת התצורה
אנו יכולים לקרוא את התצורה בדרכים שונות, עם או בלי לציין ערך ברירת מחדל במקרה שההגדרה אינה זמינה.
- במהלך ההפעלה:
Blade.of () .on (EventType.SERVER_STARTED, e -> {גרסה אופציונלית = WebContext.blade (). Env ("app.version");}) .start (App.class, args); - בתוך מסלול:
@GetRoute ("/ some-route") פומבי בטל someRoute () {מחברי מחרוזות = WebContext.blade (). Env ("app.authors", "מחברים לא ידועים"); } - במטעין מותאם אישית, על ידי יישום ה- BladeLoader ממשק, עוקף את לִטעוֹן() שיטה, והערת הכיתה עם @אפונה:
המחלקה הציבורית @Bean LoadConfig מיישמת את BladeLoader {@Override עומס הריק הציבורי (להב להב) {גרסה אופציונלית = WebContext.blade (). Env ("app.version"); מחברי מחרוזות = WebContext.blade (). Env ("app.authors", "מחברים לא ידועים"); }} 9.2. תכונות תצורה
מספר ההגדרות שכבר הוגדרו, אך מוכנות להתאמה אישית, מקובצות לפי סוג ומופיעות בכתובת זו בטבלאות שלוש עמודות (שם, תיאור, ערך ברירת מחדל). אנו יכולים גם להתייחס לדף המתורגם ולשים לב לעובדה שהתרגום באותיות שגויות באותיות רישיות. ההגדרות האמיתיות קטנות לחלוטין.
קיבוץ הגדרות תצורה לפי קידומת הופך אותם לקריאים בבת אחת למפה, דבר שימושי כאשר ישנם רבים מהם:
סביבת סביבה = להב.סביבה (); מפה מפה = environment.getPrefix ("אפליקציה"); גרסת מחרוזת = map.get ("גרסה"). ToString (); מחברי מחרוזות = map.get ("מחברים", "מחברים לא ידועים"). ToString (); 9.3. טיפול בסביבות מרובות
בעת פריסת האפליקציה שלנו לסביבה אחרת, ייתכן שנצטרך לציין הגדרות שונות, למשל ההגדרות הקשורות לחיבור מסד הנתונים. במקום להחליף ידנית את application.properties קובץ, להב מציע לנו דרך להגדיר את האפליקציה לסביבות שונות. אנחנו יכולים פשוט לשמור application.properties עם כל הגדרות הפיתוח, ואז ליצור קבצים אחרים באותה תיקייה, כמו יישומים- product.properties, המכיל רק את ההגדרות השונות.
במהלך ההפעלה נוכל לציין את הסביבה בה אנו רוצים להשתמש, והמסגרת תמזג את הקבצים באמצעות ההגדרות הספציפיות ביותר מ יישומים- product.properties, וכל שאר ההגדרות כברירת מחדל application.properties קוֹבֶץ:
java -jar target / sample-blade-app.jar --app.env = prod 10. תבניות
תבנית בלהב היא היבט מודולרי. אמנם הוא משלב מנוע תבניות בסיסי מאוד, אך לכל שימוש מקצועי ב- Views עלינו להסתמך על מנוע תבניות חיצוני. אנחנו יכולים אז בחר מנוע מאלה הזמינים במאגר מנועי להב-תבנית ב- GitHub, שהם FreeMarker, ג'טבריק, צַדֶפֶת, ו מְהִירוּת, או אפילו ליצור עטיפה לייבוא תבנית אחרת שאנחנו אוהבים.
מחבר להב מציע את Jetbrick, עוד פרויקט סיני חכם.
10.1. שימוש במנוע ברירת המחדל
תבנית ברירת המחדל עובדת על ידי ניתוח משתנים מהקשרים שונים דרך ה- ${} סִמוּן:
10.2. חיבור מנוע חיצוני
מעבר למנוע תבניות אחר הוא משב רוח! אנו פשוט מייבאים את התלות של (עטיפת הלהב של) המנוע:
com.bladejava blade-template-jetbrick 0.1.3 בשלב זה, מספיק לכתוב תצורה פשוטה כדי להורות למסגרת להשתמש בספריה זו:
המחלקה הציבורית @Bean TemplateConfig מיישמת את BladeLoader {@Override עומס הריק הציבורי (להב הלהב) {blade.templateEngine (JetbrickTemplateEngine חדש ()); }} כתוצאה מכך, כעת כל קובץ תחת src / main / resources / templates / ינותח עם המנוע החדש, שתחבירו אינו מעבר להדרכה זו.
10.3. עטיפת מנוע חדש
גלישת מנוע תבנית חדש מחייבת יצירת מחלקה אחת, אשר חייבת ליישם את תבנית מנוע ממשק ועקוף את לְדַקלֵם() שיטה:
בטל עיבוד (ModelAndView modelAndView, סופר סופר) זורק TemplateException; לשם כך, אנו יכולים להסתכל על הקוד של עטיפת Jetbrick בפועל כדי לקבל מושג מה זה אומר.
11. כניסה
להב משתמש slf4j-api כממשק רישום.
זה כולל גם יישום רישום מוגדר שכבר נקרא להב-יומן. לכן, איננו צריכים לייבא דבר; זה עובד כמו שהוא, פשוט על ידי הגדרת a כּוֹרֵת עֵצִים:
סופי סטטי פרטי org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger (LogExample.class); 11.1. התאמה אישית של לוגר משולב
במקרה שנרצה לשנות את תצורת ברירת המחדל, עלינו לכוון את הפרמטרים הבאים כמאפייני מערכת:
- רמות רישום (יכולות להיות "עקבות", "ניפוי באגים", "מידע", "אזהרה" או "שגיאה"):
# רושם שורשים com.blade.logger.rootLevel = מידע # חבילה רמת רישום מותאמת אישית com.blade.logger.somepackage = ניפוי באגים # מחלקת רישום כניסה מותאמת אישית com.blade.logger.com.baeldung.sample.SomeClass = עקבות - מידע שהוצג:
# תאריך ושעה com.blade.logger.showDate = שקר # תבנית תאריך ושעה com.blade.logger.datePattern = yyyy-MM-dd HH: mm: ss: SSS Z # שם חוט com.blade.logger.showThread = true # Logger Instance Name com.blade.logger.showLogName = true # רק החלק האחרון של FQCN com.blade.logger.shortName = true - כּוֹרֵת עֵצִים:
# נתיב com.blade.logger.dir =. / Logs # שם (ברירת המחדל היא היישום הנוכחי) com.blade.logger.name = דוגמה 11.2. לא כולל את לוגר משולב
למרות שיש לוגר משולב שכבר מוגדר מאוד שימושי להתחיל את הפרויקט הקטן שלנו, אנו עשויים להגיע בקלות למקרה בו ספריות אחרות מייבאות יישום רישום משלהם. ובמקרה זה אנו יכולים להסיר את המשולב כדי למנוע התנגשויות:
com.bladejava blade-mvc $ {blade.version} com.bladejava blade-log 12. התאמות אישיות
12.1. טיפול בחריגים בהתאמה אישית
מטפל חריגים מובנה כברירת מחדל במסגרת. זה מדפיס את החריג למסוף, ואם app.devMode הוא נָכוֹן, מעקב הערימה נראה גם בדף האינטרנט.
עם זאת, אנו יכולים להתמודד עם חריג באופן ספציפי על ידי הגדרת a @אפונה הרחבת ה- DefaultExceptionHandler מעמד:
המחלקה הציבורית של @Bean GlobalExceptionHandler מרחיבה את DefaultExceptionHandler {@Override public void handle (Exception e) {if (למשל of BaeldungException) {BaeldungException baeldungException = (BaeldungException) e; מחרוזת msg = baeldungException.getMessage (); WebContext.response (). Json (RestResponse.fail (msg)); } אחר {ידית סופר (ה); }}} 12.2. דפי שגיאה מותאמים אישית
באופן דומה, הטעויות 404 לא נמצא ו 500 שגיאת שרת פנימית מטופלים דרך דפי ברירת מחדל רזים.
אנו יכולים להכריח את המסגרת להשתמש בדפים שלנו על ידי הכרזתם ב- application.properties קובץ עם ההגדרות הבאות:
mvc.view.404 = my-404.html mvc.view.500 = my-500.html בהחלט, דפי HTML אלה חייבים להיות ממוקמים תחת ה- src / main / resources / templates תיקיה.
בתוך 500, אנו יכולים גם לאחזר את החריג הוֹדָעָה וה stackTrace באמצעות המשתנים המיוחדים שלהם:
500 שגיאת שרת פנימית השגיאה הבאה התרחשה ： "$ {message}"
$ {stackTrace} 13. משימות מתוזמנות
מאפיין מעניין נוסף של המסגרת הוא האפשרות לתזמן את ביצוע השיטה.
זה אפשרי על ידי הערת השיטה של א @אפונה שיעור עם @לוח זמנים ביאור:
@Bean class class ScheduleExample {@Schedule (name = "baeldungTask", cron = "0 * / 1 * * *?") Public public runScheduledTask () {System.out.println ("זו משימה מתוזמנת הפועלת פעם בדקה . "); }} ואכן, הוא משתמש בביטויים cron קלאסיים כדי לציין את תאריך שעה קואורדינטות. אנו יכולים לקרוא עוד על אלה במדריך לביטוי קרונים.
בהמשך, אנו עשויים לנצל את השיטות הסטטיות של ה- מנהל משימות בכיתה לביצוע פעולות במשימות המתוזמנות.
- קבל את כל המשימות המתוזמנות:
רשימת allScheduledTasks = TaskManager.getTasks (); - קבל משימה בשם:
משימה myTask = TaskManager.getTask ("baeldungTask"); - עצור משימה בשם:
בוליאני סגור = TaskManager.stopTask ("baeldungTask"); 14. אירועים
כפי שכבר נראה בסעיף 9.1, ניתן להאזין לאירוע מוגדר לפני הפעלת קוד מותאם אישית כלשהו.
להב מספק את האירועים הבאים מחוץ לקופסה:
enum ציבור EventType {SERVER_STARTING, SERVER_STARTED, SERVER_STOPPING, SERVER_STOPPED, SESSION_CREATED, SESSION_DESTROY, SOURCE_CHANGED, ENVIRONMENT_CHANGED} למרות ששש הראשונים קלים לנחש, השניים האחרונים זקוקים לכמה רמזים: ENVIRONMENT_CHANGED מאפשר לנו לבצע פעולה אם קובץ תצורה משתנה כאשר השרת למעלה. SOURCE_CHANGEDבמקום זאת הוא עדיין לא מיושם והוא קיים לשימוש עתידי בלבד.
בואו נראה כיצד נוכל להכניס ערך למושב בכל פעם שהוא נוצר:
Blade.of (). On (EventType.SESSION_CREATED, e -> {Session session = (Session) e.attribute ("session"); session.attribute ("name", "Baeldung");}). Start (App .class, טוען); 15. יישום מושב
אם מדברים על ההפעלה, יישום ברירת המחדל שלה מאחסן את ערכי ההפעלה בזיכרון.
ייתכן שנרצה לעבור ליישום אחר בכדי לספק מטמון, התמדה או משהו אחר. בוא ניקח למשל את רדיס. ראשית נצטרך ליצור את שלנו RedisSession עטיפה על ידי יישום ה- מוֹשָׁב ממשק, כפי שמוצג במסמכים עבור HttpSession.
ואז, זה רק עניין להודיע למסגרת שאנחנו רוצים להשתמש בה. אנו יכולים לעשות זאת באותו אופן שעשינו עבור מנוע התבניות המותאם אישית, כאשר ההבדל היחיד הוא שאנחנו מכנים sessionType () שיטה:
@Bean SessionConfig מחלקה ציבורית מיישמת את BladeLoader {@Override עומס חלל ציבורי (להב להב) {blade.sessionType (RedisSession חדש ()); }} 16. ויכוחים על שורת הפקודה
כאשר מריצים את להב משורת הפקודה, יש שלוש הגדרות שנוכל לציין כדי לשנות את התנהגותה.
ראשית, אנו יכולים לשנות את כתובת ה- IP, שהיא כברירת מחדל המקומית 0.0.0.0 loopback:
java -jar target / sample-blade-app.jar - server.address = 192.168.1.100 שנית, אנו יכולים גם לשנות את היציאה, שהיא כברירת מחדל 9000:
java -jar target / sample-blade-app.jar - server.port = 8080 לבסוף, כפי שנראה בסעיף 9.3, אנו יכולים לשנות את הסביבה כך שתאפשר אחרת יישומים-XXX. נכסים הקובץ לקריאה על פני ברירת המחדל, כלומר application.properties:
java -jar target / sample-blade-app.jar --app.env = prod 17. ריצה ב- IDE
כל Java IDE מודרני מסוגל להפעיל פרויקט להב מבלי להזדקק לתוספי Maven. הפעלת להב ב- IDE שימושית במיוחד בעת הפעלת הדגמות להב, דוגמאות שנכתבו במפורש כדי להציג את פונקציות המסגרת. כולם יורשים פום הורים, ולכן קל יותר לתת ל- IDE לבצע את העבודה, במקום לשנות אותם ידנית להפעלה כאפליקציות עצמאיות.
17.1. ליקוי חמה
באקליפס מספיק ללחוץ לחיצה ימנית על הפרויקט ולהפעיל אותו הפעל כיישום Java, בחר שלנו אפליקציה בכיתה, ולחץ בסדר.
הקונסולה של Eclipse, לעומת זאת, לא תציג כראוי צבעי ANSI ותשפוך את הקודים שלהם במקום:
למרבה המזל, התקנת סיומת ANSI Escape in Console פותרת את הבעיה לטובה:
17.2. רעיון IntelliJ
IntelliJ IDEA עובד עם צבעי ANSI מהקופסה. לכן, זה מספיק כדי ליצור את הפרויקט, לחץ לחיצה ימנית על ה- אפליקציה קובץ, והפעל הפעל את 'App.main ()' (שווה ערך ללחיצה Ctrl + Shift + F10):
17.3. קוד Visual Studio
אפשר גם להשתמש ב- VSCode, IDE פופולרי שאינו ממוקד ב- Java, על ידי התקנה קודמת של חבילת הרחבה של Java.
לחיצה Ctrl + F5 לאחר מכן ינהל את הפרויקט:
18. מסקנה
ראינו כיצד להשתמש בלייד ליצירת יישום MVC קטן.
כל התיעוד זמין רק בשפה הסינית. למרות היותו נפוץ בעיקר בסין, בזכות מוצאו הסיני, המחבר תרגם לאחרונה את ה- API ותיעד את פונקציות הליבה של הפרויקט באנגלית ב- GitHub.
כמו תמיד, אנו יכולים למצוא את קוד המקור של הדוגמה ב- GitHub.
