重用结构体以减少堆使用

为优化资源使用，APIClient 结构体使用一个名为 service 的通用结构体，而不是为每个 API 服务分配一个堆上的结构体。当调用 NewAPIClient 函数时，它会创建 APIClient 结构体的实例，并将 common 服务结构体复制到自身，使所有 API 服务共享相同的服务结构体，而不是为每个服务分配单独的结构体。

请解释以下代码中发生的情况。我不明白的部分是服务结构。服务结构是 apiclient 结构的包装器。当调用 newapiclient 时，它正在使用内部的服务结构并复制到自身。我似乎无法理解这一点。请指教并详细说明。谢谢。

type APIClient struct {
    cfg    *Configuration

    // Reuse a single struct instead of 
    // allocating one for each service on the heap.
    common service 

    // API Services
    AccountApi          *AccountApiService
    ContractApi         *ContractApiService
    FYIApi              *FYIApiService
    IBCustApi           *IBCustApiService
    MarketDataApi       *MarketDataApiService
    OrderApi            *OrderApiService
    PnLApi              *PnLApiService
    PortfolioApi        *PortfolioApiService
    PortfolioAnalystApi *PortfolioAnalystApiService
    ScannerApi          *ScannerApiService
    SessionApi          *SessionApiService
    TradesApi           *TradesApiService
}

type service struct {    
    client *APIClient    
}

func NewAPIClient(cfg *Configuration) *APIClient {    
    if cfg.HTTPClient == nil {    
            cfg.HTTPClient = http.DefaultClient    
    }    

    c := &APIClient{}    
    c.cfg = cfg    
    c.common.client = c    

    c.AccountApi = (*AccountApiService)(&c.common)    
    c.ContractApi = (*ContractApiService)(&c.common)
    c.FYIApi = (*FYIApiService)(&c.common)
    c.IBCustApi = (*IBCustApiService)(&c.common)
    c.MarketDataApi = (*MarketDataApiService)(&c.common)
    c.OrderApi = (*OrderApiService)(&c.common)
    c.PnLApi = (*PnLApiService)(&c.common)
    c.PortfolioApi = (*PortfolioApiService)(&c.common)
    c.PortfolioAnalystApi = (*PortfolioAnalystApiService)(&c.common)
    c.ScannerApi = (*ScannerApiService)(&c.common)
    c.SessionApi = (*SessionApiService)(&c.common)
    c.TradesApi = (*TradesApiService)(&c.common)

    return c
}

解决方案

首先，请注意表达式 (*accountapiservice)(&c.common) 是一个显式 conversion：

有许多规则允许您将一种类型的表达式转换为另一种类型，但与您的用例相关的规则是：

so the assignment statement c.accountapi = (*accountapiservice)(&c.common) can be explained like this: since the field common is of type service the expression &c.common is of type *service, that type is然后转换为 *accountapiservice，并将该转换表达式的结果分配给 c.accountapi 字段。

正如我们上面所建立的，为了使转换工作，两种类型 *accountapiservice 和 *service 必须具有相同的基础类型。因此，即使您没有提供任何 xxxapiservice 类型的定义，也可以安全地假设，如果代码实际编译，它们都被定义为

type xxxapiservice service

或

type xxxapiservice struct {
    client *apiclient
}

有效地为它们提供与 service 的基础类型相同的基础类型。

你可能会问自己为什么不像正常人一样初始化各种服务，为什么不写这个

c.AccountApi = &AccountApiService{c}

相反？答案就在 apiclient 的 common 字段上方的注释中。

这意味着分配给 common 的值由所有服务字段共享，而不是为每个服务字段分配 xxxapiservice 的新实例。我认为这里的目的是资源/性能优化。

最后赋值 c.common.client = c。 apiclient 有一个名为 common 类型为 service 的字段，类型 service 有一个名为 client 类型为 *apiclient 的字段。这基本上允许客户端通过 common 字段保存对自身的引用，尽管这不是这里的主要目标，但这正是示例代码中发生的情况。基本上是递归，这是 apiclient 设计 afaict 的一个意外功能，但它确实存在。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《重用结构体以减少堆使用》文章吧，也可关注golang学习网公众号了解相关技术文章。