streamalism.org

תוכן עניינים

• 1. סקירה כללית
• 2. דפי JavaServer
• 2.1. תחביר JSP
• 2.2. תוכן סטטי ודינמי
• 2.3. חפצים מרומזים
• 2.4. אובייקטים מרומזים אחרים
• 2.5. הוראות
• 2.6. הוראות עמוד
• 3.0. שלוש דוגמאות
• 3.1. HTML שניתנו ב- Servlet
• 3.2. Java בתוכן סטטי JSP
• 3.3. JSP עם העברה
• 3.4. נסה את זה!
• 4. סיכום

1. סקירה כללית

JavaServer Pages (JSP) מאפשר דִינָמִי הזרקת תוכן לתוך סטָטִי תוכן באמצעות Java ו- Java Servlets. אנו יכולים להגיש בקשות לא Java Servlet, בצע לוגיקה רלוונטית והפוך תצוגת תצוגה ספציפית לצד השרת שייצרך בצד הלקוח. מאמר זה יספק סקירה מעמיקה של דפי JavaServer המשתמשים ב- Java 8 ו- Jave 7 EE.

נתחיל בבדיקת כמה מושגי מפתח הרלוונטיים ל- JSP: כלומר ההבדל בין דִינָמִי ו סטָטִי תכנים, מחזור החיים של JSP ותחביר JSP כמו גם הוראות וחפצים מרומזים שנוצרו באוסף!

2. דפי JavaServer

דפי JavaServer (JSP) אפשרו להעביר נתונים ספציפיים ל- Java או להציב אותם בתצוגת .jsp ולצרוך את צד הלקוח.

קבצי JSP הם בעצם קבצי .html עם תחביר נוסף, וכמה הבדלים ראשוניים קלים:

1. ה .html הסיומת מוחלפת ב- .jsp (זה נחשב לקובץ .jsp) ו-
2. התג הבא מתווסף לראש רכיבי הסימון .html:

בואו נעבור על כמה ממושגי המפתח ב- JSP.

2.1. תחביר JSP

ישנן שתי דרכים להוסיף קוד Java ל- .jsp. ראשית, נוכל להשתמש בתחביר בסיסי של Java Scriptlet, הכולל הצבת חסימות קוד Java בתוך שני תגי Scriptlet:

<% Java code here %>

השיטה השנייה היא ספציפית ל- XML:

 קוד Java כאן 

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

 דודאד! 
שלום!

לדוגמא, אם doodad נכון, היינו מציגים את הראשון, div אלמנט אחרת היינו מציגים את השני, עמ ' אֵלֵמֶנט!

2.2. סטָטִי ו דִינָמִי תוכן

סטָטִי תוכן אינטרנט הוא רכוש קבוע הנצרך ללא תלות בבקשות RESTful, SOAP, HTTP, HTTPS או מידע אחר שהוגש על ידי המשתמש.

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

טכנולוגיית JSP מאפשרת הפרדה נקייה בין האחריות בין דִינָמִי ו סטָטִי תוכן.

השרת (servlet) מנהל את ה- דִינָמִי התוכן והלקוח (דף ה- jsp בפועל) הוא ה- סטָטִי הקשר אליו מוזרקים תכנים דינמיים.

בואו נסתכל על ה- אובייקטים מרומזים שנוצרו על ידי JSP ומאפשרים לך לגשת לצד שרת הנתונים הרלוונטי ל- JSP!

2.3. חפצים מרומזים

אובייקטים מרומזים נוצרים על ידי מנוע JSP באופן אוטומטי במהלך הַהדָרָה.

אובייקטים מרומזים כולל את HttpRequest ו HttpResponse אובייקטים ולחשוף פונקציות שונות בצד השרת לשימוש ב- servlet שלך ולאינטראקציה עם .jsp! הנה הרשימה של אובייקטים מרומזים שנוצרו:

בַּקָשָׁה

בַּקָשָׁה שייך למעמד javax.servlet.http.HttpServletRequest. ה בַּקָשָׁה האובייקט חושף את כל נתוני קלט המשתמש והופך אותם לזמינים לצד השרת.

תְגוּבָה

תְגוּבָה שייך למעמד javax.servlet.http.HttpServletResponse וקובע מה מועבר ללקוח אחרי א בַּקָשָׁה עשוי.

בואו נסתכל מקרוב על ה- בַּקָשָׁה ו תְגוּבָה אובייקטים מרומזים מכיוון שהם החשובים והשימושים ביותר.

הדוגמה שלהלן מדגימה שיטת servlet פשוטה מאוד, לא שלמה, לטיפול בקשות GET. השמטתי את רוב הפרטים כדי שנוכל להתמקד כיצד להשתמש ב- בַּקָשָׁה ו תְגוּבָה חפצים:

חלל מוגן doGet (HttpServletRequest בקשה, HttpServletResponse תגובה) זורק ServletException, IOException {מחרוזת הודעה = request.getParameter ("הודעה"); response.setContentType ("טקסט / html"); . . . }

ראשית, אנו רואים כי בַּקָשָׁה ו תְגוּבָה אובייקטים מועברים כפרמטרים לשיטה, מה שהופך אותם לזמינים במסגרתה.

אנו יכולים לגשת לפרמטרים של בקשות באמצעות .getParameter () פוּנקצִיָה. מעל, אנו חוטפים את הוֹדָעָה פרמטר ולאתחל משתנה מחרוזת כדי שנוכל להשתמש בו בלוגיקה בצד השרת שלנו. אנחנו יכולים גם לגשת ל תְגוּבָה אובייקט שקובע מה יהיו ואיך הנתונים שהועברו לתצוגה.

למעלה הגדרנו את סוג התוכן עליו. אנחנו לא צריכים להחזיר את תְגוּבָה התנגד להציג את מטעני המטען בדף JSP בעיבוד!

הַחוּצָה

הַחוּצָה שייך למעמד javax.servlet.jsp.JspWriter ומשמש לכתיבת תוכן ללקוח.

ישנן לפחות שתי דרכים להדפיס לדף JSP שלך וכדאי לדון בשתיהן כאן. הַחוּצָה נוצר באופן אוטומטי ומאפשר לך לכתוב לזיכרון ואז ל- תְגוּבָה לְהִתְנַגֵד:

out.print ("שלום"); out.println ("עולם");

זהו זה!

הגישה השנייה יכולה להיות ביצועית יותר מכיוון שהיא מאפשרת לך לכתוב ישירות ל- תְגוּבָה לְהִתְנַגֵד! הנה, אנו משתמשים PrintWriter:

PrintWriter out = response.getWriter (); out.println ("שלום עולם");

2.4. אובייקטים מרומזים אחרים

הנה כמה אחרים אובייקטים מרומזים שגם טוב לדעת!

מוֹשָׁב

מוֹשָׁב שייך למעמד javax.servlet.http.HttpSession שומר על נתוני משתמשים למשך ההפעלה.

יישום

יישום שייך למעמד javax.servlet.ServletContext מאחסן פרמטרים הכוללים יישומים שהוגדרו בעת האתחול או שיש לגשת אליהם בכל היישומים.

יוצא מן הכלל

יוצא מן הכלל שייך למעמד javax.servlet.jsp.JspException משמש להצגת הודעות שגיאה בדפי JSP הכוללים את התג .

עמוד

עמוד שייך למעמד java.lang. אובייקט מאפשר גישה או התייחסות למידע סרוולט הנוכחי.

pageContext

pageContext שייך למעמד javax.servlet.jsp.PageContext ברירת מחדל ל עמוד היקף אך ניתן להשתמש בו לגישה בַּקָשָׁה, יישום, ו תכונות הפעלה.

config

config שייך למעמד javax.servlet.ServletConfig הוא אובייקט תצורת ה- servlet המאפשר לקבל את ההקשר, שם ופרמטרים של ה- servlet.

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

2.5. הוראות

JSP מספקת הוראות מהקופסה בהן ניתן להשתמש כדי לציין פונקציות ליבה לקבצי JSP שלנו. להוראות JSP ישנם שני חלקים: (1) ההנחיה עצמה ו- (2) התכונה של אותה הנחיה שמוקצה לה ערך.

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

לכן, כדוגמה, תצוין הנחיית עמודים באמצעות תגי JSP באופן הבא:

ונוכל לעשות זאת באמצעות XML באופן הבא:

2.6. תכונות הנחיות לדפים

יש הרבה תכונות שניתן להכריז בהנחיית עמודים:

אוטומטי פלאש

אוטומטי פלאש שולט בפלט המאגר ומנקה אותו כאשר מגיעים לגודל המאגר. ערך ברירת המחדל הוא נָכוֹן.

בַּלָם

בַּלָם מגדיר את גודל החיץ המשמש את דף ה- JSP שלנו. ערך ברירת המחדל הוא 8kb.

errorPage

errorPage מציין דף JSP כדף שגיאה.

מרחיב

מרחיב מציין את מחלקת העל של קוד השרת המקביל.

מידע

מידע משמש להגדרת תיאור מבוסס טקסט עבור ה- JSP.

isELgnored

isELgnored מציין אם הדף יתעלם או לא שפת ביטוי (EL) ב- JSP. EL מאפשר לשכבת המצגת לתקשר עם שעועית מנוהלת Java ועושה זאת באמצעות ${…} תחביר ולמרות שלא ניכנס כאן לחסרונות של EL, ישנן כמה דוגמאות שנמצאות להלן המספיקות לבניית אפליקציית JSP לדוגמא! ערך ברירת המחדל עבור isELgnored הוא שֶׁקֶר.

isErrorPage

isErrorPage אומר האם דף הוא דף שגיאה או לא. עלינו לציין דף שגיאה אם ​​אנו יוצרים מטפל בשגיאות בעמוד שלנו בתוך היישום.

isThreadSafe

isThreadSafe יש ערך ברירת מחדל של נָכוֹן. isThreadSafe קובע אם ה- JSP יכול להשתמש ב- Servlet רב-הברגה או לא. באופן כללי, לעולם לא היית רוצה

כדי לכבות את הפונקציונליות הזו.

שפה

שפה קובע באיזו שפת סקריפטים להשתמש ב- JSP. ערך ברירת המחדל הוא ג'אווה.

מוֹשָׁב

מוֹשָׁב קובע אם לשמור על הפעלת HTTP או לא. ברירת המחדל היא אמיתית ומקבלת ערכים של נָכוֹן אוֹ שֶׁקֶר.

trimDirectiveWhitespaces

trimDirectiveWhitespaces מפשט רווחים לבנים בדף JSP מעבה את הקוד לבלוק קומפקטי יותר בזמן הידור. הגדרת ערך זה ל- נָכוֹן עשוי לעזור להפחית את גודל קוד ה- JSP. ערך ברירת המחדל הוא שֶׁקֶר.

3. שלוש דוגמאות

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

ישנן שלוש דרכים עיקריות להזריק ג'אווה ל- .jsp ונחקור כל אחת מהדרכים להלן תוך שימוש בפונקציות מקומיות ב- Java 8 וב- Jakarta EE.

ראשית, אנו הופכים את צד שרת הסימון שלנו להצגה לצד הלקוח. שנית, נבדוק כיצד להוסיף קוד Java ישירות לקובץ ה- jsp שלנו ללא תלות ב- javax.servlet.httpשל בַּקָשָׁה ו תְגוּבָה חפצים.

שלישית, נדגים כיצד להעביר שניהם HttpServletRequest ל- .jsp ספציפי ולאגד אליו ג'אווה מעובדת בצד השרת.

בואו נגדיר את הפרויקט שלנו באקליפס באמצעות קובץ / חדש / פרויקט / אינטרנט / פרויקט אינטרנט דינמי / סוג להתארח בטומקט! אתה אמור לראות לאחר יצירת הפרויקט:

| -פרויקט | - תוכן אינטרנט | - META-INF | - MANIFEST.MF | - WEB-INF | - lib | - src

אנו נוסיף מספר קבצים למבנה היישום, כך שבסופו של דבר:

| -פרויקט | - WebContent | - META-INF | - MANIFEST.MF | - WEB-INF | -lib * -web.xml | - ExampleTree.jsp | - ExampleTwo.jsp * - index.jsp | - src | - com | - baeldung * - ExampleOne.java * - ExampleThree.java

בואו נקים index.jsp שיוצג כשאנחנו ניגשים להקשר URL ב- Tomcat 8:

   דוגמאות JSP 
הפעל HTML שניתנו על ידי Servlet: כאן
ג'אווה בעמוד סטטי: כאן
ג'אווה מוזרק על ידי סרוולט: כאן

ישנם שלושה א, כל קישור לאחת הדוגמאות שנעבור להלן בסעיפים 4.1 עד 4.4.

אנחנו גם צריכים לוודא שיש לנו את זה web.xml להכין:

 index.html index.htm index.jsp ExampleOne com.baeldung.ExampleOne ExampleOne / ExampleOne 

הערה עיקרית כאן היא - כיצד למפות נכון כל אחת מה- servlets שלנו למיפוי סרוולט מסוים. פעולה זו מקשרת כל servlet עם נקודת קצה ספציפית בה היא יכולה לצרוך! כעת נעבור על כל אחד מהקבצים האחרים למטה!

3.1. HTML שניתנו ב- Servlet

בדוגמה זו, למעשה נדלג על בניית קובץ .jsp!

במקום זאת, ניצור ייצוג מחרוזת של הסימון שלנו ואז נכתוב אותו לתגובת GET עם PrintWriter לאחר דוגמא אחת Servlet מקבל בקשת GET:

מחלקה ציבורית ExampleOne מרחיבה את HttpServlet {@Override ruid doGet (HttpServletRequest request, HttpServletResponse response) זורק ServletException, IOException {respons.setContentType ("text / html"); PrintWriter out = response.getWriter (); out.println ("" + "" + "" + "HTML שניתנו על ידי Servlet" + "" + "" + "
" + "
דף זה הופק על ידי ה- Servlet של ExampleOne!
" + "" + "" ); } }

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

מוקדם יותר סקרנו את הַחוּצָה אובייקט שהוא תכונה של JspWriter.

מעל השתמשתי ב- PrintWriter אובייקט במקום שכותב ישירות ל תְגוּבָה לְהִתְנַגֵד.

JspWriter למעשה חוצץ את המחרוזת שתיכתב בזיכרון שנכתב לאחר מכן אל תְגוּבָה אובייקטים לאחר שמאגר הזיכרון נשטף.

PrintWriter כבר מחובר ל תְגוּבָה לְהִתְנַגֵד. העדפתי לכתוב ישירות ל- תְגוּבָה התנגד בדוגמאות שלמעלה ומתחת מסיבות אלה.

3.2. Java בתוכן סטטי JSP

כאן אנו יוצרים קובץ JSP בשם ExampleTwo.jsp עם תג JSP. כפי שנראה לעיל, הדבר מאפשר להוסיף את ג'אווה ישירות לסימון שלנו. כאן אנו מדפיסים באקראי אלמנט של a חוּט[]:

   ג'אווה בדוגמא לדף סטטי 

למעלה, תראה הצהרת משתנה זו בתוך אובייקטים של תגי JSP: סוּגשם משתנה ו אִתחוּל ממש כמו ג'אווה רגילה.

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

3.3. JSP עם העברה

עכשיו, לדוגמא האחרונה והמעורבת ביותר שלנו! הנה, אנו נשתמש ב- @WebServlet ביאור על ExampleThree שמבטל את הצורך במיפוי סרוולט ב server.xml.

@WebServlet (name = "ExampleThree", תיאור = "JSP Servlet עם ביאורים", urlPatterns = {"/ ExampleThree"}) מחלקה ציבורית ExampleThree מרחיב HttpServlet {@Override מוגן בטל doGet (HttpServletRequest בקשה, HttpServletResponse תגובה) זורק הודעת מחרוזת = request.getParameter ("הודעה"); request.setAttribute ("טקסט", הודעה); request.getRequestDispatcher ("/ ExampleThree.jsp"). העבר (בקשה, תגובה); }}

ExampleThree לוקח פרמטר URL המועבר כ- הוֹדָעָה, קושר את הפרמטר הזה ל- בַּקָשָׁה ואז מפנה מחדש את זה בַּקָשָׁה להתנגד ל ExampleThree.jsp.

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

getRequestDispatcher (). קדימה () היא דרך פשוטה להבטיח שדף ה- jsp הנכון מועבר.

כל הנתונים קשורים ל בַּקָשָׁה אובייקט שנשלח בדרכו (קובץ ה- jsp) יוצג לאחר מכן! כך אנו מטפלים בחלק האחרון הזה:

   דוגמה לקישור Java 
אמרת: $ {text}

שים לב לתג JSP שנוסף לראש הדף ExampleThree.jsp. תבחין שהחלפתי כאן את תגי ה- JSP. אני משתמש בשפת ביטוי (שהזכרתי קודם) כדי לעבד את הפרמטר שנקבע לנו (שהוא מאוגד כ- $ {text})!

3.4. נסה את זה!

כעת, אנו מייצאים את היישום שלנו ל- .war שיושק ויתארח ב- Tomcat 8! מצא את שלך server.xml ונעדכן את שלנו הֶקשֵׁר ל:

מה שיאפשר לנו לגשת ל- servlets ול- JSP שלנו localhost: 8080 / spring-mvc-xml / jsp / index.jsp! הרם עותק עבודה בכתובת: GitHub. מזל טוב!

4. מסקנה

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

זה מסכם את ההקדמה ל- JSP! היה טוב ותקודד!