在Java中通過udp發送對象

Question

我試圖通過首先序列化它然后在另一端反序列化來發送和反對udp。 我認為這是微不足道的，因為我之前已經通過udp發送了其他數據並將其序列化為文件等。

我已經調試了一段時間了，我一直在接收端獲得EOFException。 數據包正常到達，但不知何故反序列化失敗。 我不確定錯誤是發送者還是接收者。 我想問題可能是接收方不知道數據包的大小。

這是我的發件人類：

    package com.machinedata.sensordata;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

import android.content.Context;
import android.util.Log;

import com.machinedata.io.DataSerializer;
import com.machinedata.io.ManagerUdpPacket;

/**
 * This class sends udp-packets. It is used to send driver's information to the manager tablet.
 * @author tuomas
 *
 */
public class UdpSender 
{
     private final int MANAGER_PORT = 1234;
     private String ip = "192.168.11.50";   //tablet's IP
     private DatagramSocket sock = null;
     private InetAddress host;
     private String mType;
     private DataSerializer dataser;

    public UdpSender(Context context) 
    {
        try 
        {
            sock = new DatagramSocket();       
            host = InetAddress.getByName(ip);   //tabletin ip
        }
        catch(Exception e)
        {
            System.err.println("Exception alustettaessa senderia" + e);
        }

        dataser = new DataSerializer(context);
    }

    /**
     * With this function we can send packets about our machine to the manager to
     * see in the fleet-view.
     */
    public void sendToManager(ManagerUdpPacket managerUdp)
    {

        //serialize
        Log.v("sendudp", "Send a packet: " + managerUdp.getDriver());

        //serialize
        byte[] data = dataser.serializeManagerPacket(managerUdp);


        //send
        try
        {
                DatagramPacket  dp = new DatagramPacket(data , data.length , host , MANAGER_PORT);
                sock.send(dp);     
        }

        catch(IOException e)
        {
            System.err.println("IOException senderissa " + e);
        }


    }

    public void close()
    {
        sock.close();
    }
}

這是序列化功能：

/**
 * Serializes packet to be sent over udp to the manager tablet.
 */
public byte[] serializeManagerPacket(ManagerUdpPacket mp)
{
    try
    {
      ByteArrayOutputStream baos = new ByteArrayOutputStream(2048);
      ObjectOutputStream oos = new ObjectOutputStream(baos);
      oos.writeObject(mp);
      oos.close();
      // get the byte array of the object
      byte[] obj= baos.toByteArray();
      baos.close();
      return obj;
    }
    catch(Exception e) {
        e.printStackTrace();
    }

    return null;

}

包接收器類

public class UdpReceiver {

private DatagramSocket clientSocket;
private byte[] receiveData;
private final int timeout = 1;

/**
 * Create a receiver.
 * @param port Port to receive from.
 * @param signCount Number of signals in a packet
 */
public UdpReceiver(int port)
{

    //receiveData = serializeManagerPacket(new ManagerUdpPacket("asd", new MachineData(1, 2, "asd", "modelName"), 1,2,3,4,5.0,null));

    try{
        clientSocket=new DatagramSocket(port);
        clientSocket.setReceiveBufferSize(2048);
        clientSocket.setSoTimeout(timeout);
    }catch(SocketException e){
        Log.e("ERR", "SocketException in UdpReceiver()");
    }
}

public void close()
{
    clientSocket.close();
}

/**
 * Receive a data packet and split it into array.
 * @param data Array to put data in, must be correct size
 * @return True on successful read, false otherwise
 */
public ManagerUdpPacket receive()
{

    //receive a packet
    DatagramPacket recvPacket = new DatagramPacket(receiveData, receiveData.length);
    try{
        clientSocket.receive(recvPacket);
    }catch(IOException e){
        Log.e("ERR", "IOException in UdpReceiver.receive");
        return null;
    }

    ManagerUdpPacket obj = deserializeManagerPacket(receiveData);

    if (obj != null)
        Log.v("udpPacket", "UDP saatu: " + obj.getDriver());
    return obj;
}


/**
 * Deserialize the udp-packet back to readable data. 
 * @param data
 * @return
 */
public ManagerUdpPacket deserializeManagerPacket(byte[] data)
{
    try
    {
        ObjectInputStream iStream = new ObjectInputStream(new ByteArrayInputStream(data));
        ManagerUdpPacket obj = (ManagerUdpPacket) iStream.readObject();
        iStream.close();
            return obj;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

        return null;
    }
}

在接收端偵聽數據包的線程：

dataStreamTask = new TimerTask()
    {
        public void run() 
        {
            if (currentlyStreaming) 
            {

                ManagerUdpPacket mp = udpReceiver.receive();

                if(mp != null)
                {
                    Log.v("log", "Paketti saatu! " + mp.getDriver());
                }


                //stop thread until next query
                try {
                    synchronized(this){
                        this.wait(queryInterval);
                    }
                } catch (InterruptedException e) {
                    Log.e("ERR", "InterruptedException in TimerTask.run");
                }
            }

        }

最后我通過UDP發送的類：

    public class ManagerUdpPacket implements Serializable
{
    private static final long serialVersionUID = 9169314425496496555L;

    private Location gpsLocation;
    private double totalFuelConsumption;
    private long operationTime;

    //workload distribution
    private long idleTime = 0;
    private long normalTime = 0;
    private long fullTime = 0;

private int currentTaskId;
private String driverName;
String machineModelName = "";
String machineName = "";
int machineIconId = -1;
int machinePort = -1;

public ManagerUdpPacket(String driver, MachineData machine, int currentTaskId, long idleTime, long fullTime, long operationTime, double fuelConsumption, Location location)
{
    driverName = driver;
    this.currentTaskId = currentTaskId;
    this.idleTime = idleTime;
    this.fullTime = fullTime;
    this.operationTime = operationTime;
    this.totalFuelConsumption = fuelConsumption;
    this.gpsLocation = location;
    machineModelName = machine.getModelName();
    machineName = machine.getName();
    machineIconId = machine.getIconId();
    machinePort = machine.getPort();
}

public String getDriver()
{
    return driverName;
}
public int getCurrentTaskId()
{
    return currentTaskId;
}
public long getIdleTime()
{
    return idleTime;
}
public long getFullTime()
{
    return fullTime;
}
public long getOperationTime()
{
    return operationTime;
}
public double getTotalFuelConsumption()
{
    return totalFuelConsumption;
}
public double getLocation()
{
    return gpsLocation.getLatitude();
}
public String getMachineModelName()
{
    return machineModelName;
}
public String getMachineName()
{
    return machineName;
}
public int getMachineIconId()
{
    return machineIconId;
}
    public int getMachinePort()
    {
        return machinePort;
    }


}

我試圖從序列化數據包的大小獲取數據包大小或根據互聯網上的一些示例插入任意2048。 雖然不能讓它工作。

Answer 1

據我所知，receive函數返回它收到的字節長度。 但是你的緩沖區將滿了：

例：

int buffersize = 1024;

你通過udp發送8字節。

所以你的byte[]將滿8個字節，但1024的其余部分將為0。

通過.receive（）調用保存你獲得的大小，只需將緩沖區的所有值保存到另一個byte []，你就應該得到你的對象。

對於你的例子：

public ManagerUdpPacket receive()
{
int receivedBytes = 0;

//receive a packet
DatagramPacket recvPacket = new DatagramPacket(receiveData, receiveData.length);
try{
    receivedBytes = clientSocket.receive(recvPacket);
}catch(IOException e){
    Log.e("ERR", "IOException in UdpReceiver.receive");
    return null;
}
byte[] myObject = new byte[receivedBytes];

for(int i = 0; i < receivedBytes; i++)
{
     myObject[i] = receiveData[i];
}

ManagerUdpPacket obj = deserializeManagerPacket(myObject);

if (obj != null)
    Log.v("udpPacket", "UDP saatu: " + obj.getDriver());
return obj;
}

Answer 2

在UDP上接收數據時，請始終使用java.net.DatagramSocket.getReceiveBufferSize(); 。 這是平台的實際大小或套接字的SP_RCVBUF。 由於UDP是一種基於數據報的協議，不像TCP（流媒體協議），接收緩沖區對數據健全性至關重要。 通常，接收和發送緩沖區的大小相等，但在使用DatagramSocket.send(DatagramPacket)時發送時不會受到打擾，或者，也可以使用DatagramSocket.setSendBufferSize(DatagramSocket.getSendBufferSize())為此使用SO_SNDBUF選項插座。 請記住，在UDP中，如果使用大於平台的SO_SNDBUF大小，則可以丟棄該數據包。