
go-message
Biblioteca Go de Código Aberto para Email e Formato de Mensagem da Internet
Analise, Gere e Manipule Cabeçalhos RFC 5322, MIME e Content-Disposition via API Go de Streaming.
O que é go-message?
go-message é uma biblioteca Go de alto desempenho e streaming projetada para analisar e gerar mensagens de e‑mail em conformidade com o Formato de Mensagem da Internet (RFC 5322), extensões MIME (RFC 2045–2047) e cabeçalhos Content‑Disposition (RFC 2183). Ela permite que desenvolvedores Go processem o conteúdo de e‑mail de forma eficiente sem carregar mensagens completas na memória, tornando‑a ideal para servidores e clientes de e‑mail escaláveis. A biblioteca oferece decodificação automática de charset e integra‑se perfeitamente à biblioteca padrão do Go.
Construído com modularidade e extensibilidade em mente, o go-message inclui subpacotes dedicados como `mail` para manipulação de e‑mail em alto nível e `textproto` para análise de protocolos de baixo nível. Seu design compatível com DKIM garante compatibilidade com fluxos de trabalho modernos de autenticação de e‑mail. Com recursos de streaming incorporados e normalização de charset, o go-message simplifica tarefas complexas de processamento de e‑mail, como analisar corpos multipart, decodificar cabeçalhos codificados e lidar com estruturas MIME aninhadas — tudo isso mantendo eficiência de memória e desempenho.
Começando com go-message
Para começar a usar o go-message, instale‑o via `go get` a partir do repositório oficial do [go-message GitHub](https://github.com/emersion/go-message). A abordagem recomendada é usar módulos Go: execute `go get github.com/emersion/go-message` no diretório do seu projeto. Para suporte à decodificação de charset, inclua `import _ "github.com/emersion/go-message/charset"` para habilitar todas as codificações padrão. A biblioteca é leve, sem dependências e integra‑se perfeitamente a aplicações Go existentes.
Instale go-message via Go Modules
go get github.com/emersion/go-message
# Optional: enable full charset support
import _ "github.com/emersion/go-message/charset"
Análise de E-mail em Streaming
go-message fornece um analisador de streaming que processa mensagens de e‑mail de forma incremental sem carregar todo o conteúdo na memória. Isso é especialmente benéfico para lidar com e‑mails grandes ou processamento de correio em alto volume. O analisador lê cabeçalhos e partes do corpo sequencialmente, permitindo que os desenvolvedores inspecionem ou encaminhem mensagens em tempo real. Ele suporta tanto mensagens compatíveis com RFC quanto mensagens malformadas de maneira elegante, tornando‑o adequado para servidores de correio em produção. Ao aproveitar o `io.Reader` do Go, a biblioteca integra‑se naturalmente com operações de rede e I/O de arquivos.
Como analisar uma mensagem de e‑mail via API de streaming?
import (
"bytes"
"github.com/emersion/go-message"
)
func parseEmail(data []byte) error {
r := bytes.NewReader(data)
m, err := message.Read(r)
if err != nil {
return err
}
// Access headers and body parts
return nil
}
Manipulação de MIME Multipart
go-message oferece suporte total ao parsing e à geração de mensagens MIME multipartes conforme definido nas RFC 2045 e RFC 2046. Os desenvolvedores podem navegar em estruturas multipartes complexas — incluindo partes aninhadas — usando APIs intuitivas. A biblioteca decodifica automaticamente codificações de transferência (por exemplo, base64, quoted‑printable) e fornece acesso às partes individuais via interface `Part`. Isso permite uma composição de e‑mail robusta e a extração de anexos, alternativas HTML/texto e recursos incorporados. Sua natureza de streaming garante um manuseio eficiente mesmo para mensagens multipartes grandes com muitas partes.
Como extrair partes multipart de um e‑mail?
import (
"github.com/emersion/go-message"
"github.com/emersion/go-message/textproto"
)
func extractParts(m *message.Message) error {
if m.Multipart() {
for _, p := range m.Parts() {
// Process each part (e.g., text, attachment)
mediaType, params, _ := p.Header.MediaType()
if mediaType == "text/plain" {
// Read plain text content
content, _ := io.ReadAll(p.Body)
}
}
}
return nil
}
Suporte a Conjunto de Caracteres e Codificação
go-message inclui um tratamento robusto e automático de charset e codificação para cabeçalhos e conteúdo do corpo de e‑mail. Ele suporta a decodificação de cabeçalhos codificados conforme RFC 2047 (por exemplo, `=?utf-8?B?...?=`) e texto do corpo em vários charsets (UTF-8, ISO-8859, etc.). Ao importar o pacote opcional `github.com/emersion/go-message/charset`, os desenvolvedores obtêm acesso a todos os charsets IANA registrados via `golang.org/x/text/encoding`. Isso garante a renderização precisa de conteúdo de e‑mail internacional, incluindo scripts não latinos e símbolos especiais, sem necessidade de detecção ou conversão manual de charset.
Como decodificar um cabeçalho codificado em charset?
import (
"github.com/emersion/go-message"
_ "github.com/emersion/go-message/charset" // Enable all charsets
)
func decodeSubject(m *message.Message) (string, error) {
subject, err := m.Header.Get("Subject")
if err != nil {
return "", err
}
// Automatically decoded using registered charsets
return subject, nil
}
Assinatura de Mensagens Compatível com DKIM
go-message foi projetado para ser compatível com DKIM, permitindo integração perfeita com fluxos de trabalho de assinatura e verificação criptográfica. Seu analisador em streaming preserva a integridade da estrutura da mensagem, permitindo que os assinantes assinem apenas o corpo canonizado e cabeçalhos selecionados sem re‑codificação. A biblioteca evita transformações desnecessárias (por exemplo, normalização de quebras de linha) que poderiam quebrar assinaturas DKIM. Os desenvolvedores podem construir pipelines de assinatura de e‑mail combinando go-message com bibliotecas como `github.com/emersion/go-dkim`, garantindo conformidade com o RFC 6376 para autenticação de mensagens baseada em domínio.
Como preparar uma mensagem para assinatura DKIM?
import (
"bytes"
"github.com/emersion/go-message"
"github.com/emersion/go-message/textproto"
)
func prepareForDKIM(m *message.Message) (*bytes.Buffer, error) {
var buf bytes.Buffer
// Write canonicalized headers and body
h := m.Header
h.WriteTo(&buf)
buf.WriteString("\r\n")
if _, err := io.Copy(&buf, m.Body); err != nil {
return nil, err
}
return &buf, nil
}
