Java Can'；t通过对象输出流将对象从一个http处理程序发送到另一个http处理程序

因此，在我的应用程序中，我将请求从http服务器处理程序发送到另一台服务器。问题是第二台服务器卡在读取对象上。我自己也在想办法，但我看不出问题所在。所有流都已关闭，可能对客户端的响应位于错误的位置？我不知道为什么

这是我的客户：

public class ClientSimulator {

    private Random random;
    private static int clientCounter = 1;

    public static void main(String[] args) throws Exception {
        new ClientSimulator();
        new ClientSimulator();
        new ClientSimulator();
    }

    private ClientSimulator() {

        this.random = new Random();
        RuntimeMXBean rmb = ManagementFactory.getRuntimeMXBean();
        long arrivalTime = rmb.getUptime();

        System.out.println("thread no. " + clientCounter++ + " arrival time: " + arrivalTime);
        try {
            String myurl= "http://localhost:8080/sender";
            String serverResponse = createClient(myurl);
            System.out.println(serverResponse);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private String createClient(String myurl) throws Exception {
        URL url;
        BufferedReader reader = null;
        StringBuilder stringBuilder;

        try {
            //Standard HTTP connection
            url = new URL(schedulerUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoInput(true);
            connection.setDoOutput(true);

            int[] arr = {
                    random.nextInt(10-1)+1,
                    random.nextInt(10-1)+1,
                    random.nextInt(10-1)+1,
                    random.nextInt(10-1)+1,
                    random.nextInt(10-1)+1,
            };
            Task t = new Task(arr);

            ObjectOutputStream oos = new ObjectOutputStream(connection.getOutputStream());
            oos.writeObject(t);
            oos.close();

            // read the output from the server
            reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            stringBuilder = new StringBuilder();
            //print the response
            String line = reader.readLine();
            stringBuilder.append(line);

            return stringBuilder.toString();
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }
    }

    private boolean getRandBool(){
        return this.random.nextBoolean();
    }
}

这是我将请求从主服务器发送到另一台服务器的方式：

@Override
    public void handle(HttpExchange httpExchange) throws IOException {

        String template = "\nClient no. %s connected!";

        //Getting task
        Task t;
        ObjectInputStream ois = new ObjectInputStream(httpExchange.getRequestBody());
        try {
            System.out.print("Recieved object:");
            t = (Task) ois.readObject();
            t.setDeadline(deadline);
            t.setHard(isHard);
            System.out.print(" not sorted array: ");
            int[] arr = (int[]) t.getData();
            for (int anArr : arr) {
                System.out.print(anArr + " ");
            }
            ois.close();

           String response = "response for client no. " + clientCounter;
           httpExchange.sendResponseHeaders(200, response.length());
           OutputStream os = httpExchange.getResponseBody();
           os.write(response.getBytes());
           os.close();
           clientCounter++;

            HttpURLConnection test = (HttpURLConnection) new URL(fogServ1URL).openConnection();
            test.setDoOutput(true);
            System.out.println("test__1");
            ObjectOutputStream stream = new ObjectOutputStream(test.getOutputStream());
            stream.flush();
            System.out.println("test__2");
            stream.writeObject(t);
            System.out.println("test__3");
            stream.close();
            System.out.println("test__4");
            test.getResponseCode();
            System.out.println("test__5"); //this doesn't print
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

这是来自第二台服务器的处理程序：

class RootHandler implements HttpHandler{
private static int clientCounter = 1;

@Override
public void handle(HttpExchange exchange) throws IOException {



    System.out.println("\nRoot handler; \n\tclient no. " + clientCounter++);

    Task t;
    ObjectInputStream ois = new ObjectInputStream(exchange.getRequestBody());
    try {
        System.out.println("Recieved object:"); //only this is on the console
        t = (Task) ois.readObject();
        ois.close();
        System.out.println("Array not sorted:");
        int[] arr = (int[]) t.getData();
        for (int anArr : arr) {
            System.out.print(anArr + " ");
        }
        TaskSolver.solve(t);
        System.out.println("\nArray sorted!");
        for (int anArr : (int[])t.getData()) {
            System.out.print(anArr + " ");
        }
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

    String response = "Server up!";
    exchange.sendResponseHeaders(200, response.getBytes().length);
    OutputStream os = exchange.getResponseBody();
    os.write(response.getBytes());
    os.close();
}
}

我没有得到它，因为我以相同的方式将

任务

从客户机发送到主服务器，并且它可以正常工作。我只是无法读取下一个服务器中的输出。我做错了什么

---

顺便说一句。如果有人好奇我为什么要将同一个对象发送到另一个服务器：我计划创建更多服务器，主服务器将根据类型/包含头向它们发送请求。

在第二个服务器中，当读取对象时，发生了一些IOException，因为RootHandler类的handle方法中的IOException被传递给调用方法，而不是处理它。所以像

内部服务器错误
响应状态这样的错误被发送到客户端（第一个服务器）

由于在第二个服务器中存在异常，因此
test.getResponseCode（）
会抛出IOException，因为它没有在第一个服务器
handle
方法中处理

System.out.println（“测试5”）

不调用

若您想知道发生了什么，请在服务器和打印堆栈跟踪的句柄方法中捕获IOException。
在您的第一台服务器中尝试以下顺序-

通过读取
InputStream
连接第二台服务器
通过在第二台服务器的
OutputStream
上写入来发送对象
从第二台服务器获取响应
通过在第一台服务器的
OutputStream
上写入来向客户端发送响应
当前行为背后的原因与关闭
交易所有关。按照-

当请求InputStream和响应OutputStream都关闭时，交换终止

目前，在第一个服务器代码中，您正在
OutputStream
上写入响应，然后将其关闭。之后，第一台服务器开始与第二台服务器通信

当第一台服务器向第二台服务器发送请求并等待响应时，底层的
HttpExchange
关闭，从而释放连接和相关线程。到目前为止，第二台服务器还没有读取请求

在这种情况下，第二台服务器中必须出现一些
IOException
，以指示错误，否则第二台服务器将一直等待读取
InputStream
，并最终获得超时

关闭
Exchange
并释放相关线程不是关闭
OutputStream
后的立即步骤，但它可以随时终止，并且后续代码行不保证执行。在您的情况下，连接在等待第二台服务器的响应时终止，但也可以在此之前终止。
您发布的代码没有问题。我已经根据你问题中的代码创建了一个MCVE，它可以正常工作。我不会保证它不受比赛条件的影响，而且很健壮，但它不会遇到你描述的问题。您可以查看它。此外，还有解决此问题的第三方库（，）和用于构建HTTP API的更好的库（，），并且当存在如此易于使用的JSON/XML库（，）时，使用ObjectOutputStream/ObjectInputStream是非常脆弱的。如果这主要是为了学习，那就去做吧。@Pace在你的MCVE中，你还可以提到
任务
classIf
handle（）
方法在
输出流
之前初始化
输入流
，无限块是可能的，查看此答案：任何不是
ClassNotFoundException
子类的异常都将被服务器吞并。尝试将
RootHandler
的
catch
块中的异常类从
ClassNotFoundException
更改为
Throwable
或至少
IOException
。