serwer Java JavaScript WebSockets klienta

Question

Próbuję zrobić połączenie między serwerem w Javie i klienta JavaScript ale dostaję ten błąd po stronie klienta:

związku websocket do „WS://127.0.0.1:4444/”failed: Connection zamknięte przed otrzymaniem odpowiedzi handshake

To może pozostaje na openning stan, ponieważ funkcja connection.onopen nigdy nie jest wywoływana. console.log('Connected!') nie jest wywoływany.

Czy ktoś może dać mi znać, co się tutaj dzieje?

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; 
    } 
} 

Client

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

Na początek, zarówno kod wygląda identycznie Java i JavaScript jeden. Oba działają zgodnie z tym, do czego są projektowane, ale faktem jest, że próbujesz połączyć klienta WebSocket z serwerem gniazd.

Jak wiem, są dwie różne rzeczy dotyczące tego answer.

Z mojego doświadczenia nigdy nie próbowałem go na swój sposób. To powiedziawszy, jeśli mam aplikację sieciową, która używa gniazda, niż byłoby to czyste gniazdo klient/serwer, a jeśli byłaby to aplikacja internetowa, to użyłbym WebSocket po obu stronach.

tej pory tak dobrze :)

aby dzień z mniejszym bólem, jak to answer mówi, chciałbym zaproponować Ci użyć wszelkich dostępnych websocket po stronie serwera i problem został rozwiązany.

Używam zazwyczaj WebSocket for Java i tutaj jest przykładowa implementacja, którą przetestowałem z Twoim kodem klienta i działa zarówno po stronie klienta, jak i serwera.

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()); 
    } 

} 

na głównej metodzie tylko:

new WebsocketServer().start(); 

może musisz manipulować swój kod, aby dopasować go z tej implementacji, ale które powinny być częścią tej pracy.

Oto wynik testu z 2 badań:

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 

---

tutaj jest konfiguracja Maven websocket, inaczej pobrać plik JAR/s ręcznie i importować go w swoim IDE/środowisko programistyczne:

<!-- 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 więcej info: http://java-websocket.org