Question

我的目标是创建一个服务器客户端程序，用于发送服务器的IP号码。让客户端连接到IP号码（服务器）像这样看，我有一个覆盆子pi，它是服务器，它的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＆amp;接收者，这是代码。

多播发件人：

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

Multicast Receiver：

    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/

您可能还想考虑使用

等库

从服务器向客户端发送IP。 Java网络

1 个答案: