Golang中如何为自定义类型实现Reader和Writer接口

专业解答

对于自定义类型实现io.Reader和io.Writer接口，以下是具体实现方案：

1. 读取器实现

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "sync"
)

// APIClient 自定义类型实现Reader接口
type APIClient struct {
    url    string
    data   []byte
    offset int
    mu     sync.Mutex
}

// NewAPIClient 创建新的API客户端
func NewAPIClient(url string) *APIClient {
    return &APIClient{url: url}
}

// Read 实现io.Reader接口
func (ac *APIClient) Read(p []byte) (n int, err error) {
    ac.mu.Lock()
    defer ac.mu.Unlock()

    // 首次读取时获取数据
    if ac.data == nil {
        resp, err := http.Get(ac.url)
        if err != nil {
            return 0, err
        }
        defer resp.Body.Close()

        ac.data, err = io.ReadAll(resp.Body)
        if err != nil {
            return 0, err
        }
    }

    // 检查是否已读取完所有数据
    if ac.offset >= len(ac.data) {
        return 0, io.EOF
    }

    // 计算可读取的字节数
    n = copy(p, ac.data[ac.offset:])
    ac.offset += n
    return n, nil
}

// 使用示例
func main() {
    client := NewAPIClient("https://api.example.com/data")
    
    // 读取数据到缓冲区
    buf := make([]byte, 1024) // 缓冲区大小根据实际需求调整
    for {
        n, err := client.Read(buf)
        if err == io.EOF {
            break
        }
        if err != nil {
            panic(err)
        }
        fmt.Printf("读取了 %d 字节\n", n)
    }
}

关于缓冲区大小：通常使用4KB（4096字节）作为标准缓冲区大小，但可以根据API响应大小调整。对于大响应，可以使用更大的缓冲区（如32KB）。

2. 写入器实现

package main

import (
    "encoding/json"
    "fmt"
    "io"
)

// User 用户定义类型
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// UserWriter 自定义类型实现Writer接口
type UserWriter struct {
    user *User
}

// NewUserWriter 创建新的UserWriter
func NewUserWriter() *UserWriter {
    return &UserWriter{user: &User{}}
}

// Write 实现io.Writer接口
func (uw *UserWriter) Write(p []byte) (n int, err error) {
    // 解组JSON数据到User结构体
    err = json.Unmarshal(p, uw.user)
    if err != nil {
        return 0, err
    }
    
    // 返回写入的字节数（即输入数据的长度）
    return len(p), nil
}

// GetUser 获取解析后的用户数据
func (uw *UserWriter) GetUser() *User {
    return uw.user
}

// 使用示例
func main() {
    writer := NewUserWriter()
    
    // JSON数据
    jsonData := []byte(`{"id": 1, "name": "张三", "age": 30}`)
    
    // 写入数据
    n, err := writer.Write(jsonData)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("成功写入 %d 字节\n", n)
    fmt.Printf("解析的用户: %+v\n", writer.GetUser())
}

3. 同时实现ReadWriter接口

package main

import (
    "encoding/json"
    "io"
    "net/http"
    "sync"
)

// APIReadWriter 同时实现Reader和Writer接口
type APIReadWriter struct {
    url      string
    data     []byte
    offset   int
    user     *User
    mu       sync.Mutex
    readDone bool
}

// NewAPIReadWriter 创建新的API读写器
func NewAPIReadWriter(url string) *APIReadWriter {
    return &APIReadWriter{
        url:  url,
        user: &User{},
    }
}

// Read 实现io.Reader接口
func (arw *APIReadWriter) Read(p []byte) (n int, err error) {
    arw.mu.Lock()
    defer arw.mu.Unlock()

    if !arw.readDone {
        resp, err := http.Get(arw.url)
        if err != nil {
            return 0, err
        }
        defer resp.Body.Close()

        arw.data, err = io.ReadAll(resp.Body)
        if err != nil {
            return 0, err
        }
        arw.readDone = true
    }

    if arw.offset >= len(arw.data) {
        return 0, io.EOF
    }

    n = copy(p, arw.data[arw.offset:])
    arw.offset += n
    return n, nil
}

// Write 实现io.Writer接口
func (arw *APIReadWriter) Write(p []byte) (n int, err error) {
    arw.mu.Lock()
    defer arw.mu.Unlock()

    err = json.Unmarshal(p, arw.user)
    if err != nil {
        return 0, err
    }
    
    return len(p), nil
}

// GetUser 获取解析的用户数据
func (arw *APIReadWriter) GetUser() *User {
    arw.mu.Lock()
    defer arw.mu.Unlock()
    return arw.user
}

// 使用示例
func main() {
    rw := NewAPIReadWriter("https://api.example.com/user")
    
    // 作为Reader使用
    buf := make([]byte, 4096)
    var jsonData []byte
    for {
        n, err := rw.Read(buf)
        if err == io.EOF {
            jsonData = append(jsonData, buf[:n]...)
            break
        }
        if err != nil {
            panic(err)
        }
        jsonData = append(jsonData, buf[:n]...)
    }
    
    // 作为Writer使用
    n, err := rw.Write(jsonData)
    if err != nil {
        panic(err)
    }
    fmt.Printf("解析了 %d 字节的JSON数据\n", n)
}

关键点说明：

1. 读取器缓冲区大小：通常使用4KB缓冲区，可通过make([]byte, 4096)创建
2. 写入器字节计数：json.Unmarshal不返回解组字节数，因此返回输入数据的长度
3. 线程安全：使用sync.Mutex确保并发安全
4. EOF处理：读取器在数据读取完毕后返回io.EOF

这种实现方式允许你的自定义类型与标准库中的其他组件（如io.Copy、bufio.Scanner等）无缝集成。