Question

我正在尝试开发一个应用程序

1.客户端向服务器发送连接请求（IP地址+端口号）+使用“PrintStream”+ 发送数据尝试从服务器读取数据（使用输入流）

2.Client创建套接字。

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

4.SERVER在同一时间点3使用“PrintStream”写入数据。

问题出在第4点SERVER写的数据不是客户端的“INPUTSTREAM”读取的（第1点）我不知道这些同时操作是否可行。如果可能，那么如何。如果没有，那么替代方式是什么？

服务器代码

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读取客户端发送的数据。

客户端不发送任何数据。

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

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

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

1 个答案: