java.net.SocketException：连接重置

我在我的本地机器上运行客户端 - 服务器java代码，并使用java套接字连接它们 .

我最初能够将客户端连接到服务器并发送一串数据 . 当服务器获取数据时，它最初也会返回一个字符串 .

在那次沟通之后，整个事情就崩溃了 . 双方都没有回应 .

我正在使用javafx GUI，从服务器返回的数据应该触发一些操作（将节点插入javafx阶段） . 我有一个可观察到的 . 但即使没有javafx的东西，客户端在从服务器获取数据（它实际收到）后仍会挂起 . 它与输入/输出流有关 .

显然很多人都有这个问题，但没有人发布解决方案 . 哦，我已经禁用了我的防火墙 .

什么是重置连接？它可能是javafx吗？我不是很擅长 . 另一件事，我正在使用一个单独的java类（除了javafx类）来连接 . javafx类创建一个处理连接的对象 . 所以我只是调用方法（例如，侦听套接字输入流的streamFromServer） . 只有当我调用此方法时，客户端才会崩溃，因此我知道它与输入/输出流有关 .

我能够解决问题，客户端执行被while循环暂停，如下所示：

try{
   String ins;
   while((ins = (String)in.readObject()) != null){
      //do something with the data read in.
      //'in' is an ObjectInputStream bound to a client socket
   }
} catch(Exception e){
   e.printStackTrace();
}

while循环绑定了客户端的执行，所以程序无法超越这一点，所以作为无知的用户，我认为程序崩溃了 .

我通过创建一个实现runnable并在其中创建一个线程的新类来处理这个问题，该类检查输入流而不是主客户端程序，如下所示：

try{
    in = new ObjectInputStream(clientSocket.getInputStream());
    listenerThread = new StreamListener(in);
} catch(Exception e){
    e.printStackTrace();        
}

和StreamListener类：

import java.io.ObjectInputStream;
import java.util.Observable;

public class StreamListener  extends Observable implements Runnable{
    private ObjectInputStream in = null;
    public String[] bubbles = null;
    private boolean connectionOpen = true;
    public StreamListener(ObjectInputStream in){
        this.in = in;
        Thread t = new Thread(this);
        t.start();
    }
    @Override
    public void run(){
        while(connectionOpen){
            try{
                String ins;
                while((ins = (String)in.readObject()) != null){
                    System.out.println("Received: " + ins);
                    if(ins.equals("noInitial")){
                        System.out.println("Reply of no initial from server, I must be the first to connect");
                    }
                    if(ins.contains("initial#")){
                        initiateBubbles(ins.substring(8));
                    }
                    if(ins.contains("new#")){
                        int index = bubbles.length;
                        String s = ins.substring(4);
                        bubbles[index] = s;
                    }
                    if(ins.contains("drag#")){
                        String s = ins.substring(5), owner = s.substring(0,s.indexOf("#")), x = "", y = "";
                        String coordinates = s.substring(s.indexOf("#") + 1);
                        for(int i = 0; i < coordinates.length(); i++){
                            if(coordinates.charAt(i) == '#'){
                                x = coordinates.substring(0, i);
                                y = coordinates.substring(i + 1, coordinates.length() - 1);
                            }
                        }
                        String[] str;
                        for(int i = 0; i < bubbles.length; i++){
                            str = bubbles[i].split("#");
                            if(str[0].equals(owner)){
                                str[2] = x;
                                str[3] = y;
                            }
                        }
                    }
                    continue;
                }
            } catch(Exception e){
                connectionOpen = false;
                System.err.println("Could not receive bubble data from server: " + e.toString());
            }
        }
    }
    public String[] getBubbles(){
        return bubbles;
    }
    public void initiateBubbles(String s){
        bubbles = s.split("@");
        System.out.println("Bubbles initialised");
        fireNotify();
    }
    public void moveBubble(String s){
        fireNotify(s);
    }
    public void fireNotify(){
        setChanged();
        notifyObservers();
        System.out.println("Observer notified");
    }
    public void fireNotify(String s){
        setChanged();
        notifyObservers(s);
        System.out.println("Observer notified");
    }
    public void close(){
        connectionOpen = false;
        try{
            in.close();
        } catch(Exception e) {
            System.err.println("Could not close listener thread: " + e.toString());
        }
    }
}

和Voila !!这让我想到了我的下一个问题，不知怎的，观察者没有得到通知 . 谁能告诉我为什么？这是JavaFX Observer类：

import java.util.Observable;
import java.util.Observer;
import java.lang.System;

public class BubbleAdapter extends Observer{
    public-read var bubbles : Bubble[];
    public-read var bubblesInitialised : Boolean = false;
    public-read var bubbleString : String[];
    public-init var connector : StreamListener
        on replace {connector.addObserver(this)};

    override function update(observable : Observable, arg : Object){
        FX.deferAction(
            function() : Void {
                System.out.println("Observer called");
                if(arg == null){
                    bubbleString = connector.getBubbles();
                    var str : String[];
                    for(i in [0..sizeof bubbleString]){
                        if(bubbleString[i].contains("#")){
                            str = bubbleString[i].split("#");
                            bubbles[i] = Bubble {
                                name : bind str[0]
                                time : bind str[1]
                                translateX : bind Float.parseFloat(str[2])
                                translateY : bind Float.parseFloat(str[3])
                            }
                            //insert bubble after Main.stage.scene.content[Main.currentIndex++];
                        }
                    }
                    bubblesInitialised = true;
                }
                else if(arg instanceof String){

                }

            }
        );
    }
}

没关系细节，这个观察者首先应该打印出“Observer called”，但这不会发生 . 再说一遍，请帮忙 .