How to put socket in read mode until receiving another data in java

0

I created the server part and the client part. If messaging is just an input and an output works perfectly, the problem is to maintain communication without closing the socket.

In case I send a message to the server, it responds by confirming receipt. On the client side I send a receipt acknowledgment and the server then sends the result of the operation.

Is there any way to make the server-side reading method wait for a new entry? When I read it again the method ends up reading the first entry of the client, because a new entry has not yet been made. Could you help me?

Follow my code ...

Customer

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

import javax.xml.rpc.ServiceException;

public class Cliente {

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

        try {

            Socket socket = new Socket("localhost", 40005);
            String resposta = null;
            String mensagem = "#Jose Alvaro#";
            socket.setSoTimeout(18000);
            socket.setTcpNoDelay(true);
            DataOutputStream saida = new DataOutputStream(socket.getOutputStream());
            BufferedReader entrada = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            resposta = enviarSolicitacaoExecucao(entrada, saida, mensagem);
            System.out.println(resposta);
            enviarConfirmacaoRecebimentoResposta(entrada, saida, mensagem, resposta);
            resposta = lerResposta(entrada, (char) 0);
            System.out.println(resposta);
            socket.close();
            /*
             * if(StringUtil.isNull(resposta)){
             * System.out.println("Resposta é nula"); }
             */
            // resposta = limparBinariosResposta(resposta);

        } catch (IOException e) {
            System.out.println(e);
        }
    }

    private static String lerResposta(BufferedReader entrada, char charactereEsperado) throws IOException {

        StringBuilder respostaBuilder = new StringBuilder();
        String resposta = null;

        char[] charBuffer = new char[8192];
        int bytesLidos = 0;
        do {
            try {
                bytesLidos = entrada.read(charBuffer);

            } catch (Exception e) {
                System.out.println("Erro" + e.getMessage());
            }
            respostaBuilder.append(new String(charBuffer, 0, bytesLidos).trim());
        } while (charactereEsperado != 0 && charBuffer[bytesLidos - 1] != charactereEsperado);

        resposta = respostaBuilder.toString();
        // System.out.println(resposta);

        return resposta;
    }

    private static void enviarConfirmacaoRecebimentoResposta(BufferedReader entrada, DataOutputStream saida,
            String mensagem, String resposta) throws IOException, ServiceException {

        /*
         * if (!validarConfirmacaoRecebimento(mensagem.getId(), resposta)) {
         * System.out.
         * println("Resposta não contem confirmação de recebimento do EOC"); }
         * 
         */ String confirmacao = "2 requisicao" + "\n";// mensagem.montarConfirmacao();

        saida.writeBytes(confirmacao);

    }

    private static String enviarSolicitacaoExecucao(BufferedReader entrada, DataOutputStream saida, String mensagem)
            throws IOException {

        String resposta = null;

        String solicitacao = ",,,..PRATPR";

        saida.writeBytes(solicitacao + "\n");
        resposta = lerResposta(entrada, (char) 0);

        return resposta;
    }

}

Server:

public static void main(String[] args) {

     try {

           // Cria um SocketServer (Socket característico de um servidor)
           ServerSocket socket = new ServerSocket(40005);
           System.out.println("Socket iniciado OK");



           while(true) {

               Socket connectionSocket = socket.accept();
               BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));

               // Cria uma stream de sáida para retorno das informações ao cliente
               DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());

               (new ServidorSoc(connectionSocket,inFromClient,outToClient )).start();
           }
     }
     catch(Exception e){
         System.out.println(e);
     }
 }

}

public void run() {
        try {
            boolean continuar = true;
            while (continuar) {
                int cont = 1;
                String entrada = lerResposta(inFromClient, (char) 0);
                confirmacaoRec = retornarId(entrada) + confirmacaoRec;
                // System.out.println(entrada);
                // converte a resposta pra byte
                byte[] retorno = confirmacaoRec.getBytes();
                // escreve a mensagem no cliente
                outToClient.write(retorno);
                while (continuar) {
                    try {
                        sleep(10000);
                        // inFromClient.wait();
                        retornoCliente = lerResposta(inFromClient, (char) 0);
                        if (!entrada.equals(retornoCliente)) {
                            retorno = resp.getBytes();
                            outToClient.write(retorno);
                            continuar = false;
                        }
                        // System.out.println("Confirmação de recebimento" +
                        // retornoCliente);
                        // if (retornoCliente != entrada && retornoCliente !=
                        // null) {
                        // System.out.println(retornoCliente);
                        // }
                        // }
                        // sleep(1000);

                    } catch (Exception e) {
                        System.out.println(e);
                    }
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
        }

    }

    private String retornarId(String entrada3) {
        String[] s = entrada3.split("#");
        String resul = s[1];
        return resul.substring(0, 5);
    }

    private static String lerResposta(BufferedReader entrada, char charactereEsperado) throws IOException {

        StringBuilder respostaBuilder = new StringBuilder();
        String resposta = null;

        char[] charBuffer = new char[8192];
        int bytesLidos = 0;
        do {
            try {
                bytesLidos = entrada.read(charBuffer);

                // System.out.println(bytesLidos);;
            } catch (Exception e) {
                System.out.println("Erro" + e.getMessage());
            }
            respostaBuilder.append(new String(charBuffer, 0, bytesLidos).trim());
        } while (charactereEsperado != 0 && charBuffer[bytesLidos - 1] != charactereEsperado);

        resposta = respostaBuilder.toString();
        // System.out.println(resposta);

        return resposta;
    }

}
    
asked by anonymous 24.01.2018 / 18:24

1 answer

-1

I made a file server two years ago in college, it will solve your problem. It has 3 server instances, a load balance and the client side. You start the servers, then the load balance and then the client, sockets wait for messages, receive, treat, and return a response to the client.

Controller connects to server:

static Socket controladorConectaServidor() {
        try {
            server_socket_alfa = new Socket("localhost", 9700);
            System.out.println("Conexão com AlfaServer realizada");
            return server_socket_alfa;
        } catch (Exception e) {
            System.err.println("Nao consegui conectar com servidor alfa...");
            return null;
        }
    return null;
}

Server:

public class AlfaServer {

    static String endereco = ".\src\servidorAlfa\";
    static ServerSocket serversocket;
    static Socket client_socket;
    static Conexao c;
    static String msg;

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

        new AlfaServer();
        do {
            servidorEscutaControlador();
            if (connect()) {

                "AQUI VEM AS FUNÇÕES QUE VOCE PREISA IMPLEMENTAR"
                }
                fechaConexao();
            }
        } while (true);
    }

    static boolean connect() {
        boolean ret;
        try {
            client_socket = serversocket.accept();
            ret = true;
        } catch (Exception e) {
            System.err.println("Não fez conexão" + e.getMessage());
            ret = false;
        }
        return ret;
    }

    static void servidorEscutaControlador() {
        try {
            serversocket = new ServerSocket(9700);
            System.out.println("AlfaServer Escutando na porta: " + serversocket.getLocalPort());
        } catch (IOException e) {
            System.err.println("Não foi possível criar o controlador");
        }
    }

    static void fechaConexao() {
        try {
            client_socket.close();
            serversocket.close();           // fase de desconexão
        } catch (Exception e) {
            System.err.println("Não encerrou a conexão corretamente" + e.getMessage());
        }
    }

}

Connection class:

public class Conexao {

    public static void send(Socket socket, Object obj) {
        ObjectOutputStream out;
        try {

            out = new ObjectOutputStream(socket.getOutputStream());
            out.writeObject(obj);
        } catch (Exception e) {
            System.err.println("Exceção no OutputStream");
        }
    }

    public static Object receive(Socket socket) {
        ObjectInputStream in;
        Object obj = null;
        try {
            in = new ObjectInputStream(socket.getInputStream());
            obj = in.readObject();
        } catch (Exception e) {
            System.err.println("Exceção no InputStream: " + e);
        }
        return obj;
    }
}

File Server (Github)

If you have questions send me a message that I will help

    
25.01.2018 / 04:58