Go Xiaobai implements a simple go mock server

Preface

Study golang It's been a while , Read some books , I read another entry-level book last week 《Go A guide to language learning 》, It's time to test the results .

Purpose

By reading local mock data , launch http request , Back to the front end , Realization mock function .

Code

The overall code is only 50 Line code around , It is an extremely simple mock server, There's no extra functionality ( The main thing is not to

step 1

Scan local to json Final document , Get file path

//  Get current json The path where the file is located already has the file name , And then we'll do the stitching
func ParsePath() (path string, err error) {
 pwd, _ := os.Getwd()
 fileList, err := ioutil.ReadDir(pwd)
 if err != nil {
 log.Fatal(err)
 }
 var curJsonFile string
 for _, v := range fileList {
 name := v.Name()
 if isJson := strings.Contains(name, "json"); isJson {
 curJsonFile = name
 }
 }
 if curJsonFile == "" {
 return curJsonFile, errors.New("dont have json file")
 }
 absPath := pwd + "/" + curJsonFile
 return absPath, nil
}

step 2

//  Read the specific... According to the passed in file name []byte data
func ReadJSON(path string) ([]byte, error) {
 jsonFile, err := os.Open(path)
 if err != nil {
 log.Fatal("open file err")
 }
 defer jsonFile.Close()
 byteValue, err := ioutil.ReadAll(jsonFile)
 if err != nil {
 return nil, err
 }
 return byteValue, nil
}

step 3

//  Based on the incoming []byte data , Deserialize the data conversion to map type
//  Because I don't know json Specific data of the document , Specific structure , So use the map[string]interface{} Of
//  data type
func DecodeJSONString(jsonBytes []byte) (map[string]interface{}, error) {
 var m map[string]interface{}
 err := json.Unmarshal(jsonBytes, &m)
 if err != nil {
 log.Fatal("json unmarshal fail", err)
 return nil, err
 }
 return m, nil
}

step 4

var data map[string]interface{}

func returnResponse(w http.ResponseWriter, r *http.Request) {
 w.Header().Set("content-type", "application/json")
 path := r.URL.Path
 if d := data[path]; d != nil {
 stringData, err := json.Marshal(data[path])
 if err != nil {
 log.Fatal(err)
 }
 w.Write(stringData)
 }
}

func main() {
 path, err := src.ParsePath()
 if err != nil {
 log.Fatal(err)
 }
 bytes, err := src.ReadJSON(path)
 if err != nil {
 log.Fatal(err)
 }
 m, err := src.DecodeJSONString(bytes)
 data = m
 if err != nil {
 log.Fatal("decode fail: ", err)
 }
 for addr, _ := range data {
 http.HandleFunc(addr, returnResponse)
 }
 err = http.ListenAndServe(":3000", nil)
 if err != nil {
 log.Fatal("listenAndServer fail")
 }
}

Final effect

Local access

localhost:3000/v1/lottery

  The front end can get the returned data

mock The local json file

{
 "/v1/lottery": [{
 "name": "shinji",
 "age": 20
 }, {
 "name": "ayanami",
 "age": 20
 }]
}

Last

This is a very recommended mock server,  Multiple file formats are not supported yet , Multiple files , Multiple request methods , Custom rule mock Data and so on . Only for the present Golang A quiz after study , It's simple , I hope you don't spray .