Как ссылаться на несколько библиотек с одинаковыми функциями и переключаться между ними в Go

Мне интересно, как я могу сделать что-то похожее на это. В настоящее время у меня есть несколько пакетов с той же структурой и функциями, но они на самом деле получают значения из нескольких API. Я также загружаю в конфигурацию, которая имеет массив с параметрами, чтобы использовать один из этих пакетов на элемент массива. Мне интересно, как я могу создать переменную, которая использует один из этих пакетов на основе значения конфигурации. Надеюсь, это достаточно ясно. Вот псевдокод, который я написал, чтобы объяснить. заранее спасибо

package main

import (
    "errors"
    "flag"
    "os"
    "project/lib"
    "project/morelib"
    "project/extralib"
    "fmt"
    "math"
    "math/rand"
    "time"
)

func stuff(info RunInfo) (err error) {

    apiKey:= "stuff1" // actually in the config
    apiSecret := "stuff2" // actually in the config
    variable := lib.New(apiKey, apiSecret) //returns *Lib struct 
    //this is where I have to comment out the other libs and uncomment them as needed
    // variable := morelib.New(apiKey, apiSecret)
    // variable := extralib.New(apiKey, apiSecret)

//trying to switch between libraries like this or in a switch statement
    if info.libname == "lib"{
        variable = lib.New(apiKey, apiSecret) //.New("", "") returns *Lib struct
    }else if info.libname == "morelib"{
        variable = morelib.New(apiKey, apiSecret) //.New("", "") returns *MoreLib struct
    }else if info.libname == "extralib"{
        variable = extralib.New(apiKey, apiSecret) //.New("", "") returns *ExtraLib struct
    }else{
        err = errors.New("there was an error with the value.....")
        return err
    }

    mystuffs, err := variable.GetBalance("USD")
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("mystuff value: %v", mystuffs.value)

    return 

}
type RunInfo struct{
    libname string
    //other stuff
}
func main() {
    //load from config with array 
    config := config.Load()
    for i:=0; i<compare; i++{
        var runInfo RunInfo
        runInfo.libname = config.libname
        stuff(runInfo)
    }
}

псевдо-lib код:

func New(apiKey, apiSecret string) *Lib {
client := NewClient(apiKey, apiSecret)
return &Lib{client}
}
func NewClient(apiKey, apiSecret string) (c *client) {
    return &client{apiKey, apiSecret, &http.Client{}, false}
}
type Lib struct {
    client *client
}
type client struct {
    apiKey     string
    apiSecret  string
    httpClient *http.Client
    debug      bool
}

func (b *Lib) GetBalance(currency string) (balance Balance, err error) {
    payload, err := json.Marshal(BalanceParams{Currency: currency})
    if err != nil {
        return
    }
    r, err := b.client.do("POST", "GetBalance", string(payload), true)
    if err != nil {
        return
    }
    var response jsonResponse
    if err = json.Unmarshal(r, &response); err != nil {
        return
    }
    if err = handleErr(response); err != nil {
        return
    }
    err = json.Unmarshal(response.Result, &balance)

    return
}
Источник

2 ответа

Решение

Используйте оператор if и if, как в вопросе, оператор switch или карту.

Я предполагаю, что тип, возвращаемый New Функция имеет следующий интерфейс:

type GetStuffer interface 
    GetStuff(string) (Stuff, error)
}

Оператор переключения:

var variable GetStuffer
switch info.CompareVal {
case "lib":
    variable = lib.New(string1, string2) 
case "morelib":
    variable = morelib.New(string1, string2)
case "extralib":
    variable = extralib.New(string1, string2)
default:
     return errors.New("there was an error with the value.....")
}

mystuffs, err := variable.GetMyStuff()
if err != nil {
    fmt.Println(err)
    return
}

Для карты инициализируйте переменную уровня пакета картой:

var m = map[string]func(string,string) GetStuffer {
   "lib": lib.New,
   "morelib": morelib.New,
   "extralib": extralib.New,
}

и используйте это так:

fn := m[info.CompareValue]
if m == nil {
     return errors.New("there was an error with the value.....")
}
variable := fn(string1, string2)
mystuffs, err := variable.GetMyStuff()
if err != nil {
    fmt.Println(err)
    return
}

Если приведенное выше предположение о типе возврата неверно, то есть два варианта. Первое и, вероятно, самое простое, это изменить New функции для возврата типа GetStuffer, Если это невозможно, напишите немного функций адаптера:

 var m = map[string]func(string,string) GetStuffer {
   "lib":func(s1, s2 string) GetStuffer { return lib.New(s1, s2) }
   "morelib":func(s1, s2 string) GetStuffer { return morelib.New(s1, s2) }
   "extralib":func(s1, s2 string) GetStuffer { return extralib.New(s1, s2) }
}
Источник

Почему бы вам не определить интерфейс, который является только одной функцией? В вашем примере будет

type Stuffer interface {
   GetMyStuff(string) (Stuff, error)
}

Затем вы объявляете свою переменную как тип Stuffer,

Источник
Другие вопросы по тегам