Heute möchte ich gerne eine Möglichkeit präsentieren, wie es unter PHP möglich ist, Emails zu versenden.

Wichtig zu wissen ist, dass Emails nur versendet werden können, sofern auf dem Server ein Mailserver installiert ist. Das kann auf einem Server sein, den man selbst betreibt oder einer der im Rechenzentrum steht. Letzteres ist wahrscheinlich die gängigere Variante, da man beim Mailversand noch sehr viel mehr beachten muss.

Grundlegend lautet der Befehl für den Mailversand unter PHP:

mail($empfaenger, $betreff, $nachricht, $absender);

Natürlich macht es in einer größeren Webanwendung keinen Spaß, jedes Mal den kompletten Befehl einzugeben. Zumal das Ändern der Emailadresse dadurch unnötig verkompliziert werden würde.

Was können wir da nun tun?
Die Antwort ist ganz einfach: Wir schreiben uns eine Klasse, welche sich um das Verarbeiten und Senden der Emails kümmert.

Was soll die Klasse können?
Die Klasse ist später dafür zuständig, dass unsere Emails einheitlich gestaltet sind und wir nicht bei jedem Aufruf der Mail-Methode unseren Betreff und die Nachricht eintippen müssen. Weiterhin wird es mit der Klasse möglich sein, dass wir einen Massenversand (z. B. bei einem Newsletter) veranlassen.

Was beinhaltet die Klasse?
Die Klasse beinhaltet private Variablen, welche wiederum die eigentlichen Inhalte beinhalten.
Das sind in erster Linie Headerinformationen, Absenderadresse und die Signatur (sofern erwünscht).
Privat bedeutet, dass nur die eigene Klasse auf die Informationen Zugriff hat.
Weiterhin enthält die Klasse Methoden, die später von uns aufgerufen werden. Diese Methoden setzen die Email zusammen und werden diese schlussendlich auch versenden. Daher müssen sie öffentlich sein, wir rufen sie nämlich aus einer anderen Klasse auf. Wir müssen also nichts weiter tun, als die richtige Methode aufzurufen.

Genug zur Theorie, kommen wir zur Praxis.


Die Datei

Wir beginnen mit dem Erstellen der Datei. Das kann noch lokal passieren und muss nicht auf dem Server gemacht werden.

Wenn man die Datei erstellt hat, beginnt auch schon die Schreibarbeit.

class Email {

}

Hier haben wir nun eine Klasse angelegt, die Email heißt. Die Klasse ist aktuell noch leer und kann somit nichts.

Bevor wir nun in dieser Klasse die Methoden, welche später für die Verarbeitung zuständig sind, implementieren können, müssen wir unsere Variablen deklarieren. Die Variablen enthalten die Informationen, welche in die Email eingesetzt werden.

Wie bereits vorher erwähnt, deklarieren wir private Variablen, da niemand außerhalb der Klasse darauf Zugriff haben soll.

class Email {
private $header = array();
private $signatur = "Deine Signatur - kann weggelassen werden.";
private $email;
private $betreff;
private $nachricht;
}

Die Variablen sind nun deklariert. Man könnte sie nun innerhalb der Klasse direkt nutzen. Allerdings bin ich persönlich ein Freund von GET- und SET-Methoden, da wir über diese noch gesonderte Abfragen machen können. Nützlich ist das, um die Daten zu prüfen, bevor wir sie speichern. Also füge ich diese noch ein. Lediglich bei der Signatur und beim Header-Array lasse ich die SET-Methode weg, dort setze ich die entsprechenden Werte direkt ein.

class Email {
private $header = array("Content-type: text/plain; charset=utf-8", "From: Absendername <deine@adresse.de>");
private $signatur = "Deine Signatur - kann weggelassen werden.";
private $email;
private $betreff;
private $nachricht;

private function getHeader() {
 return $this->header;
}

private function getSignatur() {
 return $this->signatur;
}

private function setEmail($value) {
 $this->email = $value;
}
 
private function getEmail() {
 return $this->email;
}
 
private function setBetreff($value) {
 $this->betreff = $value;
}
 
private function getBetreff() {
 return $this->betreff;
}
 
private function setNachricht($value) {
 $this->nachricht = $value;
}
 
private function getNachricht() {
 return $this->nachricht;
}
}

Nun sind die SETTER und GETTER (wie man sie so schön nennt) auch erstellt. Über diese verarbeiten wir dann später die Informationen für die Emails.

Zur besseren Übersicht lasse ich nun den oberen Teil weg. Die Codefelder würden sonst nur unnötig lange werden. Alles was nun folgt, gehört unter die Methoden und in die Klasse Email.

Die erste Methode

Fangen wir an mit unserer ersten Methode. Diese soll eine Email erstellen und die entsprechenden Werte setzen. In unserem Fall erstmal nur die Emailadresse. Hierfür nutzen wir einfach den Konstruktor der Klasse. Der Konstruktor wird beim Erzeugen eines neuen Objekts automatisch aufgerufen und eignet sich daher ideal hierfür.

function __construct($adresse) {
 if((strpos($adresse, "@") != false) && (strpos($adresse, ".") != false)) {
  $this->setEmail($adresse);
 }
 else {
  echo "Keine gültige Emailadresse.";
 }
}

Auf den ersten Blick wirkt der Konstruktor etwas kompliziert. Das kommt allerdings daher, dass ich gleich noch eine Abfrage eingebaut habe. Diese Abfrage prüft, ob eine gültige Emailadresse vorliegt.

Anmerkung: Zu 100 % wird man nie feststellen können, ob eine Emailadresse korrekt ist, da es ganz viele verschiedene Domains gibt. Lediglich das @ und der . sind ein Indiz dafür, dass eine Adresse korrekt sein kann!

Ist eine Emailadresse nach diesem Test gültig, wird sie in der Variable gespeichert. Sonst wird eine Meldung ausgegeben.
Mehr tut der Konstruktor an dieser Stelle nicht.

Nun machen wir weiter mit der Methode, die später unsere Emails versenden soll. Ich habe die als nächstes gewählt, da sie zu den wichtigsten Methoden dieser Klasse gehört. Ohne diese Methode kann später keine Email versendet werden. Warum ich das Senden nicht in eine andere Methode packe, das erkläre ich später.

function mailSenden() {
 $this->setNachricht($this->getNachricht() ."\n\n". $this->getSignatur());

 $erfolg = mail($this->getEmail(), $this->getBetreff(), $this->getNachricht(), $this->getHeader());

if($erfolg) {
 return "Email verschickt.";
}
else {
 return "Fehler beim Versand.";
}
}

Die obere Zeile ist dafür zuständig, dass zur Nachricht noch die oben festgelegte Signatur angefügt wird. Zwischen Nachricht und Signatur kommen zwei Zeilenumbrüche.

Im Anschluss daran, wird die Mail verschickt. Die Methode mail() hat einen Rückgabewert in der Form true/false. Daher lässt sich das ganz einfach mit einem if-Anweisung überprüfen, ob die Mail versendet wurde. In der if-Anweisung müssen wir nicht nochmal zusätzlich == true schreiben, denn sollte von mail() false geliefert werden, wäre die Bedingung ohnehin nicht erfüllt. if prüft immer auf true.

Der Kern unserer Klasse ist somit fertiggestellt. Jetzt fehlt uns noch eine letzte Methode, welche uns den Betreff und den Text setzt. Die schreiben wir wie folgt:

function standardMail() {
 $this->setBetreff("Das ist eine Standardmail");
 $this->setNachricht("Hallo, du erhältst eine Standardmail von mir.");

$this->mailSenden();
}

Das Ergebnis

Nun ist unsere Klasse fertig. Sie ist nun in der Lage, Emails zu versenden. Die Emails enthalten immer den gleichen Text. Sollte man individuelle Nachrichten versenden wollen, dann kann man einfach eine neue Methode in die Klasse einfügen, ohne den Code groß ändern zu müssen. Das ist der Vorteil an dieser Möglichkeit.

Der Grund, wieso ich das Senden vom Erstellen der Mail getrennt habe, wird nun auch klar. Wenn wir weitere Methoden implementieren, können wir auf die Senden-Methode zurückgreifen und müssen nicht ständig mail() schreiben.

Dieses Prinzip kommt aus der objektorientierten Programmierung wo man versucht, Wiederholungen zu vermeiden.

Zum Schluss erkläre ich noch, wie man nun diese Klasse auch benutzen kann.

Angenommen man ist in einer anderen Datei und möchte von dort eine Email versenden, dann müssen wir erst die Emailklasse einbinden.

include "emaildatei.php";

$email = new Email("beispiel@adresse.de");
$rueckgabe = $email->standardMail();
echo $rueckgabe;

Wir sagen PHP, dass es eine Datei einbeziehen soll. Das ist die Datei, welche die Klasse Email enthält. Anschließend legen wir ein neues Objekt der Klasse Email an, in diesem Fall $email. Beim Anlegen übergeben wir dem Konstruktor die Emailadresse des Empfängers.

Haben wir nun ein neues Objekt der Klasse Email angelegt, rufen wir die Methode auf, welche unsere Vorlage für die Email enthält. Da diese Methode die mailSenden-Methode aufruft und diese wiederum einen Rückgabewert hat, lassen wir den Rückgabewert einer Variablen zuweisen. Diese Variable wird dann ausgegeben.

Das Ausgeben der Variable kann man sich allerdings auch sparen, sofern es den Anwender auf der Website nichts angeht. Man könnte den Wert natürlich auch in einer Textdatei oder Datenbank speichern, so dass man als Betreiber der Website sieht, ob ein Versand fehlgeschlagen ist.


Ich hoffe ich konnte Euch hier eine gute und einfache Anleitung geben, wie man die Funktion mail() sinnvoll in seine Webanwendung integrieren kann. Solltet Ihr noch Fragen oder Probleme haben, dann könnt ihr sie gerne hier hinterlassen.

Kategorien: Web

Lukas

Hi, mein Name ist Lukas. Seit 2016 blogge ich auf Hobbyblogging über unterschiedliche Themen des Alltags. Schwerpunkt dabei ist das Thema Smart Home, speziell mit der Open Source Software OpenHab auf dem Raspberry Pi. Neben dem Bloggen absolviere ich derzeit mein Master-Studium im Fachbereich Wirtschaftsinformatik und arbeite als Werkstudent im Software Engineering.

0 Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.