ไฟล์นี้มี HTML แบบง่ายพร้อมส่วนเพิ่มเติมสองสามรายการ นี่คือความงามของ JSP รวมกับ JSTL และ JEL สังเกตว่าการตรวจสอบข้อผิดพลาดในการตรวจสอบความถูกต้องนั้นง่ายดายเพียงใดโดยใช้แท็กมาตรฐาน เช่น<с:if>และ .

แอ็ตทริบิวต์การดำเนินการของแบบฟอร์มการลงทะเบียนชี้ไปที่ URL ต่อไปนี้: $(pageContext.request.contextPath)/processcustomer ซึ่งหมายความว่าทุกครั้งที่ลูกค้าพยายามลงทะเบียน ข้อมูลจะถูกส่งไปยังลูกค้าที่ประมวลผล โดยไม่คำนึงถึง URL ที่เข้าถึงแบบฟอร์ม สิ่งนี้สามารถทำได้ผ่านการทำงานของอ็อบเจ็กต์ที่มีอยู่ในไฟล์ JSP เช่น request .

เร็วๆ นี้เราจะดูว่าเซิร์ฟเล็ตเชื่อมโยงกับ URL ของลูกค้ากระบวนการอย่างไร และโต้ตอบกับอินพุตอย่างไร ในตอนนี้ เรามาดูไฟล์ JSP ที่รับผิดชอบหน้าต้อนรับกัน:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

ขอบคุณสำหรับการลงทะเบียน!

ข้อมูลที่คุณป้อน:

ชื่อ:$(ชื่อ)

นามสกุล:$(นามสกุล)

อีเมล:$(อีเมล)

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

การเขียนตัวควบคุม

การเขียนเซิร์ฟเล็ตที่สามารถดึงข้อมูลจากแบบฟอร์มลงทะเบียนไม่ใช่เรื่องง่ายอีกต่อไป สิ่งที่เราต้องทำคือเขียนคลาสย่อยของคลาส HttpServlet และใช้เมธอด doGet() หรือ doPost() (หรือทั้งสองอย่าง หากจำเป็น) ในกรณีนี้ เซิร์ฟเล็ตจะโต้ตอบกับข้อมูลที่มาจากคำขอ POST

นี่คือสิ่งที่ดูเหมือน:

@WebServlet(name = "CustomerController", urlPatterns = "/processcustomer") คลาสสาธารณะ CustomerController ขยาย HttpServlet ( @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) พ่น ServletException, IOException ( RequestCustomer customer = RequestCustomer.fromRequestParameters(request); customer .setAsRequestAttributes(request); การละเมิดรายการ = customer.validate(); if (!violations.isEmpty()) ( request.setAttribute("violations", allowances); ) String url = กำหนดUrl(violations); , การตอบสนอง); ) สตริงส่วนตัวกำหนดUrl(การละเมิดรายการ) ( if (!violations.isEmpty()) ( return "/"; ) else ( return "/WEB-INF/views/customerinfo.jsp"; ) ) คลาสคงที่ส่วนตัว RequestCustomer ( ชื่อสตริงสุดท้ายส่วนตัว; นามสกุลสตริงสุดท้ายส่วนตัว; อีเมลสตริงสุดท้ายส่วนตัว; RequestCustomer ส่วนตัว (ชื่อสตริง, นามสกุลสตริง, อีเมลสตริง) ( this.firstName = firstName; this.lastName = นามสกุล;<>this.email = อีเมล;

) Public static RequestCustomer fromRequestParameters(คำขอ HttpServletRequest) ( return new RequestCustomer(request.getParameter("firstname"), request.getParameter("lastname"), request.getParameter("email")); ) โมฆะสาธารณะ setAsRequestAttributes(คำขอ HttpServletRequest) ( request.setAttribute("firstname", firstName); request.setAttribute("lastname", LastName); request.setAttribute("email", email); ) ตรวจสอบรายการสาธารณะ () ( การละเมิดรายการ = new ArrayList

ที่นี่เราได้ตั้งชื่อเซิร์ฟเล็ต CustomerController เนื่องจากถือเป็นแนวปฏิบัติที่ดีในการใช้ชื่อคลาสเซิร์ฟเล็ตเป็นค่าของแอตทริบิวต์ name ของคำอธิบายประกอบ @WebServlet มิฉะนั้น บางคอนเทนเนอร์จะไม่สามารถจับคู่ได้ ส่งผลให้เกิดข้อผิดพลาด 404

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

เครื่องมือตรวจสอบความถูกต้องเป็นคลาสง่ายๆ ที่ตรวจสอบคุณสมบัติบางอย่าง เช่น สตริงว่างเปล่าหรืออีเมลดูเหมือนอีเมลหรือไม่ คุณสามารถดูการใช้งานได้ใน GitLab ของผู้เขียน

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

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

เปิดแอปพลิเคชัน

ในการเปิดแอปพลิเคชันคุณต้องทำตามขั้นตอนต่อไปนี้:

IntelliJ IDEA) เมื่อคุณปรับใช้โปรเจ็กต์และรัน เบราว์เซอร์เริ่มต้นควรเปิดขึ้นพร้อมกับหน้าต่างการลงทะเบียน

บทสรุป

ดังนั้น คุณได้รับทักษะทั้งหมดที่จำเป็นในการสร้างเว็บแอปพลิเคชันของคุณเองใน Java โดยไม่ต้องใช้เฟรมเวิร์กที่ซับซ้อน สิ่งที่คุณต้องมีคือ Servlet API เทคโนโลยีเช่น JSP สำหรับการเรนเดอร์ และเครื่องมือ Java ดั้งเดิม เยี่ยมมากใช่มั้ย?

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

เซิร์ฟเล็ตเป็นโปรแกรมจาวาที่ทำงานบนฝั่งเซิร์ฟเวอร์ของเว็บแอปพลิเคชัน เช่นเดียวกับที่แอปเพล็ตขยายฟังก์ชันการทำงานของเว็บเบราว์เซอร์แบบไดนามิก เซิร์ฟเล็ตจะขยายฟังก์ชันการทำงานของเว็บเซิร์ฟเวอร์แบบไดนามิก

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

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

Servlet ในสถาปัตยกรรมแอปพลิเคชันเว็บ

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

Servlet เป็นพร็อกซีเซิร์ฟเวอร์

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

ชั่วคราวและถาวร เซิร์ฟเล็ต"ส

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

วงจรชีวิตของเซิร์ฟเล็ต javax.servlet.Servlet

Servlets ทำงานบนแพลตฟอร์มเว็บเซิร์ฟเวอร์โดยเป็นส่วนหนึ่งของกระบวนการเดียวกันกับเว็บเซิร์ฟเวอร์ เว็บเซิร์ฟเวอร์มีหน้าที่รับผิดชอบในการเริ่มต้น เรียกใช้ และทำลายแต่ละอินสแตนซ์เซิร์ฟเล็ต เว็บเซิร์ฟเวอร์โต้ตอบกับเซิร์ฟเล็ตผ่านอินเทอร์เฟซที่เรียบง่าย: javax.servlet.Servlet.

อินเทอร์เฟซ javax.servlet.Servlet มีสามวิธีหลัก:

• เริ่มต้น()
• บริการ()
• ทำลาย()

และตัวช่วยสองวิธี:

• getServletConfig()
• getServletInfo()

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

การเริ่มต้นเซิร์ฟเล็ต, init() วิธีการ

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

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

วิธี เริ่มต้น()รับหนึ่งอาร์กิวเมนต์ - การอ้างอิงถึงวัตถุ ServletConfigซึ่งมีอาร์กิวเมนต์เพื่อเริ่มต้นเซิร์ฟเล็ต วัตถุนี้มีวิธีการ getServletContext ()ส่งคืนวัตถุ ServletContextซึ่งมีข้อมูลเกี่ยวกับสภาพแวดล้อมของเซิร์ฟเล็ต

Servlet core วิธีการบริการ ()

วิธี บริการ()คือหัวใจของเซิร์ฟเล็ต แต่ละคำขอจากไคลเอนต์ส่งผลให้มีการเรียกเมธอดเดียว บริการ()- วิธีการนี้อ่านคำขอและสร้างข้อความตอบกลับโดยใช้สองอาร์กิวเมนต์ ServletRequest และ ServletResponse:

มีสองวิธีในการส่งข้อมูลจากไคลเอนต์ไปยังเซิร์ฟเล็ต ประการแรกคือการส่งผ่านค่าในพารามิเตอร์คำขอ สามารถแทรกค่าพารามิเตอร์ลงใน URL ได้ วิธีที่สองในการส่งข้อมูลจากไคลเอนต์ไปยังเซิร์ฟเล็ตคือผ่าน InputStream (หรือ Reader)

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

ยกเลิกการโหลดเซิร์ฟเล็ต, ทำลาย () วิธีการ

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

สิ่งสำคัญคือต้องทำให้วิธีการเป็นทางการ ทำลาย()ในลักษณะที่จะหลีกเลี่ยงการปิดทรัพยากรที่จำเป็นจนกว่าจะมีการโทรทั้งหมด บริการ()จะไม่เสร็จสิ้น

การกำหนดค่าเซิร์ฟเล็ต, เมธอด getServletConfig()

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

ข้อมูลเซิร์ฟเล็ต, เมธอด getServletInfo()

วิธี getServletInfo()กำหนดโดยโปรแกรมเมอร์ที่สร้างเซิร์ฟเล็ตเพื่อส่งคืนสตริงที่มีข้อมูลเกี่ยวกับเซิร์ฟเล็ต เช่น ผู้สร้างและเวอร์ชันของเซิร์ฟเล็ต

อินเทอร์เฟซ ServletRequest

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

ต่อไป ตัวอย่างเซิร์ฟเล็ตแสดงวิธีรับข้อมูลจากพารามิเตอร์ ขอวิธี บริการ():

เครื่องอ่าน BufferedReader; สตริงพารามิเตอร์1; สตริง param2; บริการโมฆะสาธารณะ (คำขอ ServletRequest, การตอบสนอง ServletResponse) ( reader = request.getReader(); param1 = request.getParameter("First"); param2 = request.getParameter("Second"); )

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

อินเทอร์เฟซ ServletResponse

อินเทอร์เฟซ ServletResponseเป็นเครื่องมือในการส่งข้อมูลไปยังไคลเอนต์ วิธีการทั้งหมดของเครื่องมือนี้ใช้เพื่อแก้ไขปัญหานี้โดยเฉพาะ:

สาธารณะ java.lang.String getCharacterEncoding() โมฆะสาธารณะ setLocale(java.util.Locale loc) สาธารณะ java.util.Locale getLocale()

วิธีแรกส่งคืนประเภทการเข้ารหัส MIME (เช่น UTF8) ซึ่งข้อมูลที่จะแสดง สองวิธีที่สองยังใช้ได้กับชุดอักขระด้วย ระบุภาษาที่ใช้ในเอกสาร (เช่น รัสเซีย)

สาธารณะ ServletOutputStream getOutputStream() พ่น java.io.IOException

เมธอด getOutputStream ส่งคืนสตรีมเอาต์พุตสำหรับเซิร์ฟเล็ต ตัวอย่างเช่น สตรีมนี้ใช้เพื่อส่งออกไฟล์ไบนารี ข้อมูลข้อความสามารถส่งออกได้โดยใช้ java.io.Writer:

java.io.PrintWriter getWriter() สาธารณะพ่น java.io.IOException

เมธอด getWriter() จะแปลงสตริงเป็นชุดอักขระที่ระบุในเมธอด getCharacterEncoding() และ getLocale() โดยอัตโนมัติ

โมฆะสาธารณะ setContentLength (int len)

วิธีการ setContentLength ตั้งค่าของฟิลด์ส่วนหัว HTTP "Content-Length"

โมฆะสาธารณะ setContentType (ประเภทสตริง)

เมธอด setContentType ใช้เพื่อส่งประเภทเนื้อหา MIME ของเอกสาร ฟิลด์ส่วนหัว HTTP "ประเภทเนื้อหา"

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

โมฆะสาธารณะ setBufferSize (ขนาด int) int สาธารณะ getBufferSize () โมฆะสาธารณะ flushBuffer () พ่น java.io.IOException โมฆะสาธารณะ resetBuffer ()

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

บูลีนสาธารณะ isCommission()

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

โมฆะสาธารณะรีเซ็ต()

หากยังไม่ได้ส่งส่วนหัว HTTP วิธีการรีเซ็ตจะ "รีเซ็ต" ส่วนหัว HTTP เป็นค่าเริ่มต้น

แผนภูมิ JFreeChart ในเซิร์ฟเล็ต

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

Servlet พร้อมไลบรารีกราฟิก Chart.js

JNI ในเซิร์ฟเล็ต

ในบางกรณี อาจจำเป็นต้องใช้ JNI ในเว็บแอปพลิเคชัน มีการนำเสนอตัวอย่างของการใช้ JNI ในเซิร์ฟเล็ต

ข้อความ JMS ในเซิร์ฟเล็ต

Servlet สามารถใช้ในการสื่อสาร เจเอ็มเอสข้อความระหว่างแอปพลิเคชัน ตัวอย่างของการใช้เซิร์ฟเล็ตเพื่อส่งและอ่านข้อความ JMS ในคอนเทนเนอร์ JBoss จะถูกนำเสนอ

เกือบยี่สิบปีผ่านไปนับตั้งแต่การถือกำเนิดของภาษาโปรแกรม Java ในช่วงเวลานี้ Java ถูกคาดการณ์ว่าจะตายและถูกลืม โปรแกรมเมอร์หัวเราะเยาะกับความเกียจคร้านและความโลภในทรัพยากร แต่ก็มีคนที่เชื่อใน Java พวกเขาพัฒนาห้องสมุดทุกประเภท พัฒนาชุมชน พิสูจน์อย่างต่อเนื่องว่าไม่มีขีดจำกัดสำหรับ Java: เรียลไทม์, ฝังตัว, AI - ทุกอย่างเป็นไปได้ เราตัดสินใจที่จะไม่ยืนเฉยและจัดทำบทความสั้น ๆ เกี่ยวกับ Java ในส่วนนี้ ไปกันเลย!

กาน้ำชาของคุณเลือก Java

ตามข้อมูลของ Oracle ในปัจจุบัน Java virtual machine ได้รับการติดตั้งบนอุปกรณ์มากกว่าสามพันล้านเครื่อง และสิ่งเหล่านี้ไม่ได้เป็นเพียงคอมพิวเตอร์และสมาร์ทโฟนเท่านั้น แต่ยังรวมถึงกล้องถ่ายรูป โทรทัศน์ เครื่องเล่นบลูเรย์ เครื่องพิมพ์ ซิมการ์ด ตู้เอทีเอ็ม และแม้แต่รถยนต์ รายการนี้จะเติบโตอย่างต่อเนื่อง และด้วยข้อเสนอจากนายจ้างสำหรับโปรแกรมเมอร์ Java ถึงตอนนี้จำนวนตำแหน่งงานว่างสำหรับโปรแกรมเมอร์ Java ยังมีมากกว่าที่เหลือ และบริษัทต่างๆ ยินดีที่จะจ่ายเงินมากขึ้นเรื่อยๆ เพื่อดึงดูดพนักงานและจัดสภาพการทำงานที่ดีขึ้น

มันมีประโยชน์อะไร?

โปรแกรมเมอร์ Java สนใจความเรียบง่ายของไวยากรณ์ ไม่มีคำดัดแปลงหรือฟังก์ชันที่ไม่จำเป็น แม้จะไม่มีการสืบทอดหลายครั้งซึ่งในตอนแรกโปรแกรมเมอร์ C++ ค่อนข้างสับสน แต่ท้ายที่สุดกลับกลายเป็นว่าสมเหตุสมผลและสมเหตุสมผล ตรรกะง่ายๆ การทำงานอัตโนมัติพร้อมหน่วยความจำ เอกสารโดยละเอียด ฟอรัมพร้อมคำตอบสำหรับคำถามทุกประเภท โอเพ่นซอร์ส ทั้งหมดนี้ช่วยให้คุณเข้าใจกระบวนการพัฒนาได้อย่างรวดเร็วและลดจำนวนข้อผิดพลาดที่อาจเกิดขึ้นได้อย่างมาก แม้แต่ชาวนาอินเดียก็ยังเชี่ยวชาญชวาได้ในเวลาไม่กี่เดือน อย่างน้อยนั่นคือสิ่งที่ประกาศนียบัตรของพวกเขาพูด :) นอกจากนี้ Java ยังเป็นภาษาที่ตีความ คอมไพเลอร์จะแปลงซอร์สโค้ดเป็นสิ่งที่เรียกว่า bytecode ซึ่งง่ายต่อการแปลงกลับ ซึ่งทำให้ Java มีความน่าสนใจเป็นพิเศษสำหรับวิศวกรรมย้อนกลับ

เอาล่ะ มาเริ่มกันเลย

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

ประเภทข้อมูลสามารถแบ่งออกเป็นสองกลุ่ม: แบบง่าย (int, long, char และอื่นๆ) และประเภทอ็อบเจ็กต์: คลาส, อินเทอร์เฟซ, อาร์เรย์ ประเภทธรรมดามีมิติคงที่เสมอและทุกที่ ตัวอย่างเช่น ในสถาปัตยกรรมและอุปกรณ์ใดๆ int จะใช้หน่วยความจำสี่ไบต์ นี่ค่อนข้างสะดวกสำหรับการคำนวณ อาร์เรย์ข้อมูลประกอบด้วยแอตทริบิวต์ความยาวพิเศษ ซึ่งจะจัดเก็บขนาดของอาร์เรย์ ซึ่งขอขอบคุณนักพัฒนาเป็นพิเศษ ข้อมูลประเภทต่างๆ จะถูกส่งผ่านไปยังวิธีการที่แตกต่างกัน ประเภทธรรมดาจะถูกส่งผ่านตามค่าเสมอ วัตถุ - โดยการอ้างอิงเสมอเพื่อประหยัดหน่วยความจำ ซึ่งหมายความว่าถ้าเราส่ง int a = 10 และเปลี่ยนค่าของมันเป็น 5 ในวิธีการที่เรียกว่า ดังนั้นในวิธีดั้งเดิม a จะยังคงเป็น 10 แต่ถ้าเราเปลี่ยนคุณสมบัติของวัตถุ มันก็จะเปลี่ยนในวิธีดั้งเดิม .

จำความทรงจำ

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

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

โปรแกรมเมอร์หลายคนเมื่อเปลี่ยนมาใช้ Java และเรียนรู้เกี่ยวกับการล้างหน่วยความจำอัตโนมัติ จะเริ่มสร้างอ็อบเจ็กต์ในปริมาณมหาศาล โดยหวังว่าทุกอย่างจะเคลียร์ได้ด้วยตัวเอง ในขณะเดียวกันคนเก็บขยะก็เปรียบเสมือนเครื่องจักรที่สามารถกำจัดขยะที่ทิ้งลงถังขยะใกล้บ้านเท่านั้น หากคุณไม่ต้องการข้อมูลอีกต่อไป คุณไม่ควรเก็บไว้เผื่อไว้ เช่น กองโปสการ์ดเก่าๆ - กำหนดค่าว่างให้กับตัวชี้ข้อมูลและช่วยภารโรงทำความสะอาด :) เป็นความคิดที่ดีที่จะล้างรายการหากคุณไม่ต้องการมันอีกต่อไป โปรดจำไว้ว่าวัตถุจะยังคงอยู่ในหน่วยความจำตราบใดที่มีการอ้างอิงถึงวัตถุนั้นในโค้ด แม้ว่าโปรแกรมของคุณจะทำงานบนหน่วยความจำ 16 กิ๊ก และไม่เสี่ยงที่จะล่มเนื่องจากหน่วยความจำไม่เพียงพอ เนื่องจากหน่วยความจำที่ใช้มากเกินไป มันจะกลายเป็นเรื่องงุ่มง่ามและเฉื่อยชามากขึ้นเรื่อยๆ 99% ของผู้ใช้ร้องเรียนเกี่ยวกับโปรแกรม Java ที่ช้า เนื่องมาจากซอร์สโค้ดที่เขียนไม่มีประสิทธิภาพ หากคุณต้องการสร้างออบเจ็กต์ที่ใช้งานอย่างรวดเร็วและไม่จำเป็นอีกต่อไป เช่น ข้อความเล็กๆ จำนวนมาก ให้พิจารณาสร้างพูลที่จะจัดเก็บอินสแตนซ์จำนวนหนึ่งสำหรับการใช้งานซ้ำ โปรดจำไว้ว่า การสร้างและการลบออบเจ็กต์เป็นการดำเนินการที่มีราคาแพง

ไปทำงานกันเถอะสุภาพบุรุษ

หนึ่งตัวอย่างมีค่าหนึ่งพันคำ คุณสามารถเลื่อนดูคู่มือและดูคำทักทายมาตรฐานโดยไม่มีเรา ดังนั้นเราจะถือว่าคุณได้ทำสิ่งนี้ไปแล้วและพร้อมที่จะนำตัวอย่างที่น่าสนใจไปใช้

คุณและฉันจะมีส่วนร่วมในแอปพลิเคชันฝั่งเซิร์ฟเวอร์ของ Java และเขียนโปรแกรมขนาดเล็กเพื่อ "ตรวจสอบ" ผู้ใช้เครือข่ายโซเชียล ในการทำเช่นนี้ คุณไม่จำเป็นต้องหางานที่ NSA ด้วยซ้ำ ผู้ใช้โพสต์ทุกอย่างเกี่ยวกับตัวเอง และสิ่งที่เราต้องทำคือรับข้อมูลนี้ จัดระบบ และจัดแสดงไว้อย่างสวยงาม ลองใช้บริการโซเชียลยอดนิยมอย่าง foursquare และวาดการเคลื่อนไหวของเพื่อนของเราบนแผนที่

ก่อนอื่น มาดูกันว่าเราจะได้ประโยชน์อะไรจาก foursquare หลังจากที่ได้ดูหน้าต่างๆ สำหรับนักพัฒนาแล้ว เราจึงหันมาสนใจสองวิธี:

• https://developer.foursquare.com/docs/users/checkins - สถานที่ที่ผู้ใช้เยี่ยมชม น่าเสียดายที่ขณะนี้รองรับเฉพาะผู้ใช้ที่ลงทะเบียนในโปรแกรมเท่านั้น และมีข่าวลือว่าจะยังคงเป็นเช่นนั้น เนื่องจากข้อจำกัดในการใช้งาน
• https://developer.foursquare.com/docs/checkins/recent - สถานที่ที่เพื่อนของผู้ใช้ที่ลงทะเบียนเยี่ยมชม หากคุณเล่นกับฟังก์ชั่นนี้สักหน่อย ความจริงที่น่าเศร้าก็ชัดเจน: สำหรับเพื่อนแต่ละคน จะมีการคืนสถานที่หนึ่งแห่ง - สถานที่สุดท้ายที่เขาเช็คอินสำหรับเพื่อนแต่ละคน

หากต้องการใช้ foursquare API คุณต้องลงทะเบียนแอปพลิเคชันในอนาคตของเรา โดยไปที่ที่อยู่นี้: https://ru.foursquare.com/developers/register และกรอกข้อมูลในฟิลด์ (ใช่ คุณจะต้องลงทะเบียนใน foursquare ด้วย แต่คุณจะทำมันได้ดีโดยไม่มีฉัน)

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

ขึ้นไปถึงก้อนเมฆ

Captain Obvious บ่งบอกว่าแอปพลิเคชันเซิร์ฟเวอร์ใด ๆ ต้องใช้เซิร์ฟเวอร์ในการทำงาน การเพิ่มเซิร์ฟเวอร์ด้วยตัวเองเป็นเรื่องที่ยุ่งยาก ดังนั้นเราจะใช้โซลูชันคลาวด์ที่ได้รับความนิยมในปัจจุบัน คลาวด์จะได้รับการสนับสนุนจาก Google Corporation เนื่องจาก Google App Engine ของพวกเขานั้นฟรีและค่อนข้างง่ายในการติดตั้งและใช้งาน ขั้นแรก ไปที่นี่และดาวน์โหลด Google App Engine SDK สำหรับ Java

ตอนนี้คุณสามารถเริ่มสร้างโครงการได้แล้ว สำหรับการพัฒนา Java ฉันใช้ IntelliJ IDEA แต่คุณสามารถใช้สภาพแวดล้อม Eclipse ฟรีและเป็นที่รู้จักไม่แพ้กัน

ลองเลือกโปรเจ็กต์ Java ใหม่ ลองเรียกมันว่า nsa_tracker

ในแท็บถัดไป ทำเครื่องหมาย Web Application และ Google App Engine ทางด้านซ้าย และระบุเส้นทางไปยัง App Engine SDK ที่ดาวน์โหลดและคลายแพ็กไว้ก่อนหน้านี้

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

มาเริ่มค้นหากันเลย

ดังนั้นเราจึงมีโฟลเดอร์โปรเจ็กต์ซึ่งมีโฟลเดอร์ src เราจะใส่แหล่งที่มาที่นั่น ซอร์ส Java ถูกจัดกลุ่มเป็นแพ็คเกจ แพ็คเกจคือโฟลเดอร์บนดิสก์ จำเป็นต้องใช้แพ็คเกจเพื่อไม่ให้ทิ้งแหล่งข้อมูลทั้งหมดลงในฮีป แต่เพื่อแยกแหล่งที่มาออกตามหลักการของตรรกะ ตัวอย่างเช่น รหัสที่เกี่ยวข้องกับส่วนต่อประสานกับผู้ใช้จะถูกวางไว้ในแพ็คเกจ UI การโต้ตอบเครือข่าย - ในแพ็คเกจเครือข่าย สิ่งนี้อำนวยความสะดวกอย่างมากในการพัฒนาและสนับสนุนโครงการในภายหลัง ในอดีต แนวทางปฏิบัติคือการเริ่มต้นโครงสร้างแพ็คเกจด้วยชื่อบริษัทตามด้วยชื่อโปรแกรม สิ่งนี้จะช่วยให้คุณระบุแหล่งที่มาของเราได้อย่างง่ายดายจากแหล่งที่คล้ายกันในอนาคต สำหรับโปรแกรมของเรา เราจะสร้างแพ็คเกจ org.nsa.tracker เราจะสร้างคลาสในนั้น

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

หากต้องการทำงานกับ foursquare API เราจะใช้ไลบรารี foursquare-api-java ฟรี ซึ่งสามารถรับได้จากที่นี่ ไลบรารี Java เป็นไฟล์ ZIP ที่มีส่วนขยาย jar ซึ่งมีคลาส Java ที่คอมไพล์แล้วซึ่งใช้ฟังก์ชันการทำงานเฉพาะ ในการอนุญาต เราจะต้องมี ClientId และ ClientSecret ที่ได้รับระหว่างขั้นตอนการลงทะเบียนแอปพลิเคชันใน foursquare เนื่องจากพารามิเตอร์เหล่านี้ไม่เปลี่ยนแปลงระหว่างการทำงานของโปรแกรม เราจะประกาศให้เป็นค่าคงที่

สตริงสุดท้ายคงที่ส่วนตัว CLIENT_ID = "FAKE_CLIENT_ID"; สตริงสุดท้ายคงที่ส่วนตัว CLIENT_SECRET = "FAKE_CLIENT_SECRET";

Final หมายความว่าตัวแปรนี้ได้รับการกำหนดค่าสุดท้ายที่ไม่สามารถเปลี่ยนแปลงได้ คงที่ทำให้ตัวแปรพร้อมใช้งานสำหรับทุกอินสแตนซ์ของคลาสที่กำหนด เมื่อใช้ตัวอย่างการอนุญาตจากไลบรารี foursquare-api-java เราได้รับโค้ดต่อไปนี้โดยประมาณ:

โมฆะที่ได้รับการป้องกัน doGet (คำขอ HttpServletRequest, HttpServletResponse resp) พ่น ServletException, IOException ( FoursquareApi foursquareApi = new FoursquareApi (CLIENT_ID, CLIENT_SECRET, CALLBACK_URL); รหัสสตริง = req.getParameter ("code"); if (รหัส == null) ( // ไปที่หน้าการลงทะเบียน resp.sendRedirect(foursquareApi.getAuthenticationUrl()); else ( ลอง ( foursquareApi.authenticateCode(code); // การลงทะเบียนสำเร็จ โหลดข้อมูลผลลัพธ์ ผลลัพธ์ = foursquareApi.checkinsRecent("0.0,0.0", 100, 0l);

) จับ (FoursquareApiException e) ( e.printStackTrace(); ) ) )

สังเกตเห็น "พ่น ServletException, IOException" ในการประกาศวิธีการ บรรทัดนี้หมายความว่าวิธีการนี้อาจส่งข้อยกเว้นข้อใดข้อหนึ่งเหล่านี้ ข้อยกเว้นใน Java คืออ็อบเจ็กต์ที่ส่งสัญญาณการเกิดขึ้นของสถานการณ์พิเศษ สามารถตรวจสอบได้และไม่สามารถตรวจสอบได้ ข้อยกเว้นที่ตรวจสอบจะต้องได้รับการจัดการโดยส่วนของโค้ดที่ล้อมรอบด้วยบล็อก try-catch หรือผ่านด้านบน โดยทั่วไปแล้วข้อยกเว้นที่ไม่ได้ตรวจสอบจะไม่ได้รับการจัดการเนื่องจากเกิดขึ้นเมื่อโปรแกรมไม่สามารถกู้คืนสถานะได้ ในวิธีนี้เราจะจัดการเฉพาะ FoursquareApiException เท่านั้น

เมื่อเว็บเซิร์ฟเวอร์ได้รับคำขอสำหรับแอปพลิเคชัน เว็บเซิร์ฟเวอร์จะใช้ตัวอธิบายการปรับใช้เพื่อจับคู่ URL คำขอกับโค้ดที่ควรจัดการคำขอ ตัวอธิบายการปรับใช้คือไฟล์ XML ที่เรียกว่า web.xml มาเพิ่มคำอธิบายของเซิร์ฟเล็ตการติดตามกัน ติดตาม เมื่อเว็บเซิร์ฟเวอร์ได้รับคำขอสำหรับแอปพลิเคชัน เว็บเซิร์ฟเวอร์จะใช้ตัวอธิบายการปรับใช้เพื่อจับคู่ URL คำขอกับโค้ดที่ควรจัดการคำขอ ตัวอธิบายการปรับใช้คือไฟล์ XML ที่เรียกว่า web.xml มาเพิ่มคำอธิบายของเซิร์ฟเล็ตการติดตามกัน org.nsa.tracker.TrackerServlet

/ติดตาม

ตอนนี้คำขอ /track จะถูกประมวลผลโดยเซิร์ฟเล็ตของเราชื่อ TrackerServlet คุณสามารถตั้งค่าพารามิเตอร์ Callback Url ให้เป็นค่าที่ถูกต้อง http://localhost:8080/track

ในการแสดงผลลัพธ์ คุณสามารถใช้ Static Maps API ซึ่งกรุณาจัดทำโดยบริษัท Google เดียวกัน (https://developers.google.com/maps/documentation/staticmaps/) เซิร์ฟเล็ตของเราจะสร้างหน้า HTML แบบง่ายและส่งคืนตามคำขอของผู้ใช้ ตัวติดตามเอ็นเอสเอ ตัวติดตามเอ็นเอสเอ

"); sb.ผนวก(" "); index = 1; for (เช็คอินเช็คอิน: result.getResult()) ( sb.append("").ผนวก(ดัชนี++).ผนวก(" - ").ผนวก(checkin.getUser().getFirstName()).ผนวก(" ").ผนวก(checkin.getUser().getLastName()).ผนวก("

"); sb.ผนวก("");

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

ไบต์ resultBytes = sb.toString().getBytes("utf-8"); resp.setContentLength(resultBytes.length); resp.getOutputStream().write(resultBytes);

...และทุกอย่างก็พร้อมแล้ว เราเปิดตัวมันและเห็นสิ่งที่คล้ายกับรูปภาพที่มีข้อความว่า “ผลลัพธ์ของโปรแกรม”

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

แต่ฉันหวังว่าฉันจะประสบความสำเร็จในสิ่งสำคัญ: เพื่อโน้มน้าวคุณว่า Java นั้นเรียบง่ายและยอดเยี่ยม เจอกันอีกเดือน!

หนังสือสำหรับโปรแกรมเมอร์ Java

เราขอแนะนำให้เริ่มเรียนภาษาด้วยหนังสือ “Java. Java: คู่มือสำหรับผู้เริ่มต้นโดย Herbert Schildt ระดับต่อไปคือ “Java. คู่มือฉบับสมบูรณ์" มาจากเขา และคุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับเซิร์ฟเล็ตได้จากหนังสือ "Java Servlets และ JSP Cookbook" โดย Bruce W. Perry

เซิร์ฟเล็ต - นี่คือ Java-nporpaMMa ซึ่งใช้คลาสเป็นซูเปอร์คลาส HttpServiet. เซิร์ฟเล็ตใช้เพื่อขยายขีดความสามารถของเซิร์ฟเวอร์ที่มีอยู่ โดยเฉพาะเว็บเซิร์ฟเวอร์ โดยปกติแล้ว เซิร์ฟเล็ตจะรันบนเซิร์ฟเวอร์พิเศษ เซิร์ฟเวอร์ดังกล่าวเรียกว่า Java Application Servers แอปพลิเคชันเซิร์ฟเวอร์ Java มีเว็บเซิร์ฟเวอร์เป็น Building Block (บางครั้งก็ไม่ใช่หนึ่งเดียว แต่หลายตัว) รวมถึงเซิร์ฟเวอร์ที่ทำงานร่วมกับส่วนประกอบเซิร์ฟเวอร์ เซิร์ฟเวอร์บริการเสริม ฯลฯ เซิร์ฟเล็ตทำงานในสภาพแวดล้อมที่เซิร์ฟเวอร์จัดเตรียมไว้ให้ ส่วนของเซิร์ฟเวอร์ที่ออกแบบมาเพื่อจัดการเซิร์ฟเล็ตเรียกว่าคอนเทนเนอร์เซิร์ฟเล็ต ข้อมูลจำเพาะของเซิร์ฟเล็ตถือว่ามีวิธีการมาตรฐานอยู่ในคลาสเซิร์ฟเล็ต ซึ่งการดำเนินการเกิดขึ้นในขั้นตอนหนึ่งของวงจรชีวิตของเซิร์ฟเล็ต วิธีการเหล่านี้ถูกเรียกโดยคอนเทนเนอร์เซิร์ฟเล็ต การใช้งานข้อกำหนดเฉพาะของเซิร์ฟเล็ตจะรวมอยู่ในแพ็คเกจภาษา Java มาตรฐาน

หนังสือเล่มนี้ครอบคลุมถึงแอปพลิเคชันเซิร์ฟเวอร์ Java ชื่อ Blazix Blazix Server มอบชุดความสามารถที่สมบูรณ์สำหรับการทำงานกับเซิร์ฟเล็ต นอกเหนือจากการสร้างคลาสเซิร์ฟเล็ต (หรือคลาส) รวมถึงการกำหนดค่าโปรแกรมเซิร์ฟเล็ตที่สร้างขึ้นและติดตั้งบนเซิร์ฟเวอร์ คุณต้องเปลี่ยนไฟล์การกำหนดค่าเว็บเซิร์ฟเวอร์ ค่าพื้นฐานระบุไว้ในไฟล์กำหนดค่าดังนี้ servlet.name: myservlet

servlet.myservlet.className: mypackage.MyServletClass servlet.myservlet.url: /mysrvlet

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

ลูกค้าถามเว็บเซิร์ฟเวอร์ถึงที่อยู่ของเซิร์ฟเล็ต (ต้องระบุที่อยู่เป็นค่าของ servlet.myservlet.url ในไฟล์คอนฟิกูเรชันของเว็บเซิร์ฟเวอร์) เซิร์ฟเวอร์ส่งคำขอและข้อมูล (ถ้ามี) ไปยังเซิร์ฟเล็ต รับการตอบกลับจากเซิร์ฟเล็ต และส่งต่อไปยังไคลเอนต์

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

สิ่งสำคัญอย่างยิ่งที่ต้องจำไว้คือต้องระบุคลาสพาธของเซิร์ฟเล็ตในตัวแปร ciasspath หรือสามารถวางไว้ในไดเร็กทอรี C:\Blazix\classes หรือในไดเร็กทอรีที่ระบุในไฟล์การกำหนดค่าเว็บเซิร์ฟเวอร์เป็น server.ciassDir หลังจากแก้ไขไฟล์คอนฟิกูเรชันเพื่อรวมข้อมูลเกี่ยวกับเซิร์ฟเล็ตใหม่แล้ว เซิร์ฟเวอร์จะต้องหยุดและเริ่มต้นใหม่อีกครั้ง เซิร์ฟเล็ตยังสามารถวางบนเซิร์ฟเวอร์ที่รันอยู่โดยใช้ยูทิลิตีการดูแลระบบ แต่ในการดำเนินการนี้ เซิร์ฟเล็ตต้องถูกแพ็กเกจในไฟล์ WAR ที่เก็บถาวรของเว็บ หากไฟล์คลาสเซิร์ฟเล็ตมีการเปลี่ยนแปลง ไม่จำเป็นต้องหยุดเซิร์ฟเวอร์และเริ่มต้นใหม่อีกครั้ง ตามค่าเริ่มต้น เซิร์ฟเวอร์ได้รับการกำหนดค่าเพื่อให้การเรียกเซิร์ฟเล็ตที่ http://localhost:81/_reload ทำให้คลาสทั้งหมดถูกรีโหลด และคลาสเซิร์ฟเล็ตที่แก้ไขจะพร้อมใช้งานสำหรับคำขอของไคลเอ็นต์ (รูปที่ 4.1) ไปที่หน้านี้หลังจากแก้ไขไฟล์คลาสเซิร์ฟเล็ตแล้ว การหยุดเซิร์ฟเวอร์นั้นไม่จำเป็นเลย

หากผู้อ่านมีประสบการณ์เกี่ยวกับเซิร์ฟเล็ตมาบ้างแล้ว เขาจะประทับใจกับความเรียบง่ายที่เซิร์ฟเวอร์ Blazix เปรียบเทียบกับเซิร์ฟเวอร์ Java อื่นๆ เช่น Tomcat

ในการเริ่มต้นทันที ลองดูตัวอย่างง่ายๆ เซิร์ฟเล็ตบางส่วน Servlet (รายการ 4.1)

รายการ 4.1. เซิร์ฟเล็ต SomeServlet.java I

นำเข้า java.io.*; นำเข้า javax.servlet.*; นำเข้า javax.servlet.http.*;

คลาสสาธารณะ SomeServlet ขยาย HttpServlet ( โมฆะสาธารณะ doGet (คำขอ HttpServletRequest,

การตอบสนอง HttpServletResponse) พ่น ServletException, IOException ( Printwriter out = response.getWriter(); out.println("Hello World");

ในไฟล์คอนฟิกูเรชันของเว็บเซิร์ฟเวอร์ ให้เขียนดังต่อไปนี้:

servlet.name: ก่อน

servlet.first.className: SomeServlet

servlet.first.url: /dofirst

จากนั้นการเข้าถึงเซิร์ฟเล็ตจากเบราว์เซอร์จะมีลักษณะดังนี้ http://localhost:81 /dofirst (รูปที่ 4.2)

Java servlet จัดเตรียมวิธีการที่ไม่ขึ้นกับแพลตฟอร์มสำหรับการสร้างเว็บแอปพลิเคชัน (ซึ่งไม่ได้ขัดแย้งกัน แต่เราจะไม่พูดถึงปัญหานี้เพิ่มเติม เนื่องจากจากนั้นเราจะต้องตัดสินใจว่าเว็บแอปพลิเคชันหมายถึงอะไร ซึ่งไม่รวมอยู่ในรายการ ของหัวข้อต่างๆ ที่ครอบคลุม) และแอปพลิเคชั่นจำนวนมาก ทำงานได้รวดเร็วและไม่มีข้อจำกัดที่แอปพลิเคชั่น CGI มี เซิร์ฟเล็ตทำงานภายใต้การควบคุมของเว็บเซิร์ฟเวอร์ และไม่เหมือนกับแอปเพล็ตตรงที่ไม่จำเป็นต้องมีอินเทอร์เฟซผู้ใช้แบบกราฟิก เซิร์ฟเล็ตโต้ตอบกับเซิร์ฟเวอร์โดยแลกเปลี่ยนคำขอและการตอบกลับกับเซิร์ฟเวอร์ โปรแกรมไคลเอนต์ทำการร้องขอไปยังเซิร์ฟเวอร์ คำขอได้รับการประมวลผลโดยเซิร์ฟเวอร์ ส่งผ่านไปยังเซิร์ฟเล็ต และเซิร์ฟเล็ตส่งการตอบกลับผ่านเซิร์ฟเวอร์ไปยังไคลเอนต์ ปัจจุบัน เซิร์ฟเล็ตได้รับความนิยมอย่างมากเมื่อสร้างแอปพลิเคชันเว็บเชิงโต้ตอบ มีเว็บเซิร์ฟเวอร์จำนวนมากที่สามารถจัดการเซิร์ฟเล็ตได้ รวมถึง Tomcat, iPlanet Web Server (เดิมคือ Netscape

เซิร์ฟเวอร์องค์กร), Blazix J Builder Enterprise ใช้ Borland Enterprise Server (BES) ที่รวมอยู่ และยังรองรับเซิร์ฟเวอร์ Web Logic, WebSphere และ iPlanet J Builder Enterprise Server มีเซิร์ฟเวอร์ Tomcat เริ่มต้น

ข้าว. 4.2. การเรียกเซิร์ฟเล็ต

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

เทคโนโลยี JSP ซึ่งทุ่มเทให้กับบทที่ 3 เป็นส่วนขยายของเทคโนโลยีเซิร์ฟเล็ต โดย JSP มุ่งเน้นไปที่การทำงานกับเอกสาร HTML และ XML แฟรกเมนต์ JSP พบการใช้งานทั่วไปโดยเป็นส่วนหนึ่งของโค้ด HTML และ XML จะตัดสินใจเลือกและตัดสินใจว่าจะใช้เซิร์ฟเล็ตหรือเพจเซิร์ฟเวอร์ได้อย่างไร? เซิร์ฟเล็ตเหมาะสำหรับการแก้ปัญหาการเขียนโปรแกรมระดับต่ำมากกว่า และไม่เหมาะสมสำหรับการแก้ปัญหาการสร้างตรรกะการนำเสนอแอปพลิเคชัน ในทางกลับกัน เพจเซิร์ฟเวอร์ JSP มุ่งเน้นไปที่วิธีการนำเสนอผลลัพธ์แก่ผู้ใช้ในวิธีที่สะดวกที่สุดเป็นหลัก หน้าฝั่งเซิร์ฟเวอร์ถูกสร้างขึ้นแบบอินไลน์ด้วยโค้ด HTML โดยใช้รูปแบบการเขียนเอกสาร HTML เทคโนโลยี JSP มอบความสามารถที่สมบูรณ์ยิ่งขึ้นมากกว่า HTML ธรรมดา เพจ JSP สามารถจัดเตรียมความสามารถในการนำตรรกะของแอปพลิเคชันไปใช้โดยใช้คอมโพเนนต์ Java แบบธรรมดา รวมถึงคอมโพเนนต์เซิร์ฟเวอร์ EJB โดยการสร้างไลบรารีทางลัดแบบกำหนดเอง หน้าเซิร์ฟเวอร์ Java เองสามารถเป็นส่วนประกอบตรรกะการนำเสนอแบบโมดูลาร์ที่สามารถนำมาใช้ซ้ำได้ ซึ่งสามารถใช้ร่วมกับเทมเพลตและตัวกรองต่างๆ เพจ JSP จะถูกแปลงเป็นเซิร์ฟเล็ต ดังนั้นในทางทฤษฎี คุณสามารถใช้เซิร์ฟเล็ตโดยเฉพาะได้ อย่างไรก็ตาม เทคโนโลยี JSP ถูกสร้างขึ้นเพื่อลดความซับซ้อนของกระบวนการสร้างเอกสารเว็บโดยแยกตรรกะการนำเสนอแอปพลิเคชันออกจากเนื้อหาเอกสาร ในกรณีส่วนใหญ่ การตอบกลับที่ส่งไปยังไคลเอนต์ประกอบด้วยทั้งเทมเพลตการนำเสนอเอกสารและข้อมูลที่สร้างขึ้นโดยอัตโนมัติโดยการกรอกเทมเพลต ในสถานการณ์เช่นนี้ การทำงานกับ JSP จะง่ายกว่าการใช้เซิร์ฟเล็ตมาก