1. Produkter
  2.   E-post
  3.   GO
  4.   go-message

go-message

 
 

Öppen källkod Go‑bibliotek för e‑post och Internet Message Format

Parsa, generera och hantera RFC 5322-, MIME- och Content‑Disposition‑rubriker via ett strömmande Go‑API.

Vad är go-message?

go-message är ett högpresterande, strömmande Go‑bibliotek utformat för att parsra och generera e‑postmeddelanden som följer Internet Message Format (RFC 5322), MIME‑tillägg (RFC 2045–2047) och Content‑Disposition‑rubriker (RFC 2183). Det gör det möjligt för Go‑utvecklare att effektivt bearbeta e‑postinnehåll utan att ladda hela meddelanden i minnet, vilket gör det idealiskt för skalbara e‑postservrar och klienter. Biblioteket stöder automatisk avkodning av teckenkodning och integreras sömlöst med Go:s standardbibliotek.

Byggt med modularitet och utbyggbarhet i åtanke, inkluderar go-message dedikerade underpaket som `mail` för hög nivå e‑posthantering och `textproto` för låg nivå protokollparsning. Dess DKIM‑vänliga design säkerställer kompatibilitet med moderna e‑postautentiseringsarbetsflöden. Med inbyggda strömningsfunktioner och normalisering av teckenkodning förenklar go-message komplexa e‑postbehandlingsuppgifter såsom parsning av multipart‑kroppar, avkodning av kodade rubriker och hantering av nästlade MIME‑strukturer — allt medan minneseffektivitet och prestanda bibehålls.

Previous Next

Komma igång med go-message

För att börja använda go-message, installera det via `go get` från det officiella [go-message GitHub](https://github.com/emersion/go-message) repository. Den rekommenderade metoden är att använda Go‑moduler: kör `go get github.com/emersion/go-message` i din projektkatalog. För stöd för teckenkodningsavkodning, inkludera `import _ "github.com/emersion/go-message/charset"` för att aktivera alla standardkodningar. Biblioteket är lättviktigt, utan beroenden, och integreras smidigt i befintliga Go‑applikationer.

Installera go-message via Go-moduler

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

Strömmande e-postparsning

go-message tillhandahåller en strömmande parser som bearbetar e‑postmeddelanden inkrementellt utan att ladda hela innehållet i minnet. Detta är särskilt fördelaktigt för hantering av stora e‑postmeddelanden eller högvolym e‑postbehandling. Parsen läser rubriker och kroppsdela sekventiellt, vilket möjliggör för utvecklare att inspektera eller vidarebefordra meddelanden i realtid. Den stöder både RFC‑kompatibla och felaktiga meddelanden på ett smidigt sätt, vilket gör den lämplig för produktionsmailservrar. Genom att utnyttja Go:s `io.Reader` integreras biblioteket naturligt med nätverks‑ och fil‑I/O‑operationer.

Hur parsar man ett e-postmeddelande via 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
}

Hantering av MIME-multipart

go-message stöder fullt ut parsning och generering av MIME‑multipart‑meddelanden enligt RFC 2045 och RFC 2046. Utvecklare kan navigera i komplexa multipart‑strukturer — inklusive nästlade delar — med hjälp av intuitiva API:er. Biblioteket avkodar automatiskt överföringskodningar (t.ex. base64, quoted‑printable) och ger åtkomst till enskilda delar via `Part`‑gränssnittet. Detta möjliggör robust e‑postkomposition och extrahering av bilagor, HTML/text‑alternativ och inbäddade resurser. Dess strömmande natur säkerställer effektiv hantering även för stora multipart‑meddelanden med många delar.

Hur extraherar man multipart‑delar från ett e‑postmeddelande?

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
}

Stöd för teckenuppsättning och kodning

go-message inkluderar robust automatisk teckenkodnings- och kodningshantering för e‑posthuvuden och brödtext. Det stöder avkodning av RFC‑2047‑kodade rubriker (t.ex. `=?utf-8?B?...?=`) och brödtext i olika teckenkodningar (UTF‑8, ISO‑8859 osv.). Genom att importera det valfria paketet `github.com/emersion/go-message/charset` får utvecklare tillgång till alla registrerade IANA‑teckenkodningar via `golang.org/x/text/encoding`. Detta säkerställer korrekt återgivning av internationellt e‑postinnehåll, inklusive icke‑latinska skript och specialtecken, utan manuell teckenkodningsdetektering eller konvertering.

Hur avkodar man ett teckenkodningskodad rubrik?

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-vänlig signering av meddelanden

go-message är utformad för att vara DKIM‑vänlig, vilket möjliggör sömlös integration med kryptografiska signerings‑ och verifieringsarbetsflöden. Dess strömmande parser bevarar meddelandestrukturens integritet, så att undertecknare kan signera endast den kanoniserade kroppen och utvalda rubriker utan omkodning. Biblioteket undviker onödiga transformationer (t.ex. normalisering av radslut) som kan bryta DKIM‑signaturer. Utvecklare kan bygga e‑postsignerings‑pipelines genom att kombinera go-message med bibliotek som `github.com/emersion/go-dkim`, vilket säkerställer efterlevnad av RFC 6376 för domänbaserad meddelandeautentisering.

Hur förbereder man ett meddelande för DKIM‑signering?

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
}
 Svenska