在一个地方处理重复的错误情况

Question

我正在编写一个将多个字段的结构写入 TCP 连接的函数。有没有办法在一个地方处理错误，比如在 Java?

中捕获异常

我的实现看起来像，

func writeFrame(frame *Frame, conn net.Conn) error {
    bo := binary.BigEndian
    if err := binary.Write(conn, bo, frame.ype); err != nil {
        return err
    }
    if err := binary.Write(conn, bo, frame.id); err != nil {
        return err
    }
    if err := binary.Write(conn, bo, frame.seq); err != nil {
        return err
    }

    if err := binary.Write(conn, bo, uint32(len(frame.arg1))); err != nil {
        return err
    }
    if err := binary.Write(conn, bo, uint32(len(frame.arg2))); err != nil {
        return err
    }
    if err := binary.Write(conn, bo, uint32(len(frame.arg3))); err != nil {
        return err
    }

    var csum uint32
    if err := binary.Write(conn, bo, csum); err != nil {
        return err
    }

    if _, err := conn.Write(frame.arg1); err != nil {
        return err
    }
    if _, err := conn.Write(frame.arg2); err != nil {
        return err
    }
    if _, err := conn.Write(frame.arg3); err != nil {
        return err
    }
    return nil
}

Answer 1

您可以创建一个简单的类型来存储一堆写入并同时执行它们，一旦遇到错误就退出。

type MyWriter struct {
    W     io.Writer
    O     binary.ByteOrder
    items []interface{}
}

func (w *MyWriter) AddWrite(value interface{}) {
    w.items = append(w.items, value)
}

// PerformWrite executes all writes that have been added via AddWrite.
// It aborts as soon as an error is encountered and returns the error.
func (w *MyWriter) PerformWrites() error {
    for _, item := range w.items {
        if err := binary.Write(w.W, w.O, item); err != nil {
            return err
        }
    }
    return nil
}

有了这个，您的 writeFrame 函数可能看起来像这样：

func Write(conn net.Conn) error {
    w := MyWriter{W: conn, O: binary.BigEndian}
    // queue up your writes (frame.type, frame.id, ...)
    w.AddWrite(int32(1))
    w.AddWrite(int32(2))
    w.AddWrite(int64(3))

    if err := w.PerformWrites(); err != nil {
        // there was an error
        return err
    }
    return nil
}

Answer 2

您可以为此使用 bufio.Writer。如果以后发生任何错误，Write 将简单地 return 相同的错误并被忽略。

func writeFrame(frame *Frame, conn net.Conn) error {
    bo := binary.BigEndian

    w := bufio.NewWriter(conn)

    binary.Write(w, bo, frame.ype)
    binary.Write(w, bo, frame.id)
    binary.Write(w, bo, frame.seq)

    binary.Write(w, bo, uint32(len(frame.arg1)))
    binary.Write(w, bo, uint32(len(frame.arg2)))
    binary.Write(w, bo, uint32(len(frame.arg3)))

    var csum uint32
    binary.Write(w, bo, csum)

    w.Write(frame.arg1)
    w.Write(frame.arg2)
    w.Write(frame.arg3)

    // Write outstanding data to conn and return an error if any occured
    return w.Flush()
}

在一个地方处理重复的错误情况

Handle repetitive error cases in one place

error-handling

go