首先感谢博主能写出这么好的文章，受益匪浅 然后就是在GeeCache中我看到有类似于 var _ PeerPicker = (*HTTPPool)(nil) 和 var _ PeerGetter = (*httpGetter)(nil) 请问这种设计的意义是什么，我把这一行代码去了也并没有看到报错，有点疑惑，向博主请教

https://github.com/geektutu/7days-golang/blob/398679493db818265551707db70969a0e9e64529/gee-web/day3-router/gee/trie.go#L27

maybe:

    if child == nil || child.isWild {

day4 启动报错：

panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xc0000005 code=0x0 addr=0x8 pc=0x66dfda]

goroutine 1 [running]:
gee/gee.getNestPrefix(0x0, 0x0, 0x0, 0x8, 0x6a3440)
        E:/go_project/src/gee/gee/gee.go:88 +0x3a
gee/gee.(*RouterGroup).addRoute(0xc0000562c0, 0x711e2d, 0x3, 0x7123d1, 0x6, 0x72
ab98)
        E:/go_project/src/gee/gee/gee.go:63 +0x4b
gee/gee.(*RouterGroup).GET(...)
        E:/go_project/src/gee/gee/gee.go:69
main.main()
        E:/go_project/src/gee/main.go:45 +0x185

在 gee.go 添加以下方法后就可以了：

func (engine *Engine) addRoute(method string, pattern string, handler HandlerFunc) {
	engine.router.addRoute(method, pattern, handler)
}

// GET defines the method to add GET request
func (engine *Engine) GET(pattern string, handler HandlerFunc) {
	engine.addRoute("GET", pattern, handler)
}

// POST defines the method to add POST request
func (engine *Engine) POST(pattern string, handler HandlerFunc) {
	engine.addRoute("POST", pattern, handler)
}

但是在 day5 没有这三个方法也正常运行，请问为什么呢？ 还有非常喜欢大佬的教程，就是 day3 的 trie 树目前也不是特别懂

你好，我最近在看geeCache的实现，有些不明白地方想请教一下

// Get value for a key from cache
func (g *Group) Get(key string) (ByteView, error) {
	if key == "" {
		return ByteView{}, fmt.Errorf("key is required")
	}

	if v, ok := g.mainCache.get(key); ok {
		log.Println("[GeeCache] hit")
		return v, nil
	}

	return g.load(key)
}

比如这段函数的末尾,在cache未命中的情况下，会自己fallback去load缓存

我没有理解这里的逻辑，为什么缓存需要自己去fallbak？难道不应该直接返回未命中么？ 如果涉及成这样，那缓存岂不是永远是命中的？

gee-web day1 的 base3 run main.go 遇到找不到 package gee 的问题：

这是我的 go env:

google 了一下，好像要把当前项目的路径加到 gopath 去，但这样好像有点蠢（如果每个导入自己写的 package 都要这么做的话）？ 请问有什么优雅的解决方案吗？

额，我用的goland在跑hello-world里的main.go，报了这个错，我搜了一下需要修改GOOS和GOARCH，但是没有搜到怎么修改这两个变量，求解决。 package command-line-arguments imports syscall/js: build constraints exclude all Go files in D:\Go\src\syscall\js

func onlyForV2() gwebframe.HandlerFunc {
	return func(c *gwebframe.Context) {
		// Start timer
		t := time.Now()
		// if a server error occurred
		//c.Fail(500, "Internal Server Error")
		// Calculate resolution time
		log.Printf("[%d] %s in %v for group v2", c.StatusCode, c.Req.RequestURI, time.Since(t))
	}
}

加入了c.Fail会导致调用onlyForV2时必然报错

r.Use(gee.Logger())
func Logger() HandlerFunc {
    return func(c *Context) {
        // ...        
    }
}

r.Use(gee.Logger)
func Logger(c *Context) {
    // ...
}

我理解 go 的隐式接口实现在阅读上会有一定的障碍，显示返还接口的形式使得可读性在某些方面得到一定的缓解，但是无用的匿名函数和冗余的缩进严重的提高了程序复杂性。 您这边的教学对 golang 入门用户有深远的影响，但您知道一个中间件内，内嵌了一个三千行的匿名函数有多么的可怕么？

兔兔大佬好！ 在第一次学习兔兔大佬的gee-web课程的时候有这些疑惑，在第二次学习并查阅一些资料后对我的疑惑以及评论的一些疑惑进行了解答，希望能够帮到大家！

http.HandlerFunc和http.Handle的区别？

为什么只要传入任何实现了 ServerHTTP接口的实例，所有的HTTP请求，就都会交给了该实例处理？

go语言中原生的一个web服务器启动的流程？

为什么我们自己定义的handler会比原始的快呢？原生的serverHttp是怎么实现的？

文中提到 动手写RPC框架 - GeeRPC第一天 服务端与消息编码

一般来说，涉及协议协商的这部分信息，需要设计固定的字节来传输的。
但是为了实现上更简单，GeeRPC 客户端固定采用 JSON 编码 Option，后续的 header 和 body 的编码方式由 Option 中的 CodeType 指定，服务端首先使用 JSON 解码 Option，然后通过 Option 得 CodeType 解码剩余的内容。

什么叫固定字节来传输呢? 我理解下面的两个结构体,序列化之后的字节数目应该是不等的。

{MagicNumber:3927900 CodecType:application/gob}
{MagicNumber:3927900 CodecType:application/json}

代码验证, 第一个结构体编码后54字节,第二个结构体编码后55字节。 所以我有个疑问哈, 服务端是如何识别Option和后续消息体的边界的呢?

package main

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

type Type string

const (
	GobType  Type = "application/gob"
	JsonType Type = "application/json"
)

const MagicNumber = 0x3bef5c

type Option struct {
	MagicNumber int
	CodecType   Type
}

var DefaultOption = &Option{
	MagicNumber: MagicNumber,
	CodecType:   GobType,
}

func main() {
	var buf bytes.Buffer
	// send options
	_ = json.NewEncoder(&buf).Encode(&Option{
		MagicNumber: MagicNumber,
		CodecType:   GobType,
	})
	fmt.Println(buf.Bytes())
	fmt.Println(buf.Len())
	fmt.Println(buf.String())

	buf.Reset()
	_ = json.NewEncoder(&buf).Encode(&Option{
		MagicNumber: MagicNumber,
		CodecType:   JsonType,
	})

	fmt.Println(buf.Bytes())
	fmt.Println(buf.Len())
	fmt.Println(buf.String())
}

// Output
//[123 34 77 97 103 105 99 78 117 109 98 101 114 34 58 51 57 50 55 57 48 48 44 34 67 111 100 101 99 84 121 112 101 34 58 34 97 112 112 108 105 99 97 116 105 111 110 47 103 111 98 34 125 10]
//54
//{"MagicNumber":3927900,"CodecType":"application/gob"}
//
//[123 34 77 97 103 105 99 78 117 109 98 101 114 34 58 51 57 50 55 57 48 48 44 34 67 111 100 101 99 84 121 112 101 34 58 34 97 112 112 108 105 99 97 116 105 111 110 47 106 115 111 110 34 125 10]
//55
//{"MagicNumber":3927900,"CodecType":"application/json"}

Beep boop. Your images are optimized!

Your image file size has been reduced by 13% 🎉

Black Lives Matter | 💰 donate | 🎓 learn | ✍🏾 sign

📝 docs | :octocat: repo | 🙋🏾 issues | 🏅 swag | 🏪 marketplace

func TestGetRoute(t *testing.T) {
	r := newRouter()
	r.addRoute("GET", "/", nil)
	r.addRoute("GET", "/hello/:id", nil)
	r.addRoute("GET", "/hello/b/c", nil)
	n, ps := r.getRoute("GET", "/hello/21/c")
	fmt.Printf("n: %v\n", n)  // n: node{pattern=/hello/b/c, part=c, isWild=false}
	fmt.Printf("ps: %v\n", ps)//ps: map[]
}

我们期望得到 n == nil, ps == nil , 但实际上却匹配到了静态路由 pattern=/hello/b/c.

由于注册顺序导致的 路由树可以简化为： [0] root: path: / [1] path: hello [2] path: :id pattern : "/hello/:id" [3] path: c pattern : "hello/b/c"

主要原因为 先注册的 路由为 /hello/:id ， 后注册的路由为 /hello/b/c ， 在查找时，没有返回 nil, 源代码如下：

func (n *node) matchChild(part string) *node {
	for _, child := range n.children {
        if child.part == part || child.isWild {  // false,  true
            // 在查找 part为 :id 这一层时， 直接返回了child 
			return child
		}
	}
	return nil
}
func (n *node) insert(pattern string, parts []string, height int) {
	if len(parts) == height {
		n.pattern = pattern
		return
	}

    part := parts[height]
    child := n.matchChild(part) // 由于返回的不是 nil , 而是  node.part == ":id" 这个节点。
	if child == nil {
		child = &node{part: part, isWild: part[0] == ':' || part[0] == '*'}
		n.children = append(n.children, child)
	}
    
	child.insert(pattern, parts, height+1)
}

要想达到预期 结果 n == nil, ps == nil ， 就只能修改注册顺序。

先注册静态路由， 确保 matchChildren(part string) []*node  方法返回的切片 包含 child.part="b" 的这个节点。
r.addRoute("GET", "/hello/b/c", nil)
r.addRoute("GET", "/hello/:id", nil)

尊敬的作者，您好： 在学习您的geecache day4 一致性哈希章节中针对该算法有个疑问，“环上有 peer2，peer4，peer6 三个节点，key11，key2，key27 均映射到 peer2，key23 映射到 peer4。” 这个部分不太理解，当前环上有三个节点的话，key11映射的节点为 11%3=2顺时针映射peer2，key2映射的节点应该 2%3=2顺时针映射peer2，key27映射的节点为27%3=0顺时针映射peer2，key23映射的节点不也应该为23%3=2 peer2 吗？ 这个地方一直没搞明白，望您有空点拨下。万分感谢。

想问下http的rpc和tcp的rpc有啥区别。 看完http rpc，感觉流程是通过向server（给server发一个connect的http请求），得到client（包含了tcp conn），然后就是发rpc数据。 服务端：实现serveHTTP方法，然后就是handleHTTP，进入serveHTTP，先检查http请求是不是connect，然后就到了原来的serveConn， 就感觉这http和tcp的rpc没有啥区别，希望大佬可以解答一下。