ObjectOutputStream未更新

Question

我正在服务器上，其中serverclass为每个连接的客户端创建一个新线程，并且当客户端连接时，ObjectOutputStream将不会刷新连接的多个客户端。 它停留在最后连接的客户端OutputObjectStream上

这是服务器初始化函数

    private void init(Server s)
    {
    ServerSocket server = null;
    Socket c = null;
    ServerThread tmp = null;
    try
    {
        this.db = new Database();
        server = new ServerSocket(6789);
        System.out.println("Listening on 6789");
        while(true)
        {
            c = server.accept();
            tmp = new ServerThread(c, s);
            clients.add(tmp);
            new Thread(tmp).start();
        }
    }catch(IOException | SQLException e)
    {
        e.printStackTrace();
        System.exit(1);
    }   

这是ServerThread构造函数和运行函数：

    package server;

import java.io.EOFException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;

import scripts.Response;

import com.sun.rowset.CachedRowSetImpl;

public class ServerThread implements Runnable
{
public static ObjectOutputStream output;
private static ObjectInputStream input;
private Socket client = null;
private Server server = null;
private Response line = null;
private String usr;

public ServerThread(Socket c, Server server) throws IOException
{
    this.client = c;
    this.server  = server;
    this.output = new ObjectOutputStream(client.getOutputStream());
    output.flush();
    output.reset();
    this.input  = new ObjectInputStream(client.getInputStream());
}

public void run()
{
    try
    {               
        System.out.println("Client connected");

        write(new Response("200","Time to login"));
        while((line = (Response)input.readObject()) != null)
        {
            read_code(line);
        }
    }catch(EOFException e){
        System.out.println("EOFException, probably end of stream");

    }catch(IOException e)
    {
        e.printStackTrace();
        Thread.currentThread().interrupt();
    }catch(ClassNotFoundException cnfe)
    {
        cnfe.printStackTrace();
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

public void alert_user(String q) throws IOException
{
    System.out.println("In thread "+q);
    write(new Response("404", "You are being alerted!"));
}

private void read_code(Response response) throws IOException, SQLException
{
    HashMap tmp_response = response.extract_map();
    switch ((String)tmp_response.get("code"))
    {
        case "420":
            usr_login(tmp_response);
            break;
        case "430":
            select_query((String)tmp_response.get("to_select"), (String)tmp_response.get("table"), (String)tmp_response.get("rest"));
            break;
        case "431":
            /**
             * server.alertUsers(ArrayList<String> usernames); if there is users that has to be alerted
             */
            insert_query((String)tmp_response.get("table"), (ArrayList<String>)tmp_response.get("columns"), (ArrayList<String>)tmp_response.get("values"));
            break;
        default:
            System.out.println("Unrecognized command");
    }
}

private void usr_login(HashMap tmp_response) throws IOException
{
    String usr = (String) tmp_response.get("username");
    String pass = (String) tmp_response.get("password");
    boolean login = server.query_login(usr, pass);
    System.out.println(login);
    if(login)
    {
        write(new Response("9001", "Login Successfull!"));
        this.usr = usr;
    }else
        write(new Response("8999", "Login Unsuccessfull!"));
}

private void insert_query(String table, ArrayList<String> columns, ArrayList<String> values) throws IOException, SQLException
{
    CachedRowSetImpl rows = server.insert_query(table, columns, values);
    write(new Response("3", rows));
}

private void select_query(String to_select, String table, String rest) throws SQLException, IOException
{
    CachedRowSetImpl rows = server.select_query(to_select, table, rest);
    write(new Response("2", rows));
}

private void write(Response resp) throws IOException
{
    System.out.println(output.toString());
    System.out.println(client.toString());
    output.reset();
    output.writeObject(resp);
    output.flush();
}

public String get_user()
{
    return usr;
}

}

因此，当我尝试打印出对象时，我得到了这个

    Client connected
    java.io.ObjectOutputStream@3933c336 (New client (1) connected)
    Client connected
    java.io.ObjectOutputStream@5adada9e (New client (2) connected)      
    java.io.ObjectOutputStream@5adada9e (Sending to first client)

编辑为什么ObjectOutputStream不会刷新，并使用从头开始分配给它的输出流，而不是最新的输出流？

编辑忘记添加写入功能，以及打印的位置

编辑添加了整个ServerThread类

Answer 1

这是一个静态混乱的例子。

Java中的关键字static表示完全独立于此类实例的组件（变量或方法）。 对于变量，这意味着对于要共享的所有实例，只有一个变量副本，而不是每个实例的单独副本（即非静态变量）。

由于实例共享静态变量，因此对于所有实例，其值始终相同。 如果更改一个实例中的值，它也将在所有其他实例中更改。

---

在您的情况下，您使用static ObjectInputStream和ObjectOutputStream以便它们不能更改：关键字final使变量不可更改。 请注意，这只会使分配成为不可能，而不是更改分配对象的内部值（例如，通过设置器）。 它只是阻止你创建一个新对象并将其放入最终变量中。