在Golang中使用Http处理程序的全局变量

Question

我知道有一些关于这个问题的问题和帖子/文章,但从我的新手观点来看,并不完全正确.问题是,我有一个主程序监听端口并将调用重定向到特定的处理程序.典型结构:

func main() {
    http.HandleFunc("/something", specificHandler)
    http.ListenAndServe(":8080", nil)
}

处理程序是这样的:

func specificHandler(w http.ResponseWriter, r *http.Request) {
    somepackage.foo()
}

然后somepackage包含函数foo,它有一些全局变量,主要是因为它们需要共享函数(例如,当使用一个用容器/堆实现的优先级队列时,它将获得交换函数中的优先级.全球距离矩阵,当然是可变的).还有很多其他的例子.总之,全局变量......

正如您可能看到的,问题是这些变量在对处理程序的所有调用之间共享.这很糟糕.

我怎么能真正解决这个问题？必须有一个容易实现的方法,我还没有,因为它看起来像这么平常......

提前致谢.

---

编辑

使它更清楚.例如,在我的A*包中,我有以下全局变量:

var openVerticesAS PriorityQueueAStar

// which vertices are closed
var closedVertices map[int]bool

// which vertices are currently open
var openVertices map[int]bool

// cost from start to node
var gScore map[int]float64

// cost from start to end, passing by node i (g+h)
var fScore map[int]float64

然后,PriorityQueueAStar实现如下:

type PriorityQueueAStar []int // rel id

func (pq PriorityQueueAStar) Len() int { return len(pq) }

func (pq PriorityQueueAStar) Empty() bool { return len(pq) == 0 }

func (pq PriorityQueueAStar) Less(i, j int) bool {
    return fScore[pq[i]] < fScore[pq[j]]
}

func (pq PriorityQueueAStar) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueueAStar) Push(x interface{}) {
    *pq = append(*pq, x.(int))
}

func (pq *PriorityQueueAStar) Pop() interface{} {
    old := *pq
    n := len(old)
    rel := old[n-1]
    *pq = old[0 : n-1]
    return rel
}

func (pq PriorityQueueAStar) Top() interface{} {
    return pq[0]
}

那么问题是,如何在不将所有这些地图作为全局变量的情况下继续这样做？如果它们是结构的一部分,我如何从优先级队列函数访问结构？

Answer 1

当你的处理程序需要一个变量时,通常这意味着你应该实现Handler接口而不是提供一个HandlerFunc函数.

这是一个坏的例子(使用全局变量):

var globalThing string

func specificHandler(w http.ResponseWriter, r *http.Request) {
    w.Write(globalConfigThing)
}

func main() {
    globalThing = "Hello world!"
    http.HandleFunc("/something", specificHandler)
    http.ListenAndServe(":8080", nil)
}

这是一个更好的例子(不使用全局变量):

type specificHandler struct {
    Thing string
}

func (h *specificHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Write(h.Thing)
}

func main() {
    http.Handle("/something", &specificHandler{Thing: "Hello world!"})
    http.ListenAndServe(":8080", nil)
}

如您所见,a Handler可以封装变量.

为了完整起见,另一种方法是使用函数闭包.这适用于一次性处理程序,但不可重用,并且更难编写单元测试.

func main() {
    scopedThing := "Hello world!"
    http.HandleFunc("/something", func (w http.ResponseWriter, r *http.Request) {
        w.Write(scopedThing)
    })
    http.ListenAndServe(":8080", nil)
}

正确完成后,您现在可以somepackage通过将它们作为参数传递等来避免包中的全局变量.

编辑:例如,您可以使用包中的多个PriorityQueueAStar字段定义处理程序结构somepackage:

type specificHandler struct {
    QueueA somepackage.PriorityQueueAStar
    QueueB somepackage.PriorityQueueAStar
    QueueC somepackage.PriorityQueueAStar
}

func (h *specificHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    h.QueueA.Push(h.QueueB.Pop)
    h.QueueB.Push(h.QueueC.Pop)
    w.Write([]byte("Queues pushed and popped"))
}