3.5 实战练习与面试重点¶

package httpclient

import (
    "context"
    "errors"
    "fmt"
    "io"
    "log"
    "net/http"
    "time"
)

// Client 定义HTTP客户端接口
type Client interface {
    Get(ctx context.Context, url string, opts ...RequestOption) (*Response, error)
    Post(ctx context.Context, url string, body io.Reader, opts ...RequestOption) (*Response, error)
    Put(ctx context.Context, url string, body io.Reader, opts ...RequestOption) (*Response, error)
    Delete(ctx context.Context, url string, opts ...RequestOption) (*Response, error)
    Do(ctx context.Context, req *http.Request) (*Response, error)
    Use(middlewares ...Middleware)
}

// Response 封装HTTP响应
type Response struct {
    *http.Response
    BodyBytes []byte
}

// Middleware 定义中间件接口
type Middleware func(next RoundTripper) RoundTripper

// RoundTripper 定义请求执行接口
type RoundTripper interface {
    RoundTrip(ctx context.Context, req *http.Request) (*Response, error)
}

// RequestOption 定义请求选项函数
type RequestOption func(*http.Request)

// client 实现Client接口
type client struct {
    httpClient  *http.Client
    middlewares []Middleware
    baseTripper RoundTripper
    logger      *log.Logger
}

// NewClient 创建新的HTTP客户端
func NewClient(opts ...ClientOption) Client {
    c := &client{
        httpClient: &http.Client{
            Timeout: 30 * time.Second,
        },
        logger: log.Default(),
    }

    // 基础执行器
    c.baseTripper = &httpRoundTripper{client: c.httpClient}

    // 应用选项
    for _, opt := range opts {
        opt(c)
    }

    return c
}

// ClientOption 定义客户端选项函数
type ClientOption func(*client)

// WithTimeout 设置客户端超时时间
func WithTimeout(timeout time.Duration) ClientOption {
    return func(c *client) {
        c.httpClient.Timeout = timeout
    }
}

// WithLogger 设置日志器
func WithLogger(logger *log.Logger) ClientOption {
    return func(c *client) {
        c.logger = logger
    }
}

// httpRoundTripper 实现RoundTripper接口
type httpRoundTripper struct {
    client *http.Client
}

func (h *httpRoundTripper) RoundTrip(ctx context.Context, req *http.Request) (*Response, error) {
    req = req.WithContext(ctx)

    resp, err := h.client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }

    // 读取响应体
    bodyBytes, err := io.ReadAll(resp.Body)
    if err != nil {
        resp.Body.Close()
        return nil, fmt.Errorf("failed to read response body: %w", err)
    }

    // 重新包装Body，以便后续读取
    resp.Body = io.NopCloser(io.NewReader(bodyBytes))

    return &Response{
        Response:  resp,
        BodyBytes: bodyBytes,
    }, nil
}

// 实现Client接口方法
func (c *client) Get(ctx context.Context, url string, opts ...RequestOption) (*Response, error) {
    req, err := http.NewRequest(http.MethodGet, url, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }

    for _, opt := range opts {
        opt(req)
    }

    return c.Do(ctx, req)
}

func (c *client) Post(ctx context.Context, url string, body io.Reader, opts ...RequestOption) (*Response, error) {
    req, err := http.NewRequest(http.MethodPost, url, body)
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }

    for _, opt := range opts {
        opt(req)
    }

    return c.Do(ctx, req)
}

func (c *client) Put(ctx context.Context, url string, body io.Reader, opts ...RequestOption) (*Response, error) {
    req, err := http.NewRequest(http.MethodPut, url, body)
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }

    for _, opt := range opts {
        opt(req)
    }

    return c.Do(ctx, req)
}

func (c *client) Delete(ctx context.Context, url string, opts ...RequestOption) (*Response, error) {
    req, err := http.NewRequest(http.MethodDelete, url, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }

    for _, opt := range opts {
        opt(req)
    }

    return c.Do(ctx, req)
}

func (c *client) Do(ctx context.Context, req *http.Request) (*Response, error) {
    if ctx == nil {
        return nil, errors.New("context must not be nil")
    }

    // 构建中间件链
    chain := c.baseTripper
    for i := len(c.middlewares) - 1; i >= 0; i-- {
        chain = c.middlewares[i](chain)
    }

    // 执行请求
    resp, err := chain.RoundTrip(ctx, req)
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }

    return resp, nil
}

func (c *client) Use(middlewares ...Middleware) {
    c.middlewares = append(c.middlewares, middlewares...)
}

// 泛型方法：将响应体解析为指定类型
func ParseResponse[T any](resp *Response) (*T, error) {
    if resp == nil {
        return nil, errors.New("response is nil")
    }

    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        return nil, fmt.Errorf("request failed with status code: %d", resp.StatusCode)
    }

    var result T
    if err := json.Unmarshal(resp.BodyBytes, &result); err != nil {
        return nil, fmt.Errorf("failed to unmarshal response: %w", err)
    }

    return &result, nil
}

// 日志中间件
func LoggingMiddleware(logger *log.Logger) Middleware {
    return func(next RoundTripper) RoundTripper {
        return RoundTripperFunc(func(ctx context.Context, req *http.Request) (*Response, error) {
            start := time.Now()
            logger.Printf("Started %s %s", req.Method, req.URL)

            resp, err := next.RoundTrip(ctx, req)

            duration := time.Since(start)
            if err != nil {
                logger.Printf("Failed %s %s: %v (duration: %v)", req.Method, req.URL, err, duration)
            } else {
                logger.Printf("Completed %s %s: %d (duration: %v)", req.Method, req.URL, resp.StatusCode, duration)
            }

            return resp, err
        })
    }
}

// 重试中间件
func RetryMiddleware(maxRetries int, backoff time.Duration) Middleware {
    return func(next RoundTripper) RoundTripper {
        return RoundTripperFunc(func(ctx context.Context, req *http.Request) (*Response, error) {
            var lastErr error

            for i := 0; i <= maxRetries; i++ {
                // 如果是重试，需要重新创建请求体（因为Body可能已被读取）
                var newReq *http.Request
                if i > 0 && req.Body != nil {
                    bodyBytes, err := io.ReadAll(req.Body)
                    if err != nil {
                        return nil, fmt.Errorf("failed to read request body for retry: %w", err)
                    }
                    req.Body.Close()

                    newReq = req.Clone(ctx)
                    newReq.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
                } else if i > 0 {
                    newReq = req.Clone(ctx)
                } else {
                    newReq = req
                }

                resp, err := next.RoundTrip(ctx, newReq)

                // 检查是否需要重试
                if err == nil && (resp.StatusCode < 500 || resp.StatusCode == http.StatusTooManyRequests) {
                    return resp, nil
                }

                lastErr = err

                // 如果是最后一次尝试，不再重试
                if i == maxRetries {
                    break
                }

                // 等待重试
                select {
                case <-time.After(backoff * time.Duration(1<<i)): // 指数退避
                case <-ctx.Done():
                    return nil, ctx.Err()
                }
            }

            return nil, fmt.Errorf("after %d retries: %w", maxRetries, lastErr)
        })
    }
}

// RoundTripperFunc 函数类型实现RoundTripper接口
type RoundTripperFunc func(ctx context.Context, req *http.Request) (*Response, error)

func (f RoundTripperFunc) RoundTrip(ctx context.Context, req *http.Request) (*Response, error) {
    return f(ctx, req)
}

package main

import (
    "context"
    "encoding/json"
    "log"
    "net/http"
    "os"
    "time"
    "yourmodule/httpclient"
)

// 示例API响应结构体
type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Email    string `json:"email"`
}

func main() {
    // 创建自定义日志器
    logger := log.New(os.Stdout, "HTTP_CLIENT: ", log.LstdFlags)

    // 创建客户端并配置
    client := httpclient.NewClient(
        httpclient.WithTimeout(10*time.Second),
        httpclient.WithLogger(logger),
    )

    // 使用中间件
    client.Use(
        httpclient.LoggingMiddleware(logger),
        httpclient.RetryMiddleware(3, 1*time.Second),
    )

    // 发送GET请求
    ctx := context.Background()
    resp, err := client.Get(ctx, "https://api.example.com/users/1")
    if err != nil {
        log.Fatalf("请求失败: %v", err)
    }
    defer resp.Body.Close()

    // 使用泛型方法解析响应
    user, err := httpclient.ParseResponse[User](resp)
    if err != nil {
        log.Fatalf("解析响应失败: %v", err)
    }

    log.Printf("获取用户: %+v", user)

    // 发送POST请求
    newUser := User{
        Username: "newuser",
        Email:    "newuser@example.com",
    }
    body, _ := json.Marshal(newUser)
    postResp, err := client.Post(ctx, "https://api.example.com/users", 
        bytes.NewBuffer(body), 
        func(req *http.Request) {
            req.Header.Set("Content-Type", "application/json")
        },
    )
    if err != nil {
        log.Fatalf("POST请求失败: %v", err)
    }
    defer postResp.Body.Close()

    log.Printf("创建用户响应状态: %d", postResp.StatusCode)
}

package httpclient

import (
    "context"
    "net/http"
    "net/http/httptest"
    "testing"
    "time"
)

func TestClient_Get(t *testing.T) {
    // 创建测试服务器
    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodGet {
            t.Errorf("期望方法 %s，实际 %s", http.MethodGet, r.Method)
        }
        if r.URL.Path != "/test" {
            t.Errorf("期望路径 /test，实际 %s", r.URL.Path)
        }
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"status":"ok"}`))
    }))
    defer ts.Close()

    client := NewClient()
    resp, err := client.Get(context.Background(), ts.URL+"/test")
    if err != nil {
        t.Fatalf("请求失败: %v", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        t.Errorf("期望状态码 %d，实际 %d", http.StatusOK, resp.StatusCode)
    }

    // 测试泛型解析
    type Result struct {
        Status string `json:"status"`
    }
    result, err := ParseResponse[Result](resp)
    if err != nil {
        t.Fatalf("解析响应失败: %v", err)
    }

    if result.Status != "ok" {
        t.Errorf("期望状态 'ok'，实际 %s", result.Status)
    }
}

func TestRetryMiddleware(t *testing.T) {
    attempts := 0
    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        attempts++
        if attempts < 3 {
            w.WriteHeader(http.StatusInternalServerError)
            return
        }
        w.WriteHeader(http.StatusOK)
    }))
    defer ts.Close()

    client := NewClient(WithTimeout(5 * time.Second))
    client.Use(RetryMiddleware(2, 10*time.Millisecond))

    _, err := client.Get(context.Background(), ts.URL)
    if err != nil {
        t.Fatalf("请求失败: %v", err)
    }

    if attempts != 3 {
        t.Errorf("期望重试3次，实际 %d次", attempts)
    }
}

package di

import (
    "errors"
    "fmt"
    "reflect"
    "sync"
)

// Container 依赖注入容器接口
type Container interface {
    // Register 注册服务
    Register(name string, constructor interface{}, opts ...Option) error
    // RegisterInstance 注册实例
    RegisterInstance(name string, instance interface{}) error
    // Resolve 解析服务
    Resolve(name string, out interface{}) error
    // Invoke 调用函数并自动注入依赖
    Invoke(function interface{}) error
    // Cleanup 清理所有服务
    Cleanup()
}

// Option 服务注册选项
type Option func(*service)

// Scope 定义服务的生命周期
type Scope int

const (
    // Singleton 单例模式，整个容器生命周期内只创建一次
    Singleton Scope = iota
    // Transient  transient模式，每次解析都创建新实例
    Transient
)

// WithScope 设置服务的生命周期
func WithScope(scope Scope) Option {
    return func(s *service) {
        s.scope = scope
    }
}

// service 表示一个注册的服务
type service struct {
    name        string
    constructor reflect.Value
    instance    reflect.Value
    scope       Scope
    params      []reflect.Type
}

// container 实现Container接口
type container struct {
    services map[string]*service
    mu       sync.RWMutex
}

// NewContainer 创建一个新的依赖注入容器
func NewContainer() Container {
    return &container{
        services: make(map[string]*service),
    }
}

// Register 注册服务
func (c *container) Register(name string, constructor interface{}, opts ...Option) error {
    c.mu.Lock()
    defer c.mu.Unlock()

    if name == "" {
        return errors.New("服务名称不能为空")
    }

    if _, exists := c.services[name]; exists {
        return fmt.Errorf("服务 %s 已存在", name)
    }

    // 检查constructor是否为函数
    ctorType := reflect.TypeOf(constructor)
    if ctorType.Kind() != reflect.Func {
        return errors.New("constructor必须是一个函数")
    }

    // 检查函数是否至少有一个返回值
    if ctorType.NumOut() == 0 {
        return errors.New("constructor必须至少有一个返回值")
    }

    // 收集参数类型
    params := make([]reflect.Type, ctorType.NumIn())
    for i := 0; i < ctorType.NumIn(); i++ {
        params[i] = ctorType.In(i)
    }

    // 创建服务
    s := &service{
        name:        name,
        constructor: reflect.ValueOf(constructor),
        scope:       Singleton, // 默认单例
        params:      params,
    }

    // 应用选项
    for _, opt := range opts {
        opt(s)
    }

    c.services[name] = s
    return nil
}

// RegisterInstance 注册实例
func (c *container) RegisterInstance(name string, instance interface{}) error {
    c.mu.Lock()
    defer c.mu.Unlock()

    if name == "" {
        return errors.New("服务名称不能为空")
    }

    if _, exists := c.services[name]; exists {
        return fmt.Errorf("服务 %s 已存在", name)
    }

    if instance == nil {
        return errors.New("实例不能为nil")
    }

    s := &service{
        name:     name,
        instance: reflect.ValueOf(instance),
        scope:    Singleton,
    }

    c.services[name] = s
    return nil
}

// Resolve 解析服务
func (c *container) Resolve(name string, out interface{}) error {
    c.mu.RLock()
    defer c.mu.RUnlock()

    // 检查输出参数
    outVal := reflect.ValueOf(out)
    if outVal.Kind() != reflect.Ptr || outVal.IsNil() {
        return errors.New("out必须是一个非nil指针")
    }

    // 获取服务
    s, exists := c.services[name]
    if !exists {
        return fmt.Errorf("服务 %s 未注册", name)
    }

    // 解析服务实例
    instance, err := c.resolveService(s, []string{})
    if err != nil {
        return err
    }

    // 检查类型是否匹配
    outType := outVal.Elem().Type()
    if instance.Type() != outType {
        return fmt.Errorf("类型不匹配，期望 %s，实际 %s", outType, instance.Type())
    }

    // 设置输出值
    outVal.Elem().Set(instance)
    return nil
}

// Invoke 调用函数并自动注入依赖
func (c *container) Invoke(function interface{}) error {
    c.mu.RLock()
    defer c.mu.RUnlock()

    fnVal := reflect.ValueOf(function)
    fnType := fnVal.Type()

    if fnType.Kind() != reflect.Func {
        return errors.New("function必须是一个函数")
    }

    // 解析函数参数
    args := make([]reflect.Value, fnType.NumIn())
    for i := 0; i < fnType.NumIn(); i++ {
        argType := fnType.In(i)
        arg, err := c.resolveByType(argType, []string{})
        if err != nil {
            return fmt.Errorf("无法解析参数 %d: %w", i, err)
        }
        args[i] = arg
    }

    // 调用函数
    results := fnVal.Call(args)

    // 检查是否有错误返回
    for _, result := range results {
        if result.CanInterface() {
            if err, ok := result.Interface().(error); ok && err != nil {
                return err
            }
        }
    }

    return nil
}

// Cleanup 清理所有服务
func (c *container) Cleanup() {
    c.mu.Lock()
    defer c.mu.Unlock()

    // 清除所有单例实例
    for _, s := range c.services {
        if s.scope == Singleton {
            s.instance = reflect.Value{}
        }
    }
}

// resolveService 解析服务实例
func (c *container) resolveService(s *service, resolving []string) (reflect.Value, error) {
    // 检查循环依赖
    for _, name := range resolving {
        if name == s.name {
            return reflect.Value{}, fmt.Errorf("循环依赖: %v -> %s", resolving, s.name)
        }
    }

    // 如果是单例且已实例化，直接返回
    if s.scope == Singleton && s.instance.IsValid() {
        return s.instance, nil
    }

    // 如果是实例注册，直接返回
    if s.constructor.IsValid() == false && s.instance.IsValid() {
        return s.instance, nil
    }

    // 解析构造函数参数
    args := make([]reflect.Value, len(s.params))
    newResolving := append(resolving, s.name)

    for i, paramType := range s.params {
        arg, err := c.resolveByType(paramType, newResolving)
        if err != nil {
            return reflect.Value{}, fmt.Errorf("解析参数 %d 失败: %w", i, err)
        }
        args[i] = arg
    }

    // 调用构造函数
    results := s.constructor.Call(args)

    // 检查是否有错误返回
    for _, result := range results[1:] {
        if result.CanInterface() {
            if err, ok := result.Interface().(error); ok && err != nil {
                return reflect.Value{}, err
            }
        }
    }

    // 获取主要返回值
    instance := results[0]

    // 如果是单例，缓存实例
    if s.scope == Singleton {
        s.instance = instance
    }

    return instance, nil
}

// resolveByType 根据类型解析服务
func (c *container) resolveByType(targetType reflect.Type, resolving []string) (reflect.Value, error) {
    // 查找能够赋值给targetType的服务
    var candidates []*service

    for _, s := range c.services {
        // 检查服务是否可以赋值给目标类型
        var serviceType reflect.Type

        if s.instance.IsValid() {
            serviceType = s.instance.Type()
        } else if s.constructor.IsValid() {
            // 构造函数的第一个返回值类型
            serviceType = s.constructor.Type().Out(0)
        } else {
            continue
        }

        if serviceType.AssignableTo(targetType) {
            candidates = append(candidates, s)
        }
    }

    if len(candidates) == 0 {
        return reflect.Value{}, fmt.Errorf("未找到类型为 %s 的服务", targetType)
    }

    if len(candidates) > 1 {
        return reflect.Value{}, fmt.Errorf("找到多个类型为 %s 的服务", targetType)
    }

    // 解析找到的服务
    return c.resolveService(candidates[0], resolving)
}

package main

import (
    "fmt"
    "yourmodule/di"
)

// 定义服务接口
type Logger interface {
    Log(message string)
}

// 实现Logger接口
type ConsoleLogger struct{}

func NewConsoleLogger() Logger {
    return &ConsoleLogger{}
}

func (c *ConsoleLogger) Log(message string) {
    fmt.Println("Log:", message)
}

// 另一个服务，依赖Logger
type UserService struct {
    logger Logger
}

func NewUserService(logger Logger) *UserService {
    return &UserService{
        logger: logger,
    }
}

func (u *UserService) GetUser(id int) string {
    u.logger.Log(fmt.Sprintf("获取用户 %d", id))
    return fmt.Sprintf("用户 %d", id)
}

// 一个需要依赖注入的函数
func PrintUserInfo(userService *UserService, id int) {
    user := userService.GetUser(id)
    fmt.Println("用户信息:", user)
}

func main() {
    // 创建容器
    container := di.NewContainer()

    // 注册服务
    if err := container.Register("logger", NewConsoleLogger); err != nil {
        panic(err)
    }

    if err := container.Register("userService", NewUserService); err != nil {
        panic(err)
    }

    // 解析服务
    var userService *UserService
    if err := container.Resolve("userService", &userService); err != nil {
        panic(err)
    }

    user := userService.GetUser(123)
    fmt.Println("获取到用户:", user)

    // 调用函数并自动注入依赖
    if err := container.Invoke(func(logger Logger) {
        logger.Log("通过Invoke注入的日志")
    }); err != nil {
        panic(err)
    }

    // 调用带参数的函数
    if err := container.Invoke(func(us *UserService) {
        PrintUserInfo(us, 456)
    }); err != nil {
        panic(err)
    }
}

package di

import (
    "testing"
)

type TestService struct {
    Value int
}

func NewTestService() *TestService {
    return &TestService{Value: 42}
}

type DependentService struct {
    Test *TestService
}

func NewDependentService(test *TestService) *DependentService {
    return &DependentService{Test: test}
}

func TestContainer_RegisterAndResolve(t *testing.T) {
    container := NewContainer()

    // 注册服务
    err := container.Register("testService", NewTestService)
    if err != nil {
        t.Fatalf("注册服务失败: %v", err)
    }

    // 解析服务
    var service *TestService
    err = container.Resolve("testService", &service)
    if err != nil {
        t.Fatalf("解析服务失败: %v", err)
    }

    if service == nil {
        t.Error("解析结果为nil")
    }

    if service.Value != 42 {
        t.Errorf("期望值 42，实际 %d", service.Value)
    }
}

func TestContainer_DependencyResolution(t *testing.T) {
    container := NewContainer()

    // 注册服务
    err := container.Register("testService", NewTestService)
    if err != nil {
        t.Fatalf("注册testService失败: %v", err)
    }

    err = container.Register("dependentService", NewDependentService)
    if err != nil {
        t.Fatalf("注册dependentService失败: %v", err)
    }

    // 解析依赖服务
    var depService *DependentService
    err = container.Resolve("dependentService", &depService)
    if err != nil {
        t.Fatalf("解析dependentService失败: %v", err)
    }

    if depService == nil {
        t.Error("dependentService为nil")
    }

    if depService.Test == nil {
        t.Error("依赖的testService为nil")
    }

    if depService.Test.Value != 42 {
        t.Errorf("期望值 42，实际 %d", depService.Test.Value)
    }
}

func TestContainer_CircularDependency(t *testing.T) {
    // 定义有循环依赖的服务
    type A struct {
        B *B
    }
    type B struct {
        A *A
    }

    NewA := func(b *B) *A { return &A{B: b} }
    NewB := func(a *A) *B { return &B{A: a} }

    container := NewContainer()

    // 注册服务
    if err := container.Register("A", NewA); err != nil {
        t.Fatal(err)
    }
    if err := container.Register("B", NewB); err != nil {
        t.Fatal(err)
    }

    // 尝试解析服务，应该检测到循环依赖
    var a *A
    err := container.Resolve("A", &a)
    if err == nil {
        t.Error("期望检测到循环依赖错误，但未检测到")
    } else {
        t.Logf("正确检测到循环依赖: %v", err)
    }
}

func TestContainer_Invoke(t *testing.T) {
    container := NewContainer()

    // 注册服务
    if err := container.Register("testService", NewTestService); err != nil {
        t.Fatal(err)
    }

    // 测试Invoke
    var invoked bool
    err := container.Invoke(func(service *TestService) {
        invoked = true
        if service.Value != 42 {
            t.Errorf("期望值 42，实际 %d", service.Value)
        }
    })

    if err != nil {
        t.Fatalf("Invoke失败: %v", err)
    }

    if !invoked {
        t.Error("Invoke未调用函数")
    }
}