使用Java套接字發送自制對象

Question

我正在嘗試將ArrayList從服務器發送到客戶端，但是它不起作用。 服務器確實發送int。 如果客戶端發送列表，它也可以使用。

這是我嘗試發送的對象（僅字段）

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 )

我發現這種方法要容易得多，如果有興趣，我可以使用它來序列化/反序列化http://flexjson.sourceforge.net/

順便說一下，您必須為對象提供setter和getter。