Создание HTTP-сервера

package main

import "net/http"

func main() {
    err := http.ListenAndServe(`:8080`, nil)
    if err != nil {
        panic(err)
    }
} 

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

type ResponseWriter interface {
    Header() Header
    Write([]byte) (int, error)
    WriteHeader(statusCode int)
} 

package main

import "net/http"

type MyHandler struct{}

func (h MyHandler) ServeHTTP(res http.ResponseWriter, req *http.Request) {
    data := []byte("Привет!")
    res.Write(data)
}

func main() {
    var h MyHandler

    err := http.ListenAndServe(`:8080`, h)
    if err != nil {
        panic(err)
    }
} 

package main

import "net/http"

func mainPage(res http.ResponseWriter, req *http.Request) {
    res.Write([]byte("Привет!"))
}

func apiPage(res http.ResponseWriter, req *http.Request) {
    res.Write([]byte("Это страница /api."))
}

func main() {
    http.HandleFunc(`/api`, apiPage)
    http.HandleFunc(`/`, mainPage)

    err := http.ListenAndServe(`:8080`, nil)
    if err != nil {
        panic(err)
    }
} 

    // иcпользование этого фрагмента приведёт к ошибке
    // panic: http: multiple registrations for /api
    http.HandleFunc(`/api`, apiPage)
    http.HandleFunc(`/`, mainPage)
    http.HandleFunc(`/api`, mainPage) 

    // этот вариант будет работать так же, 
    // как вариант в примере
    http.HandleFunc(`/`, mainPage)
    http.HandleFunc(`/api`, apiPage) 

mux := http.NewServeMux()
mux.HandleFunc(`/api/auth`, authHandler)
mux.HandleFunc(`/api/`, apiHandler)
// ...
err := http.ListenAndServe(`:8080`, mux)
// ... 

type Request struct {
    // указаны некоторые поля структуры
    Method        string
    URL           *url.URL
    Header        Header
    Body          io.ReadCloser
    ContentLength int64
    Host          string
    // ...
} 

const (
    MethodGet     = "GET"
    MethodHead    = "HEAD"
    MethodPost    = "POST"
    MethodPut     = "PUT"
    MethodPatch   = "PATCH"
    MethodDelete  = "DELETE"
    MethodConnect = "CONNECT"
    MethodOptions = "OPTIONS"
    MethodTrace   = "TRACE"
) 

func GetHandler(w http.ResponseWriter, r *http.Request) {
   // этот обработчик принимает только запросы, отправленные методом GET
   if r.Method != http.MethodGet {
      http.Error(w, "Only GET requests are allowed!", http.StatusMethodNotAllowed)
       return
   }
   // продолжаем обработку запроса
   // ...
} 

package main

import (
    "fmt"
    "net/http"
)

func mainPage(res http.ResponseWriter, req *http.Request) {
    body := fmt.Sprintf("Method: %s\r\n", req.Method)
    body += "Header ===============\r\n"
    for k, v := range req.Header {
        body += fmt.Sprintf("%s: %v\r\n", k, v)
    }
    body += "Query parameters ===============\r\n"
    for k, v := range req.URL.Query() {
        body += fmt.Sprintf("%s: %v\r\n", k, v)
    }
    res.Write([]byte(body))
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc(`/`, mainPage)

    err := http.ListenAndServe(`:8080`, mux)
    if err != nil {
        panic(err)
    }
} 

type ResponseWriter interface {
    Header() Header
    Write([]byte) (int, error)
    WriteHeader(statusCode int)
} 

StatusOK                  = 200
StatusBadRequest          = 400
StatusUnauthorized        = 401
StatusForbidden           = 403
StatusNotFound            = 404
StatusMethodNotAllowed    = 405
StatusInternalServerError = 500    

io.WriteString(res, "Привет!")
fmt.Fprint(res, "Привет!") 

type Subj struct {
   Product string `json:"name"`
   Price   int    `json:"price"`
}

func JSONHandler(w http.ResponseWriter, req *http.Request) {
    // собираем данные
    subj := Subj{"Milk", 50}
    // кодируем в JSON
    resp, err := json.Marshal(subj)
    if err != nil {
        http.Error(w, err.Error(), 500)
        return
    }
    // устанавливаем заголовок Content-Type
    // для передачи клиенту информации, кодированной в JSON
    w.Header().Set("content-type", "application/json")
    // устанавливаем код 200
    w.WriteHeader(http.StatusOK)
    // пишем тело ответа
    w.Write(resp)
} 

package main

import (
    "io"
    "net/http"
)

const form = `<html>
    <head>
    <title></title>
    </head>
    <body>
        <form action="/" method="post">
            <label>Логин</label><input type="text" name="login">
            <label>Пароль<input type="password" name="password">
            <input type="submit" value="Login">
        </form>
    </body>
</html>`

func Auth(login, password string) bool {
    return login == `guest` && password == `demo`
}

func mainPage(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPost {
        login := r.FormValue("login")
        password := r.FormValue("password")
        if Auth(login, password) {
            io.WriteString(w, "Добро пожаловать!")
        } else {
            http.Error(w, "Неверный логин или пароль", http.StatusUnauthorized)
        }
        return
    } else {
        io.WriteString(w, form)
    }
}

func main() {
    err := http.ListenAndServe(`:8080`, http.HandlerFunc(mainPage))
    if err != nil {
        panic(err)
    }
} 

// middleware принимает параметром Handler и возвращает тоже Handler.
func middleware(next http.Handler) http.Handler {
    // получаем Handler приведением типа http.HandlerFunc
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // здесь пишем логику обработки
        // например, разрешаем запросы cross-domain
        // w.Header().Set("Access-Control-Allow-Origin", "*")
        // ...
        // замыкание: используем ServeHTTP следующего хендлера
        next.ServeHTTP(w, r)
    })
} 

func rootHandle(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Привет"))
}

func main() {
   http.Handle("/", middleware(http.HandlerFunc(rootHandle)))
   //...
} 

type Middleware func(http.Handler) http.Handler

func Conveyor(h http.Handler, middlewares ...Middleware) http.Handler {
    for _, middleware := range middlewares {
        h = middleware(h)
    }
    return h
} 

func main() {
    http.Handle("/", Conveyor(http.HandlerFunc(rootHandle), middleware1, middleware2, middleware3))
    // ...
} 

func redirect(w http.ResponseWriter, r *http.Request) {
    http.Redirect(w, r, "https://yandex.ru/", http.StatusMovedPermanently)
}

func main() {
    http.HandleFunc("/search/", redirect)
    log.Fatal(http.ListenAndServe(":8080", nil))
} 

http.Handle("/dummy", http.RedirectHandler("https://google.com", http.StatusMovedPermanently)) 

type FileSystem interface {
    Open(name string) (File, error)
} 

package main

import (
    "net/http"
)

func main() {
   // простейший сервер, которому доступны все файлы в поддиректории static
    err := http.ListenAndServe(":8080", http.FileServer(http.Dir("./static")))
    if err != nil {
        panic(err)
    }
} 

fs := http.FileServer(http.Dir("./static"))
http.Handle("/assets/", http.StripPrefix("/assets/", fs)) 

http.HandleFunc("/favicon.ico", func(w http.ResponseWriter, r *http.Request){
   http.ServeFile(w, r, "./public/favicon.ico")
}) 

// пакеты исполняемых приложений должны называться main
package main

import (
    "net/http"
)

// функция main вызывается автоматически при запуске приложения
func main() {
    if err := run(); err != nil {
        panic(err)
    }
}

// функция run будет полезна при инициализации зависимостей сервера перед запуском
func run() error {
    return http.ListenAndServe(`:8080`, http.HandlerFunc(webhook))
}

// функция webhook — обработчик HTTP-запроса
func webhook(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        // разрешаем только POST-запросы
        w.WriteHeader(http.StatusMethodNotAllowed)
        return
    }

    // установим правильный заголовок для типа данных
    w.Header().Set("Content-Type", "application/json")
    // пока установим ответ-заглушку, без проверки ошибок
    _, _ = w.Write([]byte(`
      {
        "response": {
          "text": "Извините, я пока ничего не умею"
        },
        "version": "1.0"
      }
    `))
}