Java案例怎么搭建Socket服务？

wen java案例 2026-06-11 10

Java Socket服务搭建全流程实战案例解析

目录导读

Socket通信基础与Java实现原理
单线程Socket服务端搭建与客户端测试
多线程并发Socket服务端深度优化
案例实战：简易聊天室服务端实现
常见问题与调优策略（含问答）
总结与扩展建议

Socket通信基础与Java实现原理

在Java网络编程中，Socket是位于传输层（TCP/UDP）的抽象接口，用于实现两台主机之间的双向通信，Java的java.net包提供了ServerSocket和Socket类,分别用于服务端监听与客户端连接。

核心流程：服务端通过ServerSocket绑定端口并调用accept()阻塞等待客户端连接；客户端通过Socket指定IP和端口发起连接，连接建立后，双方通过InputStream/OutputStream进行数据交互。

为什么用Socket？
在企业级应用中，Socket常支撑即时通讯、远程调用、游戏服务等场景，相比HTTP的无状态特性，Socket提供长连接,适合高频数据交换。

单线程Socket服务端搭建与客户端测试

1 服务端代码（基础版）

import java.io.*;
import java.net.*;
public class SingleServer {
    public static void main(String[] args) throws IOException {
        // 绑定端口8888
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端启动，等待客户端连接...");
        // 阻塞等待客户端连接
        Socket clientSocket = serverSocket.accept();
        System.out.println("客户端已连接：" + clientSocket.getInetAddress());
        // 读取客户端消息
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()));
        String message = reader.readLine();
        System.out.println("收到消息：" + message);
        // 回复客户端
        PrintWriter writer = new PrintWriter(
                clientSocket.getOutputStream(), true);
        writer.println("服务端已收到：" + message);
        // 关闭资源
        reader.close();
        writer.close();
        clientSocket.close();
        serverSocket.close();
    }
}

2 客户端代码（测试用）

import java.io.*;
import java.net.*;
public class SingleClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8888);
        PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
        writer.println("Hello Server!");
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
        System.out.println("服务端回复：" + reader.readLine());
        reader.close();
        writer.close();
        socket.close();
    }
}

测试步骤：

先运行SingleServer，等待连接。
再运行SingleClient,观察控制台输出。

问题：此版本只能处理一个客户端,后续连接会被阻塞。

多线程并发Socket服务端深度优化

为了让服务端同时服务多个客户端，必须引入多线程，经典做法是：accept()后为每个客户端创建一个新线程。

优化后服务端代码

import java.io.*;
import java.net.*;
public class MultiServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("多线程服务端启动...");
        while (true) {
            Socket clientSocket = serverSocket.accept();
            // 为每个客户端启动新线程
            new ClientHandler(clientSocket).start();
        }
    }
}
class ClientHandler extends Thread {
    private Socket socket;
    public ClientHandler(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
             PrintWriter writer = new PrintWriter(
                     socket.getOutputStream(), true)) {
            writer.println("欢迎连接到Java服务端");
            String inputLine;
            while ((inputLine = reader.readLine()) != null) {
                System.out.println("收到 " + socket.getInetAddress() + ": " + inputLine);
                writer.println("回显: " + inputLine);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

关键改进：

while(true)循环持续接受新连接。
使用ClientHandler线程类独立处理每个客户端的读写。
资源自动关闭（try-with-resources）。

案例实战：简易聊天室服务端实现

本案例结合场景：构建一个支持多用户相互广播消息的聊天室。

核心设计：

服务端维护一个List<PrintWriter>客户端输出流集合。
当某个客户端发来消息，遍历集合向所有在线用户广播。

聊天室服务端核心代码

import java.io.*;
import java.net.*;
import java.util.*;
public class ChatServer {
    private static List<PrintWriter> clients = new ArrayList<>();
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("聊天服务端已启动...");
        while (true) {
            Socket socket = serverSocket.accept();
            new ChatHandler(socket).start();
        }
    }
    static class ChatHandler extends Thread {
        private Socket socket;
        private PrintWriter writer;
        public ChatHandler(Socket socket) {
            this.socket = socket;
        }
        @Override
        public void run() {
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()))) {
                writer = new PrintWriter(socket.getOutputStream(), true);
                synchronized (clients) {
                    clients.add(writer);
                }
                writer.println("你已加入聊天室！在线人数：" + clients.size());
                String message;
                while ((message = reader.readLine()) != null) {
                    broadcast(socket.getInetAddress() + "说: " + message);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                synchronized (clients) {
                    clients.remove(writer);
                }
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        private void broadcast(String message) {
            synchronized (clients) {
                for (PrintWriter cw : clients) {
                    cw.println(message);
                }
            }
        }
    }
}

客户端测试：使用telnet或编写简易客户端即可测试。

常见问题与调优策略（含问答）

Q1：如何解决服务端线程数过多导致的资源耗尽？

A：建议使用线程池(ExecutorService)，将new ClientHandler().start()替换为：

ExecutorService pool = Executors.newFixedThreadPool(10);
while (true) {
    Socket socket = serverSocket.accept();
    pool.execute(new ClientHandler(socket));
}