Java 未在线程中创建Xstream

我正在调试无法通过套接字发送XStream对象序列化的消息，该对象是由手动在专用线程中创建的。我还添加了从客户端发送到服务器的调试消息

客户端

public class SocketClient implements Runnable {

static Socket client;
static Thread t;
static PrintWriter out;
static BufferedReader in;
static String strIn;

public static boolean CreateClientSocket(InetAddress ip) {
    try {
        client = new Socket();
        client.connect(new InetSocketAddress(ip, 9999), 0);
        t = new Thread(new SocketClient());
        t.start();
        return true;
    } catch (UnknownHostException ex) {
        Logger.getLogger(SocketServer.class.getName()).log(Level.SEVERE, null, ex);
        return false;
    } catch (IOException ex) {
        Logger.getLogger(SocketServer.class.getName()).log(Level.SEVERE, null, ex);
        return false;
    }
}

public static void closeClient() {
    try {
        client.close();
    } catch (IOException ex) {
        Logger.getLogger(SocketServer.class.getName()).log(Level.SEVERE, null, ex);
    }
}

public static void sendClientPlayertoServer() {
    try {
        out.println("procedure start");
        XStream xs =new XStream();
        out.println("xs created");
        GameSave gs = new GameSave();
        out.println("gs created");
        ArrayList<PlayerSerialize> listps = new ArrayList<PlayerSerialize>();
        PlayerSerialize ps = new PlayerSerialize();
        out.println("ps created");
        ps.getPlayerData(Players.players.get(1));
        listps.add(ps);
        gs.playersSerialize = listps;
        gs.gamedate = Dateutils.gamedate;
        String s =xs.toXML(gs);
        out.println("gs converted");
        String[] ssplit = s.split("\n");
        out.println("clientplayertoserver");
        for (String spart : ssplit) {
            out.println(spart);
        }
        out.println("clientready");
        out.flush();
    } catch (Exception e) {
        e.printStackTrace();
        JOptionPane.showMessageDialog(null, e.toString());
        Utils.debugWriteStringToFile(e.toString(), "sendclientexception");
    }
}

public static void sendClientReady() {
    out.println("clientready");
    out.flush();
}

public static void sendClientIsAlive() {
    out.println("clientisalive");
    out.flush();
}

@Override
public void run() {
    try {
        out = new PrintWriter(client.getOutputStream(), true);
        in = new BufferedReader(new InputStreamReader(client.getInputStream()));
        while ((strIn = in.readLine()) != null) {
            System.out.println(strIn);
            if (strIn.contains("side")) {
                strIn = in.readLine();
                System.out.println(strIn);
                DialogMultiplayerStart.setSide(strIn);
            } else if (strIn.contains("startgame")) {
                DialogMainField.startNewGame(true, false, DialogMultiplayerStart.isFirstPlayerUSSR);
                DialogMultiplayerStart.callDispose();
            } else if (strIn.contains("serverprestige")) {
                strIn = in.readLine();
                System.out.println(strIn);
                Players.players.get(0).prestige = Integer.parseInt(strIn);
            } else if (strIn.contains("clientplayertoclient")) {
                strIn = in.readLine();
                System.out.println(strIn);
                XStream xs = new XStream();
                GameSave gs = (GameSave) xs.fromXML(strIn);
                Players.players.get(1).getPlayerSerializeData(gs.playersSerialize.get(0));
            } else if (strIn.contains("refreshgamefield")) {
                PanelNextTurn.refreshGameField();
            }
        }
    } catch (IOException ex) {
        Logger.getLogger(SocketClient.class.getName()).log(Level.SEVERE, null, ex);
    }
}

}

服务器端：

public class SocketServer implements Runnable {

static ServerSocket server;
static Socket client;
static Thread t;
static PrintWriter out;
static BufferedReader in;
static String strIn;

public static void CreateServerSocket() {
    try {
        server = new ServerSocket(9999);
        t = new Thread(new SocketServer());
        t.start();
    } catch (IOException ex) {
        Logger.getLogger(SocketServer.class.getName()).log(Level.SEVERE, null, ex);
    }

}

public static void closeServer() {
    try {
        server.close();
    } catch (IOException ex) {
        Logger.getLogger(SocketServer.class.getName()).log(Level.SEVERE, null, ex);
    }
}

public static void sendSide(String side) {
    out.println("side");
    out.println(side);
}

public static void sendStartGame() {
    out.println("startgame");
}

public static void sendServerIsAlive() {
    out.println("serverisalive");
}

public static void sendServerPrestige() {
    out.println("serverprestige");
    out.println(Players.players.get(0).prestige);
}

public static void sendRefreshField() {
    out.println("refreshgamefield");
}

public static void sendClientPlayertoClient() {
    XStream xs = new XStream();
    GameSave gs = new GameSave();
    ArrayList<PlayerSerialize> listps = new ArrayList<PlayerSerialize>();

    PlayerSerialize ps = new PlayerSerialize();
    ps.getPlayerData(Players.players.get(1));
    listps.add(ps);
    gs.playersSerialize = listps;
    gs.gamedate = Dateutils.gamedate;
    String s = xs.toXML(gs);
    Utils.debugWriteStringToFile(s, "clientplayertoclient");
    out.println("clientplayertoclient");
    out.println(s);
}

@Override
public void run() {

    try {
        client = server.accept();
        DialogMultiplayerStart.updateAfterConnection();
        out = new PrintWriter(client.getOutputStream(), true);
        in = new BufferedReader(new InputStreamReader(client.getInputStream()));
        out.println("test from server");

        while ((strIn = in.readLine()) != null) {
            System.out.println(strIn);
            if (strIn.contains("clientplayertoserver")) {
                String s=new String();
                while(!(strIn=in.readLine()).contains("clientready")){
                    s=s+strIn;
                }
                XStream xs = new XStream();
                GameSave gs = (GameSave) xs.fromXML(s);
                Players.players.get(1).getPlayerSerializeData(gs.playersSerialize.get(0));
             PanelNextTurn.setClientReady();
            } else if (strIn.contains("clientisalive")) {
                DialogMainField.startNewGame(true, true, DialogMultiplayerStart.isFirstPlayerUSSR);
                DialogMultiplayerStart.callDispose();

            }
        }
        out.println("CYCLE ENDED!!!");
    } catch (IOException ex) {
        out.println("caught error");
        Logger.getLogger(SocketServer.class.getName()).log(Level.SEVERE, null, ex);
    }
}

设置side sendSide和start game sendStartGame命令效果很好，在加载游戏数据后检查服务器和客户端是否处于活动状态也很好。但无法将客户机转向服务器

---

问题是服务器端只接收过程开始消息，并且没有记录错误的文件。以这种方式使用XStream是否存在任何限制或问题？我应该使用什么作为通过套接字发送对象的不同方式？

代码中的问题与XStream无关，而是如何在客户端和服务器之间写入数据

我创建了一个小样本供您运行。它主要使用您的服务器代码和客户端代码。 我猜您已经完成了一些实现，并在代码中添加了刷新和关闭流/套接字

运行代码并查看数据是如何从客户端传输到服务器的。应该足以让你走出困境

代码如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.thoughtworks.xstream.XStream;

public class ClientServerDemo {

    public static void main(String[] args) {
        Thread server = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    new Server();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });

        server.start();
        Client.sendClientPlayertoServer();
    }

    static class PlayerData {

        private List<Player> listps;
        private Date gameDate;

        public PlayerData(List<Player> listps) {
            this.gameDate = new Date();
            this.listps = listps;
        }

        public String toString() {
            String state = "Game from " + gameDate + " " + listps.size()
                    + " Players.\n";
            for (Player p : listps) {
                state += p.toString();
            }
            return state;
        }

    }

    static class Player {
        private String name;

        public Player(String name) {
            this.name = name;
        }

        public String toString() {
            return "Player " + name + "\n";
        }
    }

    static class Server {
        Server() throws IOException {
            ServerSocket serverSocket = new ServerSocket(1234);
            Socket s;
            while ((s = serverSocket.accept()) != null) {
                readFromClient(s);
            }
        }

        private void readFromClient(Socket sock) throws IOException {
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    sock.getInputStream()));
            String strIn;
            while ((strIn = in.readLine()) != null) {
                System.out.println(strIn);
                if (strIn.contains("clientplayertoserver")) {
                    String s = new String();
                    while (!(strIn = in.readLine()).contains("clientready")) {
                        s = s + strIn;
                    }
                    XStream xs = new XStream();
                    PlayerData gs = (PlayerData) xs.fromXML(s);
                    System.out.println("***Server received playerData:\n" + gs);
                }
            }
        }
    }

    public static class Client {
        public static void sendClientPlayertoServer() {
            try {
                Socket socket = new Socket("localhost", 1234);
                PrintWriter out = new PrintWriter(new OutputStreamWriter(
                        socket.getOutputStream()));
                out.println("procedure start");
                XStream xs = new XStream();
                out.println("xs created");
                out.println("gs created");
                List<Player> listps = new ArrayList<Player>();
                Player ps = new Player("Someone");
                out.println("ps created");
                listps.add(ps);
                PlayerData gs = new PlayerData(listps);

                String s = xs.toXML(gs);
                out.println("gs converted");
                String[] ssplit = s.split("\n");
                out.println("clientplayertoserver");
                for (String spart : ssplit) {
                    out.println(spart);
                }
                out.println("clientready");
                out.flush();
                out.close();
                socket.close();

                System.out.println("+++ Client send this object:\n" + gs);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

输出主要来自您的代码。程序将不会终止，因为ServerSocket将继续侦听更多客户端，异常处理也将丢失。

---

但是，这应该足以让您开始。

显示服务器如何读取数据。还显示您是如何传输序列化数据的。您的请求将在更新后的帖子中得到答复。您使用的是bufferedwriter还是bufferedreader？如果是，那么您还应该在outputstream上调用flush并关闭，在inputstream上调用flush。请检查问题更新-我添加了flush仍然无效：，并复制了完整的客户端/服务器代码。

procedure start
xs created
gs created
ps created
gs converted
clientplayertoserver
+++ Client send this object:
Game from Mon Jan 13 19:44:06 CET 2014 1 Players.
Player Someone

***Server received playerData:
Game from Mon Jan 13 19:44:06 CET 2014 1 Players.
Player Someone