Java实现：获取同一局域网内监听指定端口的服务器IP

这个场景在局域网设备联动里太常见了——服务器IP因DHCP动态变化，但固定监听9000端口，客户端得自动定位到它的新IP。我给你整理了三个实用的方案，从简单轻量到标准化都有，你可以根据自己的技术栈和需求选：

这是最容易上手的方案，不需要依赖任何第三方服务，纯自定义逻辑就能搞定。

原理 #

客户端向整个局域网的广播地址发送UDP探测包，包里带上能识别的标识（比如“找9000端口的服务器”）；服务器在9000端口监听UDP请求，收到探测包后立刻把自己的IP回传给客户端。

步骤 #

1. 服务器端：在9000端口启动UDP监听，收到请求后回复自身IP；
2. 客户端：发送UDP广播包，等待几秒接收响应，拿到的响应里就包含服务器IP。

优缺点 #

• ✅ 实现简单，代码量少，轻量高效；
• ✅ 同物理网络内无限制，不需要额外配置；
• ❌ 如果局域网内有多个同端口的服务器，需要额外加标识区分；
• ❌ 广播包跨网段会被路由器拦截（但你是同物理网络，这个问题不存在）。

代码示例（Python） #

服务器端

import socket

UDP_IP = "0.0.0.0"
UDP_PORT = 9000

# 创建UDP套接字并绑定端口
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, UDP_PORT))

print(f"服务器在UDP {UDP_PORT}端口等待探测...")
while True:
    # 接收客户端的探测请求
    data, client_addr = sock.recvfrom(1024)
    print(f"收到来自{client_addr}的请求：{data.decode()}")
    # 获取自身IP并回复
    server_ip = socket.gethostbyname(socket.gethostname())
    sock.sendto(server_ip.encode(), client_addr)

客户端

import socket

UDP_BROADCAST_ADDR = "255.255.255.255"
UDP_PORT = 9000
TIMEOUT = 3  # 等待响应的超时时间（秒）

# 创建UDP套接字并开启广播模式
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.settimeout(TIMEOUT)

# 发送探测请求
probe_msg = "QUERY_SERVER_9000"
sock.sendto(probe_msg.encode(), (UDP_BROADCAST_ADDR, UDP_PORT))

try:
    # 接收服务器的响应
    server_ip_bytes, _ = sock.recvfrom(1024)
    server_ip = server_ip_bytes.decode()
    print(f"找到目标服务器：{server_ip}:{UDP_PORT}")
except socket.timeout:
    print("超时未找到服务器，请检查服务器是否开启或网络是否正常")

mDNS是局域网服务发现的工业标准，各大系统都原生支持（Windows的Bonjour、Linux的Avahi、macOS原生自带）。用它的话，你不用自己处理广播细节，系统会帮你搞定服务注册和查询。

原理 #

服务器把自己的服务（9000端口）注册到mDNS网络里，客户端通过查询指定的服务类型，就能自动获取服务器的动态IP和端口。

步骤 #

1. 服务器端：注册mDNS服务，指定服务类型（比如_my-server._tcp.local）和端口9000；
2. 客户端：查询对应的mDNS服务类型，拿到服务器的IP和端口。

优缺点 #

• ✅ 标准化方案，兼容性极强，适合长期维护的系统；
• ✅ 支持多服务器自动区分，不需要自己处理冲突；
• ❌ 依赖系统的mDNS服务，需要确保客户端和服务器都开启了对应的服务（比如Linux要装Avahi，Windows要装Bonjour）。

实现示例 #

服务器端（Linux+Avahi）

编辑Avahi的服务配置文件/etc/avahi/services/my-server.service：

<service-group>
  <name>My 9000 Port Server</name>
  <service>
    <type>_my-server._tcp</type>
    <port>9000</port>
  </service>
</service-group>

然后重启Avahi服务：

sudo systemctl restart avahi-daemon

客户端（Python+zeroconf库）

先安装依赖：pip install zeroconf

from zeroconf import Zeroconf, ServiceBrowser

class ServerListener:
    def add_service(self, zeroconf, service_type, service_name):
        # 获取服务详情
        service_info = zeroconf.get_service_info(service_type, service_name)
        if service_info:
            server_ip = service_info.parsed_addresses()[0]
            server_port = service_info.port
            print(f"找到服务器：{server_ip}:{server_port}")
    
    def remove_service(self, zeroconf, service_type, service_name):
        print(f"服务器 {service_name} 已离线")

# 初始化mDNS查询
zeroconf = Zeroconf()
listener = ServerListener()
# 查询我们注册的服务类型
browser = ServiceBrowser(zeroconf, "_my-server._tcp.local.", listener)

# 保持程序运行直到用户输入
try:
    input("按回车键停止查询...\n")
finally:
    zeroconf.close()

如果服务器完全不能修改代码，只能从客户端侧动手，那ARP扫描是个可行的选择——客户端遍历局域网内所有活跃IP，逐个尝试连接9000端口，能成功连接的就是目标服务器。

原理 #

先获取客户端自身的局域网网段（比如192.168.1.x），然后遍历网段内的每个IP，尝试TCP连接9000端口，连接成功的IP就是服务器。

优缺点 #

• ✅ 完全不需要服务器做任何修改，纯客户端实现；
• ❌ 扫描速度慢（尤其是大网段），会产生大量连接请求；
• ❌ 容易被防火墙拦截（如果服务器开了防火墙，可能会拒绝连接）。

代码示例（Python） #

import socket
from ipaddress import IPv4Network
import threading

TARGET_PORT = 9000
MAX_THREADS = 15  # 并发线程数，控制扫描速度
found_servers = []

def check_server(ip):
    """检查单个IP是否能连接到目标端口"""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(0.5)  # 短超时，加快扫描速度
        # 尝试连接
        result = sock.connect_ex((str(ip), TARGET_PORT))
        if result == 0:
            print(f"找到服务器：{str(ip)}:{TARGET_PORT}")
            found_servers.append(str(ip))
        sock.close()
    except Exception:
        pass

def get_local_subnet():
    """获取客户端所在的局域网网段"""
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        # 连接一个外部地址，获取本地IP
        s.connect(("8.8.8.8", 80))
        local_ip = s.getsockname()[0]
        s.close()
        # 生成/24网段（默认子网掩码255.255.255.0）
        subnet = IPv4Network(f"{local_ip}/24", strict=False)
        return subnet.hosts()
    except Exception:
        print("无法获取本地网段，请检查网络连接")
        return []

if __name__ == "__main__":
    hosts = get_local_subnet()
    threads = []
    
    for host in hosts:
        t = threading.Thread(target=check_server, args=(host,))
        threads.append(t)
        t.start()
        
        # 控制并发数，避免占用过多资源
        if len(threads) >= MAX_THREADS:
            for thread in threads:
                thread.join()
            threads = []
    
    # 等待剩余线程完成
    for thread in threads:
        thread.join()
    
    print(f"\n扫描完成，找到的服务器IP列表：{found_servers}")

• 如果能修改服务器代码：优先选UDP广播，简单高效，没有额外依赖；
• 如果追求标准化和长期维护：选mDNS，兼容性好，系统原生支持；
• 如果服务器完全不能动：只能用ARP扫描，但要注意网络规模和防火墙的影响。

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