Go lang类型断言

Question

我正尝试用依赖反转原理在金刚进行依赖注入，所以我有以下服务

package account

import (
    types "zaClouds/modules/account/domain/types"
    "zaClouds/modules/shared"
)

type IPlanDomainService interface {
    GetUsagePlanById(string) *shared.Result[types.UsagePlan]
}

type PlanDomainService struct {
    usagePlanService types.IUsagePlanService
}

func (planDomainService *PlanDomainService) GetUsagePlanById(id string) *shared.Result[types.UsagePlan] {
    result := &shared.Result[types.UsagePlan]{}
    usagePlanResult := planDomainService.usagePlanService.GetPlanById(id)

    if usagePlanResult.Err != nil {
        result.Err = usagePlanResult.Err
        return result
    }
    result.Data = usagePlanResult.Data
    return result
}

func PlanDomainServiceFactory(usagePlanService types.IUsagePlanService) IPlanDomainService {
    return &PlanDomainService{usagePlanService: usagePlanService}
}

如您所见，它接受另一个具有IUsagePlanService类型的服务。

这是它的接口

package account

import (
    "zaClouds/modules/shared"

    "github.com/shopspring/decimal"
)

type UsagePlan struct {
    ID          string
    Title       string
    Description interface{}
    PlanID      string
    Price       decimal.Decimal
    Duration    int
    Features    map[string]map[string]string
}
type IUsagePlanService interface {
    GetPlanById(string) *shared.Result[UsagePlan]
}

下面是我将此服务注入域服务的方式

func DiInit(usagePlanService interface{}) domainServices.IPlanDomainService {
domainServices.PlanDomainServiceFactory(types.IUsagePlanService(usagePlanService))
    return domainServices.PlanDomainServiceFactory(usagePlanService.(types.IUsagePlanService))
}

如您所见，我正在尝试执行类型断言，但它不起作用，并给出了以下错误：

panic: interface conversion: *usagePlan.UsagePlanRepository is not account.IUsagePlanService: missing method GetPlanById

编辑

下面是usagePlanService的实际实现

type IUsagePlanRepository interface {
    createClient(string) *http.Request
    GetPlanById(string) *shared.Result[usagePlanRepoModels.UsagePlan]
}

type UsagePlanRepository struct {
    plansEndpoint string
    httpClient    *http.Client
}

func (r *UsagePlanRepository) GetPlanById(id string) *shared.Result[usagePlanRepoModels.UsagePlan] {
    result := &shared.Result[usagePlanRepoModels.UsagePlan]{}

    req := r.createClient(id)
    resp, err := r.httpClient.Do(req)

    if err != nil {
        log.Println("failed to load plan details \n[ERROR]", err)
        result.Err = err
        return result
    }

    defer func() {
        bodyError := resp.Body.Close()

        if bodyError != nil {
            result.Err = bodyError
        }

    }()

    if result.Err != nil {
        return result
    }

    body, err := ioutil.ReadAll(resp.Body)

    if err != nil {
        utils.Logger.Error("failed to load plan details \n[ERROR]", err, nil)
        result.Err = err
        return result
    }

    if resp.StatusCode >= 400 {
        result.Err = errors.New(string(body))
        utils.Logger.Info("getPlanById", string(body))
    }

    getUsagePlanResponse, foundError := usagePlanRepoModels.CreateGetUsagePlanResponse(body)

    if foundError != nil {
        result.Err = foundError
        return result
    }

    result.Data = *getUsagePlanResponse
    return result

}

Answer 1

在使用接口时，需要定义与实现具有相同名称和签名的所有函数。

您得到的错误消息表明实现和接口是不同的。

实现没有显示在您的问题中，但是您为您的接口定义了如下函数：GetPlanById(string) *shared.Result[UsagePlan]。任何偏离它都会导致错误。一个常见的错误是指针。如果返回类型与原始类型不同，则向返回类型添加或删除*将产生错误。

编辑：

您的界面应该如下所示：

type IUsagePlanService interface {
    GetPlanById(id string) *shared.Result[usagePlanRepoModels.UsagePlan]
}

如果您的函数正在返回一个私有类型，并且您可以更改该类型，则应该这样做。如果您不能更改它，那么就应该创建一个函数来包装您试图用接口抽象的函数。