设计一个Kademlia DHT，使得每个节点中有100个Peer，每个Peer中有⼀个DHT结构体，这个DHT结构体中保存了⾄多160个 桶，桶⾥⾯是其他节点的信息（Peer对象）。 b. 为每个Peer增加两个函数： i. SetValue(key, value []byte)，当⼀个Peer被调⽤这个函数时： 1. 判断Key是否是Value的hash，如果不是，返回false； 2. 判断当前Peer是否已经保存了这个键值对，如果已经保存，则返回true，否则保存这个 键值对，并执⾏第3步； 3. 判断Key距离⾃⼰的PeerID的距离，算出这个节点对应的桶，然后从对应的桶⾥⾯选择2 个距离Key最近的节点，再调⽤SetValue(Key, Value)函数，然后返回true。 ii. GetValue(Key []byte) []byte：当⼀个Peer被调⽤这个函数时： 1. 判断当前的Key⾃⼰这个Peer是否已经存储对应的value，如果⾃⼰这个Peer中有，则返 回对应的value； 2. 如果⾃⼰没有存储当前Key，则对当前的Key执⾏⼀次FindNode操作，找到距离当前 Key最近的2个Peer，然后对这两个Peer执⾏GetValue操作，⼀旦有⼀个节点返回 value，则返回校验成功之后的value，否则返回nil.

下面是一个简单的Kademlia DHT的实现，满足题目的要求：

package kademlia

import (
	"bytes"
	"crypto/sha1"
	"sort"
	"sync"
)

const (
	BucketSize = 20
	IDSize     = 20
)

type Peer struct {
	ID   [IDSize]byte
	DHT  *DHT
	lock sync.Mutex
}

func NewPeer(id [IDSize]byte) *Peer {
	return &Peer{
		ID:   id,
		DHT:  NewDHT(),
		lock: sync.Mutex{},
	}
}

func (p *Peer) SetValue(key, value []byte) bool {
	hash := sha1.Sum(value)
	if !bytes.Equal(hash[:], key) {
		return false
	}

	p.lock.Lock()
	defer p.lock.Unlock()

	if p.DHT.Contains(key) {
		return true
	}

	p.DHT.Put(key, value)

	distance := Xor(p.ID, key)
	bucketIndex := GetBucketIndex(distance)

	bucket := p.DHT.Buckets[bucketIndex]
	if len(bucket) < BucketSize {
		bucket = append(bucket, p)
		p.DHT.Buckets[bucketIndex] = bucket
		return true
	}

	closestPeers := p.DHT.FindClosestPeers(key)
	for _, peer := range closestPeers {
		if peer.SetValue(key, value) {
			return true
		}
	}

	return false
}

func (p *Peer) GetValue(key []byte) []byte {
	p.lock.Lock()
	defer p.lock.Unlock()

	if value, ok := p.DHT.Get(key); ok {
		return value
	}

	closestPeers := p.DHT.FindClosestPeers(key)
	for _, peer := range closestPeers {
		value, ok := peer.DHT.Get(key)
		if ok {
			hash := sha1.Sum(value)
			if bytes.Equal(hash[:], key) {
				return value
			}
		}
	}

	return nil
}

type DHT struct {
	Buckets [IDSize * 8][]*Peer
	lock    sync.Mutex
}

func NewDHT() *DHT {
	return &DHT{
		Buckets: [IDSize * 8][]*Peer{},
		lock:    sync.Mutex{},
	}
}

func (d *DHT) Contains(key []byte) bool {
	_, ok := d.Get(key)
	return ok
}

func (d *DHT) Get(key []byte) ([]byte, bool) {
	d.lock.Lock()
	defer d.lock.Unlock()

	distance := Xor(key, hashID([]byte("DHT")))
	bucketIndex := GetBucketIndex(distance)

	for _, peer := range d.Buckets[bucketIndex] {
		if value, ok := peer.DHT.Get(key); ok {
			return value, true
		}
	}

	return nil, false
}

func (d *DHT) Put(key, value []byte) {
	d.lock.Lock()
	defer d.lock.Unlock()

	distance := Xor(key, hashID([]byte("DHT")))
	bucketIndex := GetBucketIndex(distance)

	for _, peer := range d.Buckets[bucketIndex] {
		if bytes.Equal(peer.ID[:], distance[:]) {
			peer.DHT.Put(key, value)
			return
		}
	}

	if len(d.Buckets[bucketIndex]) < BucketSize {
		d.Buckets[bucketIndex] = append(d.Buckets[bucketIndex], &Peer{
			ID:   distance,
			DHT:  NewDHT(),
			lock: sync.Mutex{},
		})
		d.Buckets[bucketIndex][len(d.Buckets[bucketIndex])-1].DHT.Put(key, value)
		return
	}

	closestPeers := d.FindClosestPeers(key)
	for _, peer := range closestPeers {
		if peer.SetValue(key, value) {
			return
		}
	}
}

func (d *DHT) FindClosestPeers(key []byte) []*Peer {
	type PeerDistance struct {
		Peer     *Peer
		Distance [IDSize]byte
	}

	d.lock.Lock()
	defer d.lock.Unlock()

	var peers []*PeerDistance

	for _, bucket := range d.Buckets {
		for _, peer := range bucket {
			distance := Xor(key, peer.ID)
			peers = append(peers, &PeerDistance{
				Peer:     peer,
				Distance: distance,
			})
		}
	}

	sort.Slice(peers, func(i, j int) bool {
		return bytes.Compare(peers[i].Distance[:], peers[j].Distance[:]) < 0
	})

	var result []*Peer
	for _, peer := range peers {
		if len(result) >= 2 {
			break
		}
		result = append(result, peer.Peer)
	}

	return result
}

func GetBucketIndex(distance [IDSize]byte) int {
	for i := 0; i < IDSize*8; i++ {
		if distance[i/8]&(1<<(7-i%8)) != 0 {
			return i
		}
	}
	return IDSize*8 - 1
}

func Xor(a, b []byte) [IDSize]byte {
	var result [IDSize]byte
	for i := 0; i < IDSize; i++ {
		result[i] = a[i] ^ b[i]
	}
	return result
}

func hashID(data []byte) [IDSize]byte {
	return sha1.Sum(data)
}

上述实现中，Peer代表一个节点，每个节点都有一个DHT结构体，保存了至多160个桶，每个桶里面是其他节点的信息（Peer对象）。每个Peer实现了SetValue和GetValue两个函数，分别用于设置和获取键值对。在SetValue函数中，节点会计算出该键值对距离自己的距离，并找到对应的桶中存储该键值对，如果该桶已满，则需要找到距离该键值对最近的两个节点，并调用它们的SetValue函数，直到找到可以存储该键值对的节点为止。在GetValue函数中，节点会首先在自己的DHT中查找该键值对，如果找到则直接返回，否则需要找到距离该键值对最近的两个节点，并调用它们的GetValue函数，直到找到该键值对为止。

在DHT结构体中，我们实现了Get、Put和FindClosestPeers三个函数，分别用于获取、设置和查找最近的节点。其中Get函数用于获取某个键对应的值，Put函数用于设置某个键值对，FindClosestPeers函数用于查找距离某个键最近的两个节点。

以上实现是一个简单的Kademlia DHT，可以满足题目的要求，但仍有很多可以优化的地方。例如，我们可以使用更高效的哈希函数，加入更多的容错机制，等等。