สถานการณ์: ข้อมูลการอัปเดตแบ็กเอนด์ถูกส่งไปยังไคลเอนต์ (ส่วน Java ใช้เซิร์ฟเวอร์ Tomcat)
มีวิธีแก้ปัญหามากมายสำหรับการผลักดันข้อมูลในแบ็กเอนด์เช่นการสำรวจดาวหางและ WebSocket
1. การสำรวจเป็นค่าใช้จ่ายในการพัฒนาที่ต่ำที่สุดสำหรับแบ็กเอนด์ซึ่งหมายถึงการประมวลผลคำขอ AJAX และส่งคืนข้อมูลในแบบดั้งเดิม เมื่อฉันอยู่ในโรงเรียนโครงการห้องปฏิบัติการมักจะใช้การสำรวจเพราะมันปลอดภัยและง่ายที่สุดในการดำเนินการ อย่างไรก็ตามการเสียทรัพยากรการสื่อสารที่เกิดจากการสำรวจไม่สามารถเพิกเฉยได้ ไม่ว่าข้อมูลจะเปลี่ยนแปลงหรือไม่คำขอจะถูกส่งและตอบกลับตามปกติและคำขอ HTTP แต่ละครั้งจะมีข้อมูลส่วนหัวที่ยาวนาน
2. แนวคิดของดาวหางคือการเชื่อมต่อที่ยาวนาน หลังจากที่ลูกค้าส่งคำขอแบ็กเอนด์จะทำการเชื่อมต่อจนกว่าการเชื่อมต่อจะหมดเวลาหรือแบ็กเอนด์ส่งคืนข้อมูลจากนั้นสร้างการเชื่อมต่ออีกครั้งเพื่อถ่ายโอนทรัพยากรการสื่อสารไปยังเซิร์ฟเวอร์อย่างมีประสิทธิภาพซึ่งใช้ทรัพยากรเซิร์ฟเวอร์
3. WebSocket เป็นเทคโนโลยีการสื่อสารแบบฟูลเพล็กซ์ที่จัดทำโดย HTML5 มันตระหนักถึงการสื่อสารระหว่างไคลเอนต์และเซิร์ฟเวอร์ผ่าน "handshake" มันมีประสิทธิภาพแบบเรียลไทม์ที่ดีและหัวเล็ก เบราว์เซอร์ที่รองรับในปัจจุบันมีดังนี้:
สถานการณ์ในอุดมคติคือการใช้การผสมผสานของ WebSocket และ Comet และใช้วิธีดาวหางเพื่อลดระดับเบราว์เซอร์เช่น IE8 แต่ด้วยวิธีนี้แบ็กเอนด์จำเป็นต้องใช้สอง logics สำหรับการดำเนินการตามคำขอการประมวลผลคือ WebSocket และ Comet ดังนั้นบทความนี้ได้เพิ่ม Node.js เหตุผลในการทำเช่นนี้คือการถ่ายโอนตรรกะที่จัดการ WebSocket (หรือดาวหาง) ไปยังส่วน Node.js และไม่ "ชักนำปัญหา" ไปยังแบ็กเอนด์เพราะในสถานการณ์จริงมันไม่ใช่เรื่องง่ายสำหรับนักพัฒนาส่วนหน้าเพื่อส่งเสริมนักพัฒนาแบ็คเอนด์ Node.js เป็นเลเยอร์กลางสำหรับการสื่อสารระหว่างเบราว์เซอร์และเลเยอร์ตรรกะธุรกิจ Java เชื่อมต่อลูกค้ากับ Tomcat และการสื่อสารกับ Tomcat ผ่านซ็อกเก็ต (เป็นซ็อกเก็ตไม่ใช่ WebSocket และแบ็กเอนด์จำเป็นต้องใช้อินเทอร์เฟซซ็อกเก็ต
บนไคลเอนต์ WebSocket และ Comet จะถูกนำไปใช้ผ่าน socket.io Socket.io จะเลือกวิธีการใช้งานที่เหมาะสม (WebSocket, Long Pull .. ) สำหรับเบราว์เซอร์ที่แตกต่างกันหรือไคลเอนต์ที่แตกต่างกัน การแนะนำของ socket.io ทำให้ง่ายต่อการจัดการ websocket (หรือการเชื่อมต่อที่ยาว) ซ็อกเก็ต
ไคลเอนต์แนะนำ socket.io:
<script src = "static/js/socket.io.js"> </script>
รหัส JavaScript ไคลเอนต์:
var socket = io.connect ('127.0.0.1:8181'); // ส่งข้อมูลไปยัง Server Socket.emit ('FromwebClient', JSondata); // รับข้อมูลจาก Server Socket.on ('PushtowebClient', ฟังก์ชั่น (ข้อมูล) {// do sth.});รหัสเซิร์ฟเวอร์ node.js:
var http = reghed ('http'), app = http.createserver (). ฟัง ('8181'), io = ต้องการ ('socket.io') ฟัง (แอป); io.sockets.on ('การเชื่อมต่อ', ฟังก์ชั่น (socketio) {// รับข้อมูลจากไคลเอนต์ socketio.on ('fromwebclient', ฟังก์ชั่น (webclientdata) {// do sth.}); // ไคลเอ็นต์ disconnect socketio.on Socketio.emit ('pushtowebclient', jsondata);การสร้างการเชื่อมต่อที่ดีระหว่างไคลเอนต์และเซิร์ฟเวอร์ Node.js เป็นเพียงขั้นตอนแรก ต่อไปนี้ยังต้องมีการสร้างการเชื่อมต่อระหว่างเซิร์ฟเวอร์ node.js และเลเยอร์ตรรกะธุรกิจ Java ในเวลานี้เซิร์ฟเวอร์ node.js ทำหน้าที่เป็นไคลเอนต์เพื่อส่งคำขอการเชื่อมต่อ TCP ไปยัง Tomcat หลังจากการเชื่อมต่อสำเร็จเซิร์ฟเวอร์ Node.js และ Tomcat จะสร้างช่อง Duplex แบบเต็มและเป็นช่องเดียว ไม่ว่าจะมีการร้องขอลูกค้าจำนวนเท่าใดพวกเขาจะถูกส่งต่อจากเซิร์ฟเวอร์ Node.js ไปยัง Tomcat; ในทำนองเดียวกันข้อมูลที่ผลักโดย Tomcat จะถูกแจกจ่ายไปยังไคลเอนต์แต่ละรายผ่านเซิร์ฟเวอร์ Node.js
มีปัญหาที่นี่นั่นคือหลังจากการเชื่อมต่อ WebSocket และการเชื่อมต่อซ็อกเก็ตได้รับการสร้างขึ้นการเชื่อมต่อทั้งสองจะถูกบล็อก Tomcat ไม่ทราบว่าการเชื่อมต่อ WebSocket ใดที่ส่งข้อมูลและไม่ทราบว่าไคลเอนต์ใดส่งข้อมูล แน่นอน node.js สามารถใช้รหัสเซสชันเพื่อส่งไปยัง Tomcat เพื่อระบุไคลเอนต์ที่เป็น แต่บทความนี้ใช้วิธีอื่น
เมื่อไคลเอนต์สร้างการเชื่อมต่อ WebSocket ด้วย node.js การเชื่อมต่อแต่ละครั้งจะมีอินสแตนซ์ซึ่งเรียกว่า Socketio ที่นี่ Socketio แต่ละตัวมีแอตทริบิวต์ ID เพื่อระบุการเชื่อมต่อนี้โดยเฉพาะซึ่งเรียกว่า Socket_ID ที่นี่ การใช้ socket_id ตารางการแมปจะถูกสร้างขึ้นบนเซิร์ฟเวอร์ Node.js เพื่อจัดเก็บความสัมพันธ์การแมประหว่างแต่ละ socketio และ socket_id เมื่อเซิร์ฟเวอร์ node.js ส่งข้อมูลไปยัง Tomcat ซ็อกเก็ต _id จะถูกนำมาด้วยและจากนั้นชิ้นส่วน Java จะดำเนินการชุดของการประมวลผลจากนั้นสรุปข้อมูลที่แตกต่างกันที่ลูกค้าแต่ละรายต้องการและส่งคืน ข้อมูลที่ส่งคืนจะต้องมีความสัมพันธ์ที่สอดคล้องกันกับ Socket_ID ด้วยวิธีนี้เมื่อเซิร์ฟเวอร์ node.js ได้รับข้อมูลที่ส่งโดย Tomcat จะถูกแจกจ่ายไปยังไคลเอนต์ที่แตกต่างกันโดย socketio ที่แตกต่างกันผ่านตารางการแมปดังกล่าว
รหัสเซิร์ฟเวอร์ node.js:
var http = reghed ('http'), net = reghed ('net'), app = http.createserver (). ฟัง ('8181'), io = reghed ('socket.io') ฟัง (app), nodeserver = net.socket (net.socket (); // เชื่อมต่อกับ tomcat nodeserver.connect (8007, '127.0.0.1', ฟังก์ชัน () {console.log ('เชื่อมต่อ');}); // เก็บอินสแตนซ์การเชื่อมต่อ websocket ของไคลเอนต์ var asocket = {}; // สร้างการเชื่อมต่อกับไคลเอนต์ io.sockets.on ('การเชื่อมต่อ', ฟังก์ชั่น (socketio) {// รับข้อมูลจากไคลเอนต์และส่งไปที่ tomcat socketio.on ('fromwebclient', ฟังก์ชั่น (webclientdata) = Socketio.id; - // รับข้อมูลจาก tomcat nodeserver.on ('data', ฟังก์ชั่น (ข้อมูล) {var jsondata = json.parse (data.toString ()); // แจกจ่ายข้อมูลไปยังลูกค้า (var i ใน jSondata.list) {asocket jSondata.list [i] .data);}});รหัสข้างต้นจะละเว้นตรรกะบางอย่างเช่นข้อมูลที่ได้รับจากเซิร์ฟเวอร์ Node.js จาก Tomcat แบ่งออกเป็นสองประเภทหนึ่งคือข้อมูลที่ผลักดันและอีกข้อมูลคือข้อมูลที่ตอบสนองต่อคำขอ ที่นี่ข้อมูลที่ผลักดันจะถูกประมวลผลอย่างสม่ำเสมอ
เมื่อประมวลผลการสื่อสารข้อมูลที่ส่งโดย node.js ไปยัง Tomcat อยู่ในรูปแบบสตริงและข้อมูลที่ได้รับจาก Tomcat เป็นวัตถุบัฟเฟอร์ (แปดไบต์) ซึ่งจะต้องแปลงเป็นสตริงแล้วแปลงเป็น JSON และส่งไปยังลูกค้า
บทความนี้เป็นเพียงตัวอย่างง่ายๆของการเชื่อมต่อทั้งสองดังกล่าวและต้องเพิ่มหลายสิ่งหลายอย่างในธุรกิจที่เฉพาะเจาะจง เนื่องจาก Node.js ได้รับการแนะนำในโครงการส่วนหน้าจำเป็นต้องดำเนินการสิ่งต่าง ๆ มากขึ้นเช่นการประมวลผลการแคชและแม้แต่การเพิ่มตรรกะทางธุรกิจจำนวนมาก