ซ็อกเก็ตหรือที่รู้จักกันในชื่อซ็อกเก็ตเป็นหนึ่งในเทคโนโลยีพื้นฐานสำหรับการสื่อสารเครือข่ายคอมพิวเตอร์ วันนี้ซอฟต์แวร์บนเว็บส่วนใหญ่เช่นเบราว์เซอร์เครื่องมือส่งข้อความโต้ตอบแบบทันทีและแม้แต่การดาวน์โหลด P2P จะถูกนำไปใช้ตามซ็อกเก็ต บทความนี้จะแนะนำการเขียนโปรแกรมซ็อกเก็ตตาม TCP/IP และวิธีการเขียนโปรแกรมไคลเอนต์/เซิร์ฟเวอร์
ของหวานก่อนอาหารเย็น
ระบบอินพุตและเอาท์พุท (IO) ของ UNIX เป็นไปตามเทมเพลตการทำงานเช่นการเขียนแบบเปิดอ่าน ก่อนที่กระบวนการของผู้ใช้จะดำเนินการ IO จะต้องโทรเปิดเพื่อระบุและรับสิทธิ์สำหรับไฟล์หรืออุปกรณ์ที่จะดำเนินการเพื่ออ่านหรือเขียน เมื่อเปิดวัตถุการทำงานของ IO กระบวนการของผู้ใช้สามารถดำเนินการอ่านหรือเขียนหนึ่งรายการขึ้นไปบนวัตถุ การดำเนินการอ่านใช้เพื่ออ่านข้อมูลจากวัตถุการทำงานของ IO และส่งผ่านข้อมูลไปยังกระบวนการผู้ใช้ การดำเนินการเขียนใช้เพื่อส่งข้อมูล (เขียน) ในกระบวนการของผู้ใช้ไปยังวัตถุการทำงานของ IO หลังจากการดำเนินการอ่านและเขียนเสร็จสมบูรณ์กระบวนการของผู้ใช้จำเป็นต้องโทรเข้าใกล้เพื่อแจ้งระบบว่ามันเสร็จสิ้นการใช้วัตถุ IO
เมื่อ UNIX เริ่มรองรับการสื่อสารระหว่างกัน (IPC) อินเตอร์เฟส IPC ได้รับการออกแบบให้คล้ายกับอินเทอร์เฟซการทำงานของไฟล์ IO ใน UNIX กระบวนการจะมีชุดคำอธิบาย IO ที่สามารถอ่านและเขียนได้ ตัวอธิบาย IO สามารถเป็นไฟล์อุปกรณ์หรือช่องทางการสื่อสาร (ซ็อกเก็ตซ็อกเก็ต) ตัวอธิบายไฟล์ประกอบด้วยสามส่วน: การสร้าง (เปิดซ็อกเก็ต), การอ่านและการเขียนข้อมูล (การยอมรับและส่งไปยังซ็อกเก็ต) และทำลาย (ปิดซ็อกเก็ต)
ในระบบ UNIX เวอร์ชัน BSD-like ของอินเตอร์เฟส IPC ถูกนำมาใช้เป็นเลเยอร์เหนือโปรโตคอล TCP และ UDP ปลายทางของข้อความแสดงโดยที่อยู่ซ็อกเก็ต ซ็อกเก็ตที่อยู่คือตัวระบุการสื่อสารที่ประกอบด้วยที่อยู่เครือข่ายและหมายเลขพอร์ต
การสื่อสารระหว่างกระบวนการต้องใช้ซ็อกเก็ตคู่หนึ่ง การสื่อสารระหว่างกระบวนการทำได้โดยการส่งข้อมูลระหว่างซ็อกเก็ตหนึ่งในกระบวนการหนึ่งและซ็อกเก็ตอื่นในกระบวนการอื่น เมื่อมีการดำเนินการและส่งข้อความข้อความจะถูกคิวในซ็อกเก็ตเมื่อสิ้นสุดการส่งจนกว่าโปรโตคอลเครือข่ายระดับล่างจะส่งข้อความออก เมื่อข้อความถึงซ็อกเก็ตเมื่อสิ้นสุดการรับมันก็จะอยู่ในคิวจนกว่ากระบวนการที่ได้รับจะได้รับข้อความ
การสื่อสาร TCP และ UDP
เกี่ยวกับการเขียนโปรแกรมซ็อกเก็ตเรามีสองโปรโตคอลการสื่อสารให้เลือก หนึ่งคือการสื่อสาร DataGram อีกอย่างคือการสื่อสารสตรีม
การสื่อสารดาต้าแกรม
โปรโตคอลการสื่อสาร DataGram เป็นสิ่งที่เรามักเรียกว่า UDP (โปรโตคอลข้อมูลผู้ใช้) UDP เป็นโปรโตคอลที่ไม่มีการเชื่อมต่อซึ่งหมายความว่าทุกครั้งที่เราส่งดาต้าแกรมเราจำเป็นต้องส่งตัวบ่งชี้ซ็อกเก็ตของเครื่องเนทีฟและตัวบ่งชี้ซ็อกเก็ตของเครื่องรับในเวลาเดียวกัน ดังนั้นเราจำเป็นต้องส่งข้อมูลเพิ่มเติมทุกครั้งที่เราสื่อสาร
สตรีมการสื่อสาร
โปรโตคอลการสื่อสารสตรีมหรือที่เรียกว่า TCP (โปรโตคอลการควบคุมการถ่ายโอน) เรียกอีกอย่างว่า TCP (โปรโตคอลควบคุมการถ่ายโอน) ซึ่งแตกต่างจาก UDP, TCP เป็นโปรโตคอลที่ใช้การเชื่อมต่อ ก่อนที่จะใช้การสื่อสารสตรีมเราต้องสร้างการเชื่อมต่อระหว่างคู่การสื่อสารของซ็อกเก็ต หนึ่งในซ็อกเก็ตทำหน้าที่เป็นเซิร์ฟเวอร์เพื่อฟังคำขอการเชื่อมต่อ อีกอันหนึ่งทำให้คำขอการเชื่อมต่อเป็นไคลเอนต์ เมื่อซ็อกเก็ตทั้งสองได้สร้างการเชื่อมต่อพวกเขาสามารถถ่ายโอนข้อมูลในทางเดียวหรือสองทาง
หลังจากอ่านสิ่งนี้เรามีคำถามบางอย่างเกี่ยวกับว่าเราใช้ UDP หรือ TCP สำหรับการเขียนโปรแกรมซ็อกเก็ตหรือไม่ ทางเลือกของการเขียนโปรแกรมซ็อกเก็ตตามโปรโตคอลที่ใช้สถานการณ์แอปพลิเคชันเฉพาะของคุณขึ้นอยู่กับโปรแกรมไคลเอนต์เซิร์ฟเวอร์เฉพาะของคุณ ด้านล่างเราวิเคราะห์ความแตกต่างระหว่างโปรโตคอล TCP และ UDP สั้น ๆ ซึ่งอาจช่วยให้คุณเลือกใช้งานได้ดีขึ้น
ใน UDP ทุกครั้งที่มีการส่งดาต้าแกรมตัวบ่งชี้ซ็อกเก็ตของเครื่องเนทีฟและตัวบ่งชี้ซ็อกเก็ตของตัวรับสัญญาณจะต้องรวมอยู่ด้วย เนื่องจาก TCP เป็นโปรโตคอลที่ใช้การเชื่อมต่อจึงจำเป็นต้องมีการเชื่อมต่อระหว่างคู่ซ็อกเก็ตการสื่อสารก่อนการสื่อสารดังนั้นจะมีการเขียนโปรแกรมการเชื่อมต่อที่ใช้เวลานานในโปรโตคอล TCP
ใน UDP ข้อมูล DataGram มีขนาดขีด จำกัด 64KB ไม่มีข้อ จำกัด ดังกล่าวใน TCP เมื่อซ็อกเก็ตคู่ของการสื่อสาร TCP สร้างการเชื่อมต่อการสื่อสารระหว่างพวกเขาจะคล้ายกับสตรีม IO และข้อมูลทั้งหมดจะถูกอ่านตามลำดับที่ได้รับการยอมรับ
UDP เป็นโปรโตคอลที่ไม่น่าเชื่อถือและดาต้าแกรมที่ส่งไม่จำเป็นต้องได้รับการยอมรับจากซ็อกเก็ตที่ได้รับตามลำดับที่ส่งมา TCP เป็นโปรโตคอลที่เชื่อถือได้ ลำดับของแพ็คเก็ตที่ได้รับจากปลายรับนั้นสอดคล้องกับลำดับของแพ็กเก็ตในตอนท้ายการส่ง
ในระยะสั้น TCP เหมาะสำหรับบริการเครือข่ายเช่นการเข้าสู่ระบบระยะไกล (Rlogin, Telnet) และ File Transfer (FTP) เนื่องจากขนาดของข้อมูลเหล่านี้ที่ต้องส่งนั้นไม่แน่นอน UDP นั้นง่ายกว่าและเบากว่า TCP UDP ใช้เพื่อใช้บริการบางอย่างที่เป็นแบบเรียลไทม์หรือไม่มีความสำคัญของการสูญเสียแพ็คเก็ต อัตราการสูญเสียแพ็คเก็ตของ UDP ใน LAN ค่อนข้างต่ำ
การเขียนโปรแกรมซ็อกเก็ตในชวา
ในส่วนต่อไปนี้ฉันจะอธิบายวิธีการใช้ซ็อกเก็ตเพื่อเขียนโปรแกรมไคลเอนต์และเซิร์ฟเวอร์ผ่านตัวอย่างบางส่วน
หมายเหตุ: ในตัวอย่างต่อไปนี้ฉันจะใช้การเขียนโปรแกรมซ็อกเก็ตตามโปรโตคอล TCP/IP เนื่องจากโปรโตคอลนี้ใช้กันอย่างแพร่หลายมากกว่า UDP/IP และคลาสที่เกี่ยวข้องกับซ็อกเก็ตทั้งหมดอยู่ภายใต้แพ็คเกจ java.net ดังนั้นเราจึงต้องแนะนำแพ็คเกจนี้เมื่อเราทำการเขียนโปรแกรมซ็อกเก็ต
การเขียนลูกค้า
เปิดซ็อกเก็ต
หากคุณอยู่ด้านไคลเอนต์คุณต้องเขียนรหัสต่อไปนี้เพื่อเปิดซ็อกเก็ต
สตริงโฮสต์ = "127.0.0.1"; int port = 8919; ซ็อกเก็ตไคลเอนต์ = ซ็อกเก็ตใหม่ (โฮสต์, พอร์ต);
ในรหัสด้านบนโฮสต์เป็นเครื่องที่ไคลเอนต์จำเป็นต้องเชื่อมต่อและพอร์ตเป็นพอร์ตที่เซิร์ฟเวอร์ใช้เพื่อฟังคำขอ เมื่อเลือกพอร์ตสิ่งหนึ่งที่คุณต้องใส่ใจคือพอร์ตเช่น 0 ~ 1023 ได้รับการสงวนไว้โดยระบบ พอร์ตเหล่านี้ใช้โดยบริการที่ใช้กันทั่วไปเช่น Mail, FTP และ HTTP เมื่อคุณเขียนรหัสฝั่งเซิร์ฟเวอร์และเลือกพอร์ตโปรดเลือกพอร์ตที่ใหญ่กว่า 1023
เขียนข้อมูล
ถัดไปคือการเขียนข้อมูลคำขอ เราได้รับวัตถุ OutputStream จากวัตถุซ็อกเก็ตของลูกค้าแล้วเขียนข้อมูล คล้ายกับรหัสการประมวลผลไฟล์ IO มาก
Public Class ClientSocket {โมฆะคงที่สาธารณะหลัก (สตริง args []) {สตริงโฮสต์ = "127.0.0.1"; พอร์ต int = 8919; ลอง {ซ็อกเก็ตไคลเอนต์ = ซ็อกเก็ตใหม่ (โฮสต์พอร์ต); Writer Writer = new OutputStreamWriter (client.getOutputStream ()); writer.write ("สวัสดีจากลูกค้า"); Writer.flush (); Writer.close (); client.close (); } catch (ioexception e) {e.printstacktrace (); -ปิดวัตถุ io
คล้ายกับไฟล์ IO หลังจากอ่านและเขียนข้อมูลเราต้องปิดวัตถุ IO เพื่อให้แน่ใจว่าการเปิดตัวทรัพยากรที่ถูกต้อง
การเขียนฝั่งเซิร์ฟเวอร์
เปิดซ็อกเก็ตฝั่งเซิร์ฟเวอร์
int port = 8919; Serversocket Server = ใหม่ Serversocket (พอร์ต); ซ็อกเก็ตซ็อกเก็ต = Server.accept ();
รหัสด้านบนสร้างซ็อกเก็ตฝั่งเซิร์ฟเวอร์จากนั้นเรียกใช้วิธีการยอมรับเพื่อรับฟังและรับซ็อกเก็ตคำขอของลูกค้า วิธีการยอมรับเป็นวิธีการบล็อกที่รอการบล็อกจนกว่าจะมีการเชื่อมต่อระหว่างเซิร์ฟเวอร์และไคลเอนต์
อ่านข้อมูล
รับวัตถุ InputStream ผ่านวัตถุซ็อกเก็ตที่ได้รับด้านบนจากนั้นติดตั้งไฟล์ io เพื่ออ่านข้อมูล ที่นี่เราพิมพ์เนื้อหา
คลาสสาธารณะ ServerClient {โมฆะสาธารณะคงที่หลัก (สตริง [] args) {int port = 8919; ลอง {Serversocket Server = ใหม่ Serversocket (พอร์ต); ซ็อกเก็ตซ็อกเก็ต = Server.accept (); Reader Reader = new InputStreamReader (socket.getInputStream ()); ถ่านถ่าน [] = ถ่านใหม่ [1024]; int len; StringBuilder builder = new StringBuilder (); ในขณะที่ ((len = reader.read (chars))! = -1) {builder.append (สตริงใหม่ (chars, 0, len)); } system.out.println ("รับจากไคลเอนต์ข้อความ =:" + builder); reader.close (); Socket.close (); Server.close (); } catch (exception e) {e.printstacktrace (); -ปิดวัตถุ io
มันไม่สามารถลืมได้ ในที่สุดฉันต้องปิดวัตถุ IO อย่างถูกต้องเพื่อให้แน่ใจว่าการเปิดตัวทรัพยากรที่ถูกต้อง
บันทึกตัวอย่าง
ที่นี่เราเพิ่มตัวอย่างโดยใช้ซ็อกเก็ตเพื่อใช้เซิร์ฟเวอร์ Echo นั่นคือเซิร์ฟเวอร์จะส่งข้อมูลที่ส่งโดยไคลเอนต์กลับไปยังไคลเอนต์ รหัสนั้นง่ายมาก
นำเข้า java.io.*; นำเข้า Java.net.*; echoserver ระดับสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง args []) {// ส่วนประกาศ: // ประกาศซ็อกเก็ตเซิร์ฟเวอร์และซ็อกเก็ตไคลเอ็นต์สำหรับเซิร์ฟเวอร์ // ประกาศอินพุต สายสตริง; DatainputStream คือ; Printstream OS; ซ็อกเก็ต clientsocket = null; // ลองเปิดซ็อกเก็ตเซิร์ฟเวอร์บนพอร์ต 9999 // โปรดทราบว่าเราไม่สามารถเลือกพอร์ตได้น้อยกว่า 1023 หากเราไม่ได้เป็น // ผู้ใช้ที่ได้รับการยกเว้น (รูท) ลอง {echoserver = Serversocket ใหม่ (9999); } catch (ioexception e) {system.out.println (e); } // สร้างวัตถุซ็อกเก็ตจาก Serversocket เพื่อฟังและยอมรับ // การเชื่อมต่อ // เปิดสตรีมอินพุตและเอาต์พุตลอง {clientSocket = echoserver.accept (); IS = ใหม่ datainputStream (clientsocket.getInputStream ()); OS = new printStream (clientsocket.getOutputStream ()); // ตราบใดที่เราได้รับข้อมูลสะท้อนข้อมูลนั้นกลับไปที่ลูกค้า ในขณะที่ (จริง) {line = is.readline (); OS.println (บรรทัด); }} catch (ioexception e) {system.out.println (e); -รวบรวมและเรียกใช้รหัสด้านบนและทำคำขอต่อไปนี้คุณสามารถดูเนื้อหาของข้อมูลที่ดำเนินการตามคำขอของลูกค้า
15:00 $ curl http://127.0.0.1:9999/?111get/? 111 http/1.1user-agent: curl/7.37.1host: 127.0.0.1:99999Cept
สรุป
มันค่อนข้างน่าสนใจที่จะทำการเขียนโปรแกรมลูกค้าเซิร์ฟเวอร์และการเขียนโปรแกรมซ็อกเก็ตใน Java นั้นง่ายกว่าและเร็วกว่าภาษาอื่น ๆ (เช่น C)
แพ็คเกจ java.net มีคลาสที่ทรงพลังและยืดหยุ่นมากมายสำหรับนักพัฒนาซอฟต์แวร์ในการโปรแกรม เมื่อเครือข่ายการเขียนโปรแกรมขอแนะนำให้ใช้ API ด้านล่างแพ็คเกจนี้ ในเวลาเดียวกันแพ็คเกจ Sun.* ยังมีคลาสที่เกี่ยวข้องกับการเขียนโปรแกรมเครือข่ายจำนวนมาก แต่ไม่แนะนำให้ใช้ API ด้านล่างแพ็คเกจนี้เนื่องจากแพ็คเกจนี้อาจเปลี่ยนไป นอกจากนี้แพ็คเกจนี้ไม่สามารถรับประกันได้ว่าจะรวมอยู่ในแพลตฟอร์มทั้งหมด
ข้างต้นเป็นการรวบรวมข้อมูลซ็อกเก็ต Java เราจะเพิ่มความรู้ที่เกี่ยวข้องต่อไปในอนาคต ขอบคุณสำหรับการสนับสนุนเว็บไซต์นี้!