java中使用Socket示例

最新推荐文章于 2026-05-02 07:12:28 发布

原创最新推荐文章于 2026-05-02 07:12:28 发布 · 710 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java #开发语言 #ide

本文详细介绍了在Java中使用Socket实现客户端和服务端通信的示例，包括基本的TCP连接、心跳检测以及SpringBoot集成后的应用实例。

java中使用Socket示例

一.main方式

1.客户端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Timer;
import java.util.TimerTask;

public class SocketClient {
    public static void main(String[] args) {
        while (true) {
            try {
                Socket socket = new Socket("localhost", 5000);
                System.out.println("成功连接服务器");

                // 获取输出流
                PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
                // 获取输入流
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                // 发送心跳消息
                Timer timer = new Timer();
                timer.schedule(new HeartbeatTask(out), 0, 10000);

                // 读取服务器的响应并打印
                String response;
                while ((response = in.readLine()) != null) {
                    System.out.println("服务器响应：" + response);
                }

                // 关闭流和Socket
                out.close();
                in.close();
                socket.close();

                // 如果程序能够执行到这里说明连接已经断开，退出循环尝试重连
                break;
            } catch (IOException e) {
                System.err.println("无法连接服务器，正在尝试重连...");
                try {
                    // 休眠一段时间后再尝试重连
                    Thread.sleep(5000);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

class HeartbeatTask extends TimerTask {
    private PrintWriter out;

    public HeartbeatTask(PrintWriter out) {
        this.out = out;
    }

    @Override
    public void run() {
        out.println("Heartbeat");
        System.out.println("发送心跳消息");
    }
}

2.服务端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketService {

    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(5000);
            System.out.println("服务器启动，等待客户端连接...");

            while (true) {
                // 等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("客户端已连接");

                // 创建新的线程来处理客户端连接
                ClientHandler clientHandler = new ClientHandler(clientSocket);
                clientHandler.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class ClientHandler extends Thread {
    private Socket clientSocket;

    public ClientHandler(Socket socket) {
        this.clientSocket = socket;
    }

    @Override
    public void run() {
        try {
            // 获取客户端输入流
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            // 获取服务器输出流
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

            String inputLine;
            // 读取客户端消息，并将其原样发送回去
            while ((inputLine = in.readLine()) != null) {
                System.out.println("客户端消息：" + inputLine);
                out.println("服务器收到消息：" + inputLine);
            }

            // 关闭流和Socket
            in.close();
            out.close();
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

二.springBoot方式

1.客户端

import org.springframework.stereotype.Component;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Timer;
import java.util.TimerTask;
/**
 *
 * @author csy
 * @data 2024-04-03
 */
@Component
public class SocketClient {


    //启动
    public void startSocketClient() {
        socketClient();
    }



    public void socketClient() {
        while (true) {
            try {
                Socket socket = new Socket("localhost", 5000);
                System.out.println("成功连接服务器");

                // 获取输出流
                PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
                // 获取输入流
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                // 发送心跳消息
                Timer timer = new Timer();
                timer.schedule(new HeartbeatTask(out), 0, 10000);

                // 读取服务器的响应并打印
                String response;
                while ((response = in.readLine()) != null) {
                    System.out.println("服务器响应：" + response);
                }

                // 关闭流和Socket
                out.close();
                in.close();
                socket.close();

                // 如果程序能够执行到这里说明连接已经断开，退出循环尝试重连
                break;
            } catch (IOException e) {
                System.err.println("无法连接服务器，正在尝试重连...");
                try {
                    // 休眠一段时间后再尝试重连
                    Thread.sleep(5000);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

class HeartbeatTask extends TimerTask {
    private PrintWriter out;

    public HeartbeatTask(PrintWriter out) {
        this.out = out;
    }

    @Override
    public void run() {
        out.println("Heartbeat");
        System.out.println("发送心跳消息");
    }
}

2.服务端

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 *
 * @author csy
 * @data 2024-04-03
 */
@Component
public class SocketService {

    private static final int CORE_POOL_SIZE = 4;
    private static final int MAX_POOL_SIZE = 8;
    private static final int QUEUE_CAPACITY = 20;
    private static final Long KEEP_ALIVE_TIME = 1L;
    @Autowired
    private SocketClient socketClient;

    @PostConstruct
    public void startSocket() {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());
        Thread thread = new Thread(() -> {
            this.startSocketService();
        }, "startSocketServiceThread");
        //启动服务端
        executor.execute(thread);


        Thread thread2 = new Thread(() -> {
            socketClient.startSocketClient();
        }, "startSocketClientThread");
        //启动客户端
        executor.execute(thread2);
    }


    public void startSocketService() {
        socketService();
    }

    public void socketService() {
        try {
            ServerSocket serverSocket = new ServerSocket(5000);
            System.out.println("服务器启动，等待客户端连接...");

            while (true) {
                // 等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("客户端已连接");

                // 创建新的线程来处理客户端连接
                ClientHandler clientHandler = new ClientHandler(clientSocket);
                clientHandler.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class ClientHandler extends Thread {
    private Socket clientSocket;

    public ClientHandler(Socket socket) {
        this.clientSocket = socket;
    }

    @Override
    public void run() {
        try {
            // 获取客户端输入流
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            // 获取服务器输出流
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

            String inputLine;
            // 读取客户端消息，并将其原样发送回去
            while ((inputLine = in.readLine()) != null) {
                System.out.println("客户端消息：" + inputLine);
                out.println("服务器收到消息：" + inputLine);
            }

            // 关闭流和Socket
            in.close();
            out.close();
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}