将字节流从服务器端java中的套接字转换为字符串

Question

我将一个对象序列化为字节并发送到服务器端。 在服务器端我得到了字节流，但我想打印我从服务器得到的对象/字符串，以验证我得到了它

服务器端：

    CarServerSocket = new ServerSocket(4441);
    System.out.println("Server is ready and waiting for connection from client..\n");
    try {
        while (true) {
            carSocket = CarServerSocket.accept();
            System.out.println("Server Connected");         
            final DataInputStream bytesIR  = new DataInputStream(carSocket.getInputStream());
            bytesIRLength = bytesIR.readInt();  
                while (bytesIRLength > 0) { 
                    byte[] messageIn = new byte[bytesIRLength];
                    bytesIR.readFully(messageIn,0,messageIn.length);
                    bytesIR.readUTF();

                }
            }
    }catch(EOFException e ){
            System.out.println("\ngot all objects from client.\ndisconnecting server...");              
            CarServerSocket.close();
            carSocket.close();
        }
    }

客户端 - 序列化

objectOut.writeObject(CarList[i]); // converting object to bytes.
        objectOut.flush();
        objectInBytes = byteOut.toByteArray();
        System.out.println("Sending car object #"+i);
        dOut.writeInt(objectInBytes.length); // getting object bytes size.
        dOut.write(objectInBytes); // sending object in bytes.  

我厌倦了使用：toString()、readUTF()...但没有运气。

任何人都可以请建议我如何解决它？

谢谢你。

Answer 1

您可以尝试使用某种 InputStreamReader 从 InputStream 读取数据，如下所示：

    CarServerSocket = new ServerSocket(4441);
    System.out.println("Server is ready and waiting for connection from client..\n");
    try {
        while (true) {
            carSocket = CarServerSocket.accept();
            System.out.println("Server Connected"); 
            StringBuilder yourData = new StringBuilder();
            new BufferedReader(new InputStreamReader(carSocket.getInputStream()))
                .lines().forEach(stringBuilder::append);
            System.out.println(yourData.toString());
    }catch(EOFException e ){
            System.out.println("\ngot all objects from client.\ndisconnecting server...");              
            CarServerSocket.close();
            carSocket.close();
        }
    }

Answer 2

您需要使用ObjectInputStream来反序列化对象。 好的，所以您的对象完全包含在您已经收到的数据报中。 您只需要将数据缓冲区转换为ObjectInputStream 。 从臀部编码，这将类似于......

try( ByteArrayInputStream bais = new ByteArrayInputStream(messageIn);
        ObjectInputStream ois = new ObjectInputStream(bais)) {
    Object o = ois.readObject();
}

---

编辑：这是一些显示此工作的完整代码。

public class ByteStream {

    public static void main(String[] args) throws IOException {
        Server server = new Server(4441);
        new Thread(server).start();

        Client client = new Client(4441);
        new Thread(client).start();
    }
}

class Client implements Runnable {

    private final Socket socket;

    Client(int port) throws UnknownHostException, IOException {
        socket = new Socket("localhost", port);
    }

    @Override
    public void run() {
        MyObject send = new MyObject();
        send.x = 10;
        send.msg = "X = ";

        try {
            try (DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    ObjectOutputStream oos = new ObjectOutputStream(baos)) {

                oos.writeObject(send);
                oos.flush();
                byte[] objectInBytes = baos.toByteArray();
                int length = objectInBytes.length;
                System.out.println("Client: sending 'objectInBytes' length = " + length);
                dos.writeInt(length);
                dos.write(objectInBytes);
            } finally {
                socket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Server implements Runnable {
    private final ServerSocket serverSocket;

    Server(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    @Override
    public void run() {
        try {
            try (Socket socket = serverSocket.accept();
                    DataInputStream bytesIR = new DataInputStream(socket.getInputStream())) {
                int length = bytesIR.readInt();
                byte[] messageIn = new byte[length];
                bytesIR.readFully(messageIn);
                System.out.println("Server: got datagram length = " + length);
                process(messageIn);
            } finally {
                serverSocket.close();
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    private void process(byte[] messageIn) throws IOException, ClassNotFoundException {
        try (ByteArrayInputStream bais = new ByteArrayInputStream(messageIn);
                ObjectInputStream ois = new ObjectInputStream(bais)) {
            Object o = ois.readObject();
            System.out.println(o.getClass() + ": " + o);
        }
    }
}

class MyObject implements Serializable {
    private static final long serialVersionUID = -1478875967217194114L;
    double x;
    String msg;
    public String toString() { return msg + x; }
}

和输出：

Client: sending 'objectInBytes' length = 75
Server: got datagram length = 75
class MyObject: X = 10.0

Answer 3

objectOut.writeObject(CarList[i]); // converting object to bytes.
objectOut.flush();
objectInBytes = byteOut.toByteArray();
System.out.println("Sending car object #"+i);
dOut.writeInt(objectInBytes.length); // getting object bytes size.
dOut.write(objectInBytes); // sending object in bytes. 

这一切都是毫无意义的。 它只是浪费时间和空间。 只需将ObjectOutputStream.writeObject()直接用于发送方的套接字，并直接从接收方的套接字使用ObjectInputStream.readObject() 。