DatagramSockets são mecanismos Java para comunicação de rede via UDP em vez de TCP. Java fornece DatagramSocket para se comunicar por UDP em vez de TCP. Também é construído com base no IP. DatagramSockets pode ser usado para enviar e receber pacotes pela Internet.

Um dos exemplos em que o UDP é preferível ao TCP é a cobertura ao vivo de canais de TV. Neste aspecto, queremos transmitir ao público ao vivo o maior número possível de frames sem nos preocupar com a perda de um ou dois frames. Sendo o TCP um protocolo confiável, adiciona sua própria sobrecarga durante a transmissão.
Outro exemplo onde o UDP é preferido é o jogo multijogador online. Em jogos como contra-ataque ou call of duty, não é necessário retransmitir todas as informações, mas as mais importantes. Também deve ser observado que a maioria dos aplicativos na vida real usa uma combinação cuidadosa de UDP e TCP; transmitir os dados críticos sobre TCP e o resto dos dados via UDP.

Este artigo é uma implementação simples de um programa cliente-servidor unilateral em que o cliente envia mensagens ao servidor e o servidor apenas as imprime até que o cliente envie um “tchau”.

Etapas do modelo de programação de datagrama Java

1. Criação de DatagramSocket: - Primeiro, um objeto datagramSocket é criado para transportar o pacote até o destino e recebê-lo sempre que o servidor enviar algum dado. Para criar um datagramSocket, os seguintes construtores podem ser usados:
   • protegido DatagramSocket DatagramSocket():
     
     
     

     Sintaxe: public DatagramSocket()
                   lança SocketException
     Cria um datagramSocket e o vincula a qualquer disponível
     porta na máquina local. Se este construtor for usado, o
     O sistema operacional atribuiria qualquer porta a este soquete.
     

   • protegido DatagramSocket DatagramSocket (porta interna): -

     Sintaxe: public DatagramSocket (int port)
                             lança SocketException
     Parâmetros:
     porta - porta à qual o soquete deve ser vinculado
     Lança:
     SocketException - se o soquete não puder ser vinculado ao 
     porta local específica. Cria um DatagramSocket e vincula
     para a porta especificada na máquina local.

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

     Sintaxe: public DatagramSocket (int port,
                            InetAddress inetaddress)
                             lança SocketException
     Parâmetros:
     porta - porta à qual o soquete deve ser vinculado.
     inetaddress - endereço local ao qual o soquete deve ser vinculado.
     Lança:
     SocketException - se o soquete não puder ser vinculado ao 
     porta local específica. Ele cria um DatagramSocket e
     liga-o à porta e ao endereço IP especificados.
     

2. Criação do DatagramPacket: Nesta etapa, é criado o pacote de envio / recebimento de dados por meio de um datagramSocket.
   • Construtor para enviar dados: DatagramPacket (byte buf [], comprimento int, InetAddress inetaddress, porta int): -

     Sintaxe: public DatagramPacket (byte [] buf,
                   deslocamento interno,
                   comprimento interno,
                   Endereço SocketAddress)
     Parâmetros:
     buf - os dados do pacote.
     deslocamento - o deslocamento de dados do pacote.
     comprimento - o comprimento do pacote de dados.
     endereço - o endereço do soquete de destino.
     Constrói um DatagramPacket para enviar dados no endereço especificado
      e a porta especificada.

   • Construtor para receber os dados:
     DatagramPacket (byte buf [], comprimento interno): -

     Sintaxe: public DatagramPacket (byte buf [],
                   comprimento interno)
     Parâmetros:
     buf - os dados do pacote.
     comprimento - o comprimento do pacote de dados.
     Constrói um DatagramPacket para receber os dados de comprimento
     no buf da matriz de bytes.
     

3. Invocar uma chamada send() ou receive() no objeto socket

   Sintaxe: void send (pacote DatagramPacket)
                              lança SocketException
   Parâmetros:
   pacote - pacote de dados a enviar.
   Lança:
   SocketException - se houver um erro na ligação.
   IllegalArgumentException - se o endereço não for compatível com o soquete.
   

   Sintaxe: void receive (DatagramPacket packet)
                              lança SocketException
   Parâmetros:
   pacote - pacote de dados a receber deste socket.
   Lança:
   SocketException - se houver um erro na ligação.
   IllegalArgumentException - se o endereço não for compatível com o soquete.
   

Implementação do lado do 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;
        }
    }
}

Saída:

Hello
I am Client.
...
bye

Implementação do lado do 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;
    }
}

Em poucas palavras, podemos resumir as etapas de envio e recebimento de dados por UDP da seguinte maneira: -

1. Para enviar um pacote via UDP, devemos saber 4 coisas, a mensagem a enviar, seu comprimento, endereço IP de destino, porta em que o destino está escutando.
2. Uma vez que saibamos todas essas coisas, podemos criar o objeto socket para transportar os pacotes e pacotes que realmente possuem os dados.
3. Invoque a chamada send() / receive() para realmente enviar / receber pacotes.
4. Extraia os dados do pacote recebido.

Saída:

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

Nota: - Para testar os programas acima no sistema, certifique-se de executar primeiro o programa do servidor e depois o do cliente. Certifique-se de estar no console do cliente e, a partir daí, continue digitando suas mensagens, cada uma seguida por um retorno de carro. Sempre que enviar uma mensagem, você será redirecionado para o console do servidor, dependendo das configurações do seu ambiente. Se não for redirecionado automaticamente, mude para o console do servidor para garantir que todas as suas mensagens sejam recebidas. Finalmente, para encerrar a comunicação, digite "tchau" (sem aspas) e pressione Enter.

Como um leitor entusiasmado, você também deve tentar implementar um aplicativo de bate-papo bidirecional em que o servidor será capaz de responder às mensagens como e quando quiser.

Referências:
http://download.java.net/jdk7/archive/b123/docs/api/java/net/DatagramSocket.html
http://download.java.net/jdk7/archive/b123/docs/api/java /net/DatagramPacket.html

Este artigo foi contribuído por Rishabh Mahrsee . Se você gosta de GeeksforGeeks e gostaria de contribuir, você também pode escrever um artigo usando contribute.geeksforgeeks.org ou enviar o seu artigo para contribute@geeksforgeeks.org. Veja o seu artigo na página principal do GeeksforGeeks e ajude outros Geeks.

Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima.