
go-message
Otwarto‑źródłowa biblioteka Go do e‑maili i formatu wiadomości internetowych
Parsuj, generuj i obsługuj nagłówki RFC 5322, MIME oraz Content-Disposition za pomocą strumieniowego API Go.
Czym jest go-message?
go-message to wysokowydajna, strumieniowa biblioteka Go przeznaczona do parsowania i generowania wiadomości e-mail zgodnych z formatem Internet Message Format (RFC 5322), rozszerzeniami MIME (RFC 2045–2047) oraz nagłówkami Content-Disposition (RFC 2183). Umożliwia programistom Go efektywne przetwarzanie treści e-maili bez ładowania całych wiadomości do pamięci, co czyni ją idealną dla skalowalnych serwerów i klientów poczty. Biblioteka obsługuje automatyczne dekodowanie zestawu znaków i integruje się płynnie ze standardową biblioteką Go.
Zbudowany z myślą o modularności i rozszerzalności, go-message zawiera dedykowane podpakiety takie jak `mail` do obsługi poczty na wysokim poziomie oraz `textproto` do parsowania protokołu niskiego poziomu. Jego przyjazny dla DKIM projekt zapewnia zgodność z nowoczesnymi przepływami uwierzytelniania e-maili. Dzięki wbudowanym możliwościom strumieniowania i normalizacji zestawu znaków, go-message upraszcza złożone zadania przetwarzania e-maili, takie jak parsowanie ciał multipart, dekodowanie zakodowanych nagłówków oraz obsługa zagnieżdżonych struktur MIME — wszystko przy zachowaniu efektywności pamięci i wydajności.
Rozpoczęcie pracy z go-message
Aby rozpocząć korzystanie z go-message, zainstaluj go za pomocą `go get` z oficjalnego repozytorium [go-message GitHub](https://github.com/emersion/go-message). Zalecanym podejściem jest użycie modułów Go: uruchom `go get github.com/emersion/go-message` w katalogu projektu. Aby uzyskać wsparcie dekodowania zestawów znaków, dołącz `import _ "github.com/emersion/go-message/charset"`, aby włączyć wszystkie standardowe kodowania. Biblioteka jest lekka, nie ma zależności i płynnie integruje się z istniejącymi aplikacjami Go.
Zainstaluj go-message za pomocą Go Modules
go get github.com/emersion/go-message
# Optional: enable full charset support
import _ "github.com/emersion/go-message/charset"
Strumieniowe parsowanie e-maili
go-message zapewnia parser strumieniowy, który przetwarza wiadomości e-mail stopniowo, bez ładowania całej zawartości do pamięci. Jest to szczególnie korzystne przy obsłudze dużych wiadomości e-mail lub przetwarzania dużej liczby wiadomości. Parser odczytuje nagłówki i części ciała kolejno, umożliwiając programistom inspekcję lub przekazywanie wiadomości w czasie rzeczywistym. Obsługuje zarówno wiadomości zgodne z RFC, jak i niepoprawne, w sposób elegancki, co czyni go odpowiednim dla produkcyjnych serwerów pocztowych. Wykorzystując `io.Reader` Go, biblioteka integruje się naturalnie z operacjami sieciowymi i plikowymi I/O.
Jak parsować wiadomość e-mail za pomocą API strumieniowego?
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
}
Obsługa MIME Multipart
go-message w pełni obsługuje parsowanie i generowanie wiadomości MIME multipart zgodnie z definicjami w RFC 2045 i RFC 2046. Programiści mogą nawigować po złożonych strukturach multipart — w tym zagnieżdżonych częściach — korzystając z intuicyjnych interfejsów API. Biblioteka automatycznie dekoduje kodowania transferowe (np. base64, quoted‑printable) i udostępnia dostęp do poszczególnych części poprzez interfejs `Part`. Umożliwia to solidne tworzenie e‑maili oraz wyodrębnianie załączników, alternatyw HTML/tekstowych i osadzonych zasobów. Jej strumieniowa natura zapewnia efektywne przetwarzanie nawet dużych wiadomości multipart z wieloma częściami.
Jak wyodrębnić części multipart z wiadomości 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
}
Obsługa zestawów znaków i kodowania
go-message zawiera solidną automatyczną obsługę zestawów znaków i kodowania dla nagłówków i treści wiadomości e‑mail. Obsługuje dekodowanie nagłówków zakodowanych zgodnie z RFC 2047 (np. `=?utf-8?B?...?=`) oraz tekstu w różnych zestawach znaków (UTF‑8, ISO‑8859 itp.). Importując opcjonalny pakiet `github.com/emersion/go-message/charset`, programiści uzyskują dostęp do wszystkich zarejestrowanych zestawów znaków IANA poprzez `golang.org/x/text/encoding`. Zapewnia to dokładne renderowanie międzynarodowej treści e‑mail, w tym skryptów nielatinowych i specjalnych symboli, bez ręcznego wykrywania lub konwersji zestawu znaków.
Jak zdekodować nagłówek zakodowany w zestawie znaków?
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
}
Podpisywanie wiadomości przyjazne DKIM
go-message został zaprojektowany z myślą o przyjazności dla DKIM, umożliwiając płynną integrację z przepływami pracy dotyczącymi kryptograficznego podpisywania i weryfikacji. Jego parser strumieniowy zachowuje integralność struktury wiadomości, pozwalając podpisującym na podpisanie jedynie kanonizowanego ciała i wybranych nagłówków bez ponownego kodowania. Biblioteka unika niepotrzebnych transformacji (np. normalizacji zakończeń linii), które mogłyby uszkodzić podpisy DKIM. Programiści mogą budować potoki podpisywania e‑mail, łącząc go-message z bibliotekami takimi jak `github.com/emersion/go-dkim`, zapewniając zgodność z RFC 6376 dotyczącą uwierzytelniania wiadomości opartego na domenie.
Jak przygotować wiadomość do podpisu 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
}
