由于指针导致结构中的持久数据出现问题.我怎样才能用预期的数据获取结构的最新实例?

Question

我有这个微服务，它为用户准备通过API路径检索的数据。

但是，在用户可以获得请求的数据之前，我需要做一些数据处理。我是这样做的:

我将一个包含数据的填充结构体传递给两个函数，用于处理getDataOriginWeather()和getDataDestinationWeather()。两个函数运行后，API服务器就可以供用户请求数据，也就是结构体。

问题是，用户正在提取的结构包含了数据通过两个函数处理之前和之后的混合记录。

结构体的预期数据应该是经过两个函数传递后的数据。

我将这个结构体从一个包传递到另一个包。

这是我的代码。

// the struct I'm working with and that will eventually be get requested by users.
package models
type TravelItenaries struct {
Origin                string
Destination           string
Flight_num            string
Origin_latitude       string
Origin_longitude      string
Destination_latitude  string
Destination_longitude string
Coordinates_ori       string
Coordinates_dest      string
Temp_c_ori            string
Temp_f_ori            string
Temp_c_dest           string
Temp_f_dest           string
LastUpdated           string
}

在允许将数据发送给用户之前，这里是我处理数据的地方。

package data
// for brevity I have removed how I populated the struct. I do so by using a CSV file. 
func getDataOriginWeather() (travel *models.TravelItenaries, err error) {
fmt.Println("Getting origin data from Weather API...")
// construct url params for weather API calls.
params := url.Values{
"key": []string{"xxx"},
"q":   []string{""},
}
// build URL for request
u := &url.URL{
Scheme: "https",
Host:   "api.weatherapi.com",
Path:   "/v1/current.json",
// encode params for URL syntax
RawQuery: params.Encode(),
}
client := &http.Client{}
values := u.Query()
var responseData models.OriginWeather
for _, flight := range TravelItenaries {
values.Set("q", flight.Coordinates_ori)
u.RawQuery = values.Encode()
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
fmt.Println(err)
}
resp, err := client.Do(req)
if err != nil {
fmt.Println(err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
}
json.Unmarshal(body, &responseData)
flight.Temp_f_ori = strconv.FormatFloat(responseData.Current.Temp_f_ori, 'g', -1, 64)
flight.Temp_c_ori = strconv.FormatFloat(responseData.Current.Temp_c_ori, 'g', -1, 64)
flight.LastUpdated = responseData.Current.LastUpdated
//fmt.Println(utils.PrettyPrint(flight))
TravelItenaries = append(TravelItenaries, flight)
}

return travel, nil
}
// Run processes the data for me.
func Run() {
fmt.Println("Starting Weather API requests...")
getDataDestinationWeather() // note that for brevity, I won't preset  getDataDestinationWeather() here because it's basically the exact same function as the one below
getDataOriginWeather() // this function and getDataDestinationWeather() work on the same struct. 
fmt.Println("Completed Weather API requests... n...Data loaded & ready.")
}

我的问题是将这个结构体传递给我的handlers包，其中预期经getDataDestinationWeather()和getDataOriginWeather()处理后的数据

package handlers 
// as you see I'm using a pointer, assuming my problems would be solved. 
// for the most part this does everything I want, except that I'm also getting 
// records in my struct from before it's been processed by getDataOriginWeather()
// and getDataDestinationWeather()
var Data = &data.TravelItenaries
func (s *Server) getWeather(w http.ResponseWriter, r *http.Request) {
...
// Here I'm simply trying to print the struct to the user after it's been processed
// by data.getDataOriginWeather() and data.getDataDestinationWeather with the expected 
// data. 
fmt.Println(utils.PrettyPrint(Data))
}

虽然var Data = &data.TravelItenaries确实包含"预期数据"，但它也包含函数之前的旧记录。

我如何显式地传递结构体后，它已在data.Run()处理到handlers.getWeather()与处理的数据。我在这里使用的指针提供了混合的结果。

请让我知道如果你需要看到更多我的代码。

Answer 1

在"功能似乎你是:

• 不检查错误-我认为你应该。
• 在一个可变的全局变量上工作-如果你不这样做，你的代码将更干净，更容易测试和调试。

如何显式传递结构体在使用处理过的数据运行()到handlers.getWeather()。我的用法此处的指针提供了混合结果。

创建一个结构体，其中包含处理调用所需的内容。实现http。该结构的处理程序。在设置服务器时使用。

的例子:

package main
import (
"encoding/json"
"log"
"net/http"
)
type TravelHandler struct {
Data interface{} // the preloaded data you need to serve http
}
func (th TravelHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
err := json.NewEncoder(w).Encode(th.Data)
if err != nil {
http.Error(w, "could not encode data", 500)
}
}
func createTravelHandler() *TravelHandler {
// populate travel handler
return &TravelHandler{}
}
func main() {
th := createTravelHandler() // no mutable global, return the handler from a function (or pipe it through several functions)
err := http.ListenAndServe("localhost:3000", th)
log.Println(err)
}