7

我想发送多个随机值Socket。我认为数组是发送它们的最佳方式。但我不知道如何将数组写入 Socket OutputStream？

我的 Java 类：

导入 java.io.ByteArrayOutputStream；导入 java.io.IOException；导入 java.io.InputStream；导入 java.net.Socket；导入java.io.*；导入 java.util.Random；

public class NodeCommunicator {

    public static void main(String[] args) {
        try {
            Socket nodejs = new Socket("localhost", 8181);

            Random randomGenerator = new Random();
            for (int idx = 1; idx <= 1000; ++idx){
                Thread.sleep(500);
                int randomInt = randomGenerator.nextInt(35);
                sendMessage(nodejs, randomInt + " ");
                System.out.println(randomInt);
            }

            while(true){
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            System.out.println("Connection terminated..Closing Java Client");
            System.out.println("Error :- "+e);
        }
    }

    public static void sendMessage(Socket s, String message) throws IOException {
        s.getOutputStream().write(message.getBytes("UTF-8"));
        s.getOutputStream().flush();
    }

}
4

7 回答 7

8

使用 java.io.DataOutputStream / DataInputStream 对，他们知道如何读取整数。以长度 + 随机数的数据包形式发送信息。

发件人

Socket sock = new Socket("localhost", 8181);
DataOutputStream out = new DataOutputStream(sock.getOutputStream());
out.writeInt(len);
for(int i = 0; i < len; i++) {
      out.writeInt(randomGenerator.nextInt(35))
...

接收者

 DataInputStream in = new DataInputStream(sock.getInputStream());
 int len = in.readInt();
 for(int i = 0; i < len; i++) {
      int next = in.readInt();
 ...
于 2012-12-21T05:19:27.070 回答
4

Java 数组实际上是Objects 并且它们实现了Serializable接口。因此，您可以序列化您的数组，获取字节并通过套接字发送这些字节。这应该这样做：

public static void sendMessage(Socket s, int[] myMessageArray)
   throws IOException {
  ByteArrayOutputStream bs = new ByteArrayOutputStream();
  ObjectOutputStream os = new ObjectOutputStream(bs);
  os.writeObject(myMessageArray);
  byte[] messageArrayBytes = bs.toByteArray();
  s.getOutputStream().write(messageArrayBytes);
  s.getOutputStream().flush();
}

真正巧妙的是，它不仅适用于任何对象，int[]而且适用于任何Serializable对象。

编辑： 再想一想，这更简单：

发件人：

public static void sendMessage(Socket s, int[] myMessageArray)
   throws IOException {
  OutputStream os = s.getOutputStream();  
  ObjectOutputStream oos = new ObjectOutputStream(os);  
  oos.writeObject(myMessageArray); 
}

接收器：

public static int[] getMessage(Socket s)
   throws IOException {
  InputStream is = s.getInputStream();  
  ObjectInputStream ois = new ObjectInputStream(is);  
  int[] myMessageArray = (int[])ois.readObject(); 
  return myMessageArray;
}

我也留下我的第一个答案（它也可以工作并且）它对于将对象写入 UDPDatagramSockets和DatagramPackets没有流的地方很有用。

于 2012-12-21T05:41:21.633 回答
2

我建议int使用一些分隔符简单地连接字符串中的值，例如@@，然后立即传输最终连接的字符串。在接收端，只需使用相同的分隔符拆分字符串即可int[]返回，例如：

    Random randomGenerator = new Random();
    StringBuilder numToSend = new StringBuilder("");
    numToSend.append(randomGenerator.nextInt(35));

    for (int idx = 2; idx <= 1000; ++idx){
        Thread.sleep(500);
        numToSend.append("@@").append(randomGenerator.nextInt(35));
    }
    String numsString = numToSend.toString();
    System.out.println(numsString);
    sendMessage(nodejs, numsString);

在接收端，获取您的字符串并拆分为：

   Socket remotejs = new Socket("remotehost", 8181);
   BufferedReader in = new BufferedReader(
                               new InputStreamReader(remotejs.getInputStream()));
   String receivedNumString = in.readLine();
   String[] numstrings = receivedNumString.split("@@");
   int[] nums = new int[numstrings.length];
   int indx = 0;
   for(String numStr: numstrings){
     nums[indx++] = Integer.parseInt(numStr);
   }
于 2012-12-21T04:24:47.883 回答
1

好吧，流是字节流，因此您必须将数据编码为字节序列，并在接收端对其进行解码。如何写入数据取决于您要如何对其进行编码。

由于从 0 到 34 的数字适合单个字节，因此这可以很简单：

outputStream.write(randomNumber);

另一方面：

int randomNumber = inputStream.read();

当然，在每个字节之后刷新流并不是很有效（因为它会为每个字节生成一个网络数据包，并且每个网络数据包都包含数十个字节的标头和路由信息......）。如果性能很重要，您可能也需要使用 BufferedOutputStream。

于 2012-12-21T04:48:22.393 回答
1

因此，您可以比较我编写的模板的替代格式，该模板允许您使用您希望使用的任何格式，或者比较替代方案。

abstract class DataSocket implements Closeable {
    private final Socket socket;
    protected final DataOutputStream out;
    protected final DataInputStream in;

    DataSocket(Socket socket) throws IOException {
        this.socket = socket;
        out = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
        in = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
    }

    public void writeInts(int[] ints) throws IOException {
        writeInt(ints.length);
        for (int i : ints)
            writeInt(i);
        endOfBlock();
    }

    protected abstract void writeInt(int i) throws IOException;

    protected abstract void endOfBlock() throws IOException;

    public int[] readInts() throws IOException {
        nextBlock();
        int len = readInt();
        int[] ret = new int[len];
        for (int i = 0; i < len; i++)
            ret[i] = readInt();
        return ret;
    }

    protected abstract void nextBlock() throws IOException;

    protected abstract int readInt() throws IOException;

    public void close() throws IOException {
        out.close();
        in.close();
        socket.close();
    }
}

二进制格式，4 字节整数

class BinaryDataSocket extends DataSocket {
    BinaryDataSocket(Socket socket) throws IOException {
        super(socket);
    }

    @Override
    protected void writeInt(int i) throws IOException {
        out.writeInt(i);
    }

    @Override
    protected void endOfBlock() throws IOException {
        out.flush();
    }

    @Override
    protected void nextBlock() {
        // nothing
    }

    @Override
    protected int readInt() throws IOException {
        return in.readInt();
    }
}

停止位编码的二进制，每 7 位一个字节。

class CompactBinaryDataSocket extends DataSocket {
    CompactBinaryDataSocket(Socket socket) throws IOException {
        super(socket);
    }

    @Override
    protected void writeInt(int i) throws IOException {
        // uses one byte per 7 bit set.
        long l = i & 0xFFFFFFFFL;
        while (l >= 0x80) {
            out.write((int) (l | 0x80));
            l >>>= 7;
        }
        out.write((int) l);
    }

    @Override
    protected void endOfBlock() throws IOException {
        out.flush();
    }

    @Override
    protected void nextBlock() {
        // nothing
    }

    @Override
    protected int readInt() throws IOException {
        long l = 0;
        int b, count = 0;
        while ((b = in.read()) >= 0x80) {
            l |= (b & 0x7f) << 7 * count++;
        }
        if (b < 0) throw new EOFException();
        l |= b << 7 * count;
        return (int) l;
    }
}

最后用新行编码的文本。

class TextDataSocket extends DataSocket {
    TextDataSocket(Socket socket) throws IOException {
        super(socket);
    }

    private boolean outBlock = false;

    @Override
    protected void writeInt(int i) throws IOException {
        if (outBlock) out.write(' ');
        out.write(Integer.toString(i).getBytes());
        outBlock = true;
    }

    @Override
    protected void endOfBlock() throws IOException {
        out.write('\n');
        out.flush();
        outBlock = false;
    }

    private Scanner inLine = null;

    @Override
    protected void nextBlock() throws IOException {
        inLine = new Scanner(in.readLine());
    }

    @Override
    protected int readInt() throws IOException {
        return inLine.nextInt();
    }
}
于 2012-12-21T09:40:30.183 回答
0

如果您想向套接字发送多个随机值，请选择一种简单的格式并让双方都同意（发送方和接收方），例如，您可以简单地选择一个分隔符;并创建一个包含所有值的字符串然后发送

于 2012-12-21T04:27:56.917 回答
0

Android Socket SERVER 示例修改为接收整数数组而不是字符串：

...
class CommunicationThread implements Runnable {

    private ObjectInputStream input;

    public CommunicationThread(Socket clientSocket) {

        try {

            this.input = new ObjectInputStream(clientSocket.getInputStream());

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void run() {

        while (!Thread.currentThread().isInterrupted()) {

            try {

                int[] myMessageArray = (int[]) input.readObject();

                String read = null;
                read = String.format("%05X", myMessageArray[0] & 0x0FFFFF);
                int i = 1;
                do {
                    read = read + ", " + String.format("%05X", myMessageArray[i] & 0x0FFFFF);
                    i++;
                } while (i < myMessageArray.length);
                read = read + " (" + myMessageArray.length + " bytes)";

                updateConversationHandler.post(new updateUIThread(read));

            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
}
...
于 2014-12-21T18:22:06.460 回答