Java-Spring Boot 集成海康威视明眸门禁 布防|报警|回调|获取事件|查询用户信息

最近做门禁的集成，突然感觉海康这个东西挺有意思的，于是记录一下。

好了废话不多说，开始上环境、代码

本集成是海康-设备网络集成（以人为中心）

环境：windows

开发工具：IDEA

JDK版本：JDK-11.0.12

海康jar包：怎么引入都行（本地引入、maven上传到私服）

                链接：https://pan.baidu.com/s/12limkwExPqn9q-vUc6zA6g?pwd=xr0s 
                提取码：xr0s 

海康库：

        windows环境：链接：https://pan.baidu.com/s/10iADLziw-jdxWd9Awmuu4Q?pwd=o26k 
                                提取码：o26k 

        linux环境：     链接：https://pan.baidu.com/s/10iADLziw-jdxWd9Awmuu4Q?pwd=o26k 
                                提取码：o26k 

布防整体流程：

我们就以此流程开始：

1、初始化SDK：

    /**
     * 海康设备提前操作方法（第一步）
     */
    private Integer preparation(String ip, String user, String password, Integer port, Boolean isLogin) {
        // 创建操作类
        createHkSdkInstance();
        // 加载组件库
        loadLinuxSystem(SystemHkSelect.isLinux());
        // 初始话操作类
        HK_NET_SDK.NET_DVR_Init();

        log.info("海康设备初始化成功！");
        // 操作完成，首先登录设备
        return loginAccessHk(ip, user, password, ObjectUtils.isNotEmpty(port) ? Short.parseShort(port.toString()) : (short) 8000;
    }

参数解释：

ip：门禁设备的IP地址

user：门禁设备的管理员

password：管理员密码

port：端口   默认8000

isLogin：暂时无用

    /**
     * 创建海康SDK操作类（第二步）
     */
    private void createHkSdkInstance() {
        try {
            // 海康SDK操作类
            if (HK_NET_SDK == null) {
                log.info("海康SDK操作类为空，开始创建海康SDK操作类");
                HK_NET_SDK = (HCNetSDK) Native.loadLibrary(stringDllPath,         
                HCNetSDK.class);
                log.info("海康SDK操作类创建成功");
            } else {
                log.info("海康SDK操作类不为空，无需创建");
            }
        } catch (Exception e) {
            throw exception(UNKNOWN_OPERATING_SYSTEM);
        }
    }

参数解释：

 stringDllPath：海康库的加载地址（配置成海康库里HCNetSDK.dll这个文件的路径）

        windows环境：C:\\Users\\PinRu\\Desktop\\CH-HCNetSDKV6.1.9.48_build20230410_win64\\lib\\HCNetSDK.dll

        linux环境：C:\\Users\\PinRu\\Desktop\\CH-HCNetSDKV6.1.9.48_build20230410_linux64\\lib\\libhcnetsdk.so

/**
 * linux系统建议调用以下接口加载组件库（win下不需要操作）（第三步）
 */
private void loadLinuxSystem(Boolean isLinux) {
        // linux系统建议调用以下接口加载组件库（win下不需要操作）
        if (isLinux) {
            log.info("加载海康组件库" + isLinux);
            HCNetSDK.BYTE_ARRAY ptrByteArray1 = new HCNetSDK.BYTE_ARRAY(256);
            HCNetSDK.BYTE_ARRAY ptrByteArray2 = new HCNetSDK.BYTE_ARRAY(256);
            //这里是库的绝对路径，请根据实际情况修改，注意改路径必须有访问权限
            // cry组件库
            System.arraycopy(stringCryPath.getBytes(), 0, ptrByteArray1.byValue, 0,
                    stringCryPath.length());
            ptrByteArray1.write();
            HK_NET_SDK.NET_DVR_SetSDKInitCfg(3, ptrByteArray1.getPointer());
            System.arraycopy(stringSslPath.getBytes(), 0, ptrByteArray2.byValue, 0,
                    stringSslPath.length());
            ptrByteArray2.write();
            // ssl组件库
            HK_NET_SDK.NET_DVR_SetSDKInitCfg(4, ptrByteArray2.getPointer());
            HCNetSDK.NET_DVR_LOCAL_SDK_PATH strComPath = new HCNetSDK.NET_DVR_LOCAL_SDK_PATH();
            // lib组件库
            System.arraycopy(stringLibPath.getBytes(), 0, strComPath.sPath, 0,
                    stringLibPath.length());
            strComPath.write();
            HK_NET_SDK.NET_DVR_SetSDKInitCfg(2, strComPath.getPointer());
        }
    }

参数解释： 

 isLinusx：是否是linux环境（win开发环境下，直接写成false）

stringCryPath：cry路径         默认路径：/lib/libcrypto.so.1.1

stringSslPath：ssl路径          默认路径：/lib/libssl.so.1.1

stringLibPath：lib库路径       默认路径：/lib/

2、用户注册

    public static Integer loginAccessHk(String deviceIp, String userName, String password,
            short port) {
        //注册（登录海康设备）
        //设备登录信息
        HCNetSDK.NET_DVR_USER_LOGIN_INFO strLoginInfo = new HCNetSDK.NET_DVR_USER_LOGIN_INFO();
        //设备ip地址
        strLoginInfo.sDeviceAddress = new byte[HCNetSDK.NET_DVR_DEV_ADDRESS_MAX_LEN];
        System.arraycopy(deviceIp.getBytes(), 0, strLoginInfo.sDeviceAddress, 0, deviceIp.length());

        //设备用户名
        strLoginInfo.sUserName = new byte[HCNetSDK.NET_DVR_LOGIN_USERNAME_MAX_LEN];
        System.arraycopy(userName.getBytes(), 0, strLoginInfo.sUserName, 0, userName.length());

        //设备密码
        strLoginInfo.sPassword = new byte[HCNetSDK.NET_DVR_LOGIN_PASSWD_MAX_LEN];
        System.arraycopy(password.getBytes(), 0, strLoginInfo.sPassword, 0, password.length());

        //sdk端口
        strLoginInfo.wPort = port;
        //是否异步登录：0- 否，1- 是
        strLoginInfo.bUseAsynLogin = false;
        strLoginInfo.write();
        //设备信息
        HCNetSDK.NET_DVR_DEVICEINFO_V40 strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V40();
        AtomicInteger userId = new AtomicInteger(-1);
        userId.set(HK_NET_SDK.NET_DVR_Login_V40(strLoginInfo, strDeviceInfo));
        if (userId.get() == -1) {
            return HK_NET_SDK.NET_DVR_GetLastError();
        } else {
            log.info("设备登录成功，用户ID：" + userId);
            strDeviceInfo.read();
            CHAR_ENCODE_TYPE = strDeviceInfo.byCharEncodeType;
        }
        return userId.get();
    }

参数解释：

deviceIp：门禁设备的IP地址

userName：门禁设备的管理员

password：管理员密码

port：端口   默认8000

3、门禁设备布防

    public Boolean equipmentRegistration() {
        // 设备准备工作（必须调用）
        try {
            Integer userId = preparation("", "", "", null, null);
            // 回调函数
            if (callBack == null) {
                callBack = new HkEquipmentCallBack();
            }
            // 设置回调
            HK_NET_SDK.NET_DVR_SetDVRMessageCallBack_V50(0, callBack, null);
            //布防参数
            HCNetSDK.NET_DVR_SETUPALARM_PARAM_V50 param =
                    new HCNetSDK.NET_DVR_SETUPALARM_PARAM_V50();
            param.dwSize = param.size();
            //布防等级
            param.byLevel = 0;
            // 智能交通报警信息上传类型：0- 老报警信息（NET_DVR_PLATE_RESULT），1- 新报警信息(NET_ITS_PLATE_RESULT)
            param.byAlarmInfoType = 1;
            //布防类型：0-客户端布防，1-实时布防
            param.byDeployType = 1;
            param.write();
            // 设备布防
            int v41 = HK_NET_SDK.NET_DVR_SetupAlarmChan_V50(userId, param, null, 0);

            if (v41 < 0) {
                log.info("设备布防失败，布防结果：" + v41);
                // 布防失败
                logout(userId);
            }
        } catch (Exception e) {
            log.error("门禁设备设置门禁布防失败！错误信息：", e);
            return Boolean.FALSE;
        }
        log.info("布防成功");
        return Boolean.TRUE;
    }

HkEquipmentCallBack 布防回调：

import cn.hutool.extra.spring.SpringUtil;
import com.sun.jna.Pointer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * 布防回调的入口
 */
@Component
@Slf4j
public class HkEquipmentCallBack implements HCNetSDK.FMSGCallBack_V31 {

    @Override
    public boolean invoke(int lCommand, HCNetSDK.NET_DVR_ALARMER pAlar, Pointer pAlarmInfo,
            int dwBufLen, Pointer pUser) {
        log.info("hk alarm call back，type：{}", lCommand);
        // 轮询处理事件回调
        switch (lCommand) {
            case HCNetSDK.COMM_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_TRADEINFO:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ALARM_V30:
                break;
            case HCNetSDK.COMM_ALARM_V40:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ALARM_RULE:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_IPCCFG:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_UPLOAD_FACESNAP_RESULT:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_SNAP_MATCH_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ALARM_ACS:
                // 门禁设备主机报警
                EquipmentHandle handle = SpringUtil.getBean(EquipmentHandle.class);
                handle.equipmentHandleMethod(pAlar, pAlarmInfo);
                break;
            case HCNetSDK.COMM_ID_INFO_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_VCA_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ISAPI_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ALARMHOST_CID_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_SWITCH_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ALARMHOST_EXCEPTION:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ALARMHOST_OPERATEEVENT_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ALARMHOST_ALARMOUTSTATUS:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_UPLOAD_VIDEO_INTERCOM_EVENT:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_ALARM_VIDEO_INTERCOM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_THERMOMETRY_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_FIREDETECTION_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_THERMOMETRY_DIFF_ALARM:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_UPLOAD_AIOP_VIDEO:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_UPLOAD_AIOP_POLLING_SNAP:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_UPLOAD_AIOP_POLLING_VIDEO:
                saveEquipmentLog(pAlar);
                break;
            case HCNetSDK.COMM_IPC_AUXALARM_RESULT:
                saveEquipmentLog(pAlar);
                break;
            default:
                break;
        }
        return false;
    }

    private void saveEquipmentLog(HCNetSDK.NET_DVR_ALARMER pAlar) {
        // 给个回调，嗨嗨嗨
        log.info("此报警暂时不需要做何处理，休息一下吧~~~~");
    }
}

布防回调目前我这只用到主机报警

报警处理类EquipmentHandle ：

import cn.hutool.core.codec.Base64Encoder;
import cn.hutool.extra.spring.SpringUtil;
import com.sun.jna.Pointer;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import java.nio.Buffer;
import java.nio.ByteBuffer;

/**
 * 门禁设备布防报警-回调的处理类
 */
@Component
@Slf4j
public class EquipmentHandle {

    public void equipmentHandleMethod(HCNetSDK.NET_DVR_ALARMER pAlar, Pointer pAlarmInfo) {
        // 设备主机事件
        HCNetSDK.NET_DVR_ACS_ALARM_INFO strAcsInfo = new HCNetSDK.NET_DVR_ACS_ALARM_INFO();
        strAcsInfo.write();
        Pointer pAcsInfo = strAcsInfo.getPointer();
        pAcsInfo.write(0, pAlarmInfo.getByteArray(0, strAcsInfo.size()), 0, strAcsInfo.size());
        strAcsInfo.read();
        // 门禁事件的详细信息解析，通过主次类型的可以判断当前的具体门禁类型，例如（主类型：0X5 次类型：0x4b 表示人脸认证通过，
        // 主类型：0X5 次类型：0x4c 表示人脸认证失败）
        saveEquipmentLogAcs(pAlar, strAcsInfo);
    }

    private void saveEquipmentLogAcs(HCNetSDK.NET_DVR_ALARMER pAlar, HCNetSDK.NET_DVR_ACS_ALARM_INFO strAcsInfo) {
        // 获取事件的类型
        String messageMain = HkEventEnum.getMessageByCode(strAcsInfo.dwMajor);
        String message = HkEventEnum.getMessageByCode(strAcsInfo.dwMinor);
        if (ObjectUtils.isEmpty(messageMain) && ObjectUtils.isEmpty(message)) {
            // 主级事件为null，则不记录
            return;
        }
        if (HkEventEnum.Hk_Event_84.getEventType().equals(strAcsInfo.dwMinor)
                || HkEventEnum.Hk_Event_85.getEventType().equals(strAcsInfo.dwMinor)
                || HkEventEnum.Hk_Event_1024.getEventType().equals(strAcsInfo.dwMinor)) {
            // 屏蔽部分非法事件
            return;
        }
        
        // 获取卡号
        String byCardNo = new String(strAcsInfo.struAcsEventInfo.byCardNo).trim();
        log.info("卡号：" + byCardNo);
        // 获取卡类型 人员类型（0：白名单，1：访客，2：黑名单）
        String byCardType = String.valueOf(strAcsInfo.struAcsEventInfo.byCardType);
        // 设备唯一编码
        String byDeviceNo = String.valueOf(strAcsInfo.struAcsEventInfo.byDeviceNo);
        // 通进类型（0：入场，1：离场）
        String dwDoorNo = String.valueOf(strAcsInfo.struAcsEventInfo.dwDoorNo);

        // 给个回调，嗨嗨嗨
        HkCallBackBuilderVo builder = new HkCallBackBuilderVo(pAlar);
        log.info("获取到的本机IP地址：{}", builder.sDeviceIpStr);

        // 人员工号，需要关联查询
        if (ObjectUtils.isNotEmpty(builder.sDeviceIpStr)) {
            // 获取设备详情
            // 取值类型
            HkAdapter hkAdapter = SpringUtil.getBean(HkAdapter.class);
            log.info("当前回调的事件编号：{}", strAcsInfo.struAcsEventInfo.dwSerialNo);
            String employeeNo = hkAdapter.selectEmployeeNo(strAcsInfo.struAcsEventInfo.dwSerialNo, null);
            log.info("获取到的用户编码：{}", employeeNo);
            // 获取人员名称
            if (ObjectUtils.isNotEmpty(employeeNo)) {
                String userName = hkAdapter.selectUserName(employeeNo);
                log.info("获取到的用户名称：{}", userName);
            } else {

                String cardNo = hkAdapter.selectEmployeeNo(strAcsInfo.struAcsEventInfo.dwSerialNo,
                        EnableFlagEnum.ENABLE_STATUS_1.getCode());
                log.info("获取到的用户卡号：{}", cardNo);
            }

            // 人脸图片数据
            String dataBytes = null;
            if (strAcsInfo.dwPicDataLen > 0) {
                long offset = 0;
                Buffer buffers = strAcsInfo.pPicData.getByteBuffer(offset, strAcsInfo.dwPicDataLen);
                // 转换成64单独存储
                dataBytes = assembleDataBytes(buffers, strAcsInfo.dwPicDataLen);
            }
            log.info("获取到的人脸图片数据：{}", dataBytes);
        }

    }

    private String assembleDataBytes(Buffer buffers, int dwSnapPicLen) {
        byte[] bytes = new byte[dwSnapPicLen];
        buffers.rewind();
        ((ByteBuffer) buffers).get(bytes);
        // 人脸图片数据
        return (ObjectUtils.isNotEmpty(bytes) ? "data:image/jpg;base64," + Base64Encoder.encode(bytes) : StringUtils.EMPTY);
    }

EquipmentHandle - HkCallBackBuilderVo：

import lombok.Data;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;

import java.nio.charset.StandardCharsets;

/**
 * description
 */
@Data
public class HkCallBackBuilderVo {
    /**
     * userid是否有效 0-无效，1-有效
     */
    public byte byUserIdValid;
    /**
     * 序列号是否有效 0-无效，1-有效
     */
    public byte bySerialValid;
    /**
     * 版本号是否有效 0-无效，1-有效
     */
    public byte byVersionValid;
    /**
     * 设备名字是否有效 0-无效，1-有效
     */
    public byte byDeviceNameValid;
    /**
     * MAC地址是否有效 0-无效，1-有效
     */
    public byte byMacAddrValid;
    /**
     * login端口是否有效 0-无效，1-有效
     */
    public byte byLinkPortValid;
    /**
     * 设备IP是否有效 0-无效，1-有效
     */
    public byte byDeviceIpValid;
    /**
     * socket ip是否有效 0-无效，1-有效
     */
    public byte bySocketIpValid;
    /**
     * NET_DVR_Login()返回值, 布防时有效
     */
    public int lUserId;
    /**
     * 序列号
     */
    public String sSerialNumberStr;
    /**
     * 版本信息 高16位表示主版本，低16位表示次版本
     */
    public int dwDeviceVersion;
    /**
     * 设备名字
     */
    public String sDeviceNameStr;
    /**
     * MAC地址
     */
    public String byMacAddrStr;
    /**
     * link port
     */
    public short wLinkPort;
    /**
     * IP地址
     */
    public String sDeviceIpStr;
    /**
     * 报警主动上传时的socket IP地址
     */
    public String sSocketIpStr;
    /**
     * Ip协议 0-IPV4, 1-IPV6
     */
    public byte byIpProtocol;
    /**
     * 主动推送
     */
    public String byRes2Str;

    public HkCallBackBuilderVo(HCNetSDK.NET_DVR_ALARMER pAlar) {
        byUserIdValid = pAlar.byUserIDValid;
        bySerialValid = pAlar.bySerialValid;
        byVersionValid = pAlar.byVersionValid;
        byDeviceNameValid = pAlar.byDeviceNameValid;
        byMacAddrValid = pAlar.byMacAddrValid;
        byLinkPortValid = pAlar.byLinkPortValid;
        byDeviceIpValid = pAlar.byDeviceIPValid;
        bySocketIpValid = pAlar.bySocketIPValid;
        lUserId = pAlar.lUserID;
        sSerialNumberStr = ObjectUtils.isNotEmpty(pAlar.sSerialNumber) ? StringUtils.toEncodedString(pAlar.sSerialNumber, StandardCharsets.UTF_8) : StringUtils.EMPTY;
        dwDeviceVersion = pAlar.dwDeviceVersion;
        sDeviceNameStr = ObjectUtils.isNotEmpty(pAlar.sDeviceName)? StringUtils.toEncodedString(pAlar.sDeviceName, StandardCharsets.UTF_8) : StringUtils.EMPTY;
        byMacAddrStr = ObjectUtils.isNotEmpty(pAlar.byMacAddr)? StringUtils.toEncodedString(pAlar.byMacAddr, StandardCharsets.UTF_8) : StringUtils.EMPTY;
        wLinkPort = pAlar.wLinkPort;
        sDeviceIpStr = ObjectUtils.isNotEmpty(pAlar.sDeviceIP)? StringUtils.toEncodedString(pAlar.sDeviceIP, StandardCharsets.UTF_8) : StringUtils.EMPTY;
        sSocketIpStr = ObjectUtils.isNotEmpty(pAlar.sSocketIP)? StringUtils.toEncodedString(pAlar.sSocketIP, StandardCharsets.UTF_8) : StringUtils.EMPTY;
        byIpProtocol = pAlar.byIpProtocol;
        byRes2Str = ObjectUtils.isNotEmpty(pAlar.byRes2)? StringUtils.toEncodedString(pAlar.byRes2, StandardCharsets.UTF_8) : StringUtils.EMPTY;
    }

海康适配器（包含设备注册-用户注册-用户登出-布防-查询用户-查询事件）：

/**
 * 海康适配器
 */
@Component
@Slf4j
public class HkAdapter {
    // 1. 海康的门禁 || 后端需要先引入海康操作库，目前不在项目内集成海康操作库，是通过海康开放平台
    // 【https://open.hikvision.com/download/5cda567cf47ae80dd41a54b3?type=10】获取的操作库，
    // 不同的服务器须集成不同的操作库，否则会出现异常

    // 2. Windows开发时需要将“库文件”文件夹中的HCNetSDK.dll、HCCore.dll、HCNetSDKCom文件夹、libssl-1_1-x64.dll、
    // libcrypto-1_1-x64.dll、hlog.dll、hpr.dll、zlib1.dll等文件拷贝到lib文件夹下，HCNetSDKCom文件夹（包含里面的功能组件dll库文件）
    // 需要和HCNetSDK.dll、HCCore.dll一起加载，放在同一个目录下，且HCNetSDKCom文件夹名不能修改。如果自行开发软件不能正常实现相应功能，
    // 而且程序没有指定加载的dll库路径，请在程序运行的情况下尝试删除HCNetSDK.dll。如果可以删除，说明程序可能调用到系统盘
    // Windows->System32目录下的dll文件，建议删除或者更新该目录下的相关dll文件；如果不能删除，dll文件右键选择属性确认SDK库版本。
    //
    // 3. Linux开发时需要将“库文件”文件夹中libhcnetsdk.so、libHCCore.so、libcrypto.so.1.1、libssl.so.1.1、libhpr.so、
    // libz.so等文件拷贝到lib文件夹下。HCNetSDKCom文件夹（包含里面的功能组件dll库文件）需要和libhcnetsdk.so、
    // libHCCore.so一起加载，放在同一个目录下，且HCNetSDKCom文件夹名不能修改。如果库文件加载有问题，初始化失败，
    // 也可以尝试将SDK所在路径添加到LD_LIBRARY_PATH环境变量中。

    // 4. 具体请参考海康的开发文档以及文件包结构

    /**
     * 组件库路径
     */
    private String stringDllPath;

    /**
     * cry路径
     */
    private String stringCryPath;

    /**
     * ssl路径
     */
    private String stringSslPath;

    /**
     * lib路径
     */
    private String stringLibPath;

    /**
     * 海康SDK
     */
    static HCNetSDK HK_NET_SDK = null;

    /**
     * 海康设备字符集
     */
    static int CHAR_ENCODE_TYPE = 0;

    /**
     * 全局回调
     */
    static HkEquipmentCallBack callBack;

    /**
     * 海康设备提前操作方法（定时任务登录认证使用）
     *
     * @param equipment 门禁基本信息
     */
    public Integer preparationScheduled(GuardEquipmentRespVO equipment) {
        try {

            // 设置回调
            // 当返回值是true时，说明host是可用的，false则不可。
            try {
                boolean status = InetAddress.getByName(equipment.getAddressIp()).isReachable(3000);
                if (!status) {
                    return EntranceConstants.NET_DVR_NETWORK_FAIL_CONNECT;
                }
            } catch (IOException e) {
                return EntranceConstants.NET_DVR_NETWORK_FAIL_CONNECT;
            }

            return EntranceConstants.NET_DVR_NO_ERROR;
        } catch (Exception e) {
            log.error("海康设备加载失败！错误信息：", e);
            // 错误状态默认给离线
            return EntranceConstants.NET_DVR_NETWORK_FAIL_CONNECT;
        }
    }

    /**
     * 海康设备提前操作方法（必须提前调用）
     *
     * @param equipment 门禁基本信息
     */
    private Integer preparation(String ip, String user, String password, Integer port, Boolean isLogin) {
        // 创建操作类
        createHkSdkInstance();
        // 加载组件库
        loadLinuxSystem(SystemHkSelect.isLinux());
        // 初始话操作类
        HK_NET_SDK.NET_DVR_Init();

        log.info("海康设备初始化成功！");
        // 操作完成，首先登录设备
        return loginAccessHk(ip, user, password, ObjectUtils.isNotEmpty(port) ? Short.parseShort(port.toString())
                        : (short) 8000);
    }

    /**
     * 创建海康SDK操作类，调用海康SDK接口
     * 根据不同操作系统选择不同的库文件和库路径
     * 固定方式不可更改
     */
    private void createHkSdkInstance() {
        try {
            // 海康SDK操作类
            if (HK_NET_SDK == null) {
                log.info("海康SDK操作类为空，开始创建海康SDK操作类");
                HK_NET_SDK = (HCNetSDK) Native.loadLibrary(stringDllPath, HCNetSDK.class);
                log.info("海康SDK操作类创建成功");
            } else {
                log.info("海康SDK操作类不为空，无需创建");
            }
        } catch (Exception e) {
            log.info("海康SDK操作类创建失败");
        }
    }

    private void loadLinuxSystem(Boolean isLinux) {
        // linux系统建议调用以下接口加载组件库（win下不需要操作）
        if (isLinux) {
            log.info("加载海康组件库" + isLinux);
            HCNetSDK.BYTE_ARRAY ptrByteArray1 = new HCNetSDK.BYTE_ARRAY(256);
            HCNetSDK.BYTE_ARRAY ptrByteArray2 = new HCNetSDK.BYTE_ARRAY(256);
            //这里是库的绝对路径，请根据实际情况修改，注意改路径必须有访问权限
            // cry组件库
            System.arraycopy(stringCryPath.getBytes(), 0, ptrByteArray1.byValue, 0,
                    stringCryPath.length());
            ptrByteArray1.write();
            HK_NET_SDK.NET_DVR_SetSDKInitCfg(3, ptrByteArray1.getPointer());
            System.arraycopy(stringSslPath.getBytes(), 0, ptrByteArray2.byValue, 0,
                    stringSslPath.length());
            ptrByteArray2.write();
            // ssl组件库
            HK_NET_SDK.NET_DVR_SetSDKInitCfg(4, ptrByteArray2.getPointer());
            HCNetSDK.NET_DVR_LOCAL_SDK_PATH strComPath = new HCNetSDK.NET_DVR_LOCAL_SDK_PATH();
            // lib组件库
            System.arraycopy(stringLibPath.getBytes(), 0, strComPath.sPath, 0,
                    stringLibPath.length());
            strComPath.write();
            HK_NET_SDK.NET_DVR_SetSDKInitCfg(2, strComPath.getPointer());
        }
    }

    public static Integer loginAccessHk(String deviceIp, String userName, String password,
            short port) {
        //注册（登录海康设备）
        //设备登录信息
        HCNetSDK.NET_DVR_USER_LOGIN_INFO strLoginInfo = new HCNetSDK.NET_DVR_USER_LOGIN_INFO();
        //设备ip地址
        strLoginInfo.sDeviceAddress = new byte[HCNetSDK.NET_DVR_DEV_ADDRESS_MAX_LEN];
        System.arraycopy(deviceIp.getBytes(), 0, strLoginInfo.sDeviceAddress, 0, deviceIp.length());

        //设备用户名
        strLoginInfo.sUserName = new byte[HCNetSDK.NET_DVR_LOGIN_USERNAME_MAX_LEN];
        System.arraycopy(userName.getBytes(), 0, strLoginInfo.sUserName, 0, userName.length());

        //设备密码
        strLoginInfo.sPassword = new byte[HCNetSDK.NET_DVR_LOGIN_PASSWD_MAX_LEN];
        System.arraycopy(password.getBytes(), 0, strLoginInfo.sPassword, 0, password.length());

        //sdk端口
        strLoginInfo.wPort = port;
        //是否异步登录：0- 否，1- 是
        strLoginInfo.bUseAsynLogin = false;
        strLoginInfo.write();
        //设备信息
        HCNetSDK.NET_DVR_DEVICEINFO_V40 strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V40();
        AtomicInteger userId = new AtomicInteger(-1);
        userId.set(HK_NET_SDK.NET_DVR_Login_V40(strLoginInfo, strDeviceInfo));
        if (userId.get() == -1) {
            return HK_NET_SDK.NET_DVR_GetLastError();
        } else {
            log.info("设备登录成功，用户ID：" + userId);
            strDeviceInfo.read();
            CHAR_ENCODE_TYPE = strDeviceInfo.byCharEncodeType;
        }
        return userId.get();
    }

    /**
     * 登出（完成工作指令时，必须调用）
     */
    public static void logout(Integer userId) {
        // 登出和清理设备操作缓存，释放SDK资源
        if (userId >= 0) {
            if (!HK_NET_SDK.NET_DVR_Logout(userId)) {
                log.info("设备注销失败");
            }
            log.info("设备注销成功，用户ID：" + userId);
        }

        // 释放SDK资源，防止一直占用内存
        HK_NET_SDK.NET_DVR_Cleanup();
    }

    /**
     * 查询人员信息（预留）
     */
    public String eventUserInfo(Integer userId, String equipmentNo) {
        //数组
        HCNetSDK.BYTE_ARRAY ptrByteArray = new HCNetSDK.BYTE_ARRAY(1024);
        //字符串拷贝到数组中
        System.arraycopy(USER_INFO.getBytes(), 0, ptrByteArray.byValue, 0, USER_INFO.length());
        ptrByteArray.write();

        int lHandler = HK_NET_SDK.NET_DVR_StartRemoteConfig(userId, HCNetSDK.NET_DVR_JSON_CONFIG,
                ptrByteArray.getPointer(), USER_INFO.length(), null, null);
        if (lHandler < 0) {
            log.info("SearchUserInfo失败,错误码为" + HK_NET_SDK.NET_DVR_GetLastError());
        } else {
            //组装查询的JSON报文，这边查询的是所有的人员
            JSONObject jsonObject = new JSONObject();
            JSONObject jsonSearchCond = new JSONObject();

            // 查询指定的工号人员信息
            JSONArray jsonArray = new JSONArray();
            if (ObjectUtils.isNotEmpty(equipmentNo)) {
                jsonArray.put(new JSONObject().set("employeeNo", equipmentNo));
            }
            jsonSearchCond.set("EmployeeNoList", jsonArray);
            jsonSearchCond.set("searchID",
                    DateUtil.format(new Date(), DatePattern.PURE_DATE_PATTERN));
            jsonSearchCond.set("searchResultPosition", 0);
            jsonSearchCond.set("maxResults", 50);
            jsonObject.set("UserInfoSearchCond", jsonSearchCond);

            String toString = jsonObject.toString();
            log.info("查询的json报文:" + toString);

            //把string传递到Byte数组中，后续用.getPointer()方法传入指针地址中。
            HCNetSDK.BYTE_ARRAY byteArray = new HCNetSDK.BYTE_ARRAY(toString.length());
            System.arraycopy(toString.getBytes(), 0, byteArray.byValue, 0, toString.length());
            byteArray.write();

            //定义接收结果的结构体
            HCNetSDK.BYTE_ARRAY ptrOutBuff = new HCNetSDK.BYTE_ARRAY(10 * 1024);

            IntByReference pInt = new IntByReference(0);

            while (true) {
                int dwState = HK_NET_SDK.NET_DVR_SendWithRecvRemoteConfig(lHandler,
                        byteArray.getPointer(),
                        toString.length(), ptrOutBuff.getPointer(), 20 * 1024, pInt);
                if (dwState == -1) {
                    break;
                } else if (dwState == HCNetSDK.NET_SDK_CONFIG_STATUS_NEED_WAIT) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else if (dwState == HCNetSDK.NET_SDK_CONFIG_STATUS_FAILED) {
                    log.error("查询人员失败");
                    break;
                } else if (dwState == HCNetSDK.NET_SDK_CONFIG_STATUS_EXCEPTION) {
                    log.error("查询人员异常");
                    break;
                } else if (dwState == HCNetSDK.NET_SDK_CONFIG_STATUS_SUCCESS) {
                    ptrOutBuff.read();

                    String trim = new String(ptrOutBuff.byValue).trim();
                    // 得到的人员信息
                    try {
                        ObjectMapper objectMapper = new ObjectMapper();
                        JsonNode rootNode = objectMapper.readTree(trim);
                        JsonNode userInfoSearch = rootNode.get("UserInfoSearch");
                        JsonNode userInfo = userInfoSearch.get("UserInfo");
                        JsonNode userInfoOne = userInfo.get(0);
                        JsonNode name = userInfoOne.get("name");
                        return name.asText();
                    } catch (JsonProcessingException e) {
                        return StringUtils.EMPTY;
                    }
                } else if (dwState == HCNetSDK.NET_SDK_CONFIG_STATUS_FINISH) {
                    log.error("获取人员完成");
                    break;
                }
            }

            if (!HK_NET_SDK.NET_DVR_StopRemoteConfig(lHandler)) {
                log.error("NET_DVR_StopRemoteConfig接口调用失败，错误码：" + HK_NET_SDK.NET_DVR_GetLastError());
            } else {
                log.info("NET_DVR_StopRemoteConfig接口成功");
            }
        }
        return null;
    }
    
    public String selectEmployeeNo(Integer dwSerialNo,
            Integer isCard) {
        // 设备准备工作（必须调用）
        Integer userId = preparation("", "", "", null, null);
        // 通过事件类型拿到人员工号
        String event = searchAllEvent(userId, dwSerialNo, isCard);
        // 句柄完成，登出设备（必须调用）
        logout(userId);

        return event;
    }

    public String selectUserName(String employeeNo) {
        // 设备准备工作（必须调用）
        Integer userId = preparation("", "", "", null, null);
        // 通过事件类型拿到人员工号
        String event = eventUserInfo(userId, employeeNo);
        // 句柄完成，登出设备（必须调用）
        logout(userId);

        return event;
    }

    public static String searchAllEvent(int userId, Integer dwSerialNo, Integer isCard) {
        //事件条数
        int i = 0;
        HCNetSDK.NET_DVR_ACS_EVENT_COND strAcsEventCond = new HCNetSDK.NET_DVR_ACS_EVENT_COND();
        strAcsEventCond.read();
        strAcsEventCond.dwSize = strAcsEventCond.size();
        // 查询全部主次类型的报警
        strAcsEventCond.dwMajor = 0;
        // 查询次事件报警类型
        strAcsEventCond.dwMinor = 0;
        strAcsEventCond.dwBeginSerialNo = dwSerialNo;
        strAcsEventCond.dwEndSerialNo = dwSerialNo;
        strAcsEventCond.write();
        Pointer condPointer = strAcsEventCond.getPointer();
        int remoteConfig = HK_NET_SDK.NET_DVR_StartRemoteConfig(userId,
                HCNetSDK.NET_DVR_GET_ACS_EVENT,
                condPointer, strAcsEventCond.size(), null, null);
        if (remoteConfig <= -1) {
            log.info("NET_DVR_StartRemoteConfig调用失败，错误信息：" +HK_NET_SDK.NET_DVR_GetLastError());
        }
        HCNetSDK.NET_DVR_ACS_EVENT_CFG eventCfg = new HCNetSDK.NET_DVR_ACS_EVENT_CFG();
        eventCfg.read();
        eventCfg.dwSize = eventCfg.size();
        eventCfg.write();
        Pointer cfgPointer = eventCfg.getPointer();
        while (true) {
            int dwEventSearch = HK_NET_SDK.NET_DVR_GetNextRemoteConfig(remoteConfig, cfgPointer,
                    eventCfg.size());
            if (dwEventSearch == HCNetSDK.NET_SDK_NEXT_STATUS__FINISH) {
                break;
            } else if (dwEventSearch == HCNetSDK.NET_SDK_GET_NEXT_STATUS_FAILED) {
                break;
            } else if (dwEventSearch == HCNetSDK.NET_SDK_GET_NEXT_STATUS_SUCCESS) {
                eventCfg.read();
                //获取的事件信息通过eventCfg结构体进行解析
                if (ObjectUtils.isNotEmpty(isCard)) {
                    return new String(eventCfg.struAcsEventInfo.byCardNo).trim()
                            .replace(new String(new char[]{160}), StringUtils.EMPTY);
                }
                return new String(eventCfg.struAcsEventInfo.byEmployeeNo).trim()
                        .replace(new String(new char[]{160}), StringUtils.EMPTY);
            }
            i++;
        }
        return null;
    }
}

好了，这就是海康布防回调、获取用户信息、获取事件类型的所有了，写的比较粗糙，有错误的地方希望大家能指正。

补：代码补全

 

HkEventEnum

import lombok.Getter;
import lombok.RequiredArgsConstructor;

/**
 * 门禁在线状态
 *
 * @author Pinru
 * @version 1.0.0
 * @create 2023/8/23 11:53
 */
@RequiredArgsConstructor
public enum HkEventEnum {
    /**
     * 合法卡认证通过
     */
    Hk_Event_0("MINOR_LEGAL_CARD_PASS", 0x01, "合法卡认证通过"),
    /**
     * 刷卡加密码认证通过
     */
    Hk_Event_2("MINOR_CARD_AND_PSW_PASS", 0x02, "刷卡加密码认证通过"),
    /**
     * 刷卡加密码认证失败
     */
    Hk_Event_3("MINOR_CARD_AND_PSW_FAIL", 0x03, "刷卡加密码认证失败"),
    /**
     * 数卡加密码认证超时
     */
    Hk_Event_4("MINOR_CARD_AND_PSW_TIMEOUT", 0x04, "数卡加密码认证超时"),
    /**
     * 刷卡加密码超次
     */
    Hk_Event_5("MINOR_CARD_AND_PSW_OVER_TIME", 0x05, "刷卡加密码超次"),
    /**
     * 未分配权限
     */
    Hk_Event_6("MINOR_CARD_NO_RIGHT", 0x06, "未分配权限"),
    /**
     * 无效时段
     */
    Hk_Event_7("MINOR_CARD_INVALID_PERIOD", 0x07, "无效时段"),
    /**
     * 卡号过期
     */
    Hk_Event_8("MINOR_CARD_OUT_OF_DATE", 0x08, "卡号过期"),
    /**
     * 无此卡号
     */
    Hk_Event_9("MINOR_INVALID_CARD", 0x09, "无此卡号"),
    /**
     * 反潜回认证失败
     */
    Hk_Event_10("MINOR_ANTI_SNEAK_FAIL", 0x0a, "反潜回认证失败"),
    /**
     * 卡不属于多重认证群组
     */
    Hk_Event_11("MINOR_NOT_BELONG_MULTI_GROUP", 0x0c, "卡不属于多重认证群组"),
    /**
     * 卡不在多重认证时间段内
     */
    Hk_Event_12("MINOR_INVALID_MULTI_VERIFY_PERIOD", 0x0d, "卡不在多重认证时间段内"),
    /**
     * 多重认证模式超级权限认证失败
     */
    Hk_Event_13("MINOR_MULTI_VERIFY_SUPER_RIGHT_FAIL", 0x0e, "多重认证模式超级权限认证失败"),
    /**
     * 多重认证模式远程认证失败
     */
    Hk_Event_14("MINOR_MULTI_VERIFY_REMOTE_RIGHT_FAIL", 0x0f, "多重认证模式远程认证失败"),
    /**
     * 多重认证成功
     */
    Hk_Event_15("MINOR_MULTI_VERIFY_SUCCESS", 0x10, "多重认证成功"),
    /**
     * 首卡开门开始
     */
    Hk_Event_16("MINOR_LEADER_CARD_OPEN_BEGIN", 0x11, "首卡开门开始"),
    /**
     * 首卡开门结束
     */
    Hk_Event_17("MINOR_LEADER_CARD_OPEN_END", 0x12, "首卡开门结束"),
    /**
     * 常开状态开始
     */
    Hk_Event_18("MINOR_ALWAYS_OPEN_BEGIN", 0x13, "常开状态开始"),
    /**
     * 常开状态结束
     */
    Hk_Event_19("MINOR_ALWAYS_OPEN_END", 0x14, "常开状态结束"),
    /**
     * 门锁打开
     */
    Hk_Event_20("MINOR_LOCK_OPEN", 0x15, "门锁打开"),
    /**
     * 门锁关闭
     */
    Hk_Event_21("MINOR_LOCK_CLOSE", 0x16, "门锁关闭"),
    /**
     * 开门按钮打开
     */
    Hk_Event_22("MINOR_DOOR_BUTTON_PRESS", 0x17, "开门按钮打开"),
    /**
     * 开门按钮放开
     */
    Hk_Event_23("MINOR_DOOR_BUTTON_RELEASE", 0x18, "开门按钮放开"),
    /**
     * 正常开门
     */
    Hk_Event_24("MINOR_DOOR_OPEN_NORMAL", 0x19, "正常开门（门磁）"),
    /**
     * 正常关门
     */
    Hk_Event_25("MINOR_DOOR_CLOSE_NORMAL", 0x1a, "正常关门（门磁）"),
    /**
     * 门异常打开
     */
    Hk_Event_26("MINOR_DOOR_OPEN_ABNORMAL", 0x1b, "门异常打开（门磁）"),
    /**
     * 门打开超时
     */
    Hk_Event_27("MINOR_DOOR_OPEN_TIMEOUT", 0x1c, "门打开超时（门磁）"),
    /**
     * 报警输出打开
     */
    Hk_Event_28("MINOR_ALARMOUT_ON", 0x1d, "报警输出打开"),
    /**
     * 报警输出关闭
     */
    Hk_Event_29("MINOR_ALARMOUT_OFF", 0x1e, "报警输出关闭"),
    /**
     * 常关状态开始
     */
    Hk_Event_30("MINOR_ALWAYS_CLOSE_BEGIN", 0x1f, "常关状态开始"),
    /**
     * 常关状态结束
     */
    Hk_Event_31("MINOR_ALWAYS_CLOSE_END", 0x20, "常关状态结束"),
    /**
     * 多重认证需要远程开门
     */
    Hk_Event_32("MINOR_MULTI_VERIFY_NEED_REMOTE_OPEN", 0x21, "多重多重认证需要远程开门"),
    /**
     * 多重认证超级密码认证成功
     */
    Hk_Event_33("MINOR_MULTI_VERIFY_SUPERPASSWD_VERIFY_SUCCESS", 0x22, "多重认证超级密码认证成功事件"),
    /**
     * 多重认证重复认证
     */
    Hk_Event_34("MINOR_MULTI_VERIFY_REPEAT_VERIFY", 0x23, "多重认证重复认证事件"),
    /**
     * 多重认证超时
     */
    Hk_Event_35("MINOR_MULTI_VERIFY_TIMEOUT", 0x24, "多重认证重复认证事件"),
    /**
     * 门铃响
     */
    Hk_Event_36("MINOR_DOORBELL_RINGING", 0x25, "门铃响"),
    /**
     * 指纹比对通过
     */
    Hk_Event_37("MINOR_FINGERPRINT_COMPARE_PASS", 0x26, "指纹比对通过"),
    /**
     * 指纹比对失败
     */
    Hk_Event_38("MINOR_FINGERPRINT_COMPARE_FAIL", 0x27, "指纹比对失败"),
    /**
     * 刷卡加指纹认证通过
     */
    Hk_Event_39("MINOR_CARD_FINGERPRINT_VERIFY_PASS", 0x28, "刷卡加指纹认证通过"),
    /**
     * 刷卡加指纹认证失败
     */
    Hk_Event_40("MINOR_CARD_FINGERPRINT_VERIFY_FAIL", 0x29, "刷卡加指纹认证失败"),
    /**
     * 刷卡加指纹认证超时
     */
    Hk_Event_41("MINOR_CARD_FINGERPRINT_VERIFY_TIMEOUT", 0x2a, "刷卡加指纹认证超时"),
    /**
     * 刷卡加指纹加密码认证通过
     */
    Hk_Event_42("MINOR_CARD_FINGERPRINT_PASSWD_VERIFY_PASS", 0x2b, "刷卡加指纹加密码认证通过"),
    /**
     * 刷卡加指纹加密码认证失败
     */
    Hk_Event_43("MINOR_CARD_FINGERPRINT_PASSWD_VERIFY_FAIL", 0x2c, "刷卡加指纹加密码认证失败"),
    /**
     * 刷卡加指纹加密码认证超时
     */
    Hk_Event_44("MINOR_CARD_FINGERPRINT_PASSWD_VERIFY_TIMEOUT", 0x2d, "刷卡加指纹加密码认证超时"),
    /**
     * 指纹加密码认证通过
     */
    Hk_Event_45("MINOR_FINGERPRINT_PASSWD_VERIFY_PASS", 0x2e, "指纹加密码认证通过"),
    /**
     * 指纹加密码认证失败
     */
    Hk_Event_46("MINOR_FINGERPRINT_PASSWD_VERIFY_FAIL", 0x2f, "指纹加密码认证失败"),
    /**
     * 指纹加密码认证超时
     */
    Hk_Event_47("MINOR_FINGERPRINT_PASSWD_VERIFY_TIMEOUT", 0x30, "指纹加密码认证超时"),
    /**
     * 指纹不存在
     */
    Hk_Event_48("MINOR_FINGERPRINT_INEXISTENCE", 0x31, "指纹不存在"),
    /**
     * 呼叫中心
     */
    Hk_Event_49("MINOR_CALL_CENTER", 0x33, "呼叫中心事件"),
    /**
     * 人脸加指纹认证通过
     */
    Hk_Event_50("MINOR_FACE_AND_FP_VERIFY_PASS", 0x36, "人脸加指纹认证通过"),
    /**
     * 人脸加指纹认证失败
     */
    Hk_Event_51("MINOR_FACE_AND_FP_VERIFY_FAIL", 0x37, "人脸加指纹认证失败"),
    /**
     * 人脸加指纹认证超时
     */
    Hk_Event_52("MINOR_FACE_AND_FP_VERIFY_TIMEOUT", 0x38, "人脸加指纹认证超时"),
    /**
     * 人脸加密码认证通过
     */
    Hk_Event_53("MINOR_FACE_AND_PW_VERIFY_PASS", 0x39, "人脸加密码认证通过"),
    /**
     * 人脸加密码认证失败
     */
    Hk_Event_54("MINOR_FACE_AND_PW_VERIFY_FAIL", 0x3a, "人脸加密码认证失败"),
    /**
     * 人脸加密码认证超时
     */
    Hk_Event_55("MINOR_FACE_AND_PW_VERIFY_TIMEOUT", 0x3b, "人脸加密码认证超时"),
    /**
     * 人脸加刷卡认
     */
    Hk_Event_56("MINOR_FACE_AND_CARD_VERIFY_PASS", 0x3c, "人脸加刷卡认证通过"),
    /**
     * 人脸加刷卡认证失败
     */
    Hk_Event_57("MINOR_FACE_AND_CARD_VERIFY_FAIL", 0x3d, "人脸加刷卡认证失败"),
    /**
     * 人脸加刷卡认证超时
     */
    Hk_Event_58("MINOR_FACE_AND_CARD_VERIFY_TIMEOUT", 0x3e, "人脸加刷卡认证超时"),
    /**
     * 人脸加密码加指纹认证通过
     */
    Hk_Event_59("MINOR_FACE_AND_PW_AND_FP_VERIFY_PASS", 0x3f, "人脸加密码加指纹认证通过"),
    /**
     * 人脸加密码加指纹认证失败
     */
    Hk_Event_60("MINOR_FACE_AND_PW_AND_FP_VERIFY_FAIL", 0x40, "人脸加密码加指纹认证失败"),
    /**
     * 人脸加密码加指纹认证超时
     */
    Hk_Event_61("MINOR_FACE_AND_PW_AND_FP_VERIFY_TIMEOUT", 0x41, "人脸加密码加指纹认证超时"),
    /**
     * 人脸加刷卡加指纹认证通过
     */
    Hk_Event_62("MINOR_FACE_CARD_AND_FP_VERIFY_PASS", 0x42, "人脸加刷卡加指纹认证通过"),
    /**
     * 人脸加刷卡加指纹认证失败
     */
    Hk_Event_63("MINOR_FACE_CARD_AND_FP_VERIFY_FAIL", 0x43, "人脸加刷卡加指纹认证失败"),
    /**
     * 人脸加刷卡加指纹认证超时
     */
    Hk_Event_64("MINOR_FACE_CARD_AND_FP_VERIFY_TIMEOUT", 0x44, "人脸加刷卡加指纹认证超时"),
    /**
     * 工号加指纹认证通过
     */
    Hk_Event_65("MINOR_EMPLOYEENO_AND_FP_VERIFY_PASS", 0x45, "工号加指纹认证通过"),
    /**
     * 工号加指纹认证失败
     */
    Hk_Event_66("MINOR_EMPLOYEENO_AND_FP_VERIFY_FAIL", 0x46, "工号加指纹认证失败"),
    /**
     * 工号加指纹认证超时
     */
    Hk_Event_67("MINOR_EMPLOYEENO_AND_FP_VERIFY_TIMEOUT", 0x47, "工号加指纹认证超时"),
    /**
     * 工号加指纹加密码认证通过
     */
    Hk_Event_68("MINOR_EMPLOYEENO_AND_FP_AND_PW_VERIFY_PASS", 0x48, "工号加指纹加密码认证通过"),
    /**
     * 工号加指纹加密码认证失败
     */
    Hk_Event_69("MINOR_EMPLOYEENO_AND_FP_AND_PW_VERIFY_FAIL", 0x49, "工号加指纹加密码认证失败"),
    /**
     * 工号加指纹加密码认证超时
     */
    Hk_Event_70("MINOR_EMPLOYEENO_AND_FP_AND_PW_VERIFY_TIMEOUT", 0x4a, "工号加指纹加密码认证超时"),
    /**
     * 人脸认证通过
     */
    Hk_Event_71("MINOR_FACE_VERIFY_PASS", 0x4b, "人脸认证通过"),
    /**
     * 人脸认证失败
     */
    Hk_Event_72("MINOR_FACE_VERIFY_FAIL", 0x4c, "人脸认证失败"),
    /**
     * 工号加人脸认证通过
     */
    Hk_Event_73("MINOR_EMPLOYEENO_AND_FACE_VERIFY_PASS", 0x4d, "工号加人脸认证通过"),
    /**
     * 工号加人脸认证失败
     */
    Hk_Event_74("MINOR_EMPLOYEENO_AND_FACE_VERIFY_FAIL", 0x4e, "工号加人脸认证失败"),
    /**
     * 工号加人脸认证超时
     */
    Hk_Event_75("MINOR_EMPLOYEENO_AND_FACE_VERIFY_TIMEOUT", 0x4f, "工号加人脸认证超时"),
    /**
     * 人脸识别失败
     */
    Hk_Event_76("MINOR_FACE_RECOGNIZE_FAIL", 0x50, "人脸识别失败"),
    /**
     * 首卡授权开始
     */
    Hk_Event_77("MINOR_FIRSTCARD_AUTHORIZE_BEGIN", 0x51, "首卡授权开始"),
    /**
     * 首卡授权结束
     */
    Hk_Event_78("MINOR_FIRSTCARD_AUTHORIZE_END", 0x52, "首卡授权结束"),
    /**
     * 工号加密码认证通过
     */
    Hk_Event_79("MINOR_EMPLOYEENO_AND_PW_PASS", 0x65, "工号加密码认证通过"),
    /**
     * 工号加密码认证失败
     */
    Hk_Event_80("MINOR_EMPLOYEENO_AND_PW_FAIL", 0x66, "工号加密码认证失败"),
    /**
     * 工号加密码认证超时
     */
    Hk_Event_81("MINOR_EMPLOYEENO_AND_PW_TIMEOUT", 0x67, "工号加密码认证超时"),
    /**
     * 真人检测失败
     */
    Hk_Event_82("MINOR_HUMAN_DETECT_FAIL", 0x68, "真人检测失败"),
    /**
     * 人证比对通过
     */
    Hk_Event_83("MINOR_PEOPLE_AND_ID_CARD_COMPARE_PASS", 0x69, "人证比对通过"),
    /**
     * 人证比对失败
     */
    Hk_Event_84("MINOR_PEOPLE_AND_ID_CARD_COMPARE_FAIL", 0x70, "人证比对失败"),
    /**
     * 非授权名单事件
     */
    Hk_Event_85("MINOR_CERTIFICATE_BLACK_LIST", 0x71, "非授权名单事件"),

    /**
     * 非法事件
     */
    Hk_Event_1024("MINOR_CERTIFICATE_ILLEGAL", 1024, "非法事件");

    /**
     * 编码
     */
    @Getter
    private final String code;

    /**
     * 名称
     */
    @Getter
    private final Integer eventType;

    /**
     * 错误信息
     */
    @Getter
    private final String message;

    public static String getMessageByCode(String code) {
        for (HkEventEnum anEnum : HkEventEnum.values()) {
            if (anEnum.getCode().equals(code)) {
                return anEnum.getMessage();
            }
        }
        return null;
    }

    public static String getMessageByCode(Integer eventType) {
        for (HkEventEnum anEnum : HkEventEnum.values()) {
            if (anEnum.getEventType().equals(eventType)) {
                return anEnum.getMessage();
            }
        }
        return null;
    }
}

GuardEquipmentRespVO

import cn.hutool.core.date.DatePattern;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.*;

import java.util.Date;

import io.swagger.v3.oas.annotations.media.Schema;

/**
 * 门禁设备
 *
 * @author PinRu
 * @version 1.0.0
 * @create 2023/12/25 17:41
 */
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class GuardEquipmentRespVO extends GuardEquipmentBaseVO {
@Schema(description =  "门禁名称", requiredMode = RequiredMode.REQUIRED)
    @NotNull(message = "门禁名称不能为空")
    @Size(max = 30)
    private String name;

    @Schema(description =  "门禁编码", requiredMode = RequiredMode.REQUIRED)
    @NotNull(message = "门禁编码不能为空")
    @Size(max = 30)
    private String code;

    @Schema(description =  "版本号")
    @Size(max = 30)
    private String version;

    @Schema(description =  "门禁方向 【AccessDirectionEnum】", requiredMode = RequiredMode.REQUIRED)
    @NotNull(message = "门禁方向 【AccessDirectionEnum】不能为空")
    private Integer direction;

    @Schema(description =  "门禁位置 【AccessPositionEnum】", requiredMode = RequiredMode.REQUIRED)
    @NotNull(message = "门禁位置 【AccessPositionEnum】不能为空")
    private Integer position;

    @Schema(description =  "设备ip", requiredMode = RequiredMode.REQUIRED)
    @NotNull(message = "设备ip不能为空")
    @Size(max = 60)
    private String addressIp;

    @Schema(description =  "门禁端口", requiredMode = RequiredMode.REQUIRED)
    @Max(32767)
    private Integer port;

    @Schema(description =  "设备mac")
    @Size(max = 60)
    private String mac;

    @Schema(description =  "门禁协议 【AccessAgreementEnum】", requiredMode = RequiredMode.REQUIRED)
    @NotNull(message = "门禁协议 【AccessAgreementEnum】不能为空")
    private String agreement;

    @Schema(description =  "门禁管理员")
    private String accessUser;

    @Schema(description =  "门禁密码")
    @Size(max = 60)
    private String accessPassword;

    @Schema(description =  "门禁状态")
    private Integer status;

     @Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED)
    private Long id;

    @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
    @JsonFormat(pattern = DatePattern.NORM_DATETIME_PATTERN)
    private Date createTime;

    @Schema(description = "心跳时间", requiredMode = Schema.RequiredMode.REQUIRED)
    @JsonFormat(pattern = DatePattern.NORM_DATETIME_PATTERN)
    private Date heartBeatTime;

    @Schema(description =  "门禁方向名称", requiredMode = Schema.RequiredMode.REQUIRED)
    private String directionName;

    @Schema(description =  "门禁位置名称", requiredMode = Schema.RequiredMode.REQUIRED)
    private String positionName;

    @Schema(description =  "门禁协议名称", requiredMode = Schema.RequiredMode.REQUIRED)
    private String agreementName;

    @Schema(description =  "门禁状态")
    private String statusName;
}

EntranceConstants

/**
 * 门禁常量
 *
 * @author Pinru
 * @version 1.0.0
 * @create 2023/12/25 17:34
 */
public interface EntranceConstants {

    /**
     * 门禁方向
     */
    String DIRECTION_TYPE = "direction_type";

    /**
     * 门禁位置
     */
    String POSITION_TYPE = "position_type";

    /**
     * 门禁协议
     */
    String AGREEMENT_TYPE = "agreement_type";


    /**
     * 门禁操作API地址（海康-查询用户信息）
     */

    String USER_INFO = "POST /ISAPI/AccessControl/UserInfo/Search?format=json";

    /**
     * 海康redis-Map-Key
     */
    String HK_REDIS_MAP_KEY = "HK_REDIS_EQUIPMENT_KEY";


    /**
     * 大华redis-Map-Key
     */
    String DH_REDIS_MAP_KEY = "DH_REDIS_EQUIPMENT_KEY";

    /**
     * 海康错误码-错误信息
     */
    Integer NET_DVR_NO_ERROR = 0;

    /**
     * 海康错误码-没有错误用户名密码错误。注册时输入的用户名或者密码错误。
     */
    Integer NET_DVR_PASSWORD_ERROR = 1;

    /**
     * 海康错误码-权限不足。一般和通道相关，例如有预览通道1权限，无预览通道2权限，即有预览权限但不完全，预览通道2返回此错误。
     */
    Integer NET_DVR_NOENOUGHPRI = 2;

    /**
     * 海康错误码-SDK未初始化。
     */
    Integer NET_DVR_NO_INIT = 3;

    /**
     * 海康错误码-通道号错误。设务没有对应的通道号。
     */
    Integer NET_DVR_CHANNEL_ERROR = 4;

    /**
     * 海康错误码-设备总的连接数超过最大。
     */
    Integer NET_DVR_OVER_MAX_LINK = 5;

    /**
     * 海康错误码-版本不匹配，SDK和设条的版本不匹配。
     */
    Integer NET_DVR_VERSION_NOMATCH = 6;

    /**
     * 海康错误码-逢接设备失败。设备不在线或网络原因引起的连接超时等。
     */
    Integer NET_DVR_NETWORK_FAIL_CONNECT = 7;

    /**
     * 海康错误码-向设备发送失败。
     */
    Integer NET_DVR_NETWORK_SEND_ERROR = 8;

    /**
     * 海康错误码-从设备接收数据失败。
     */
    Integer NET_DVR_NETWORK_RECEIVE_ERROR = 9;

    /**
     * 海康错误码-从设备接收数据超时。
     */
    Integer NET_DVR_NETWORK_RECEIVE_TIMEOUT = 10;

    /**
     * 海康错误码-传送的数据有误。发送给设备或者从设备接收到的数据错误，如远程参数配量时输入设备不支持的值
     */
    Integer NET_DVR_NETWORK_ERROR_DATA = 11;

    /**
     * 海康错误码-调用次序错误。
     */
    Integer NET_DVR_ORDER_ERROR = 12;

    /**
     * 海康错误码-无此权限。用户对某个功能模块的权限。例如无预览权限用户预览返回此错误。
     */
    Integer NET_DVR_OPER_NO_PERMIT = 13;

    /**
     * 海康错误码-设备命令执行超时。
     */
    Integer NET_DVR_COMMAND_TIME_OUT = 14;

    /**
     * 海康错误码-串口号错误。指定的设备串口号不存在。
     */
    Integer NET_DVR_ERROR_SERIAL_PORT = 15;

    /**
     * 海康错误码-报警消口错误，指定的设备报警输入或者输出端口不存在。
     */
    Integer NET_DVR_ERROR_ALARM_PORT = 16;

    /**
     * 海康错误码-参数错误，SDK接口中给入的输入或输出参数为空，或者参数格式或值不符合要求。
     */
    Integer NET_DVR_PARAMETER_ERROR = 17;

    /**
     * 海康错误码-设备通道处于错误状态。
     */
    Integer NET_DVR_CHAN_EXCEPTION = 18;

    /**
     * 海康错误码-设备无硬盘，当设备无硬盘时，对设备的录像文件、硬盘配置等操作失败。
     */
    Integer NET_DVR_NO_DISK = 19;

    /**
     * 海康错误码-硬盘号错误，当对设备进行硬盘管理操作时，指定的硬盘号不存在时这回该错误。
     */
    Integer NET_DVR_ERROR_DISK_NUM = 20;

    /**
     * 海康错误码-设备硬盘满。
     */
    Integer NET_DVR_DISK_FULL = 21;

    /**
     * 海康错误码-设备硬盘出错。
     */
    Integer NET_DVR_DISK_ERROR = 22;

    /**
     * 海康错误码-设备不支持。
     */
    Integer NET_DVR_NO_SUPPORT = 23;

    /**
     * 刷卡加密码认证失败
     */
    String MESSAGE = "刷卡加密码认证失败";
}

SystemHkSelect

/**
 * 获取当前操作系统的类型
 *
 * @author Pinru
 * @version 1.0.0
 * @create 2023/12/20 16:16
 */
public class SystemHkSelect {

    /**
     * 是否是linux
     *
     * @return Boolean
     */
    public static boolean isLinux() {
        return System.getProperty("os.name").toLowerCase().contains("linux");
    }

    /**
     * 是否是windows
     *
     * @return Boolean
     */
    public static boolean isWindows() {
        return System.getProperty("os.name").toLowerCase().contains("windows");
    }
}