上集回顾

在上篇中，咱们讲了如何在GO语言中如何使用其他语言（在CGO内实现一个调用回调函数的跳板函数）从外部传递进来的回调函数，并且留下了一个问题，就是如果不使用跳板函数，如何来处理调用这个回调函数呢，不知道大家的答案怎么样，现在给出我的正经答案，那么就是使用syscall系统调用来做，实际上后面咱们调用其他语言动态库函数，这个也是最常用的，比如调用API函数等。

func notify(msg string) {
	//C.callNotify(unsafe.Pointer(notifyCallBack), C.pgoString(unsafe.Pointer(&msg)))
	syscall.Syscall(notifyCallBack, 1, uintptr(unsafe.Pointer(&msg)), 0, 0)
}

很简单对不对，直接将回调地址传入，然后传入参数就行，syscall这个函数，有好几个函数调用，少于三个参数的用syscall,6个的用syscall6，以此类推，一共有有可以支持18个参数的Syscall18。

不过就我个人来说，我更喜欢使用跳板函数的方式，因为比较直观。

将GO函数作为回调函数，让外部语言使用

在上一篇开头，咱们都已经涉及到了相关的知识，就是Go的函数类型无法作为通用语言类型一致的ABI，只能使用syscall.NewCallback或者NewCallbackCDecl来将一个Go函数类型包装成一个ABI类型指针。这两个函数实际上调用的都是compileCallback，前面都已经说过。

那么如果要搞一个Go函数作为回调函数，有一些什么需要注意的呢，主要有两点：

1. 函数必须有一个返回值，并且这个返回值必须是指针大小类型（也就是C语言中的size_t，go语言中的uintptr大小），不能是其他类型，浮点数都不行
2. 函数的参数要要对应，也只能是指针大小类型，也不能是浮点数类型

为什么呢，因为里面的代码(windows平台)就是这样写的

有了上面的知识之后，现在咱们来模拟一下用Go语言来模拟一个C语言的那个回调函数NotifyMsg，因为回调函数声明得时候，用了__stdcall，所以咱们使用syscall.NewCallback，如果使用得是__cdecl或者不写（默认就是cdecl），那么咱们就需要使用NewCallbackCDecl来生成一个回调指针了。

    funcGoCallBack := syscall.NewCallback(func(String2 C.pgoString) int {
		msg := *(*string)(unsafe.Pointer(String2))
		fmt.Println(msg)
		return 0
	})
    //注册一下，自己调用自己
	registerCallBack(funcGoCallBack)
	notify("这是GO语言模拟了C得NotifyMsg回调函数")

那么问题来了，可能有人说，别人给的库函数没有返回函数，用的是void返回，而上面我们也说了使用syscall.NewCallback的时候，必须要有一个返回值的，怎么破呢,回答，就是无所谓，对于返回void类型的，咱们直接给他 uintptr作为返回值类型就是，因为本身实际上返回值是在eax或者rax中的，无非就是给这个寄存器值了而已，我们用不用无所谓。

下面咱们写一个比较完整的例子，就是调用WindowsAPI，并且这个API具备有回调含糊的，来看看效果。

package main

import (
	"fmt"
	"syscall"
	"time"
	"unsafe"
)

type POINT struct {
	X, Y int32
}

type MSG struct {
	HWnd    syscall.Handle
	Message uint32
	WParam  uintptr
	LParam  uintptr
	Time    uint32
	Pt      POINT
}

func main() {
	libuser32, _ := syscall.LoadLibrary("user32.dll")
	fnGetMessageW, _ := syscall.GetProcAddress(libuser32, "GetMessageW")
	fnTranslateMessage, _ := syscall.GetProcAddress(libuser32, "TranslateMessage")
	fnDispatchMessageW, _ := syscall.GetProcAddress(libuser32, "DispatchMessageW")
	fnSetTimer, _ := syscall.GetProcAddress(libuser32, "SetTimer")
	timerCallBack := syscall.NewCallback(func(handle syscall.Handle, msg uint, timerId uint, dtime uint32) uintptr {
		fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
		return 0
	})
	r1, _, _ := syscall.Syscall6(fnSetTimer, 4, 0, uintptr(1000), uintptr(1000), timerCallBack, 0, 0)
	if r1 == 0 {
		fmt.Println("创建定时器失败")
	}
	tk := time.After(time.Second * 30)
	for {
		//启动一个消息循环
		select {
		case <-tk:
			fmt.Println("30秒退出")
			return
		default:
			var msg MSG
			ret, _, _ := syscall.Syscall6(fnGetMessageW, 4, uintptr(unsafe.Pointer(&msg)), 0, 0, 0, 0, 0)
			if ret != 0 {
				syscall.Syscall(fnTranslateMessage, 1, uintptr(unsafe.Pointer(&msg)), 0, 0)
				syscall.Syscall(fnDispatchMessageW, 1, uintptr(unsafe.Pointer(&msg)), 0, 0)
			}
		}
	}
}

以上代码，主要就是通过设定了一个Win的时钟定时器，然后这个定时器里面执行的回调函数，咱们就指定了Go的一个闭包作为回调函数，因为WinAPI都是stdcall类型的，所以，咱们使用syscall.NewCallback来构建回调函数指针，最后启用了消息循环去不断的触发时钟，上面的代码需要注意的点是，一定要启用下面的消息循环哦，因为Win的这个时钟是在消息循环中触发的，否则的话是没有效果，这类知识不属于本篇范畴，不做详解，有需要的自行去查看MSDN相关知识咯。

到此为止，基本上在Go中触发调用外部语言的回调函数，以及以Go作为回调函数，给外部语言使用的方式，都了解OK了。

最后，咱们使用Go实现一个DLL，给Delphi调用

这里，就基本上将前面的知识综合在一起了，并生成动态库给其他语言调用。

package main

/*
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct _goString{
	char*	utf8Data;
	int	datalen;
}goString,*pgoString;

typedef void _stdcall (*notifyCallBack)(pgoString string);
*/
import "C"
import (
	"syscall"
	"time"
	"unsafe"
)

var notifyCallBack uintptr

func notify(msg string) {
	syscall.Syscall(notifyCallBack, 1, uintptr(unsafe.Pointer(&msg)), 0, 0)
}

//export registerCallBack
func registerCallBack(callBackFunc uintptr) {
	notifyCallBack = callBackFunc
	go func() {
		for i := 0; i < 5; i++ {
			select {
			case <-time.After(time.Second):
				notify("当前时间：" + time.Now().Format("2006-01-02 15:04:05"))
			}
		}
		notify("全部通知完毕，现在退出了,再也不会触发了")
	}()
}

func main() {

}

上面是Go动态库的主要代码，我们编译他生成动态库

set CGO_ENABLED=1
SET GOOS=windows
SET CC=D:\devtools\msys64\mingw32\bin\gcc.exe  
SET GOARCH=386
go build -ldflags "-s -w" -buildmode=c-shared -o test.dll

执行上面的一堆指令，可以写一个批处理文件，自动去执行他，上面有几个需要注意的点

GOARCH指定了生成的是32位系统的DLL，如果生成32位的，GCC的编译器CC变量要指定成咱们系统中的32位的GCC哦，如果GOARCH=AMD64，那么编译成64位的，就需要指定64位的GCC，编译就能生成指定的动态库test.dll了

使用本方式编译出来的动态库，里面可能会导出一堆，我们不需要的函数或者结构，如果不想要那些结构的话，咱们可以自己使用def文件，指定导出的数据，然后编译，比如上面的库只有一个导出函数，所以，首先咱们需要编写一个def文件，比如取名为callback.def

callback.def内容如下：

EXPORTS
    registerCallBack

然后咱们编译，此时的编译指令，也有点区别，不能一步到位了，需要生成中间文件，然后一步步的去连接处理，指令如下：

set CGO_ENABLED=1
SET GOOS=windows
SET CC=D:\devtools\msys64\mingw32\bin\gcc.exe
SET GOARCH=386
go build -ldflags "-s -w" -buildmode=c-archive -o ./bin/test.a
gcc callback.def ./bin/test.a -shared -lwinmm -lWs2_32 -o ./bin/test.dll -Wl,--out-implib,./bin/test.lib

这样导出的内容就只有def中定义的registerCallBack了

下面给出Delphi的调用示例

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,qstring;

type
  TGoString = record
    utf8: PByte;
    datalen: Integer;
  end;
  PGoString = ^TGoString;
  TNotifyCallBack = procedure(msg: PGoString);stdcall;
  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;
  dllHandle: THandle;
  registerCallBack: procedure(notifyMsg: TNotifyCallBack);cdecl;
implementation

{$R *.dfm}

procedure notif(msg: PGoString);stdcall;
var
  utf8Msg: string;
begin
  utf8Msg := qstring.Utf8Decode(PQCharA(msg^.utf8),msg^.datalen );
  
  if GetCurrentThreadId <> MainThreadID then
  begin
    TThread.Synchronize(nil,procedure
      begin
         Form1.Memo1.Lines.Add(utf8Msg)
      end);
  end
  else Form1.Memo1.Lines.Add(utf8Msg)
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  DllHandle := LoadLibrary('test.dll');
  if dllHandle <> 0 then
  begin
    registerCallBack := GetProcAddress(dllHandle,'registerCallBack');
    if Assigned(registerCallBack) then
      registerCallBack(@notif);
  end;
end;

end.

最后运行结果，就会不断的将数据显示到Memo1中