go-message

 
 

Отворена Go библиотека за имейли и Интернет съобщителен формат

Парсирайте, генерирайте и обработвайте заглавки RFC 5322, MIME и Content-Disposition чрез потоков Go API.

Какво е go-message?

go-message е високопроизводителна, потокова Go библиотека, създадена за анализиране и генериране на имейл съобщения, съответстващи на Интернет съобщителен формат (RFC 5322), MIME разширения (RFC 2045–2047) и заглавки Content-Disposition (RFC 2183). Тя позволява на Go разработчиците ефективно да обработват имейл съдържание без да зареждат цялите съобщения в паметта, което я прави идеална за мащабируеми пощенски сървъри и клиенти. Библиотеката поддържа автоматично декодиране на набори от знаци и се интегрира безпроблемно със стандартната библиотека на Go.

Създадена с мисъл за модулност и разширяемост, go-message включва специализирани подпакети като `mail` за обработка на имейли на високо ниво и `textproto` за парсиране на протоколи на ниско ниво. Дизайнът ѝ, ориентиран към DKIM, осигурява съвместимост с модерните работни процеси за автентикация на имейли. С вградените възможности за поточно обработване и нормализация на наборите от знаци, go-message опростява сложни задачи по обработка на имейли, като парсиране на multipart тела, декодиране на кодирани заглавки и работа с вложени MIME структури — всичко това, като запазва ефективността на паметта и производителността.

Previous Next

Започване с go-message

За да започнете да използвате go-message, инсталирайте го чрез `go get` от официалното хранилище [go-message GitHub](https://github.com/emersion/go-message). Препоръчителният подход е да използвате Go модули: изпълнете `go get github.com/emersion/go-message` в директорията на вашия проект. За поддръжка на декодиране на набори от знаци, включете `import _ "github.com/emersion/go-message/charset"`, за да активирате всички стандартни кодирания. Библиотеката е лека, без зависимости и се интегрира плавно в съществуващи Go приложения.

Инсталирайте go-message чрез Go Modules

go get github.com/emersion/go-message
# Optional: enable full charset support
import _ "github.com/emersion/go-message/charset"

Парсиране на имейли в поток

go-message предоставя потоков парсер, който обработва имейл съобщения инкрементно, без да зарежда цялото съдържание в паметта. Това е особено полезно при работа с големи имейли или обработка на голям обем поща. Парсерът чете заглавията и частите от тялото последователно, позволявайки на разработчиците да инспектират или препращат съобщения в реално време. Той поддържа както RFC‑съвместими, така и неправилно форматирани съобщения по елегантен начин, което го прави подходящ за продукционни пощенски сървъри. Чрез използване на `io.Reader` от Go, библиотеката се интегрира естествено с мрежови и файлови I/O операции.

Как да парсираме имейл съобщение чрез Streaming API?

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
}

Обработка на MIME Multipart

go-message напълно поддържа парсиране и генериране на MIME multipart съобщения, както е дефинирано в RFC 2045 и RFC 2046. Разработчиците могат да навигират сложни multipart структури — включително вложени части — използвайки интуитивни API‑та. Библиотеката автоматично декодира трансферните кодирания (например base64, quoted-printable) и предоставя достъп до отделните части чрез интерфейса `Part`. Това позволява стабилно съставяне на имейли и извличане на прикачени файлове, HTML/текст алтернативи и вградени ресурси. Нейната потокова природа осигурява ефективна обработка дори за големи multipart съобщения с много части.

Как да извлечете multipart части от имейл?

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
}

Поддръжка на набор от знаци и кодиране

go-message включва надеждна автоматична обработка на набори от знаци и кодиране за заглавията и съдържанието на имейлите. Той поддържа декодиране на RFC 2047‑кодираните заглавия (например `=?utf-8?B?...?=`) и текст в тялото в различни набори от знаци (UTF-8, ISO-8859 и др.). Чрез импортиране на опционалния пакет `github.com/emersion/go-message/charset`, разработчиците получават достъп до всички регистрирани IANA набори от знаци чрез `golang.org/x/text/encoding`. Това осигурява точно визуализиране на международно имейлно съдържание, включително нелатински скриптове и специални символи, без ръчно откриване или конвертиране на набори от знаци.

Как да декодирате заглавка, кодирана с набор от знаци?

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
}

Подписване на съобщения, съвместимо с DKIM

go-message е проектиран да бъде съвместим с DKIM, позволявайки безпроблемна интеграция с процеси за криптографско подписване и проверка. Неговият потоков парсер запазва целостта на структурата на съобщението, позволявайки на подписващите да подпишат само канонизираното тяло и избрани заглавия без повторно кодиране. Библиотеката избягва ненужни трансформации (например нормализация на край на ред), които биха могли да нарушат DKIM подписи. Разработчиците могат да изградят процеси за подписване на имейли, като комбинират go-message с библиотеки като `github.com/emersion/go-dkim`, осигурявайки съответствие с RFC 6376 за удостоверяване на съобщения, базирано на домейни.

Как да подготвите съобщение за 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
}
 Български