חלק 6: מיכלי Servlet

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

• על הרשת ;
• על ארכיטקטורת תוכנה ;
• על פרוטוקולי HTTP/HTTPS ;
• על יסודות מייבן;
• על servlets (כתיבת יישום אינטרנט פשוט) .

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

תוֹכֶן:

• מהו מיכל servlet
• כיצד להשתמש במיכלי servlet
• התקנה והרצה של Tomcat"
• פריסת אפליקציה ל-Tomcat
• שימוש בפרוטוקול HTTPS במקום HTTP
• הפקת תעודה
• הגדרת השרת
• יצירה דינמית של דפי HTML
• חלופות לטומקט

מהו מיכל servlet

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

כיצד להשתמש במיכלי servlet

בנוסף לבקשות ניתוב, מיכל ה-servlet מבצע פונקציות נוספות:

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

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

התקנה והרצה של Tomcat

1. כדי להתקין את Tomcat, פשוט פרק את הארכיון שהורדתי לספרייה הרצויה.

2. שימו לב ש- Tomcat דורש Java גרסה 8 ומעלה כדי להפעיל. ודא שמשתנה הסביבה JAVA_HOME מתייחס לגרסת ה-jdk הנוכחית.

3. לאחר מכן עליך להגדיר גישת משתמש ל- Tomcat . זה נעשה בקובץ tomcat-users.xml, שנמצא בתיקייה conf.

   Tomcat מגיע מסופק מראש עם ארבעה תפקידים:

   • 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"/>

   עכשיו הכל מוכן להשקה!

4. בתיקיית bin, הפעל את הקובץ startup.bat (startup.sh ב-Linux).

5. לאחר מספר שניות, פתח את הקישור http://localhost:8080/ בדפדפן שלך . המנהל הגרפי יופיע שם:

   אם אתה רואה תפריט כזה, זה אומר ש- Tomcat פועל.

6. אם זה לא עובד, בדוק ידנית את משתני הסביבה JAVA_HOME ו-CATALINA_HOME:

   • JAVA_HOME - חייב להתייחס לגרסה הנוכחית של Java 8+;
   • CATALINA_HOME - חייב להתייחס ל-Tomcat או להיעדר (לא חייב להצביע על גרסה אחרת של 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");
   }
}

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

1. דרך GUI

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

   אם חזרת על כל השלבים אחרי, הכניסה היא משתמש, הסיסמה היא סיסמה .

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

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

   לחץ על "פרוס", אנו רואים שהאפליקציה שלנו הופיעה בסעיף היישומים:

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

2. דרך מערכת הקבצים

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

   כל מה שאנחנו צריכים לעשות זה להעביר את servlet.war שלנו לכאן.

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

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

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

שימוש בפרוטוקול HTTPS במקום HTTP

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

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

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

הפקת תעודה

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

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

לאחר ביצוע הפקודה, כלי השירות יתחיל איתנו דיאלוג: הזן את המידע הדרוש. כעת יצרנו מאגר מפתחות בספריית הבית שלנו (עבור Windows זה C:\Users\{username}\.keystore) ומפתח של tomcat בתוכו. יצרנו אישור פשוט שרוב הדפדפנים יקבלו. תעודה זו אינה מתאימה ליישומים מסחריים: ניתן להשתמש בה רק למטרות בדיקה. בשרת הייצור, עליך להשתמש באישור מרשות אישורים (לדוגמה, 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 סטטי משעמם, תוכלו לכתוב קוד JAVA באמצעות משתנים, לולאות, מערכים ומבני שפות אחרים. דמיינת? החדשות הטובות הן שמשהו דומה קיים, החדשות הרעות הן שהוא לא קיים במלואו. אם לא ניחשתם, אנחנו מדברים על טכנולוגיית JSP (Java Server Pages). בקיצור, מדובר בטכנולוגיה שמאפשרת להכניס פיסות של קוד JAVA לדף 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 כאן . בעצם... אנחנו לא כאן בשביל זה, אלא בשביל מיכלי servlet! מה הקשר ל-JSP? זה פשוט: השינוי של קוד JAVA מ-JSP לקוד HTML מתבצע על ידי מיכל ה-servlet. כאשר servlet עומד להחזיר תוכן JSP כתגובה, המכיל שם לב והופך אותו תחילה לדף HTML קריא לדפדפן לפני שליחת התוכן הזה ללקוח. כיום ישנם אנלוגים רבים של טכנולוגיית JSP - Thymeleaf, FreeMarket, Mustache ואחרים. כולם עובדים על עיקרון דומה. איזה מהם לבחור לעבודה זה עניין של טעם. זה חל גם על בחירת מיכל servlet. בדוגמאות השתמשנו ב- Tomcat - הקונטיינר הנפוץ ביותר, אך חלק מהפרויקטים משתמשים באחרים. כדאי להכיר בקצרה את הפופולריים ביותר ולהסתכל על ההבדלים ביניהם מ- Tomcat.

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

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

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

2. WildFly - לשעבר Jboss . גם קוד פתוח. פותח על ידי Red Hat. השם שונה כדי למנוע בלבול עם מוצר אחר של החברה - JBoss Enterprise Application Platform.

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

3. Jetty - בדומה לקודמים, הוא קוד פתוח. פותח על ידי Eclipse.

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

4. WebLogic היא תוכנה ברישיון הדורשת רכישה לפני השימוש. בבעלות אורקל.

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

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

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

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