ส่วนที่ 6 คอนเทนเนอร์ Servlet

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

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

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

สารบัญ:

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

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

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

ใช้คอนเทนเนอร์ servlet อย่างไร

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

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_BASE — ข้อมูลนี้ต้องอ้างอิงถึง Tomcat หรือไม่มีอยู่ (ไม่ควรอ้างอิง Tomcat เวอร์ชันอื่น)

การปรับใช้แอปพลิเคชันใน Tomcat

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

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

ก่อนปรับใช้ เราจำเป็นต้องทำแพ็คเกจเซิร์ฟเล็ตของเราในไฟล์ WAR โดยปกติจะใช้ Maven ในการทำเช่นนี้ แต่ในการสร้างไฟล์ WAR คุณต้องมีไฟล์ web.xml ที่มีการแมปสำหรับเซิร์ฟเล็ตทั้งหมด เราใช้คำอธิบายประกอบ @WebServlet ใหม่เพื่อเขียนเซิร์ฟเล็ต ดังนั้นเราจึงไม่มีไฟล์ web.xml โชคดีที่ IDEA สามารถทำงานสกปรกให้เราได้ โดยห่อโปรเจ็กต์ของเราไว้ในไฟล์ WAR ในการดำเนินการนี้ ให้เปิดโครงสร้างโปรเจ็กต์ (Ctrl+Shift+Alt+S) -> Artifacts -> เลือกไฟล์ WAR ที่ต้องการ -> เลือกช่องทำเครื่องหมายถัดจาก "รวมในบิลด์โปรเจ็กต์" -> คลิก "ตกลง" มาสร้างโครงการโดยใช้คีย์ผสม Ctrl+F9 ตอนนี้ไฟล์ WAR ของเราอยู่ในไดเร็กทอรีเป้าหมาย สามารถเปลี่ยนชื่อไฟล์เป็นสิ่งที่ง่ายกว่า เช่น servlet.war และย้ายไปยังตำแหน่งที่สะดวกกว่า เช่น C:\\my\\เราจะใส่ มันลงในภาชนะ มีสองวิธีในการทำเช่นนี้

1. การใช้อินเทอร์เฟซแบบกราฟิก

   โดยไปที่ลิงก์นี้: http://localhost:8080/manager/ html Tomcat ควรขอชื่อผู้ใช้และรหัสผ่าน

   หากคุณติดตามฉันมาจนถึงจุดนี้ชื่อผู้ใช้คือ "ผู้ใช้" และรหัสผ่านคือ "รหัสผ่าน "

   หลังจากลงชื่อเข้าใช้สำเร็จ คุณจะเห็น Tomcat Web Application Manager ส่วน "แอปพลิเคชัน" มีแอปพลิเคชันอยู่แล้ว 5 รายการ — ซึ่งเป็นยูทิลิตี้ Tomcat ซึ่งทำให้ Tomcat ทำงานได้ง่ายขึ้น สามารถลบได้ในอนาคต

   ด้านล่างคือส่วน "ปรับใช้" คุณสามารถเลือกไฟล์เก็บถาวร WAR เพื่อปรับใช้ได้ที่นี่ ป้อนเส้นทางและบริบทด้วยตนเอง:

   คลิก "ปรับใช้" และเราเห็นว่าแอปพลิเคชันของเราปรากฏในส่วน "แอปพลิเคชัน":

   เมื่อใช้อินเทอร์เฟซแบบกราฟิกของ Tomcat เราสามารถหยุด รีสตาร์ท และลบเซสชัน ตลอดจนกำหนดระยะเวลาเซสชันได้ เมื่อปรับใช้ เราระบุบริบท /demo ซึ่งหมายความว่าแอปพลิเคชันของเราเข้าถึงได้โดยใช้http://localhost:8080/ demo ตรวจสอบ. ทุกอย่างควรจะทำงาน

2. ผ่านระบบไฟล์

   ในการปรับใช้แอปพลิเคชันด้วยวิธีนี้ คุณต้องเปิดไดเร็กทอรีที่ Tomcat ถูกคลายซิป จากนั้นไปที่โฟลเดอร์ "webapps" ที่นี่คุณจะพบยูทิลิตี้ที่เราพบแล้ว:

   สิ่งที่ต้องทำคือให้เราย้ายไฟล์ servlet.war ที่นี่

   เรารอสักครู่แล้วดูว่ามีโฟลเดอร์ "เซิร์ฟเล็ต" ใหม่ปรากฏขึ้น ซึ่งหมายความว่าแอปพลิเคชันของเราถูกปรับใช้ ไปที่อินเทอร์เฟซตัวจัดการแอปพลิเคชันที่http://localhost:8080/manager / ที่นี่เราเห็นว่าแอปพลิเคชันของเราถูกปรับใช้ในบริบท /servlet:

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

   อย่างที่คุณเห็น การปรับใช้แอปพลิเคชันใน Tomcat นั้นง่ายกว่าที่คิด แต่ฟังก์ชั่นอื่น ๆ ก็ใช้งานง่ายเช่นกัน มาตรวจสอบกัน

ใช้ HTTPS แทน HTTP

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

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\\{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 แบบไดนามิก

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

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

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

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

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

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

3. Jettyเช่นเดียวกับก่อนหน้านี้เป็นโอเพ่นซอร์ส มันถูกพัฒนาโดย Eclipse

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

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

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

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

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

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