Xstream没有在线程中创建

我正在调试通过套接字发送由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); 
    } 
}

设置侧（sendSide），并开始游戏（sendStartGame）命令的伟大工程，检查服务器和客户端还活着游戏数据加载后 - 也可以正常工作。但没有办法发送客户端转向服务器。

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

来源

2014-01-12 lozga

显示您的服务器如何读取数据。同时显示如何传输序列化数据。 – Matthias

您的请求在更新后的文章中得到解答。 – lozga

你正在使用bufferedwriter或bufferedreader？如果是，那么你还应该在输出流上调用'flush（）'和'close（）'，并在输入流上调用'flush（）'。 – Matthias

代码中的问题与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(); 
      } 
     } 
    } 
}

这里是这个例子的输出：

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

输出主要是从您的代码。该程序不会终止，因为ServerSocket将继续监听更多的客户端，异常处理也会丢失。但是，这应该足以让你开始。

来源

2014-01-13 18:46:20 Matthias

请检查问题更新 - 我已添加刷新（仍然没有影响:(），并复制完整的客户端/服务器代码。 – lozga

Xstream没有在线程中创建

回答

相关问题