Classe Java.net.DatagramSocket em Java

O soquete de datagrama é um tipo de soquete de rede que fornece um ponto sem conexão para enviar e receber pacotes. Cada pacote enviado de um soquete de datagrama é individualmente roteado e entregue. Também pode ser usado para enviar e receber mensagens broadcast. Datagram Sockets é o mecanismo do java para fornecer comunicação de rede via UDP em vez de TCP.
Construtores:

DatagramSocket(): Cria um datagramSocket e o vincula a qualquer porta disponível na máquina local. Se este construtor for usado, o sistema operacional atribuirá qualquer porta a este soquete.
```
Sintaxe: public DatagramSocket()
               lança SocketException
Lança:
SocketException: se o soquete não puder ser aberto
```

DatagramSocket (DatagramSocketImpl impl): Cria um soquete de datagrama não acoplado com determinado datagramImpl.

Sintaxe: protected DatagramSocket (DatagramSocketImpl impl)
 Parâmetros: 
impl: instance of datagramScketImpl

DatagramSocket (int port): Cria e vincula o soquete do datagrama à porta especificada. O soquete será vinculado a um endereço curinga escolhido pelo kernel.
```
Sintaxe: public DatagramSocket (int port)
               lança SocketException
Parâmetros:  
porta: número da porta para ligar este soquete
```

DatagramSocket (int port, InetAddress laddr): Constrói um socket de datagrama e o vincula à porta e inetaddress especificados.

Sintaxe: public DatagramSocket (int port,
              InetAddress laddr)
               lança SocketException
Parâmetros:
porta: porta local para vincular
laddr: endereço local para vincular
Lança:
SocketException: se o soquete não puder ser aberto

DatagramSocket (SocketAddress bindaddr): Constrói um novo objeto de soquete e o vincula ao endereço de soquete especificado (endereço IP + número da porta).

Sintaxe: public DatagramSocket (SocketAddress bindaddr)
               lança SocketException
Parâmetros:
bindaddr: endereço de soquete para ligar
Lança: 
SocketException: se o soquete não puder ser aberto

Métodos :

bind(): Vincula este soquete ao endereço e número de porta especificados.

Sintaxe: public void bind (SocketAddress addr)
 Parâmetros:  
addr: endereço de soquete para vincular

connect(): Conecta-se ao endereço e porta especificados. Depois de conectar-se ao host remoto, este soquete pode enviar ou receber pacotes somente deste host remoto. Se uma conexão não puder ser feita para o host remoto especificado, as chamadas para send() ou receive() lançariam a exceção PortUnreachable.
```
Sintaxe: public void connect (endereço InetAddress,
           porta interna)
Parâmetros:
endereço: endereço do host remoto
porta: número da porta do host remoto
```
Outro método sobrecarregado usa o endereço do soquete como parâmetro.
```
Sintaxe: public void connect (endereço SocketAddress)
 Parâmetros:
endereço: endereço do soquete do host remoto
```
desconectar(): Desconecta o soquete. Se o soquete não estiver conectado, esse método não terá efeito.
```
Sintaxe: public void disconnect()
```
isBound(): Retorna um valor booleano indicando se este socket está ligado ou não.
```
Sintaxe: public boolean isBound()
```
isConnected(): Retorna um valor booleano indicando se este soquete está conectado ou não.
```
Sintaxe: public boolean isConnected()
```
isConnected(): Retorna o valor booleano que representa o estado da conexão do soquete. Observe que mesmo após fechar o soquete, este método continuará a retornar verdadeiro se este soquete foi conectado antes de fechar o soquete.
```
Sintaxe: public boolean isConnected()
```
getInetAddress(): Retorna o endereço ao qual este socket está conectado.
```
Sintaxe: public InetAddress getInetAddress()
```
getPort(): Retorna a porta na máquina à qual este soquete está conectado.
```
Sintaxe: public int getPort()
```
getRemoteSocketAddress(): Retorna o endereço do soquete (endereço IP + número da porta) ao qual este soquete está conectado.
```
Sintaxe: public SocketAddress getRemoteSocketAddress()
```
getLocalSocketAddress(): Retorna o endereço da máquina à qual este soquete está vinculado, ou seja, o endereço do soquete da máquina local.
```
public SocketAddress getLocalSocketAddress()
```
send(): Envia um pacote de datagrama deste socket. Deve-se observar que as informações sobre os dados a serem enviados, o endereço para o qual são enviados, etc. são tratadas pelo próprio pacote.
```
Sintaxe: public void send (DatagramPacket p)
 Parâmetros:
p: pacote para enviar
```
receber(): É usado para receber o pacote de um remetente. Quando um pacote é recebido com sucesso, o buffer do pacote é preenchido com a mensagem recebida. O pacote também contém informações valiosas, como o endereço do remetente e o número da porta. Este método espera até que um pacote seja recebido.
```
Sintaxe: public void receive (DatagramPacket p)
 Parâmetros:  
p: pacote de datagrama no qual os dados de entrada são preenchidos
```
getLocalAddress(): Retorna o endereço local ao qual este socket está vinculado.
```
Sintaxe: public InetAddress getLocalAddress()
```
getLocalPort(): Retorna a porta na máquina local à qual este soquete está vinculado.
```
Sintaxe: public int getLocalPort()
```
setSOTimeout(): É usado para definir o tempo de espera para receber um pacote de datagrama. Como o método call to receive() bloqueia a execução do programa indefinidamente até que um pacote seja recebido, esse método pode ser usado para limitar esse tempo. Depois que o tempo especificado expira, java.net.SocketTimeoutException é lançado.
```
Sintaxe: public void setSoTimeout (int timeout)
 Parâmetros: 
timeout: time to wait
```
getSoTimeout(): Retorna o parâmetro de tempo limite, se especificado, ou 0, que indica tempo infinito.
```
Sintaxe: public int getSoTimeout()
```

setSendBufferSize(): Usado para definir um limite para o tamanho máximo do pacote que pode ser enviado a partir deste soquete. Ele define a opção SO_SNDBUF, que é usada pela implementação da rede para definir o tamanho dos buffers de rede subjacentes. Aumentar o tamanho pode permitir enfileirar os pacotes antes de enviar quando a taxa de envio for alta.

Sintaxe: public void setSendBufferSize (int size)
 Parâmetros:  
size: tamanho do buffer de envio a ser definido

Implementação Java:

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

import java.util.Arrays;

public class datasocket

{

public static void main(String[] args) throws IOException

{

// Constructor to create a datagram socket

DatagramSocket socket = new DatagramSocket();

InetAddress address = InetAddress.getByName("localhost");

int port = 5252;

byte buf[] = { 12, 13 };

byte buf1[] = new byte[2];

DatagramPacket dp = new DatagramPacket(buf, 2, address, port);

DatagramPacket dptorec = new DatagramPacket(buf1, 2);

// connect() method

socket.connect(address, port);

// isBound() method

System.out.println("IsBound : " + socket.isBound());

// isConnected() method

System.out.println("isConnected : " + socket.isConnected());

// getInetAddress() method

System.out.println("InetAddress : " + socket.getInetAddress());

// getPort() method

System.out.println("Port : " + socket.getPort());

// getRemoteSocketAddress() method

System.out.println("Remote socket address : " +

socket.getRemoteSocketAddress());

// getLocalSocketAddress() method

System.out.println("Local socket address : " +

socket.getLocalSocketAddress());

// send() method

socket.send(dp);

System.out.println("...packet sent successfully....");

// receive() method

socket.receive(dptorec);

System.out.println("Received packet data : " +

Arrays.toString(dptorec.getData()));

// getLocalPort() method

System.out.println("Local Port : " + socket.getLocalPort());

// getLocalAddress() method

System.out.println("Local Address : " + socket.getLocalAddress());

// setSOTimeout() method

socket.setSoTimeout(50);

// getSOTimeout() method

System.out.println("SO Timeout : " + socket.getSoTimeout());

}

Para testar o programa acima, um pequeno programa de servidor é necessário para receber o pacote enviado e para implementar o método receive(). Sua implementação é apresentada a seguir.

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

public class smallserver {

public static void main(String[] args) throws IOException {

DatagramSocket ds = new DatagramSocket(5252);

byte buf[] = new byte[2];

byte send[] = { 13, 18 };

DatagramPacket dp = new DatagramPacket(buf, 2);

ds.receive(dp);

DatagramPacket senddp = new DatagramPacket(send, 2,

dp.getAddress(), dp.getPort());

ds.send(senddp);

}

Resultado: do lado do cliente

IsBound: true
isConnected: true
InetAddress: localhost / 127.0.0.1
Porta: 5252
Endereço de soquete remoto: localhost / 127.0.0.1: 5252
Endereço de soquete local: /127.0.0.1:59498
pacote enviado com sucesso
Dados de pacote recebidos: [13, 18]
Porta local: 59498
Endereço local: /127.0.0.1
SO Tempo Limite: 50

getSendBufferSize(): Retorna o valor da opção SO_SNDBUF deste socket.
```
Sintaxe: public int getSendBufferSize()
```
setReceiveBufferSize(): Usado para definir um limite para o tamanho máximo do pacote que é recebido neste soquete. Ele define a opção SO_RCVBUF, que é usada pela implementação de rede para definir o tamanho dos buffers de rede subjacentes. Aumentar o tamanho pode permitir enfileirar os pacotes na extremidade receptora, quando os pacotes são enviados mais rápido do que são consumidos.
```
Sintaxe: public void setReceiveBufferSize (int size)
 Parâmetros:  
size: tamanho do buffer de recepção a ser definido
```
getReceiveBufferSize(): Retorna o valor da opção SO_RCVBUF deste socket.
```
Sintaxe: public int getReceiveBufferSize()
```
setReuseAddress(): às vezes, pode ser necessário vincular vários soquetes ao mesmo endereço. Habilitar essa opção permite que outro soquete se vincule ao mesmo endereço que este. Deve ser definido antes que uma chamada para bind() seja feita. Ele define o valor da opção de soquete SO_REUSEADDR.
```
Sintaxe: public void setReuseAddress (boolean on)
 Parâmetros:  
on: true para habilitar, false caso contrário
```
getReuseAddress(): Retorna o valor booleano indicando a configuração da opção de soquete SO_REUSEADDR.
```
Sintaxe: public boolean getReuseAddress()
```

setBroadcast(): Define o valor da opção de soquete SO_BROADCAST.

Sintaxe: public void setBroadcast (booleano ativado)
Parâmetros: 
on: true para permitir bradcast, false caso contrário

getBroadcast(): Retorna verdadeiro se a transmissão estiver habilitada, falso caso contrário.
```
Sintaxe: public boolean getBroadcast()
```
setTrafficClass(): usado para definir o octeto do tipo de serviço no cabeçalho do datagrama IP para datagramas enviados deste DatagramSocket. Para obter mais detalhes sobre a classe de tráfego, consulte a Wikipedia
```
Sintaxe: public void setTrafficClass (int tc)
 Parâmetros:  
tc: int valor do bitset, 0 <= tc <= 255
```
getTrafficClass(): obtém a classe de tráfego ou tipo de serviço do cabeçalho IP dos pacotes enviados deste socket.
```
Sintaxe: public int getTrafficClass()
```
close(): fecha este soquete de datagrama. Qualquer chamada de recepção pendente lançará SocketException.
```
Sintaxe: public void close()
```
isClosed(): Retorna o valor booleano indicando se o socket está fechado ou não.
```
Sintaxe: public boolean isClosed()
```
getChannel(): Retorna um canal de dados, se houver algum associado a este socket. Mais detalhes sobre os canais de datagrama podem ser encontrados na documentação oficial do Java .
```
Sintaxe: public DatagramChannel getChannel()
```

setDatagramSocketImplFactory(): Define a fábrica de implementação de soquete de datagrama para o aplicativo.

Sintaxe: public static void setDatagramSocketImplFactory (
                                 DatagramSocketImplFactory fac)
Parâmetros: 
fac - a fábrica desejada.
Lança: 
IOException - se ocorrer um erro de E / S ao configurar a fábrica de soquete de datagrama.
SocketException - se a fábrica já estiver definida.

Implementação Java:

import java.io.IOException;

import java.net.DatagramSocket;

public class datasock2 {

public static void main(String[] args) throws IOException {

// Constructor

DatagramSocket socket = new DatagramSocket(1235);

// setSendBufferSize() method

socket.setSendBufferSize(20);

// getSendBufferSize() method

System.out.println("Send buffer size : " +

socket.getSendBufferSize());

// setReceiveBufferSize() method

socket.setReceiveBufferSize(20);

// getReceiveBufferSize() method

System.out.println("Receive buffer size : " +

socket.getReceiveBufferSize());

// setReuseAddress() method

socket.setReuseAddress(true);

// getReuseAddress() method

System.out.println("SetReuse address : " +

socket.getReuseAddress());

// setBroadcast() method

socket.setBroadcast(false);

// getBroadcast() method

System.out.println("setBroadcast : " +

socket.getBroadcast());

// setTrafficClass() method

socket.setTrafficClass(45);

// getTrafficClass() method

System.out.println("Traffic class : " +

socket.getTrafficClass());

// getChannel() method

System.out.println("Channel : " +

((socket.getChannel()!=null)?socket.getChannel():"null"));

// setSocketImplFactory() method

socket.setDatagramSocketImplFactory(null);

// close() method

socket.close();

// isClosed() method

System.out.println("Is Closed : " + socket.isClosed());

}

Saída :

Tamanho do buffer de envio: 20
Tamanho do buffer de recepção: 20
Endereço SetReuse: true
setBroadcast: false
Classe de trânsito: 44
Canal: nulo
Está fechado: verdadeiro

Referências: Documentação oficial do Java
Este artigo é uma contribuição de 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.

Acervo Lima

O maior acervo de tutoriais e referências

Classe Java.net.DatagramSocket em Java

Latest posts

Latest posts

Most popular posts