Javascript Websocket onmessage未启动-基于java的服务器

我的项目基本上是让websocket实时使用基于java的服务器。我可能从网络论坛上获取的代码部分。基于java的服务器工作到一定程度，因为我可以使用（非web）应用程序客户端对其进行测试，但目标是使其能够与基于web的客户端通信

问题在于onmessage事件侦听器。在我的努力中，服务器可以成功地向web客户端发送消息，web客户端可以读取消息，但它只能一次性工作。客户端中的onmessage事件一次不能从服务器接收多条消息。服务器必须重新启动，浏览器必须重新启动，这不是我想要的。最终，我希望web客户端能够在与服务器进行java通信时进行实时更新—类似于聊天程序

我正在寻找方法来确保事件侦听器得到维护，但不确定如何做到这一点。此外，我不确定webclient是否需要在线程上，但也不确定如何做到这一点

请访问我的github档案：

--------------------------Java服务器-----------------------------

    /*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package imageserver;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.io.ByteArrayOutputStream;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Base64;
import javax.xml.bind.DatatypeConverter;;





/**
 *
 * @author Russell Brown
 */
public class ImageServer {


    public static ServerSocket server;
    public static Socket clientSocket;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here


        try
        {


                server = new ServerSocket(6666); 
                System.out.println("server created");
                clientSocket = server.accept(); 
                System.out.println("client accepted");

                InputStream inputStream = clientSocket.getInputStream();
                OutputStream outputStream = clientSocket.getOutputStream();
                doHandShakeToInitializeWebSocketConnection(inputStream, outputStream);

                int counter = 0;

                while (true)
                {

                    String string = "hello" + counter;

                    outputStream.write(encode(string));

                    counter++;

                    Thread.sleep(10);

                }





        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }

    }



    public static byte[] encode(String mess) throws IOException{
        byte[] rawData = mess.getBytes();

        int frameCount  = 0;
        byte[] frame = new byte[10];

        frame[0] = (byte) 129;

        if(rawData.length <= 125){
            frame[1] = (byte) rawData.length;
            frameCount = 2;
        }else if(rawData.length >= 126 && rawData.length <= 65535){
            frame[1] = (byte) 126;
            int len = rawData.length;
            frame[2] = (byte)((len >> 8 ) & (byte)255);
            frame[3] = (byte)(len & (byte)255); 
            frameCount = 4;
        }else{
            frame[1] = (byte) 127;
            int len = rawData.length;
            frame[2] = (byte)((len >> 56 ) & (byte)255);
            frame[3] = (byte)((len >> 48 ) & (byte)255);
            frame[4] = (byte)((len >> 40 ) & (byte)255);
            frame[5] = (byte)((len >> 32 ) & (byte)255);
            frame[6] = (byte)((len >> 24 ) & (byte)255);
            frame[7] = (byte)((len >> 16 ) & (byte)255);
            frame[8] = (byte)((len >> 8 ) & (byte)255);
            frame[9] = (byte)(len & (byte)255);
            frameCount = 10;
        }

        int bLength = frameCount + rawData.length;

        byte[] reply = new byte[bLength];

        int bLim = 0;
        for(int i=0; i<frameCount;i++){
            reply[bLim] = frame[i];
            bLim++;
        }
        for(int i=0; i<rawData.length;i++){
            reply[bLim] = rawData[i];
            bLim++;
        }

        return reply;
    }


    private static void doHandShakeToInitializeWebSocketConnection(InputStream inputStream, OutputStream outputStream) throws UnsupportedEncodingException {
        String data = new Scanner(inputStream,"UTF-8").useDelimiter("\\r\\n\\r\\n").next();

        Matcher get = Pattern.compile("^GET").matcher(data);

        if (get.find()) {
            Matcher match = Pattern.compile("Sec-WebSocket-Key: (.*)").matcher(data);
            match.find();                 

            byte[] response = null;
            try {
                response = ("HTTP/1.1 101 Switching Protocols\r\n"
                        + "Connection: Upgrade\r\n"
                        + "Upgrade: websocket\r\n"
                        + "Sec-WebSocket-Accept: "
                        + DatatypeConverter.printBase64Binary(
                                MessageDigest
                                .getInstance("SHA-1")
                                .digest((match.group(1) + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
                                        .getBytes("UTF-8")))
                        + "\r\n\r\n")
                        .getBytes("UTF-8");
            } catch (NoSuchAlgorithmException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            try {
                outputStream.write(response, 0, response.length);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } else {

        }
    }


    private static void printInputStream(InputStream inputStream) throws IOException {
        int len = 0;            
        byte[] b = new byte[1024];
        //rawIn is a Socket.getInputStream();
        while(true){
            len = inputStream.read(b);
            if(len!=-1){

                byte rLength = 0;
                int rMaskIndex = 2;
                int rDataStart = 0;
                //b[0] is always text in my case so no need to check;
                byte data = b[1];
                byte op = (byte) 127;
                rLength = (byte) (data & op);

                if(rLength==(byte)126) rMaskIndex=4;
                if(rLength==(byte)127) rMaskIndex=10;

                byte[] masks = new byte[4];

                int j=0;
                int i=0;
                for(i=rMaskIndex;i<(rMaskIndex+4);i++){
                    masks[j] = b[i];
                    j++;
                }

                rDataStart = rMaskIndex + 4;

                int messLen = len - rDataStart;

                byte[] message = new byte[messLen];

                for(i=rDataStart, j=0; i<len; i++, j++){
                    message[j] = (byte) (b[i] ^ masks[j % 4]);
                }

                System.out.println(new String(message)); 

                b = new byte[1024];

            }
        }
    }



}

<!DOCTYPE html>

<html>

<head>

<meta charset="UTF-8">

<title>WebSocket Client</title>

 <script type="text/javascript">

      var wsocket;      

      function connect() {         

          wsocket = new WebSocket("ws://localhost:6666");          
          wsocket.onopen = onopen;
          wsocket.onmessage = onmessage;
          wsocket.onclose = onclose; 


      }

      function onopen() {
        document.writeln("opened");
      }

      function onmessage(event) { 

         document.writeln(event.data);



      }

      function onclose(e) {
            document.writeln("closed");
      }

      window.addEventListener("load", connect, false);




  </script>




</head>

<body>




</body>

</html>

/*
*要更改此许可证标题，请在“项目属性”中选择“许可证标题”。
*要更改此模板文件，请选择工具|模板
*然后在编辑器中打开模板。
*/
包映像服务器；
导入java.awt.Color；
导入java.awt.Graphics2D；
导入java.awt.Rectangle；
导入java.io.ByteArrayOutputStream；
导入java.awt.image.buffereImage；
导入javax.imageio.imageio；
导入java.io.File；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.OutputStream；
导入java.io.UnsupportedEncodingException；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.security.MessageDigest；
导入java.security.NoSuchAlgorithmException；
导入java.util.ArrayList；
导入java.util.Scanner；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
导入java.util.Base64；
导入javax.xml.bind.DatatypeConverter；；
/**
*
*@作者拉塞尔·布朗
*/
公共类ImageServer{
公共静态服务器套接字服务器；
公共静态套接字clientSocket；
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
//此处的TODO代码应用程序逻辑
尝试
{
服务器=新服务器套接字（6666）；
System.out.println（“创建的服务器”）；
clientSocket=server.accept（）；
System.out.println（“客户接受”）；
InputStream InputStream=clientSocket.getInputStream（）；
OutputStream OutputStream=clientSocket.getOutputStream（）；
doHandShakeToInitializeWebSocketConnection（inputStream、outputStream）；
int计数器=0；
while（true）
{
String=“hello”+计数器；
write（编码（字符串））；
计数器++；
睡眠（10）；
}
}
捕获（例外情况除外）
{
例如printStackTrace（）；
}
}
公共静态字节[]编码（字符串混乱）引发IOException{
byte[]rawData=mess.getBytes（）；
int frameCount=0；
字节[]帧=新字节[10]；
帧[0]=（字节）129；
如果（rawData.length=126&&rawData.length>8）&（字节）255）；
帧[3]=（字节）（len和（字节）255）；
帧数=4；
}否则{
帧[1]=（字节）127；
int len=rawData.length；
帧[2]=（字节）（（len>>56）和（字节）255）；
帧[3]=（字节）（（len>>48）和（字节）255）；
帧[4]=（字节）（（len>>40）和（字节）255）；
帧[5]=（字节）（（len>>32）和（字节）255）；
帧[6]=（字节）（（len>>24）和（字节）255）；
帧[7]=（字节）（（len>>16）和（字节）255）；
帧[8]=（字节）（（len>>8）和（字节）255）；
帧[9]=（字节）（len和（字节）255）；
帧数=10；
}
int bLength=frameCount+rawData.length；
字节[]回复=新字节[bLength]；
int-bLim=0；
for（int i=0；i解决方案：发现浏览器有可以调试的开发工具。问题完全是IE问题。已删除document.writeln并向div元素添加响应，如下所示：

  function onmessage(event) { 

  console.log(event.data);

  var div = document.getElementsByName("mydiv")[0];

  div.innerHTML += event.data;

    // document.writeln(event.data);


  }

感谢您的支持。
我还有一个关于websocket的问题-在web客户端上，当websocket接收到消息时，它会自动关闭吗？如果是，那么我应该重新创建它吗？这有限制吗？在chrome中似乎确实有效，但在IE或Firefox中则不起作用。