浏览器为什么不请求数据？java的ServerSocket和套接字

问题描述

最近，我想验证计算机网络问题。因此，我编写了一个程序，起初它起作用了。但有时，它会产生错误-内存不足错误。经过测试，我发现我的代码是错误的。我直接读取一个字节，然后将其转换为字符。我不知道为什么有时连接中没有数据。该程序只读取-1，然后将-1转换为字符，但是整个程序无法停止。所以，我想知道，此错误的原因是什么？我不知道是浏览器还是程序。希望您能帮助我解决这个问题。

这是我的代码：

def main():
    for file_json in os.listdir(path_to_json):
        if not file_json.endswith('.json'): continue
        print("""""######starting######""")
        print(file_json)
        try:
             with open("{}/{}".format(path_to_json,file_json),'r') as json_file:
                json_data = json.load(json_file)
                print("JSON File is Valid")
                flowVersions = json_data['flow']['flowVersions']
                get_status(flowVersions)
                source(flowVersions)
                operators(flowVersions)
                target(flowVersions)

        except Exception as e  :
            print (e)
            print("JSON File is Invalid")

def get_status(flowVersions):
    for flow in flowVersions:
        print("status is : ",flow["status"])

def source(flowVersions):
    for flow in flowVersions:
        for topic in flow['topics']:
            name = topic['name']
            print('sourceName is : ',name)
            sourceName_check = name.startswith('ES_')

            if sourceName_check:
                print("sourceName is vaild and starts with ES_:")
            else:
                print("sourceName is not starting with ES_:")

当我使用浏览器访问http：// localhost：8080时，如果您多次访问 或过一会儿，会出现错误。而且，这是错误信息：

package org.dragon;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class CheckServer {
    public static final String CRLF = "\r\n";
    public static final String BLANK = " ";
    
    
    public static void main(String[] args) {
        try (ServerSocket server = new ServerSocket(8080)) {
            while (true) {
                Socket client = server.accept();
                new Thread(()-> {
                    StringBuilder sb = new StringBuilder();
                    try {
                        InputStream in = new BufferedInputStream(client.getInputStream());
                        OutputStream out = new BufferedOutputStream(client.getOutputStream());
                        char ch;
                        while ((ch = (char) in.read()) != '\n') {
                            sb.append(ch);
                        }

                        System.out.println(sb); 
                        byte[] body = "I love you yesterday and today!".getBytes();
                    
                        // create response header
                        StringBuilder headerBuilder = new StringBuilder();
                        headerBuilder.append("HTTP/1.1 200 OK").append(CRLF)
                        .append("Host:").append(BLANK).append(client.getInetAddress().getHostName()).append(CRLF)
                        .append("Content-Type:").append(BLANK).append("application/json").append(CRLF)
                        .append("Access-Control-Allow-Origin:").append(BLANK).append("*").append(CRLF)
                        .append("Content-Length:").append(BLANK).append(body.length).append(CRLF)
                        .append(CRLF);
                        
                        System.out.println(headerBuilder);
                        // response header
                        byte[] header = headerBuilder.toString().getBytes(StandardCharsets.UTF_8);
                        // return response message
                        out.write(header);
                        out.write(body);
                        // flush the stream
                        out.flush();
                    
                    } catch (Throwable e) {
                        e.printStackTrace();
                        System.out.println("StringBuilder object's length: " + sb.length());
                        System.out.println("StringBuilder object's content: ");
                        System.out.println(sb);
                        System.out.println("========================");
                    } finally {
                        if (client != null) {
                            try {
                                client.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
}

当我尝试打印sb时，会发生异常，但是我认为这不是问题。 我真的想知道为什么代码不读取数据？

GET / HTTP/1.1

HTTP/1.1 200 OK 
Host: 0:0:0:0:0:0:0:1 
Content-Type: application/json 
Access-Control-Allow-Origin: * 
Content-Length: 31


java.lang.OutOfMemoryError: Java heap space
StringBuilder object's length: 1207959550
StringBuilder object's content: 
    at java.util.Arrays.copyOf(Arrays.java:3332)
    at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)
    at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:649)
    at java.lang.StringBuilder.append(StringBuilder.java:202)
    at org.dragon.CheckServer.lambda$0(CheckServer.java:28)
    at org.dragon.CheckServer$$Lambda$1/135721597.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-1" java.lang.OutOfMemoryError: Java heap space
    at java.util.Arrays.copyOfRange(Arrays.java:3664)
    at java.lang.String.<init>(String.java:207)
    at java.lang.StringBuilder.toString(StringBuilder.java:407)
    at java.lang.String.valueOf(String.java:2994)
    at java.io.PrintStream.println(PrintStream.java:821)
    at org.dragon.CheckServer.lambda$0(CheckServer.java:56)
    at org.dragon.CheckServer$$Lambda$1/135721597.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:748)

浏览器发送的请求是否为空？

注意：：我知道我无法直接将读取的字节转换为字符。我必须判断它是否为-1。如果为-1，则可以忽略它。但是我不明白为什么会有这样的要求？

解决方法

无限的stringbuilder

按照编写的方式，您的代码从线上读取数据并将其添加到stringbuilder中，这是内存中的东西。

您的代码将继续执行此操作，直到遇到字符\n。请注意，read()方法将返回-1，并且如果流已结束，它将永远永远这样做。这意味着您将永远向字符串生成器添加-1个字符的无穷序列。当然，“永远”并不是永远不变：一旦用尽内存来存储-1的无限序列，就会得到这个。

解决方案很简单：当.read（）调用返回-1或\ n时，停止循环。将结果保存在局部变量中，然后可以简单地进行检查。像这样：

while (true) {
    int ch = in.read(); // do NOT cast to char,you can't detect -1 that way
    if (ch == -1 || ch == '\n') break;
    sb.append((char) ch); // cast here.
}

不要忽略-1-在-1处结束循环。没有更多数据了。 曾经。如果您正在等待换行符，它将永远不会发生。

好的，为什么会这样？

嘿，这是网络。您没有任何保证。