共计 5292 个字符，预计需要花费 14 分钟才能阅读完成。
序
本文次要钻研一下 golang 的 zap 的 WriteSyncer
WriteSyncer
zap@v1.16.0/zapcore/write_syncer.go
type WriteSyncer interface {
io.Writer
Sync() error}WriteSyncer 内嵌了 io.Writer 接口，定义了 Sync 办法
Writer
/usr/local/go/src/io/io.go
type Writer interface {Write(p []byte) (n int, err error)
}Writer 接口定义了 Write 办法
lockedWriteSyncer
zap@v1.16.0/zapcore/write_syncer.go
type lockedWriteSyncer struct {
sync.Mutex
ws WriteSyncer
}
func Lock(ws WriteSyncer) WriteSyncer {if _, ok := ws.(*lockedWriteSyncer); ok {
// no need to layer on another lock
return ws
}
return &lockedWriteSyncer{ws: ws}
}
func (s *lockedWriteSyncer) Write(bs []byte) (int, error) {s.Lock()
n, err := s.ws.Write(bs)
s.Unlock()
return n, err
}
func (s *lockedWriteSyncer) Sync() error {s.Lock()
err := s.ws.Sync()
s.Unlock()
return err
}lockedWriteSyncer 定义了 sync.Mutex 及 WriteSyncer 属性，它实现了 WriteSyncer 接口，它对 Write 和 Sync 办法都加了锁，外部委托的 WriteSyncer；Lock 办法用于创立 lockedWriteSyncer
multiWriteSyncer
zap@v1.16.0/zapcore/write_syncer.go
type multiWriteSyncer []WriteSyncer
func NewMultiWriteSyncer(ws ...WriteSyncer) WriteSyncer {if len(ws) == 1 {return ws[0]
}
// Copy to protect against https://github.com/golang/go/issues/7809
return multiWriteSyncer(append([]WriteSyncer(nil), ws...))
}
func (ws multiWriteSyncer) Write(p []byte) (int, error) {
var writeErr error
nWritten := 0
for _, w := range ws {n, err := w.Write(p)
writeErr = multierr.Append(writeErr, err)
if nWritten == 0 && n != 0 {nWritten = n} else if n < nWritten {nWritten = n}
}
return nWritten, writeErr
}
func (ws multiWriteSyncer) Sync() error {
var err error
for _, w := range ws {err = multierr.Append(err, w.Sync())
}
return err
}multiWriteSyncer 为
[]WriteSyncer类型，它实现了 WriteSyncer 接口，其 Write 办法会遍历 multiWriteSyncer 挨个执行其 w.Write，而后会用 multierr.Append(writeErr, err)来包装 err；其 Sync 办法会遍历 multiWriteSyncer，挨个执行 w.Sync()，而后会用 multierr.Append(writeErr, err)来包装 err；NewMultiWriteSyncer 办法用于创立 multiWriteSyncer
CombineWriteSyncers
zap@v1.16.0/writer.go
func CombineWriteSyncers(writers ...zapcore.WriteSyncer) zapcore.WriteSyncer {if len(writers) == 0 {return zapcore.AddSync(ioutil.Discard)
}
return zapcore.Lock(zapcore.NewMultiWriteSyncer(writers...))
}
func Open(paths ...string) (zapcore.WriteSyncer, func(), error) {writers, close, err := open(paths)
if err != nil {return nil, nil, err}
writer := CombineWriteSyncers(writers...)
return writer, close, nil
}
func open(paths []string) ([]zapcore.WriteSyncer, func(), error) {writers := make([]zapcore.WriteSyncer, 0, len(paths))
closers := make([]io.Closer, 0, len(paths))
close := func() {
for _, c := range closers {c.Close()
}
}
var openErr error
for _, path := range paths {sink, err := newSink(path)
if err != nil {openErr = multierr.Append(openErr, fmt.Errorf("couldn't open sink %q: %v", path, err))
continue
}
writers = append(writers, sink)
closers = append(closers, sink)
}
if openErr != nil {close()
return writers, nil, openErr
}
return writers, close, nil
}CombineWriteSyncers 办法会先应用 zapcore.NewMultiWriteSyncer(writers…)创立 multiWriteSyncer，在通过 Lock 创立 lockedWriteSyncer；Open 办法依据 paths 创立 zapcore.WriteSyncer，最初通过 CombineWriteSyncers 来创立带锁的 multiWriteSyncer
Sink
zap@v1.16.0/sink.go
type Sink interface {
zapcore.WriteSyncer
io.Closer
}Sink 接口内嵌了 zapcore.WriteSyncer 及 io.Closer 接口
Closer
/usr/local/go/src/io/io.go
type Closer interface {Close() error
}Closer 接口定义了 Close 办法
nopCloserSink
type nopCloserSink struct{zapcore.WriteSyncer}
func (nopCloserSink) Close() error { return nil}nopCloserSink 内嵌了 zapcore.WriteSyncer，其 Close 办法为空操作
newSink
zap@v1.16.0/sink.go
var (
_sinkMutex sync.RWMutex
_sinkFactories map[string]func(*url.URL) (Sink, error) // keyed by scheme
)
func init() {resetSinkRegistry()
}
func resetSinkRegistry() {_sinkMutex.Lock()
defer _sinkMutex.Unlock()
_sinkFactories = map[string]func(*url.URL) (Sink, error){schemeFile: newFileSink,}
}
func newSink(rawURL string) (Sink, error) {u, err := url.Parse(rawURL)
if err != nil {return nil, fmt.Errorf("can't parse %q as a URL: %v", rawURL, err)
}
if u.Scheme == "" {u.Scheme = schemeFile}
_sinkMutex.RLock()
factory, ok := _sinkFactories[u.Scheme]
_sinkMutex.RUnlock()
if !ok {return nil, &errSinkNotFound{u.Scheme}
}
return factory(u)
}newSink 办法解析 url，而后通过 scheme 找到对应的 factory，调用 factory 创立 Sink；_sinkFactories 默认注册了 newFileSink
newFileSink
zap@v1.16.0/sink.go
func newFileSink(u *url.URL) (Sink, error) {
if u.User != nil {return nil, fmt.Errorf("user and password not allowed with file URLs: got %v", u)
}
if u.Fragment != "" {return nil, fmt.Errorf("fragments not allowed with file URLs: got %v", u)
}
if u.RawQuery != "" {return nil, fmt.Errorf("query parameters not allowed with file URLs: got %v", u)
}
// Error messages are better if we check hostname and port separately.
if u.Port() != "" {return nil, fmt.Errorf("ports not allowed with file URLs: got %v", u)
}
if hn := u.Hostname(); hn != ""&& hn !="localhost" {return nil, fmt.Errorf("file URLs must leave host empty or use localhost: got %v", u)
}
switch u.Path {
case "stdout":
return nopCloserSink{os.Stdout}, nil
case "stderr":
return nopCloserSink{os.Stderr}, nil
}
return os.OpenFile(u.Path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
}newFileSink 针对 stdout 创立
nopCloserSink{os.Stdout}，针对 stderr 创立nopCloserSink{os.Stderr}，非以上两者则返回 os.OpenFile(u.Path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)；*os.File领有 Write、Sync、Close 办法，实现了 Sink 接口
实例
func sinkDemo() {sink, cleanup, err := zap.Open("stdout", "/tmp/out1", "/tmp/out2")
if err == nil {defer cleanup()
}
sink.Write([]byte("hello"))
sink.Write([]byte("world"))
}输入
helloworld同时 /tmp/out1，/tmp/out2 也都有输入
小结
- WriteSyncer 内嵌了 io.Writer 接口，定义了 Sync 办法；它有 lockedWriteSyncer、multiWriteSyncer 两个实现，同时 CombineWriteSyncers 创立是带 lock 的 multiWriteSyncer
- Sink 接口内嵌了 zapcore.WriteSyncer 及 io.Closer 接口；
*os.File领有 Write、Sync、Close 办法，实现了 Sink 接口；nopCloserSink 内嵌了 zapcore.WriteSyncer，其 Close 办法为空操作；FileSink 则是基于文件的 sink - zap.Open 先通过 newSink 创立 fileSink 的 zapcore.WriteSyncer，再通过 CombineWriteSyncers 将这些 fileSink 包装为带锁的 multiWriteSyncer
doc
- zap