通过套接字在同一个 activity 中发送和接收数据

Question

我正在使用 TCP 套接字通过客户端服务器线程在同一个 activity 中的同一个套接字发送和接收数据，其目的是向其他设备发送一个字符串，该字符串将触发一旦另一台设备收到通知，该设备将重播类似 dismiss 或 accepted 的内容，我遇到的问题是在发送字符串后，另一台设备收到它并发送 dismiss 或 accepted String 但我的设备没有收到那个字符串我猜我的 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 中使用相同的端口使用 server/client 无法正常工作，是否有任何其他方式来侦听套接字，例如是否有内置侦听器或类似的东西. 感谢任何帮助

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客户端服务器。

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

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

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

通过套接字在同一个 activity 中发送和接收数据

sending and recieving data through sockets in the same activity

java

sockets

multithreading

android

tcp