Enviando una estructura C++ sobre UDP en Java

Question

Soy un programador C++ y necesito configurar algunas comunicaciones UDP entre una aplicación java de Android y el servidor C++ que se ejecuta en una PC.

que tienen estructura que necesito para recibir en el PC que consiste en lo siguiente:

int 
int 
float 

Desafortunadamente estoy totalmente en una pérdida en cuanto a cómo puedo hacer esto con Java.

Necesito crear un DatagramPacket pero el constructor solo toma una matriz de bytes. Ahora con C++ esto sería un lanzamiento fácil desde una estructura a un char *. Sin embargo, lanzar de esta manera no es posible con Java.

He creado una clase simple que tiene los campos anteriores. Eso parece estar bien. Mi problema restante es cómo convertir eso en una matriz de bytes. ¿Alguien puede ayudar a un novato de Java en este frente?

¡Salud!

Edición: He creado una función en la clase que hace lo siguiente

 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(); 
     } 

¿Hay una mejor manera de hacer esto?

Prefiero no usar el búfer de protocolo de Google mencionado en la respuesta de Steve porque, si bien es interesante, requeriría demasiados cambios en otras implementaciones de plataforma que preferiría no hacer.

Answer 1

Puede usar Google protocol buffers como una forma independiente del idioma para serializar estructuras para transmisión y recepción. Tanto Java como C++ están disponibles de manera inmediata, y Jon Skeet ha escrito una implementación de C# lista para la producción.

Veo un par de ejemplos de Protobuf en uso en Android, incluido this.

Answer 2

Otro enfoque quizá más simple proviene de 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. 
    } 
} 

bastante feo pieza de código, pero aún más bonita que tratar directamente con tampones o JNI ya mencionadas búferes de protocolo de Google.