0

私はソケットに非常に慣れていないので、誰かが私を助けてくれることを望んでいました. 何かが機能していましたが、情報を非常に迅速に送信していなかったので、リファクタリングしましたが、機能するものに戻ることができません。client = listener.accept();問題は、発行された最初のメッセージのみが読み取られ、送信者がまだメッセージを送信していると確信しているにもかかわらず、受信者が座っていることです。

ここで私が間違っているかもしれないことを誰でも見ることができますか?

ありがとう

  public class Sender {
        Socket server = null;
        DataInputStream inp = null;
        PrintStream outp = null;

        public Sender(){
            server = new Socket("127.0.0.1" , 3456);
            outp = new PrintStream(server.getOutputStream());
        }

        private void connectAndSendToServer(String message)  {
            outp = new PrintStream(server.getOutputStream());
            outp.print(message + "\n");
            outp.flush();

        }
    }

受信者クラス

public class Receive{


    public String receiveMessage(int port) {
        String message= null;
        ServerSocket listener = null;
        Socket client = null;
        try{
            listener = new ServerSocket(port);
            client = listener.accept();         
            BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
            return br.readLine();

        }
        ...
        finally{
            try {
                if(client!=null && listener!=null){
                    client.close();
                    listener.close();
                }
            } 
            catch (IOException e) {

            }
        }
        return message;
    }
}
4

3 に答える 3

2

これは、aServerSocketが通常の Socket のエントリ ポイントとして使用されるためです。accept()は、データを通常の に送受信するスレッドとは異なるスレッドで通常行われるブロッキング操作ですSocket。そこに座って、新しい接続が新しい接続を生成するのを待ちます。新しい接続Socketは、データに使用されます。

これは、メッセージを受信して​​いる間は、特定のソケットから読み取るために readLine() だけを呼び出す必要があることを意味します。acceptそれが別の操作であり、ブロックしているという理由だけで、 を内部に持つことreceiveMessageは間違っています。

Socket socket = serverSocket.accept();

ClientThread thread = new ClientThread(socket);

class ClientThread extends Thread {
  Socket socket;

  public void run() {
    while (!closed) {
      String line = reader.readLine();
      ...
    }
  }

ただし、すべてのクライアントにスレッドを用意する必要はありませんが、サーバーに複数の接続を受け入れさせたい場合は、確実に少なくとも 2 つ必要です。

于 2012-11-10T11:55:10.143 に答える
2

ServerSocket を正しく使用していません。メッセージごとに新しいインスタンスを作成するのではなく、それをデータ メンバーとして使用し、無限ループを実行して新しいクライアント ソケット接続を取得する必要があります。ローカルで作成するため、メソッドから戻ると、オブジェクトが使用および参照されなくなるため (したがって GC が実行されるため)、ソケットは閉じられます。
次のようなもの (< condition met > は疑似コードで、新しい接続を受け入れる条件を定義します):

while(< condition met >) {
    try {
        client = listener.accept();
        BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
        String str = br.readLine();
        //do something with str
    } finally {
        //close client socket
    }    
}

より良いアプローチは、別のスレッドでクライアント ソケットを処理することです。これにより、メイン スレッドが受け入れられるようになり、同時にクライアント ソケットで何でも実行できるようになります。

于 2012-11-10T11:56:41.260 に答える
0

私が書いたこの基本的なチャットサーバーを試してみてください。このサーバーは単にループで実行を続け、クライアントから送信されたメッセージをこのサーバーに関連付けられている他のすべてのクライアントにブロードキャストします。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class Server {

    // ///----------------------------------------Instance Variable Fields
    ServerSocket ss = null;
    Socket incoming = null;

    // ///----------------------------------------Instance Variable Fields

    // ///---------------------------------------- static Variable Fields
    public static ArrayList<Socket> socList = new ArrayList<Socket>();

    // ///---------------------------------------- static Variable Fields

    public void go() {

        try {

            ss = new ServerSocket(25005);

            while (true) {

                incoming = ss.accept();
                socList.add(incoming);
                System.out.println("Incoming: " + incoming);
                new Thread(new ClientHandleKaro(incoming)).start();

            }

        } catch (IOException e) {

            e.printStackTrace();
        } finally {

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

    }

    class ClientHandleKaro implements Runnable {

        InputStream is = null;
        OutputStream os = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        PrintWriter pw = null;
        boolean isDone = false;

        Socket sInThread = null;

        public ClientHandleKaro(Socket sxxx) {

            this.sInThread = sxxx;

        }

        @Override
        public void run() {

            if (sInThread.isConnected()) {

                System.out.println("Welcamu Clienta");
                System.out.println(socList);
            }

            try {
                is = sInThread.getInputStream();
                System.out.println("IS: " + is);
                isr = new InputStreamReader(is);
                br = new BufferedReader(isr);

                os = sInThread.getOutputStream();
                pw = new PrintWriter(os, true);

                String s = new String();

                while ((!isDone) && (s = br.readLine()) != null) {

                    String[] asx = s.split("-");
                    System.out.println("On Console: " + s);

                    // pw.println(s);

                    Thread tx = new Thread(new ReplyKaroToClient(s,
                            this.sInThread));
                    tx.start();

                    if (asx[1].trim().equalsIgnoreCase("BYE")) {

                        System.out.println("I am inside Bye");
                        isDone = true;

                    }
                }
            } catch (IOException e) {

                System.out.println("Thanks for Chatting.....");
            } finally {

                try {
                    Thread tiku = new Thread(new ByeByeKarDo(sInThread));
                    tiku.start();
                    try {
                        tiku.join();
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }

                    System.out.println("Accha to hum Chalte hain !!!");
                    System.out.println(socList);

                    br.close();
                    pw.close();
                    sInThread.close();

                } catch (IOException e) {

                }
            }

        }

    }

    class ReplyKaroToClient implements Runnable {

        public String mString;
        public Socket mSocket;

        public ReplyKaroToClient(String s, Socket sIn) {

            this.mString = s;
            this.mSocket = sIn;
        }

        @Override
        public void run() {

            for (Socket sRaW : socList) {

                if (mSocket.equals(sRaW)) {
                    System.out.println("Mai same hun");
                    continue;

                } else {
                    try {
                        new PrintWriter(sRaW.getOutputStream(), true)
                                .println(mString);
                    } catch (IOException e) {

                        System.out.println("Its in Catch");

                    }
                }
            }

        }

    }

    class ByeByeKarDo implements Runnable {

        Socket inCom;

        public ByeByeKarDo(Socket si) {

            this.inCom = si;
        }

        @Override
        public void run() {

            try {
                new PrintWriter(inCom.getOutputStream(), true)
                        .println("You have Logged Out of Server... Thanks for your Visit");
            } catch (IOException e) {

                e.printStackTrace();
            }

        }

    }

    public static void main(String[] args) {

        new Server().go();
    }
}
于 2012-11-10T12:39:18.047 に答える