使用tcp工具调试socket服务端通信

Amberish

已于 2023-03-17 14:44:48 修改

阅读量1.1k

点赞数

文章标签： tcp/ip java 网络

于 2023-03-17 14:39:55 首次发布

本文链接：https://blog.csdn.net/weixin_44671867/article/details/129616710

版权

背景介绍：
客户端是用tcp连接调试，工具链接: https://pan.baidu.com/s/1kfjv1jdS8KJgb7YVSu9Wtw 提取码: z34a
服务端是Java代码写的逻辑，用byte[]流接收客户端传来的数据，再转化成16进制字符串

目前服务端程序功能：

接收客户端tcp工具通信
用byte[]流接收客户端传来的数据，再转化成16进制字符串
解决客户端/服务端断网重连问题

先贴代码，服务端启动类

package cn.socketTest;

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 接收的是byte[]字节流，转化成16进制字符，每次接到一个新的客户端连接，对应创建一个线程
 *
 * 断电重连：该程序满足。
 *         场景：客户端/服务端没有网络，客户端发送消息，服务端没有回应，客户端请求超时，自动断开连接，当恢复网络时，客户端再次连接服务端，连接成功。这个时候服务端对应的该客户端
 *         有俩个线程，处理方式是杀死之前的旧线程，用新创建的线程服务该客户端
 *
 * 服务端断网：
 */

public class SocketServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(1111);//创建绑定到特定端口的服务器Socket。
            Socket socket = null;//需要接收的客户端Socket
            System.out.println("服务器启动");
            //定义一个死循环，不停的接收客户端连接
            while (true) {
                socket = serverSocket.accept();//侦听并接受到此套接字的连接
                InetAddress inetAddress = socket.getInetAddress();//获取客户端的连接
                System.out.print("inetAddress : " + inetAddress);
                ServerThread thread = new ServerThread(socket, inetAddress);//自己创建的线程类
                thread.start();
                int count = Thread.activeCount() - 1;//当前线程数-主线程数就是活动的线程
                System.out.println("  客户端数量：" + count);//打印客户端数量
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务线程：

package cn.socketTest;

import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Arrays;

public class ServerThread extends Thread {

    InetAddress inetAddress = null;//接收客户端的连接
    private volatile Socket socket = null;

    private volatile boolean exit = false;

    private volatile InputStream inputStream = null;

    public ServerThread(Socket socket, InetAddress inetAddress) throws IOException {
        this.socket = socket;
        this.inetAddress = inetAddress;
        this.inputStream = socket.getInputStream();
    }

    @Override
    public void run() {
        try {
            //封装输入流（接收客户端的字节流）
            byte[] hardCode = new byte[3];//假设 前三位传参是机器编码，先取出机器编码
            byte[] bytes = new byte[1]; // 一次读取一个byte
            inputStream.read(hardCode);//读取硬件编码
            //断网重连
            ServerThread td = StoreMap.getInstance().get(Arrays.toString(hardCode));
            if (td != null) {
                td.exit = true;
                td.inputStream.close();
                td.socket.close();
            }
            StoreMap.getInstance().put(Arrays.toString(hardCode), this);//存当前线程

            String ret = "";
            while (!exit && inputStream.read(bytes) != -1) {
                System.out.print("🥛");
                ret += bytesToHexString(bytes) + " ";
                if (inputStream.available() == 0) { //一个请求
                    System.out.print("🍓");
                    System.out.println(socket.getRemoteSocketAddress() + ":" + ret + "  当前线程：" + this.getName() + "，状态：" + this.getState() + " 线程活跃数量：" + Thread.activeCount() + ",设备编码：" + Arrays.toString(hardCode));
                    ret = "";
                }
                System.out.print("🍌");
            }
            System.out.println("出for循环");
        } catch (IOException e) {
            System.out.println("socket强制关闭了！！");
        } finally {
            //关闭资源
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println(getName() + "执行完成");
        }
    }

    /**
     * 将16进制字符转换成byte[]数组。与byte2Hex功能相反。
     *
     * @param string 16进制字符串
     * @return byte[]数组
     */
    public static byte[] hex2Byte(String string) {
        if (string == null || string.length() < 1) {
            return null;
        }
        // 因为一个byte生成两个字符，长度对应1:2，所以byte[]数组长度是字符串长度一半
        byte[] bytes = new byte[string.length() / 2];
        // 遍历byte[]数组，遍历次数是字符串长度一半
        for (int i = 0; i < string.length() / 2; i++) {
            // 截取没两个字符的前一个，将其转为int数值
            int high = Integer.parseInt(string.substring(i * 2, i * 2 + 1), 16);
            // 截取没两个字符的后一个，将其转为int数值
            int low = Integer.parseInt(string.substring(i * 2 + 1, i * 2 + 2), 16);
            // 高位字符对应的int值*16+低位的int值，强转成byte数值即可
            // 如dd，高位13*16+低位13=221(强转成byte二进制11011101，对应十进制-35)
            bytes[i] = (byte) (high * 16 + low);
        }
        return bytes;
    }

    /**
     * byte[]数组转换为16进制的字符串
     *
     * @param bytes 要转换的字节数组
     * @return 转换后的结果
     */
    public static String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);
            if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }
        return sb.toString();
    }

}

断电重连单例缓存：

package cn.socketTest;

import java.util.HashMap;
import java.util.Map;

//缓存 存放 编码对应的线程
public class StoreMap {

    private StoreMap(){

    }

    private static Map<String, ServerThread> instance = new HashMap<>();

    public static Map<String, ServerThread> getInstance() {
        return instance;
    }

    public static void setInstance(Map<String, ServerThread> instance) {
        StoreMap.instance = instance;
    }
}

程序刚开始是参考网络上的代码，参考代码能够做到用tcp连接到服务端，并没有断网重连的处理，逻辑是每次收到客户端连接创建一个线程服务，将该客户端和对应的线程存到map中，每次创建新线程时，先去map里查询该客户端有没有连过，如果能查到到，将这个查到的线程杀死，然后将该设备标识和新创建的线程再存到map中，然后再进行接受数据，处理业务。

断网重连的难点是，杀死线程，折腾两天才弄好，普通没有socket情况下，将while循环中的exit置为true，线程就能停止，该程序因为涉及到socket，不仅exit要置为true，还需要关闭socket才能线程才能结束。如果不关闭socket，他会一直停在这行代码：

            while (!exit && inputStream.read(bytes) != -1) {

不会往下走。

场景：在tcp工具开了三个客户端，模拟三个设备，数据前三位假设传的是设备编码，设备编码一样的是同一个客户端。

49设备是第一个连接服务端，当前活跃的线程数是2，包括一个main线程，一个服务49设备的服务端线程。
50设备第二个连接服务端，然后50设备又关掉客户端，线程数由3个变成2个，再次开启50设备，当前线程数又变成了3个。
51设备第三个链接服务端，连接成功后，服务端断网，客户端继续发送消息，服务端无响应，请求超时，客户端单方面断开
连接，请注意是单方面，因为服务端对应的线程还活着，假设取名51老线程。该设备再次访问服务端时，需要先连接，再发送数据，服务端会创建一个新线程服务51设备，假设取名51新线程，到现在为止，是有俩线程为该设备服务，51老线程会一直在while那行代码等待数据，但是一直会等不到，因为51新线程在服务51设备。所以当前所写的程序是杀死51老线程。杀死之后线程数又是4个。

后台打印：
在这里插入图片描述