Envoyer et recevoir l'objet serialize sur UDP

Je ne sais pas ce que vous voulez accomplir en fin de compte, mais le fait de travailler avec UDP n'est pas si facile... la principale raison en est dans la Description de la DatagramPacket Objet:

Datagramme paquets sont utilisés pour mettre en œuvre
un sans connexion, de livraison de paquets
service. Chaque message est acheminé à partir de
une machine à une autre basée uniquement
l'information contenue dans cette
paquet. Plusieurs paquets envoyés à partir de
une machine à une autre peut être routée
différemment, et peut arriver dans n'importe quel
ordre. Livraison de paquets n'est pas
garanti.

Un bon tutoriel lorsque vous travaillez avec udp est http://download.oracle.com/javase/tutorial/networking/datagrams/clientServer.html

Au sujet de votre blocage:

Reçoit un datagramme paquet à partir de cette
socket. Lorsque cette méthode est de retour, le
DatagramPacket du tampon est rempli avec
les données reçues. Le datagramme paquet
contient également l'adresse IP de l'expéditeur,
et le numéro de port de l'expéditeur
machine.

Cette méthode bloque jusqu'à ce qu'un datagramme est
reçu. Le champ longueur de l'
datagramme paquet objet contient l'
la longueur du message reçu. Si l'
le message est plus long que le paquet
la longueur, le message est tronqué.

Je n'ai pas vraiment testé, mais je suis assez sûr - sur la base de la description que le datagramsocket.reseive fonction de bloc jusqu'à ce que le paquet est rempli (dans votre cas, jusqu'à 100000 octets reçus).

Je vous suggère de commencer avec un datagrampacket avec un fixe de longueur connue, où vous transmettre la taille de la charge utile. Quelque chose comme:

public static void main(String[] args) {
    ClientModel c1 = new ClientModel ();
    c1.data = 123;
    c1.name = "test";

    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream(baos);
      oos.writeObject(c1);
      oos.flush();
      //get the byte array of the object
      byte[] Buf= baos.toByteArray();

      int number = Buf.length;;
      byte[] data = new byte[4];

      //int -> byte[]
      for (int i = 0; i < 4; ++i) {
          int shift = i << 3; //i * 8
          data[3-i] = (byte)((number & (0xff << shift)) >>> shift);
      }

      DatagramSocket socket = new DatagramSocket(1233);
      InetAddress client = InetAddress.getByName("localhost");
      DatagramPacket packet = new DatagramPacket(data, 4, client, 1234);
      socket.send(packet);

      //now send the payload
      packet = new DatagramPacket(Buf, Buf.length, client, 1234);
      socket.send(packet);

      System.out.println("DONE SENDING");
    } catch(Exception e) {
        e.printStackTrace();
    }
}

De l'autre côté, vous SAVEZ maintenant vos tailles:

public static void main(String[] args) {
    try {
      DatagramSocket socket = new DatagramSocket(1234);

      byte[] data = new byte[4];
      DatagramPacket packet = new DatagramPacket(data, data.length );
      socket.receive(packet);

      int len = 0;
      //byte[] -> int
      for (int i = 0; i < 4; ++i) {
          len |= (data[3-i] & 0xff) << (i << 3);
      }

      //now we know the length of the payload
      byte[] buffer = new byte[len];
      packet = new DatagramPacket(buffer, buffer.length );
      socket.receive(packet);

        ByteArrayInputStream baos = new ByteArrayInputStream(buffer);
      ObjectInputStream oos = new ObjectInputStream(baos);
      ClientModel c1 = (ClientModel)oos.readObject();
      c1.print();
    } catch(Exception e) {
        e.printStackTrace();
    }
}

La CientModel clas sI utilisé:

public class ClientModel implements Serializable{
    private static final long serialVersionUID = -4507489610617393544L;

    String name = "";
    int data = 1;

    void print() {
        System.out.println(data +": " + name);
    }
}

J'ai testé ce code et il fonctionne très bien. Espérons que l'aide (j'ai eu l'octet de type int et autour de http://www.tutorials.de/java/228129-konvertierung-von-integer-byte-array.html)

Edit: Comme indiqué dans les commentaires, il est souvent une très mauvaise idée d'utiliser UDP, principalement, parce que vous ne savez pas si vos paquets sont reçus dans l'ordre correct, ou même pas du tout. UDP ne garantit PAS que. Je ne voulais pas faire trop de udp de programmation, mais la seule partie que vous pouvez compter sur (si j'ai bien compris), c'est, que si vous obtenez un paquet et il s'inscrit dans le datagramme (65,527 octets - voir https://en.wikipedia.org/wiki/User_Datagram_Protocol) il contiendra l'ensemble de la chose. Donc, si vous ne vous souciez pas de l'ordre dans lequel le message venu et votre objet s'inscrit dans le datagramme, vous devriez être bien.

Edit2: Comme pour le code: ne pas utiliser en tant que tel. c'est seulement un exemple, ind UDP vous devez avoir un seul type de paquet, et ce avec une taille connue. de cette façon, vous n'avez pas besoin d'envoyer la "taille". Si vous utilisez le code comme indiqué ci-dessus, et un paquet est perdu, le paquet suivant sera de la bonne taille (c'est à dire le premier paquet est supprimé, tout à coup vous de vérifier les premiers octets de la charge utile pour obtenir la taille).