С каким типом данных умеет работать GIN

Работа GIN с типами данных

GIN — это популярный HTTP-фреймворк для Go, который предоставляет удобные средства для обработки входящих запросов и формирования ответов. Его ключевой особенностью является способность работать с различными типами данных как на уровне входящих запросов (парсинг и валидация), так и на уровне исходящих ответов (сериализация). Давайте подробно разберём эти возможности.

Основные типы данных во входящих запросах

GIN умеет автоматически парсить и привязывать (биндить) данные из различных источников запроса к структурам Go. Это реализуется через методы Bind, ShouldBind, BindJSON, ShouldBindJSON и другие.

1. JSON (наиболее распространённый вариант)

    GIN может десериализовать JSON-тело запроса в структуру Go. Поддерживаются вложенные объекты, массивы, все базовые типы.

```go
package main

import "github.com/gin-gonic/gin"

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name" binding:"required"`
    Email string `json:"email"`
}

func main() {
    r := gin.Default()
    r.POST("/users", func(c *gin.Context) {
        var user User
        // Биндинг JSON из тела запроса в структуру User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            return
        }
        // Далее работаем с заполненной структурой user
        c.JSON(200, gin.H{"status": "user created", "id": user.ID})
    })
    r.Run()
}
```

2. Form Data (application/x-www-form-urlencoded или multipart/form-data)

    Используется в HTML-формах и загрузке файлов. Для биндинга используется `ShouldBind` или специальные методы.

```go
type LoginForm struct {
    User     string `form:"username" binding:"required"`
    Password string `form:"password" binding:"required"`
}

r.POST("/login", func(c *gin.Context) {
    var form LoginForm
    if err := c.ShouldBind(&form); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    // form.User, form.Password теперь содержат данные
})
```

3. Query Parameters (URL-параметры)

    Параметры из строки запроса (например, `/search?q=gin&page=2`) также могут быть привязаны к структуре.

```go
type SearchQuery struct {
    Query string `form:"q"` // Тег `form` используется для query-параметров
    Page  int    `form:"page"`
}

r.GET("/search", func(c *gin.Context) {
    var query SearchQuery
    if err := c.ShouldBindQuery(&query); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    // query.Query и query.Page готовы к использованию
})
```

4. URI Parameters (Path parameters)

    Параметры, извлечённые из самого пути маршрута, доступны через методы `c.Param()` или могут быть привязаны с помощью тега `uri`.

```go
r.GET("/users/:id", func(c *gin.Context) {
    id := c.Param("id") // Простое получение строки
    // ...
})

// Биндинг в структуру
type UserURI struct {
    ID int `uri:"id" binding:"required"`
}

r.GET("/users/:id", func(c *gin.Context) {
    var params UserURI
    if err := c.ShouldBindUri(&params); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    // params.ID содержит int, полученный из пути
})
```

5. Заголовки (Headers)

    GIN может извлекать отдельные заголовки через `c.GetHeader()` или биндить набор заголовков в структуру с тегом `header`.

```go
type ApiHeaders struct {
    ApiKey   string `header:"X-API-Key" binding:"required"`
    ClientID string `header:"X-Client-ID"`
}

r.GET("/secure", func(c *gin.Context) {
    var headers ApiHeaders
    if err := c.ShouldBindHeader(&headers); err != nil {
        c.JSON(401, gin.H{"error": "unauthorized"})
        return
    }
    // Проверяем headers.ApiKey
})
```

6. Файлы (Multipart/Form-Data)

    Для загрузки файлов используется метод `c.FormFile()` для одного файла или `c.MultipartForm()` для нескольких.

Типы данных в исходящих ответах

GIN гибко сериализует данные для отправки клиенту.

1. JSON (стандартный формат для REST API)

    Метод `c.JSON()` автоматически сериализует любую структуру Go в JSON, устанавливая правильный заголовок `Content-Type: application/json`. Он работает со:
    *   Структурами и срезами структур
    *   Картами (`map[string]interface{}`)
    *   Встроенным типом `gin.H` (это просто псевдоним для `map[string]any`)
    *   Базовыми типами (строками, числами, булевыми)

```go
c.JSON(200, gin.H{"user": "admin", "active": true})
```

2. XML, YAML, ProtoBuf

    GIN имеет встроенные методы для других форматов сериализации:
    *   `c.XML()` — для XML.
    *   `c.YAML()` — для YAML.
    *   `c.ProtoBuf()` — для Protocol Buffers (требует предварительной генерации структур из `.proto` файлов).

1. Строки и HTML

    *   `c.String()` — отправляет простой текст.
    *   `c.Data()` — отправляет сырые данные (байты) с произвольным Content-Type.
    *   Для HTML обычно используется шаблонизация с `c.HTML()` и загрузкой шаблонов через `gin.LoadHTMLGlob()`.

1. Потоки (Streaming)

    Можно напрямую писать в `c.Writer` (реализующий интерфейс `http.ResponseWriter`) для потоковой передачи данных, например, для **Server-Sent Events (SSE)**.

Валидация и кастомные типы

Одной из сильнейших сторон GIN является интеграция с библиотекой валидации go-playground/validator. Используя тег binding, можно накладывать ограничения на поля.

type Product struct {
    SKU    string  `json:"sku" binding:"required,alphanum"`
    Price  float64 `json:"price" binding:"required,gt=0"`
    InStock bool    `json:"in_stock"`
}

GIN также поддерживает работу с кастомными типами данных, если для них реализован интерфейс encoding.TextUnmarshaler (для биндинга) или encoding.TextMarshaler (для сериализации в JSON/XML).

Итог: GIN — это мощный и гибкий инструмент, который умеет работать практически со всеми стандартными типами данных, встречающимися в веб-разработке: от простых строк и чисел до сложных JSON-структур и потоковых данных. Его архитектура, построенная вокруг биндинга в структуры, делает код чище, безопаснее и проще в поддержке.