通过 XML（Java、TCP）进行客户端-服务器通信

Question

i have written a client - server programm, where different clients and server communicate via request/reply using xml and tcp sockets. Later i want to add udp sockets. This is the current code:

Client:

package network.client;
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

public class Client implements Closeable {
    private Socket socket;

    public Client(String host, int port) throws IOException {
        this(new Socket(host, port));
    }

    public Client(Socket s) {
        this.socket = s;
    }

    @Override
    public void close() throws IOException {
        this.socket.close();
    }

    public void send(String msg) throws IOException {

        OutputStream out=this.socket.getOutputStream();
        out.write(msg.getBytes());
        out.flush();
        socket.shutdownOutput();

    }

    public void recv() {
        try {
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            String request="";
            String temp=in.readLine();
            while(temp!=null) {
               request+=temp;
               temp=in.readLine();
            }
            socket.shutdownInput();
            
            System.out.println("Client: " + request);
            System.out.println(request.toString().length());
        } catch (IOException ex) {
            System.err.println("Error: Unable to read server response\n\t" + ex);
        }        
    }

    public static void main(String[] args) {
        // Make sure command line arguments are valid
        String ip="127.0.0.1";
        int port=5000;

        StringBuilder sb = new StringBuilder();
       
        sb.append("stuff");
        System.out.println(sb.toString().length());
        try (Client c = new Client(ip, port)) {
            c.send(sb.toString());
            c.recv();
            c.close();
            
        } catch (IOException ex) {
            System.err.println("Error: " + ex);
        }
    }
}

Server:

package network.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Server {

    private static ServerSocket serversocket;
    private static ExecutorService threadpool;
    private String ip;
    private int port;

    public static void main(final String[] args) {

        Server2 server;
        String ip = "127.0.0.1";
        int port = 5000;

        try {
            server = new Server(ip, port);
            
            while (true) {
                Runnable requestHandler = null;
                try {
                    requestHandler = new TCPRequestHandler(serversocket.accept());

                } catch (IOException io) {
                    System.out.println("Accepting client connection failed");
                    io.printStackTrace();
                }
                threadpool.submit(requestHandler);
            }
            
        } catch (IOException io) {
            System.out.println(io.getMessage());
            io.printStackTrace();
        }
        System.out.println("end");

    }

    public Server(String ip, int port) throws IOException {
        this.ip = ip;
        this.port = port;
        try {
            this.serversocket = new ServerSocket();
            serversocket.bind(new InetSocketAddress(ip, port));
        } catch (IOException io) {
            throw new IOException("Creating the ServerSocket failed");
        }
        
        System.out.println("Binding the server succeeded");

        this.threadpool = Executors.newCachedThreadPool();
    }
}

RequestHandler:

public class TCPRequestHandler extends Thread{
    private Socket clientSocket=null;
    
    public TCPRequestHandler(Socket clientSocket) {
        this.clientSocket=clientSocket;
    }       
    
    public void run(){
        System.out.println("Accepted client connection (" + clientSocket.getInetAddress().getHostAddress() + ", " + clientSocket.getPort() + ")");
        byte[] buffer = new byte[1024];
        int count;
            try {
                BufferedReader in =new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                OutputStream out = clientSocket.getOutputStream();
                
                String request="";
                String temp=in.readLine();
                while(temp!=null) {
                   request+=temp;
                   temp=in.readLine();
                }
                System.out.println("Server:" + request);
                System.out.println(request.toString().length());
                // do stuff with xml request
               
                out.write(request.getBytes());
                out.flush();
                
                clientSocket.shutdownInput();
                clientSocket.shutdownOutput();
            } catch (IOException io) {
                System.err.println("IO initialization failed");
            }
    }
}

XML Request:

<Request>
  <Info Attribute1="" Attribute2=""></Info>
  <Info Attribute1="" Attribute2=""></Info>
</Request>

XML Reply (the overhead sending back the attributes will be necessary for the client, so i have to send it twice):

<Reply>
  <Info Attribute1="" Attribute2="">GoodReply</Info>
  <Info Attribute1="" Attribute2="">GoodReply</Info>
</Reply>

My question is 2-folded:

1.) Maybe I did something unusual at the client-server programming (forgetting to close something, unusual stream reading/handling). Reading every line of the client/server message seems to be eg weird for me, because i'd rather read the xml message until it is finished independently of its line). Feel free to provide me "good coding style" advice:-)

2.) At the moment i would assemble the XML by a StringBuilder and send just the bytes of the whole String and without special characters like \r \n. I'm not sure how to do it with a common api like Stax (this seemed to be complicated). Parsing the Attributes and their content will be necessary for the application. Is there an easier/more common way to solve this? If not: how to do it with eg Stax?

Answer 1

Good question!

Since TCP is a streaming protocol, you don't really know where the message begins and where it ends, unless you specify that each connect/disconnect contains exactly one message, or that you specify some delimiting mechanism (a framing protocol). Actually, it might be easier to start with UDP, since a datagram could contain the entire message in itself.

As for the framing protocol, an example is the Using the NETCONF Protocol over Secure Shell specification. You can of course devise your own framing.