极客兔兔Gee-Cache Day5

• HTTPPool 既可以是服务端，也可以是客户端，这取决于特定的使用场景和上下文：

  • 作为客户端：当本地缓存没有找到需要的数据时，HTTPPool 需要作为客户端，通过 httpGetter （实现了 PeerGetter 接口）去其他的远程节点（服务端）请求数据。
  • 作为服务端：当其他节点的 HTTPPool 实例（作为客户端）请求当前节点存储的数据时，当前节点的 HTTPPool 实例则作为服务端响应这些请求。

• HTTPPool实现了PeerPicker接口，httpGetter实现了PeerGetter接口，前者用来找到对应的远程节点（由于每个远程节点对应一个httpGetter，因此实际找到的是httpGetter），后者用来向远处节点请求数据

• Peer.go

  • package gee
    
    type PeerPicker interface {
    	PickPeer(key string) (peer PeerGetter, ok bool)
    }
    
    type PeerGetter interface {
    	Get(group string, key string) ([]byte, error)
    }
    

  • PickerPeer用来找到key对应的远程节点，远程节点和PeerGetter一一对应，找到PeerGetter就找到对应的远程节点

  • PeerGetter根据group和key向远程节点获取数据

• url.QueryEscape()：net/url包，用于将url中的特殊字符用asll码进行替换，防止丢失

• var _ PeerGetter = (*httpGetter)(nil) ：检验接口实现是否正确

• day5需要实现http的客户端，对于缓存未命中时，需要向远程节点请求数据，此时被作为客户端，http.go中已经在day2实现了服务端的代码，需要再加上客户端

  • HTTPPool实现了上面的PeerPicker接口，实现了其需要实现的PickPeer()函数，该函数返回远程节点对应的PeerGetter，找到PeerGetter就能去访问远程节点的数据

    • // 查找PeerGetter
      func (p *HTTPPool) PickPeer(key string) (PeerGetter, bool) {
      	p.mu.Lock()
      	defer p.mu.Unlock()
      	if peer := p.peers.Get(key); peer != "" && peer != p.self {
      		return p.httpGetters[peer], true
      	}
      	return nil, false
      }
      var _ PeerPicker = (*HTTPPool)(nil) // 检验接口实现是否正确
      

  • ``httpGetter实现了PeerGetter接口，实现了其需要实现的Get()函数，Get()函数主要是吊桶net/http中的Get()方法，向远程节点请求数据，并使用ioutil的ReadAll`获取

    • func (h *httpGetter) Get(group string, key string) ([]byte, error) {
      	u := fmt.Sprintf(
      		"%s%s%s",
      		h.baseURL,
      		url.QueryEscape(group),
      		url.QueryEscape(key),
      	)
      
      	res, err := http.Get(u)
      	if err != nil {
      		return nil, err
      	}
      	defer res.Body.Close()
      
      	if res.StatusCode != http.StatusOK {
      		return nil, fmt.Errorf("error response body: %v", err)
      	}
      
      	bytes, err := ioutil.ReadAll(res.Body)
      	if err != nil {
      		return nil, fmt.Errorf("error response body: %v", err)
      	}
      	return bytes, nil
      }
      var _ PeerGetter = (*httpGetter)(nil) // 检验接口实现是否正确
      

  • HTTPPool管理客户端的所有过程，因此需要加入httpGetter属性，其是一个map[string]*httpGetter类型，通过key映射httpGetter，同时加入day4中实现的一致性哈希过程，由于这些需要实现互斥访问哈希表，因此还需要一个mutex

    • type HTTPPool struct {
      	self     string
      	basePath string
      
      	mu          sync.Mutex
      	peers       *consistenthash.Map    // 缓存值
      	httpGetters map[string]*httpGetter // 每个httpGetter对应一个远程节点，在缓存未命中时向远程节点请求数据
      }
      

  • 最后，将HTTPPool集成在主流程中，即group中，group需要实现RegisterPeer()函数，将对应的HTTPPool注入，同时封装getFromPeer()方法，其中调用了之前的Get()方法，用来请求远程节点的数据，重写一下load()方法，在不存在HTTPPool时才调用getLocally()，否则调用getFromPeer

    • type Group struct {
      	name      string // 缓存名称
      	getter    Getter // 回调函数
      	mainCache cache  // 缓存
      
      	peers PeerPicker // 集成HTTPPool
      }
      // 将HTTPPool注入到group中
      func (g *Group) RegisterPeers(peer PeerPicker) {
      	if g.peers != nil {
      		panic("最多一个peerPicker")
      	}
      	g.peers = peer
      }
      
      // 缓存未命中 向远程节点请求
      func (g *Group) load(key string) (Value ByteView, err error) {
      	if g.peers != nil {
      		if peer, ok := g.peers.PickPeer(key); ok {
      			if value, err := g.getFromPeer(peer, key); err == nil {
      				return value, nil
      			}
      			log.Println("获取Peer失败")
      		}
      	}
      	// 不存在远程节点 调用回调函数
      	return g.getLocally(key)
      }
      
      // 向远处节点请求
      func (g *Group) getFromPeer(peer PeerGetter, key string) (ByteView, error) {
      	bytes, err := peer.Get(g.name, key)
      	if err != nil {
      		return ByteView{}, err
      	}
      	return ByteView{b: bytes}, nil
      
      }
      

  • 因此，流程如下

    •                            是
      接收 key --> 检查是否被缓存 -----> 返回缓存值 ⑴
                      |  否                         是
                      |-----> 是否应当从远程节点获取 -----> 与远程节点交互 --> 返回缓存值 ⑵
                                  |  否
                                  |-----> 调用`回调函数`，获取值并添加到缓存 --> 返回缓存值 ⑶