Java环境下服务端与客户端通信标准相关技术疑问

Q1: 获取客户端可连接的服务端IP（无需外部服务方案） #

The problem with InetAddress.getLocalHost().getHostAddress() is that it usually returns the loopback address (127.0.0.1) or an internal LAN IP if your server has multiple network interfaces. To get the IP clients can actually connect to, you need to target the network interface used for external communication.

Here's a reliable way to do this without external services:

import java.net.*;
import java.util.Enumeration;

public class ServerIPResolver {
    public static String getClientReachableIP() throws SocketException {
        Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
        while (interfaces.hasMoreElements()) {
            NetworkInterface iface = interfaces.nextElement();
            // Skip loopback or inactive interfaces
            if (iface.isLoopback() || !iface.isUp()) continue;
            
            Enumeration<InetAddress> addresses = iface.getInetAddresses();
            while (addresses.hasMoreElements()) {
                InetAddress addr = addresses.nextElement();
                // Prioritize IPv4 non-link-local addresses
                if (addr instanceof Inet4Address && !addr.isLinkLocalAddress()) {
                    return addr.getHostAddress();
                }
            }
        }
        // Fallback to localhost if no valid IP found
        return "127.0.0.1";
    }

    public static void main(String[] args) throws SocketException {
        System.out.println("Server IP for clients: " + getClientReachableIP());
    }
}

Key Notes:

• This works if your server has a public IP directly assigned (e.g., cloud servers) or is on the same LAN as the client.
• If your server is behind a NAT (most home/office networks), this method returns the internal LAN IP, which isn't reachable from the internet. In that case, you can't get the public IP without external services—NAT hides the public address from the server itself.

Q2: 确定服务端兼容的输入输出流类型（以time.nist.gov:13为例） #

The correct stream type depends entirely on the server's protocol:

• ObjectOutputStream/ObjectInputStream are only for serialized Java objects (used in custom Java-to-Java services).
• OutputStreamWriter/InputStreamReader handle text-based protocols (ASCII, UTF-8, etc.), wrapping raw byte streams to manage character encoding.
• Raw OutputStream/InputStream are for binary protocols.

For time.nist.gov port 13, this uses the Daytime Protocol (RFC 868), which sends plain ASCII text. So ObjectOutputStream will fail—this service doesn't send serialized Java objects. Instead, use a raw InputStream wrapped in a BufferedReader to read the text.

Working example:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.Socket;

public class NistTimeClient {
    public static void main(String[] args) {
        try (Socket socket = new Socket("time.nist.gov", 13);
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
            
            String timeResponse = reader.readLine();
            System.out.println("NIST Time: " + timeResponse);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

How to confirm the stream type:

1. Manual testing: Use tools like telnet time.nist.gov 13 or nc time.nist.gov 13—you'll see a human-readable string, confirming it's a text protocol.
2. Check specs: Look up the service's RFC (e.g., RFC 868 for Daytime) to verify the data format.
3. Inspect raw bytes: If unsure, read raw bytes from the InputStream—text will be readable, while serialized Java objects have a distinct header (like AC ED 00 05).

For custom services, you'll need server-side documentation or reverse-engineer the data format by analyzing sent/received bytes.

内容的提问来源于stack exchange，提问作者Asghabard