Go 语言类型断言

Question

I am trying to do dependency injection in golang with applying dependency inversion principle, so I have the following service

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}
}

as you can see, it accepts another service with type IUsagePlanService

and here is the interface for it

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]
}

and here is the way I am injecting this service to domain service

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

as you can see, I am trying to do a type assertion but it doesn't work, and gives me the following error:

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

Edit

Here is the actual implementation for 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

When using an interface, you need to define all functions that you will use with the same name and signature as the implementation.

The error message you got indicates that the implementation and the interface are different.

The implementation is not shown in your question, but you defined the function for your interface like this: GetPlanById(string) *shared.Result[UsagePlan] . Any deviation from it will result in error. One common mistake is with the pointers. Adding or removing the * to the return type will incur in error if it differs from the original.