Socket Server antwortet dem Client nicht

[MarcelFelder]

Guten Tag, ich muss im Studium ein Spiel programmieren. Ich bin für die Server/Client Architektur verantwortlich. Ich habe bereits eine Server-Klasse und eine Client-Klasse geschrieben. Es funktioniert eigentlich auch schon vieles, nur bei einem Punkt komme ich nicht mehr weiter. Wenn der Client eine Message an den Server sendet, so antwortet der Server dann nicht dem Client (gemäss if-Condition in der Server-Klasse). Oder liegt das Problem beim Client und dieser kann die Nachricht nicht empfangen? Kann mir jemand helfen? ich habe leider kaum Erfahrung mit Java. Besten Dank.

 

[Robat]

Du würdest uns hier allen einen gefallen tun, wenn du deinen [wichtigen] Quellcode entweder hier in Code-Tags [ code = Java] .. [ / code] (nur eben ohne Leerzeichen) oder zumindestens Screenshots / Dateien mit der Endung .java hochladen könntest.

Ich (und mMn die anderen auch) haben sicherlich keine Lust deine Code erst richtig zu formatieren 🙂

Gruß
Robert

 

[MarcelFelder]

Entschuldige, ich kann keine .java Dateien hochladen, daher so:

Server:

package Test;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * A simple Server class
 * 
 * Based on code example from 
 * http://www.mysamplecode.com/2011/12/java-multithreaded-socket-server.html
 * Date of visit: 11.10.2016
 * 
 * @author Marcel Felder
 *
 */
public class ServerNew {

    //Instance variables
    ServerSocket serverSocket;
    boolean ServerOn = true;
    private ArrayList<PrintStream> list_clientWriter;
    private ArrayList<Socket> list_clientSockets;
    private Map<Integer, String> map_id_name = new HashMap<Integer, String>();
    int port = 16003;
    int clientId = 0;
    private static final int MAX_CLIENT = 2; //This server can accept up to MAX_CLIENT clients' connection

    //Main object of the server instance
    public ServerNew() { 
       
        try { 
            serverSocket = new ServerSocket(port);
            appendTextToConsole("Server created. Port: " + port);
            //list_clientWriter = new ArrayList<PrintStream>();
            list_clientSockets = new ArrayList<Socket>();
        } 
        catch(IOException ioe) { 
            appendTextToConsole("Could not create ServerSocket on port " + port + ". Quitting."); 
            System.exit(-1); 
        } 

        //Ausgabe Zeit des Erstellen des Server
        Calendar now = Calendar.getInstance();
        SimpleDateFormat formatter = new SimpleDateFormat("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
        appendTextToConsole("ServerSocket created: " + formatter.format(now.getTime()));

        // Successfully created Server Socket. Now wait for connections. 
        while(ServerOn) {                        
            listenToClients();

        } try { 
            serverSocket.close(); 
            appendTextToConsole("Server stopped");    
        }catch(Exception e) { 
            appendTextToConsole("Problem stopping ServerSocket"); 
            System.exit(-1); 
        } 

    }
   
   
    /**
    * Method where Server accepts several clients. 
    * For each ClientSocket a new ClientServiceThread
    * will be started.
    */
    public void listenToClients() {

        while (clientId < 2) {
           
            appendTextToConsole("Server waits for incoming clients");
           
            try {

                clientId++;

                Socket clientSocket = serverSocket.accept();
                list_clientSockets.add(clientSocket);

                appendTextToConsole("Client " + clientId + " hinzugefuegt.");

                // Start a service thread 
                ClientServiceThread clientThread = new ClientServiceThread(clientSocket, clientId);
                clientThread.start(); 

            }   catch(IOException ioexception) { 
                appendTextToConsole("Exception encountered on accept. Ignoring. Stack Trace :"); 
                ioexception.printStackTrace(); 
            } 

            if (clientId == MAX_CLIENT) {
                appendTextToConsole("Spiel wird gestartet");
               
                sendToOneClient(0, "Dein Zug");

                sendToOneClient(1, "Name des Gegners #" + map_id_name.get(1));

                sendToOneClient(0, "Name des Gegners #" + map_id_name.get(2));
            }
        }
    }

   
    /**
    * Method to show text in server console
    * 
    * @param message
    *            the text to be showed in console
    */
    public void appendTextToConsole(String message) {

        System.out.println(message);
    }
   
   
    /**
    * Method to send a message to only one client
    * 
    * @param index
    *            the index of the print writer.
    * @param message
    *            the message for the client
    * @throws IOException 
    */
    public void sendToOneClient(int index, String message) {

        PrintStream writer;

        try {       
            writer = list_clientWriter.get(index);
            writer.println(message);
            writer.flush();   
       
        }catch (Exception e) {
            System.err.println("IOException: " + e);
        }
    }
   
   
    /**
    * Method to send message to all clients
    * 
    * @param message
    *            the message which has to be sent to all clients
    * @throws IOException 
    */
    public void sendToAllClients(String message) throws IOException {

        Iterator<PrintStream> it = list_clientWriter.iterator();
       
        while (it.hasNext()) {
            PrintStream writer = (PrintStream) it.next();

            writer.println(message);
            writer.flush();
        }
    }
   
   
    /**
    * Method to add a player name, according to the client id, to the HashMap
    * 
    * @param id
    *            the id of the connected socket
    * @param name
    *            the player name to be added
    */
    public void addPlayername(int id, String name) {
        map_id_name.put(id, name);
    }

   
    //Main method to start the server
    public static void main (String[] args) 
    { 
        new ServerNew();        
    } 

   
    //-----------New Class-----------//
   
   
    /**
     * A class, which listens to incoming messages from client and interprets them.
     * 
     * @author Marcel Felder
     *
     */
    public class ClientServiceThread extends Thread { 
       
        //Instance variables
        Socket ClientSocket;
        int ClientId;
        boolean RunThread = true;
       
        private DataInputStream inFromClient = null;
        private PrintStream outToClient = null;

        public ClientServiceThread() { 
            super(); 
        } 

        public ClientServiceThread(Socket s, int id) { 
            this.ClientSocket = s;
            this.ClientId = id;
        } 

        public void run() {
           
            String clientMessage;
         
            try {
               
                inFromClient = new DataInputStream(ClientSocket.getInputStream());
                outToClient = new PrintStream(ClientSocket.getOutputStream());
                outToClient.println("Hello Client " + clientId + ", schön bist du hier!");
                list_clientWriter = new ArrayList<PrintStream>();
                list_clientWriter.add(outToClient);
           
               
                // At this point, we can read for input and reply with appropriate output. 
                // Run in a loop until RunThread is set to false 
                while(RunThread) {
                   
                    if(!ServerOn) 
                    { 
                        // Special command. Quit this thread 
                        appendTextToConsole("Server has already stopped"); 
                        outToClient.println("Server has already stopped"); 
                        outToClient.flush(); 
                        RunThread = false;
                    } 
                   
                    // read incoming stream
                    while ((clientMessage = inFromClient.readLine()) != null) {
                       
                        appendTextToConsole("Client " + ClientId + " says :" + clientMessage);
                       
                       
                        //TEST FÜRS SENDEN!!
                        if(clientMessage.equals("hello")){
                            appendTextToConsole("es geht bis hier");
                            //bis hier gehts, danach kann der text nicht zurück an den sender 
                            //gesendet werden! checken warum?
                            outToClient.println("it works");
                        }
                     
                        // Interpreting the messages
                        if(clientMessage.equals("switchTurn")){
                            if(this.ClientId == 1){
                                sendToOneClient(1, "Your turn");
                                sendToAllClients(clientMessage); 
                            } else if(this.ClientId == 2){
                                sendToOneClient(0, "Your turn");
                                sendToAllClients(clientMessage);
                            }   
                       
                        }else if(clientMessage.contains("won")){
                            if(this.ClientId == 1){
                                sendToOneClient(1, clientMessage);
                                sendToAllClients("Game is over");
                            } else if(this.ClientId == 2){
                                sendToOneClient(0, clientMessage);
                                sendToAllClients("Game is over");
                            }   
                       
                        }else if(clientMessage.equalsIgnoreCase("quit")){ 
                                // Special command. Quit this thread 
                                RunThread = false;  
                                appendTextToConsole("Stopping client thread for client: " + ClientId); 
                            }
                       
                        else if(clientMessage.equalsIgnoreCase("end")) { 
                                // Special command. Quit this thread and Stop the Server
                                RunThread = false;  
                                appendTextToConsole("Stopping client thread for client: " + ClientId); 
                                ServerOn = false;
                                appendTextToConsole("Server stopped ");
                            }
                           
                        else{
                            sendToAllClients(clientMessage);
                            outToClient.flush();
                            }
                        }
                    }
                }

            catch(Exception e) { 
                e.printStackTrace();
            } 
           
            finally { 
               
                // Clean up 
                try {                    
                    inFromClient.close(); 
                    outToClient.close(); 
                    ClientSocket.close(); 
                    System.out.println("...Stopped"); 
                } catch(IOException ioexception) { 
                    ioexception.printStackTrace(); 
                } 
         }      
      }
   }    
}

Client:

package Test;



import java.net.*;

import java.io.*;



/**

 * A simple Server class

 * 

 * Based on code example from 

 * http://www.mysamplecode.com/2011/12/java-socket-client-example-connect-to.html

 * Date of visit: 11.10.2016

 * 

 * @author Marcel Felder

 *

 */

public class ClientNew implements Runnable{ 

   

    //Instance Variables

    Socket clientSocket = null;

    int port = 16003;

    String host = "localhost";

    DataInputStream inFromServer = null;

    PrintStream outToServer = null;

    BufferedReader inFromUser = null;

    privatestaticbooleanclosed = false;

   

    //Main object of the client instance

    public ClientNew() throws IOException {

   

        try {

         

            //create client socket to establish connection to server

            clientSocket = new Socket(host, port);

           

            //create I/O stream to communicate with server/client

            inFromUser = new BufferedReader(new InputStreamReader(System.in));

            inFromServer = new DataInputStream(clientSocket.getInputStream());

            outToServer = new PrintStream(clientSocket.getOutputStream());



           

        } catch (UnknownHostException e) {

            System.err.println("Don't know about host: " + host);

        } catch (IOException e) {

            System.err.println("Couldn't get I/O for the connection to: " + host);

        }

       

        if (clientSocket != null && outToServer != null && inFromServer != null) {

            try {

                //Create new Thread

                new Thread(new ClientNew()).start();

             

                while (!closed) {

                    System.out.println("Type in something and press enter. Will send it to the server.");

                    outToServer.println(inFromUser.readLine());

                }

            }catch (IOException e) {

                System.err.println("IOException: " + e);

            }

         

            finally {

                inFromServer.close();

                outToServer.close();

                clientSocket.close();

            } 

        }



//        try {

//            while (ClientOn) {

//             

//                while ((messageFromUser = inFromUser.readLine()) != null){

//                    //messageFromClient = inFromClient.readLine(); //message typed in from Client

//                    //outToServer.writeBytes(messageFromClient + '\n'); //message send to Server

//                    outToServer.writeBytes(messageFromUser + '\n'); //message send to Server

//                    //System.out.println("Type in something and press enter. Will send it to the server.");

//                }

//

//                while ((messageFromServer = inFromServer.readLine()) != null){

//                    System.out.println(messageFromServer);

//                }

//                //messageFromServer = inFromServer.readUTF(); //message in from Server

//} 

//        }catch (Exception e){

//            e.printStackTrace();

//        }      

       

    }



   

   

   

   

    public static void main(String[] args) { 

        new SocketClient();

    }











    @Override

    public void run() {

        String responseLine;

        try {

            while ((responseLine = inFromServer.readLine()) != null){

                System.out.println(responseLine);

            }

        }catch (IOException e) {

            System.err.println("IOException: " + e);

        }

       

    }

}

 

[Robat]

//TEST FÜRS SENDEN!!
if(clientMessage.equals("hello")){
appendTextToConsole("es geht bis hier");
//bis hier gehts, danach kann der text nicht zurück an den sender
//gesendet werden! checken warum?
outToClient.println("it works");
}

Hat das was mit deinem Problem zu tun? Also du gibst hier "es geht bis hier" aus.. heißt es, dass er doch antwortet? Oder antwortet er gar nicht? Hast du schon mal gedebugged? Oder wie genau kann ich dein Problem interpretieren? 🙂

PS: Deine Methode <appendToConsole()> macht es schwierig deinen QC zu lesen - eher eine unnötige Methode 😛

Gruß
Robert

 

[MarcelFelder]

Hat das was mit deinem Problem zu tun? Also du gibst hier "es geht bis hier" aus.. heißt es, dass er doch antwortet? Oder antwortet er gar nicht? Hast du schon mal gedebugged? Oder wie genau kann ich dein Problem interpretieren? 🙂

PS: Deine Methode <appendToConsole()> macht es schwierig deinen QC zu lesen - eher eine unnötige Methode 😛

Gruß
Robert

Der Server erkennt zwar, dass ich vom Client die Message "hello" sende und gibt den Text "es geht bis hier" auf der Server-Konsole aus. Aber eigentlich sollte er jetzt noch dem Client antworten "it works" (auf der Client Konsole). Tut er aber nicht. Etwas mit der Variable outToClient oder dem InputStream beim Client scheint nicht zu funktionieren. Und ja, dass mit der append-Methode ist fraglich, aber es wird nicht gern gesehen vom Dozent die SysOut Methode. Naja...
Beim Debuggen konnte ich nicht feststellen was dem Ding fehlt.

 

[fhoffmann]

Hallo,

ein outToClient.flush(); nach outToClient.println("it works"); kann nicht schaden.

Außerdem rufst du in der main-Funktion new SocketClient() auf und nicht new ClientNew() - welche Klasse meinst du nun wirklich?
Und der Konstruktor ClientNew() ruft in seinem Code sich selber auf: new Thread(new ClientNew()).start()!
Ferner ist mir aufgefallen, dass der Server bei jeder Anmeldung eines Clients eine neue Liste der Clients erstellt: list_clientWriter = new ArrayList<PrintStream>()

Gruß
Fritz

 

[JuKu]

Einmal verwendest du println, mal deine eigene Methode:

//TEST FÜRS SENDEN!!
                        if(clientMessage.equals("hello")){
                            appendTextToConsole("es geht bis hier");
                            //bis hier gehts, danach kann der text nicht zurück an den sender
                            //gesendet werden! checken warum?
                            outToClient.println("it works");
                        }
                   
                        // Interpreting the messages
                        if(clientMessage.equals("switchTurn")){
                            if(this.ClientId == 1){
                                sendToOneClient(1, "Your turn");
                                sendToAllClients(clientMessage);
                            } else if(this.ClientId == 2){
                                sendToOneClient(0, "Your turn");
                                sendToAllClients(clientMessage);
                            }
                     
                        }

Probiere mal nen outToClient.flush() nach dem outToClient.println("it works") .