Go Http Server 프레임워크를 빠르게 구현하는 방법은 무엇입니까? 하나의 기사로 완료

이 기사에서는 Golang에 대한 관련 지식을 소개하고 Go Http Server 프레임워크를 빠르게 구현하는 방법에 대해 설명하겠습니다.

Go에서 http 서버를 사용하려는 경우 가장 쉬운 방법은 http/net

err := http.ListenAndServe(":8080", nil)if err != nil {
    panic(err.Error())}http.HandleFunc("/hello", func(writer http.ResponseWriter, request *http.Request) {
    writer.Write([]byte("Hello"))})

를 사용하여 핸들 func를 정의하는 것입니다. [관련 권장 사항: Go 비디오 튜토리얼]

유형 HandlerFunc func(ResponseWriter, * 요청) code><code>type HandlerFunc func(ResponseWriter, *Request)

标准库的 http 服务器实现很简单，开启一个端口，注册一个实现HandlerFunc

표준 라이브러리의 http 서버 구현은 매우 간단합니다. 포트를 열고 HandlerFunc를 구현하는 핸들러를 등록하세요.

동시에 표준 라이브러리도 제공합니다. 요청을 완전히 인수하는 방법

func main() {
    err := http.ListenAndServe(":8080", &Engine{})
    if err != nil {
        panic(err.Error())
    }}type Engine struct {}func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/hello" {
        w.Write([]byte("Hello"))
    }}

Define ServerHTTP

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)}

HTTP 서버 프레임워크를 작성해야 한다면 이 방법을 구현해야 합니다. 동시에 net/http의 입력 및 출력 스트림은 그리 많지 않습니다. 편리합니다. 또한 패키징과 간단한 Route가 필요합니다. ServeHTTP에 Path를 작성하지 마세요.

간단한 요약입니다

• ServeHTTP를 구현하는 엔진

• HTTP 원본 입력 및 출력 스트림을 래핑하는 컨텍스트

• 라우트 매칭을 구현하는 경로

Route 단순화를 위해 Map 여기서는 완전한 일치를 수행하기 위해

import (
    "net/http")type Engine struct {
    addr  string
    route map[string]handFunc}type Context struct {
    w      http.ResponseWriter
    r      *http.Request
    handle handFunc}type handFunc func(ctx *Context) errorfunc NewServer(addr string) *Engine {
    return &Engine{
        addr:  addr,
        route: make(map[string]handFunc),
    }}func (e *Engine) Run() {
    err := http.ListenAndServe(e.addr, e)
    if err != nil {
        panic(err)
    }}func (e *Engine) Get(path string, handle handFunc) {
    e.route[path] = handle}func (e *Engine) handle(writer http.ResponseWriter, request *http.Request, handle handFunc) {
    ctx := &Context{
        w:      writer,
        r:      request,
        handle: handle,
    }
    ctx.Next()}func (e *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    handleF := e.route[req.URL.Path]
    e.handle(w, req, handleF)}func (c *Context) Next() error {
    return c.handle(c)}func (c *Context) Write(s string) error {
    _, err := c.w.Write([]byte(s))
    return err}

우리는 HTTP 서버를 확인하기 위해 테스트를 작성합니다

func TestHttp(t *testing.T) {
    app := NewServer(":8080")

    app.Get("/hello", func(ctx *Context) error {
        return ctx.Write("Hello")
    })

    app.Run()}

여기에 패키지한 핸들은 표준 라이브러리와 비교할 때 쓰기만 하고 반환하지 않습니다. 작성하지 않은 후 반환하는 것을 잊어버리는 문제. 종종 발견하기 어렵습니다.

Http 서버에도 미들웨어 기능이 필요합니다. 여기서 아이디어는 엔진에 handlerFunc 배열을 저장하고, 외부 등록을 지원하고, 요청이 들어올 때 새 Ctx를 생성하고, 엔진의 전역 HandleFunc를 Ctx에 복사하는 것입니다. , 그런 다음 c.Next()를 사용하여 matryoshka 스타일 호출을 구현합니다.

package httpimport (
    "net/http")type Engine struct {
    addr        string
    route       map[string]handFunc
    middlewares []handFunc}type Context struct {
    w        http.ResponseWriter
    r        *http.Request
    index    int
    handlers []handFunc}type handFunc func(ctx *Context) errorfunc NewServer(addr string) *Engine {
    return &Engine{
        addr:        addr,
        route:       make(map[string]handFunc),
        middlewares: make([]handFunc, 0),
    }}func (e *Engine) Run() {
    err := http.ListenAndServe(e.addr, e)
    if err != nil {
        panic(err)
    }}func (e *Engine) Use(middleware handFunc) {
    e.middlewares = append(e.middlewares, middleware)}func (e *Engine) Get(path string, handle handFunc) {
    e.route[path] = handle}func (e *Engine) handle(writer http.ResponseWriter, request *http.Request, handle handFunc) {
    handlers := make([]handFunc, 0, len(e.middlewares)+1)
    handlers = append(handlers, e.middlewares...)
    handlers = append(handlers, handle)
    ctx := &Context{
        w:        writer,
        r:        request,
        index:    -1,
        handlers: handlers,
    }
    ctx.Next()}func (e *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    handleF := e.route[req.URL.Path]
    e.handle(w, req, handleF)}func (c *Context) Next() error {
    c.index++
    if c.index < len(c.handlers) {
        return c.handlers[c.index](c)
    }
    return nil}func (c *Context) Write(s string) error {
    _, err := c.w.Write([]byte(s))
    return err}

구현 방법은 매우 간단합니다. 여기서는 사전 및 사후 미들웨어를 지원할 수 있는지 확인합니다.

func TestHttp(t *testing.T) {
    app := NewServer(":8080")

    app.Get("/hello", func(ctx *Context) error {
        fmt.Println("Hello")
        return ctx.Write("Hello")
    })
    app.Use(func(ctx *Context) error {
        fmt.Println("A1")
        return ctx.Next()
    })
    app.Use(func(ctx *Context) error {
        err := ctx.Next()
        fmt.Println("B1")
        return err    })

    app.Run()}

출력:

=== RUN   TestHttp
A1
Hello
B1

총 100줄의 코드만으로 간단한 Http Server를 구현했습니다. 후속 세부 사항으로 이동 Gin의 소스 코드를 살펴보면 주요 초점은 Route와 접두사 트리 구현에 있습니다. 🎜

위 내용은 Go Http Server 프레임워크를 빠르게 구현하는 방법은 무엇입니까? 하나의 기사로 완료의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!