将 IP 从服务器发送到客户端。爪哇网络

Question

我的目标是创建一个服务器-客户端程序，发送服务器的 IP 号并让客户端连接到 IP 号（服务器）。
这样看，我有一个树莓派作为服务器，它的 IP 应该发送到许多作为客户端的计算机。
我已经尝试了一些完成的“多聊天服务器客户端”代码和其他将服务器连接到客户端的代码，但问题是，客户端如何找到服务器？

这就是我想要做的：
1.服务器监听特定端口，例如：3000端口。
2. 客户端应向该端口发送一条消息或不同的 IP 号（192.168.1.0-255）。
3. 当消息或 IP 与服务器正在侦听的内容正确时，服务器应将其 IP 发送回客户端。

换句话说，我们不会在服务器端硬编码任何IP，每次服务器重启时IP都会改变等等，所以程序应该让客户端将IP发送到一个端口，直到IP无论服务器是什么IP都是正确的，然后连接两者。

这是我编写并尝试过的一些代码，但这不是我想要做的。 如果你有一些网站、教程、地方可以看，请告诉我，我不需要任何完成的代码，只是想了解客户端如何找到服务器 b 发送 IP 直到它连接。

这也是我一直在查看的链接，但还没有找到我想要做的事情。 http://cs.lmu.edu/~ray/notes/javanetexamples/

你这么多。

服务器：

public class SocketServer {

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

    SocketClient ip = new SocketClient();

    System.out.println("Server started.");
    ServerSocket ss = new ServerSocket(3000);
    System.out.println("Server is waiting for client...");
    Socket s = ss.accept();

    System.out.println("Client connected.");
    ip.getIpNumber();

    BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
    String str = br.readLine();

    System.out.println("Client sent: " + str);

}
}

客户：

public class SocketClient {

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

    String ip = "localhost";
    int port = 3000;
    Socket s = new Socket(ip, port);
    Scanner scn = new Scanner(System.in);
    System.out.println("Send message to server...");
    String str = scn.next();

    OutputStreamWriter os = new OutputStreamWriter(s.getOutputStream());
    PrintWriter out = new PrintWriter(os);
    out.println(str);
    out.flush();
}

public void getIpNumber() {

    try {
        String ip = InetAddress.getLocalHost().getHostAddress();
        System.out.println("Clients ip number is: " + ip);

    } catch (UnknownHostException e) {
        System.out.println("UnknownHostException");
        e.printStackTrace();
    }
}
}

编辑 1： 我确实创建了 MultiCast Sender & Receiver，这是代码。

多播发送者：

public class MulticastSender {

public static void main(String[] args) {

    try {
        InetAddress group = InetAddress.getByName("224.0.0.1");
        MulticastSocket multicastSocket = new MulticastSocket();
        String ipMessage = "Multimessage";
        DatagramPacket datagramPacket = new DatagramPacket(ipMessage.getBytes(), ipMessage.length(), group, 3000);
        multicastSocket.send(datagramPacket);
        multicastSocket.close();


    } catch (UnknownHostException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

组播接收器：

    public static void main(String[] args) {

        try {
        InetAddress group = InetAddress.getByName("224.0.0.1");
        MulticastSocket multicastSocket = new MulticastSocket(3000);
        multicastSocket.joinGroup(group);
        byte[] buffer = new byte[100];
        DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);
        multicastSocket.receive(datagramPacket);
        System.out.println(new String(buffer));
        multicastSocket.close();


    } catch (UnknownHostException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

编辑 2：

在 Ipper 的帮助和 Michiel De Mey 网站的链接的帮助下，这是我从中获取的内容并且它有效，但如果我以错误的方式或其他方式进行了编辑，请告诉我。

服务器：

public class Server implements Runnable {

DatagramSocket socket;

public static void main(String[] args) {

    Thread discoveryThread = new Thread(Server.getInstance());
    discoveryThread.start();
}

@Override
public void run() {

    try {

        //Keep a socket open to listen to all the UDP traffic that is destined for this port
        socket = new DatagramSocket(3000, InetAddress.getByName("0.0.0.0"));
        socket.setBroadcast(true);

        while (true) {
            System.out.println(getClass().getName() + ": Ready to receive broadcast packets!");

            //Receive a packet
            byte[] recvBuf = new byte[15000];
            DatagramPacket packet = new DatagramPacket(recvBuf, recvBuf.length);
            socket.receive(packet);

            //Packet received
            System.out.println(getClass().getName() + ": Discovery packet received from: " + packet.getAddress().getHostAddress());
            System.out.println(getClass().getName() + ": Packet received; data: " + new String(packet.getData()));

            //See if the packet holds the right command (message)
            String message = new String(packet.getData()).trim();
            if (message.equals("DISCOVER_FUIFSERVER_REQUEST")) {
                byte[] sendData = "DISCOVER_FUIFSERVER_RESPONSE".getBytes();

                //Send a response
                DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, packet.getAddress(), packet.getPort());
                socket.send(sendPacket);

                System.out.println(getClass().getName() + ": Sent packet to: " + sendPacket.getAddress().getHostAddress());
            }
        }
    } catch (IOException ex) {
        Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
    }
}

public static Server getInstance() {
    return DiscoveryThreadHolder.INSTANCE;
}

private static class DiscoveryThreadHolder {

    private static final Server INSTANCE = new Server();
}
}

客户：

public class Client {

public static void main(String[] args) {

    Client client = new Client();
    client.connect();

}

public void connect() {

    try {
        DatagramSocket c;
        c = new DatagramSocket();
        c.setBroadcast(true);
        byte[] sendData = "DISCOVER_FUIFSERVER_REQUEST".getBytes();

        try {

            byte[] buf = new byte[256];
            InetAddress ip = InetAddress.getByName("255.255.255.255");
            DatagramPacket packet = new DatagramPacket(sendData, sendData.length, ip, 3000);
            c.send(packet);
            System.out.println(getClass().getName() + ": Request packet sent to: 255.255.255.255 (DEFAULT)");

        } catch (IOException e) {
            e.printStackTrace();

        }

        // Broadcast the message over all the network interfaces
        Enumeration interfaces = NetworkInterface.getNetworkInterfaces();
        while (interfaces.hasMoreElements()) {
            NetworkInterface networkInterface = (NetworkInterface) interfaces.nextElement();

            if (networkInterface.isLoopback() || !networkInterface.isUp()) {
                continue; // Don't want to broadcast to the loopback interface
            }

            for (InterfaceAddress interfaceAddress : networkInterface.getInterfaceAddresses()) {
                InetAddress broadcast = interfaceAddress.getBroadcast();
                if (broadcast == null) {
                    continue;
                }

                // Send the broadcast package!
                try {
                    DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, broadcast, 3000);
                    c.send(sendPacket);

                } catch (Exception e) {

                }

                System.out.println(getClass().getName() + ": Request packet sent to: " + broadcast.getHostAddress());
            }
        }

        System.out.println(getClass().getName() + ": Done looping over all network interfaces. Now waiting for a reply!");

        //Wait for a response
        byte[] recvBuf = new byte[15000];
        DatagramPacket receivePacket = new DatagramPacket(recvBuf, recvBuf.length);
        c.receive(receivePacket);

        //We have a response
        System.out.println(getClass().getName() + ": Broadcast response from server: " + receivePacket.getAddress().getHostAddress());

        //Check if the message is correct
        String message = new String(receivePacket.getData()).trim();
        if (message.equals("DISCOVER_FUIFSERVER_RESPONSE")) {
            //DO SOMETHING WITH THE SERVER'S IP (for example, store it in your controller)
            System.out.println("Server's IP: " + receivePacket.getAddress());
        }

        //Close the port!
        c.close();
    } catch (IOException ex) {

    }
}
}

Answer 1

这个例子应该提供你所需要的（如果你想自己写代码）：

http://michieldemey.be/blog/network-discovery-using-udp-broadcast/

您可能还想考虑使用诸如

之类的库

• https://github.com/jmdns/jmdns
• http://jslp.sourceforge.net/jSLP/userguide.html