- Wer hat es nicht schon mal versucht?
- Wen hat es nicht ebenfalls schon so zur Verzweiflung getrieben?
- Wer hat nicht schon Stunden mit Suchen und Probieren verbracht und ist zu keinem Ergebnis gekommen?
- Wer hatte nicht schon mindestens einmal Problem beim Verwenden der JavaMail-API?
Nun, um euch zu beruhigen: das hier soll kein 08/15-Tutorial werden, in dem ich euch einfach Code hinklatsche und mir meinen Teil denke. Dieses Tutorial soll denen helfen, die eben so wie ich Probleme beim Einstieg in die JavaMail-API haben.
Was brauchen wir für JavaMail ?
Nun, zunächst brauchen wir die aktuelle Version der JavaMail-API. Um euch die Suche zu erleichtern gebe ich euch hier den Link auf die aktuelle Version 1.4.4 (Stand:13.08.2011) :
JavaMail-API 1.4.4
Zu beachten: ihr benötigt mindestens Java6 SE oder EE. Solltet ihr noch auf einer 5er oder gar noch älteren Version arbeiten müsst ihr zusätzlich das aktuelle
JavaBeans Activation Framework 1.1.1 herunterladen.
Nach dem ihr nun das (oder die) Zip-File(s) heruntergeladen habt entpackt ihr diese. Ich schlage euch hierfür einen neuen Unterordner in eurem Projektbaum vor. Nennt diesen neuen Unterordner am besten "javamail144". (Ich selber arbeite mit Java7 und brauche daher kein JAF. Bei Problemen mit dessen Installation bitte HIER nachfragen.)
Nun erhalten wir eine etwas größere Ordnerstruktur. Die Inhalte sollen uns jetzt erst einmal nicht weiter interessieren.
Nach dem Entpacken müssen wir noch unseren Classpath anpassen. Wer diesen systemweite ändern will fügt am Ende nur noch die absoluten Pfad zum "mail.jar" und "activision.jar" hinzu.
//UPDATE IDE *DANKE an JavaDeveloper2011*
In Sachen IDE:
- in NetBeans bei den Projekt-Libraries unter 'Add JAR/Folder'
- bei eclipse-Projekten unter Build-Path > Add External Archives...
WICHTIG: es reicht NICHT nur den/die Pfad/e in den CP mit aufzunehmen in welchem das/die Jar-File(s) liegt/en, statt dessen muss/müssen es das/die Jar-File(s) selbst dierekt sein. (Anmerkung : Da ich keine IDE verwende kann ich hier leider keinen Support leisten.)
Wie arbeiten wir nun mit JavaMail?
Nun, da sich mein Tutorial hier leider nur auf das simple Versenden von E-Mails mit Hilfe eines E-Mail Kontos bei einem Anbieter beschränkt dürfte dieser Abschnitt nur sehr klein ausfallen. Ich bitte an dieser Stelle ALLE die mehr Informationen zur Verwendung von JavaMail haben diese hier niederzuschreiben. DANKE.
Zunächst sehen wir uns einmal die Klassen an welche wir aus dem JavaMail-Paket verwenden:
javax.mail.Address
-abstrakte Klasse, Funktion siehe abgeleitete Klasse javax.mail.internet.InternetAddress
javax.mail.Message
-abstrakte Klasse, Funktion siehe abgeleitete Klasse javax.mail.internet.MimeMessage
javax.mail.Session
-Verwaltungs-Klasse für die Verbindung zum SMTP-Server
-speichert Verbindungsparameter
-ermöglicht das Erzeugen von Verbindungs-Objekten
javax.mail.Transport
-abstrakte Klasse, Funktion siehe abgeleitete Klasse com.sun.mail.smtp.SMTPTransport
javax.mail.internet.InternetAddress
-Klasse deren Objekte E-Mail-Adressen repräsentieren
-wird sowohl für Absender als auch Empfänger verwendet
javax.mail.internet.MimeMessage
-stellt die eigentliche E-Mail dar
-Klasse deren Objekte eine E-Mail mit allen Headern und Body repräsentieren
com.sun.mail.smtp.SMTPTransport
-Verbindungs-Klasse
-repräsentiert die eigentliche Verbindung zum SMTP-Server
-wird verwendet um mehrere E-Mails über die selbe Verbindung zu versenden
javax.mail.Service
-abstrakte Klasse
-super-Klasse von javax.mail.Transport
-stellt Methoden zum Herstellen einer Verbindung sowie deren Trennung bereit
-wird nicht dierekt verwendet
java.util.Properties
-Liste mit allen Verbindungs-Parametern
Nun, nach dem wir uns einen Überblick über die zu verwenden Klassen gemacht haben können wir uns nähere Information aus der Doc holen. Diese liegt dem JavaMail-Paket bei.
Wie versende ich nun eine E-Mail?
Nun, diesen Bereich gliedere ich auf Grund der verschiedenen Arten dies zu bewerkstelligen in folgende Punkte:
- Arten der Verbindung
- Properties vs connect()
- Text- und HTML-E-Mails
Arten der Verbindung
Da Sicherheit im Laufe der Zeit immer wichtiger geworden ist findet man heutzutage kaum noch einen E-Mail Provider der einem das Senden von E-Mails ohne jegliche Authtifizierung oder Sicherung des Kommunitkationskanals ermöglicht. Daher schneide ich die erste Möglichkeit nur sporadisch an:
PLAIN-Connection
Bei dieser Verbindungs-Art werden alle Informationen, wie etwa Username und Passwort, im Klartext übertragen. Da es sehr leicht ist so an sensible Informationen zu kommen wird diese Art heute sehr selten bis gar nicht mehr verwendet
NO-Auth
Bei diesem Verfahren ermöglicht es der SMTP-Server eine E-Mail mit einem beliebigen Absender an einen beliebigen Empfänger zu senden. Dies bezeichnet man als "open SMTP-Relay" was frei übersetzt so viel wie "offener SMTP-Server" beduetet. Diese Form wird heute nur noch von speziell darauf abgestimmten Relay-Proxies verwendet um z.B. Mitarbeitern in einem Firmennetz die Kommuniktaion mit ihrem privaten E-Mail Provider zu ermöglichen. Allerdings kann diese Betriebsart auch zu einem großen Sicherheitsrisiko werden in dem ein solches Relay für Spam und änliches missbraucht wird.
Auth
Das ist die wohl am häufigsten verwendete Konfiguration: der Client muss sich beim Server authentifizieren um eine E-Mail zu senden. Dadurch wird unter anderem sichergestellt das der SMTP-Server nicht von Personen verwendet werden kann welche kein E-Mail-Konto auf diesem besitzen. Auch wird dadurch die Absender-Adresse fest mit dem User-Konto verknüpft.
SSLv2
Bei dieser Verbindungsart werden sämtliche Informationen mit Hilfe von SSLv2 verschlüsselt übertragen. Dies wird heute noch häufig verwendet, wurde aber mitlerweile von seinem Nachfolger SSLv3/TLSv1 abgelöst.
SSLv3/TLSv1
Ist der aktuelle Sicherheitsstandard bei dem wie bei SSLv2 alle Informationen verschlüsselt übertragen werden. Er wird meist in Kombination mit Client-Authentifizierung verwendet.
Properties vs connect()
Dieser Abschnitt befasst sich mit den zwei Möglichkeiten welche man hat um der JavaMail-API die Verbindungseinstellungen zu übergeben :
Properties
Eines der wohl bekanntesten Formate in Java wenn es um eine Zuordnung von Name=Wert - Paaren geht. Hier hat jede Einstellung einen bestimmten Namen und kann bestimmte Werte annehmen.
connect()
Bei dieser Variante werden alle Objekten die notwendigen Informationen über Getter mitgeteilt. Ganz besonderst beim Verbindungsaufbau kann man so dierekt Werte für Server, Port, Username, Passwort, Protokoll, Verschlüsselung und andere mitgeben.
Die Properties-Variante ist eine kompfortablere Art da alle nötigen Informationen aus dem Properties-Objekt ausgelesen werden und so nicht mehr von uns manuell übergeben werden müssen.
Text- und HTML-E-Mails
Wie viele von euch in den letzten Jahren mitbekommen werden haben findet auch das HTML-Format in E-Mails immer größeren Zulauf. Das liegt zum Einen daran das es lediglich auf den MIME-Typ ankommt ob HTML interpretiert werden soll oder nicht und zum Andren alle HTML-Zeichen im ASCII-Code liegen und somit ohne Probleme übertragen werden können.
Diese Tutorial zeigt euch lediglich die einfache Text-Variante. Aber den unten stehenden Code auf HTML-E-Mails zu erweitern ist gar nicht so schwer. Es muss lediglich der MIME-Typ text/html gesetzt und die komplette E-Mail muss aus einer HTML-Seite zusammen gebaut werden. Ansonsten ändert sich am Versenden selbst nicht, nur an dem WAS gesendet wird.
Nun aber endlich zum Code um den es hier geht.
Wir werden diese Schritt für Schritt durcharbeiten um auch zu verstehen was in den einzelnen Zeilen passiert.
Hinweis: da eine Klasse immer einem festen Aufbau folgt müssen eventuelle Paket-Angaben natürlich in die erste Zeile.
Import-Anweisungen
Da ich euch oben schon mal eine schöne Auflistung aller benötigten Klassen gemacht habe können wir daraus die import-Anweisungen durch simples Copy&Paste bauen:
Code java:
1 2 3 4 5 6 7 | import java.util.Properties;
import javax.mail.Address;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage; |
Nanu, wo sind denn com.sun.mail.smtp.SMTPTransport und javax.mail.Service?
Nun, ich habe diese Klassen lediglich genannt da wir auf Methoden zugreifen werden die in diesen deklariert sind. Instanzen oder Objekte dieser Klassen selbst brauchen wir nicht wesshalb auch kein Import nötig ist.
Als nächstes folgt die Klassendeklaration. Nennen wir diese Klasse der Einfachheit halber mal SendMailTLS. TLS aus dem Grund da wir in diesem Tutorial das aktuelle SSLv3/TLSv1 verwenden. Ich werde jedoch auch als Kommentar die Codes für PLAIN/NO-Auth und SSLv2/AUTH schreiben:
Code java:
1 | public class SendMailTLS |
Um uns nun nicht mit unnötigen Klassen, Objekten, Methoden und Variablen rumzuärgern schreiben wir den gesamten Code in die main()-Methode und veranlassen diese zur vereinfachung mit throws Exceptions alles an den ClassLoader weiter zu werfen
Innerhalb der main() deklarieren wir nun erst einmal unsere Login-Daten sowie die Server-Adresse. Als Beispiel verwende ich hier GoogleMail/TLSv1 (getestet). Jedoch sind auch die Variablen für PLAIN , NO-AUTH und SSLv2 vorhanden:
Code java:
1 2 3 4 5 6 7 8 9 10 11 12 13 | // Google-Mail mit TLSv1 und Auth
String host="smtp.gmail.com";
int port=587;
String user="somthing@googlemail.com";
String pass="somthingsecret";
// PLAIN / NO-AUTH
String host="smtp.host.tld";
int port=25;
// Google-Mail mit SSLv2 und Auth
String host="smtp.gmail.com";
int port=465; |
Bitte beachtet, dass ihr natürlich nur eine dieser 3 Möglichkeiten kopiert.
Ich habe für PLAIN / NO-AUTH extra keinen speziellen Host angegeben, das diese Verfahren wie oben beschrieben nur noch in SMTP-Relays Verwendung findet und daher praktisch keine Bedeutung für uns hat.
Auch zu beachten ist der unterschiedliche Port zwischen SSLv2 und SSLv3/TLSv1. Den genauen Server-Namen und Port bekommt ihr von eurem E-Mail-Provider. Meistens findet ihr diese Angaben in den Rubriken: Zugang, Einstellungen, POP3/IMAP/SMTP oder in der Hilfe.
Als nächstes müssen wir unserer Verbindung noch mitteilen das wir uns
1) mit unserem Username und Passwort authentifizieren wollen
2) eine gesicherte Verbindung über SSLv2 bzw SSLv3/TLSv1 herstellen wollen
Dafür brauchen wir jetzt das Properties-Objekt. Wir erzeugen einfach ein leeres und setzen folgende Properties um das zu erreichen was wir wollen
Code java:
1 2 3 4 5 6 7 8 9 10 | Properties props=new Properties();
// Authentifizierung aktivieren
props.put("mail.smtp.auth", "true");
// SSLv2
props.put("mail.smtp.socketFactory.port", "465");
props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
// SSLv3/TLSv1
props.put("mail.smtp.starttls.enable", "true"); |
Auch hier gilt wieder: entweder SSLv2 ODER SSLv3/TLSv1.
Nun kommen wir endlich zu etwas JavaMail spezifischem, dem Vorbereiten der Verbindung
Dazu benötigen wir ein Objekt der Klasse javax.mail.Session. Da der Konstruktor protected ist müssen wir auf eine getInstance()-Methode ausweichen.
"Ein Singleton" werden jetzt sicherlich einige von euch Denken. Nun, das ist nur teilweise richtig. Einerseits bietet uns die Klasse Session ein Singleton an um mit einer Verbindung alle E-Mails verschicken zu können die wir haben, andererseits können wir aber auch für jede E-Mail eine neue Session erzeugen.
Dazu haben wir zwei Methoden:
Code java:
1 2 | static Session getDefaultInstance()
static Session getInstance() |
getDefaultInstance() ermöglicht es uns die Singleton-Eigenschaft von Session zu nutzen. Mit getInstance() hingegen erzeugen wir jedes mal eine neue Instanz.
Den Instanz-Methoden müssen wir das Properties-Objekt übergeben womit die Session mit den darin enthaltenen Parametern erzeugt wird. Abhängig ob wir alle Informationen in das Properties-Objekt geschrieben haben können wir nach dem Erzeugen einer Session-Instanz und einer dadurch erzeugten Transport-Instanz verschiedene connect()-Methoden aufrufen.
In diesem Tutorial verwende ich eine Mischform: Authenfizierung und Verschlüsselung via TLSv1 werden über Properties übergeben, die Login-Informationen erst beim Aufruf von connect().
Wie sieht der Verbindungsaufbau nun genau aus?
Wie oben bereits erwähnt brauchen wir für die erfolgreiche Verbindung 2 Objekte
- ein Session-Objekt das die Verbindungsinformationen wie Protokoll, Verschlüsselung, Server, Login-Informationen und andere enthält
- ein Transport-Objekt welches eine durch das Session-Objekt definierte Verbindung mit einem bestimmten Protokoll herstellt
Als erstes erzeugen wir das Session-Objekt. Wir können wir ruhig die Sigleton-Eigenschaft nutzen und uns über
Code java:
1 | Session session=Session.getDefaultInstance(props); |
eine für unsere Verbindung gültige Session erzeugen. Um nun aber die Verbindung zum Server auch herstellen zu können müssen wir nun noch das Transport-Objekt erzeugen. Dies geschieht mit
Code java:
1 | Transport transport=session.getTransport("smtp"); |
WICHTIG: SMTP muss an dieser Stelle klein geschrieben werden, da man ansonsten eine Exception erhält, welche aussagt das kein Provider für SMTP gefunden wurde.
Zum Schluss stellen wir nun noch die Verbindung mit dem Server her. Da wir uns dafür entschieden haben die Login-Daten NICHT im Properties-Objekt anzugeben müssen wir nun den ausführlichen connect mit Angabe von Server, Port, Username und Passwort durchführen. Stehen diese 4 Informationen im Properties-Objekt so können wir die parameterlose connect()-Methode aufrufen. Alle nötigen Informationen werden dann aus den Properties gelesen.
Code java:
1 | transport.connect(host, port, user, pass); |
Und damit haben wir auch schon die Verbindung zum Server via TLSv1 hergestllt ohne selbst irgendwie mit Dingen wie Schlüsselen oder Zertifikaten rumhandtiert haben zu müssen.
Als nächstes bauen wir uns nun unsere E-Mail zusammen.
Am besten erzeugen wir, bevor wir die E-Mail selbst erzeugen, die Empfänger-Adressen.
Dazu bietet uns die Klasse InternetAddress eine statische Methode parse(String) an. Diese bekommt alle Adressen in einem einzigen String übergeben. Zur Trennung zwischen einzelnen Adressen wird ein simples Komma verwendet. Wenn wir natürlich nur einen Empfänger haben brauchen wir auch keine Kommas.
Von der statischen Methode parse(String) erhalten wir ein Array des Typs Address.
Das ganze sieht dann so aus:
Code java:
1 | Address[] addresses=InternetAddress.parse("empfaenger@provider.tld"); |
Achtung: es ist darauf zu achten das KEINE Sonderzeichen wie Umlaute oder andere verwendet werden da diese laut RFC nicht gestattet sind. Um eine E-Mail-Adresse auf Gültigkeit zu prüfen könnte man eine RegEx nach folgendem Muster verwenden:
//Update
RegEx aktualisiert das nun auch Bindestriche sowohl im User-Namen als auch im Host-Namen vorkommen dürfen.
Code :
1 | [a-zA-Z0-9\\._\\-]{3,}\\@[a-zA-Z0-9\\._\\-]{3,}\\.[a-zA-Z]{2,6} |
Diese RegEx ist natürlich verbesserungswürdig; sie soll lediglich einen Leitgedanken geben.
Nach dem wir nun also auch die Emfänger zusammen haben, können wir uns daran machen, die E-Mail selbst zu erzeugen. Wir verwenden dafür die Klasse MimeMessage welche uns neben normalen Text-E-Mails auch die Möglichkeit für HTML-E-Mails bietet. Dies würde aber den Rahmen dieses Tutorials sprengen.
Eine neue E-Mail erzeugen wir mit einem einfachen Konstruktor der Klasse MimeMessage dem wir die aktuelle Session übergeben.
Code java:
1 | Message message=new MimeMessage(session); |
Nach dem erzeugen setzen wir auch gleich noch den Absender. Dieser ist in aller Regel mit dem vollem Usernamen (also Username + @ + Provider) gleich, kann aber Zusätzlich noch einen "persönlichen" Namen enthalten ( "Vorname Nachname <username@provider.tld>").
(Gleiches gilt auch für die Empfänger-Adressen.)
Code java:
1 | message.setFrom(new InternetAddress(user)); |
Es gibt einige Hoster bei denen man den Absender nicht explizit angeben muss. Diese setzen dann den FROM-Header beim Senden automatisch. Einige verlangen aber auch die explizite Angabe des Absenders. Was allerdings (fast) alle gemeinsam haben: mit einem falschen Absender verweigert der SMTP-Server das Senden und man bekommt eine entsprechende Exception (Ausnahme: SMTP-Relay).
Nun müssen wir auch noch den/die Empfänger der E-Mail angeben. Dies geschiet mit einer änlichen Methode : setRecipients(Message.RecipientType type, Address[] addresses)
Code java:
1 | message.setRecipients(Message.RecipientType.TO, addresses); |
Message.RecipientType kann folgende Werte haben:
- Message.RecipientType.TO - Empfänger der E-Mail
- MessageRecipientType.CC - Empfänger der sog. CarbonCopy , einer Kopie der E-Mail für dessen Duplikation der SMTP-Server verantwortlicht ist ; bei CC sehen alle Empfänger und CC-Empfänger die jeweils anderen Felder komplett
- MessageRecipientType.BCC - Empfänger der sog. BlindCarbonCopy , einer Kopie der E-Mail ähnlich wie CC , nur das weder Empfänger noch CC-Empfäger dieses Feld sehen und auch der BCC-Empfänger die anderen Felder nicht.
Wir verwenden hier den Typ TO für den Standardempfänger.
Wenn noch CC- oder BCC-Empfänger gewünscht sind müssen diese in eigenen Methodenaufrufen gesetzt werden. Zusätzlich bietet und MimeMessage auch noch eine Methode addRecipients(Message.RecipientType type, Address[] addresses), mit der einfach mehrere Empfänger hinzugefügt werden können wenn man keine Lust hat vorher mit einer for()-Schliefen und einem StringBuilder den kompletten Empfänger-String selbst zusammen zu setzen.
Nachdem wir nun Absender und Empfänger definiert haben folgt nun noch der Betreff. Diesen setzen wir mit der Methode setSubject(String):
Code java:
1 | message.setSubject("TEST SUBJECT"); |
Nun kommt der Teil über den ich hier schon Stunden lang schreibe: der Inhalt der E-Mail
Da wir nur eine Text-E-Mail versenden wollen reicht es auch den Inhalt als String zu übergeben.
ACHTUNG: Es nützt nichts in diesen String HTML einzubetten, da der MIME-Typ auf text/plain eingestellt ist womit der HTML-Code nicht interpretiert wird. Um dies zu erreichen müsste man den MIME-Typ auf text/html ändern. Aber das würde jetzt zu weit führen da dafür noch gewisse andere Methoden aufgerufen werden müssen bevor der Inhalt gesetzt wird.
Den Inhalt der E-Mail setzen wir mit der Methode Message.setText(String).
Code java:
1 | message.setText("text/plain BODY"); |
Wenn ein Zeilenumbruch erfolgen soll sollten wir dies mit der Zeichenfolge \r\n tun, da zwar \n von Unix und Mac richtig interpretiert wird (auch wenn für Mac eigentlich \r reserviert ist), jedoch Microsoft daran verzweifelt.
Was jetzt noch fehlt ist das absenden der E-Mail. Das geschieht durch den Aufruf der Methode Transport.sendMessage(Message, Address[]). Zur Sicherheit lassen wir uns bei Erfolg noch einen Hinweis ausgeben.
Code java:
1 2 | transport.sendMessage(message, addresses);
System.out.println("E-Mail gesendet"); |
Zum Schluss beenden wir noch die Verbindung zum Server sauber mit Transport.close().
Code java:
1 | transport.close(); |
Wenn wir nun alle Teil-Codes zusammennehmen erhalten wir folgendes funktionsfähiges Beispielprogramm
Code java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | import java.util.Properties;
import javax.mail.Address;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendMailTLS
{
public static void main(String[] args) throws Exception
{
String host="smtp.gmail.com";
int port=587;
String user="username";
String pass="password";
Properties props=new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
Session session=Session.getInstance(props);
Transport transport=session.getTransport("smtp");
transport.connect(host, port, user, pass);
Address[] addresses=InternetAddress.parse("recipent@host.tld");
Message message=new MimeMessage(session);
message.setFrom(new InternetAddress(user));
message.setRecipients(Message.RecipientType.TO, addresses);
message.setSubject("TEST SUBJECT");
message.setText("text/plain BODY");
transport.sendMessage(message, addresses);
System.out.println("SEND");
transport.close();
}
} |
Abschließende Worte
Ich hoffe ich konnte euch mit diesem Tutorial einen Einblick in die JavaMail-API geben.
Natürlich ist die JavaMail-API nicht auf das Senden von Text-E-Mails beschränkt.
Eine kleine Auflistung der Möglichkeiten:
- Senden von Text- und HTML-E-Mails via SMTP
- Empfangen von Text- und HTML-E-Mails via POP3
- Senden und Empfangen von E-Mail-Anhängen
- Verwalten des E-Mail-Postfaches via IMAP
- Verschlüsselung mit SSLv2 und SSLv3/TLSv1
Was mit der JavaMail-API NICHT möglich ist:
- einen E-Mail-Server betreiben
Dafür gibt es spezielle Programme und System-Dienste die dies können.
Die JavaMail-API ist lediglich dafür gedacht um komplexe E-Mail-Clienten zu schreiben, welche das Empfangen / Senden von Text- und HTML-E-Mails mit Dateianhängen sowie das Verwalten des Postfaches ermöglichen. Nicht aber für den Betrieb eines E-Mail-Servers.
getestete Server
Google-Mail
SMTP-Server : smtp.gmail.com
Port : 587
Verschlüsselung : SSLv3/TLSv1
Web.de
SMTP-Server : smtp.web.de
Port : 587
Verschlüsselung : SSLv3/TSLv1
Yahoo!
SMTP-Server : smtp.mail.yahoo.de
Port : 465
Verschlüsselung : SSLv2
Ich bitte an dieser Stelle noch ein mal alle die Ahnung von der JavaMail-API haben auch noch andere Möglichkeiten dieser Lib zu posten. Es wäre schön wenn wir es schaffen könnten alles was mit diesem Thema zu tun hat in einem "Komplettpaket" bereithalten zu können.
Bei Fragen, Hinweisen, Kritik oder Vorschlägen bitte NICHT via PN an mich richten, sondern die Kommentarfunktion nutzen. Und über eine Bewertung würde ich mich auch freuen.
bis zum nächsten Tutorial
SPiKEe
Login
Bereiche
Kategorien
Forum - Programming
Shop @ tutorials.de
tutorials.de-Systemmitteilung