net/http路由注册

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
)

type HandlerStruct struct {
	content string
}

//HandlerStruct Handler对象
func (handler *HandlerStruct) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, handler.content)
}

func Handler(w http.ResponseWriter, req *http.Request) {
	// 判断请求类型
	if req.Method != "GET" {
		w.WriteHeader(500)
		fmt.Fprintf(w, "requrie get method")
		return
	}
	if req.URL.Path == "handleFunc" {
		w.WriteHeader(200)
		//
		fmt.Fprintf(w, "Hello word")
		return
	} else {
		w.WriteHeader(200)
		//
		fmt.Fprintf(w, "muxHandleFunc  hello  word")
		return
	}
}

func main() {
	//1. 路由，func(w http.ResponseWriter, r *http.Requests)
	//http.HandleFunc("/handleFunc", Handler)
	//2. 路由，ServeHTTP(ResponseWriter, *Request) 实现http.Handler接口的类型的实例
	//http.Handle("/handle", &HandlerStruct{content: "Hello word"})
	// ListenAndServe监听TCP网络地址addr，然后调用handler,
	//handler来处理传入连接的请求，没handler，默认用DefaultServeMux，ListenAndServe总是返回一个非nil错误
	//已接受的连接被配置为启用TCP保持连接。
	// HandlerFunc实际上是将handler函数做了一个类型转换
	//http.ListenAndServe(":8080", nil)
	// DefaultServeMux是service使用的默认ServeMux
	// DefaultServeMux.Handle(pattern, handler) 路由注册
	// ServeMux 服务复用器
	// 注册路由的处理函数最后都会用到ServerMux结构的Handle方法去注册路由处理函数。
	/*  相当于路由和handler映射表
	type ServeMux struct {
		mu    sync.RWMutex
		m     map[string]muxEntry  key 路由:{路由，处理方法}
		es    []muxEntry // slice of entries sorted from longest to shortest.
		hosts bool       // whether any patterns contain hostnames
	}

	type muxEntry struct {
		h       Handler 处理方法
		pattern string  路由
	}
	*/
	//创建一个ServeMux实例取代默认的DefaultServeMux
	//3.
	mux := http.NewServeMux()
	mux.HandleFunc("/muxhandleFunc", Handler)
	//4.
	mux.Handle("/muxhandle", &HandlerStruct{content: "muxHandle  hello  word"})
	//
	// http.ListenAndServe(":8080", mux)

	// 创建server
	server := &http.Server{
		Addr:    ":8080",
		Handler: mux,
	}
	// 创建监听管道  终端控制进程结束
	sigCh := make(chan os.Signal)
	// 将信号写进sigCh，监听指定信号 ctrl c  ，kill
	signal.Notify(sigCh, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		<-sigCh
		// 通过监听信号，关闭服务，Shutdown优雅地关闭服务器而不中断任何服务
		if err := server.Shutdown(context.Background()); err != nil {
			log.Fatal("Shutdown server:", err)
		}
	}()

	log.Println("Starting HTTP server...")
	// 开启服务
	err := server.ListenAndServe()
	if err != nil {
		if err == http.ErrServerClosed {
			log.Print("Server closed under request")
		} else {
			log.Fatal("Server closed unexpected")
		}
	}
}

重新写一个简单的ServeMux的版本

api

package api

import (
	"fmt"
	"net/http"
)

type Api struct {
}

// api管理
func NewApi() *Api {
	return &Api{}
}

// HandleFunc
func (a *Api) Handler(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(200)
	fmt.Fprintf(w, "TODO::")
	return
}

server

package main

import (
	"context"
	"server/httpserver/api"
	"fmt"
	"log"
	"net"
	"net/http"
	"os"
	"os/signal"
	"regexp"
	"syscall"
	"time"
)

// 路由-handler
type route struct {
	// 匹配路由
	pattern *regexp.Regexp
	// 处理方法
	handler http.Handler
}

// 路由管理  相当于简单版的 ServeMux，一般直接用ServeMux，不用重新写
type RegexpHandler struct {
	routes []*route
}

// 1. 添加路由,ServeHTTP(ResponseWriter, *Request) 实现http.Handler接口的类型的实例
//func (r *RegexpHandler) Handle(pattern string, handler http.Handler) {
//	r.routes = append(r.routes, &route{pattern: regexp.MustCompilePOSIX(pattern), handler: handler})
//}

//2. 添加路由 处理方法 func(w http.ResponseWriter, r *http.Requests)
func (r *RegexpHandler) HandleFunc(pattern string, handleFunc func(w http.ResponseWriter, r *http.Request)) {
	r.routes = append(r.routes, &route{pattern: regexp.MustCompilePOSIX(pattern), handler: http.HandlerFunc(handleFunc)})
}

// http服务
type WebServer struct {
	server *http.Server
}

// http服务管理
func NewWebServer() *WebServer {
	ws := &WebServer{}
	return ws.init()
}

// ServeHTTP将请求发送给处理程序
// 模式最接近于匹配请求URL
func (rh *RegexpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	for _, route := range rh.routes {
		if route.pattern.MatchString(r.URL.Path) {
			route.handler.ServeHTTP(w, r)
			return
		}
	}
	// 未找到路由
	http.NotFound(w, r)
}
func (w *WebServer) init() *WebServer {
	// 初始化路由组
	r := &RegexpHandler{
		routes: make([]*route, 0),
	}
	wapi := api.NewApi()
	// 添加路由 ,处理方法
	r.HandleFunc("/todo", wapi.Handler)
	// 创建服务 指定Handler
	server := &http.Server{
		Addr: ":8080",
		// Handler:
		// type Handler interface {
		//	ServeHTTP(ResponseWriter, *Request)
		//}
		Handler: r,
	}
	w.server = server
	return w
}

// 启动webserver
func (w *WebServer) Start() error {
	if l, err := net.Listen("tcp4", ":8080"); err != nil {
		return err
	} else {
		fmt.Println("web server start at :")
		go w.server.Serve(l)
		return nil
	}
}
func (ws *WebServer) ShutDown() error {
	ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
	// 当Shutdown被调用时，服务，ListenAndServe，和
	// listenandservtls立即返回ErrServerClosed。确保
	//程序不会退出，而是等待Shutdown返回。
	//
	// Shutdown不会试图关闭或等待被劫持
	//连接，例如WebSockets。关机的来电者应该
	//分别通知这些长时间连接关闭并等待
	//关闭它们，如果需要。参见RegisterOnShutdown获取方法
	//注册关机通知函数。
	return ws.server.Shutdown(ctx)
}

func main() {
	// mux := http.NewServeMux()
	//mux.HandleFunc()
	//
	 创建server
	//server := &http.Server{
	//	Addr:    ":8080",
	//	Handler: mux,
	//}
	 webserver := NewWebServer()
	// 创建监听管道  终端控制进程结束
	sigCh := make(chan os.Signal)
	// 将信号写进sigCh，监听指定信号 ctrl c  ，kill
	signal.Notify(sigCh, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		fmt.Println(<-sigCh)
		// 通过监听信号，关闭服务，Shutdown优雅地关闭服务器而不中断任何服务
		// webserver.server.Shutdown(context.Background())
		if err := webserver.ShutDown(); err != nil {
			log.Fatal("Shutdown server:", err)
		}
	}()

	log.Println("Starting HTTP server...")
	// 开启服务
	err := webserver.server.ListenAndServe()
	if err != nil {
		if err == http.ErrServerClosed {
			log.Print("Server closed under request")
		} else {
			log.Fatal("Server closed unexpected")
		}
	}
}