极客兔兔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 --> 检查是否被缓存 -----> 返回缓存值 ⑴
                    |  否                         是
                    |-----> 是否应当从远程节点获取 -----> 与远程节点交互 --> 返回缓存值 ⑵
                                |  否
                                |-----> 调用`回调函数`，获取值并添加到缓存 --> 返回缓存值 ⑶