Golang如何嵌入一个带有额外隐藏方法的接口？

huangapple
go评论120阅读模式
英文:

Golang embed an interface with additional hidden methods?

问题

我想在一个结构体中嵌入一个http.ResponseWriter。这样做是可以的，它确保我的结构体也实现了http.ResponseWriter接口：

  1. type MyWriter struct {
  2.     BytesWritten int
  3.     http.ResponseWriter
  4. }

然而，尽管通常嵌入的http.ResponseWriter实现了http.Hijacker、http.CloseNotifier和http.Flusher接口，但它不再实现这些接口。

有没有办法解决这个问题呢？

英文:

I want to embed a http.ResponseWriter in a struct. That's fine, it makes sure my struct also implements http.ResponseWriter:

  1. type MyWriter struct {
  2.     BytesWritten int
  3.     http.ResponseWriter
  4. }

However, it no longer implements http.Hijacker, http.CloseNotifier or http.Flusher even though the embedded http.ResponseWriter usually does.

Is there some way to do this?

答案1

得分: 2

如果你知道响应写入器满足问题中列出的所有接口，那么你可以这样做：

  1. type allResponseWriterInterfaces struct {
  2.     http.ResponseWriter
  3.     http.Hijacker
  4.     http.CloseNotifier
  5.     http.Flusher
  6. }
  8. type MyWriter struct {
  9.     BytesWritten int
  10.     allResponseWriterInterfaces
  11. }
  13. ...
  15. aw, ok := w.(allResponseWriterInterfaces)
  16. if !ok {
  17.     // 哎呀，响应写入器没有实现这些接口
  18.     // 处理错误
  19. }
  20. mw := MyWriter{0, aw}

如果响应写入器不满足所有接口，情况就会变得混乱。参考Gorilla logger中处理响应写入器满足(http.ResponseWriter, http.CloseNotifier)或者(http.ResponseWriter, http.CloseNotifier, http.Hijacker)的示例。

英文:

If you know that the response writer satisfies all of the interfaces listed in the question, then you can do this:

  1. type allResponseWriterInterfaces {
  2.     http.ResponseWriter
  3.     http.Hijacker
  4.     http.CloseNotifier
  5.     http.Flusher
  6. }
  8. type MyWriter struct {
  9.     BytesWritten int
  10.     allResponseWriterInterfaces
  11. }
  13. ...
  15. aw, ok := w.(allResponseWriterInterfaces)
  16. if !ok {
  17.     // oops, response writer does not implement the interfaces
  18.     // handle the error
  19. }
  20. mw := MyWriter{0, aw}

It get's messy if the response writer does not satisfy all of the interfaces. See the Gorilla logger for an example of handling the case where the response writer satisfies (http.ResponseWriter, http.CloseNotifier) or (http.ResponseWriter, http.CloseNotifier, http.Hijacker).

答案2

得分: 0

一种解决方案是暴力解法，实际上实现所有的排列。我尝试过这种方法，发现它非常痛苦。总共有18种排列！

所以这里有一个通用的包装器。优点是你可以多次重复使用这个包装器。

关键是定义一个接口，如下所示：

// ResponseWriterTo可以将请求代理到底层的http.ResponseWriter。
// 它与CustomResponseWriter一起使用，用于包装具有自定义行为的http.ResponseWriter。
type ResponseWriterTo interface {
HeaderTo(w http.ResponseWriter) http.Header
WriteHeaderTo(w http.ResponseWriter, s int)
WriteTo(w http.ResponseWriter, b []byte) (n int, err error)

  1. // http.ResponseWriter有时会实现其他方法。
  2. CloseNotifyTo(w http.CloseNotifier) <-chan bool
  3. FlushTo(w http.Flusher)
  4. HijackTo(w http.Hijacker) (net.Conn, *bufio.ReadWriter, error)
  6. // ReaderFrom用于优化从TCP连接或文件中读取的http包。
  7. ReadFromTo(w io.ReaderFrom, r io.Reader) (n int64, err error)

}

这样我们就可以定义一个自定义的包装器函数（这是冗长的部分）：

// CustomResponseWriter创建一个http.ResponseWriter，它实现了尽可能多的基本http.ResponseWriter的隐藏接口。
func CustomResponseWriter(base http.ResponseWriter, custom ResponseWriterTo) http.ResponseWriter {
rw := &customResponseWriter{base: base, custom: custom}

  1. // 基本的http.ResponseWriter可以实现许多隐藏接口，所以检查所有的排列
  3. type HCFR interface {
  4.     http.ResponseWriter
  5.     http.Hijacker
  6.     http.CloseNotifier
  7.     http.Flusher
  8.     io.ReaderFrom
  9. }
  10. if _, ok := base.(HCFR); ok {
  11.     return struct {
  12.         HCFR
  13.     }{rw}
  14. }
  16. type HCF interface {
  17.     http.ResponseWriter
  18.     http.Hijacker
  19.     http.CloseNotifier
  20.     http.Flusher
  21. }
  22. if _, ok := base.(HCF); ok {
  23.     return struct {
  24.         HCF
  25.     }{rw}
  26. }
  28. // 其他排列...
  30. return struct {
  31.     http.ResponseWriter
  32. }{rw}

}

// customResponseWriter允许我们将ResponseWriterTo适配到ResponseWriter。
type customResponseWriter struct {
base http.ResponseWriter
custom ResponseWriterTo
}

func (w *customResponseWriter) Header() http.Header { return w.custom.HeaderTo(w.base) }
func (w *customResponseWriter) Write(b []byte) (int, error) { return w.custom.WriteTo(w.base, b) }
func (w *customResponseWriter) WriteHeader(s int) { w.custom.WriteHeaderTo(w.base, s) }
func (w *customResponseWriter) CloseNotify() <-chan bool {
return w.custom.CloseNotifyTo(w.base.(http.CloseNotifier))
}
func (w *customResponseWriter) Flush() { w.custom.FlushTo(w.base.(http.Flusher)) }
func (w *customResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
return w.custom.HijackTo(w.base.(http.Hijacker))
}
func (w *customResponseWriter) ReadFrom(r io.Reader) (n int64, err error) {
return w.custom.ReadFromTo(w.base.(io.ReaderFrom), r)
}

这个想法是将正确的接口嵌入到一个结构体中。然后只有"正确"的方法被暴露出来。

英文:

One solution is the brute-force solution. Actually implement all permutations. I tried this and found out how painful it is. There are 18 permutations!

So here is a general-purpose wrapper. The advantage is that you can re-use this wrapper as many times as you want.

The key is to define an interface like so:

  1. // ResponseWriterTo can proxy requests to an underlying http.ResponseWriter.
  2. // It is used with CustomResponseWriter to wrap an http.ResponseWriter with
  3. // custom behavior.
  4. type ResponseWriterTo interface {
  5.     HeaderTo(w http.ResponseWriter) http.Header
  6.     WriteHeaderTo(w http.ResponseWriter, s int)
  7.     WriteTo(w http.ResponseWriter, b []byte) (n int, err error)
  9.     // Additional methods that http.ResponseWriter sometimes implements.
  10.     CloseNotifyTo(w http.CloseNotifier) &lt;-chan bool
  11.     FlushTo(w http.Flusher)
  12.     HijackTo(w http.Hijacker) (net.Conn, *bufio.ReadWriter, error)
  14.     // ReaderFrom is used by the http package to optimize reads from TCP
  15.     // connections or from files.
  16.     ReadFromTo(w io.ReaderFrom, r io.Reader) (n int64, err error)
  17. }

so that we can define a custom wrapper function (this is the verbose part):

  1. // CustomResponseWriter creates a http.ResponseWriter that implements as many
  2. // hidden interfaces from the base http.ResponseWriter as are available.
  3. func CustomResponseWriter(base http.ResponseWriter, custom ResponseWriterTo) http.ResponseWriter {
  4.     rw := &amp;customResponseWriter{base: base, custom: custom}
  6.     // the base http.ResponseWriter can implement many hidden interfaces,
  7.     // so check all permutations
  9.     type HCFR interface {
  10.         http.ResponseWriter
  11.         http.Hijacker
  12.         http.CloseNotifier
  13.         http.Flusher
  14.         io.ReaderFrom
  15.     }
  16.     if _, ok := base.(HCFR); ok {
  17.         return struct {
  18.             HCFR
  19.         }{rw}
  20.     }
  22.     type HCF interface {
  23.         http.ResponseWriter
  24.         http.Hijacker
  25.         http.CloseNotifier
  26.         http.Flusher
  27.     }
  28.     if _, ok := base.(HCF); ok {
  29.         return struct {
  30.             HCF
  31.         }{rw}
  32.     }
  34.     type HCR interface {
  35.         http.ResponseWriter
  36.         http.Hijacker
  37.         http.CloseNotifier
  38.         io.ReaderFrom
  39.     }
  40.     if _, ok := base.(HCR); ok {
  41.         return struct {
  42.             HCR
  43.         }{rw}
  44.     }
  46.     type HFR interface {
  47.         http.ResponseWriter
  48.         http.Hijacker
  49.         http.Flusher
  50.         io.ReaderFrom
  51.     }
  52.     if _, ok := base.(HFR); ok {
  53.         return struct {
  54.             HFR
  55.         }{rw}
  56.     }
  58.     type CFR interface {
  59.         http.ResponseWriter
  60.         http.CloseNotifier
  61.         http.Flusher
  62.         io.ReaderFrom
  63.     }
  64.     if _, ok := base.(CFR); ok {
  65.         return struct {
  66.             CFR
  67.         }{rw}
  68.     }
  70.     type HC interface {
  71.         http.ResponseWriter
  72.         http.Hijacker
  73.         http.CloseNotifier
  74.     }
  75.     if _, ok := base.(HC); ok {
  76.         return struct {
  77.             HC
  78.         }{rw}
  79.     }
  81.     type HF interface {
  82.         http.ResponseWriter
  83.         http.Hijacker
  84.         http.Flusher
  85.     }
  86.     if _, ok := base.(HF); ok {
  87.         return struct {
  88.             HF
  89.         }{rw}
  90.     }
  92.     type CF interface {
  93.         http.ResponseWriter
  94.         http.CloseNotifier
  95.         http.Flusher
  96.     }
  97.     if _, ok := base.(CF); ok {
  98.         return struct {
  99.             CF
  100.         }{rw}
  101.     }
  103.     type HR interface {
  104.         http.ResponseWriter
  105.         http.Hijacker
  106.         io.ReaderFrom
  107.     }
  108.     if _, ok := base.(HR); ok {
  109.         return struct {
  110.             HR
  111.         }{rw}
  112.     }
  114.     type CR interface {
  115.         http.ResponseWriter
  116.         http.CloseNotifier
  117.         io.ReaderFrom
  118.     }
  119.     if _, ok := base.(CR); ok {
  120.         return struct {
  121.             CR
  122.         }{rw}
  123.     }
  125.     type FR interface {
  126.         http.ResponseWriter
  127.         http.Flusher
  128.         io.ReaderFrom
  129.     }
  130.     if _, ok := base.(FR); ok {
  131.         return struct {
  132.             FR
  133.         }{rw}
  134.     }
  136.     type H interface {
  137.         http.ResponseWriter
  138.         http.Hijacker
  139.     }
  140.     if _, ok := base.(H); ok {
  141.         return struct {
  142.             H
  143.         }{rw}
  144.     }
  146.     type C interface {
  147.         http.ResponseWriter
  148.         http.CloseNotifier
  149.     }
  150.     if _, ok := base.(C); ok {
  151.         return struct {
  152.             C
  153.         }{rw}
  154.     }
  156.     type F interface {
  157.         http.ResponseWriter
  158.         http.Flusher
  159.     }
  160.     if _, ok := base.(F); ok {
  161.         return struct {
  162.             F
  163.         }{rw}
  164.     }
  166.     type R interface {
  167.         http.ResponseWriter
  168.         io.ReaderFrom
  169.     }
  170.     if _, ok := base.(R); ok {
  171.         return struct {
  172.             R
  173.         }{rw}
  174.     }
  176.     return struct {
  177.         http.ResponseWriter
  178.     }{rw}
  179. }
  181. // customResponseWriter allows us to adapt a ResponseWriterTo to a ResponseWriter.
  182. type customResponseWriter struct {
  183.     base   http.ResponseWriter
  184.     custom ResponseWriterTo
  185. }
  187. func (w *customResponseWriter) Header() http.Header         { return w.custom.HeaderTo(w.base) }
  188. func (w *customResponseWriter) Write(b []byte) (int, error) { return w.custom.WriteTo(w.base, b) }
  189. func (w *customResponseWriter) WriteHeader(s int)           { w.custom.WriteHeaderTo(w.base, s) }
  190. func (w *customResponseWriter) CloseNotify() &lt;-chan bool {
  191.     return w.custom.CloseNotifyTo(w.base.(http.CloseNotifier))
  192. }
  193. func (w *customResponseWriter) Flush() { w.custom.FlushTo(w.base.(http.Flusher)) }
  194. func (w *customResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
  195.     return w.custom.HijackTo(w.base.(http.Hijacker))
  196. }
  197. func (w *customResponseWriter) ReadFrom(r io.Reader) (n int64, err error) {
  198.     return w.custom.ReadFromTo(w.base.(io.ReaderFrom), r)
  199. }

The idea is to embed the correct interface into a struct. Then only the "right" methods are exposed.

huangapple
  • 本文由 发表于 2015年12月22日 13:08:57
  • 转载请务必保留本文链接：https://go.coder-hub.com/34408808.html
  • go
  • http
  • interface
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定