Golang implements the operation of a restful microservice


How to build a simple web service with net / HTTP

Golang provides a concise way to build web services

package main 
import (
func HelloResponse(rw http.ResponseWriter, request *http.Request) {
    fmt.Fprintf(w, "Hello world.")
func main() {
    http.HandleFunc("/", HelloResponse)
    http.ListenAndServe(":3000", nil)

There are two core methods:

Func handlefunc (pattern string, handler func (responsewriter, * request)): handlefunc registers a handler function corresponding to a given pattern.

Func listenandserve (addr string, handler) error: listenandserve listens to the given TCP network address, then takes the handler and calls the serve method to receive the request.

After go build, execute the compiled file and you can see Hello world on the client

With web services, you can set small goals

I think that as the first version, there is no need for complex design, just receive the user’s request, find the corresponding handler, execute its logic, and then return the JSON response.

With small goals, how can we achieve them?

1. Design how users register controllers and actions

According to my observation, some frameworks preset a series of methods such as get, post and put in the controller to receive HTTP requests of get, post and put.

I think this design has its advantages, because users only need to implement these methods, but it also has its disadvantages at the business level, because we can’t guarantee that the controller responsible for a page or function only receives one get request. If there are two get requests, we need to establish another controller to implement its get method only.

Therefore, I learned from the syntax of laravel registering controller and action in the PHP community: get (“/”“ [email protected] “)。

The user only needs to define:

type IndexController struct {
func (IndexController *IndexController) Index(//params) (//return values) {

Of course, after thinking this way, we will bring some features of dynamic scripting language into the framework, and we will certainly use golang‘s reflect library.

2. Design the relationship container of path, controller and action

I used golang’s map to define a data structure such as map [string] map [string] map [string] string

Take [“/”: [“get”: [“indexcontroller”: “get”], “post”: [“indexcontroller”: “post”], “/ foo”: [“get”: [“indexcontroller”: “foo”]] for example:

This indicates that under the “/” path, there are get and post requests, corresponding to the get and post methods under indexcontroller respectively. Under the “/ foo” path, there are get requests, corresponding to the foo method under indexcontroller.

When accepting the request, if the corresponding method is not found, it returns 405.

3. How to bind a series of registered methods with path to receive external requests

We can see that the handler type required by func handlefunc (pattern string, handler func (responsewriter, * request)) is func (responsewriter, * request)), which is different from our designed functionfunction (indexcontroller * indexcontroller) index (/ / params) (/ / return values) {}.

At this time, I found that because golang has the first class functions feature, we can handle the functions as follows:

http.HandleFunc(path, HandleRequest()) 
func HandleRequest() {
    return func(rw http.ResponseWriter, request *http.Request) {
        // do your logic

4. Say hi to encoding / JSON

When we receive the return value of function, we need to JSON encode the result, and encoding / JSON is responsible for this function. I use JSON. Marshal ():

Func Marshall (V interface {}) ([] byte, error): Marshall returns the encoding result of V.

How to use

package main 
import (
type IndexController struct {
func (IndexController *IndexController) Index(request map[string]url.Values, headers http.Header) (statusCode int, response interface{}) {
    return 200, map[string]string{"hello": "world"}
type BarController struct {
func (*BarController) Bar(request map[string]url.Values, headers http.Header) (statusCode int, response interface{}, responseHeader http.Header) {
    return 200, map[string]string{"GoTo": "Bar"}, http.Header{"Foo": {"Bar", "Baz"}}
func main() {
    var apiService = GoGym.Prepare()
    apiService.Get("index", "[email protected]")
    apiService.Post("bar", "[email protected]")
    controllers := []interface{}{&IndexController{}}

Project complete code

package GoGym 
import (
const (
    GETMethod     = "GET"
    POSTMethod    = "POST"
    PUTMethod     = "PUT"
    PATCHMethod   = "PATCH"
    DELETEMethod  = "DELETE"
const (
    HTTPMethodNotAllowed = 405
// APIService for now is the struct for containing controllerRegistry and registeredPathAndController,
// and it is the core service provider
type APIService struct {
    // controllerRegistry is where all registered controllers exist
    controllerRegistry map[string]interface{}
    //registeredPathAndController is a mapping of paths and controllers
    registeredPathAndController map[string]map[string]map[string]string
    requestForm                 map[string]url.Values
func (api *APIService) Get(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(GETMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
func (api *APIService) Post(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(POSTMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
func (api *APIService) Put(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(PUTMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
func (api *APIService) Patch(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(PATCHMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
func (api *APIService) Options(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(OPTIONSMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
func (api *APIService) Delete(path, controllerWithActionString string) {
    mapping := api.mappingRequestMethodWithControllerAndActions(DELETEMethod, path, controllerWithActionString)
    api.registeredPathAndController[path] = mapping
// mappingRequestMethodWithControllerAndActions is a function for mapping request method with controllers
// which containing actions
func (api *APIService) mappingRequestMethodWithControllerAndActions(requestMethod, path, controllerWithActionString string) map[string]map[string]string {
    mappingResult := make(map[string]map[string]string)
    if length := len(api.registeredPathAndController[path]); length > 0 {
        mappingResult = api.registeredPathAndController[path]
    controllerAndActionSlice := strings.Split(controllerWithActionString, "@")
    controller := controllerAndActionSlice[0]
    action := controllerAndActionSlice[1]
    controllerAndActionMap := map[string]string{controller: action}
    mappingResult[requestMethod] = controllerAndActionMap
    return mappingResult
// HandleRequest is a function to handle http request
func (api *APIService) HandleRequest(controllers map[string]map[string]string) http.HandlerFunc {
    return func(rw http.ResponseWriter, request *http.Request) {
        method := request.Method
        api.requestForm["query"] = request.Form
        api.requestForm["form"] = request.PostForm
        macthedControllers, ok := controllers[method]
        if !ok {
        for k, v := range macthedControllers {
            controllerKey := "*" + k
            controller := api.controllerRegistry[controllerKey]
            in := make([]reflect.Value, 2)
            in[0] = reflect.ValueOf(api.requestForm)
            in[1] = reflect.ValueOf(request.Header)
            returnValues := reflect.ValueOf(controller).MethodByName(v).Call(in)
            statusCode := returnValues[0].Interface()
            intStatusCode := statusCode.(int)
            response := returnValues[1].Interface()
            responseHeaders := http.Header{}
            if len(returnValues) == 3 {
                responseHeaders = returnValues[2].Interface().(http.Header)
            api.JSONResponse(rw, intStatusCode, response, responseHeaders)
// RegisterHandleFunc is a function registers a handle function to handle request from path
func (api *APIService) RegisterHandleFunc() {
    for k, v := range api.registeredPathAndController {
        path := k
        if !strings.HasPrefix(k, "/") {
            path = fmt.Sprintf("/%v", k)
        http.HandleFunc(path, api.HandleRequest(v))
// RegisterControllers is a function registers a struct of controllers into controllerRegistry
func (api *APIService) RegisterControllers(controllers []interface{}) {
    for _, v := range controllers {
// RegisterControllers is a function registers a controller into controllerRegistry
func (api *APIService) RegisterController(controller interface{}) {
    controllerType := getType(controller)
    api.controllerRegistry[controllerType] = controller
// getType is a function gets the type of value
func getType(value interface{}) string {
    if t := reflect.TypeOf(value); t.Kind() == reflect.Ptr {
        return "*" + t.Elem().Name()
    } else {
        return t.Name()
// Serve is a function
func (api *APIService) Serve(port int) {
    fullPort := fmt.Sprintf(":%d", port)
    http.ListenAndServe(fullPort, nil)
// JSONResponse is a function return json response
func (api *APIService) JSONResponse(rw http.ResponseWriter, statusCode int, response interface{}, headers http.Header) {
    for k, v := range headers {
        for _, header := range v {
            rw.Header().Add(k, header)
    rw.Header().Add("Content-Type", "application/json")
    rsp, err := json.Marshal(response)
    if err != nil {
        // TODO: logging error
        fmt.Println("JSON err:", err)
// Prepare is a fucntion prepare the service and return prepared service to the user
func Prepare() *APIService {
    var apiService = new(APIService)
    apiService.controllerRegistry = make(map[string]interface{})
    apiService.registeredPathAndController = make(map[string]map[string]map[string]string)
    apiService.requestForm = make(map[string]url.Values)
    return apiService

The above is my personal experience. I hope I can give you a reference, and I hope you can support developpaer. If you have any mistakes or don’t consider completely, please don’t hesitate to comment.