springBoot Tcp服务端实现 webSocket Tcp

使用Springboot+webSocket 构建TCP 服务

1. 服务监听

/**
 * @author guoshunli
 * @version 1.0
 * @description: TODO  TCP 服务
 * @date 2022/9/5 13:50
 */
@Slf4j
@Data
@Component
@NoArgsConstructor
public class SocketServer implements ApplicationRunner {

    private Integer port = 9090;
    private boolean started;

    private ServerSocket serverSocket;
     // 网关设备
    @Autowired
    private DevInstallProfileService devInstallProfileService;


    // 防止重复创建socket线程链接对象浪费资源
    private ExecutorService executorService = Executors.newCachedThreadPool();

    public void start() throws IOException {
        start(null);
    }

    public void start(Integer port) throws IOException {
        log.info("port: {}, {}", this.port, port);
        try {
            serverSocket =  new ServerSocket(port == null ? this.port : port);
            started = true;
            log.info("Socket服务已启动，占用端口： {}", serverSocket.getLocalPort());
            UpdateWrapper updateWrapper =new UpdateWrapper();
            updateWrapper.set("sys_state", OFFLINE);
            devInstallProfileService.update(updateWrapper);
        } catch (IOException e) {
            log.error("端口冲突,异常信息：{}", e);
            System.exit(0);
        }
        while  (true){
            try {
                // 开启socket监听  //阻塞io
                Socket socket = serverSocket.accept();
                log.info("=======开启socket监听======");
                //注册连接
                ClientSocket register = register(socket);
                log.info("======={}:注册连接======",register.getKey());
                // 在此判断是否重复创建socket对象线程
                if (register != null){
                    executorService.submit(register);
                    log.info("======={}:创建一个线程池任务======",register.getKey());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        start();
    }
}

2. socket任务处理器 SocketHandler,里面封装读写数据,销毁链接,等方法.

package com.tsy.energy.webSocket.tcp;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import static com.tsy.energy.webSocket.tcp.SocketPool.add;
import static com.tsy.energy.webSocket.tcp.SocketPool.remove;

/**
 * @author guoshunli
 * @version 1.0
 * @description: TODO socket任务处理器 SocketHandler,里面封装读写数据,销毁链接,等方法.
 * @date 2022/9/5 11:59
 */
@Slf4j
public class SocketHandler {

    /**
     * 将连接的Socket注册到Socket池中
     * @param socket
     * @return
     */
    public static ClientSocket register(Socket socket){
        ClientSocket clientSocket = new ClientSocket();
        clientSocket.setSocket(socket);
        try {
            clientSocket.setInputStream(new DataInputStream(socket.getInputStream()));
            clientSocket.setOutputStream(new DataOutputStream(socket.getOutputStream()));
            byte[] bytes = new byte[1024];
            //getInputStream 一个阻塞io 用来获取注册包 第一次进行未发送注册包进行一次阻塞
            int read= clientSocket.getInputStream().read(bytes);
            // 防止 第一次注册包什么也没有 然后有断开连接
            if (read !=-1) {
                // read 数据长度
                String key = new String(bytes, 0, read);
                clientSocket.setKey(key);
                add(clientSocket);
                return clientSocket;
            }else {
                close(clientSocket);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 向指定客户端发送信息
     * @param clientSocket
     * @param message
     */
    public static void sendMessage(ClientSocket clientSocket, String message){
        try {
            log.info("发送消息到客户端  : >>>>>" + message);
            clientSocket.getOutputStream().write(message.getBytes("utf-8"));
            //clientSocket.getOutputStream().writeUTF(message);
        } catch (IOException e) {
            log.error("发送信息异常：{}", e);
            close(clientSocket);
        }
    }

    /**
     * 获取指定客户端的上传信息
     * @param clientSocket
     * @return
     */
    public static void onMessage(ClientSocket clientSocket){
        byte[] keyByte = new byte[1024];
        byte[] msgByte = new byte[1];
        try {
            // 第一次先发送序列号
            if(StringUtils.isEmpty(clientSocket.getKey())) {
                clientSocket.getInputStream().read(keyByte);
                clientSocket.setKey(new String(keyByte, "UTF-8"));
            }else {
                String info = "";
                //接收收到的数据
                
                /* while (true){
                    if (clientSocket.getInputStream().available() >0) {
                        clientSocket.getInputStream().read(msgByte);
                        //十六进制
                        String tempStr = HexEcodeUtil.ByteArrayToHexStr(msgByte);
                        info += tempStr;
                        //已经读完
                        if (clientSocket.getInputStream().available() == 0) {
                            //重置,不然每次收到的数据都会累加起来
                            clientSocket.setMessage(info);
                            System.out.println("clientSocket.setMessage(info);");
                            break;
                        }
                    }
                }
*/
                // 十进制数据
                int readLine = clientSocket.getInputStream().read(msgByte);
                // 当读取长度为 -1 时，则TCP以断开连接  判断客户端断开连接 ClientSocket类会执行一次 isSocketClosed 
                if (readLine == -1){
                    return;
                }
                while (readLine!=-1) {
                    clientSocket.setMessage(new String(msgByte, "UTF-8"));
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
           /* close(clientSocket);*/
        }
        //return null;
    }


    /**
     * 指定Socket资源回收
     * @param clientSocket
     */
    public static void close(ClientSocket clientSocket){
        log.info("进行资源回收");
        if (clientSocket != null){
            log.info("开始回收socket相关资源，其Key为{}", clientSocket.getKey());
            remove(clientSocket.getKey());
            Socket socket = clientSocket.getSocket();
            try {
                socket.shutdownOutput();
                socket.shutdownInput();
            } catch (IOException e) {
                log.error("关闭输入输出流异常，{}", e);
            }finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    log.error("关闭socket异常{}", e);
                }
            }
        }
    }


    /**
     * 发送数据包，判断数据连接状态
     * @param clientSocket
     * @return
     */
    public static boolean isSocketClosed(ClientSocket clientSocket){
        try {
            clientSocket.getSocket().sendUrgentData(1);
            log.info("==========》给客户端设备:{} 发送数据包",clientSocket.getKey());
            return false;
        } catch (IOException e) {
            return true;
        }
    }
}

3. 每个链接都是一个ClientSocket对象

/**
 * @author guoshunli
 * @version 1.0
 * @description:
 * TODO 封装socket对象 ClientSocket 每个链接都是一个ClientSocket对象.
 * TODO 我们可以在此类中和客户端进行收到等操作达到监听效果.也可以将收到的数据保存到数据库中,以便后续业务需求
 * @date 2022/9/5 11:57
 */
public class SocketPool {

    private static final ConcurrentHashMap<String, ClientSocket> ONLINE_SOCKET_MAP = new ConcurrentHashMap<>();


    public static void add(ClientSocket clientSocket){
        if (clientSocket != null && !clientSocket.getKey().isEmpty()) {
            ONLINE_SOCKET_MAP.put(clientSocket.getKey(), clientSocket);
        }
    }

    public static void remove(String key){
        if (!StringUtils.isEmpty(key))
            ONLINE_SOCKET_MAP.remove(key);
    }
}

4. 消息处理

/**
 * @author guoshunli
 * @version 1.0
 * @description: TODO 处理客户端消息
 * @date 2022/9/5 11:57
 */
@Slf4j
@Data
public class ClientSocket implements Runnable {

    private Socket socket;
    private DataInputStream inputStream;
    private DataOutputStream outputStream;
    private String key;
    private String message;

    private  int mark =1;

    // 网关设备
    @Autowired
    private DevInstallProfileService devInstallProfileService;


    ClientSocket(){
        devInstallProfileService = SpringUtil.getBean(DevInstallProfileService.class);
    }

    @Override
    public void run() {
        while (true){
            try {
                onMessage(this);
                if (mark == 1){
                    UpdateWrapper updateWrapper =new UpdateWrapper();
                    updateWrapper.eq("topic",this.key);
                    updateWrapper.set("sys_state", ONLINE);
                    Boolean isUpdate =  devInstallProfileService.update(updateWrapper);
                    if (isUpdate){
                        this.mark = 0;
                    }
                    log.info(" 当前设备:["+this.key+"] 已上线:[{}]",isUpdate);
                }
                log.info(LocalDateTime.now()+" 当前设备:"+this.key+" 接收到数据: <<<<<< "+ this.message);
            }catch (Exception e) {
                e.printStackTrace();
            }
            //在接受到消息后进行回调一次进行检查
            if (isSocketClosed(this)){
                log.info("客户端已关闭,其Key值为：{}", this.getKey());
                //关闭对应的服务端资源
                close(this);
                UpdateWrapper updateWrapper =new UpdateWrapper();
                updateWrapper.eq("topic",this.key);
                updateWrapper.set("sys_state", OFFLINE);
                Boolean isUpdate =  devInstallProfileService.update(updateWrapper);
                log.info(" 当前设备:"+this.key+"下线:[{}]",isUpdate);
                this.mark =0;
                break;
            }
        }
    }
}