java - 在同一 Activity 中通过套接字发送和接收数据

Question

我正在使用 TCP 套接字通过客户端服务器线程在同一个 Activity 中从同一个套接字发送和接收数据，其目的是向其他设备发送一个字符串，一旦另一个设备，该字符串将触发通知收到它然后该设备将重播类似关闭或接受的内容，我遇到的问题是在发送字符串后其他设备接收它并发送关闭或接受的字符串但我的设备没有收到该字符串我猜那里是我的 ServerThread 中的问题 请注意，服务器线程和客户端线程在用作内部类的同一 Activity 中，并在按钮中被调用。 代码:

客户端线程

private class ChatClientThread extends Thread {








          @Override
          public void run() {
           Socket socket = null;
           DataOutputStream dataOutputStream = null;




           try {

            socket = new Socket("192.168.0.113", 23);
            dataOutputStream = new DataOutputStream(
              socket.getOutputStream());



            dataOutputStream.writeUTF("  "+"SolveProblemOrder_2");
            dataOutputStream.flush();

            ServerThread serv =new ServerThread();
            serv.start();

           } catch (UnknownHostException e) {
            e.printStackTrace();
            final String eString = e.toString();
            TicketDetails.this.runOnUiThread(new Runnable() {

             @Override
             public void run() {
              Toast.makeText(TicketDetails.this, eString, Toast.LENGTH_LONG).show();
             }

            });
           } catch (IOException e) {
            e.printStackTrace();
            final String eString = e.toString();
            TicketDetails.this.runOnUiThread(new Runnable() {

             @Override
             public void run() {
              Toast.makeText(TicketDetails.this, eString, Toast.LENGTH_LONG).show();
             }

            });
           } finally {
            if (socket != null) {
             try {
              socket.close();
             } catch (IOException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
             }
            }

            if (dataOutputStream != null) {
             try {
              dataOutputStream.close();
             } catch (IOException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
             }
            }



            TicketDetails.this.runOnUiThread(new Runnable() {

             @Override
             public void run() {

             }

            });
           }

          }


         }

服务器线程

public class ServerThread extends Thread {

          private ServerSocket serverSocket;
          private Socket clientSocket;


          public void run(){

            try{
              // Open a server socket listening on port 23
              InetAddress addr = InetAddress.getByName(getLocalIpAddress());
              serverSocket = new ServerSocket(23, 0,addr);
              try{
              clientSocket = serverSocket.accept();
             DataInputStream dataInputStream = new DataInputStream(clientSocket.getInputStream());
             String newMsg = null;
             Toast.makeText(getApplicationContext(), newMsg, Toast.LENGTH_LONG).show();
              // Client established connection.
              // Create input and output streams
              while (true) {
                     if (dataInputStream.available() > 0) {
                      newMsg = dataInputStream.readUTF();
                              }

              }}catch(Exception e){
                     e.printStackTrace();
                 }
              // Perform cleanup



            } catch(Exception e) {
              // Omitting exception handling for clarity
            }
          }

          private String getLocalIpAddress() throws Exception {
            String resultIpv6 = "";
            String resultIpv4 = "";

              for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); 
                en.hasMoreElements();) {

                NetworkInterface intf = en.nextElement();
                for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); 
                    enumIpAddr.hasMoreElements();) {

                    InetAddress inetAddress = enumIpAddr.nextElement();
                    if(!inetAddress.isLoopbackAddress()){
                      if (inetAddress instanceof Inet4Address) {
                        resultIpv4 = inetAddress.getHostAddress().toString();
                        } else if (inetAddress instanceof Inet6Address) {
                          resultIpv6 = inetAddress.getHostAddress().toString();
                        }
                    }
                }
            }
            return ((resultIpv4.length() > 0) ? resultIpv4 : resultIpv6);
          }
        }

我在按钮点击监听器中启动这两个线程:

ChatClientThread chatClient=new ChatClientThread();
                        chatClient.start();
ServerThread serv =new ServerThread();
        serv.start();

如果在使用相同端口的同一 Activity 中使用服务器/客户端这不起作用，是否有任何其他方式来监听套接字，例如是否有内置监听器或类似的东西。 任何帮助表示赞赏

Answer 1

您通过 socket.getOutputStream() 写入套接字，您必须从 socket.getInputStream() 的 InputStream 读取； 您可以调整您的代码。 您的服务器使用来自套接字的 InputStream 来读取数据，因此您也必须在您的客户端代码中执行此操作，因为您不仅要发送还要接收数据。

检查这个只是阅读是非常简单的。

https://systembash.com/a-simple-java-tcp-server-and-tcp-client/

查看从套接字开始读取的代码:

BufferedReader inFromClient =
               new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));

和写入套接字的代码:

   DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());

或搜索 google : java client server 。

这个想法是你将数据发送到套接字输出流，你可以从同一个套接字输入流中读取它。

你在这里看到它从套接字输入读取数据并通过套接字输出将数据发送到服务器的示例

String sentence;
  String modifiedSentence;
  BufferedReader inFromUser = new BufferedReader( new InputStreamReader(System.in));
  Socket clientSocket = new Socket("localhost", 6789);
  DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
  BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
  sentence = inFromUser.readLine();
  outToServer.writeBytes(sentence + '\n');
  modifiedSentence = inFromServer.readLine();
  System.out.println("FROM SERVER: " + modifiedSentence);
  clientSocket.close();