Question

我有一个类似于下面所示的服务对象，该服务对象通过HTTP公开：

type ComputeService struct {

}

func (svc ComputeService) Compute(userType string, data Data) (Result, error) {
   // rate limit based on userType (both check and increment counter)
   // if not rate limited, compute and return result
}

现在，如您所见，需要基于userType进行速率限制。速率限制器本身的实现根据userType进行更改。我正在考虑使用userType解决速率限制器的两种方法。

// First approach: for each request new ComputeService object is
// created after resolving RateLimiter using userType in the handler
// itself
type ComputeService struct {
    RateLimiter RateLimiter
}

// Second approach: ComputeService object is initialized during startup
// and only RateLimiter is resolved with every Compute() call by calling
// the provider function
type ComputeService struct {
    RateLimiterProvider func(userType string) RateLimiter
}

两者都是可以测试的。哪一个更可取？我倾向于第二种方法，因为使用它意味着处理程序将纯粹是读取请求，委托给服务，写出响应，而在第一种方法中，处理程序将包含解决速率限制器实现的其他步骤。

Answer 1

如果您使用的是Dargo之类的DI系统，则可以使用其提供程序注入在运行时动态选择实现。

在这种情况下，您的服务将类似于以下内容：

import "github.com/jwells131313/dargo/ioc"

type RateLimiter interface {
}

type UserType1RateLimiter struct {
}

type UserType2RateLimiter struct {
}

type ComputeService struct {
    RateLimiterProvider ioc.Provider `inject:"RateLimiter"`
}

func (svc ComputeService) Compute(userType string, data Data) (Result, error) {
    // rate limit based on userType (both check and increment counter)
    // if not rate limited, compute and return result
    raw, err := svc.RateLimiterProvider.QualifiedBy(userType).Get()
    if err != nil {
        return nil, err
    }

    limiter := raw.(RateLimiter)
    //...
}

这是将它们绑定到ServiceLocator中的方法：

func initializer() {
    serviceLocator, _ = ioc.CreateAndBind("ExampleLocator", func(binder ioc.Binder) error {
        binder.Bind("RateLimiter", UserType1RateLimiter{}).QualifiedBy("UserType1")
        binder.Bind("RateLimiter", UserType2RateLimiter{}).QualifiedBy("UserType2")
        binder.Bind("ComputeService", ComputeService{})
        return nil
    })
}

这仅在使用诸如Dargo之类的东西时适用，但在您的情况下仍然有用。

如果您不使用Dargo，虽然我个人会选择第二种方法，但在我看来，这只是个见解

Golang中的工厂功能

1 个答案: