java Peer to Peer using UDP socket

Question

I am having a simple Peer to Peer program written in java. I have the following code.

import java.net.*;
import java.io.*;
public class Broadcasts {

private final Runnable receiver;
private final Runnable sender;
private boolean run = true;


  public Broadcasts(UDPSocketHandler parent)  throws UnknownHostException{
    InetAddress aHost = InetAddress.getLocalHost();

    sender = new Runnable() {
        public void run() {
            byte data[] = "Hello".getBytes();
            DatagramSocket socket = null;
            try {
                socket = new DatagramSocket();
            } catch (SocketException ex) {
                ex.printStackTrace();
                parent.quit();
            }

            DatagramPacket packet = new DatagramPacket(
                    data,
                    data.length,
                    aHost,
                    9090);
            while (run) {
                try {

                    System.out.println("what is sent"+new String(packet.getData()));
                    socket.send(packet);
                    Thread.sleep(1000);
                } catch (IOException ex) {
                    ex.printStackTrace();
                    parent.quit();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                    parent.quit();
                }
            }
        }
    };


    receiver = new Runnable() {
        public void run() {
            byte data[] = new byte[0];
            DatagramSocket socket = null;
            try {
                socket = new DatagramSocket(9090);
            } catch (SocketException ex) {
                ex.printStackTrace();
                //parent.quit();
            }
            DatagramPacket packet = new DatagramPacket(data, data.length);
            //System.out.println("this is what has been received"+packet.getData());
            String temp;
           // while (run) {
                try {
                    socket.receive(packet);
                    System.out.println("this is what has been received"+packet.getData());

                    //System.out.println("Message received ..."+ temp);
                } catch (IOException ex) {
                    ex.printStackTrace();
                    parent.quit();
                }

            //}
        }
    };


    new Thread(sender).start();
    new Thread(receiver).start();

}

  public void quit() {
    run = false;
  }
}

Then I have the following class to handle my communication

public class UDPSocketHandler {

  private final Broadcasts broadcasts;
// continue running application?
  private boolean run = true;

  public UDPSocketHandler() throws UnknownHostException
  {
    // start socket server to accept incoming connections
    new Thread().start();


    // late initialize of UDP broadcast and receive, to ensure needed
    // objects are instantiated
    broadcasts = new Broadcasts(this);
}

// global quit method shuts down everything and exits
public void quit() {
    run = false;
    broadcasts.quit();
    System.exit(0);
}

// application entry
  public static void main(String[] args) throws UnknownHostException{
   new UDPSocketHandler();

  }
}

The problem is that the receiver do not receive anything. From what I understood, we could run the sender and receive on the same program as shown in this question. That is actually what I would like to do but using UDP instead of TCP. What is the problem with my code?

Answer 1

After some efforts and hours I have finally managed to to get my program working. I have the following:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.*;

public class SocketTest {
  private boolean run = true;


  public static void main(String[] args) throws IOException {

    startServer();
    startSender();
  }

  public static void startSender() throws UnknownHostException{
    InetAddress aHost = InetAddress.getLocalHost();
    (new Thread() {
        @Override
        public void run() {
            byte data[] = "Hello".getBytes();
            DatagramSocket socket = null;
            try {
                socket = new DatagramSocket();
                socket.setBroadcast(true);
            } catch (SocketException ex) {
                ex.printStackTrace();
                //parent.quit();
            }

            DatagramPacket packet = new DatagramPacket(
                    data,
                    data.length,
                    aHost,
                    9090);
            int i=0;
            while (i<10) {
                try {

                    System.out.println("what us mmmm.."+new String(packet.getData()));
                    socket.send(packet);
                    Thread.sleep(50);
                    i++;
                    System.out.println(i);
                } catch (IOException ex) {
                    ex.printStackTrace();
                   // parent.quit();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                   // parent.quit();
                }
            }
        }}).start();
    }


  public static void startServer() {
    (new Thread() {
        @Override
        public void run() {

                //byte data[] = new byte[0];
                DatagramSocket socket = null;
                try {
                    socket = new DatagramSocket(9090);
                    //socket.setBroadcast(true);;

                } catch (SocketException ex) {
                    ex.printStackTrace();
                    //parent.quit();
                }
                DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
                //System.out.println("this is what has been received111"+packet.getData());
                String temp;
                while (true) {
                try {
                    socket.receive(packet);
                    temp=new String(packet.getData());
                    System.out.println("this is what has been received"+temp);


                    //System.out.println("Message received ..."+ temp);
                } catch (IOException ex) {
                    ex.printStackTrace();
                    //parent.quit();
                }

                 }
            }

    }).start();
 }
}

With this code, each node can act as both client and server. All we have to do is to pass the correct port number of a server to which we are sending the request. In this sample code, the port number is the same as the client sending the packet to itself. I hope this could help others