Java 项目赢得'；初始化输入/输出流后是否继续？

在人们怀疑我根本不知道自己在做什么（最终无缘无故地否决这一点）之前，请阅读以下内容：

它连接到我的服务器很好！我没有收到任何错误（来自客户端或服务器），我的服务器正在识别连接。它与我朋友的客户，他做了，但我想做我自己的客户，显然我做错了什么。请继续话题！谢谢：）

---

标题基本上说明了一切。我在Client.java

run（）

中测试了

println

消息在

setupStream（）的上方和下方，但只有
setupStream（）上方的消息才会打印。我不确定如何在不使程序停止的情况下初始化流

Client.java

import java.io.IOException;


public class Client extends Stream implements Runnable {
    public boolean running = false;
    private Thread clientThread;

    Frame frame;
    public Client() {
        super("localhost", 43594);

        frame = new ClientFrame(500, 500);
        start();
    }

    public synchronized void start() {
        if(running) return;
        running = true;

        clientThread = new Thread(this);
        clientThread.start();
    }
    public synchronized void stop() {
        if(!running) return;
        running = false;

        clientThread.interrupt();
        try {
            clientThread.join();
        } catch (InterruptedException e) {e.printStackTrace();}
    }

    public void run() {
        try{
        setupStream();

        while(running) {
            System.out.println("running");
        }
        }catch(IOException e) {
            e.printStackTrace();
        }finally {
            try{
            out.close();
            in.close();
            socket.close();
            clientThread.join();
            }catch(IOException | InterruptedException e) { e.printStackTrace(); }
        }
    }
    public static void main(String[] args) {
        new Client();
    }
}

Stream.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;


public class Stream {

    Socket socket;
    ObjectOutputStream out;
    ObjectInputStream in;
    String data;

    public Stream(String host, int port) {
        try {
            socket = new Socket(host, port);
        } catch (IOException e) { 
            e.printStackTrace();
        }
    }

    protected void setupStream() throws IOException {
        out = new ObjectOutputStream(socket.getOutputStream());
        out.flush();
        in = new ObjectInputStream(socket.getInputStream());
    }

}

我的服务器线程：

package Server;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;

public class User extends Thread {
    public static int users = 0;
    public int ID;
    public String username;
    boolean online = false;

    public static ArrayList<String> usernames = new ArrayList<String>();

    Socket socket;

    DataOutputStream out;
    DataInputStream in;
    String input;

    public User(Socket socket) {
        this.socket = socket;

    }

    public String decode(String input) {
        String[] split = input.split(" ");

        if(input.startsWith("::")) {
            try {
                switch(split[0].substring(2, split[0].length()).toLowerCase()) {
                case "setname": 
                case "changename":
                case "newname":
                    if(usernames.contains(split[1].toLowerCase())) {
                        out.writeUTF("This name is already taken! Please choose a different one.");
                        out.flush();
                        return null;
                    }
                    if(username == null) {
                        username = split[1].substring(0, 1).toUpperCase() + split[1].substring(1, split[1].length());
                        Server.users.put(split[1].toLowerCase(), Server.user[ID]);
                        usernames.add(split[1].toLowerCase());
                    } else {
                        usernames.remove(username.toLowerCase());
                        username = split[1].substring(0, 1).toUpperCase() + split[1].substring(1, split[1].length());
                        usernames.add(split[1].toLowerCase());
                    }
                        return null;
                case "rank+":
                    return null;
                case "[sm]=":
                    return null;
                }
            }catch(IOException e) { }
        }
        return input;
    }

    String timeStamp;
    public void run() {
        try {

            out = new DataOutputStream(socket.getOutputStream());
            out.flush();
            in = new DataInputStream(socket.getInputStream());

            while((input = in.readUTF()) != null) {
                input = decode(input);

                if(input != null) {
                    if(username != null) {
                        timeStamp = new SimpleDateFormat("[h:mm:ss] ").format(Calendar.getInstance().getTime());
                        Server.sendGlobalMessage(timeStamp + username +": "+input);
                    } else {
                        timeStamp = new SimpleDateFormat("[h:mm:ss] ").format(Calendar.getInstance().getTime());
                        Server.sendGlobalMessage(timeStamp + "Guest "+ID+": "+input);
                    }
                }
            }

        }catch(IOException e) { e.printStackTrace(); } finally { 
            try{
                out.close();
                in.close();
                socket.close();
            } catch(IOException e) { e.printStackTrace(); }
        }

    }

}

包服务器；
导入java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.net.Socket；
导入java.text.simpleDataFormat；
导入java.util.ArrayList；
导入java.util.Calendar；
公共类用户扩展线程{
公共静态int用户=0；
公共int ID；
公共字符串用户名；
布尔在线=假；
public static ArrayList usernames=new ArrayList（）；
插座；
数据输出流输出；
数据输入流输入；
字符串输入；
公共用户（套接字）{
this.socket=socket；
}
公共字符串解码（字符串输入）{
String[]split=input.split（“”）；
if（input.startsWith（“：”）{
试一试{
开关（拆分[0]。子字符串（2，拆分[0]。长度（））.toLowerCase（）{
案例“setname”：
案例“changename”：
案例“newname”：
if（usernames.contains（拆分[1].toLowerCase（））{
out.writeUTF（“此名称已被使用！请选择其他名称”）；
out.flush（）；
返回null；
}
如果（用户名==null）{
username=split[1]。子字符串（0,1）.toUpperCase（）+split[1]。子字符串（1,split[1].length（））；
Server.users.put（拆分[1].toLowerCase（），Server.user[ID]）；
usernames.add（拆分[1].toLowerCase（））；
}否则{
usernames.remove（username.toLowerCase（））；
username=split[1]。子字符串（0,1）.toUpperCase（）+split[1]。子字符串（1,split[1].length（））；
usernames.add（拆分[1].toLowerCase（））；
}
返回null；
案例“等级+”：
返回null；
案例“[sm]=”：
返回null；
}
}捕获（IOE）{}
}
返回输入；
}
字符串时间戳；
公开募捐{
试一试{
out=新的DataOutputStream（socket.getOutputStream（））；
out.flush（）；
in=新的DataInputStream（socket.getInputStream（））；
而（（input=in.readUTF（））！=null）{
输入=解码（输入）；
如果（输入！=null）{
如果（用户名！=null）{
时间戳=新的SimpleDataFormat（“[h:mm:ss]”）。格式（Calendar.getInstance（）.getTime（））；
sendGlobalMessage（时间戳+用户名+：“+输入）；
}否则{
时间戳=新的SimpleDataFormat（“[h:mm:ss]”）。格式（Calendar.getInstance（）.getTime（））；
sendGlobalMessage（时间戳+“来宾”+ID+：“+input）；
}
}
}
}catch（IOException e）{e.printStackTrace（）；}最后{
试一试{
out.close（）；
in.close（）；
socket.close（）；
}catch（IOE异常）{e.printStackTrace（）；}
}
}
}

我已经有一段时间没有接触服务器线程的代码了，因为在我创建新客户端之前，它一直在运行。
我怀疑您的服务器没有创建ObjectOutputStream，因此当客户端构建ObjectInputStream时，它会阻止等待object stream头，它永远不会到达。
您正在默默地忽略
setupStream（）
中的异常。至少在catch块中添加
e.printStackTrace（）
。@VinceEmigh您应该担心错误处理，
Stream
构造函数总是失败，但由于异常被抑制，所以没有注意到任何异常。此外，
setupStream
由于
null
Socket
而抛出NPE，因为没有任何内容在侦听它！没有那么多方法无法到达
setupStreams（）
（锁定或引发异常）下面的行。如果从不检查异常，您如何知道不会抛出异常？你说你没有收到任何错误，但是你粘贴的代码无法检测到。如果你忽略了那些堆栈跟踪，人们怎么可能知道你已经知道没有错误了？你一开始并没有提到服务器，所以你很可能忘记了它，因为缺少stacktraces而没有意识到它……这正是我所说的。ObjectInputStream在另一端需要ObjectOutputStream，反之亦然。然而，关于异常处理的评论是不容忽视的。它不是在程序运行后添加到程序中的东西。首先，这是让它工作的一个重要部分。