Invio di una struttura C++ su UDP in Java

Question

Sono un programmatore C++ e ho bisogno di configurare alcune comunicazioni UDP tra un'app per android java e il server C++ in esecuzione su un PC.

devo struttura che ho bisogno di ricevere sul PC che si compone dei seguenti elementi:

int 
int 
float 

Purtroppo io sono totalmente in perdita quanto a come posso fare questo con Java.

Ho bisogno di creare un DatagramPacket ma il costruttore prende solo un array di byte. Ora con C++ questo sarebbe un cast facile da una struttura a un char *. Tuttavia casting come questo non è possibile con Java.

Ho creato una classe semplice che contiene i campi sopra. Sembra a posto. Il mio problema rimanente è come trasformarlo in un array di byte. Qualcuno può aiutare un noob Java su questo fronte?

Cheers!

Edit: ho creato una funzione nella classe che fa la seguente

 public byte[] GetBytes() throws IOException 
     { 
      ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); 
      DataOutputStream  dataOut = new DataOutputStream(byteOut); 
      dataOut.writeInt(Integer.reverseBytes(int1)); 
      dataOut.writeInt(Integer.reverseBytes(int2)); 
      dataOut.writeFloat(float1); 

      return byteOut.toByteArray(); 
     } 

Esiste un modo migliore per fare questo?

Preferisco non utilizzare il buffer del protocollo google menzionato nella risposta di Steve perché, sebbene sia interessante, richiederebbe troppe modifiche ad altre implementazioni della piattaforma che preferirei non fare.

Answer 1

È possibile utilizzare Google protocol buffers come metodo indipendente dalla lingua per serializzare le strutture per la trasmissione e la ricezione. Sia Java che C++ sono disponibili immediatamente e Jon Skeet ha scritto un'implementazione C# pronta per la produzione.

Vedo un paio di esempi di Protobuf in uso su Android, incluso this.

Answer 2

Un altro approccio forse più semplice viene da Javolution.struct: http://javolution.org/target/site/apidocs/javolution/io/Struct.html

public static class Student extends Struct { 
    public final Enum32<Gender>  gender = new Enum32<Gender>(Gender.values()); 
    public final UTF8String   name = new UTF8String(64); 
    public final Date     birth = inner(new Date()); 
    public final Float32[]   grades = array(new Float32[10]); 
    public final Reference32<Student> next = new Reference32<Student>(); 
} 
class UDPMessage extends Struct { 
     Student student = inner(new Student()); 
     ... 
} 
... 
public void run() { 
    byte[] bytes = new byte[1024]; 
    DatagramPacket packet = new DatagramPacket(bytes, bytes.length); 
    UDPMessage message = new UDPMessage(); 
    message.setByteBuffer(ByteBuffer.wrap(bytes), 0); 
    // packet and message are now two different views of the same data. 
    while (isListening) { 
     multicastSocket.receive(packet); 
     int xxx = message.xxx.get(); 
     ... // Process message fields directly. 
    } 
} 

abbastanza brutto pezzo di codice, ma ancora più bella di trattare direttamente con tamponi JNI o ​​già citati buffer di protocollo di Google.