Transferring primitive data types via UDP other than a String

Question

Hi ALL,
I am new to Socket programming in UDP.
I need to implement a FTP client-server application.
Now the packet that I need to transfer using UDP as a DatagramPacket consists of multiple primitive data types, (3short types and 1 byte array of size 265.)
How do I do that?
All the samples and examples I managed to find on the Internet illustrated the problem of transferring a String type converted to getBytes and the byteArray is transferred.
However, in my case i need to pass this structure..(3fields) to the other side. If I convert the 4 fields to a single concatenated string there's this problem of finding out where each of the four fields begin and where do they end.
Please suggest and help...
thanks..
: )

Answer 1

Just create a class that represents your structure and convert-it to a byte array that can be sended over a DatagramSocket.
Try this sample code :
import java.io.*;
import java.net.*;
public class DP
    /** Creates a new instance of DP */
    public DP ()
     * @param args the command line arguments
    public static void main (String[] args)
        try
            System.out.println ("Starting server ...");
            DatagramServerThread server = new DatagramServerThread ("Datagram server");
            server.start ();
            System.out.println ("Creating your object ...");
            ByteArrayOutputStream baos = new ByteArrayOutputStream (); // Creating byte array output stream ..
            ObjectOutputStream oos = new ObjectOutputStream (baos);// Creating a object output stream that writes to byte array output stream..
            YourStructure newObject = new YourStructure (); // creating your data structure..
            newObject.setShortField1 ((short)12);// setting values ...
            newObject.setShortField2 ((short)45);
            newObject.setShortField3 ((short)4);
            newObject.setArray (new byte [256]);
            oos.writeObject (newObject); // write your structure to object output stream...
            byte data_to_be_sent[] = baos.toByteArray (); // retrieving equivalent byte array...
            // send data...
            DatagramSocket s = new DatagramSocket ();
            System.out.println ("Sending ...");
            DatagramPacket packet = new DatagramPacket (data_to_be_sent, data_to_be_sent.length);
            packet.setAddress (InetAddress.getByName ("localhost"));
            packet.setPort (8888);
            s.send (packet);
        catch (Exception e)
            e.printStackTrace ();
class YourStructure implements Serializable
     * Holds value of property shortField1.
    private short shortField1;
     * Holds value of property shortField2.
    private short shortField2;
     * Holds value of property shortField3.
    private short shortField3;
     * Holds value of property array.
    private byte[] array;
     * Getter for property shortField1.
     * @return Value of property shortField1.
    public short getShortField1 ()
        return this.shortField1;
     * Setter for property shortField1.
     * @param shortField1 New value of property shortField1.
    public void setShortField1 (short shortField1)
        this.shortField1 = shortField1;
     * Getter for property shortField2.
     * @return Value of property shortField2.
    public short getShortField2 ()
        return this.shortField2;
     * Setter for property shortField2.
     * @param shortField2 New value of property shortField2.
    public void setShortField2 (short shortField2)
        this.shortField2 = shortField2;
     * Getter for property shortField3.
     * @return Value of property shortField3.
    public short getShortField3 ()
        return this.shortField3;
     * Setter for property shortField3.
     * @param shortField3 New value of property shortField3.
    public void setShortField3 (short shortField3)
        this.shortField3 = shortField3;
     * Getter for property array.
     * @return Value of property array.
    public byte[] getArray ()
        return this.array;
     * Setter for property array.
     * @param array New value of property array.
    public void setArray (byte[] array)
        this.array = array;
    public String toString ()
        StringBuffer buffer = new StringBuffer ();
        buffer.append ("Short field 1 is ");
        buffer.append(this.getShortField1 ());
        buffer.append ("\nShort field 2 is ");
        buffer.append (this.getShortField2 ());
        buffer.append ("\nShort field 3 is ");
        buffer.append (this.getShortField3 ());
        buffer.append ("\nYour array field is ");
        for (int index = 0; index < this.getArray ().length; index++)
            buffer.append ("Index [" + index + "] = " + this.getArray () [index] + "\n");
        return buffer.toString ();
class DatagramServerThread extends Thread
    protected DatagramSocket socket = null;
    public DatagramServerThread (String name) throws IOException
        super (name);
        socket = new DatagramSocket (8888);
    public void run ()
        try
            byte buffer [] = new byte [socket.getReceiveBufferSize ()];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            System.out.println ("Server is ready. Waiting for packet ...");
            socket.receive(packet); // waiting for packet ...
            System.out.println ("Packet received! : ");
            byte received_data[] = packet.getData ();
            ByteArrayInputStream bais = new ByteArrayInputStream (received_data); // Creating byte array input stream ..
            ObjectInputStream ois = new ObjectInputStream (bais); // Creting Object input stream
            Object readed_object = ois.readObject ();
            YourStructure your_original_object = (YourStructure)readed_object;
            System.out.println (your_original_object.toString ());
            System.out.println ("Exiting server thread. Bye");
            socket.close ();
        catch (Exception e)
            System.err.println ("Server error");
            e.printStackTrace ();
}