Java对接硬件接口，采用Scoket连接，数据报文通信

第一次对接这玩意，也是RLG!!! 对接硬件不都用C来搞吗？没法奈何我只会java

不废话，先直接上部分对接需求文档>>>

 

先解读一下以上的东西，看备注可知，以0x  开头，基本确定是全是16进制的东西

先理一下，

类型为Byte， 一个字节等于2位16进制数

类型为Uint ...反正跟java中的"int"八九不离十， int占4个字节等于8位16进制数

类型为Ushort ...反正跟java中的"short八九不离十， short占2个字节等于4位16进制数

还有个要注意的点，数字类型高低位排序。低位在“前”按照甲方爸爸给的提示，这个“前”是从右往左排 ，意思是越小的，越排在后面

以长度lenth举个栗子吧：

      //当长度 lenth=18时

       int lenth=18；

      //转16进制
       String lenthHex = Integer.toHexString(lenth);

      //这时的lenthHex应该等于12，但是文档要求长度为4x2位16进制，于是 
      //往前补0，这是的lenthHex等于00000012
      //再低位在前排序，注意，此处全部都是这对于字节，于是2位一体倒序
      //输出lenthHex=12000000

下面给出 设备登录的需求文档来做一次实际操作

    //设备登陆测试
    final static String info =
            "01" +//开始标记
            "41000000" +//长度 LEN  原值为65 （低位排序）
            "00000000" +//
            "00000000" +//
            "01" +//版本
            "4B03" +//命令   原值为843 （低位排序）
            "1B00ED8B91D23143AFE845EAA4F7EFCF" +//唯一标识 （随便填的，文档只要求保证唯一性）
            //content 原值为 厂家识别码：15EFD2B2FD6B476697B729F33D08630A+设备的唯一标识码:5078c650bac04a0fa190bb7480573f26 +xor运算可参考 http://www.ip33.com/bcc.html
            "31354546443242324644364234373636393742373239463333443038363330413530373863363530626163303461306661313930626237343830353733663236" +"05" +//xor运算
            "00" +//状态
            "01";//结束标记

 来看一下测试工具的返回结果

 

 

 返回Flag区域=00表示处理成功

下面给出java代码中如何实现发送和接收数据代码，基于springboot，为了性能全局只创建一次连接

数据发送者

/**
 * 在项目启动完成后启动 优先级1，发送数据直接调用sendMsg方法即可
 */

@Component
@Order(value = 1)
public class BaseServer implements ApplicationRunner {

private final static Logger logger = LoggerFactory.getLogger(AttendanceServer.class); private static final ThreadLocal<Socket> threadConnect = new ThreadLocal<Socket>(); //对方域名 private static final String HOST = ""; //对方监听端口 private final static int PORT = 8080; //服务输出流 public static OutputStream outStr = null; //服务输入流 public static InputStream inStr = null; //Socket连接 public static Socket client;

 public void run(ApplicationArguments args) throws Exception { try { //初始化连接 this.connect(); }catch (Exception e){ logger.error("初始化连接服务出现异常！"+e.getMessage()); e.printStackTrace(); } } /** * 连接初始化方法 * @throws Exception */ public static void connect() throws Exception { client = threadConnect.get(); //如果client为空，则建立一次新的连接 if (client == null) { client = new Socket(HOST, PORT); threadConnect.set(client); logger.info("服务初始化成功！"); } outStr = client.getOutputStream(); inStr = client.getInputStream(); } /** * 关闭连接方法 * @throws Exception */ public static void disconnect() { try { outStr.close(); inStr.close(); client.close(); outStr=null; inStr=null; client=null; } catch (IOException e) { e.printStackTrace(); } } /** * 发送数据方法(添加同步锁，防止输出流被写入垃圾数据) * @param info */ public synchronized static void sendMsg(String info) { byte[] m = HexUtil.hexStringToBytes(info); try { logger.info("准备发送报文："+info); Thread.sleep(1500); outStr.write(m); outStr.flush(); } catch (Exception e) { e.printStackTrace(); //如果此处捕获到异常，直接关闭当前连接，然后重新初始化 logger.info("发送报文出现异常，即将重新建立连接！"); disconnect(); try { //初始化连接  connect(); }catch (Exception ex){ logger.error("初始化连接服务出现异常！"+ex.getMessage()); ex.printStackTrace(); } } } }

接收者服务

/**
 * 数据接收服务 ,继承自连接服务
 * 在项目启动完成后启动 优先级2
 */
@Component
@Order(value = 2)
public class Receiver extends BaseServer implements ApplicationRunner {

    private final Logger logger = LoggerFactory.getLogger(Receiver.class);


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

        logger.info("数据接收服务初始化成功！");

        try {

            while (true) {

                byte[] b = new byte[1024];

                if (inStr == null) {
                    //可能是连接还在初始化中，需要等待
                    continue;
                }

                Thread.sleep(500);

                if (inStr.available() > 0)  {

                    int r = inStr.read(b);

                    if (r > -1) {

                        String result = HexUtil.BinaryToHexString(b);
                    }
                }
            }

        } catch (IOException e) {

            logger.error("数据接收服务出现异常" + e.getMessage() + "原因是:");

            e.printStackTrace();

        }

    }

}

 

 进制转换工具类 

public class HexUtil {

    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        // toUpperCase将字符串中的所有字符转换为大写
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        // toCharArray将此字符串转换为一个新的字符数组。
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }
    //charToByte返回在指定字符的第一个发生的字符串中的索引，即返回匹配字符
    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }


    public static String BinaryToHexString(byte[] bytes) {
        String hexStr = "0123456789ABCDEF";
        String result = "";
        String hex = "";
        for (byte b : bytes) {
            hex = String.valueOf(hexStr.charAt((b & 0xF0) >> 4));
            hex += String.valueOf(hexStr.charAt(b & 0x0F));
            result += hex ;
        }
        return result;
    }

    //两位一字符，倒序排序
    public static String reverseString(String str) {

        List<String> strlist=new ArrayList();

        char[] chr = str.toCharArray();

        for (int i = 0 ; i < chr.length; i=i+2) {

            String s=chr[i]+""+chr[i+1];

            strlist.add(s);

        }
        Collections.reverse(strlist);

        String result="";

        for(String v:strlist){

            result+=v;
        }
        return result;

    }

    /**
     * 16进制转换成为string类型字符串
     * @param s
     * @return
     */
    public static String hexStringToString(String s) {
        if (s == null || s.equals("")) {
            return null;
        }
        s = s.replace(" ", "");
        byte[] baKeyword = new byte[s.length() / 2];
        for (int i = 0; i < baKeyword.length; i++) {
            try {
                baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        try {
            s = new String(baKeyword, "UTF-8");
            new String();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return s;
    }


    /**
     * 字符串转化成为16进制字符串
     * @param s
     * @return
     */
    public static String strTo16(String s) {
        String str = "";
        for (int i = 0; i < s.length(); i++) {
            int ch = (int) s.charAt(i);
            String s4 = Integer.toHexString(ch);
            str = str + s4;
        }
        return str;
    }

    //将16进制字符串自动补全到8位 并且倒序排序
    public static String full8(String lenth) {

        int a = lenth.getBytes().length;

        int b = 8 - a;

        for (int i = 0; i < b; i++) {

            lenth = "0" + lenth;

        }

        return reverseString(lenth);
    }

    /**
     * xor运算
     *
     * @param data
     * @return
     */
    public static String getBCC(byte[] data) {

        String ret = "";
        byte BCC[] = new byte[1];
        for (int i = 0; i < data.length; i++) {
            BCC[0] = (byte) (BCC[0] ^ data[i]);
        }
        String hex = Integer.toHexString(BCC[0] & 0xFF);
        if (hex.length() == 1) {
            hex = '0' + hex;
        }
        ret += hex.toUpperCase();
        return ret;
    }
}

稍微修改一下就能用了