日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

Golang使用CGO與Plugin技術運行加載C動態庫_Golang

作者：??字節跳動技術團隊??? ? 更新時間： 2022-09-07 編程語言

文章簡介

本文介紹一種 Golang 程序在運行時加載 C 動態庫的技術，跳過了 Golang 項目編譯階段需要鏈接 C 動態庫的過程，提高了 Golang 項目開發部署的靈活性。

技術背景

Golang 程序調用 OpenCC 動態庫的函數，執行文本繁體轉簡體操作。 需要在編譯時不鏈接動態庫，只在程序運行時加載 OpenCC 動態庫。

OpenCC 庫是使用 C++ 編寫的繁簡體轉換程序，提供 C 語言 API 接口。 開源項目地址

CGO 技術是讓 Golang 語言使用 C 語言代碼的一種方式，可以在 Golang 程序編譯的時候鏈接 C 動態庫。C 語言經過數十年的發展，有豐富的開源項目。在 Golang 生態還不是很完善的情況下，我們經常需要使用一些成熟的C開源項目。

Plugin 是 Golang 1.8 版本引入了一個新的插件系統，允許程序員使用動態鏈接庫構建松散耦合的模塊化程序，在程序運行時動態加載和綁定。

本文循序漸進地講解 2 種解決方案：

  • 解決方案 1：使用 CGO 技術，編譯時綁定 OpenCC 的接口。
  • 解決方案 2：引入 Plugin 技術，程序運行時加載動態庫。

解決方案1

方案 1 是最初的解決方案，使用 CGO 技術，在編譯的時候綁定 OpenCC 的接口。

Golang -> CGO -> libopencc.so

編寫CGO接口定義文件：

// opencc.h
#include <stdlib.h>

void* Opencc_New(const char *configFile);
void* Opencc_Delete(void *id);
const char *Opencc_Convert(void *id, const char *input);
void Opencc_Free_String(char *p);
// opencc.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "opencc/src/opencc.h"

const char *Convert(const char *input, const char *config) {
        if(strlen(config) > 16) {
                return 0;
        }

        char configFile[256] = "/usr/share/opencc/";
        strcat(configFile, config);
        strcat(configFile, ".json");

        opencc_t p = opencc_open(configFile);
        char *out = opencc_convert_utf8(p, input, strlen(input));
        out[strlen(input)] = '\0';

        opencc_close(p);

        return out;
}

void Convert_free_string(char *p) {
        opencc_convert_utf8_free(p);
}

void* Opencc_New(const char *configFile) {
        return opencc_open(configFile);
}

void Opencc_Delete(void *id) {
        opencc_close(id);
}

const char *Opencc_Convert(void *id, const char *input) {
        char *output = opencc_convert_utf8(id, input, strlen(input));
        output[strlen(input)] = '\0';
        return output;
}

void Opencc_Free_String(char *p) {
        opencc_convert_utf8_free(p);
}
// opencc.go
package opencc

import "unsafe"
// #cgo LDFLAGS: -L${SRCDIR}/output/lib -lopencc
// #include "opencc.h"
import "C"
func NewConverter(config string) unsafe.Pointer {
        return C.Opencc_New(C.CString(config))
}
func Convert(p unsafe.Pointer, input string) string {
        inputChars := C.CString(input)
        outputChars := C.Opencc_Convert(p, inputChars)

        defer C.Opencc_Free_String(inputChars)
        defer C.Opencc_Free_String(outputChars)

        result := C.GoString(outputChars)
        return result
}
func Close(p unsafe.Pointer) {
        C.Opencc_Delete(p)
}
func ConvertOneTime(input string, config string) string {
        p := NewConverter(config)
        defer Close(p)
        return Convert(p, input)
}
func ConvertAsync(input string, config string, callback func(output string)) {
        go func() {
                callback(ConvertOneTime(input, config))
        }()
}
// test.go 調用OpenCC動態庫的函數。
package main

import "fmt"
import "your/repository/go-opencc"
const (
        input = "中國鼠標軟件打印機"
        config_s2t = "/usr/share/opencc/s2t.json"
        config_t2s = "/usr/share/opencc/t2s.json"
)
func main() {
        fmt.Println("Test Converter class:")
        c := opencc.NewConverter(config_s2t)
        defer c.Close()
        output := c.Convert(input)
        fmt.Println(output)

        fmt.Println("Test Convert function:")
        s := opencc.Convert(input, config_s2t)
        fmt.Println(s)
        fmt.Println(opencc.Convert(s, config_t2s))

        fmt.Println("Test ConvertAsync function:")
        retChan := make(chan string)
        opencc.ConvertAsync(input, config_s2t, func(output string) {
                retChan <- output
        })

        fmt.Println(<- retChan)
}

方案 1，可以正確鏈接 libopencc.so 文件，并成功執行 Convert 函數進行繁簡體轉換。 但是有個問題，該方案在 Mac 系統上不容易進行編譯，需要在 Mac 系統里安裝 OpenCC 項目。假如調用 OpenCC 的項目有 10 人共同開發，就需要在 10 人的 Mac 電腦上進行編譯，開發協作困難，不方便部署。

解決方案2

引入 Plugin 技術，程序運行時加載動態庫。

Golang -> Plugin -> libgo_opencc.so -> CGO -> libopencc.so

編寫 Plugin 動態鏈接庫。

// opencc_lib.go
package main
import (
        "unsafe"

        opencc "your/repository/go-opencc"
)

type openccConverter string

// NewConverter 創建Converter
func (s openccConverter) NewConverter(config string) unsafe.Pointer {
        return opencc.NewConverter(config)
}

// Convert 轉換函數
func (s openccConverter) Convert(p unsafe.Pointer, input string) string {
        return opencc.Convert(p, input)
}

// Close 釋放Converter占用的內存資源(不再使用Converter了)
func (s openccConverter) Close(p unsafe.Pointer) {
        opencc.Close(p)
}
// ConvertOneTime 轉換函數(轉換一次，該函數每次調用都會加載配置文件，有性能影響)
func (s openccConverter) ConvertOneTime(input string, config string) string {
        return opencc.ConvertOneTime(input, config)
}
// OpenccConverter export symble
var OpenccConverter openccConverter

編譯動態庫 build.sh 創建 output 目錄，編譯生成 ./output/lib/libgo_opencc.so 動態庫。

#!/bin/bash

mkdir -p output

cd opencc
./build.sh
cd ..
cp -rf opencc/output/* ./output
go build -buildmode=plugin -o ./output/lib/libgo_opencc.so ./lib/opencc_lib.go

使用 Plugin 加載 libgo_opencc.so，調用 OpenCC 的函數。

package main
import (
        "os"
        "plugin"
        "testing"
        "unsafe"
        "fmt"
)
// 實現 opencc_lib.go 的接口
type OpenccConverter interface {
        NewConverter(config string) unsafe.Pointer
        Convert(p unsafe.Pointer, input string) string
        Close(p unsafe.Pointer)
        ConvertOneTime(input string, config string) string
}

func TestOpenccSo(t *testing.T) {
        openccPlugin, pluginErr := plugin.Open("/your/path/to/go-opencc/output/lib/libgo_opencc.so")
        if pluginErr != nil {
                panic(pluginErr)
        }

        symbol, cerr := openccPlugin.Lookup("OpenccConverter")
        if cerr != nil {
                fmt.Errorf("%+v", cerr)
                os.Exit(1)
        }

        plug, ok := symbol.(OpenccConverter)
        if !ok {
                fmt.Errorf("unexpected type from module symbol")
                os.Exit(1)
        }

        config := "/usr/share/opencc/hk2s.json"
        pointer := plug.NewConverter(config)
        defer plug.Close(pointer)

        input := "傳統漢字"

        output := plug.Convert(pointer, input)

        fmt.Printf("output: %s", output)
}
// 運行測試 TestOpenccSo，輸出 “傳統漢字”。

方案 2，實現了在程序運行時通過 Plugin 技術加載 libgo_opencc.so 動態庫，再由 libgo_opencc.so 鏈接到 libopencc.so，即可在 Mac、Linux 系統上編譯 Golang 程序，無需每臺開發機都部署 OpenCC 項目。最終發布到生產環境時，由編譯打包平臺將 libgo_opencc.so 和 libopencc.so 一起打包發布。

原文鏈接：https://juejin.cn/post/7120176632693784607

欄目分類
最近更新