3

我想通过 LAN 广播字符串，但是当我将客户端代码中的服务器 IP 更改为 255.255.255.255 时，它不会广播。我应该怎么做才能通过 LAN 广播字符串？我应该在客户端代码中做什么，以便不同 IP 的所有侦听端口可以同时接收字符串。

我的客户端或发送字符串的代码是：

public class MainActivity extends Activity {

    private Socket socket;
    private static final int SERVERPORT = 6000;
    private static final String SERVER_IP = "192.168.1.10";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);     

        new Thread(new ClientThread()).start();
    }

public void onClick(View view) {
        try {
            EditText et = (EditText) findViewById(R.id.EditText01);
            String str = et.getText().toString();
            PrintWriter out = new PrintWriter(new BufferedWriter(
                new OutputStreamWriter(socket.getOutputStream())), true);
            out.println(str);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    class ClientThread implements Runnable {

    @Override
        public void run() {
            try {
                InetAddress serverAddr = InetAddress.getByName(SERVER_IP);
                socket = new Socket(serverAddr, SERVERPORT);
            } catch (UnknownHostException e1) {
                e1.printStackTrace();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
}

我的服务器或接收字符串的代码是：

public class MainActivity extends Activity {
    private ServerSocket serverSocket;

    Handler updateConversationHandler;
    Thread serverThread = null;
    private TextView text;
    public static final int SERVERPORT = 6000;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text = (TextView) findViewById(R.id.text2);
        updateConversationHandler = new Handler();
        this.serverThread = new Thread(new ServerThread());
        this.serverThread.start();
    }

    @Override
    protected void onStop() {
        super.onStop();
        try {
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    class ServerThread implements Runnable {
        public void run() {
            Socket socket = null;
            try {
                serverSocket = new ServerSocket(SERVERPORT);
            } catch (IOException e) {
                e.printStackTrace();
            }
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    socket = serverSocket.accept();
                    CommunicationThread commThread = new CommunicationThread(socket);
                    new Thread(commThread).start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class CommunicationThread implements Runnable {

        private Socket clientSocket;
        private BufferedReader input;

        public CommunicationThread(Socket clientSocket) {
            this.clientSocket = clientSocket;
            try {
                this.input = new BufferedReader(new InputStreamReader(this.clientSocket.getInputStream()));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    String read = input.readLine();
                    updateConversationHandler.post(new updateUIThread(read));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class updateUIThread implements Runnable {

        private String msg;

        public updateUIThread(String str) {
            this.msg = str;
        }

        @Override
        public void run() {
            text.setText(text.getText().toString()+"Client Says: "+ msg + "\n");
        }
    }
}
4

1 回答 1

6

Socket是一个 TCP 套接字。使用 TCP 无法进行广播。如果要使用 TCP，则不能广播，必须为每个客户端打开一个连接，并分别通过每个连接发送数据。

DatagramSocket是一个 UDP 套接字。使用 UDP 可以进行广播。但是，需要注意的是，UDP 不能保证您的消息会真正到达。为了保证您的消息到达，您必须实现某种确认/重试协议，但如果您这样做，您最好使用 TCP，因为它就是这样做的。

编辑：另一个问题和我对下面评论的回答。OP写道：

那么我将如何获得局域网中监听设备的IP以便分别进行连接？

这里的主题是设备或服务发现，这是一个不常见的挑战。有很多选择。这里有一些，没有特别的顺序：

  1. 在客户端设备的配置中指定服务器 IP 地址并让它们连接到您。
  2. 在服务器设备的配置中指定客户端 IP 地址列表，并让它连接到所有这些地址。
  3. 实现某种 UDP 发现协议，通过 UDP 广播发现请求，设备以有关其 IP 地址等的信息进行响应。与上述相同的警告。
  4. 让您的服务器广播 UDP 消息来宣布其存在及其 IP 地址，让您的客户端监听这些消息并建立与服务器的 TCP 连接。与上述相同的警告。
  5. 查看现有的服务发现协议，例如jmdns.sourceforge.net（与 Bonjour/zeroconf 兼容）。这实际上是一个相当普遍的问题，并且存在许多协议来解决它。
  6. 让您的服务器扫描其子网中的所有 IP，并尝试与每个 IP 建立 TCP 连接。非常耗时，但可能是合适的。

选项 1-2 是最容易实现的，但需要用户手动配置。

选项 3-5 有一个共同的主题：通过使用 UDP 及其广播功能自动交换配置信息来避免手动配置要求。使用该信息建立 TCP 连接，然后使用 TCP 进行可靠的数据传输。请记住，UDP 广播的范围仅限于子网，因此您不能使用基于广播的发现来发现其他 LAN 上的机器——因为您必须使用基于 TCP 的注册进行某种中央服务注册，并且著名的注册服务器。

选项 6 以极差的发现性能和潜在的系统资源使用率高为代价来避免手动配置。选项 3-5 旨在优化发现过程。

于 2013-08-14T19:39:47.817 回答