JNA字符串&结构体
1.字符串
1.1 返回字符串类型
c/c++代码
- 全局变量
char retp[1024];
const char* getStr1(int a, int b){
memset(retp, 0, 1024);
char outstr[256];
memset(outstr, 0, 256);
if (outstr != 0){
sprintf_s(outstr, "汉字out DLL汉字: %d + %d==%d\n", a, b, (a + b));
}
strcpy_s(retp, outstr);
return retp;
}
- malloc函数分配空间
const char* getStr2(int a, int b){
char* retp = (char*)malloc(1024);
memset(retp, 0, 1024);
char outstr[256];
memset(outstr, 0, 256);
if (outstr != 0){
sprintf_s(outstr, "汉字out DLL汉字: %d + %d==%d\n", a, b, (a + b));
//printf("%s",outstr);
}
strcpy_s(retp, strlen(outstr) + 1, outstr);
return retp;
}
java代码
package com.jnademo;
import com.sun.jna.Library;
import com.sun.jna.Native;
public class JnaTest {
public interface CLibrary extends Library {
CLibrary INSTANCE = (CLibrary) Native.load("E:\\dllws\\jnaTest\\x64\\Debug\\jnaTest.dll",
CLibrary.class);
String getStr1(int a, int b);
String getStr2(int a, int b);
}
public static void main(String[] args) {
System.setProperty("jna.encoding","GBK");
System.out.println(CLibrary.INSTANCE.getStr1(1, 3));
System.out.println(CLibrary.INSTANCE.getStr2(2, 3));
}
}
要注意添加System.setProperty("jna.encoding","GBK");否则会出现乱码。具体规则
- c++ char* GBK编码时
System.setProperty("jna.encoding", "GBK");
- c++ char* UTF8编码时
System.setProperty("jna.encoding", "UTF-8");
另外，其实还有个更简单的办法，JNA提供了一个宽字符字符串WString，当然c++接口参数类型要使用wchar_t*，这样WString就可以无缝转wchar_t*了，不用做任何修改，也绝对不会乱码。
1.2 C/C++接收字符串类型
C/C++代码
bool JavaStr(char* szText, int textLen) {
if (szText == NULL || textLen <= 0) {
return false;
}
std::string strText(szText, textLen);
//OutputDebugStringA("JavaStr:");
//OutputDebugStringA(strText.c_str());
cout << strText.c_str() << endl;
return true;
}
java代码
package com.jnademo;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.List;
import com.sun.jna.Library;
import com.sun.jna.Native;
public class TestStructDemo {
public interface TestStruct extends Library {
TestStruct INSTANCE = (TestStruct) Native.load("E:\\dllws\\jnaTest\\x64\\Debug\\jnaTest.dll",
TestStruct.class);
public boolean JavaStr(String str, int strLen); // 使用String传参数，中文会参数乱码
public boolean JavaStr(byte[] str, int strLen); // 使用byte[]传参数，中文正常
}
public static void main(String[] args) throws UnsupportedEncodingException {
//https://blog.51cto.com/softo/6009271
String utf8Str = "UTF8转成GBK";
String gbkStr = new String(utf8Str.getBytes("UTF-8"), "GBK"); // UTF8转成GBK
byte[] gbkBytes = utf8Str.getBytes("UTF-8");
TestStruct.INSTANCE.JavaStr(gbkStr, gbkStr.length()); // 传字符串C++接收时中文是乱码
TestStruct.INSTANCE.JavaStr(gbkBytes, gbkBytes.length); // 传字节数组C++接收中文正常
}
}
2. 结构体
C/C++代码
#define JNA_LIBAPI extern "C" __declspec( dllexport )
//C++结构体
struct UserStruct{
long id;
char* name;
int age;
};
JNA_LIBAPI void sayUser(UserStruct pUserStruct);
JNA_LIBAPI void sayUser2(UserStruct* pUserStruct);
定义一个结构体UserStruct，在定义两个方法，参数分别是UserStruct对象类型和UserStruct指针类型。
java代码
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.List;
import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.NativeLong;
import com.sun.jna.Structure;
public class TestStructDemo {
public interface TestStruct extends Library {
TestStruct INSTANCE = (TestStruct) Native.load("E:\\dllws\\jnaTest\\x64\\Debug\\jnaTest.dll", TestStruct.class);
//结构体定义
public static class myStructure extends Structure {
public NativeLong id;
public String name;
public int age;
public static class ByReference extends myStructure implements Structure.ByReference {}
public static class ByValue extends myStructure implements Structure.ByValue {}
@Override
protected List<String> getFieldOrder() {
return Arrays.asList(new String[] {"id", "name", "age"});
}
}
//申明C端调用结构体的函数
public void sayUser(myStructure.ByValue struct);
public void sayUser2(myStructure.ByReference struct);
}
public static void main(String[] args) throws UnsupportedEncodingException {
//ByValue这个类代表结构体本身
TestStruct.myStructure.ByValue testReference = new TestStruct.myStructure.ByValue();
testReference.age = 20;
testReference.id = new NativeLong(10);
testReference.name = new String("Tony");
TestStruct.INSTANCE.sayUser(testReference);
//ByReference代表结构体指针
TestStruct.myStructure.ByReference testReference2 = new TestStruct.myStructure.ByReference();
testReference2.age = 80;
testReference2.id = new NativeLong(100);
testReference2.name = new String("Jack");
TestStruct.INSTANCE.sayUser2(testReference2);
}
}
在Java中实现对C结构体的模拟，需要继承Structure类，利用这个类来模拟C语言的结构体。必须注意，Structure子类中公共字段的顺序，必须与C语言中结构体的顺序一致，否则会报错！因为Java调用动态库中的C函数，实际上是一段内存作为函数参数传递给C函数。动态库以为这个参数就是C语言传过来的参数。同时，C语言的结构体是一个严格规范，它定义了内存的次序，因此，Jna中模拟的结构体变量顺序绝不能错。
如果一个struct有两个int变量，int a 和 int b 如果Jna中的次序和C语言中次序相反，那么不会报错，但是数据将被传递到错误的字段中去。
Structure类代表了一个原生结构体。当Structure对象作为一个函数的参数或者返回值传递时，它代表结构体指针。当它被用在另一个结构体内部作为一个字段时，它代表结构体本身。
Structure类有两个内部接口Structure.ByReference和Structure.ByValue。这两个接口仅仅是标记，如果一个类实现Structure.ByReference接口，就表示这个类代表结构体指针；如果一个类实现Structure.ByValue接口，就表示这个类代表结构体本身。使用这两个接口的实现类，可以明确定义Structure实例表示的是结构体还是结构体指针。
参考：
https://blog.csdn.net/redchairman/article/details/108438202
https://blog.csdn.net/houmingyang/article/details/127071298
https://zhuanlan.zhihu.com/p/466863639
