Here are the most common and reliable ways to get hostnames and IP addresses in Java (Java 21). Pick the approach that matches your runtime (desktop app, server app, behind proxy, etc.).

1. Quick local host info
   • Good for simple cases, but can return 127.0.0.1 if your host isn’t configured in DNS/hosts.

   import java.net.InetAddress;
   
   public class LocalHostQuick {
       public static void main(String[] args) throws Exception {
           InetAddress local = InetAddress.getLocalHost();
           System.out.println("Host name: " + local.getHostName());
           System.out.println("Canonical host name: " + local.getCanonicalHostName());
           System.out.println("IP address: " + local.getHostAddress());
       }
   }
   

2. Robust way: list network interfaces
   • Picks non-loopback, non-virtual, up interfaces; prefers IPv4 but supports IPv6.

   import java.net.Inet4Address;
   import java.net.InetAddress;
   import java.net.NetworkInterface;
   import java.util.ArrayList;
   import java.util.Enumeration;
   import java.util.List;
   
   public class LocalAddresses {
       public static void main(String[] args) throws Exception {
           List<InetAddress> addresses = new ArrayList<>();
           for (Enumeration<NetworkInterface> ifaces = NetworkInterface.getNetworkInterfaces(); ifaces.hasMoreElements(); ) {
               NetworkInterface nif = ifaces.nextElement();
               if (!nif.isUp() || nif.isLoopback() || nif.isVirtual()) continue;
   
               for (Enumeration<InetAddress> addrs = nif.getInetAddresses(); addrs.hasMoreElements(); ) {
                   InetAddress addr = addrs.nextElement();
                   if (addr.isLoopbackAddress() || addr.isLinkLocalAddress()) continue; // skip 127.0.0.1, fe80::
                   addresses.add(addr);
               }
           }
   
           // Prefer IPv4 for display
           addresses.stream()
                    .sorted((a, b) -> Boolean.compare(b instanceof Inet4Address, a instanceof Inet4Address))
                    .forEach(a -> System.out.println(a.getHostAddress() + " (" + a.getHostName() + ")"));
       }
   }
   

3. DNS lookup: resolve a hostname to IPs
   • Useful to get IPs for a remote host or reverse lookup a specific IP.

   import java.net.InetAddress;
   
   public class ResolveHost {
       public static void main(String[] args) throws Exception {
           String host = "example.com"; // replace with your host
           InetAddress[] all = InetAddress.getAllByName(host);
           for (InetAddress inet : all) {
               System.out.println(host + " -> " + inet.getHostAddress());
           }
   
           // Reverse lookup of a specific IP
           InetAddress ip = InetAddress.getByName("203.0.113.10"); // placeholder IP
           System.out.println(ip.getHostAddress() + " reverse -> " + ip.getCanonicalHostName());
       }
   }
   

4. In a Spring MVC/Jakarta web app
   • Getting the client IP (taking proxies into account) and server info. Utility to extract client IP (checks common proxy headers, then falls back):

   import jakarta.servlet.http.HttpServletRequest;
   import java.util.List;
   
   public class IpUtils {
       private static final List<String> IP_HEADER_CANDIDATES = List.of(
           "X-Forwarded-For",
           "X-Real-IP",
           "CF-Connecting-IP",
           "Fastly-Client-Ip",
           "True-Client-Ip",
           "X-Cluster-Client-Ip",
           "Forwarded",
           "Forwarded-For"
       );
   
       public static String getClientIp(HttpServletRequest request) {
           for (String header : IP_HEADER_CANDIDATES) {
               String value = request.getHeader(header);
               if (value != null && !value.isBlank() && !"unknown".equalsIgnoreCase(value)) {
                   // X-Forwarded-For can contain a list: client, proxy1, proxy2...
                   String first = value.split(",")[0].trim();
                   if (!first.isBlank()) return first;
               }
           }
           return request.getRemoteAddr();
       }
   }
   

Controller example:

import jakarta.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.net.InetAddress;
import java.util.Map;

@RestController
public class NetInfoController {

    @GetMapping("/net-info")
    public Map<String, String> netInfo(HttpServletRequest request) throws Exception {
        String clientIp = IpUtils.getClientIp(request);

        // Server info via servlet and InetAddress
        String serverIp = request.getLocalAddr();     // or request.getServerName()
        String serverHostName = InetAddress.getLocalHost().getHostName();

        return Map.of(
            "clientIp", clientIp,
            "serverIp", serverIp,
            "serverHostName", serverHostName
        );
    }
}

Notes and tips

• getLocalHost may return 127.0.0.1 if your machine’s hostname isn’t resolvable. Enumerating NetworkInterface is more reliable.
• For containers/Kubernetes, you may prefer:
  • The interface enumeration approach, or
  • Reading an environment variable like HOSTNAME (if set by the platform).
• Reverse DNS (getCanonicalHostName) depends on network/DNS config and may be slow; cache if needed.
• Always handle exceptions: UnknownHostException, SocketException.
• When behind proxies/load balancers, only trust client-IP headers if your infrastructure sanitizes them; otherwise they can be spoofed.

Building a simple web server in Java involves creating a server socket to listen on a specific port, accepting client requests, and sending responses back to the client. Below is a basic example of building a simple HTTP server in Java.

Example Code

package org.kodejava.net;

import java.io.*;
import java.net.*;

public class SimpleWebServer {
    public static void main(String[] args) {
        int port = 8080; // Port number the server will listen on

        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("Server is listening on port " + port);

            while (true) {
                // Accept incoming client connections
                Socket clientSocket = serverSocket.accept();

                // Create a new thread to handle the request
                new Thread(() -> handleClientRequest(clientSocket)).start();
            }
        } catch (IOException e) {
            System.err.println("Server exception: " + e.getMessage());
            e.printStackTrace();
        }
    }

    private static void handleClientRequest(Socket clientSocket) {
        try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {

            // Read the HTTP request from the client
            String requestLine = in.readLine();
            System.out.println("Client request: " + requestLine);

            // Read and discard the rest of the request headers
            while (in.ready() && in.readLine() != null);

            // Build a basic HTTP response
            String responseBody = "<html><body><h1>Welcome to Simple Java Web Server</h1></body></html>";
            String response = "HTTP/1.1 200 OK\r\n" +
                              "Content-Type: text/html\r\n" +
                              "Content-Length: " + responseBody.length() + "\r\n" +
                              "\r\n" +
                              responseBody;

            // Send the HTTP response to the client
            out.write(response);
            out.flush();

        } catch (IOException e) {
            System.err.println("Client handling exception: " + e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                System.err.println("Failed to close client socket: " + e.getMessage());
            }
        }
    }
}

Steps to Run the Server

1. Compile the Code
   Save the file as SimpleWebServer.java and compile it:

   javac SimpleWebServer.java
   

2. Run the Server
   Execute the program:

   java SimpleWebServer
   

3. Access the Server
   Open a web browser and navigate to http://localhost:808. You should see the message:
   Welcome to Simple Java Web Server.

Key Concepts

1. ServerSocket:
   The ServerSocket class is used to listen on a specific port for incoming connections.
2. Socket:
   Represents the client’s connection. You can use the Socket object to read the request and send the response.
3. HTTP Protocol:
   The server follows a basic structure of HTTP responses:
   • First the status line (e.g., HTTP/1.1 200 OK).
   • Then the headers (e.g., Content-Type and Content-Length).
   • Finally, the response body.

4. Multithreading:
   Each client connection is handled on a separate thread to allow the server to process multiple requests simultaneously.

Notes

• Error Handling: Additional error handling should be implemented in production-level servers.
• Performance: For larger servers, consider using established frameworks like Spring Boot or Jakarta EE.
• Security: This is a basic example and does not address security concerns like HTTPS, request validation, etc.