Java Server JavaScript-Client WebSockets

Question

Ich versuche, eine Verbindung zwischen einem Server in Java und JavaScript-Client zu tun, aber ich bin immer diesen Fehler auf Client-Seite:

WebSocket-Verbindung zu ‚ws://127.0.0.1:4444/‘ist fehlgeschlagen: Verbindung geschlossen, bevor ein Handshake-Antwort

Empfang vielleicht auf Sie bleibt openning Zustand, weil die connection.onopen Funktion nie aufgerufen wird. Die console.log('Connected!') wird nicht aufgerufen.

Könnte mich jemand wissen lassen, was hier falsch läuft?

Server

import java.io.IOException; 
import java.net.ServerSocket; 

public class Server { 

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

     try (ServerSocket serverSocket = new ServerSocket(4444)) { 
      GameProtocol gp = new GameProtocol(); 

      ServerThread player= new ServerThread(serverSocket.accept(), gp); 
      player.start(); 

     } catch (IOException e) { 
      System.out.println("Could not listen on port: 4444"); 
      System.exit(-1); 
     } 

    } 

} 

Serverthread

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

public class ServerThread extends Thread{ 

    private Socket socket = null; 
    private GameProtocol gp; 

    public ServerThread(Socket socket, GameProtocol gp) { 
     super("ServerThread"); 
     this.socket = socket; 
     this.gp = gp; 
    } 

    public void run() { 

     try (
       PrintWriter out = new PrintWriter(socket.getOutputStream(), true); 
       BufferedReader in = new BufferedReader(
         new InputStreamReader(
           socket.getInputStream())); 
       ) { 
      String inputLine, outputLine; 

      while ((inputLine = in.readLine()) != null) { 
       outputLine = gp.processInput(inputLine); 
       System.out.println(outputLine); 
      } 
      socket.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

GameProtocol

public class GameProtocol { 

    public String processInput(String theInput) { 

     String theOutput = null; 

     theOutput = theInput; 

     return theOutput; 
    } 
} 

Kunde

var connection = new WebSocket('ws://127.0.0.1:4444'); 

    connection.onopen = function() { 
    console.log('Connected!'); 
    connection.send('Ping'); // Send the message 'Ping' to the server 
    }; 

    // Log errors 
    connection.onerror = function (error) { 
    console.log('WebSocket Error ' + error); 
    }; 

    // Log messages from the server 
    connection.onmessage = function (e) { 
    console.log('Server: ' + e.data); 
    }; 

Answer 1

mit zu starten, sowohl Ihr Code sieht die Java und JavaScript identisch. Beide funktionieren für das, was sie entworfen haben, aber die Fakten sind, dass Sie versuchen, einen WebSocket-Client mit einem Socket-Server zu verbinden.

Wie ich weiß, sind sie zwei verschiedene Dinge in Bezug auf diese answer.

Aus meiner Erfahrung habe ich es nie auf Ihre Weise versucht. Das heißt, wenn ich eine Netzwerkanwendung habe, die Socket als reines Client/Server-Socket verwendet, und wenn es sich um eine Webanwendung handelte, würde ich WebSocket auch auf beiden Seiten verwenden.

So weit so gut :)

Um Ihren Tag mit weniger Schmerzen zu machen, da dies answer sagt, würde ich Ihnen vorschlagen, alle verfügbaren WebSocket auf Server-Seite zu verwenden und Ihr Problem gelöst ist.

Ich verwende in der Regel WebSocket for Java und hier ist eine Beispielimplementierung, die ich mit Ihrem Client-Code getestet habe und es funktioniert, sowohl auf Client-und Server-Seite.

import org.java_websocket.WebSocket; 
import org.java_websocket.handshake.ClientHandshake; 
import org.java_websocket.server.WebSocketServer; 

import java.net.InetSocketAddress; 
import java.util.HashSet; 
import java.util.Set; 

public class WebsocketServer extends WebSocketServer { 

    private static int TCP_PORT = 4444; 

    private Set<WebSocket> conns; 

    public WebsocketServer() { 
     super(new InetSocketAddress(TCP_PORT)); 
     conns = new HashSet<>(); 
    } 

    @Override 
    public void onOpen(WebSocket conn, ClientHandshake handshake) { 
     conns.add(conn); 
     System.out.println("New connection from " + conn.getRemoteSocketAddress().getAddress().getHostAddress()); 
    } 

    @Override 
    public void onClose(WebSocket conn, int code, String reason, boolean remote) { 
     conns.remove(conn); 
     System.out.println("Closed connection to " + conn.getRemoteSocketAddress().getAddress().getHostAddress()); 
    } 

    @Override 
    public void onMessage(WebSocket conn, String message) { 
     System.out.println("Message from client: " + message); 
     for (WebSocket sock : conns) { 
      sock.send(message); 
     } 
    } 

    @Override 
    public void onError(WebSocket conn, Exception ex) { 
     //ex.printStackTrace(); 
     if (conn != null) { 
      conns.remove(conn); 
      // do some thing if required 
     } 
     System.out.println("ERROR from " + conn.getRemoteSocketAddress().getAddress().getHostAddress()); 
    } 

} 

Auf dem Haupt-Methode nur:

new WebsocketServer().start(); 

Unter Umständen müssen Sie Ihren Code zu manipulieren, um sie mit dieser Implementierung passen, aber das sollte Teil der Arbeit sein.Hier

ist der Testausgang mit 2 Tests:

New connection from 127.0.0.1 
Message from client: Ping 
Closed connection to 127.0.0.1 
New connection from 127.0.0.1 
Message from client: Ping 

---

hier ist WebSocket Maven-Konfiguration, da sonst die JAR-Datei herunterladen/s manuell und importieren Sie es in Ihrem IDE/Entwicklungsumgebung:

<!-- https://mvnrepository.com/artifact/org.java-websocket/Java-WebSocket --> 
<dependency> 
    <groupId>org.java-websocket</groupId> 
    <artifactId>Java-WebSocket</artifactId> 
    <version>1.3.0</version> 
</dependency> 

WebSocket weitere Informationen: http://java-websocket.org