การเขียนโปรแกรมเครือข่ายด้วยซ็อกเก็ต (Socket) ตอนที่ 10: ทดสอบการทำงานของ UDP Server & Client

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

 จากนั้นรันไคลเอนต์ด้วยคำสั่ง java UDPClient จะได้ผลัพธ์ดังนี้

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

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

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

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

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

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

การเขียนโปรแกรมเครือข่ายด้วยซ็อกเก็ต (Socket) ตอนที่ 9: UDP Client ด้วยภาษาจาวา (Java)

หลังจากสร้างโปรแกรมเซิร์ฟเวอร์ไปแล้วจากตอนที่ 8 ตอนนี้มาดูโปรแกรมฝั่งไคลเอนต์กันครับ มาดูโค้ดกันเลยครับ

1. import java.io.*; 
2. import java.net.*;
3. import java.util.*; 
4. class UDPClient { 
5.    public static void main(String args[]) throws Exception { 
6.       Scanner inFromUser = new Scanner(System.in);
7.       DatagramSocket clientSocket = new DatagramSocket(); 
8.       InetAddress IPAddress = InetAddress.getByName("localhost"); 
9.       byte[] sendData = new byte[1024]; 
10.       byte[] receiveData = new byte[1024]; 
11.       System.out.print("Please enter words: ");
12.       String sentence = inFromUser.nextLine();
13.       sendData = sentence.getBytes();  
14.       DatagramPacket sendPacket = 
15.          new DatagramPacket(sendData, sendData.length, IPAddress, 9876); 
16.       clientSocket.send(sendPacket); 
17.       DatagramPacket receivePacket = 
18.          new DatagramPacket(receiveData, receiveData.length); 
19.       clientSocket.receive(receivePacket); 
20.       String modifiedSentence = new String(receivePacket.getData()); 
21.       System.out.println("FROM SERVER:" + modifiedSentence.trim()); 
22.    clientSocket.close(); 
23.    } 
24. } 

บรรทัดที่ 7 สร้างซ็อกเก็ตเพื่อใช้ในการแลกเปลี่ยนข้อมูลกับเซิร์ฟเวอร์ บรรทัดที่ 8 แปลงชื่อโดเมนของเซิร์ฟเวอร์เป็นหมายเลขไอพี ในที่นี้เรารันโปรแกรมไคลเอนต์และเซิร์ฟเวอร์บนเครื่องเดียวกันชื่อโดเมนจึงเป็น localhost บรรทัดที่ 14-15 เตรียมแพ็กเก็ตที่ใช้ส่งข้อมูล โดยนอกจากข้อมูลที่จะส่งไปแล้ว ก็ต้องระบุหมายเลขไอพี และหมายเลขพอร์ตของโปรแกรมเซิร์ฟเวอร์ และถึงแม้เราจะไม่ได้ระบุหมายเลขไอพี และหมายเลขพอร์ตของไคลเอนต์ที่เป็นผู้ส่ง ข้อมูลนี้จะถูกใส่ลงไปในแพ็กเก็ตโดยอัตโนมัติ บรรทัดที่ 19 ส่งข้อมูลผ่านซ็อกเก็ตไปให้เซิร์ฟเวอร์ บรรทัดที่ 20 รอรับข้อมูลที่เซิร์ฟเวอร์จะตอบกลับมา

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

การเขียนโปรแกรมเครือข่ายด้วยซ็อกเก็ต (Socket) ตอนที่ 8: UDP Server ด้วยภาษาจาวา (Java)

จากตอนที่ 7  ก็คงเข้าใจความแตกต่างระหว่างทีซีพี (TCP) กับยูดีพี (UDP) กันแล้วนะครับ คราวนี้เราจะมาเขียนโปรแกรมฝั่งเซิร์ฟเวอร์กัน โดยโปรแกรมเซิร์ฟเวอร์นี้จะทำงานเหมือน TCPServer คือรับข้อมูลสตริงจากไคลเอนต์ เอามาแปลงเป็นตัวอักษรตัวใหญ่ แล้วส่งกลับไปให้ไคลเอนต์ มาดูโค้ดกันเลยครับ

1. import java.io.*; 
2. import java.net.*; 
3. class UDPServer { 
4.   public static void main(String args[]) throws Exception 
5.     { 
6.     DatagramSocket serverSocket = new DatagramSocket(9876); 
7.       byte[] receiveData = new byte[1024]; 
8.       byte[] sendData  = new byte[1024];
9.       while(true) 
10.       { 
11.             System.out.println("The server is waiting ");
12.             DatagramPacket receivePacket = 
13.              new DatagramPacket(receiveData, receiveData.length); 
14.             serverSocket.receive(receivePacket);
15.             String sentence = new String(receivePacket.getData());
16.             InetAddress IPAddress = receivePacket.getAddress(); 
17.             int port = receivePacket.getPort(); 
18.             String capitalizedSentence = sentence.toUpperCase();
19.             sendData = capitalizedSentence.getBytes(); 
20.             DatagramPacket sendPacket = 
21.                   new DatagramPacket(sendData, sendData.length, IPAddress, port); 
22.               serverSocket.send(sendPacket); 
23.         } 
24.     } 
25. }  

การสร้างซ็อกเก็ตจะใช้คลาส DatagramSocket ตามที่เขียนไว้ในบรรทัดที่ 6 ในที่นี้โปรแกรมเซิร์ฟเวอร์จะรอรับการติดต่ออยู่ที่พอร์ตหมายเลข 9876  บรรทัดที่ึ 7 และ 8 จะสร้างบัฟเฟอร์สำหรับรับและส่งข้อมูลตามลำดับ โดยในโปรแกรมนี้ระบุขนาดของการรับส่งข้อมูลไว้ที่ไม่เกิน 1024 ไบต์ บรรทัดที่ 12-13 สร้างแพ็กเก็ตรับข้อมูล โดยระบุว่าให้เอาข้อมูลมาเก็บไว้ในบัฟเฟอร์คือ receiveData ด้วยความยาวตามขนาดของบัฟเฟอร์ที่ประกาศไว้ ในตัวอย่างนี้คือ 1024 ไบต์ บรรทัดที่ 4 รออ่านข้อมูลที่ไคลเอนต์จะส่งมา โดยข้อมูลจะถูกเก็บลงแพ็กเก็ตที่ประกาศไว้ในบรรทัดที่ 12 

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

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

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

การเขียนโปรแกรมเครือข่ายด้วยซ็อกเก็ต (Socket) ตอนที่ 7: โปรโตคอลทีซีพี (TCP) กับ ยูดีพี (UDP)

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

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

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

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

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

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