Galera preciso de ajuda em uma aplicação minha que usa Sockets, DatagramSocket, Multicast, DatagramPackets. Eu tenho um servidor e um cliente, os dois são multi-threads. Antes de explicar já vou falar qual o problema. Rodando a aplicação com ip localhost( 127.0.0.1 ) ela funciona eu executando o servidor e abrindo mais de dois clientes. Agora executando o servidor em um servidor mesmo( tenho um servidor linux aqui em casa ) e abrindo o cliente na minha máquina usando o ip do servidor não funciona. Eu estou tentando depurar e acho que já sei onde é o problema só não sei como resolver. ( Lembrando que isso que vou falar agora se refere a quando rodo a aplicação servidor em um servidor mesmo ).
Eu fiz uns testes e vi que o cliente manda a mensagem para o servidor e o servidor recebe. Agora eu não sei se o servidor está mandando de volta porque o cliente parece ficar no loop de espera por pacotes e não recebe nada. Veja, o cliente manda mensagem para o servidor assim:
@Override
public void run() {
// Envia mensagem e descarrega PrintWriter
try {
Formatter output = new Formatter( clienteSocket.getOutputStream() );
output.format( "%s\n", mensagemParaEnviar ); // envia mensagem
output.flush();
}
catch( IOException ioE ) {
ioE.printStackTrace();
}
}
O servidor recebe mensagem do cliente assim:
public class RecebedorDeMensagem implements Runnable {
/** Fluxo de entrada para ler mensagens recebidas do cliente */
private BufferedReader bufferInput;
public RecebedorDeMensagem( MensagemListener listener, Socket clienteSocket ) {
mensagemListener = listener;
try {
/** Configura tempo limite para leitura das mensages de um cliente - 5 segundos */
clienteSocket.setSoTimeout( 5000 );
bufferInput = new BufferedReader( new InputStreamReader( clienteSocket.getInputStream() ) );
}
catch( IOException e ) {
e.printStackTrace();
}
} // fim do construtor
/**
* Escuta por novas mensagens e as entrega para MensagemListener
*/
@Override
public void run() {
String mensagem;
// Escuta por mensagens até parar
while( continuaEscutando ) {
try {
/** String para mensagens recebidas. OBS: Se passar 5 segundos sem ler dados gera uma exceção */
mensagem = bufferInput.readLine();
}
catch( SocketTimeoutException sTE ) {
continue; // Continua para a próxima iteração do loop
}
catch( IOException ioE ) {
ioE.printStackTrace();
break;
}
} // fim do método run de Runnable
O servidor envia para os clientes de volta assim:
/**
* Entrega mensagens para MULTICAST_ENDERECO sobre DatagramSocket
*/
@Override
public void run() {
try {
/** Cria DatagramSocket para enviar mensagens */
DatagramSocket datagramSocket = new DatagramSocket( MULTICAST_PORTA_ENVIA );
/** Usa um InetAdress reservado para um grupo multicast - O grupo de assinantes que desejam se conectar ao grupo */
InetAddress grupo = InetAddress.getByName( MULTICAST_ENDERECO );
/** Cria um DatagramPacket contendo a mensagem */
DatagramPacket datagramPacket = new DatagramPacket( dadosDaMensagem, dadosDaMensagem.length, grupo, MULTICAST_PORTA_LISTENER );
// Envia pacote para grupo Multicast - cada cliente recebe os pacotes
datagramSocket.send( datagramPacket );
datagramSocket.close();
}
catch( IOException ioE ) {
ioE.printStackTrace();
}
} // fim do método run
e por último o cliente recebe mensagens do servidor assim:
public RecebedorDePacotes( MensagemListener listener ) {
mensagemListener = listener;
// Conecta MulticastSocket ao endereço Multicast e porta
try {
// Porta que o MulticastSocket irá escutar por novas mensagens
multicastSocket = new MulticastSocket( MULTICAST_PORTA_LISTENER );
// Usa InetAddress para receber grupo multicast
multicastGrupo = InetAddress.getByName( MULTICAST_ENDERECO );
// Se junta ao grupo multicast para receber mensagens enviadas do MULTICAST_ENDERECO
multicastSocket.joinGroup( multicastGrupo );
// Configura com 5 segundos como tempo limite para esperar novos pacotes - Previne RecebedorDePacotes do bloqueio indefinido
// enquanto estiver esperando para receber novos DatagramPackets
multicastSocket.setSoTimeout( 5000 );
}
catch( IOException ioE ) {
ioE.printStackTrace();
}
} // fim do construtor
@Override
public void run() {
// Escuta por novas mensagens até parar
while( continuaEscutando ) {
// Cria buffer para as mensagens recebidas
byte[] buffer = new byte[ MENSAGEM_TAMANHO ];
// Cria DatagramPacket para as mensagens recebidas
DatagramPacket datagramPacket = new DatagramPacket( buffer, MENSAGEM_TAMANHO );
// Recebe novos DatagramPackets( Bloqueando chamada )
try {
multicastSocket.receive( datagramPacket );
}
catch( SocketTimeoutException stE ) {
continue; // continua para próxima iteração do loop
}
catch( IOException ioE ) {
ioE.printStackTrace();
break;
}
/** Coloca dados da mensagem na string */
String mensagem = new String( datagramPacket.getData() );
} // fim do loop while
Eu sei que nesse ultimo codigo que eu postei, essa linha fica bloqueada:
try {
multicastSocket.receive( datagramPacket );
}
Porque essa parte nunca chega( fazendo os meus testes percebi isso )
/** Coloca dados da mensagem na string */
String mensagem = new String( datagramPacket.getData() );
} // fim do loop while
Porém ele fica rodando o run direto procurando por mensagens e parece nunca receber. O código aqui ta resumido foram apenas para quem quiser me ajudar entender como estou fazendo o envio e recebimento. O restou eu estou fazendo tambem mas não postei aqui tipo fechar a conexao, dizer quando parar de escutar e tal.