Trabajando con UDP DatagramSockets en Java

DatagramSockets son el mecanismo de Java para la comunicación de red a través de UDP en lugar de TCP. Java proporciona DatagramSocket para comunicarse a través de UDP en lugar de TCP. También está construido sobre IP. DatagramSockets se puede utilizar para enviar y recibir paquetes a través de Internet.

Uno de los ejemplos donde se prefiere UDP sobre TCP es la cobertura en vivo de los canales de TV. En este aspecto, queremos transmitir tantos fotogramas a la audiencia en vivo como sea posible sin preocuparnos por la pérdida de uno o dos fotogramas. TCP, al ser un protocolo confiable, agrega su propia sobrecarga durante la transmisión.
Otro ejemplo en el que se prefiere UDP son los juegos multijugador en línea. En juegos como counter-strike o call of duty, no es necesario transmitir toda la información sino las más importantes. También se debe tener en cuenta que la mayoría de las aplicaciones en la vida real utilizan una combinación cuidadosa de UDP y TCP; transmitiendo los datos críticos sobre TCP y el resto de los datos vía UDP.

Este artículo es una implementación simple del programa cliente-servidor unilateral en el que el cliente envía mensajes al servidor y el servidor simplemente lo imprime hasta que el cliente envía «adiós».

Pasos del modelo de programación Java Datagram

1. Creación de DatagramSocket: primero, se crea un objeto datagramSocket para llevar el paquete al destino y recibirlo siempre que el servidor envíe datos. Para crear un datagramSocket se pueden usar los siguientes constructores:
   • protegido DatagramSocket DatagramSocket():

     Syntax: public DatagramSocket()
                   throws SocketException
     Creates a datagramSocket and binds it to any available
     port on local machine. If this constructor is used, the
     OS would assign any port to this socket.
     

   • DatagramSocket protegido DatagramSocket (puerto int): –

     Syntax: public DatagramSocket(int port)
                             throws SocketException
     Parameters:
     port - port to which socket is to be bound
     Throws:
     SocketException - If the socket cannot be bound to the 
     specific local port. Creates a DatagramSocket and binds 
     to the specified port on the local machine.

   • protegido DatagramSocket DatagramSocket (puerto int, InetAddress inetaddress):-

     Syntax: public DatagramSocket(int port,
                            InetAddress inetaddress)
                             throws SocketException
     Parameters:
     port - port to which socket is to be bound.
     inetaddress - local address to which socket is to be bound.
     Throws:
     SocketException - If the socket cannot be bound to the 
     specific local port. It creates a DatagramSocket and 
     binds it to specified port and ip-address.

2. Creación de DatagramPacket: En este paso se crea el paquete para enviar/recibir datos a través de un datagramSocket.
   • Constructor para enviar datos:
     DatagramPacket(byte buf[], int length, InetAddress inetaddress, int port):-

     Syntax: public DatagramPacket(byte[] buf,
                   int offset,
                   int length,
                   SocketAddress address)
     Parameters:
     buf - the packet data.
     offset - the packet data offset.
     length - the packet data length.
     address - the destination socket address.
     Constructs a DatagramPacket for sending data at specified address
      and specified port.

   • Constructor para recibir los datos:
     DatagramPacket(byte buf[], longitud int):-

     Syntax: public DatagramPacket(byte buf[],
                   int length)
     Parameters:
     buf - the packet data.
     length - the packet data length.
     Constructs a DatagramPacket for receiving the data of length length
     in the byte array buf.
     

3. Invoque una llamada de envío() o recepción() en el objeto de socket

   Syntax: void send(DatagramPacket packet)
                              throws SocketException
   Parameters:
   packet - Datagrampacket to send.
   Throws:
   SocketException - If there is an error in binding.
   IllegalArgumentException - if address is not supported by the socket.
   

   Syntax: void receive(DatagramPacket packet)
                              throws SocketException
   Parameters:
   packet - Datagrampacket to receive from this socket.
   Throws:
   SocketException - If there is an error in binding.
   IllegalArgumentException - if address is not supported by the socket.
   

Implementación del lado del cliente

// Java program to illustrate Client side
// Implementation using DatagramSocket
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
  
public class udpBaseClient_2
{
    public static void main(String args[]) throws IOException
    {
        Scanner sc = new Scanner(System.in);
  
        // Step 1:Create the socket object for
        // carrying the data.
        DatagramSocket ds = new DatagramSocket();
  
        InetAddress ip = InetAddress.getLocalHost();
        byte buf[] = null;
  
        // loop while user not enters "bye"
        while (true)
        {
            String inp = sc.nextLine();
  
            // convert the String input into the byte array.
            buf = inp.getBytes();
  
            // Step 2 : Create the datagramPacket for sending
            // the data.
            DatagramPacket DpSend =
                  new DatagramPacket(buf, buf.length, ip, 1234);
  
            // Step 3 : invoke the send call to actually send
            // the data.
            ds.send(DpSend);
  
            // break the loop if user enters "bye"
            if (inp.equals("bye"))
                break;
        }
    }
}

Producción:

Hello
I am Client.
...
bye

Implementación del lado del servidor

// Java program to illustrate Server side
// Implementation using DatagramSocket
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
  
public class udpBaseServer_2
{
    public static void main(String[] args) throws IOException
    {
        // Step 1 : Create a socket to listen at port 1234
        DatagramSocket ds = new DatagramSocket(1234);
        byte[] receive = new byte[65535];
  
        DatagramPacket DpReceive = null;
        while (true)
        {
  
            // Step 2 : create a DatgramPacket to receive the data.
            DpReceive = new DatagramPacket(receive, receive.length);
  
            // Step 3 : revieve the data in byte buffer.
            ds.receive(DpReceive);
  
            System.out.println("Client:-" + data(receive));
  
            // Exit the server if the client sends "bye"
            if (data(receive).toString().equals("bye"))
            {
                System.out.println("Client sent bye.....EXITING");
                break;
            }
  
            // Clear the buffer after every message.
            receive = new byte[65535];
        }
    }
  
    // A utility method to convert the byte array
    // data into a string representation.
    public static StringBuilder data(byte[] a)
    {
        if (a == null)
            return null;
        StringBuilder ret = new StringBuilder();
        int i = 0;
        while (a[i] != 0)
        {
            ret.append((char) a[i]);
            i++;
        }
        return ret;
    }
}

En pocas palabras, podemos resumir los pasos para enviar y recibir datos a través de UDP de la siguiente manera:

1. Para enviar un paquete a través de UDP, debemos saber 4 cosas, el mensaje a enviar, su longitud, la dirección IP de destino, el puerto en el que está escuchando el destino.
2. Una vez que sabemos todas estas cosas, podemos crear el objeto socket para transportar los paquetes y los paquetes que realmente poseen los datos.
3. Invoque la llamada send()/receive() para enviar/recibir paquetes.
4. Extraiga los datos del paquete recibido.

Producción:

Client:- Hello
Client:- I am client.
...
Client:- bye
Client sent bye.....EXITING

Nota:- Para probar los programas anteriores en el sistema, asegúrese de ejecutar primero el programa del servidor y luego el del cliente. Asegúrese de estar en la consola del cliente y desde allí siga escribiendo sus mensajes, cada uno seguido de un retorno de carro. Cada vez que envíe un mensaje, será redirigido a la consola del servidor según la configuración de su entorno. Si no se redirige automáticamente, cambie a la consola del servidor para asegurarse de que se reciban todos sus mensajes. Finalmente, para finalizar la comunicación, escriba «adiós» (sin comillas) y presione enter.

Como lector entusiasta, también debe intentar implementar una aplicación de chat bidireccional en la que el servidor pueda responder a los mensajes cuando quiera.

Referencias:
http://download.java.net/jdk7/archive/b123/docs/api/java/net/DatagramSocket.html
http://download.java.net/jdk7/archive/b123/docs/api/java /net/Paquete de datos.html

Este artículo es una contribución de Rishabh Mahrsee . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.