การทำงานกับส่วนหัว HTTP ใน Spring MVC: คำแนะนำสำหรับ @RequestHeader และ @ResponseHeader

การแนะนำ

ส่วนหัว HTTP เป็นพื้นฐานในกระบวนการสื่อสารระหว่างไคลเอนต์และเซิร์ฟเวอร์ โดยจะให้ข้อมูลที่เป็นประโยชน์เกี่ยวกับคำขอหรือการตอบกลับ เช่น ประเภทของเนื้อหา ชุดอักขระ การตั้งค่าภาษา และอื่นๆ Spring MVC หนึ่งในเฟรมเวิร์ก Java ที่ใช้กันอย่างแพร่หลาย มอบวิธีที่ง่ายและสวยงามในการทำงานกับส่วนหัว HTTP โดยใช้คำอธิบายประกอบ @RequestHeader และ @ResponseHeader ในคู่มือนี้ เราจะเจาะลึกว่าคำอธิบายประกอบเหล่านี้ทำงานอย่างไร และจะปรับปรุงเว็บแอปพลิเคชันของเราได้อย่างไร

รู้เบื้องต้นเกี่ยวกับส่วนหัว HTTP

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

ตัวอย่างเช่น:

Content-Type: text/html; charset=UTF-8

ในที่นี้ชื่อของส่วนหัวคือ "ประเภทเนื้อหา" และค่าของส่วนหัวระบุว่าเนื้อหาเป็นเอกสาร HTML ที่มีการเข้ารหัส UTF-8

ประเภทของส่วนหัว HTTP

ส่วนหัว HTTP สามารถแบ่งประเภทกว้างๆ ได้เป็นประเภทต่อไปนี้:

• ส่วนหัวทั่วไป: สิ่งเหล่านี้ปรากฏอยู่ในทั้งข้อความคำขอและคำตอบ แต่ไม่เกี่ยวข้องโดยตรงกับข้อมูลของร่างกาย ตัวอย่าง ได้แก่ Cache-Control, Connection และ Date
• ส่วนหัวของคำขอ: ส่วนหัวเหล่านี้ให้ข้อมูลเพิ่มเติมเกี่ยวกับทรัพยากรที่จะดึงข้อมูลหรือเกี่ยวกับตัวไคลเอ็นต์เอง ส่วนหัวคำขอทั่วไปบางรายการคือ User-Agent (ให้ข้อมูลเกี่ยวกับตัวแทนผู้ใช้ที่ส่งคำขอ) และ Accept (ระบุประเภทสื่อที่ไคลเอ็นต์สามารถประมวลผลได้)
• ส่วนหัวการตอบกลับ:ตามชื่อที่แนะนำ ส่วนหัวการตอบกลับจะให้ข้อมูลเพิ่มเติมเกี่ยวกับการตอบกลับของเซิร์ฟเวอร์ ส่วนหัวเช่น Location (ใช้ในการเปลี่ยนเส้นทาง) และ Server (อธิบายซอฟต์แวร์ที่ใช้โดยเซิร์ฟเวอร์ต้นทาง) เป็นตัวอย่าง
• ส่วนหัวของเอนทิตี:ใช้เพื่อระบุข้อมูลเกี่ยวกับเนื้อหาของทรัพยากร เช่น ความยาวหรือประเภทของทรัพยากร Content-Type (ระบุประเภทของทรัพยากร) และ Content-Length (ระบุขนาดของการตอบกลับ) เป็นตัวอย่างคลาสสิก
• ส่วนหัวที่กำหนดเอง: นอกเหนือจากส่วนหัวมาตรฐานแล้ว นักพัฒนาซอฟต์แวร์สามารถกำหนดส่วนหัวที่กำหนดเองของตนเองได้ ส่วนหัวที่กำหนดเองมักจะขึ้นต้นด้วย 'X-' (แม้ว่าแบบแผนนี้จะเลิกใช้แล้ว) เช่น X-Frame-Options

ความสำคัญของส่วนหัว HTTP

ส่วนหัว HTTP ไม่ได้เป็นเพียงพาหะของข้อมูลเมตาเท่านั้น พวกเขามีอิทธิพลอย่างมากต่อวิธีการทำงานของเว็บแอปพลิเคชัน:

• การเจรจา: ส่วนหัวสามารถใช้เพื่อเจรจาประเภทของเนื้อหาที่แสดง (HTML, JSON, XML) หรือการเข้ารหัสที่ใช้
• ความปลอดภัย: ส่วนหัวบางส่วนมีบทบาทสำคัญในการเพิ่มความปลอดภัยของเว็บ ส่วนหัว Strict-Transport-Security ช่วยให้มั่นใจได้ว่าเว็บไซต์สามารถเข้าถึงได้ผ่าน HTTPS เท่านั้น ในขณะที่ Content-Security-Policy ช่วยป้องกันการโจมตีด้วยสคริปต์ข้ามไซต์
• ประสิทธิภาพ:ส่วนหัวควบคุมพฤติกรรมการแคชและอาจส่งผลต่อประสิทธิภาพของเว็บแอปพลิเคชันอย่างมาก การใช้ส่วนหัวแคชอย่างเหมาะสมสามารถลดการโหลดของเซิร์ฟเวอร์และปรับปรุงเวลาในการโหลดเพจได้

คำอธิบายประกอบ @RequestHeader

ใน Spring MVC คำอธิบายประกอบจะทำให้กระบวนการพัฒนาเว็บแอปพลิเคชันง่ายขึ้น เพื่อให้มั่นใจว่านักพัฒนาสามารถมุ่งเน้นไปที่ตรรกะหลักมากกว่าแบบสำเร็จรูป คำอธิบายประกอบที่ทรงพลังอย่างหนึ่งคือ @RequestHeader โดยจะผูกค่าของส่วนหัว HTTP เข้ากับพารามิเตอร์วิธีการ ทำให้สามารถรวมข้อมูลส่วนหัวภายในวิธีการควบคุมของคุณได้อย่างราบรื่น

ทำความเข้าใจกับ @RequestHeader

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

ตัวอย่าง:

@RequestMapping("/fetchContentType")
public String getContentType(@RequestHeader("Content-Type") String contentType) {
    return "Content Type is: " + contentType;
}

ในข้อมูลโค้ดด้านบน เมธอด getContentType รับค่าของส่วนหัว 'Content-Type' โดยอัตโนมัติจากคำขอ HTTP ขาเข้า ต้องขอบคุณ @RequestHeader

การจัดการหลายส่วนหัว

อาจมีสถานการณ์ที่คุณต้องดึงข้อมูลส่วนหัวมากกว่าหนึ่งรายการ แทนที่จะประกาศหลายพารามิเตอร์ คุณสามารถใช้ Map:

@RequestMapping("/fetchHeaders")
public String getHeaders(@RequestHeader Map<String, String> headers) {
    return "Headers are: " + headers.toString();
}

วิธีการนี้จะดึงส่วนหัวทั้งหมดจากคำขอและวางไว้ในแผนที่

การจัดการส่วนหัวเสริม

รับประกันว่าจะไม่แสดงส่วนหัวทั้งหมดในทุกคำขอ ในกรณีดังกล่าว คุณลักษณะ required ของคำอธิบายประกอบจะมีประโยชน์:

@RequestMapping("/optionalHeader")
public String getOptionalHeader(@RequestHeader(value = "optional-header", required = false) String headerValue) {
    return headerValue != null ? "Header value is: " + headerValue : "Header not present.";
}

ในที่นี้ หาก “ตัวเลือกส่วนหัว” ไม่ได้เป็นส่วนหนึ่งของคำขอ ก็จะไม่มีข้อผิดพลาดเกิดขึ้น และวิธีการจะจัดการอย่างดี

ค่าเริ่มต้น

สำหรับส่วนหัวที่อาจเป็นทางเลือก Spring มีตัวเลือกในการตั้งค่าเริ่มต้น หากไม่มีส่วนหัวในคำขอ ระบบจะใช้ค่าเริ่มต้น:

@RequestMapping("/defaultHeaderValue")
public String getDefaultHeader(@RequestHeader(value = "X-Custom-Header", defaultValue = "default-value") String headerValue) {
    return "Header value is: " + headerValue;
}

ในตัวอย่างข้างต้น หากไม่พบ “X-Custom-Header” ในคำขอที่เข้ามา headerValue จะถูกตั้งค่าเป็น 'ค่าเริ่มต้น'

การแปลงประเภท

ความสามารถในการแปลงประเภทของ Spring MVC สามารถแปลงค่าส่วนหัวเป็นประเภทข้อมูลที่ต้องการได้โดยอัตโนมัติ:

@RequestMapping("/fetchDate")
public String getDate(@RequestHeader("Date") Date date) {
    return "Date header as a Date object: " + date.toString();
}

หากส่วนหัว “Date” ถูกส่งในรูปแบบวันที่ที่ถูกต้อง Spring จะแปลงเป็นวัตถุ Date โดยอัตโนมัติ

คำอธิบายประกอบ @ResponseHeader

แม้ว่าคำอธิบายประกอบ @RequestHeader จะเกี่ยวกับการอ่านส่วนหัวที่เข้ามา แต่เมื่อต้องตั้งค่าส่วนหัวในการตอบสนอง HTTP นั้น Spring MVC ก็ใช้วิธีการที่แตกต่างออกไปเล็กน้อย ตรงกันข้ามกับชื่อที่อาจแนะนำ ไม่มีคำอธิบายประกอบ @ResponseHeader โดยตรงใน Spring MVC อย่างไรก็ตาม นักพัฒนาสามารถใช้เครื่องมือเช่น HttpServletResponse และ ResponseEntity ที่หรูหรากว่าเพื่อให้ได้ผลลัพธ์ที่ต้องการ

การใช้ HttpServletResponse

วิธีดั้งเดิมของ Servlet API ในการตั้งค่าส่วนหัวการตอบกลับคือผ่านอ็อบเจ็กต์ HttpServletResponse วัตถุนี้มีวิธีการควบคุมและแก้ไขการตอบสนองที่ส่งไปยังไคลเอนต์

@RequestMapping("/setHeaderUsingServlet")
public void setHeaderUsingServlet(HttpServletResponse response) {
    response.setHeader("X-Custom-Header", "CustomHeaderValue");
    response.getWriter().write("Header has been set!");
}

ในตัวอย่างนี้ "X-Custom-Header" ถูกตั้งค่าไว้ในการตอบกลับ จากนั้นข้อความธรรมดาจะถูกเขียนลงในเนื้อหาการตอบกลับ

การใช้ ResponseEntity

แม้ว่า HttpServletResponse เสนอวิธีที่ตรงไปตรงมาในการตั้งค่าส่วนหัว แต่คลาส ResponseEntity นำเสนอแนวทางที่ซับซ้อนและเชิงวัตถุมากกว่า โดยเฉพาะอย่างยิ่งมีประโยชน์ในแอปพลิเคชัน RESTful

@RequestMapping("/setHeaderUsingEntity")
public ResponseEntity<String> setHeaderWithEntity() {
    HttpHeaders headers = new HttpHeaders();
    headers.set("X-Custom-Header", "CustomHeaderValue");
    
    return new ResponseEntity<>("Body with custom header", headers, HttpStatus.OK);
}

ResponseEntity มีวิธีแสดงการตอบสนอง HTTP ทั้งหมด รวมถึงสถานะ ส่วนหัว และเนื้อหา ในตัวอย่างข้างต้น เราสร้างการตอบกลับใหม่ด้วยส่วนหัวที่กำหนดเองและส่งคืน

การตั้งค่าหลายส่วนหัว

หากคุณต้องการตั้งค่าหลายส่วนหัวในการตอบกลับ ทั้ง HttpServletResponse และ ResponseEntity ทำให้มันค่อนข้างง่าย:

ใช้ HttpServletResponse:

@RequestMapping("/setMultipleHeadersServlet")
public void setMultipleHeadersServlet(HttpServletResponse response) {
    response.setHeader("X-Custom-Header-1", "Value1");
    response.setHeader("X-Custom-Header-2", "Value2");
    response.getWriter().write("Multiple headers have been set!");
}

ใช้ ResponseEntity:

@RequestMapping("/setMultipleHeadersEntity")
public ResponseEntity<String> setMultipleHeadersEntity() {
    HttpHeaders headers = new HttpHeaders();
    headers.set("X-Custom-Header-1", "Value1");
    headers.set("X-Custom-Header-2", "Value2");
    
    return new ResponseEntity<>("Body with multiple headers", headers, HttpStatus.OK);
}

ใช้กรณีของส่วนหัวการตอบกลับ

การตั้งค่าส่วนหัวการตอบสนองไม่ได้เป็นเพียงตัวเลือกเชิงโวหารเท่านั้น แต่ยังส่งผลต่อพฤติกรรมของแอปพลิเคชันได้อย่างมาก:

• การควบคุมแคช: ส่วนหัว เช่น Cache-Control สามารถแนะนำไคลเอ็นต์เกี่ยวกับวิธีการแคชการตอบสนอง ซึ่งอาจช่วยปรับปรุงประสิทธิภาพของแอปพลิเคชันได้
• ความปลอดภัย: ส่วนหัวเช่น X-Frame-Options หรือ Strict-Transport-Security สามารถบังคับใช้นโยบายความปลอดภัยได้ ทำให้เว็บแอปพลิเคชันมีความปลอดภัยมากขึ้น
• การจัดการเนื้อหา:หากคุณให้บริการดาวน์โหลดไฟล์ ส่วนหัว Content-Disposition สามารถใช้เพื่อแนะนำชื่อไฟล์และระบุว่าเบราว์เซอร์ควรแสดงไฟล์หรือถือเป็นไฟล์แนบหรือไม่

การใช้งานจริงของส่วนหัว HTTP

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

การเจรจาต่อรองเนื้อหา

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

ในฤดูใบไม้ผลิ MVC:

@RequestMapping(value = "/negotiateContent", produces = {"application/json", "application/xml"})
public ResponseEntity<User> getUser() {
    User user = new User("John", 30);
    return new ResponseEntity<>(user, HttpStatus.OK);
}

วิธีการควบคุมข้างต้นสามารถให้บริการวัตถุ User ในรูปแบบ JSON หรือ XML ขึ้นอยู่กับค่าส่วนหัว Accept ในคำขอที่เข้ามา

เสริมสร้างความปลอดภัย

ส่วนหัว HTTP สามารถเพิ่มระดับความปลอดภัยของแอปพลิเคชันของคุณได้อย่างมาก:

• X-Frame-Options:ส่วนหัวนี้สามารถป้องกันการโจมตีด้วยการคลิกแจ็คโดยการควบคุมว่าเบราว์เซอร์ควรได้รับอนุญาตให้แสดงผลหน้าเว็บใน <frame>, <iframe>, <embed> หรือ <object>

response.setHeader("X-Frame-Options", "DENY");

• Strict-Transport-Security: ส่วนหัวนี้ช่วยให้แน่ใจว่าการสื่อสารทั้งหมดจาก User Agent ควรทำผ่าน HTTPS สามารถตั้งค่าเป็น:

response.setHeader("Strict-Transport-Security", "max-age=31536000; includeSubDomains");

การจัดการแคชฝั่งไคลเอ็นต์

ส่วนหัว HTTP จะควบคุมวิธีการหรือแม้ว่าการใช้แคชในฝั่งไคลเอ็นต์จะส่งผลต่อประสิทธิภาพการทำงาน:

• การควบคุมแคช: กำหนดทิศทางกลไกการแคชทั้งหมดเกี่ยวกับวิธีการใช้การตอบสนอง

response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");

• หมดอายุ:ระบุวันที่/เวลาที่การตอบกลับถือว่าเก่าแล้ว

response.setHeader("Expires", "Tue, 03 Jul 2001 06:00:00 GMT");

การเปิดใช้งาน CORS

ส่วนหัวการแชร์ทรัพยากรข้ามต้นทาง (CORS) ช่วยให้คุณระบุต้นทางที่ได้รับอนุญาตให้อ่านทรัพยากรบนหน้าเว็บ

การใช้คำอธิบายประกอบ @CrossOrigin ของ Spring:

@CrossOrigin(origins = "https://allowed-origin.com")
@RequestMapping("/corsEnabledEndpoint")
public ResponseEntity<String> handleCORS() {
    return new ResponseEntity<>("CORS-enabled response", HttpStatus.OK);
}

วิธีการควบคุมข้างต้นจะยอมรับเฉพาะคำขอจาก “https://allowed-origin.com' เท่านั้น

จัดการการดาวน์โหลดไฟล์

ส่วนหัว HTTP สามารถอำนวยความสะดวกในการดาวน์โหลดไฟล์:

• การจัดการเนื้อหา: ระบุว่าเนื้อหาควรแสดงแบบอินไลน์หรือถือเป็นไฟล์แนบ

response.setHeader("Content-Disposition", "attachment; filename=\"filename.jpg\"");

สิ่งนี้จะแจ้งให้ผู้ใช้ดาวน์โหลดไฟล์ด้วยชื่อไฟล์ที่ระบุ

บทสรุป

ส่วนหัว HTTP มีบทบาทสำคัญในการเพิ่มประสิทธิภาพการทำงานและประสิทธิภาพของเว็บแอปพลิเคชัน Spring MVC มอบวิธีที่ง่ายดายในการทำงานกับส่วนหัวเหล่านี้โดยใช้กลไกคำอธิบายประกอบและการตอบสนอง @RequestHeader เช่น HttpServletResponse และ ResponseEntity ไม่ว่าคุณจะจัดการการเจรจาต่อรองเนื้อหา การกำหนดลักษณะภาษา หรือสร้างพฤติกรรมที่กำหนดเองตามส่วนหัว Spring MVC ก็พร้อมให้ความช่วยเหลือคุณ

1. เอกสารประกอบ Spring MVC
2. ส่วนหัว MDN HTTP
3. @CrossOrigin ในฤดูใบไม้ผลิ