socket接收16进制速度比较快

Posted 2023-05-16

是的，比较快 接收设置，sock接收的数据是bytes类型，收到的普通数据为b'xxx‘，转换成str类型，需要’xxx'.decode('utf-8')，但是收到的‘aa'十六进制的bytes数据为b'\xaa',需转换成普通 str 'aa'，转换用'xx'.hex()即可转换。
if recv_msg:
msg = f"来自IP:address[0]端口:address[1]:"
self.tcp_signal_write_msg.emit(msg)
try:
info = recv_msg.decode("utf-8")
self.tcp_signal_write_info.emit(info, self.InfoRec)
except Exception as ret:
if recv_msg.hex(): #将16进制bytes b'\xaa'转换成utf-8 str 'aa'
info = recv_msg.hex()
self.tcp_signal_write_info.emit(info, self.InfoRec)
else:
msg="数据格式错误"+ret.__str__()
self.tcp_signal_write_msg.emit(msg)
解析接收的数据：以十六进制显示与普通方式显示
if self.receive_HEX_flag: # 以十六进制接收
info=bytes(info,encoding='utf-8') #转换成bytes类型
info_hex = base64.b16encode(info) #16进制编码
else:
info_hex = info
base64以16进制编码需bytes类型，重新将str转换为bytes,用 bytes(info,encoding='utf-8')转换。
发送设置：
if self.send_HEX_flag: #以十六进制发送
info_hex=base64.b16encode(info.encode())
else:
info_hex=info
16进制发只需将所需数据转换成16进制即可，普通发送不用转换。 参考技术A 接收设置，sock接收的数据是bytes类型，收到的普通数据为b'xxx‘，转换成str类型，需要’xxx'.decode('utf-8')，但是收到的‘aa'十六进制的bytes数据为b'\xaa',需转换成普通 str 'aa'，转换用'xx'.hex()即可转换。

if recv_msg:
msg = f"来自IP:address[0]端口:address[1]:"
self.tcp_signal_write_msg.emit(msg)
try:
info = recv_msg.decode("utf-8")
self.tcp_signal_write_info.emit(info, self.InfoRec)
except Exception as ret:
if recv_msg.hex(): #将16进制bytes b'\xaa'转换成utf-8 str 'aa'
info = recv_msg.hex()
self.tcp_signal_write_info.emit(info, self.InfoRec)
else:
msg="数据格式错误"+ret.__str__()
self.tcp_signal_write_msg.emit(msg)
解析接收的数据：以十六进制显示与普通方式显示

if self.receive_HEX_flag: # 以十六进制接收
info=bytes(info,encoding='utf-8') #转换成bytes类型
info_hex = base64.b16encode(info) #16进制编码
else:
info_hex = info
base64以16进制编码需bytes类型，重新将str转换为bytes,用 bytes(info,encoding='utf-8')转换。

发送设置：

if self.send_HEX_flag: #以十六进制发送
info_hex=base64.b16encode(info.encode())
else:
info_hex=info
16进制发只需将所需数据转换成16进制即可，普通发送不用转换。 参考技术B 接收设置，sock接收的数据是bytes类型，收到的普通数据为b'xxx‘，转换成str类型，需要’xxx'.decode('utf-8')，但是收到的‘aa'十六进制的bytes数据为b'\xaa',需转换成普通 str 'aa'，转换用'xx'.hex()即可转换。
if recv_msg:
msg = f"来自IP:address[0]端口:address[1]:"
self.tcp_signal_write_msg.emit(msg)
try:
info = recv_msg.decode("utf-8")
self.tcp_signal_write_info.emit(info, self.InfoRec)
except Exception as ret:
if recv_msg.hex(): #将16进制bytes b'\xaa'转换成utf-8 str 'aa'
info = recv_msg.hex()
self.tcp_signal_write_info.emit(info, self.InfoRec)
else:
msg="数据格式错误"+ret.__str__()
self.tcp_signal_write_msg.emit(msg)
解析接收的数据：以十六进制显示与普通方式显示
if self.receive_HEX_flag: # 以十六进制接收
info=bytes(info,encoding='utf-8') #转换成bytes类型
info_hex = base64.b16encode(info) #16进制编码
else:
info_hex = info
base64以16进制编码需bytes类型，重新将str转换为bytes,用 bytes(info,encoding='utf-8')转换。
发送设置：
if self.send_HEX_flag: #以十六进制发送
info_hex=base64.b16encode(info.encode())
else:
info_hex=info
16进制发只需将所需数据转换成16进制即可，普通发送不用转换。 参考技术C 接收设置，sock接收的数据是bytes类型，收到的普通数据为b'xxx‘，转换成str类型，需要’xxx'.decode('utf-8')，但是收到的‘aa'十六进制的bytes数据为b'\xaa',需转换成普通 str 'aa'，转换用'xx'.hex()即可转换。
if recv_msg:
msg = f"来自IP:address[0]端口:address[1]:"
self.tcp_signal_write_msg.emit(msg)
try:
info = recv_msg.decode("utf-8")
self.tcp_signal_write_info.emit(info, self.InfoRec)
except Exception as ret:
if recv_msg.hex(): #将16进制bytes b'\xaa'转换成utf-8 str 'aa'
info = recv_msg.hex()
self.tcp_signal_write_info.emit(info, self.InfoRec)
else:
msg="数据格式错误"+ret.__str__()
self.tcp_signal_write_msg.emit(msg)
解析接收的数据：以十六进制显示与普通方式显示
if self.receive_HEX_flag: # 以十六进制接收
info=bytes(info,encoding='utf-8') #转换成bytes类型
info_hex = base64.b16encode(info) #16进制编码
else:
info_hex = info
base64以16进制编码需bytes类型，重新将str转换为bytes,用 bytes(info,encoding='utf-8')转换。
发送设置：
if self.send_HEX_flag: #以十六进制发送
info_hex=base64.b16encode(info.encode())
else:
info_hex=info
16进制发只需将所需数据转换成16进制即可，普通发送不用转换。 参考技术D 接收设置，sock接收的数据是bytes类型，收到的普通数据为b'xxx‘，转换成str类型，需要’xxx'.decode('utf-8')，但是收到的‘aa'十六进制的bytes数据为b'\xaa',需转换成普通 str 'aa'，转换用'xx'.hex()即可转换。
if recv_msg:
msg = f"来自IP:address[0]端口:address[1]:"
self.tcp_signal_write_msg.emit(msg)
try:
info = recv_msg.decode("utf-8")
self.tcp_signal_write_info.emit(info, self.InfoRec)
except Exception as ret:
if recv_msg.hex(): #将16进制bytes b'\xaa'转换成utf-8 str 'aa'
info = recv_msg.hex()
self.tcp_signal_write_info.emit(info, self.InfoRec)
else:
msg="数据格式错误"+ret.__str__()
self.tcp_signal_write_msg.emit(msg)
解析接收的数据：以十六进制显示与普通方式显示
if self.receive_HEX_flag: # 以十六进制接收
info=bytes(info,encoding='utf-8') #转换成bytes类型
info_hex = base64.b16encode(info) #16进制编码
else:
info_hex = info
base64以16进制编码需bytes类型，重新将str转换为bytes,用 bytes(info,encoding='utf-8')转换。
发送设置：
if self.send_HEX_flag: #以十六进制发送
info_hex=base64.b16encode(info.encode())
else:
info_hex=info
16进制发只需将所需数据转换成16进制即可，普通发送不用转换。

硬件通信Java Socket怎么发送和接收16进制数据

关键点

• 发送时：首先将你的16进制的数据，转化成byte[]，然后发送

• 接收时：获得数据，然后将byte[]的东西转化成16进制字符串

1 服务端socket

public class Server 

    private static class ClientHandler implements Runnable 

        private Socket socket;

        public ClientHandler(Socket socket) 
            this.socket = socket;
        

        @Override
        public void run() 

            try 

                //封装输入流（接收客户端的流）
                BufferedInputStream bis = new BufferedInputStream(
                        socket.getInputStream());
                DataInputStream dis = new DataInputStream(bis);
                byte[] bytes = new byte[1]; // 一次读取一个byte
                String ret = "";
                while (dis.read(bytes) != -1) 
                    ret += bytesToHexString(bytes) + " ";
                    if (dis.available() == 0)  //一个请求
                        System.out.println(socket.getRemoteSocketAddress() + ":" + ret);
                        ret = "";
                    
                

             catch (Exception e) 
                e.printStackTrace();
             finally 
                System.out.println("client is over");
                if (socket != null) 
                    try 
                        socket.close();
                     catch (IOException e) 

                        e.printStackTrace();
                    
                
            

        

    

    public static void main(String[] args) 

        ServerSocket server = null;
        try 
            server = new ServerSocket(8003);
            while (true) 
                System.out.println("listening...");

                Socket socket = server.accept();
                System.out.println("连接客户端地址：" + socket.getRemoteSocketAddress());
                System.out.println("connected...");
                ClientHandler handler = new ClientHandler(socket);
                Thread t = new Thread(handler);
                t.start();

            

         catch (Exception e) 
            e.printStackTrace();
         finally 

            if (server != null) 
                try 
                    server.close();
                 catch (IOException e) 

                    e.printStackTrace();
                
            
        
    

    /**
     * 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();
    

2 客户端socket

public class Client 

    public static void main(String[] args) 

        Socket socket = null;
        try 
            System.out.println("connecting...");
            socket = new Socket("127.0.0.1", 8003);
            System.out.println("connection success");

            // 输入任意字符发送，输入q退出
            Scanner in = new Scanner(System.in);
            String str = "01 10 00 00 00 02 04 00 01 00 00 a2 6f"; //发送的16进制字符串
            byte[] bytes = hexStringToByteArray(str);
            OutputStream os = socket.getOutputStream();
            while (!(in.nextLine()).equals("q"))  //输入q退出
                os.write(bytes);
            
            os.close();

         catch (Exception e) 
            e.printStackTrace();
         finally 
            if (socket != null) 
                try 
                    socket.close();
                 catch (Exception e) 

                
            
        
    

    /**
     * 16进制表示的字符串转换为字节数组
     *
     * @param hexString 16进制表示的字符串
     * @return byte[] 字节数组
     */
    public static byte[] hexStringToByteArray(String hexString) 
        hexString = hexString.replaceAll(" ", "");
        int len = hexString.length();
        byte[] bytes = new byte[len / 2];
        for (int i = 0; i < len; i += 2) 
            // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节
            bytes[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character
                    .digit(hexString.charAt(i + 1), 16));
        
        return bytes;