基于SpringBoot注入Bean形式的监听(端口)

起一个线程、监听对应的端口,注入到容器

package com.port.component;

import com.port.service.PortListenerService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;


/**
 * @Description: 监听端口bean
 * @author: be_insighted
 * @create: 2024/4/1 15:09
 * @since 1.0.0
 */



@Component
public class AppRunner implements CommandLineRunner {

    @Value("${listener-port}")
    private int listenPort;

    private final PortListenerService portListenerService;

    public AppRunner(PortListenerService portListenerService) {
        this.portListenerService = portListenerService;
    }

    @Override
    public void run(String... args) throws Exception {
        portListenerService.startListening(listenPort); // 开始监听端口
    }
}

Port Listener进行逻辑处理,注入到容器

package com.port.service;

/**
 * @Description: 端口监听逻辑层
 * @author: be_insighted
 * @create: 2024/4/1 15:08
 * @since 1.0.0
 */

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import javax.annotation.PreDestroy;

@Slf4j
@Service
public class PortListenerService {

    private ServerSocket serverSocket;
    private boolean running = true;

    public void startListening(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        log.info("Listening on port: " + port);

        Thread listenerThread = new Thread(() -> {
            while (running) {
                try {
                    Socket clientSocket = serverSocket.accept();
                    handleClient(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        listenerThread.start();
    }

    private void handleClient(Socket clientSocket) {
        try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
             BufferedWriter out = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()))) {
            String message;
            while ((message = in.readLine()) != null) {
                // 处理接收到的报文
                processMessage(message);
                // 可选：向客户端发送响应
                out.write("Message received\n");
                out.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void processMessage(String message) {
        // 这里将报文保存到数据库，使用你的MessageRepository或其他数据访问层
        // 例如：messageRepository.save(new Message(message));
        System.out.println("Received message: " + message);
        // TODO: 实现保存到数据库的逻辑
    }

    @PreDestroy
    public void stopListening() throws IOException {
        running = false;
        if (serverSocket != null && !serverSocket.isClosed()) {
            serverSocket.close();
        }
    }
}