חלק 6. מיכלי Servlet

חומר זה הוא חלק מסדרת "מבוא לפיתוח ארגוני". מאמרים קודמים:

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

תוכן העניינים:

מה זה מיכל servlet?

זוהי תוכנית שפועלת על שרת ויכולה לקיים אינטראקציה עם ה-servlets שיצרנו. במילים אחרות, אם ברצוננו להפעיל את יישום האינטרנט שלנו על שרת, אנו פורסים תחילה קונטיינר של servlet ואז שמים בו servlets. זרימת העבודה פשוטה: כאשר הלקוח ניגש לשרת, הקונטיינר מעבד את הבקשה שלו, קובע איזה servlet צריך לעבד אותה, ואז מעביר את הבקשה. חלק 6. מיכלי סרבל - 2

כיצד משתמשים במיכלי servlet?

בנוסף לבקשות ניתוב, מיכל servlet מבצע פונקציות אחרות:

זה יוצר באופן דינמי דפי HTML מקובצי JSP.
זה מצפין/מפענח הודעות HTTPS.
הוא מספק גישה מוגבלת לניהול servlet.

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

התקנה והפעלה של Tomcat

כדי להתקין את Tomcat, פשוט פתח את הארכיון שהורדתי לספרייה הרצויה.
שימו לב ש- Tomcat דורש Java גרסה 8 ומעלה כדי להתחיל ולהפעיל. ודא שמשתנה הסביבה JAVA_HOME מפנה לגרסה הנוכחית של ה-JDK.
לאחר מכן, עליך להגדיר גישת משתמש ל- Tomcat . זה נעשה בקובץ tomcat-users.xml, שנמצא בתיקייה conf.

ישנם ארבעה תפקידים מוגדרים מראש בטומקט:
- manager-gui - גישה לממשק הגרפי ולדף הסטטוס
- מנהל-סקריפט — גישה לממשק הטקסט ולדף הסטטוס
- manager-jmx — גישה ל-JMX ולדף הסטטוס
- מנהל-סטטוס — גישה רק לדף הסטטוס
בתוך התג <tomcat-users>, אנו מציינים במפורש את התפקידים הללו ומקצים אותם למשתמש שלנו:
```
<role rolename="manager-gui"/>
<role rolename="manager-script"/>
<role rolename="manager-jmx"/>
<role rolename="manager-status"/>
<user username="user" password="password"
    roles="manager-gui, manager-script, manager-jmx, manager-status"/>
```
עכשיו הכל מוכן להשקה!
בתיקיית bin, הפעל את הקובץ startup.bat (startup.sh ב-Linux).
לאחר מספר שניות, פתח את הקישור http://localhost:8080/ בדפדפן שלך. תראה לוח מחוונים גרפי:

אם אתה רואה תפריט כזה, אז Tomcat פועל.
אם הוא לא פועל, בדוק ידנית את משתני הסביבה JAVA_HOME ו-CATALINA_HOME:
- JAVA_HOME - זה חייב להתייחס לגרסה הנוכחית של Java 8+.
- CATALINA_BASE - זה חייב להתייחס ל- Tomcat או להיעדר (זה לא אמור להתייחס לגרסה אחרת של Tomcat).

פריסת אפליקציה בטומקט

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


import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class MainServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
       HttpSession session = req.getSession();
       Integer visitCounter = (Integer) session.getAttribute("visitCounter");
       if (visitCounter == null) {
           visitCounter = 1;
       } else {
           visitCounter++;
       }
       session.setAttribute("visitCounter", visitCounter);
       String username = req.getParameter("username");
       resp.setContentType("text/html");
       PrintWriter printWriter = resp.getWriter();
       if (username == null) {
           printWriter.write("Hello, Anonymous" + "
");
       } else {
           printWriter.write("Hello, " + username + "
");
       }
       printWriter.write("Page was visited " + visitCounter + " times.");
       printWriter.close();
   }
}

IndexServlet:


import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/")
public class IndexServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
       resp.sendRedirect(req.getContextPath() + "/hello");
   }
}

לפני הפריסה, עלינו לארוז את ה-servlets שלנו בקובץ WAR. בדרך כלל משתמשים ב-Maven לשם כך, אבל כדי ליצור קובץ WAR צריך קובץ web.xml שיש בו מיפוי לכל ה-servlets. השתמשנו בביאור @WebServlet החדש כדי לכתוב את ה-servlets, כך שאין לנו קובץ web.xml. למרבה המזל, IDEA יכול לעשות עבורנו את העבודה המלוכלכת, לעטוף את הפרויקט שלנו בקובץ WAR. לשם כך, פתחו את מבנה הפרויקט (Ctrl+Shift+Alt+S) -> Artifacts -> בחרו בקובץ ה-WAR הרצוי -> בחרו בתיבת הסימון שליד "כלול בבניית הפרויקט" -> לחצו על "אישור". חלק 6. מיכלי סרבל - 4

בואו נבנה את הפרויקט באמצעות שילוב המקשים Ctrl+F9. כעת קובץ ה-WAR שלנו נמצא בספריית היעד. חלק 6. מיכלי Servlet - 5

ניתן לשנות את שם הקובץ למשהו פשוט יותר, למשל servlet.war, ולהעביר אותו למקום נוח יותר, למשל C:\\my\\. ברגע שקובץ ה-WAR מוכן לשימוש, נכניס אותו למיכל . ישנן שתי דרכים לעשות זאת.

שימוש בממשק הגרפי

כדי לעשות זאת, עקוב אחר הקישור הזה: http://localhost:8080/manager/html . Tomcat צריך לבקש שם משתמש וסיסמה.

אם עקבת איתי עד לנקודה זו, שם המשתמש הוא "משתמש", והסיסמה היא "סיסמה" .

לאחר כניסה מוצלחת, תראה את מנהל יישומי האינטרנט של Tomcat. הקטע "יישומים" כבר מכיל 5 יישומים - אלו הם כלי עזר של Tomcat, שמקלים על העבודה עם Tomcat. ניתן למחוק אותם בעתיד.

להלן הקטע "פרוס". כאן אתה יכול לבחור את ארכיון ה-WAR לפריסה. בואו נזין את הנתיב וההקשר באופן ידני:

לחץ על "פרוס" ואנו רואים שהאפליקציה שלנו הופיעה בקטע "יישומים":
באמצעות הממשק הגרפי של Tomcat, אנו יכולים לעצור, להפעיל מחדש ולמחוק הפעלה, כמו גם להגדיר את משך ההפעלה. בעת הפריסה, ציינו את ההקשר /demo, כלומר הגישה לאפליקציה שלנו מתבצעת באמצעות http://localhost:8080/demo . תבדוק את זה. הכל אמור לעבוד.
דרך מערכת הקבצים

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

כל מה שנדרש הוא שנעביר לכאן את קובץ servlet.war שלנו.

אנו ממתינים מספר שניות ואז רואים שתיקיית "servlet" חדשה הופיעה. המשמעות היא שהאפליקציה שלנו פרוסה. עבור אל ממשק מנהל היישומים בכתובת http://localhost:8080/manager/ . כאן אנו רואים שהאפליקציה שלנו פרוסה בהקשר /servlet:

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

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

שימוש ב-HTTPS במקום ב-HTTP

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

הפק תעודה בחתימה עצמית
בצע הגדרות שרת נוספות

בואו נתאמן לעשות את זה.

הפקת תעודה

ללא קשר לגרסה, ה-JDK כולל מספר רב של כלי עזר. אחד מהם הוא keytool . זהו כלי להפקה ולעבודה עם מפתחות הצפנה. כדי להשתמש בו, בשורת הפקודה, עבור אל ספריית C:\\Program Files\\Java\\jdk1.8.0_181\\bin והפעל את הפקודה keytool -genkey -alias tomcat -keyalg RSA .

keytool - שם כלי השירות שאנו מריצים עם אפשרויות שורת הפקודה
-genkey - ציין שאנו רוצים ליצור מפתח חדש
-alias tomcat - צור כינוי מפתח
-keyalg RSA - בחר RSA בתור אלגוריתם יצירת המפתחות

לאחר ביצוע הפקודה, כלי השירות מתחיל איתנו דיאלוג: חלק 6. מיכלי סרבל - 11

הזן את המידע הדרוש. כעת יצרנו מאגר מפתחות בספריית הבית שלנו (עבור Windows, זהו C:\\Users\\{username}\\.keystore) ומפתח טומקאט בתוכו. הפקנו אישור פשוט שרוב הדפדפנים יתלוננו עליו. תעודה כזו אינה מתאימה ליישומים מסחריים: ניתן להשתמש בה רק למטרות בדיקה. בשרת ייצור, עליך להשתמש באישור מרשות אישורים (לדוגמה, https://letsencrypt.org/ ).

הגדרת השרת

כעת, כשהאישור מוכן, עלינו להתאים את הגדרות השרת, כלומר את מחבר ה-SSL. זה נעשה בקובץ server.xml, שנמצא ב- apache-tomcat-9.0.30/conf/ . בו אנו מוצאים בלוקים כמו זה:


<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
               maxThreads="150" SSLEnabled="true">
        <SSLHostConfig>
            <Certificate certificateKeystoreFile="conf/localhost-rsa.jks"
                         type="RSA" />
        </SSLHostConfig>
 </Connector>

ואנחנו שמים את התצורה שלנו לידם:


    <Connector
           protocol="org.apache.coyote.http11.Http11NioProtocol"
           port="8443" maxThreads="200"
           scheme="https" secure="true" SSLEnabled="true"
           keystoreFile="C:\Users\user\.keystore" keystorePass="mypass"
           clientAuth="false" sslProtocol="TLS"/>

אנו מקצים את הערכים העדכניים ביותר לפרמטרים keystoreFile ו-keystorePass, שומרים את הקובץ ולאחר מכן מפעילים מחדש את Tomcat באמצעות הקבצים shutdown.bat ו-startup.bat. כעת השרת מוכן לעבד בקשות HTTPS. הכתובת השתנתה רק מעט: https://localhost:8443/demo/hello . כשתלחצו על הקישור תקבלו אזהרה על מהימנות התעודה, וזה לא מפתיע. כפי שאמרנו קצת קודם, צריך להיעזר בשירותיה של אחת מרשויות האישורים כדי לקבל תעודה רגילה. אבל לעת עתה, השגנו את המטרה שלנו: האפליקציה פועלת באמצעות פרוטוקול HTTPS, וזה חשוב!

יצירת דפי HTML באופן דינמי

כעת נמשיך את הסקירה הכללית שלנו על מיכלי servlet על ידי בחינת תכונה נוספת: יצירה דינמית של דפי HTML. תארו לעצמכם עולם מושלם שבו, במקום קוד HTML סטטי משעמם, תוכלו לכתוב קוד ג'אווה, באמצעות משתנים, לולאות, מערכים ומבני שפות אחרים. הצלחתם לדמיין את זה? החדשות הטובות הן שקיים משהו דומה. החדשות הרעות הן שזה לא לגמרי משיג את הפנטזיה הזו. אם לא ניחשתם, אנחנו מדברים על JavaServer Pages (JSP). בקיצור, זו טכנולוגיה שמאפשרת להכניס פיסות של קוד Java לדף HTML. נכון, קוד ג'אווה זה עדיין מומר ל-HTML לפני שהוא נשלח ללקוח, אבל HTML זה ייווצר באופן דינמי, תוך התחשבות בגורמים שונים. לדוגמה, אתה יכול להשתמש בהצהרות מותנות ולהחזיר תוכן שונה בהתאם לתנאי כלשהו. דף JSP לדוגמה:


<%@ page language="java"" %>
<html>
<head>
<title>JSP</title>
</head>

<body>
<%
String firstName="name";
String secondName="surname";
    
    if (firstName.equals("name")){
      out.print("Hello: "+firstName+"<br>");
    }

    if (firstName.equals("name") && secondName.equals("surname"))
    {
      out.print("Hello, my dear friend! <br>");
    }
    else
    {
      out.print("I don't know you. Go away! <br>");
    }
%>
</body>
</html>

תוכל לקרוא עוד על JSP כאן . בסופו של יום, המאמר הזה לא עוסק ב-JSP - אנחנו כאן כדי לדבר על מיכלי servlet! אז למה הזכרנו את JSP? זה פשוט: מיכל servlet הוא מה שממיר קוד Java מ-JSP ל-HTML. כאשר servlet עומד להחזיר תוכן JSP כתגובה, הקונטיינר לוקח לתשומת ליבו וממיר אותו תחילה לדף HTML ידידותי לדפדפן לפני שליחת תוכן כזה ללקוח. כיום, ישנם אנלוגים רבים לטכנולוגיית JSP - Thymeleaf, FreeMarket, Mustache ואחרים. כולם עובדים בצורה דומה. איזה מהם לבחור לעבודה שלך זה עניין של טעם. זה חל גם על בחירת מיכל servlet. בדוגמאות אלו, השתמשנו ב- Tomcat, הקונטיינר הנפוץ ביותר, אך חלק מהפרויקטים משתמשים בקונטיינרים אחרים. כדאי לסקור בקצרה את הפופולריים ביותר ולשקול במה הם שונים מטומקט.

חלופות לטומקט

GlassFish הוא מיכל קוד פתוח שהפיתוח שלו נתמך על ידי אורקל.

בניגוד ל-Tomcat, זהו שרת אינטרנט מן המניין, שבנוסף לסרבלטים, יכול לפעול עם רכיבים אחרים ממסגרת JavaEE. עם זאת, הוא משתמש בהרבה יותר זיכרון RAM. ישנה גמישות רבה יותר בעת כוונון עדין של השרת, מה שמקשה על השימוש בו. יש להשתמש בו בעת פיתוח יישומים במסגרת JavaEE.
WildFly היה ידוע בעבר בשם JBoss . זה גם קוד פתוח. הוא פותח על ידי Red Hat. השם שונה כדי למנוע בלבול עם עוד אחד ממוצרי החברה - JBoss Enterprise Application Platform.

כמו GlassFish, WildFly הוא שרת אינטרנט מן המניין. אגב, מתחת למכסה המנוע, WildFly משתמש ב-Tomcat כמיכל servlet. שלא כמו GlassFish, WildFly קל יותר וקל להגדרה.
Jetty , כמו הקודמים, הוא קוד פתוח. הוא פותח על ידי Eclipse.

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

יש לו פונקציונליות מעט רחבה יותר מאשר Tomcat. זה יכול לעבוד עם פרוטוקול FTP. אבל זה לא כל כך גמיש בעת פיתוח ובדיקת יישומים.
WebSphere (WebSphere Application Server, ליתר דיוק) היא תוכנה בתשלום. זה פותח על ידי IBM. בדומה ל-WildFly ו- GlassFish, זהו שרת יישומים שלם. אבל יש לו ממשק תצורה ידידותי יותר, בתוספת אמינות גבוהה בפעולה.

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

הבחירה במיכל הservlet הנכון או בשרת היישומים תלוי בפרויקט המסוים. ישנם פרויקטים שבהם אפילו אנדרדוג ברור עשוי להתגלות כבחירה מצוינת, אבל בהתחלה עדיף לבצע מחקר מעמיק של מיכל סרבטים אחד. Tomcat הוא כנראה המועמד המושלם למחקר הזה. וכבר עשינו את הצעדים הראשונים בלימוד זה, אבל מכאן זה תלוי בכם! במאמרים האחרונים של סדרת "מבוא לפיתוח ארגוני", נכיר את דפוס ה-MVC. חלק 7. היכרות עם דפוס ה-MVC (Model-View-Controller).