用Java套接字發送自制對象

Question

我試圖從服務器發送ArrayList到客戶端，但它不起作用。服務器確實發送了整數。如果客戶端發送列表，它也可以工作。

這裏是我嘗試發送的對象（只有字段）

public class DrawingPoint implements Serializable 
{ 
    private double x; 
    private double y; 
    private boolean paint; 
    Color c; 
    private int dikte; 
    boolean gum;  

    public DrawingPoint(double x, double y, boolean paint, Color c, int dikte, 
      boolean gum) { 
     super(); 
     this.x = x; 
     this.y = y; 
     this.paint = paint; 
     this.c = c; 
     this.dikte = dikte; 
     this.gum = gum; 
    } 

    public double getX() { 
     return x; 
    } 

    public double getY() { 
     return y; 
    } 

    public boolean isPaint() { 
     return paint; 
    } 

    public int getDikte() { 
     return dikte; 
    } 
//getters and setters 

} 

下面是服務器和客戶端

服務器的代碼（這不是服務器，但這個類臨危和發送的東西，服務器，使一個陣列，這些對象，並讓我們將它發送。）

package MultiplayerPaint.socket.server; 

import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.io.Serializable; 
import java.net.Socket; 
import java.util.ArrayList; 

import MultiplayerPaint.DrawingPoint; 

public class ThreadClass extends Thread implements Runnable, Serializable{ 

    transient Socket socket; 
    transient Server server; 
    private transient ObjectInputStream inputFromClient; 
    private transient ObjectOutputStream outputToClient; 
    public ArrayList<DrawingPoint> list = new ArrayList<>(); 
    String name; 
    public int nummer; 
    transient private boolean changed = false; 

    public ThreadClass(Socket socket, Server server, int nummer) 
    { 
     this.server = server; 
     this.nummer = nummer; 
     try { 
      inputFromClient = new ObjectInputStream(socket.getInputStream()); 
      outputToClient = new ObjectOutputStream(socket.getOutputStream()); 
      runOnce(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    @Override 
    public void run() { 
     while(true) 
     { 
      try { 
       Thread.sleep(1000/5); 
       ArrayList<DrawingPoint> l = (ArrayList<DrawingPoint>) inputFromClient.readObject(); 
       list = l; 
       changed = true; 
      } catch (Exception e) { 
       e.printStackTrace(); 
       System.exit(0); 
      } 
     } 
    } 

    public void runOnce() 
    { 
     try { 
      outputToClient.writeInt(nummer); 
      outputToClient.flush(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    public boolean isChanged() { 
     return changed; 
    } 

    public void setChanged(boolean changed) { 
     this.changed = changed; 
    } 

    public void sending(ThreadClass[] sturen) { 
     try { 
      for(ThreadClass t : sturen) 
      { 
       outputToClient.writeObject(t); 
      } 
      outputToClient.flush(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

這是客戶

package MultiplayerPaint.socket; 

import java.awt.Color; 
import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.net.Socket; 
import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.Collections; 
import java.util.Iterator; 
import java.util.List; 

import MultiplayerPaint.DrawingPoint; 
import MultiplayerPaint.PaintModel; 
import MultiplayerPaint.socket.server.Server; 
import MultiplayerPaint.socket.server.ThreadClass; 

public class Client 
{ 

    private ObjectInputStream inputFromClient; 
    private ObjectOutputStream outputToClient; 
    int aantal= -1; 
    int nummer; 

    public Client(final PaintModel m) 
    { 
     try { 
      Socket socket = new Socket(Server.HOST, Server.PORT); 
      outputToClient = new ObjectOutputStream(socket.getOutputStream()); 
      inputFromClient = new ObjectInputStream(socket.getInputStream()); 
      nummer = inputFromClient.readInt(); 
      m.nummer = nummer; 
     } catch (IOException e1) { 
      e1.printStackTrace(); 
     } 
     Thread sturen = new Thread(new Runnable() { 

      @Override 
      public void run() { 
       try { 
        while(true) 
        { 

         ArrayList<DrawingPoint> l = new ArrayList<>(); 
         l.addAll(m.getPoints()); 
         outputToClient.writeObject(l); 
         outputToClient.flush(); 
         aantal = m.getPoints().size(); 
         Thread.sleep(1000/5); 
        } 
       } catch (Exception e) { 
        e.printStackTrace(); 
       } 
      } 
     }); 
     sturen.start(); 
     Thread ontvangen = new Thread(new Runnable() { 

      @Override 
      public void run() { 
       while(true) 
       { 
        try { 
         ArrayList<ThreadClass> l = new ArrayList<>(); 
         for(int i = 0; i< 4; i++) 
         { 
          l.add((ThreadClass) inputFromClient.readObject()); 
         } 
         Iterator<ThreadClass> it = l.iterator(); 
         while(it.hasNext()) 
         { 
          ThreadClass t = it.next(); 
          if(t.nummer == nummer) 
          { 
           System.out.println(t.nummer + " " + t.list.size()); 
           for(DrawingPoint p: t.list) 
           { 
            if(p == null) System.out.println("null"); 
            else System.out.println(t.nummer + " X " + p.getX() + " Y " + p.getY()); 
           } 
           continue; 
          } 
          System.out.println(t.nummer + " " + t.list.size()); 

          m.otherPoints.put(t.nummer, t.list); 
         Thread.sleep(1000/5); 
         } 
        } 
        catch (Exception e1) 
        { 
         e1.printStackTrace(); 
        } 
       } 
      } 
     }); 
     ontvangen.start(); 
    } 
} 

Answer 1

要通過套接字發送對象，我會推薦你​​先序列化你的對象併發送它們，之後當你的對象被接收時，它們被反序列化。

例如，我將我的對象轉換爲JSON格式，並將其保存爲一個字符串，將該字符串發送到服務器，服務器將其反序列化爲一個java對象，然後再使用序列化對象回答問題等等。

 
//Client side 
Person person; 
String stringJSON = serializer.serialize(person); 

socket.getOutputStream().println(stringJSON); 

//Server Side 

String stringJSON = socket.getInputStream().readLine(); 
Person person = JSONDeserializer.deserialize(stringJSON) 

我覺得這種方式更容易，如果intrested我用這個序列化/ desrialize http://flexjson.sourceforge.net/

到時候你必須爲你的對象提供getter和setter方法的方式。