javascript 与Java服务器和Javascript客户端建立WebSocket连接

Establishing WebSocket connection with Java server and Javascript client

提问by Yuri Heupa

I'm trying to implement WebSockets with a Javascript-based client and a Java-based server. I think I've done all the correct steps, but for an unknown reason, I can't establish the connection with both.

我正在尝试使用基于 Javascript 的客户端和基于 Java 的服务器来实现 WebSockets。我想我已经完成了所有正确的步骤，但是由于未知的原因，我无法与两者建立连接。

When the server socket receives a connection, it handles to form a websocket-accept response, and it sends back to the client, but the connection in the client socket instantly close, weird that there's no handshake problem.

当服务端socket接收到一个连接时，它处理形成一个websocket-accept响应，并发回客户端，但是客户端socket中的连接立即关闭，奇怪的是没有握手问题。

Does anyone have an idea what might be the problem?

有谁知道可能是什么问题？

Here's my server code implemented in java:

这是我用java实现的服务器代码：

package server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

import server.message.Message;
import server.message.SpeakMessage;


public class Server implements ConnectionListener {
    private static final int PORT = 1509;
    private MessageDispatcher dispatcher = new MessageDispatcher();
    private List<ConnectionManager> clients = new ArrayList<>();

    public void listen() {
        try (ServerSocket server = new ServerSocket(PORT)) {
            System.out.printf("Listening on port %d...%n", PORT);
            while (true) {
                System.out.println("Waiting for connection...");
                Socket client = server.accept();
                System.out.println("Incoming connection - Attempting to establish connection...");
                ConnectionManager manager = new ConnectionManager(client, dispatcher, this);
                manager.start();
            }
        } catch (IOException e) {
            System.out.println("Unable to start server");
            e.printStackTrace();
        }
        System.exit(0);
    }

    public void execute() {
        try {
            while (true) {
                if (dispatcher.isEmpty()) {
                    Thread.sleep(100);
                    continue;
                }
                Message msg = dispatcher.read();
                if (msg instanceof SpeakMessage)
                    broadcast(MessageEncoder.spoke(((SpeakMessage) msg).getText()));
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void main(String[] args) {
        final Server server = new Server();
        new Thread(new Runnable() {
            @Override
            public void run() {
                server.listen();
            }
        }).start();
        server.execute();
    }

    public synchronized void broadcast(byte[] message) {
        for (ConnectionManager client : clients) {
            client.send(message);
        }
    }

    @Override
    public synchronized void clientConnected(ConnectionManager who) {
        clients.add(who);
        System.out.println("Connected client " + clients.size());
    }

    @Override
    public synchronized void clientDisconnected(ConnectionManager who) {
        clients.remove(who);
    }
}

Heres subclass ConnectionManager of server:

这是服务器的子类 ConnectionManager：

package server;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.Socket;
import java.security.MessageDigest;
import java.util.Properties;

import server.message.HandshakeMessage;
import server.message.Message;


public class ConnectionManager {
    private static final int CLIENT_VERSION = 1;
    private Socket socket;
    private MessageDecoder decoder = new MessageDecoder();
    private MessageDispatcher dispatcher;
    private ConnectionListener listener;

    public ConnectionManager(Socket connection, MessageDispatcher dispatcher, ConnectionListener listener) {
        socket = connection;
        this.dispatcher = dispatcher;
        this.listener = listener;
    }

    public void start() {
        Thread t = new Thread(new ChannelReader());
        t.setName("Client thread");
        t.setDaemon(true);
        t.start();
    }

    public void send(byte[] data) {
        if (socket == null)
            return;

        try {
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            dos.write(data);
            dos.flush();
        } catch (IOException e) {
            disconnect("Client closed the connection");
        }
    }

    private class ChannelReader implements Runnable {
        private boolean accepted = false;
        private String ret = null;

        @Override
        public void run() {
            try {
                DataInputStream in = new DataInputStream(socket.getInputStream());
                while (socket != null && socket.isConnected()) {
                    int len = in.readShort();
                    if (len < 0) {
                        disconnect("Invalid message length.");
                    }

                    String s;
                    readLine(in);
                    Properties props = new Properties();
                    while((s=readLine(in)) != null && !s.equals("")) {
                        String[] q = s.split(": ");
                        props.put(q[0], q[1]);
                    }

                    if(props.get("Upgrade").equals("websocket") && props.get("Sec-WebSocket-Version").equals("13")) { // check if is websocket 8
                        String key = (String) props.get("Sec-WebSocket-Key");
                        String r = key + "" + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; // magic key
                        MessageDigest md = MessageDigest.getInstance("SHA-1");
                        md.reset();
                        md.update(r.getBytes());
                        byte[] sha1hash = md.digest();


                        String returnBase = base64(sha1hash);


                        ret = "HTTP/1.1 101 Switching Protocols\r\n";
                            ret+="Upgrade: websocket\r\n";
                            ret+="Connection: Upgrade\r\n";
                            ret+="Sec-WebSocket-Accept: "+returnBase;

                    } else {
                        disconnect("Client got wrong version of websocket");
                    }

                    Message msg = decoder.decode((String) props.get("Sec-WebSocket-Protocol"));

                    if (!accepted) {
                        doHandshake(msg);
                    } else if (dispatcher != null) {
                        dispatcher.dispatch(msg);
                    }
                }
            } catch (Exception e) {
                disconnect(e.getMessage());
                e.printStackTrace();
            }
        }

        private void doHandshake(Message msg) {
            if (!(msg instanceof HandshakeMessage)) {
                disconnect("Missing handshake message");
                return;
            }
            HandshakeMessage handshake = (HandshakeMessage) msg;
            if (handshake.getVersion() != CLIENT_VERSION) {
                disconnect("Client failed in handshake.");
                return;
            }
            send(ret.getBytes());
            accepted = true;
            listener.clientConnected(ConnectionManager.this);
        }   

        private String base64(byte[] input) throws ClassNotFoundException, 
        SecurityException, NoSuchMethodException, IllegalArgumentException, 
        IllegalAccessException, InvocationTargetException, InstantiationException {
            Class<?> c = Class.forName("sun.misc.BASE64Encoder");
            java.lang.reflect.Method m = c.getMethod("encode", new Class<?>[]{byte[].class});
            String s = (String) m.invoke(c.newInstance(), input);
            return s;
        }

        private String readLine(InputStream in) {
            try{
                String line = "";
                int pread;
                int read = 0;
                while(true) {
                    pread = read;
                    read = in.read();
                    if(read!=13&&read!=10)
                        line += (char) read;
                    if(pread==13&&read==10) break;
                }
                return line;
            }catch(IOException ex){

            }
            return null;
        }

    }

    public synchronized void disconnect(String message) {
        System.err.println(message);
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException e) {

            }
        }
        socket = null;
        listener.clientDisconnected(ConnectionManager.this);
    }
}

And the MessageDispatcher:

和 MessageDispatcher：

package server;

import java.util.Queue;
import java.util.concurrent.LinkedBlockingDeque;

import server.message.Message;


public class MessageDispatcher {
    Queue<Message> messageQueue = new LinkedBlockingDeque<>();

    public void dispatch(Message message) {
        messageQueue.offer(message);
    }

    public Message read() {
        return messageQueue.poll();
    }

    public boolean isEmpty() {
        return messageQueue.isEmpty();
    }
}

And heres my client code implemented in javascript:

这是我在 javascript 中实现的客户端代码：

var canvas, // Canvas DOM element
    ctx,    // Canvas rendering context
    socket; // Socket connection

function init() {
    // Initialise the canvas
    canvas = document.getElementById("gameCanvas");
    ctx = canvas.getContext("2d");
    // Maximise the canvas
    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;

    // Initialise socket connection
    if (window.WebSocket) { 
        socket = new WebSocket("ws://localhost:1509/", ["1", "YURI"]);
        socket.onopen = onSocketConnected();
        socket.onclose = onSocketDisconnect();
        socket.onmessage = onSocketMessage();
        socket.onerror = onSocketError();
    } else {
        alert("The browser does not support websocket.");
    }

};

// Socket message
function onSocketMessage(message) {
    console.log('Message: ' + message.data);
};

// Socket error
function onSocketError(error) {
    console.log('Error: ' + error.data);
};

// Socket connected
function onSocketConnected() {
    console.log("Connected to socket server");
};

// Socket disconnected
function onSocketDisconnect() {
    console.log("Disconnected from socket server");
};

回答by JustToHelp

I think, it is because you are using the Socket Package on the Java Server Side and the WebSocket API on the Client Side. Your idea is really good but the wrong technology. Keep the WebSocket on the Client Side (Javascript) becaue you don't have lots of other possibilities, but try JWebSocket on the Server side (Java). In Fact WebSocket is using TCP/IP but its own communication protocol over TCP/IP. The Java Socket Package is purely TCP/IP. Re-write your server with JWebSocket, all details about JWebSocket can be found at: http://jwebsocket.org/. I hope my answer will help you.

我认为，这是因为您在 Java 服务器端使用了 Socket Package，在客户端使用了 WebSocket API。你的想法很好，但技术错误。将 WebSocket 保留在客户端 (Javascript)，因为您没有很多其他可能性，但请尝试在服务器端 (Java) 上使用 JWebSocket。事实上，WebSocket 使用的是 TCP/IP 但它自己的基于 TCP/IP 的通信协议。Java Socket Package 是纯粹的 TCP/IP。用 JWebSocket 重写你的服务器，关于 JWebSocket 的所有细节都可以在：http://jwebsocket.org/ 找到 。希望我的回答能帮到你。

回答by ahmad pirzargar

you must specify end of return packet with "\r\n\r\n"

你必须用“\r\n\r\n”指定返回包的结束

  ret = "HTTP/1.1 101 Switching Protocols\r\n";
   ret+="Upgrade: websocket\r\n";
   ret+="Connection: Upgrade\r\n";
   ret+="Sec-WebSocket-Accept: "+returnBase + "\r\n\r\n";

and for create accept key i use

并为创建接受密钥我使用

public class WSKeyGenerator {
    private final static String MAGIC_KEY =
            "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
    public static String getKey(String strWebSocketKey) throws
            NoSuchAlgorithmException {
        strWebSocketKey += MAGIC_KEY;
        MessageDigest shaMD = MessageDigest.getInstance("SHA-1");
        shaMD.reset();
        shaMD.update(strWebSocketKey.getBytes());
        byte messageDigest[] = shaMD.digest();
        BASE64Encoder b64 = new BASE64Encoder();
        return b64.encode(messageDigest);
    }
}

I recommend that use the http://websocket.org/echo.htmlto check the server's websocket functionality

我建议使用http://websocket.org/echo.html检查服务器的 websocket 功能