การเขียนโปรแกรมเครือข่าย Ruby

คุณต้องการสร้างไคลเอนต์เครือข่ายและเซิร์ฟเวอร์ที่กำหนดเองใน Ruby หรือไม่? หรือแค่เข้าใจวิธีการทำงาน

จากนั้นคุณจะต้องจัดการกับซ็อกเก็ต

เข้าร่วมทัวร์ การเขียนโปรแกรมเครือข่ายทับทิม เพื่อเรียนรู้พื้นฐาน และเริ่มพูดคุยกับเซิร์ฟเวอร์และไคลเอนต์อื่นโดยใช้ Ruby!

แล้วซ็อกเก็ตคืออะไร ?

ซ็อกเก็ตเป็นจุดสิ้นสุดของช่องทางการสื่อสาร ทั้งไคลเอ็นต์และเซิร์ฟเวอร์ใช้ซ็อกเก็ตในการสื่อสาร

วิธีการทำงานนั้นง่ายมาก :

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

ประเภทของซ็อกเก็ต

มีซ็อกเก็ตสองสามประเภทสำหรับคุณ ซึ่งโดยทั่วไปแล้ว - TCP Socket - จะช่วยให้คุณสามารถเชื่อมต่อกับบริการที่ใช้ TCP เช่น HTTP หรือ FTP

หากคุณต้องใช้โปรโตคอลที่ใช้ UDP คุณสามารถใช้ซ็อกเก็ต UDP ได้

ซ็อกเก็ตประเภทอื่นๆ มีความลึกลับมากกว่าเล็กน้อย ซ็อกเก็ต Unix อนุญาตให้ IPC (การสื่อสารระหว่างกระบวนการ) ในระบบ Unix โดยไม่มีโอเวอร์เฮดของการเชื่อมต่อ TCP แบบเต็ม

การใช้ซ็อกเก็ตใน Ruby

ตอนนี้เรารู้แล้วว่าซ็อกเก็ตทำอะไรให้เราได้บ้าง ก็ได้เวลาเริ่มใช้งานแล้ว

ขั้นแรก กำหนดให้ใช้ไลบรารีซ็อกเก็ตในโปรแกรมของคุณ:

ต้องการ 'ซ็อกเก็ต'

ในการสร้างซ็อกเก็ต TCP คุณสามารถใช้ TCPSocket class เนื่องจากพารามิเตอร์ คุณจะต้องมีที่อยู่ IP ปลายทางและพอร์ต

การดำเนินการนี้จะพยายามสร้างการเชื่อมต่อ หากไม่สามารถสร้างได้ คุณจะได้รับ Errno::ECONNREFUSED ผิดพลาด

socket =TCPSocket.new('google.com', 80)

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

socket.write "GET / HTTP/1.1"socket.write "\r\n\r\n"

หลายวิธีที่คุณจะใช้มาจากคลาสพาเรนต์ของ TCPSocket .

หากต้องการอ่านการตอบกลับจากเซิร์ฟเวอร์ คุณสามารถใช้วิธี recv

คุณต้องส่งจำนวนไบต์ที่คุณต้องการอ่านจากซ็อกเก็ตเป็นพารามิเตอร์:

ใส่ socket.recv(100)

มีปัญหาเล็กน้อย คุณอาจไม่ได้รับข้อมูลใด ๆ กลับ และดูเหมือนว่าแอปของคุณจะไม่ทำอะไรเลย

เหตุผลก็คือ หากมีข้อมูลไม่เพียงพอให้อ่าน โปรแกรมของคุณจะ "บล็อก"

ซึ่งหมายความว่า จะรอจนกว่าจะมีข้อมูลบางส่วนหรือเซิร์ฟเวอร์ปิดการเชื่อมต่อ .

คุณอาจต้องการเพิ่มหรือลดปริมาณข้อมูลที่กำลังอ่านขึ้นอยู่กับโปรโตคอลที่คุณกำลังใช้งาน

หากการบล็อกเป็นปัญหาสำหรับคุณ ให้ตรวจสอบเมธอด readpartial และ read_nonblock จากคลาส IO

วิธีการเขียนเซิร์ฟเวอร์ TCP

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

คลาส TCPServer ทำสองข้อแรกให้เราแล้ว

นี่คือตัวอย่าง :

ต้องการ 'socket'socket =TCPServer.new('0.0.0.0', 8080)client =socket.acceptputs "ไคลเอนต์ใหม่! #{client}"client.write("สวัสดีจากเซิร์ฟเวอร์")client.close 

 เซิร์ฟเวอร์ตัวอย่างของเราจะรอฟังที่พอร์ต 8080 และทักทายลูกค้าที่เชื่อมต่อด้วยข้อความ
 

 สังเกตว่า เราสามารถรับลูกค้าได้เพียงรายเดียวเท่านั้น และโปรแกรมจะสิ้นสุดลง
 
การรับลูกค้าหลายราย
 

 เพื่อให้สามารถยอมรับและตอบสนองต่อลูกค้าหลายราย เราจำเป็นต้องมีการวนซ้ำและบางเธรด
 

 ตัวอย่าง :
 
require 'socket'PORT =8081socket =TCPServer.new('0.0.0.0', PORT)def handle_connection(client) ทำให้ไคลเอนต์ "New! #{client}" client.write ("สวัสดีจากเซิร์ฟเวอร์") เป็นไคลเอนต์ closeendputs "กำลังฟังใน #{PORT} กด CTRL+C เพื่อยกเลิก"loop do client =socket.accept Thread.new { handle_connection(client) }end
 

 ที่ควรเริ่มต้นเซิร์ฟเวอร์ใหม่ที่คอยฟังจนกว่าคุณจะหยุดมัน
 

 หากคุณต้องการเรียนรู้วิธีนำสิ่งนี้ไปสู่อีกระดับ &เขียนเว็บเซิร์ฟเวอร์ใน Ruby อ่านโพสต์บล็อกนี้
 
บทสรุป
 

 คุณได้เรียนรู้ว่าซ็อกเก็ต TCP คืออะไร ทำงานอย่างไร และคุณสามารถใช้คลาส Ruby บางคลาสได้อย่างไร เช่น TCPServer &TCPSocket เพื่อสร้างแอปพลิเคชัน Ruby ที่สามารถโต้ตอบกับเครื่องอื่นบนอินเทอร์เน็ตได้
 

 การเล่นโปรแกรมเครือข่าย ruby ​​เป็นเรื่องสนุก!
 

 ไปสร้างสรรค์สิ่งดีๆ และแบ่งปันกับทุกคน ในส่วนความคิดเห็น 🙂
 

 อย่าลืมเข้าร่วมจดหมายข่าวของฉันหากคุณต้องการพัฒนาทักษะ Ruby ของคุณต่อไป!