• 视频AI分析定时任务思路解析

    序言：

         最近项目中用到视频ai分析，由于sdk涉及保密，不便透露，仅对定时任务分析的思路作出分享，仅供参考。

    1、定时任务

         由于ai服务器的性能上限，只能同时对64个rtsp流分析一种算法，或者对8个rtsp流分析8种算法。因此定时任务，做如下设计。   

        AiHandlerTask.java 

    1.  
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.alibaba.fastjson.JSONArray;
    5. import com.alibaba.fastjson.JSONObject;
    6. import com.ewaycloud.jw.ai.service.AiService;
    7. import com.ewaycloud.jw.camera.entity.Camera;
    8. import com.ewaycloud.jw.camera.mapper.CameraMapper;
    9. import com.ewaycloud.jw.camera.service.CameraService;
    10. import com.ewaycloud.jw.cases.dto.CaseDTO;
    11. import com.ewaycloud.jw.cases.service.CaseService;
    12. import com.ewaycloud.jw.channel.service.HikService;
    13. import com.ewaycloud.jw.task.entity.Task;
    14. import com.ewaycloud.jw.task.mapper.TaskMapper;
    15. import org.springframework.scheduling.annotation.EnableScheduling;
    16. import org.springframework.stereotype.Component;
    17.  
    18. import javax.annotation.Resource;
    19. import java.util.Date;
    20. import java.util.List;
    21.  
    22. /**
    23.  * AI分析 定时任务 处理类
    24.  *
    25.  * @author gwh
    26.  * @date 2024-04-14 13:59:17
    27.  */
    28. @Component
    29. @EnableScheduling
    30. public class AiHandlerTask {
    31.  
    32.     @Resource
    33.     AiService aiService;
    34.     @Resource
    35.     TaskService taskService;
    36.     @Resource
    37.     CameraService cameraService;
    38.     @Resource
    39.     private TaskMapper taskMapper;
    40.  
    41.     @Resource
    42.     private CameraMapper cameraMapper;
    43.     @Resource
    44.     private HikService hkService;
    45.  
    46.     @Resource
    47.     private CaseService caseService;
    48.  
    49.     /**
    50.      *	注解中的Cron表达式: {秒数} {分钟} {小时} {日期} {月份} {星期} {年份(可为空)}
    51.      *	注意：日和周其中的一个必须为"?"
    52.      *	10/5 20 10 * * ? 每天10点20分第10秒以后，每3秒执行一次，到10点21分就不会执行了
    53.      *
    54.      * AI算法分析任务： 每5秒执行一次
    55.      */
    56. //   @Scheduled(cron = "0/5 * * * * ?")
    57.     public void startTask(){
    58.       // System.out.println("AI分析定时任务执行 每隔5秒执行一次：" + new Date());
    59.        //查询要执行的任务
    60.         List aiTasks = taskMapper.findAiTasks(null);
    61.         if (null != aiTasks) {
    62.             for(Task vo:aiTasks){
    63.                 if (null != vo.getDeptId()) {
    64.                     //查询某谈话室下边的摄像头列表（flag是1 谈话人特写 和2 被谈话人特写 的）
    65.                     List cameraList = cameraMapper.findCamersByDeptId(vo.getDeptId());
    66.                     if (null != cameraList && cameraList.size()>0) {
    67.                         for(Camera camera:cameraList) {
    68.                             //根据摄像头编码cameraCode，调用海康接口拉流
    69.                             String cameraCode = camera.getCameraCode();
    70.                             try {
    71.                                 //根据cameraCode、开始时间、结束时间 调用海康接口 拉回放流
    72.                                 //查询时间（IOS8601格式yyyy-MM-dd'T'HH:mm:ss.SSSzzz，和结束时间相差不超过三天
    73.                                 JSONObject data = hkService.playbackURLs( cameraCode, vo.getStartTime(),  vo.getEndTime());
    74.                                 //谈话人特写AI分析
    75.                                 if (null != data && null != data.getString("url")) {
    76.                                     String rtspUrl = data.getString("url");
    77.                                     //疑似肢体冲突
    78.                                   //  startAiTask(rtspUrl, 1L, vo.getStartTime(), vo.getEndTime(), vo);
    79.                                     //玩手机分析
    80.                                   //  startAiTask(rtspUrl, 2L, vo.getStartTime(), vo.getEndTime(), vo);
    81.                                     //倒地分析
    82.                                   //  startAiTask(rtspUrl, 3L, vo.getStartTime(), vo.getEndTime(), vo);
    83.                                     //人数异常
    84.                                     startAiTask(rtspUrl, 5L, vo.getStartTime(), vo.getEndTime(), vo);
    85.                                 }
    86.                             } catch (Exception e) {
    87.                                 e.printStackTrace();
    88.                             }
    89.                         }
    90.                     }
    91.                 }
    92.             }
    93.         }
    94.       //  System.out.println("AI分析定时任务执行 每隔10秒执行一次:: " + new Date());
    95.     }
    96.  
    97.     //执行拉流调用AI分析的方法
    98.     public void startAiTask(String rtspUrl, Long aiId, String startTime, String endTime, Task vo) {
    99.         //调用AI分析接口
    100.         if (null != rtspUrl) {
    101.             //调用海康AI算法分析
    102.             String aiResponse = "";
    103.             if (aiId == 1) {//疑似肢体冲突
    104.                 aiResponse = aiService.indoorPhysicalConfront(rtspUrl, startTime, endTime);
    105.                 vo.setBreakName("疑似肢体冲突");
    106.                 vo.setAiId(1L);
    107.             } else if (aiId == 2) {//玩手机
    108.                 aiResponse = aiService.playCellphone(rtspUrl, startTime, endTime);
    109.                 vo.setBreakName("玩手机");
    110.                 vo.setAiId(2L);
    111.             } else if (aiId == 3) {//倒地
    112.                 aiResponse = aiService.failDown(rtspUrl, startTime, endTime);
    113.                 vo.setBreakName("倒地");
    114.                 vo.setAiId(3L);
    115.             } else if (aiId == 4) {//人员站立
    116.                 aiResponse = aiService.Standup(rtspUrl,startTime, endTime);
    117.                 vo.setBreakName("人员站立");
    118.                 vo.setAiId(4L);
    119.             } else if (aiId == 5) {//人数异常
    120.                 aiResponse = aiService.PeopleNumChange(rtspUrl, startTime, endTime);
    121.                 vo.setBreakName("人数异常");
    122.                 vo.setAiId(5L);
    123.             } else if (aiId == 6) {//声强突变
    124.                 aiResponse = aiService.audioAbnormal(rtspUrl, startTime, endTime);
    125.                 vo.setBreakName("声强突变");
    126.                 vo.setAiId(6L);
    127.             } else if (aiId == 7) {//超时滞留
    128.                 aiResponse = aiService.overtimeTarry(rtspUrl, startTime, endTime);
    129.                 vo.setBreakName("超时滞留");
    130.                 vo.setAiId(7L);
    131.             } else if (aiId == 8) {//攀高
    132.                 aiResponse = aiService.reachHeight(rtspUrl, startTime, endTime);
    133.                 vo.setBreakName("攀高");
    134.                 vo.setAiId(8L);
    135.             }
    136.             JSONObject aiResponseJSONObject = JSON.parseObject(aiResponse);
    137. //            System.out.println("AI分析定时任务返回aiResponseJSONObject：" + aiResponseJSONObject);
    138.             String taskId = "";
    139.             String taskStatus = "";
    140.             if (null != aiResponseJSONObject && null != aiResponseJSONObject.getString("taskID") ){
    141.                 taskId = aiResponseJSONObject.getString("taskID");
    142.                 //调用海康查询任务状态接口获取AI分析任务状态
    143.                 String result = aiService.queryTaskVideoStatus(taskId);
    144.                 JSONObject resultJSONObject = JSON.parseObject(result);
    145.                 JSONArray statusJSONArray = resultJSONObject.getJSONArray("status");
    146.                 JSONObject statusJSONObject = (JSONObject) statusJSONArray.get(0);
    147.                  taskStatus = statusJSONObject.getString("taskStatus");
    148.                 //将AI分析结果taskStatus插入task表中,更新任务表，状态:1 未执行, 2等待, 3 正在执行 , 4 已完成
    149.                 vo.setTaskState(Integer.parseInt(taskStatus));
    150.                 vo.setTaskId(taskId); //保存 海康返回的 taskID
    151.                 //如果任务完成，关闭rtsp流
    152.                 if ("4".equals(taskStatus)) {
    153.                     //根据caseId更新案件表的 task_state =1 ， ai任务状态（0：未执行  1：已执行）
    154.                     Long caseId = vo.getCaseId();
    155.                     CaseDTO caseDTO = new CaseDTO();
    156.                     caseDTO.setCaseId(caseId);
    157.                     caseDTO.setCaseState(1);
    158.                     caseService.updCaseInfo(caseDTO);
    159.                     //关闭rtsp流
    160.                     try {
    161.                     hkService.clearPlayUrls(rtspUrl);
    162.                     } catch (Exception e) {
    163.                         e.printStackTrace();
    164.                     }
    165.                 }
    166.             }
    167.             System.out.println("AI分析定时任务返回 taskId：" + taskId +" breakName: "+ vo.getBreakName() +" taskStatus: "+ taskStatus);
    168.             //更新任务表, 根据caseId 和taskId查询任务，如果有更新，没有插入
    169.             Task dto = new Task();
    170.                dto.setCaseId(vo.getCaseId());
    171.                dto.setTaskId(vo.getTaskId());
    172.             List tasks = taskMapper.findTasks(dto);
    173.             if(null != tasks && tasks.size()>0){
    174.                 for(Task po : tasks){
    175.                     vo.setId(po.getId());
    176.                     vo.setUpdateTime(new Date());
    177.                     taskService.updateById(po);
    178.                 }
    179.             }else {
    180.                 vo.setCreateTime(new Date());
    181.                 vo.setUpdateTime(new Date());
    182.                 taskMapper.insert(vo);
    183.             }
    184.         }
    185.     }
    186.  
    187. }

    2、算法实现，由于涉密，只贴出接口

    AiService.java

    1.  
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.ewaycloud.jw.ai.entity.Ai;
    5. import com.ewaycloud.jw.task.entity.Task;
    6.  
    7. import java.util.List;
    8.  
    9. /**
    10.  * AI对接
    11.  *
    12.  * @author gwh
    13.  * @date 2024-03-13 13:49:09
    14.  */
    15. public interface AiService extends IService {
    16.  
    17.     String getAiDeviceInfo();
    18.  
    19.     /**
    20.      * 创建--疑似肢体冲突事件--分析视频分析任务
    21.      *
    22.      */
    23.     String indoorPhysicalConfront(String streamUrl, String startTime, String endTime);
    24.  
    25.     /**
    26.      * 创建--玩手机--分析视频分析任务
    27.      *
    28.      */
    29.     String playCellphone(String streamUrl, String startTime, String endTime);
    30.  
    31.     /**
    32.      * 创建--倒地检测--分析视频分析任务
    33.      *
    34.      */
    35.     String failDown(String streamUrl, String startTime, String endTime);
    36.  
    37.     /**
    38.      * 创建--人员站立--分析视频分析任务
    39.      *
    40.      */
    41.     String Standup(String streamUrl, String startTime, String endTime);
    42.  
    43.     /**
    44.      * 创建--人数异常--分析视频分析任务
    45.      *
    46.      */
    47.     String PeopleNumChange(String streamUrl, String startTime, String endTime);
    48.  
    49.  
    50.     /**
    51.      * 创建--声强突变--分析视频分析任务
    52.      *
    53.      */
    54.     String audioAbnormal(String streamUrl, String startTime, String endTime);
    55.  
    56.  
    57.     /**
    58.      * 创建--超时滞留--分析视频分析任务
    59.      *
    60.      */
    61.      String overtimeTarry(String streamUrl, String startTime, String endTime);
    62.  
    63.     /**
    64.      * 创建--攀高--分析视频分析任务
    65.      *
    66.      */
    67.     String reachHeight(String streamUrl, String startTime, String endTime);
    68.  
    69.  
    70.     /**
    71.      * 查询分析视频分析任务状态
    72.      *
    73.      */
    74.     String queryTaskVideoStatus(String taskId);
    75.  
    76.  
    77.  
    78. }

    3、启动一个线程，Socket监听10006端口，接收ai服务器返回的结果

    ListenThread.java

    1.  
    2.  
    3. import com.ewaycloud.jw.ai.entity.AiResolveResult;
    4. import com.ewaycloud.jw.ai.mapper.AiResolveResultMapper;
    5. import com.ewaycloud.jw.task.entity.ContentTypeEnum;
    6. import com.ewaycloud.jw.task.entity.Task;
    7. import com.ewaycloud.jw.task.mapper.TaskMapper;
    8. import com.mysql.cj.util.StringUtils;
    9. import lombok.extern.slf4j.Slf4j;
    10. import org.springframework.stereotype.Service;
    11. import org.springframework.transaction.annotation.Transactional;
    12.  
    13. import javax.annotation.Resource;
    14. import java.io.ByteArrayOutputStream;
    15. import java.io.InputStream;
    16. import java.io.OutputStream;
    17. import java.net.ServerSocket;
    18. import java.net.Socket;
    19. import java.util.Date;
    20. import java.util.List;
    21.  
    22. /**
    23.  * @author gwhui
    24.  * @date 2024/1/18 17:38
    25.  * @desc 监听处理线程
    26.  */
    27. @Slf4j
    28. @Service
    29. public class ListenThread implements Runnable {
    30.     private final AlarmDataParser alarmDataParser = new AlarmDataParser();
    31.  
    32.     private static TaskMapper taskMapper;
    33.     @Resource
    34.     public void setVerificDao(TaskMapper taskMapper) {
    35.         ListenThread.taskMapper = taskMapper;
    36.     }
    37.     private static AiResolveResultMapper aiResolveResultMapper;
    38.     @Resource
    39.     public void setVerificDao(AiResolveResultMapper aiResolveResultMapper) {
    40.         ListenThread.aiResolveResultMapper = aiResolveResultMapper;
    41.     }
    42.  
    43.     @Override
    44.     public void run() {
    45. //        int listenPort = propertiesUtil.getIntegerProperty("custom.isapi.listen.port", 9999);
    46.         int listenPort =10006;
    47.         try {
    48.             ServerSocket serverSocket = new ServerSocket(listenPort);
    49.             System.out.println("启动监听, 监听端口:" + listenPort);
    50.             while (!Thread.currentThread().isInterrupted()) {
    51.                 Socket accept = serverSocket.accept();
    52.                 accept.setKeepAlive(true);
    53.                System.out.println("设备(客户端)信息：" + accept.getInetAddress().getHostAddress());
    54.                 if (accept.isConnected()) {
    55.                     handleData(accept);
    56.                 }
    57.                 accept.close();
    58.             }
    59.             serverSocket.close();
    60.             System.out.println("停止监听完成");
    61.         } catch (InterruptedException e) {
    62.             // 线程被中断的处理逻辑
    63.             System.out.println("停止监听完成: " + e.getMessage());
    64.         } catch (Exception e) {
    65.             System.out.println("监听创建异常: " + e.getMessage());
    66.         }
    67.     }
    68.  
    69.     @Transactional(rollbackFor = Exception.class)
    70.     public synchronized  void handleData(Socket accept) throws Exception {
    71.         InputStream inputData = accept.getInputStream();
    72.         OutputStream outputData = accept.getOutputStream();
    73.  
    74.         // 输出数据
    75.         ByteArrayOutputStream byOutputData = new ByteArrayOutputStream();
    76.  
    77.         byte[] buffer = new byte[2 * 1024 * 1024];
    78.         int length = 0;
    79.  
    80.         // 持续接收处理数据直到接收完毕
    81.         String recvAlarmData = "";
    82.         while ((length = inputData.read(buffer)) > 0) {
    83.             byOutputData.write(buffer, 0, length);
    84.  
    85.             String recvData = byOutputData.toString();
    86.             recvAlarmData = recvAlarmData + recvData;
    87.  
    88.             // 获取boundary
    89.             String strBoundary = "boundary=";
    90.             int beginIndex = recvData.indexOf(strBoundary);
    91.             beginIndex += strBoundary.length();
    92.             int lenIndex = recvData.indexOf("\r\n", beginIndex);
    93.             String strBoundaryMark = recvData.substring(beginIndex, lenIndex);
    94.  
    95.             if (recvAlarmData.contains("--" + strBoundaryMark.trim() + "--")) {
    96.                 //表单结束符判断接收结束
    97.                 break;
    98.             }
    99.         }
    100. //        System.out.println("==============recvAlarmData========>>  "+recvAlarmData);
    101.         if(null != recvAlarmData){
    102.             String taskId = null;
    103.             int index = recvAlarmData.indexOf("");
    104.             if(index != -1){
    105.                 taskId = recvAlarmData.substring(index + 8, index + 40);
    106.             }
    107.             //获取服务器返回的图片
    108.             String bkgUrl = null;
    109.             int indexStartBkgUrl = recvAlarmData.indexOf("");
    110.             int indexEndBkgUrl = recvAlarmData.indexOf("");
    111.             if(indexStartBkgUrl != -1){
    112.                 bkgUrl = recvAlarmData.substring(indexStartBkgUrl+8, indexEndBkgUrl);
    113.                 bkgUrl =bkgUrl.replaceAll("&","&");
    114.             }
    115.             System.out.println("===AIrecieveData===>>taskId:  "+taskId +" bkgUrl: "+ bkgUrl);
    116.             //根据taskId查询 任务信息
    117.             if(!StringUtils.isNullOrEmpty(taskId)){
    118.                 Task task = taskMapper.finTaskByTaskId(taskId);
    119.                 if(null != task){
    120.                         AiResolveResult vo = new AiResolveResult();
    121.                         vo.setCreateTime(new Date());
    122.                         vo.setUpdateTime(new Date());
    123.                         vo.setTaskId(taskId); //保存海康返回的 taskId
    124.                         vo.setBreakName(task.getBreakName());
    125.                         vo.setAiId(task.getAiId());
    126.                         vo.setDeptId(task.getDeptId());
    127.                         vo.setCameraId(task.getCameraId());
    128.                         vo.setBreakTypeId(task.getAiId());
    129.                         vo.setRiskTime(task.getTalkTime());
    130.                         vo.setTalkAddress(task.getTalkAddress());
    131.                         vo.setTalkAddressName(task.getTalkAddressName());
    132.                         vo.setTalkUnit(task.getTalkUnit());
    133.                         vo.setTalkUnitName(task.getTalkUnitName());
    134.                         vo.setPhoto(bkgUrl); //保存海康返回的图片
    135.                         vo.setCaseId(task.getCaseId());
    136.                         vo.setCaseName(task.getCaseName());
    137.                         vo.setInterviewerName(task.getInterviewerName());
    138.                         //根据taskId查询任务结果表，如果有做更新操作，没有做插入操作
    139.                         List  aiResolveResults  =  aiResolveResultMapper.findAiResults(vo);
    140.                         if(null != aiResolveResults && aiResolveResults.size()>0){
    141.                             for(AiResolveResult aiResolveResult:aiResolveResults){
    142.                                 if(null != aiResolveResult){
    143.                                     aiResolveResult.setPhoto(vo.getPhoto());
    144.                                     aiResolveResultMapper.updateById(aiResolveResult);
    145.                                 }
    146.                             }
    147.                         }else {
    148.                             aiResolveResultMapper.insert(vo);
    149.                         }
    150.                 }
    151.  
    152.             }
    153.         }
    154.         String response = "HTTP/1.1 200 OK" +
    155.                 "\r\n" +
    156.                 "Connection: close" +
    157.                 "\r\n\r\n";
    158.         outputData.write(response.getBytes());
    159.         outputData.flush();
    160.         outputData.close();
    161.         inputData.close();
    162.         //解析数据
    163.         response = parseAlarmInfoByte(byOutputData);
    164.         System.out.println("==============response========>>  "+response);
    165.     }
    166.  
    167.     private String parseAlarmInfoByte(ByteArrayOutputStream byOutputData) throws Exception {
    168.         // 事件报文字节
    169.         byte[] byAlarmDataInfo = byOutputData.toByteArray();
    170.         int iDataLen = byAlarmDataInfo.length;
    171.  
    172.         String szBoundaryMark = "boundary=";
    173.         String szContentTypeMark = "Content-Type: ";
    174.         int iTypeMarkLen = szContentTypeMark.getBytes("UTF-8").length;
    175.         String szContentLenMark = "Content-Length: ";
    176.         int iLenMarkLen = szContentLenMark.getBytes("UTF-8").length;
    177.         String szContentLenMark2 = "content-length: ";
    178.         int iLenMarkLen2 = szContentLenMark2.getBytes("UTF-8").length;
    179.         int iContentLen = 0;
    180.         String szEndMark = "\r\n";
    181.         int iMarkLen = szEndMark.getBytes("UTF-8").length;
    182.         String szEndMark2 = "\r\n\r\n";
    183.         int iMarkLen2 = szEndMark2.getBytes("UTF-8").length;
    184.         String szJson = "text/json";
    185.         String szJpg = "image/jpeg";
    186.  
    187.         int iStartBoundary = doDataSearch(byAlarmDataInfo, szBoundaryMark.getBytes("UTF-8"), 0, byAlarmDataInfo.length);
    188.         iStartBoundary += szBoundaryMark.getBytes("UTF-8").length;
    189.         int iEndBoundary = doDataSearch(byAlarmDataInfo, szEndMark.getBytes("UTF-8"), iStartBoundary, byAlarmDataInfo.length);
    190.         byte[] byBoundary = new byte[iEndBoundary - iStartBoundary];
    191.         System.arraycopy(byAlarmDataInfo, iStartBoundary, byBoundary, 0, iEndBoundary - iStartBoundary);
    192.  
    193.         String szBoundaryEndMark = "--" + new String(byBoundary).trim() + "--";
    194.         int iDateEnd = doDataSearch(byAlarmDataInfo, szBoundaryEndMark.getBytes("UTF-8"), 0, byAlarmDataInfo.length);
    195.  
    196.         String szBoundaryMidMark = "--" + new String(byBoundary).trim();
    197.         int iBoundaryMidLen = szBoundaryMidMark.getBytes("UTF-8").length;
    198.         int startIndex = iEndBoundary;
    199.  
    200.         String szContentType = "";
    201.  
    202.         int[] iBoundaryPos = new int[11]; //boundary个数，这里最大解析10个
    203.         int iBoundaryNum = 0;
    204.         for (iBoundaryNum = 0; iBoundaryNum < 10; iBoundaryNum++) {
    205.             startIndex = doDataSearch(byAlarmDataInfo, szBoundaryMidMark.getBytes("UTF-8"), startIndex, iDateEnd);
    206.             if (startIndex < 0) {
    207.                 break;
    208.             }
    209.             startIndex += iBoundaryMidLen;
    210.             iBoundaryPos[iBoundaryNum] = startIndex;
    211.         }
    212.         iBoundaryPos[iBoundaryNum] = iDateEnd;//最后一个是结束符
    213.  
    214.         for (int i = 0; i < iBoundaryNum; i++) {
    215.             // Content-Type
    216.             int iStartType = doDataSearch(byAlarmDataInfo, szContentTypeMark.getBytes("UTF-8"), iBoundaryPos[i], iBoundaryPos[i + 1]);
    217.             if (iStartType > 0) {
    218.                 iStartType += iTypeMarkLen;
    219.                 int iEndType = doDataSearch(byAlarmDataInfo, szEndMark.getBytes("UTF-8"), iStartType, iBoundaryPos[i + 1]);
    220.                 if (iEndType > 0) {
    221.                     byte[] byType = new byte[iEndType - iStartType];
    222.                     System.arraycopy(byAlarmDataInfo, iStartType, byType, 0, iEndType - iStartType);
    223.                     szContentType = new String(byType).trim();
    224.                 }
    225.             }
    226.  
    227.             // Content-Length
    228.             int iStartLength = doDataSearch(byAlarmDataInfo, szContentLenMark.getBytes("UTF-8"), iBoundaryPos[i], iBoundaryPos[i + 1]);
    229.             if (iStartLength > 0) {
    230.                 iStartLength += iLenMarkLen;
    231.                 int iEndLength = doDataSearch(byAlarmDataInfo, szEndMark.getBytes("UTF-8"), iStartLength, iBoundaryPos[i + 1]);
    232.                 if (iEndLength > 0) {
    233.                     byte[] byLength = new byte[iEndLength - iStartLength];
    234.                     System.arraycopy(byAlarmDataInfo, iStartLength, byLength, 0, iEndLength - iStartLength);
    235.                     iContentLen = Integer.parseInt(new String(byLength).trim());
    236.                 }
    237.             }
    238.  
    239.             // Content-Length(兼容错误大小写)
    240.             int iStartLength2 = doDataSearch(byAlarmDataInfo, szContentLenMark2.getBytes("UTF-8"), iBoundaryPos[i], iBoundaryPos[i + 1]);
    241.             if (iStartLength2 > 0) {
    242.                 iStartLength2 += iLenMarkLen2;
    243.                 int iEndLength2 = doDataSearch(byAlarmDataInfo, szEndMark.getBytes("UTF-8"), iStartLength2, iBoundaryPos[i + 1]);
    244.                 if (iEndLength2 > 0) {
    245.                     byte[] byLength2 = new byte[iEndLength2 - iStartLength2];
    246.                     System.arraycopy(byAlarmDataInfo, iStartLength2, byLength2, 0, iEndLength2 - iStartLength2);
    247.                     iContentLen = Integer.parseInt(new String(byLength2).trim());
    248.                 }
    249.             }
    250.  
    251.             // 通过\r\n\r\n判断报文数据起始位置
    252.             int iStartData = doDataSearch(byAlarmDataInfo, szEndMark2.getBytes("UTF-8"), iBoundaryPos[i], iBoundaryPos[i + 1]);
    253.             if (iStartData > 0) {
    254.                 iStartData += iMarkLen2;
    255.  
    256.                 // 有的报文可能没有Content-Length
    257.                 if (iContentLen <= 0) {
    258.                     iContentLen = iBoundaryPos[i + 1] - iStartData;
    259.                 }
    260.  
    261.                 // 截取数据内容
    262.                 byte[] byData = new byte[iContentLen];
    263.                 System.arraycopy(byAlarmDataInfo, iStartData, byData, 0, iContentLen);
    264.  
    265.                 // 根据类型处理数据
    266.                 int contentType = ContentTypeEnum.getEventType(szContentType);
    267.                 String storeFolder = System.getProperty("user.dir") + "\\output\\listen\\event\\";
    268.                 switch (contentType) {
    269.                     case ContentTypeEnum.APPLICATION_JSON:
    270.                     case ContentTypeEnum.APPLICATION_XML: {
    271.                         String rawContent = new String(byData).trim();
    272.                         alarmDataParser.parseAlarmInfo(contentType, storeFolder, rawContent, null);
    273.                         break;
    274.                     }
    275.                     case ContentTypeEnum.IMAGE_JPEG:
    276.                     case ContentTypeEnum.IMAGE_PNG:
    277.                     case ContentTypeEnum.VIDEO_MPG:
    278.                     case ContentTypeEnum.VIDEO_MPEG4:
    279.                     case ContentTypeEnum.APPLICATION_ZIP: {
    280.                         alarmDataParser.parseAlarmInfo(contentType, storeFolder, null, byData);
    281.                         break;
    282.                     }
    283.                     default: {
    284.                         System.out.println("未匹配到可以解析的content-type, 请自行补全处理!");
    285.                     }
    286.                 }
    287.             }
    288.         }
    289.         // 响应报文
    290.         String response = "";
    291.  
    292.         // 消费交易事件 （实际如果没有消费机设备可以不需要消费机的处理代码）
    293.         String eventType = "";
    294.         String eventConfirm = "";
    295.         if (eventType.equals("ConsumptionEvent") || eventType.equals("TransactionRecordEvent") || eventType.equals("HealthInfoSyncQuery")) {
    296.             response = "HTTP/1.1 200 OK" +
    297.                     "\r\n" +
    298.                     "Content-Type: application/json; charset=\"UTF-8\"" +
    299.                     "\r\n" +
    300.                     "Content-Length: " + eventConfirm.length() +
    301.                     "\r\n\r\n" + eventConfirm +
    302.                     "\r\n";
    303.         } else {
    304.             response = "HTTP/1.1 200 OK" +
    305.                     "\r\n" +
    306.                     "Connection: close" +
    307.                     "\r\n\r\n";
    308.         }
    309.  
    310.         return response;
    311.     }
    312.  
    313.     private int doDataSearch(byte[] bySrcData, byte[] keyData, int startIndex, int endIndex) {
    314.         if (bySrcData == null || keyData == null || bySrcData.length <= startIndex || bySrcData.length < keyData.length) {
    315.             return -1;
    316.         }
    317.  
    318.         if (endIndex > bySrcData.length) {
    319.             endIndex = bySrcData.length;
    320.         }
    321.  
    322.         int iPos, jIndex;
    323.         for (iPos = startIndex; iPos < endIndex; iPos++) {
    324.             if (bySrcData.length < keyData.length + iPos) {
    325.                 break;
    326.             }
    327.  
    328.             for (jIndex = 0; jIndex < keyData.length; jIndex++) {
    329.                 if (bySrcData[iPos + jIndex] != keyData[jIndex]) {
    330.                     break;
    331.                 }
    332.             }
    333.             if (jIndex == keyData.length) {
    334.                 return iPos;
    335.             }
    336.         }
    337.         return -1;
    338.     }
    339.  
    340.  
    341. }

    4、数据库设计

    瀚高国产数据库

            

    5、前端页面设计

  • 相关阅读:
    SPI在Java中的实现与应用 | 京东物流技术团队
    逻辑回归——线性二分类（机器学习）
    嵌入式Linux应用开发-第十三章APP怎么读取按键值
    Java刷题day28
    计算摄影——图像超分
    CDGA|做数据安全治理，先考个DAMA证书吧！
    docker部署最新版nacos(2.2.3)设置登录密码
    c语言实现数据结构中的带头双向循环链表
    【解决方案】如何使用 Http API 代替 OpenFeign 进行远程服务调用
    CompletableFuture理解与应用
  • 原文地址：https://blog.csdn.net/gaowenhui2008/article/details/139832836