Golang для веб-разработки: высокопроизводительные сервера и API

package main

import (
"fmt"
"net/http"
)

func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Привет, это мой первый golang веб-сервер и rest api!")
})

fmt.Println("Сервер запущен на http://localhost:8080")
http.ListenAndServe(":8080", nil)
}

package main

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

type Message struct {
Text string `json:"text"`
}

func main() {
// Обработчик для GET-запросов
http.HandleFunc("/api/hello", func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}

message := Message{Text: "Привет от golang веб-сервера и rest api!"}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(message)
})

// Обработчик для POST-запросов
http.HandleFunc("/api/echo", func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}

var message Message
if err := json.NewDecoder(r.Body).Decode(&message); err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}

w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(message)
})

fmt.Println("Сервер запущен на http://localhost:8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}

type apiHandler struct {
// Здесь могут быть зависимости, например, доступ к БД
db *sql.DB
}

func (h *apiHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path

switch {
case path == "/api/users" && r.Method == http.MethodGet:
h.getUsers(w, r)
case path == "/api/users" && r.Method == http.MethodPost:
h.createUser(w, r)
default:
w.WriteHeader(http.StatusNotFound)
}
}

func (h *apiHandler) getUsers(w http.ResponseWriter, r *http.Request) {
// Логика получения пользователей из БД
// ...
}

func (h *apiHandler) createUser(w http.ResponseWriter, r *http.Request) {
// Логика создания пользователя
// ...
}

// В функции main:
handler := &apiHandler{db: database}
http.Handle("/api/", handler)

package main

import (
"encoding/json"
"fmt"
"log"
"net/http"
"strconv"
"strings"
"sync"
)

// Модель данных
type Task struct {
ID int `json:"id"`
Title string `json:"title"`
Description string `json:"description"`
Completed bool `json:"completed"`
}

// Хранилище данных (для простоты используем in-memory)
type TaskStore struct {
sync.RWMutex
tasks map[int]Task
nextTaskID int
}

// Создание нового хранилища
func NewTaskStore() *TaskStore {
return &TaskStore{
tasks: make(map[int]Task),
nextTaskID: 1,
}
}

// Метод для добавления задачи
func (s *TaskStore) Add(task Task) Task {
s.Lock()
defer s.Unlock()

task.ID = s.nextTaskID
s.nextTaskID++
s.tasks[task.ID] = task

return task
}

// Метод для получения всех задач
func (s *TaskStore) GetAll() []Task {
s.RLock()
defer s.RUnlock()

allTasks := make([]Task, 0, len(s.tasks))
for _, task := range s.tasks {
allTasks = append(allTasks, task)
}

return allTasks
}

// Метод для получения задачи по ID
func (s *TaskStore) Get(id int) (Task, bool) {
s.RLock()
defer s.RUnlock()

task, exists := s.tasks[id]
return task, exists
}

// Метод для обновления задачи
func (s *TaskStore) Update(id int, task Task) (Task, bool) {
s.Lock()
defer s.Unlock()

if _, exists := s.tasks[id]; !exists {
return Task{}, false
}

task.ID = id
s.tasks[id] = task

return task, true
}

// Метод для удаления задачи
func (s *TaskStore) Delete(id int) bool {
s.Lock()
defer s.Unlock()

if _, exists := s.tasks[id]; !exists {
return false
}

delete(s.tasks, id)
return true
}

// TaskHandler обрабатывает HTTP-запросы к API задач
type TaskHandler struct {
store *TaskStore
}

// Функция-обработчик всех запросов к API
func (h *TaskHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")

// Извлечение ID из пути
path := strings.Trim(r.URL.Path, "/")
pathParts := strings.Split(path, "/")

if len(pathParts) < 2 {
http.Error(w, "Некорректный путь", http.StatusBadRequest)
return
}

if pathParts[0] != "api" || pathParts[1] != "tasks" {
http.Error(w, "Неизвестный ресурс", http.StatusNotFound)
return
}

// Запрос к коллекции /api/tasks
if len(pathParts) == 2 {
switch r.Method {
case http.MethodGet:
h.getTasks(w, r)
case http.MethodPost:
h.createTask(w, r)
default:
http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
}
return
}

// Запрос к элементу /api/tasks/{id}
if len(pathParts) == 3 {
id, err := strconv.Atoi(pathParts[2])
if err != nil {
http.Error(w, "Некорректный ID", http.StatusBadRequest)
return
}

switch r.Method {
case http.MethodGet:
h.getTask(w, r, id)
case http.MethodPut:
h.updateTask(w, r, id)
case http.MethodDelete:
h.deleteTask(w, r, id)
default:
http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
}
return
}

http.Error(w, "Некорректный путь", http.StatusBadRequest)
}

// Получение списка всех задач
func (h *TaskHandler) getTasks(w http.ResponseWriter, r *http.Request) {
tasks := h.store.GetAll()
json.NewEncoder(w).Encode(tasks)
}

// Создание новой задачи
func (h *TaskHandler) createTask(w http.ResponseWriter, r *http.Request) {
var task Task
if err := json.NewDecoder(r.Body).Decode(&task); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}

// Валидация
if task.Title == "" {
http.Error(w, "Поле Title обязательно", http.StatusBadRequest)
return
}

createdTask := h.store.Add(task)
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(createdTask)
}

// Получение задачи по ID
func (h *TaskHandler) getTask(w http.ResponseWriter, r *http.Request, id int) {
task, exists := h.store.Get(id)
if !exists {
http.Error(w, "Задача не найдена", http.StatusNotFound)
return
}

json.NewEncoder(w).Encode(task)
}

// Обновление задачи
func (h *TaskHandler) updateTask(w http.ResponseWriter, r *http.Request, id int) {
var task Task
if err := json.NewDecoder(r.Body).Decode(&task); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}

// Валидация
if task.Title == "" {
http.Error(w, "Поле Title обязательно", http.StatusBadRequest)
return
}

updatedTask, exists := h.store.Update(id, task)
if !exists {
http.Error(w, "Задача не найдена", http.StatusNotFound)
return
}

json.NewEncoder(w).Encode(updatedTask)
}

// Удаление задачи
func (h *TaskHandler) deleteTask(w http.ResponseWriter, r *http.Request, id int) {
if deleted := h.store.Delete(id); !deleted {
http.Error(w, "Задача не найдена", http.StatusNotFound)
return
}

w.WriteHeader(http.StatusNoContent)
}

// Основная функция
func main() {
taskStore := NewTaskStore()
taskHandler := &TaskHandler{store: taskStore}

// Демонстрационные данные
taskStore.Add(Task{Title: "Изучить Golang", Description: "Освоить основы языка Go", Completed: false})
taskStore.Add(Task{Title: "Создать REST API", Description: "Разработать API на Go", Completed: false})

http.Handle("/api/tasks/", taskHandler)
http.Handle("/api/tasks", taskHandler)

fmt.Println("REST API сервер запущен на http://localhost:8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
"github.com/gin-gonic/gin"
"net/http"
)

type Task struct {
ID int `json:"id"`
Title string `json:"title" binding:"required"`
Completed bool `json:"completed"`
}

var tasks = []Task{
{ID: 1, Title: "Изучить Gin Framework", Completed: false},
{ID: 2, Title: "Создать REST API", Completed: false},
}

func main() {
r := gin.Default() // Создает маршрутизатор с логгером и recovery middleware

// Группа маршрутов для API
api := r.Group("/api")
{
api.GET("/tasks", getTasks)
api.GET("/tasks/:id", getTaskByID)
api.POST("/tasks", createTask)
api.PUT("/tasks/:id", updateTask)
api.DELETE("/tasks/:id", deleteTask)
}

r.Run(":8080") // Запуск сервера на порту 8080
}

func getTasks(c *gin.Context) {
c.JSON(http.StatusOK, tasks)
}

func getTaskByID(c *gin.Context) {
id := c.Param("id")

for _, task := range tasks {
if string(task.ID) == id {
c.JSON(http.StatusOK, task)
return
}
}

c.JSON(http.StatusNotFound, gin.H{"message": "Task not found"})
}

func createTask(c *gin.Context) {
var newTask Task

// Валидация и привязка JSON к структуре
if err := c.ShouldBindJSON(&newTask); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}

// Установка ID для новой задачи
newTask.ID = len(tasks) + 1
tasks = append(tasks, newTask)

c.JSON(http.StatusCreated, newTask)
}

func updateTask(c *gin.Context) {
// Реализация обновления задачи
// ...
}

func deleteTask(c *gin.Context) {
// Реализация удаления задачи
// ...
}

package main

import (
"github.com/labstack/echo/v4"
"github.com/labstack/echo/v4/middleware"
"net/http"
"strconv"
)

func main() {
e := echo.New()

// Middleware
e.Use(middleware.Logger())
e.Use(middleware.Recover())

// Маршруты
e.GET("/api/tasks", getTasks)
e.POST("/api/tasks", createTask)
e.GET("/api/tasks/:id", getTask)

e.Logger.Fatal(e.Start(":8080"))
}

func getTasks(c echo.Context) error {
return c.JSON(http.StatusOK, tasks)
}

func getTask(c echo.Context) error {
id, err := strconv.Atoi(c.Param("id"))
if err != nil {
return c.JSON(http.StatusBadRequest, map[string]string{
"error": "Invalid ID",
})
}

// Поиск задачи по ID
// ...

return c.JSON(http.StatusOK, task)
}

func createTask(c echo.Context) error {
var task Task

if err := c.Bind(&task); err != nil {
return c.JSON(http.StatusBadRequest, map[string]string{
"error": err.Error(),
})
}

// Валидация
if task.Title == "" {
return c.JSON(http.StatusBadRequest, map[string]string{
"error": "Title is required",
})
}

// Сохранение задачи
// ...

return c.JSON(http.StatusCreated, task)
}

package main

import (
"fmt"
"net/http"
"strings"
"time"

"github.com/dgrijalva/jwt-go"
)

var jwtKey = []byte("your_secret_key")

// JWTMiddleware проверяет JWT токен в заголовке Authorization
func JWTMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Получение токена из заголовка Authorization
authHeader := r.Header.Get("Authorization")
if authHeader == "" {
http.Error(w, "Отсутствует авторизационный токен", http.StatusUnauthorized)
return
}

// Формат токена: "Bearer {token}"
tokenParts := strings.Split(authHeader, " ")
if len(tokenParts) != 2 || tokenParts[0] != "Bearer" {
http.Error(w, "Некорректный формат токена", http.StatusUnauthorized)
return
}

tokenString := tokenParts[1]

// Парсинг и валидация токена
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
// Проверка метода подписи
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, fmt.Errorf("неожиданный метод подписи: %v", token.Header["alg"])
}

return jwtKey, nil
})

if err != nil {
http.Error(w, "Недействительный токен", http.StatusUnauthorized)
return
}

if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
// Проверка срока действия токена
if exp, ok := claims["exp"].(float64); ok && int64(exp) < time.Now().Unix() {
http.Error(w, "Срок действия токена истек", http.StatusUnauthorized)
return
}

// Добавление информации о пользователе в контекст запроса
ctx := r.Context()
// Здесь можно добавить данные из токена в контекст

// Передача запроса следующему обработчику
next.ServeHTTP(w, r.WithContext(ctx))
return
}

http.Error(w, "Недействительный токен", http.StatusUnauthorized)
})
}

func MetricsMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()

// Оборачиваем ResponseWriter для доступа к статус-коду
wrapper := NewResponseWriterWrapper(w)

// Выполняем запрос
next.ServeHTTP(wrapper, r)

// Вычисляем время обработки
duration := time.Since(start)

// Логируем метрики
log.Printf(
"Method: %s, Path: %s, Status: %d, Duration: %s",
r.Method,
r.URL.Path,
wrapper.Status(),
duration,
)

// Здесь можно отправить метрики в систему мониторинга
// например, Prometheus
})
}