Java使用JNA进行读卡器的开发与封装示例

概述：前段时间对读卡器进行开发，目的是开发一个工具类接口给其他同事用在项目上调用读卡器，于是呼写了一个Java调用读卡器，进行读卡，写卡的操作例子。由于使用的是厂商提供的dll库，所以选择了JNA进行开发。当然还有一种JNI方式，这种方式适合开发底层，比如封装SDK。业务开发建议使用JNA，方便使用。JNI开发比较繁琐，需要Java类，包对应C的类，包名称，以及编译等注意事项。

1、首先在pom里引入：JNA三方库

<dependency>
            <groupId>com.sun.jna</groupId>
            <artifactId>jna</artifactId>
            <version>3.0.9</version>
        </dependency>

2、接口类封装：用于存放dll库中可以调用的接口。

import com.sun.jna.Library;

/**
 * @author liuxiaobao
 * @date 2022/6/22 9:12
 * 说明：RWOptionService 声明了对YOW-60X系列的读卡器，读和写的相关接口
 */
public interface RWOptionService extends Library {

    int YW_GetReaderID(int ReaderID);
    /**
     * 函数： YW_USBHIDInitial
     * 名称： 免驱USB端口初始化
     * 参数： 无
     * 返回值：>0为成功 ，其它失败
     */
    int YW_USBHIDInitial();

    /**
     * 函数： YW_USBHIDFree
     * 名称： 免驱USB端口释放
     * 参数： 无
     * 返回值：>0为成功，其它失败
     */
    int YW_USBHIDFree();


    /**
     * 函数： YW_Buzzer
     * 名称： 蜂鸣器操作函数
     * 参数： ReaderID：读写器ID号，0为广播地址
     * Time_ON：蜂鸣器响时间，单位0.1s
     * Time_OFF：蜂鸣器不响时间，单位0.1s
     * Cycle：蜂鸣器循环次数
     * 返回值：>=0为成功，其它失败
     */
    int YW_Buzzer(int ReaderID, int Time_ON, int Time_OFF, int Cycle);

    /**
     * 函数： YW_Led
     * 名称： LED灯操作函数
     * 参数： ReaderID：读写器ID号，0为广播地址
     * LEDIndex：选择要操作的LED灯
     * Time_ON： 灯亮的时间，单位0.1s
     * Time_OFF：灯不亮时间，单位0.1s
     * Cycle：   循环次数
     * LedIndexOn：最后要亮的灯 0不亮 1 红灯 2绿灯
     * 返回值：>=0为成功，其它失败
     */
    int YW_Led(int ReaderID, int LEDIndex, int Time_ON, int Time_OFF, int Cycle, int LedIndexOn);

    /**
     * 函数： YW_AntennaStatus
     * 名称： 开启天线，在所有卡操作之前必须开启天线
     * 参数：  ReaderID：读写器ID号，0为广播地址
     * Status: true为开启天线， false为关闭天线
     * 返回值：>=0为成功，其它失败
     */
    int YW_AntennaStatus(int ReaderID, boolean Status);

    /**
     * 函数： YW_SearchCardMode
     * 名称： 寻卡模式设置
     * 参数：  ReaderID：读写器ID号，0为广播地址
     * Mode: 寻卡模式
     * SEARCHMODE_14443A       =    Byte(Char('A'));
     * SEARCHMODE_14443B       =    Byte(Char('B'));
     * SEARCHMODE_15693        =    Byte(Char('1'));
     * SEARCHMODE_ST           =    Byte(Char('S'));
     * SEARCHMODE_AT88RF020    =    Byte(Char('R'));
     * 详细参见说明书
     * 返回值：>=0为成功，其它失败
     */
    int YW_SearchCardMode(int ReaderID, int Mode);

    /**
     * 函数： YW_RequestCard
     * 名称： 寻卡TypeA卡
     * 参数：  ReaderID：读写器ID号，0为广播地址
     * RequestMode: 寻卡模式
     * 所有卡  常数 REQUESTMODE_ALL=$52;
     * 激活的卡 常数 REQUESTMODE_ACTIVE=$26;
     * CardType：输出卡类型
     * 0x4400 -> Ultralight/UltraLight C /MifarePlus(7Byte UID)
     * 0x4200 -> MifarePlus(7Byte UID)
     * 0x0400 ->Mifare Mini/Mifare 1K (S50) /MifarePlus(4Byte UID)
     * 0x0200->Mifare_4K(S70)/ MifarePlus(4Byte UID)
     * 0x4403 ->Mifare_DESFire
     * 0x0800 ->Mifare_Pro
     * 返回值：>=0为成功，其它失败
     */
    int YW_RequestCard(int ReaderID, int RequestMode, short CardType[]);

    /**
     * 函数： YW_AntiCollide
     * 名称： 访冲突操作
     * 参数：  ReaderID：读写器ID号，0为广播地址
     * LenSNO:   输出卡号的长度
     * SNO：  输出卡号
     * 返回值：>=0为成功，其它失败
     */
    int YW_AntiCollide(int ReaderID, byte LenSNO[], byte SNO[]);

    /**
     * 函数： YW_CardSelect
     * 名称： 选卡
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * LenSNO:   要选择卡卡号的长度
     * SNO：  要选择卡卡号
     * 返回值：>=0为成功，其它失败
     */
    int YW_CardSelect(int ReaderID, byte LenSNO, byte SNO[]);

    /**
     * 函数： YW_DownLoadKey
     * 名称： 下载秘钥到读写器中
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * KeyIndex:   秘钥的序号，从0-31
     * Key ：  秘钥指针，6个字节
     * 返回值：>=0为成功，其它失败
     */
    int YW_DownLoadKey(int ReaderID, int KeyIndex, byte Key[]);

    /**
     * 函数： YW_KeyDown_Authorization
     * 名称： 用读写器中的秘钥进行授权
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * KeyMode:  秘钥选择Key A或者Key B
     * 常数  PASSWORD_A           =    $60;
     * 常数  PASSWORD_B           =    $61;
     * BlockAddr：  要授权的块号
     * KeyIndex:   秘钥的序号，从0-31
     * 返回值：>=0为成功，其它失败
     */
    int YW_KeyDown_Authorization(int ReaderID, int KeyMode, int BlockAddr, byte KeyIndex);

    /**
     * 函数： YW_KeyAuthorization
     * 名称： M1卡授权
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * KeyMode:  秘钥选择Key A或者Key B
     * 常数  PASSWORD_A           =    $60;
     * 常数  PASSWORD_B           =    $61;
     * BlockAddr：  要授权的块
     * Key：  秘钥字节指针，6字节
     * 返回值：>=0为成功，其它失败
     */
    int YW_KeyAuthorization(int ReaderID, int KeyMode, int BlockAddr, byte[] Key);

    /**
     * 函数： YW_ReadaBlock
     * 名称： 读取M1卡一个块
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * BlockAddr:   要读取的块号
     * LenData：  要读取的字节数，最大为16
     * Data：  数据指针
     * 返回值：>=0为成功，其它失败
     */
    int YW_ReadaBlock(int ReaderID, int BlockAddr, int LenData, byte pData[]);

    /**
     * 函数： YW_WriteaBlock
     * 名称： 写入M1卡一个块
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * BlockAddr:   要写入的块号
     * LenData：  要读取的字节数，必须为16
     * Data：  数据指针
     * 返回值：>=0为成功，其它失败
     */
    int YW_WriteaBlock(int ReaderID, int BlockAddr, int LenData, byte pData[]);

    /**
     * 函数： YW_Purse_Initial
     * 名称： M1卡将某一块初始化钱包
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * BlockAddr:   要初始化钱包的块号
     * IniValue：  钱包初始化值
     * 返回值：>=0为成功，其它失败
     */
    int YW_Purse_Initial(int ReaderID, int BlockAddr, int IniMoney);

    /**
     * 函数： YW_Purse_Read
     * 名称： 读取M1卡某个块的钱包值
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * BlockAddr:   要初始化钱包的块号
     * Value：  钱包的当前值
     * 返回值：>=0为成功，其它失败
     */
    int YW_Purse_Read(int ReaderID, int BlockAddr, int Money[]);

    /**
     * 函数： YW_Purse_Decrease
     * 名称： 对钱包进行减值操作
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * BlockAddr:   要初始化钱包的块号
     * Decrement：  要减去的值
     * 返回值：>=0为成功，其它失败
     */
    int YW_Purse_Decrease(int ReaderID, int BlockAddr, int Decrement);

    /**
     * 函数： YW_Charge
     * 名称： 对钱包进行加值操作
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * BlockAddr:   要初始化钱包的块号
     * Charge：    要增加的值
     * 返回值：>=0为成功，其它失败
     */
    int YW_Purse_Charge(int ReaderID, int BlockAddr, int Charge);

    /**
     * 函数： YW_CardHalt
     * 名称： 对M1卡进行Halt操作
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * 返回值：>=0为成功，其它失败
     */
    int YW_CardHalt(int ReaderID);

    /**
     * 函数： YW_Restore
     * 名称： 对钱包进行Restor操作
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * BlockAddr:   钱包的块号
     * 返回值：>=0为成功，其它失败
     */
    int YW_Restore(int ReaderID, int BlockAddr);

    /**
     * 函数： YW_Transfer
     * 名称： 对钱包进行Transfer操作
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * BlockAddr:   钱包的块号
     * 返回值：>=0为成功，其它失败
     */
    int YW_Transfer(int ReaderID, int BlockAddr);

    /**
     * 函数： YW_AntiCollideAndSelect
     * 名称： 对M1卡进行防碰撞并选卡
     * 参数：  ReaderID：  读写器ID号，0为广播地址
     * MultiCardMode：对多张卡的处理方式
     * 00  返回多卡错误
     * 01  返回一张卡片
     * CardMem：返回卡的内存代码
     * SNOLen: 输出卡号的长度
     * SNO：卡的序列号
     * 返回值：>=0为成功，其它失败
     */
    int YW_AntiCollideAndSelect(int ReaderID, byte ReturnMode, byte CardMem[], byte SNLen[], byte SN[]);


}

3、读写实现，dll库文件看你自己放在什么位置了，我放在了项目根目录下lib里了，这个需要根据你自己的现实的情况而定。

import com.sun.jna.Native;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;


/**
 * @author liuxiaobao
 * @date 2022/6/22 9:21
 */
public class RWUtils {

    public static RWOptionService INSTANCE;//动态库声明

    /**
     * 说明：通过静态代码块实例化动态库，并且判断加载 x32 dll还是x64 dll 库
     * */
    static {

        String bits = System.getProperty("sun.arch.data.model");// 获取jdk位数
        System.out.println("jdk 位数：" + bits);
        String ops = System.getProperty("os.name");   // 获取os名称
        System.out.println("操作系统：" + ops);
        if (ops.startsWith("win") || ops.startsWith("Win"))//windows
        {
            if ("32".equals(bits)) {
                System.out.println("当前程序加载了 YW60X-32.dll");
                System.load(System.getProperty("user.dir") + "\\lib\\YW60X-32.dll");
                INSTANCE = (RWOptionService) Native.loadLibrary("YW60X-32", RWOptionService.class);

            } else {
                System.out.println("当前程序加载了 YW60X-64.dll");
                System.load(System.getProperty("user.dir") + "\\lib\\YW60X-64.dll");
                INSTANCE = (RWOptionService) Native.loadLibrary("YW60X-64", RWOptionService.class);
            }

        } else {//其他操作系统
            System.out.println("当前仅支持Windows系统，暂不支持其他操作系统！");
        }
    }


    /**
     * 写卡方法 from liuxiaobao
     *
     * @param readerID     读卡器id
     * @param requestmode  请求模式
     * @param cardtype     卡类型
     * @param lenSn        卡号长度
     * @param cardNo       卡号
     * @param key          秘钥
     * @param blockData    块数据
     * @param blockAddr    块
     * @param buzzerAndLed 是否开启声音和led灯
     * @return boolean    (true:成功 false：失败  )
     */
    public static boolean write(int readerID, int requestmode, short[] cardtype, byte[] lenSn, byte[] cardNo, byte[] key, byte[] blockData, int blockAddr, boolean buzzerAndLed) {

        INSTANCE.YW_USBHIDInitial();
        int rt = 0;
        rt = INSTANCE.YW_RequestCard(readerID, requestmode, cardtype);
        rt = INSTANCE.YW_AntiCollide(readerID, lenSn, cardNo);
        rt = INSTANCE.YW_CardSelect(readerID, lenSn[0], cardNo);
        rt = INSTANCE.YW_KeyAuthorization(readerID, 96, blockAddr, key);
        System.out.println();
        rt = INSTANCE.YW_WriteaBlock(readerID, blockAddr, 16, blockData);
        if (buzzerAndLed) {
            INSTANCE.YW_Led(readerID, 1, 1, 1, 3, 2);
            INSTANCE.YW_Buzzer(readerID, 1, 1, 2);
        }
        INSTANCE.YW_USBHIDFree();
        if (rt > 0) {
            //写卡完成
            System.out.println("写入成功，写入的数据为：" + byteArrayToInt(blockData, 0, true));

            return true;
        }
        //写卡失败
        return false;
    }

    /**
     * 读卡方法 from liuxiaobao
     *
     * @param readerID     读卡器id
     * @param requestmode  请求模式
     * @param cardtype     卡类型
     * @param lenSn        卡号长度
     * @param cardNo       卡号
     * @param key          秘钥
     * @param blockData    块数据
     * @param blockAddr    块
     * @param buzzerAndLed 是否开启声音和led灯
     * @return map   (cardNo:十进制卡号 data：十进制数据  )
     */
    public static Map reader(int readerID, int requestmode, short[] cardtype, byte[] lenSn, byte[] cardNo, byte[] key, byte[] blockData, int blockAddr, boolean buzzerAndLed) {
        Map<String, Integer> resultMap = new HashMap<>();

        INSTANCE.YW_USBHIDInitial();
        int rt = 0;
        rt = INSTANCE.YW_RequestCard(readerID, requestmode, cardtype);
        rt = INSTANCE.YW_AntiCollide(readerID, lenSn, cardNo);
        resultMap.put("cardNo", byteArrayToInt(cardNo, 0, true));
        rt = INSTANCE.YW_CardSelect(readerID, lenSn[0], cardNo);
        rt = INSTANCE.YW_KeyAuthorization(readerID, 96, blockAddr, key);
        rt = INSTANCE.YW_ReadaBlock(readerID, blockAddr, 16, blockData);
        System.out.println();
        if (rt > 0) {
            resultMap.put("data", byteArrayToInt(blockData, 0, true));
        }
        if (rt > 0 && buzzerAndLed) {
            INSTANCE.YW_Led(readerID, 1, 1, 1, 3, 2);
            INSTANCE.YW_Buzzer(readerID, 2, 2, 1);
        }
        INSTANCE.YW_USBHIDFree();

        return resultMap;
    }

    public static void main(String args[]) {
   /*     int readerID = 1001;//读卡器id随意整型
        int requestmode = 38;
        short cardtype[] = new short[1];
        byte lenSn[] = new byte[1];
        byte cardNo[] = new byte[8];
        byte Key[] = new byte[]{(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF};
        byte blockData[] = new byte[16];
        int blockAddr = 5;

        int eNo = 88188;*/

        Calendar instance = Calendar.getInstance();
        DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        System.out.println(dateFormat.format(instance.getTime()));

/*
          System.out.println(getTimeAdd());*/

/*
        byte[] bytes = intToByteArray(eNo, true);



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

            blockData[i]=bytes[i];
        }



         boolean flag = write(readerID, requestmode, cardtype, lenSn, cardNo, Key, blockData, blockAddr, true);
       if(true){

           int i = byteArrayToInt(blockData, 0, true);
           System.out.println("eNoInt:"+i);
           System.out.println("写入成功，写入的数据为："+i);
       }*/


      /*  while (true) {
            Map reader = reader(readerID, requestmode, cardtype, lenSn, cardNo, Key, blockData, blockAddr, true);
            System.out.println("cardNo:" + reader.get("cardNo"));
            System.out.println("data:" + reader.get("data"));
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }*/


    }
    public static int getTimeAdd(){
        LocalTime now = LocalTime.now();
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("HHmm");
        String timeStr = now.format(dtf);
        if(!timeStr.isEmpty()){
            String times[]= timeStr.split(":");
            return  Integer.parseInt(times[0])+Integer.parseInt(times[1]);
        }
        return -1;
    }


    /**
     * 整型转byte数组 from liuxiaobao
     *
     * @param i     整数
     * @param isBig true:大端模式  false:小端模式
     * @return 数组
     */
    public static byte[] intToByteArray(int i, boolean isBig) {
        byte[] result = new byte[4];
        // 由高位到低位
        if (isBig) {
            result[0] = (byte) ((i >> 24) & 0xFF);
            result[1] = (byte) ((i >> 16) & 0xFF);
            result[2] = (byte) ((i >> 8) & 0xFF);
            result[3] = (byte) (i & 0xFF);
        } else {
            result[3] = (byte) ((i >> 24) & 0xFF);
            result[2] = (byte) ((i >> 16) & 0xFF);
            result[1] = (byte) ((i >> 8) & 0xFF);
            result[0] = (byte) (i & 0xFF);
        }
        return result;
    }

    /**
     * byte数组转整型 from liuxiaobao
     *
     * @param bytes byte数组
     * @param start 起始位
     * @param isBig true:大端模式  false:小端模式
     * @return 整数
     */
    public static int byteArrayToInt(byte[] bytes, int start, boolean isBig) {
        int value = 0;
        if (isBig) {
            value += (bytes[start] & 0x000000FF) << 24;
            value += (bytes[start + 1] & 0x000000FF) << 16;
            value += (bytes[start + 2] & 0x000000FF) << 8;
            value += (bytes[start + 3] & 0x000000FF);
        } else {
            value += (bytes[start] & 0x000000FF);
            value += (bytes[start + 1] & 0x000000FF) << 8;
            value += (bytes[start + 2] & 0x000000FF) << 16;
            value += (bytes[start + 3] & 0x000000FF) << 24;
        }
        return value;
    }


}