背景

​

服务想必大家都有很多开发经验，但是从零开始搭建一个项目的经验，就少的多了。更不要说不使用任何框架的情况下从零开始搭建一个服务。那么这次就看看从零开始搭建一个好用好写web服务到底有多难？

HelloWorld

官网给出的helloworld例子。http标准库提供了两个方法，HandleFunc注册处理方法和ListenAndServe启动侦听接口。

假如业务更多

下面我们模拟一下接口增多的情况。可以看出有大量重复的部分。这样自然而然就产生了抽象服务的需求。

package main

import (
"fmt"
"net/http"

)

func greet(w http.ResponseWriter, r *http.Request) {

	fmt.Fprintf(w, "Greet!: %s\n", r.URL.Path)

}

func hello(w http.ResponseWriter, r *http.Request) {

	fmt.Fprintf(w, "Hello!: %s\n", r.URL.Path)

}

func notfound(w http.ResponseWriter, r *http.Request) {

	fmt.Fprintf(w, "Hello, you've requested: %s\n", r.URL.Path)

}

func main() {

	http.HandleFunc("/", notfound)

	http.HandleFunc("/hello", hello)

	http.HandleFunc("/greet", greet)

	http.ListenAndServe(":80", nil)

}

我们想要一个服务，它代表的是对某个端口监听的实例，它可以根据访问的路径，调用对应的方法。在需要的时候，我可以生成多个服务实例，监听多个端口。那么我们的Server需要实现下面两个方法。

type Server interface {

	Route(pattern string, handlerFunc http.HandlerFunc)


	Start(address string) error

}

简单实现一下。

package server

import "net/http"

type Server interface {

	Route(pattern string, handlerFunc http.HandlerFunc)

	Start(address string) error

}

type httpServer struct {

	Name string

}

func (s *httpServer) Route(pattern string, handlerFunc http.HandlerFunc) {

	http.HandleFunc(pattern, handlerFunc)

}

func (s *httpServer) Start(address string) error {
return http.ListenAndServe(address, nil)

}

func NewHttpServer(name string) Server {
return &httpServer{

		Name: name,

	}

}

修改业务代码

func main() {

	server := server.NewHttpServer("demo")

	server.Route("/", notfound)

	server.Route("/hello", hello)

	server.Route("/greet", greet)

	server.Start(":80")

}

格式化输入输出

在我们实际使用过程中，输入输出一般都是以json的格式。自然也需要通用的处理过程。

type Context struct {

	W http.ResponseWriter

	R *http.Request

}

func (c *Context) ReadJson(data interface{}) error {

	body, err := io.ReadAll(c.R.Body)
if err != nil {
return err

	}

	err = json.Unmarshal(body, data)
if err != nil {
return err

	}
return nil

}

func (c *Context) WriteJson(code int, resp interface{}) error {

	c.W.WriteHeader(code)

	respJson, err := json.Marshal(resp)
if err != nil {
return err

	}

	_, err = c.W.Write(respJson)
return err

}

模拟了一个常见的业务代码。定义了入参和出参。

type helloReq struct {

	Name string

	Age  string

}

type helloResp struct {

	Data string

}

func hello(w http.ResponseWriter, r *http.Request) {

	req := &helloReq{}

	ctx := &server.Context{

		W: w,

		R: r,

	}


	err := ctx.ReadJson(req)

if err != nil {

		fmt.Fprintf(w, "err:%v", err)
return

	}


	resp := &helloResp{

		Data: req.Name + "_" + req.Age,

	}


	err = ctx.WriteJson(http.StatusOK, resp)
if err != nil {

		fmt.Fprintf(w, "err:%v", err)
return

	}


}

用postman试一下，是不是和我们平常开发的接口有一点像了。

由于200，404，500的返回结果实在是太普遍了，我们当然也可以进一步封装输出方法。但是我觉得没必要。

在我们设计的过程中，是否要提供辅助性的方法，还是只聚焦核心功能，是非常值得考虑的问题。

func (c *Context) SuccessJson(resp interface{}) error {
return c.WriteJson(http.StatusOK, resp)

}

func (c *Context) NotFoundJson(resp interface{}) error {
return c.WriteJson(http.StatusNotFound, resp)

}

func (c *Context) ServerErrorJson(resp interface{}) error {
return c.WriteJson(http.StatusInternalServerError, resp)

}

让框架来创建Context

观察下业务代码，还有个非常让人不舒服的地方。Context是框架内部使用的数据结构，居然要业务来创建！真的是太不合理了。

那么下面我们把Context移入框架内部创建，同时业务侧提供的handlefunction入参应该直接是由框架创建的Context。

首先修改我们的路由注册接口的定义。在实现中，我们注册了一个匿名函数，在其中构建了ctx的实例，并调用入参中业务的handlerFunc。

type Server interface {

	Route(pattern string, handlerFunc func(ctx *Context))

	Start(address string) error

}

func (s *httpServer) Route(pattern string, handlerFunc func(ctx *Context)) {

	http.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {

		ctx := NewContext(w, r)

		handlerFunc(ctx)

	})

}

func NewContext(w http.ResponseWriter, r *http.Request) *Context {
return &Context{

		W: w,

		R: r,

	}

}

这样修改之后我们的业务代码也显得更干净了。

func hello(ctx *server.Context) {

	req := &helloReq{}

	err := ctx.ReadJson(req)

if err != nil {

		ctx.ServerErrorJson(err)
return

	}


	resp := &helloResp{

		Data: req.Name + "_" + req.Age,

	}


	err = ctx.WriteJson(http.StatusOK, resp)
if err != nil {

		ctx.ServerErrorJson(err)
return

	}

}

RestFul API 实现

当然我们现在发现，不管用什么方法调用我们的接口，都可以正常返回。但是我们平常都习惯写restful风格的接口。

那么在注册路由时，自然需要加上一个method的参数。注册时候也加上一个GET的声明。

type Server interface {

	Route(method string, pattern string, handlerFunc func(ctx *Context))

	Start(address string) error

}

server.Route(http.MethodGet, "/hello", hello)

那么我们自然可以这样写，当请求方法不等于我们注册方法时，返回error。

func (s *httpServer) Route(method string, pattern string, handlerFunc func(ctx *Context)) {

	http.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
if r.Method != method {

			w.Write([]byte("error"))
return

		}

		ctx := NewContext(w, r)

		handlerFunc(ctx)

	})

}

那么我们现在就有了一个非常简单的可以实现restful api的服务了。

但是距离一个好用好写的web服务还有很大的进步空间。