Let's start with a simple example , How to use Go Language to build a simple Web service , From shallow to deep , Introduce the implementation details

A simple Web The server

package main

import (
	"fmt"
	"log"
	"net/http"
)

func HelloWorld(w http.ResponseWriter, r *http.Request) {
    
	_, err := fmt.Fprintf(w, "Hello World!")
	if err != nil {
    
		log.Panic(err)
	}
}
func main() {
    
	// Set access routes , This is when url The path in is /hello when , Server calls HelloWorld function （ It can be uniformly called handler function ）
	http.HandleFunc("/hello", HelloWorld)
	//web The listening port is 8080
	if err := http.ListenAndServe(":8080", nil); err != nil {
    
		log.Panic(err)
	}
}

here web The listening port is 8080, Run the program . Then open the browser , Input http://127.0.0.1:8080/hello, We will get the following results

Web How the server works

1、 First of all to see HandleFunc function , Look at the notes and you probably know HandleFunc It's for registration handler function （ It can also be called app, Corresponding to the previous HelloWorld function , Used to process user requests , And return the result ）, Two into the refs , One pattern（ It is simply understood as url The path in ）, One handler function

// HandleFunc registers the handler function for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    
	DefaultServeMux.HandleFunc(pattern, handler)
}

2、DefaultServerMux It's a ServeMux Structural instance , Mainly used to store pattern and handler The correspondence between

type ServeMux struct {
    
	mu    sync.RWMutex
	m     map[string]muxEntry
	es    []muxEntry // slice of entries sorted from longest to shortest.
	hosts bool       // whether any patterns contain hostnames
}

type muxEntry struct {
    
	h       Handler
	pattern string
}

// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

3、HandleFunc The function is called ServeMux Method of implementation HandleFunc

// HandleFunc registers the handler function for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    
	DefaultServeMux.HandleFunc(pattern, handler)
}
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    
	if handler == nil {
    
		panic("http: nil handler")
	}
	mux.Handle(pattern, HandlerFunc(handler))
}

notes ：mux.Handle(pattern, HandlerFunc(handler)) In this business HandlerFunc Is a function type , take handler Cast

// The HandlerFunc type is an adapter to allow the use of
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler that calls f.
type HandlerFunc func(ResponseWriter, *Request)

4、ServeMux Realized Handle Method , Mainly using fields m（map[string]muxEntry） Storage pattern and handler The relationship between , The key is pattern, The value is handler

// Handle registers the handler for the given pattern.
// If a handler already exists for pattern, Handle panics.
func (mux *ServeMux) Handle(pattern string, handler Handler) {
    
	mux.mu.Lock()
	defer mux.mu.Unlock()

	if pattern == "" {
    
		panic("http: invalid pattern")
	}
	if handler == nil {
    
		panic("http: nil handler")
	}
	if _, exist := mux.m[pattern]; exist {
    
		panic("http: multiple registrations for " + pattern)
	}

	if mux.m == nil {
    
		mux.m = make(map[string]muxEntry)
	}
	e := muxEntry{
    h: handler, pattern: pattern}
	mux.m[pattern] = e
	if pattern[len(pattern)-1] == '/' {
    
		mux.es = appendSorted(mux.es, e)
	}

	if pattern[0] != '/' {
    
		mux.hosts = true
	}
}

5、ListenAndServe The function is to listen and respond to requests

func ListenAndServe(addr string, handler Handler) error {
    
	server := &Server{
    Addr: addr, Handler: handler}
	return server.ListenAndServe()
}

There are two of them , One is the listening address , One is handler, Notice the handler Refer to mux（ Router , Used to store pattern and app The relationship between ）. If handler by nil, Description default use DefautServeMux, Next, we can also construct a mux

package main

import (
	"fmt"
	"log"
	"net/http"
)

func HelloWorld(w http.ResponseWriter, r *http.Request) {
    
	_, err := fmt.Fprintf(w, "Hello World!")
	if err != nil {
    
		log.Panic(err)
	}
}
func main() {
    
	// Customize a mux
	mux := new(http.ServeMux)
	// Register function 
	mux.HandleFunc("/hello", HelloWorld)
	if err := http.ListenAndServe(":8080", mux); err != nil {
    
		log.Panic(err)
	}
}

Run the program , Then open the browser , Input http://127.0.0.1:8080/hello, It will also get the expected results