无法读取数据（由服务器发送）在客户端

Question

我试图发展其

1.client发送请求到服务器的连接（IP地址+端口号）+使用“发送数据的应用程序PrintStream“+ 尝试从服务器读取数据（使用输入流）

2.Client创建套接字。

3.Server读取数据通过客户端发送

4.SERVER使用“的PrintStream”在同一时间点没有3

问题是在点写4个数据由服务器写入的未读通过客户端（点1）的“INPUTSTREAM” 我不知道这些同时操作是否可能。如果可能，那么如何。如果不是那么替代方式是什么？

服务器代码

package com.example.loneranger.ser; 


import android.app.Activity; 
import android.os.Bundle; 
import android.widget.TextView; 

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.InputStreamReader; 
import java.io.PrintWriter; 
import java.net.InetAddress; 
import java.net.NetworkInterface; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.net.SocketException; 
import java.util.Enumeration; 

public class MainActivity extends Activity { 


    TextView ip; 
    TextView msg; 
    String data = ""; 

    ServerSocket httpServerSocket; 

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


     ip = (TextView) findViewById(R.id.infoip); 
     msg = (TextView) findViewById(R.id.msg); 

     ip.setText(getIpAddress() + ":" 
       + 8080 + "\n"); 

     Server server = new Server(); 
     server.start(); 
    } 

    @Override 
    protected void onDestroy() { 
     super.onDestroy(); 

     if (httpServerSocket != null) { 
      try { 
       httpServerSocket.close(); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
     } 
    } 

    private String getIpAddress() { 
     String ip = ""; 
     try { 
      Enumeration<NetworkInterface> enumNetworkInterfaces = NetworkInterface 
        .getNetworkInterfaces(); 
      while (enumNetworkInterfaces.hasMoreElements()) { 
       NetworkInterface networkInterface = enumNetworkInterfaces 
         .nextElement(); 
       Enumeration<InetAddress> enumInetAddress = networkInterface 
         .getInetAddresses(); 
       while (enumInetAddress.hasMoreElements()) { 
        InetAddress inetAddress = enumInetAddress.nextElement(); 

        if (inetAddress.isSiteLocalAddress()) { 
         ip += "IP: " 
           + inetAddress.getHostAddress() + "\n"; 
        } 

       } 

      } 

     } catch (SocketException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
      ip += "Something Wrong! " + e.toString() + "\n"; 
     } 

     return ip; 
    } 

    private class Server extends Thread { 


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

      try { 
       httpServerSocket = new ServerSocket(8888); 

       while(true){ 
        socket = httpServerSocket.accept(); 

        HttpResponseThread httpResponseThread = 
          new HttpResponseThread(
            socket); 
        httpResponseThread.start(); 
       } 
      } catch (IOException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } 

     } 


    } 

    private class HttpResponseThread extends Thread { 

     Socket socket; 

     HttpResponseThread(Socket socket){ 
      this.socket = socket; 

     } 

     @Override 
     public void run() { 
      BufferedReader BReader; 
      PrintWriter printer; 
      String request; 


      try { InputStream inputStream = socket.getInputStream(); 
       BReader = new BufferedReader(new InputStreamReader(inputStream)); 
       request = BReader.readLine(); 
Thread.sleep(500); 
       printer = new PrintWriter(socket.getOutputStream(), true); 


       printer.print("hello laundu"); 
       printer.flush(); 
       String ip123=socket.getInetAddress().toString(); 
       printer.close(); 

       BReader.close(); 

       socket.close(); 


       data += "Request of " + request 
         + " from "+ ip123 + "\n"; 
       MainActivity.this.runOnUiThread(new Runnable() { 

        @Override 
        public void run() { 

         msg.setText(data); 
        } 
       }); 

      } catch (IOException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 

      return; 
     } 
    } 

} 

客户端代码

mport android.os.AsyncTask; 
import android.widget.TextView; 

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.ByteArrayOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.io.OutputStreamWriter; 
import java.io.PrintWriter; 
import java.io.UnsupportedEncodingException; 
import java.net.Socket; 
import java.net.UnknownHostException; 

public class Client extends AsyncTask<Void, Void, Void> { 

    String dstAddress; 
    int dstPort; 
    String response = ""; 
    TextView textResponse; 
    MainActivity activity; 
    OutputStream outputStream; 
    BufferedReader BReader; 
    String request; 

    Client(String addr, int port, TextView textResponse) { 
     dstAddress = addr; 
     dstPort = port; 
     this.textResponse=textResponse; 
     this.activity=activity; 
    } 

    @Override 
    protected Void doInBackground(Void... arg0) { 

     Socket socket = null; 

     try { 
      socket = new Socket(dstAddress, dstPort); 
      Server server = new Server(socket); 
      server.start(); 

      PrintWriter out = new PrintWriter(new BufferedWriter(

        new OutputStreamWriter(socket.getOutputStream())), 

        true); 

      out.print("futfujb"); 
      out.flush(); 




      /* 
      * notice: inputStream.read() will block if no data return 
      */ 


     } catch (UnknownHostException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
      response = "UnknownHostException: " + e.toString(); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
      response = "IOException: " + e.toString(); 
     } /*finally { 
      if (socket != null) { 
       try { 

       } catch (IOException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
       } 
      } 
     }*/ 
     return null; 
    } 

    @Override 
    protected void onPostExecute(Void result) { 
     textResponse.setText(response); 
     super.onPostExecute(result); 
    } 
    private class Server extends Thread { 
     Socket socket; 
     Server(Socket socket) 
     { 
      this.socket=socket; 
     } 
     @Override 
     public void run() { 

       try { //Thread.sleep(500); 

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(
          1024); 
        byte[] buffer = new byte[1024]; 

        int bytesRead; 
        InputStream inputStream = socket.getInputStream(); 

        if(inputStream.available()>0) 
        { 
         while ((bytesRead = inputStream.read(buffer)) != -1) { 
          byteArrayOutputStream.write(buffer, 0, bytesRead); 
          response += byteArrayOutputStream.toString("UTF-8"); 
         } 
        } 

        inputStream.close(); 
        socket.close(); 
      } 
      catch (UnsupportedEncodingException e) { 
        e.printStackTrace(); 
       } catch (IOException e) { 
        e.printStackTrace(); 
       } 


     } 


    } 


} 

Answer 1

正如我上面的评论，有什么在此代码对应于以下步骤之一：

2.Server获取请求创建新的SOCKET连接。

（a）没有请求，（b）服务器不创建新的连接。客户创建它。服务器接受它。

3.Server读取客户端发送的数据。

客户端不发送任何数据。

有两个问题在这里（至少）：

1. 服务器阻断readLine()等待消息，客户端永远不会发送。所以它永远不会自己发送，所以客户端没有收到任何东西。根据评论，让客户发送请求。
2. 客户端错误地使用available()。删除这个测试并让客户端进入读取循环。它将在对等体（服务器）关闭连接时退出。