Question

因此，在我的应用中，我将请求从http server handler发送到另一台服务器。事情是第二个服务器卡在阅读对象上。我试图弄清楚自己，但我看不出问题。所有流都关闭了，也许对客户的响应是在错误的地方？我不知道为什么会这样......

这是我的客户：

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

我不明白，因为我以相同的方式将Task从客户端发送到主服务器并且正常工作。我只是无法读取下一个服务器的输出。我究竟做错了什么？

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

Answer 1

在读取对象的第二台服务器中，发生了一些IOException，因为RootHandler类的handle方法中的IOException被传递给调用方法而不是处理它。因此，Internal Server Error响应状态等错误将发送到客户端（第一个服务器）。

由于第二个服务器中存在异常，test.getResponseCode()会抛出IOException，因为它未在第一个服务器handle方法中处理

System.out.println("test__5");

未被调用。

如果你想知道发生了什么，请在服务器和打印堆栈跟踪的handle方法中捕获IOException。

Answer 2

在第一台服务器 -

中尝试按照以下顺序进行操作

阅读InputStream
与第二台服务器连接。
通过写在第二台服务器的OutputStream上发送对象。
从第二台服务器获取响应
通过在第一台服务器的OutputStream上书写来向客户发送回复。

当前行为背后的原因与关闭Exchange有关。根据{{3}} -

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

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

当第一个服务器向第二个服务器发送请求并等待响应时，当时基础HttpExchange被关闭，因此连接和关联的线程被释放。到目前为止，第二台服务器还没有读取请求。

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

关闭Exchange并释放关联线程不是关闭OutputStream后的立即步骤，但它可以随时终止，并且不保证后续代码行的执行。在您的情况下，连接在等待来自第二台服务器的响应时终止，但它也可以在此之前终止。

无法通过Object Output Stream将对象从一个http处理程序发送到另一个http处理程序

2 个答案: