Golang E -Mail senden

Das SMTP -Protokoll ist einer der Bausteine ​​des modernen Internets. Das Protokoll wirkt als Standard für E-Mail-Übertragungen. Es umfasst einen Mailserver und einen Mail -Client, um die Übertragung von E -Mails zu erleichtern.

In diesem Handbuch werden wir besprechen, wie Sie E -Mails über das SMTP -Paket in Go senden können. Zum Testen verwenden wir einen lokal gehosteten SMTP -Server mit Mailslurper.

Golang SMTP

Das SMTP-Paket ist ein Unterpaket des Golang Net-Pakets. Es implementiert hochrangige Funktionen für die Arbeit mit SMTP-Protokoll.

Lassen Sie uns erfahren, wie Sie E -Mails mit dem SMTP -Paket senden können.

Das SMTP -Paket enthält eine Sendmail () -Methode, mit der Sie E -Mail an die angegebene Adresse senden können.

Die Funktionssyntax ist wie gezeigt:

func sendmail (addr String, ein Auth, von String, zu [] String, msg [] byte) Fehler

Die Funktion akzeptiert die Adresse des SMTP -Servers als Zeichenfolge, einen Authentifizierungsmechanismus, E -Mail.

Die E -Mail -Nachricht sollte mit dem Header, einer leeren Zeile und dem E -Mail -Körper beginnen. Sie sollten jede Zeile der Nachricht mit CRLF -Zeichen beenden und die Einhaltung des RFC 822 -E -Mail -Stils ermöglichen.

Der folgende Code zeigt ein einfaches Beispiel für die Verwendung der Sendmail -Funktion zum Senden einer E -Mail.

Paket Main
importieren (
"fmt"
"Protokoll"
"net/SMTP"
)
const (
Userername = "LinuxHint"
Passwd = "Passwort"
Host = "Localhost"
)
func main ()
von: = "[email protected] "
an: = [] String
"[email protected] ",

msg: = [] byte ("von: [email protected] \ r \ n " +
"To: [email protected] " +
"Betreff: Golang Tests Mail \ r \ n" +
"E -Mail -Körper: Willkommen zu gehen!\ r \ n ")
Auth: = SMTP.PlainAuth ("", Benutzername, Passwd, Host)
ERR: = SMTP.Sendmail (host+": 25", auth, von, von, bis, msg)
Wenn er irrt != nil
Protokoll.Tödlich (arr)

fmt.Println ("Mail erfolgreich gesendet!"))

Im obigen Beispiel beginnen wir zunächst die erforderlichen Pakete importieren. Wir geben dann die erforderlichen Variablen an. In unserem Beispiel setzen wir den Benutzernamen, das Passwort und den Host.

In der Hauptfunktion setzen wir den Absender der E -Mail und den Empfänger mithilfe der von bzw. auf Variablen.

Als nächstes kommt der E -Mail -Körper, wir verwenden den RFC 822 -Stil, um die Nachricht zu konstruieren. Beachten Sie, dass jede Zeile mit CRLF -Zeichen getrennt ist.

Als nächstes erstellen wir die Authentifizierung mit der PlainAuth -Methode. Die Funktion nimmt die Identität, den Benutzernamen, das Kennwort und den Host auf und richtet einen einfachen Auth -Mechanismus mit dem Server aus. Die Funktion kehrt dann zu einem Auth -Objekt zurück.

Schließlich senden wir die E -Mail über die Sendmail -Funktion, die die Adresse, das Auth -Objekt, den Absender, die Empfänger und die Nachricht als Argumente übergeben.

Mailslurper Auth -Methode

Wenn Sie den obigen Code auf MailSlurper ausführen, gibt der Server einen Fehler wie unten zurück und schließt die Verbindung.

$ go run E -Mails.gehen
2022/02/02 02:52:39 SMTP: Server unterstützt Auth nicht
Beendenstatus 1

Sie können dies mit einer benutzerdefinierten Sendmail -Funktion lösen. Ein Beispielcode ist wie unten gezeigt:

Paket Main
importieren (
"Codierung/Base64"
"fmt"
"Protokoll"
"net/SMTP"
"Saiten"
)
const (
Userername = "LinuxHint"
Passwd = "Passwort"
Host = "Localhost"
)
func main ()
von: = "[email protected] "
an: = [] String
"[email protected] ",

MSG: = [] byte ("E -Mail -Körper: Willkommen zu gehen!\ r \ n ")
err: = sendmail (host+": 2500", von "golang testing -e -Mail", String (msg), bis)
Wenn er irrt != nil
Protokoll.Tödlich (arr)

fmt.Println ("Mail erfolgreich gesendet!"))

func sendmail (addr, von, Subjekt, Körperzeichenfolge, bis [] String) Fehler
R: = Strings.NewReplacer ("\ r \ n", "," \ r ",", "\ n", ",", "%0a", "", "%0d", "")
c, arr: = SMTP.Zifferblatt (addr)
Wenn er irrt != nil
Return err zurück

Aufhebung c.Schließen()
Wenn er = c.Mail (r.Ersetzen (von)); irren != nil
Return err zurück

für i: = Bereich zu
zu [i] = r.Ersetzen (zu [i])
Wenn er = c.RCPT (zu [i]); irren != nil
Return err zurück


w, arr: = c.Daten()
Wenn er irrt != nil
Return err zurück

MSG: = "bis:" + Strings.Schließen Sie sich an (zu, ",") + "\ r \ n" +
"Von:" + von + "\ r \ n" +
"Betreff:" + Subjekt + "\ r \ n" +
"Inhaltstyp: text/html; charset =" utf-8 "\ r \ n" +
"Content-Transfer-Codierung: Base64 \ r \ n" +
"\ r \ n" + base64.Stillding.CodetoString ([] Byte (Körper))
_, err = w.Schreiben ([] byte (msg))
Wenn er irrt != nil
Return err zurück

err = w.Schließen()
Wenn er irrt != nil
Return err zurück

Rückkehr c.Aufhören()

Golang senden Mail - Kohlenstoffkopie

Sie können auch E -Mails an mehrere Benutzer mit Carbon Copy und Blind Carbon Copy senden. CC -Empfänger sind für alle sichtbar.

Wir können dies mit dem Code wie unten tun:

Paket Main
importieren (
"fmt"
"Protokoll"
"net/SMTP"
"Saiten"
)
Geben Sie die Mailstruktur ein
Absender Zeichenfolge
Zu [] String
Cc [] String
BCC [] String
Betreff Zeichenfolge
Körperschnur

func main ()
Absender: = "[email protected]"
an: = [] String
"[email protected] ",
"[email protected] ",
"[email protected]",

CC: = [] String
"[email protected] ",
"Noch ein Helfer.Dev ",

Benutzername: = "LinuxHint"
Passwd: = "Passwort"
Host: = "Localhost"
Betreff: = "Golang Mail -Test"
Körper: = "Nachrichtenkörper"
Req: = Mail
Absender: Absender,
Zu: zu,
CC: CC,
Betreff: Betreff,
Körper Körper,

MSG: = CompoSemsg (Req)
Auth: = SMTP.PlainAuth ("", Benutzername, Passwd, Host)
ERR: = SMTP.Sendmail (Host+": 2500", Auth, Absender, bis, [] byte (msg))
Wenn er irrt != nil
Protokoll.Tödlich (arr)

fmt.Println ("Nachricht erfolgreich gesendet!"))

// Nachrichten basierend auf dem CC konstruieren
func CompoSemsg (Mail) String
// leerer String
MSG: = ""
// Sender einstellen
msg += fmt.Sprintf ("von: %s \ r \ n", Mail.Absender)
// Wenn mehr als 1 Empfänger
Wenn Len (Mail.Bis)> 0
msg += fmt.Sprintf ("CC: %s \ r \ n", Strings.Beitreten (Mail.CC, ";"))

// Betreff hinzufügen
msg += fmt.Sprintf ("Betreff: %s \ r \ n", Mail.Thema)
// Postkörper hinzufügen
msg += fmt.Sprintf ("Körper: %s \ r \ n", Mail.Körper)
MSG zurückgeben

Der obige Code sendet die E -Mails mit dem SMTP -Protokoll an die angegebenen Empfänger.

Schließen

In diesem Handbuch haben wir die Grundlagen der Verwendung des SMTP -Pakets untersucht, um E -Mails an einen oder mehrere Benutzer zu senden. Überprüfen Sie die Dokumentation, um mehr zu erfahren.