Java调用Golang生成的动态库(dll,so)

0x01. 环境准备

A. GCC

在控制台中输入

  1. gcc -v

如果提示命令未找到,那么说明你的计算机中还没有gcc,去安装一个吧,gcc官方网站:https://gcc.gnu.org/
如果从来没有安装过gcc的朋友可以直接安装win-build,可以帮你快速的安装
官方网站:http://mingw-w64.org/doku.php/download/win-builds

0x02. 编写go程序

我们这里只是编写一个简单的计算加法的程序,接受两个整数,然后计算他们的和,并返回。
在这里,我们将文件命名为libhello.go

  1. package main
  2. import "C"
  3. //export Sum
  4. func Sum(a int, b int) int {
  5. return a + b
  6. }
  7. func main() {
  8. }

注意,即使是要编译成动态库,也要有main函数,上面的import “C”一定要有
而且一定要有注释

  1. //export Sum

经测试,如果没有这个导出的DLL库中找不到对应的函数

0x03. 编译go程序

首先,将控制台的所在目录切换到go程序的所在目录,即libhello.go所在目录

A. Windows动态库

执行如下命令生成DLL动态链接库:

  1. go build -buildmode=c-shared -o libhello.dll .\libhello.go

如果控制台没有报错,那么会在当前路径下生成libhello.dll文件

B. Linux/Unix/macOS动态库

执行如下命令生成SO动态库:

  1. go build -buildmode=c-shared -o libhello.so .\libhello.go

0x04. 在java中调用

A. JNA的引用

Java调用Native的动态库有两种方式,JNI和JNA,JNA是Oracle最新推出的与Native交互的方式,具体介绍我就不多说了,引用百度百科的连接:https://baike.baidu.com/item/JNA/8637274?fr=aladdin,有需要的朋友可以去看看。
在这里,我们使用JNA的方式,JNI的方式基本废弃,除非有特殊需要,在这里不多说,有需要可以联系我讨论。
新建Java工程,我使用的是Maven做包管理,所以直接引用JNA的依赖:

  1. <dependency>
  2. <groupId>net.java.dev.jna</groupId>
  3. <artifactId>jna</artifactId>
  4. <version>4.5.2</version>
  5. </dependency>

如果你没有使用包管理工具,可以直接下载Jar文件引入,下载地址也贴一下吧,也是4.5.2版本的:
http://central.maven.org/maven2/net/java/dev/jna/jna/4.5.2/jna-4.5.2.jar

B. 创建接口

我们需要创建一个interface来映射DLL中的函数,之后我们可以通过interface的实例来访问DLL中的函数。

  1. package cn.lemonit.robot.runner.executor;
  2. import com.sun.jna.Library;
  3. import com.sun.jna.Native;
  4. public interface LibHello extends Library {
  5. LibHello INSTANCE = (LibHello) Native.loadLibrary("E:/workspace/libhello", LibHello.class);
  6. int Sum(int a, int b);
  7. }

注意,Sum是函数名,一定要与Go中事先写好的函数名保持一致
Native.loadLibrary()的第一个参数是一个字符串,要加载的动态库的名称或全路径,后面不需要加.dll或者.so的后缀。第二个参数为interface的类名称。

C. 调用

我们新建一个App类,作为main方法的入口类,在main方法中不需要多余的操作,只需要调用即可,在这里我们调用Sum方法,同时传如222 , 333,可以看到控制台输出:555

  1. package cn.lemonit.robot.runner.executor;
  2. public class App {
  3. public static void main(String[] args) {
  4. System.out.println(LibHello.INSTANCE.Sum(222, 333));
  5. }
  6. }

大功告成,我终于玩通了Java调用Go程序!!!!
???不对劲,有点太过于幸灾乐祸了,往下继续>>>

0x05. 参数中包含字符串

A. 我真的大功告成了吗?

我们的程序总不能只传数值型的参数吧,我们把GO程序改一下,换成一个一字符串作为参数的函数,接受一个字符串参数,然后从控制台输出:hello: xxx,如下:

  1. package main
  2. import "fmt"
  3. //export Hello
  4. func Hello(msg string) {
  5. fmt.Print("hello: " + msg)
  6. }
  7. func main() {
  8. }

按照上面0x02.B步骤中的写法,我们将java的LibHello接口改成这个样子:

  1. package cn.lemonit.robot.runner.executor;
  2. import com.sun.jna.Library;
  3. import com.sun.jna.Native;
  4. public interface LibHello extends Library {
  5. LibHello INSTANCE = (LibHello) Native.loadLibrary("E:/workspace/libhello", LibHello.class);
  6. void Hello(String msg);
  7. }

接下来,我们调用这个接口,将0x02.C中的启动入口类App代码改成这样:

  1. package cn.lemonit.robot.runner.executor;
  2. public class App {
  3. public static void main(String[] args) {
  4. LibHello.INSTANCE.Hello("LemonIT.CN");
  5. }
  6. }

运行起来,咦?报错了???

  1. fatal error: string concatenation too long
  2. goroutine 17 [running, locked to thread]:
  3. runtime.throw(0x644c1d4f, 0x1d)
  4. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx runtime报错,没有意义,不贴了)

这是怎么回事,我传的是一个很标准的String啊,怎么会报错呢?
在一阵无头绪中,发现刚才在调用go build -buildmode=c-shared -o libhello.dll .\libhello.go命令的时候在文件夹中除了libhello.dll被生成之外,还生成了一个libhello.h文件!!!这不是C的头文件么?出于好奇,打开看看有什么高大上的东西,这一打开还真是吓到我了:

  1. /* Created by "go tool cgo" - DO NOT EDIT. */
  2. /* package command-line-arguments */
  3. #line 1 "cgo-builtin-prolog"
  4. #include <stddef.h> /* for ptrdiff_t below */
  5. #ifndef GO_CGO_EXPORT_PROLOGUE_H
  6. #define GO_CGO_EXPORT_PROLOGUE_H
  7. typedef struct { const char *p; ptrdiff_t n; } _GoString_;
  8. #endif
  9. /* Start of preamble from import "C" comments. */
  10. /* End of preamble from import "C" comments. */
  11. /* Start of boilerplate cgo prologue. */
  12. #line 1 "cgo-gcc-export-header-prolog"
  13. #ifndef GO_CGO_PROLOGUE_H
  14. #define GO_CGO_PROLOGUE_H
  15. typedef signed char GoInt8;
  16. typedef unsigned char GoUint8;
  17. typedef short GoInt16;
  18. typedef unsigned short GoUint16;
  19. typedef int GoInt32;
  20. typedef unsigned int GoUint32;
  21. typedef long long GoInt64;
  22. typedef unsigned long long GoUint64;
  23. typedef GoInt64 GoInt;
  24. typedef GoUint64 GoUint;
  25. typedef __SIZE_TYPE__ GoUintptr;
  26. typedef float GoFloat32;
  27. typedef double GoFloat64;
  28. typedef float _Complex GoComplex64;
  29. typedef double _Complex GoComplex128;
  30. /*
  31. static assertion to make sure the file is being used on architecture
  32. at least with matching size of GoInt.
  33. */
  34. typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1];
  35. typedef _GoString_ GoString;
  36. typedef void *GoMap;
  37. typedef void *GoChan;
  38. typedef struct { void *t; void *v; } GoInterface;
  39. typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
  40. #endif
  41. /* End of boilerplate cgo prologue. */
  42. #ifdef __cplusplus
  43. extern "C" {
  44. #endif
  45. extern void Hello(GoString p0);
  46. #ifdef __cplusplus
  47. }
  48. #endif

这么大一篇子,往下翻翻翻,找到了我们的Hello函数的定义:

  1. extern void Hello(GoString p0);

发现问题了,人家参数要的事GoString,而我们传的是Java的String,肯定类型不一致啊。那GoString是个什么东西呢,我该给他传什么?往上翻,找到了这么两行代码:

  1. typedef struct { const char *p; ptrdiff_t n; } _GoString_;
  2. // .....
  3. typedef _GoString_ GoString;

嗯嗯嗯,看来这个GoString不过就是个C里面的结构体罢了,结构体里面一个char *一个ptrdiff_t,看来我们用java调用程序的时候,构造个这么样的结构体给他传进来应该就行了,好了,有思路了,开始折腾。

B. 创建GoString!

我们首先用JNA构建一个C的结构体类型,那么问题来了,JNA中char *可以直接用java的String来代替,那么ptrdiff_t这个玩意……有点无语,这是啥啊?经过一顿操作百度和谷歌,终于知道了,这个类型实际上是两个内存地址之间的距离的值,数据类型实际上就是C中的long int,在这里他表示的是字符串char *的长度,也就是字符串的长度呗~,知道这个就好办了,我们在Java中直接用long类型来代替它。
我们新建一个GoString类来对应C中的GoString结构体,也就是Go程序中的string,这块得说一下,有些人可能没有用过JNA,在JNA中若想定义一个结构体,需要创建一个类继承自com.sun.jna.Structure,熟悉C的人应该知道(不知道也没关系),向C中传值通常有两种,一种是传引用(就是传指针类型),一种是传真实值,在JNA里面做的话我们通常在这个结构体类中创建两个静态的内部类,这两个内部类继承自这个结构体类,并实现Structure.ByValue和Structure.ByReference接口,其中ByValue就是传真实值时候用的,ByReference就是传引用的时候用的,综上所述,我们的GoString类就应该长成这个样子:

  1. package cn.lemonit.robot.runner.executor;
  2. import com.sun.jna.Structure;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. public class GoString extends Structure {
  6. public String str;
  7. public long length;
  8. public GoString() {
  9. }
  10. public GoString(String str) {
  11. this.str = str;
  12. this.length = str.length();
  13. }
  14. @Override
  15. protected List<String> getFieldOrder() {
  16. List<String> fields = new ArrayList<>();
  17. fields.add("str");
  18. fields.add("length");
  19. return fields;
  20. }
  21. public static class ByValue extends GoString implements Structure.ByValue {
  22. public ByValue() {
  23. }
  24. public ByValue(String str) {
  25. super(str);
  26. }
  27. }
  28. public static class ByReference extends GoString implements Structure.ByReference {
  29. public ByReference() {
  30. }
  31. public ByReference(String str) {
  32. super(str);
  33. }
  34. }
  35. }

可以发现,我们重写了一个getFieldOrder方法,在里面新建一个list,然后把两个属性名作为字符串放到里面,然后当做返回值返回了。这个操作实际是为了告诉JNA,我这两个变量和C结构体中的变量是怎么个对应关系的,我们再来回顾一下刚才libhello.h中定义的GoString结构体(其实是省着你再往上翻看,费劲,直接粘出来方便你看):

  1. typedef struct { const char *p; ptrdiff_t n; } _GoString_;

我们的字符串叫str,而char *的名称是p,我们的字符串长度叫length,而结构体中叫n,JNA又不是人工智能框架,肯定猜不出来你想把str对应到p,length想对应到n,所以我们在这里通过list的形式把字段名在list中排一个顺序,告诉JNA,我的str想对应结构体的第一个属性,length想对应结构体的第二个属性。(你可以试试,让fields.add的顺序调换一下,肯定会出问题)。

C. 有了GoString!我又可以幸灾乐祸了!???

好了,GoString有了,万事俱备,只欠东风了!用一把,我们把刚才0x05.A中的LibHello类改成这样:

  1. package cn.lemonit.robot.runner.executor;
  2. import com.sun.jna.Library;
  3. import com.sun.jna.Native;
  4. public interface LibHello extends Library {
  5. LibHello INSTANCE = (LibHello) Native.loadLibrary("E:/workspace/libhello", LibHello.class);
  6. void Hello(GoString.ByValue msg);
  7. }

App入口类代码改成这样:

  1. package cn.lemonit.robot.runner.executor;
  2. public class App {
  3. public static void main(String[] args) {
  4. LibHello.INSTANCE.Hello(new GoString.ByValue("LemonIT.CN"));
  5. }
  6. }

运行!控制台成功输出:

hello: LemonIT.CN
哈哈哈!成功了,有点小激动!把代码发给朋友们看!!!有一个朋友问我,你这Hello函数的结果能不能不在Go中的控制台打印,而是在Java中打印到控制台?额……我犹豫了一下,应该能吧……开干!

0x06. 返回值中包含字符串

A. 做一个小实验~

我们把0x05中的Go函数Hello改一下,让结果通过返回值返回,而不是直接在控制台打印,变成这样滴:

  1. package main
  2. import "C"
  3. //export Hello
  4. func Hello(msg string) string{
  5. return "hello:" + msg
  6. }
  7. func main() {
  8. }

既然返回值也是string,那JNA这边也得小改一波,把0x05.C中的LibHello类改成这样:

  1. package cn.lemonit.robot.runner.executor;
  2. import com.sun.jna.Library;
  3. import com.sun.jna.Native;
  4. public interface LibHello extends Library {
  5. LibHello INSTANCE = (LibHello) Native.loadLibrary("E:/workspace/libhello", LibHello.class);
  6. GoString.ByValue Hello(GoString.ByValue msg);
  7. }

运行入口类App也对应修改一下:

  1. package cn.lemonit.robot.runner.executor;
  2. public class App {
  3. public static void main(String[] args) {
  4. System.out.println(LibHello.INSTANCE.Hello(new GoString.ByValue("LemonIT.CN")).str);
  5. }
  6. }

大功告成,运行一下!

  1. panic: runtime error: cgo result has Go pointer
  2. goroutine 17 [running, locked to thread]:
  3. main._cgoexpwrap_b02601c1465e_Hello.func1(0xc04203deb8)
  4. _cgo_gotypes.go:59 +0x6c
  5. main._cgoexpwrap_b02601c1465e_Hello(0xbe3ce0, 0xa, 0xc042008050, 0x10)
  6. _cgo_gotypes.go:61 +0xa1

嗯?这啥?我的LemonIT.CN呢?在控制台中并没有找到啊!有点让人发狂,怎么一步一个坎~不过想想比尔盖茨,我还是决定做一名脾气好的程序员,慢慢研究吧。

B. 事情总有解决办法!(车到山前必有路,有路必有丰田车)

虽然没有LemonIT.CN,但是看控制台中的error,cgo result has Go pointer,还是找到了一丝线索。又开始一顿操作百度和谷歌。原来,Go有自己的GC(垃圾回收,不解释),通俗点说就是我Go语言的指针你们其他语言别想用!额,那咋整!急的我连大学时候的课堂笔记都翻出来了。无意中看到了当时写的借助JNA与C通信,C中将char *返回给Java,然后Java使用String即可接收。嗯,嗯?这条咋忘了呢?哈哈哈,岂不是我把Go中的string转成C的char *返回就可以了?好了,让我们试上那么一试,把刚才的Go中的Hello函数再次修改一波:

  1. package main
  2. import "C"
  3. //export Hello
  4. func Hello(msg string) *C.char{
  5. return C.CString("hello : " + msg)
  6. }
  7. func main() {
  8. }

同样滴,我们的JNA这边也得改一改,把LibHello类修改成这样:

  1. package cn.lemonit.robot.runner.executor;
  2. import com.sun.jna.Library;
  3. import com.sun.jna.Native;
  4. public interface LibHello extends Library {
  5. LibHello INSTANCE = (LibHello) Native.loadLibrary("E:/workspace/libhello", LibHello.class);
  6. String Hello(GoString.ByValue msg);
  7. }

LibHello既然改了,那么入口类App也得对应修改:

  1. package cn.lemonit.robot.runner.executor;
  2. public class App {
  3. public static void main(String[] args) {
  4. System.out.println(LibHello.INSTANCE.Hello(new GoString.ByValue("LemonIT.CN")));
  5. }
  6. }

好了好了好了,运行:

  1. hello : LemonIT.CN

终于输出出来了!

0x07. 总结

这个Go和Java的交互刚刚走了这一小小步就一步一个坎,看来真不能随便的幸灾乐祸啊!!还得谦虚,路才能越走越远。虽然费了这么大劲就解决了这么点小事,但是Go语言的优势是很大的,还是很值得我来折腾的,相信能读到这里的朋友也是对Go语言非常的喜爱,大家一起加油吧,欢迎各位大佬来指正批评~

作者:柠檬信息技术有限公司
链接:https://www.jianshu.com/p/b19b9715c36b
來源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

ft_authoradmin  ft_create_time2018-08-17 15:52
 ft_update_time2018-08-17 15:59