ส่วนที่ 6: คอนเทนเนอร์เซิร์ฟเล็ต

เนื้อหานี้เป็นส่วนหนึ่งของชุด "ข้อมูลเบื้องต้นเกี่ยวกับการพัฒนาองค์กร" บทความก่อนหน้านี้:

• เกี่ยวกับเครือข่าย
• เกี่ยวกับสถาปัตยกรรมซอฟต์แวร์
• เกี่ยวกับโปรโตคอล HTTP/HTTPS ;
• เกี่ยวกับพื้นฐานของ Maven
• เกี่ยวกับเซิร์ฟเล็ต (การเขียนเว็บแอปพลิเคชันอย่างง่าย )

ในบทความที่แล้ว เราได้ทำความคุ้นเคยกับเซิร์ฟเล็ตและเรียนรู้วิธีสร้างเว็บแอปพลิเคชันด้วยความช่วยเหลือของพวกเขา ถึงเวลาที่จะพิจารณาให้ละเอียดยิ่งขึ้นว่าวันหยุดนี้จะเกิดขึ้นไม่ได้หากไม่มี - คอนเทนเนอร์เซิร์ฟเล็ต

เนื้อหา:

• คอนเทนเนอร์เซิร์ฟเล็ตคืออะไร
• วิธีใช้คอนเทนเนอร์เซิร์ฟเล็ต
• การติดตั้งและใช้งาน Tomcat"
• การปรับใช้แอปพลิเคชันกับ Tomcat
• การใช้โปรโตคอล HTTPS แทน HTTP
• การสร้างใบรับรอง
• การตั้งค่าเซิร์ฟเวอร์
• การสร้างหน้า HTML แบบไดนามิก
• ทางเลือกอื่นสำหรับ Tomcat

คอนเทนเนอร์เซิร์ฟเล็ตคืออะไร

นี่คือโปรแกรมที่ทำงานบนเซิร์ฟเวอร์และสามารถโต้ตอบกับเซิร์ฟเล็ตที่เราสร้างขึ้นได้ กล่าวอีกนัยหนึ่ง หากเราต้องการรันเว็บแอปพลิเคชันของเราบนเซิร์ฟเวอร์ อันดับแรกเราจะปรับใช้คอนเทนเนอร์เซิร์ฟเล็ต จากนั้นจึงวางเซิร์ฟเล็ตไว้ วิธีการทำงานนั้นง่ายดาย: เมื่อไคลเอนต์ติดต่อกับเซิร์ฟเวอร์ คอนเทนเนอร์จะประมวลผลคำขอของเขา กำหนดว่าเซิร์ฟเล็ตใดควรประมวลผลและส่งต่อ

วิธีใช้คอนเทนเนอร์เซิร์ฟเล็ต

นอกเหนือจากการร้องขอการกำหนดเส้นทางแล้ว เซิร์ฟเล็ตคอนเทนเนอร์ยังทำหน้าที่อื่นๆ:

1. สร้างเพจ HTML จากไฟล์ JSP แบบไดนามิก
2. เข้ารหัส/ถอดรหัสข้อความ HTTPS
3. จัดเตรียมการเข้าถึงแบบจำกัดสำหรับการดูแลระบบเซิร์ฟเล็ต

โดยทั่วไปฟังดูดีเหลือเพียงการหาวิธีนำไปใช้ทั้งหมด ถ้าจะเรียนรู้วิธีใช้อะไรบางอย่าง คุณแค่ต้อง... ลองใช้มันดู :) เอาล่ะ วันนี้เราจะมาฝึกกัน! คอนเทนเนอร์เซิร์ฟเล็ตยอดนิยมคือApache Tomcat เป็นโอเพ่นซอร์สและใช้งานได้ฟรี ดาวน์โหลด Tomcat สำหรับระบบปฏิบัติการของคุณจากลิงก์นี้และมาดูวิธีทำงานกับคอนเทนเนอร์กัน

การติดตั้งและใช้งาน Tomcat

1. หากต้องการติดตั้ง Tomcat เพียงแตกไฟล์เก็บถาวรที่ดาวน์โหลดมาลงในไดเร็กทอรีที่ต้องการ

2. โปรดทราบว่า Tomcat ต้องใช้ Java เวอร์ชัน 8 ขึ้นไปจึงจะทำงานได้ ตรวจสอบให้แน่ใจว่าตัวแปรสภาพแวดล้อม JAVA_HOME อ้างอิงถึงเวอร์ชัน jdk ปัจจุบัน

3. ถัดไป คุณต้องกำหนดค่าการเข้าถึง Tomcat ของผู้ใช้ ซึ่งทำได้ในไฟล์ tomcat-users.xml ซึ่งอยู่ในโฟลเดอร์ conf

   Tomcat มาพร้อมสี่บทบาทล่วงหน้า:

   • manager-gui - เข้าถึงอินเทอร์เฟซแบบกราฟิกและหน้าสถานะ
   • manager-script - เข้าถึงอินเทอร์เฟซข้อความและหน้าสถานะ
   • 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 ได้ ดังนั้นจึงถึงเวลาปรับใช้โปรเจ็กต์บางประเภทในนั้น ลองใช้เซิร์ฟเล็ตจากบทความที่แล้ว เซิร์ฟเล็ตหลัก:

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();
   }
}

ดัชนีเซิร์ฟเล็ต:

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 จะใช้เพื่อการนี้ แต่ในการสร้างไฟล์เก็บถาวร war คุณต้องมีไฟล์ web.xml ซึ่งเซิร์ฟเล็ตทั้งหมดจะถูกแมป เราเขียนเซิร์ฟเล็ตโดยใช้คำอธิบายประกอบ @WebServlet ใหม่ ดังนั้นเราจึงไม่มี web.xml โชคดีที่ IDEA สามารถทำงานสกปรกให้เราและรวมโครงการของเราทีละโครงการไว้ในคลังข้อมูลสงคราม ในการดำเนินการนี้ คุณต้องเปิดโครงสร้างโปรเจ็กต์ (Ctrl + Shift + Alt + S) -> สิ่งประดิษฐ์ -> เลือกการชงที่ต้องการ -> ทำเครื่องหมายที่ช่องถัดจาก "รวมในการสร้างโปรเจ็กต์" -> คลิก "ตกลง" สร้างโครงการโดยใช้ชุดค่าผสม Ctrl + F9 ตอนนี้ไฟล์เก็บถาวร war ของเราอยู่ในไดเร็กทอรีเป้าหมาย ไฟล์สามารถเปลี่ยนชื่อสิ่งที่ง่ายกว่าได้ - เช่น 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 ของเรามาที่นี่

   เรารอสักครู่เราจะเห็นว่ามีโฟลเดอร์เซิร์ฟเล็ตใหม่ปรากฏขึ้น ซึ่งหมายความว่าแอปพลิเคชันของเราถูกปรับใช้ ไปที่อินเทอร์เฟซ 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 - ระบุว่าเราต้องการสร้างคีย์ใหม่
• -alias tomcat - สร้างนามแฝงที่สำคัญ
• -keyalg RSA - เลือก RSA เป็นอัลกอริธึมการสร้างคีย์

หลังจากดำเนินการคำสั่งแล้วยูทิลิตี้จะเริ่มการสนทนากับเรา: ป้อนข้อมูลที่จำเป็น ตอนนี้เราได้สร้างที่เก็บคีย์ในโฮมไดเร็กตอรี่ของเราแล้ว (สำหรับ Windows คือ C:\Users\{ชื่อผู้ใช้}\.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 แบบไดนามิก

ตอนนี้เรามาดูคุณสมบัติอื่น ๆ ของคอนเทนเนอร์เซิร์ฟเล็ตต่อไป - การสร้างหน้า 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 ได้ที่นี่ จริงๆ แล้ว... เราไม่ได้มาที่นี่เพื่อสิ่งนี้ แต่เพื่อประโยชน์ของคอนเทนเนอร์เซิร์ฟเล็ต! JSP เกี่ยวอะไรกับเรื่องนี้? ง่ายมาก: การแปลงโค้ด JAVA จาก JSP ไปเป็นโค้ด HTML ดำเนินการโดยคอนเทนเนอร์เซิร์ฟเล็ต เมื่อเซิร์ฟเล็ตกำลังจะส่งคืนเนื้อหา JSP เป็นการตอบกลับ คอนเทนเนอร์จะสังเกตเห็นและเปลี่ยนให้เป็นหน้า HTML ที่เบราว์เซอร์อ่านได้ก่อนที่จะส่งเนื้อหานั้นไปยังไคลเอนต์ วันนี้มีเทคโนโลยี JSP ที่คล้ายคลึงกันมากมาย - Thymeleaf, FreeMarket, Moustache และอื่น ๆ ล้วนทำงานบนหลักการเดียวกัน จะเลือกงานแบบไหนเป็นเรื่องของรสนิยม นอกจากนี้ยังใช้กับการเลือกคอนเทนเนอร์เซิร์ฟเล็ตด้วย ในตัวอย่างเราใช้ Tomcat ซึ่งเป็นคอนเทนเนอร์ที่ใช้บ่อยที่สุด แต่บางโปรเจ็กต์ก็ใช้อย่างอื่น ควรทำความคุ้นเคยกับสิ่งที่ได้รับความนิยมมากที่สุดโดยย่อและดูความแตกต่างจาก Tomcat

ทางเลือกอื่นสำหรับ Tomcat

1. GlassFishเป็นคอนเทนเนอร์โอเพ่นซอร์สที่ Oracle รองรับ

   ต่างจาก Tomcat ตรงที่เป็นเว็บเซิร์ฟเวอร์ที่มีคุณสมบัติครบถ้วน ซึ่งนอกเหนือจากเซิร์ฟเล็ตแล้ว ยังสามารถใช้งานส่วนประกอบอื่นๆ จากกรอบงาน JavaEE ได้อีกด้วย ในขณะเดียวกันก็ใช้ RAM มากกว่ามาก มีความยืดหยุ่นมากขึ้นเมื่อปรับแต่งเซิร์ฟเวอร์อย่างละเอียด ซึ่งทำให้ใช้งานยากขึ้น มันคุ้มค่าที่จะใช้เมื่อพัฒนาแอปพลิเคชันโดยใช้เฟรมเวิร์ก JavaEE

2. WildFly - ชื่อเดิมJboss โอเพ่นซอร์สอีกด้วย พัฒนาโดยเรดแฮท เปลี่ยนชื่อเพื่อหลีกเลี่ยงความสับสนกับผลิตภัณฑ์ของบริษัทอื่น - JBoss Enterprise Application Platform

   WildFly เช่นเดียวกับ GlassFish เป็นเว็บเซิร์ฟเวอร์ที่มีคุณสมบัติครบถ้วน อย่างไรก็ตาม ภายใต้ประทุน WildFly ใช้ Tomcat เป็นคอนเทนเนอร์เซิร์ฟเล็ต WildFly ต่างจาก GlassFish ตรงที่มีน้ำหนักเบากว่าและตั้งค่าง่ายกว่า

3. Jetty - คล้ายกับอันก่อนหน้านี้เป็นโอเพ่นซอร์ส พัฒนาโดยคราส

   เช่นเดียวกับ Tomcat มันเป็นคอนเทนเนอร์เซิร์ฟเล็ตธรรมดา โดยไม่รองรับส่วนประกอบทั้งหมดของเฟรมเวิร์ก JavaEE ในขณะเดียวกันก็มีน้ำหนักเบากว่าและสามารถเรียกใช้บนโทรศัพท์มือถือได้ มันเริ่มและหยุดอย่างรวดเร็วและขยายขนาดได้ดี ต่างจาก Tomcat ตรงที่มีชุมชนและฐานความรู้ที่เล็กกว่า

4. WebLogicเป็นซอฟต์แวร์ลิขสิทธิ์ที่ต้องซื้อก่อนใช้งาน เป็นเจ้าของโดยออราเคิล

   เมื่อเทียบกับ Tomcat ฟังก์ชันการทำงานจะกว้างกว่าเล็กน้อย สามารถทำงานร่วมกับโปรโตคอล ftp ได้ แต่มันไม่ยืดหยุ่นนักเมื่อพัฒนาและทดสอบแอปพลิเคชัน

5. WebSphere (ถ้าให้เจาะจงคือ WebSphere Application Server) เป็นซอฟต์แวร์ที่ต้องชำระเงิน พัฒนาโดยไอบีเอ็ม เช่นเดียวกับ WildFly และ GlassFish มันเป็นเซิร์ฟเวอร์แอปพลิเคชันที่มีคุณสมบัติครบถ้วน แต่มีอินเทอร์เฟซการตั้งค่าที่เป็นมิตรกว่า บวกกับความน่าเชื่อถือในการปฏิบัติงานสูง

   ข้อเสียคือใช้ทรัพยากรมาก ใช้เวลาในการเริ่มต้นและหยุดนานซึ่งไม่สะดวกในการพัฒนาโครงการขนาดเล็ก

เซิร์ฟเล็ตคอนเทนเนอร์หรือแอปพลิเคชันเซิร์ฟเวอร์ใดที่จะเลือกขึ้นอยู่กับโปรเจ็กต์เฉพาะ มีโครงการที่แม้แต่คนนอกที่ชัดเจนก็สามารถพิสูจน์ตัวเองด้วยคุณภาพสูงสุดได้ แต่ในตอนแรกจะเป็นการดีกว่าที่จะเข้าใจสิ่งหนึ่งอย่างถี่ถ้วน ตัวเลือกที่เหมาะสมที่สุดสำหรับอันนี้ก็คือ Tomcat เราได้ดำเนินการขั้นแรกในการศึกษาเรื่องนี้แล้ว และจากนั้นก็ขึ้นอยู่กับคุณ! ในบทความสุดท้ายของชุด "บทนำสู่การพัฒนาองค์กร" เราจะทำความคุ้นเคยกับรูปแบบ MVC ตอนที่ 7. ความรู้เบื้องต้นเกี่ยวกับรูปแบบ MVC (Model-View-Controller) ตอนที่ 8. การเขียนแอปพลิเคชันขนาดเล็กใน spring-boot