JavaMail API - Kurzanleitung
Die JavaMail-API bietet ein plattformunabhängiges und protokollunabhängiges Framework zum Erstellen von Mail- und Messaging-Anwendungen. Die JavaMail-API bietet eine Reihe abstrakter Klassen, die Objekte definieren, aus denen ein Mailsystem besteht. Es ist ein optionales Paket (Standarderweiterung) zum Lesen, Verfassen und Senden elektronischer Nachrichten.
JavaMail bietet Elemente, mit denen eine Schnittstelle zu einem Messagingsystem erstellt wird, einschließlich Systemkomponenten und Schnittstellen. Während diese Spezifikation keine spezifische Implementierung definiert, enthält JavaMail mehrere Klassen, die RFC822- und MIME-Internet-Messaging-Standards implementieren. Diese Klassen werden als Teil des JavaMail-Klassenpakets geliefert.
Im Folgenden sind einige der von der JavaMail-API unterstützten Protokolle aufgeführt:
SMTP: Akronym für Simple Mail Transfer Protocol. Es bietet einen Mechanismus zum Zustellen von E-Mails.
POP: Akronym für Post Office Protocol. POP ist der Mechanismus, den die meisten Leute im Internet verwenden, um ihre E-Mails zu erhalten. Es definiert die Unterstützung für ein einzelnes Postfach für jeden Benutzer. RFC 1939 definiert dieses Protokoll.
IMAP: Akronym für Internet Message Access Protocol. Es ist ein erweitertes Protokoll zum Empfangen von Nachrichten. Es bietet Unterstützung für mehrere Postfächer für jeden Benutzer. Darüber hinaus kann das Postfach von mehreren Benutzern gemeinsam genutzt werden. Es ist in RFC 2060 definiert.
MIME: Akronym für Multipurpose Internet Mail Extensions. . Es ist kein Mail-Übertragungsprotokoll. Stattdessen wird der Inhalt der Übertragung definiert: das Format der Nachrichten, Anhänge usw. Hier werden viele verschiedene Dokumente wirksam: RFC 822, RFC 2045, RFC 2046 und RFC 2047. Als Benutzer der JavaMail-API müssen Sie sich normalerweise nicht um diese Formate kümmern. Diese Formate existieren jedoch und werden von Ihren Programmen verwendet.
NNTP and Others: Es gibt viele Protokolle, die von Drittanbietern bereitgestellt werden. Einige davon sind NNTP (Network News Transfer Protocol), S / MIME (Secure Multipurpose Internet Mail Extensions) usw.
Details dazu werden in den folgenden Kapiteln behandelt.
Die Architektur
Wie oben erwähnt, verwendet die Java-Anwendung die JavaMail-API zum Erstellen, Senden und Empfangen von E-Mails. Die folgende Abbildung zeigt die Architektur von JavaMail:
Der abstrakte Mechanismus der JavaMail-API ähnelt anderen J2EE-APIs wie JDBC, JNDI und JMS. Wie aus dem obigen Architekturdiagramm hervorgeht, ist die JavaMail-API in zwei Hauptteile unterteilt:
Ein anwendungsunabhängiger Teil: Eine Anwendungsprogrammierschnittstelle (API) wird von den Anwendungskomponenten zum Senden und Empfangen von E-Mail-Nachrichten verwendet, unabhängig vom zugrunde liegenden Anbieter oder Protokoll.
Ein dienstabhängiger Teil: Eine Dienstanbieterschnittstelle (SPI) spricht die protokollspezifischen Sprachen wie SMTP, POP, IMAP und Network News Transfer Protocol (NNTP). Es wird verwendet, um einen Anbieter eines E-Mail-Dienstes an die J2EE-Plattform anzuschließen.
Das Senden einer E-Mail mit Ihrer Java-Anwendung ist einfach genug, sollte aber zunächst erfolgen JavaMail API und Java Activation Framework (JAF) auf Ihrem Computer installiert.
Du wirst das brauchen JavaBeans Activation Framework (JAF)Erweiterung, die das Paket javax.activation nur bereitstellt , wenn Sie Java SE 6 oder höher nicht verwenden.
Sie können die neueste Version von JavaMail (Version 1.5.0) von der Standard-Website von Java herunterladen.
Sie können die neueste Version von JAF (Version 1.1.1) von der Standard-Website von Java herunterladen.
Laden Sie diese Dateien herunter und entpacken Sie sie. In den neu erstellten Verzeichnissen der obersten Ebene finden Sie eine Reihe von JAR-Dateien für beide Anwendungen. Sie müssen hinzufügenmail.jar und activation.jar Dateien in Ihrem CLASSPATH.
SMTP-Server
Zum Senden von E-Mails benötigen Sie einen SMTP-Server, der für das Senden von E-Mails verantwortlich ist. Sie können eine der folgenden Techniken verwenden, um den SMTP-Server abzurufen:
Installieren und verwenden Sie alle SMTP-Server wie Postfix-Server (für Ubuntu), Apache James-Server (Java Apache Mail Enterprise Server) usw. (oder)
Verwenden Sie den SMTP - Server , der vom Host - Provider für zB vorgesehen: kostenlos SMTP bieten durch JangoSMTP Website ist relay.jangosmtp.net (oder)
Verwenden Sie den von Unternehmen bereitgestellten SMTP-Server, z. B. Google Mail, Yahoo usw.
In den Beispielen in den folgenden Kapiteln haben wir den kostenlosen JangoSMTP-Server zum Senden von E-Mails verwendet. Sie können ein Konto erstellen, indem Sie diese Site besuchen und Ihre E-Mail-Adresse konfigurieren.
Die JavaMail-API besteht aus einigen Schnittstellen und Klassen, die zum Senden, Lesen und Löschen von E-Mail-Nachrichten verwendet werden. Obwohl die JavaMail-API viele Pakete enthält, werden die beiden Hauptpakete behandelt , die in der Java Mail-API häufig verwendet werden: javax.mail und javax.mail.internet . Diese Pakete enthalten alle JavaMail-Kernklassen. Sie sind:
| Klasse | Beschreibung |
|---|---|
| javax.mail.Session | Die Schlüsselklasse der API. Ein Multithread-Objekt repräsentiert die Verbindungsfactory. |
| javax.mail.Message | Eine abstrakte Klasse, die eine E-Mail-Nachricht modelliert. Unterklassen stellen die tatsächlichen Implementierungen bereit. |
| javax.mail.Address | Eine abstrakte Klasse, die die Adressen (von und zu Adressen) in einer Nachricht modelliert. Unterklassen stellen die spezifischen Implementierungen bereit. |
| javax.mail.Authenticator | Eine abstrakte Klasse zum Schutz von Mail-Ressourcen auf dem Mail-Server. |
| javax.mail.Transport | Eine abstrakte Klasse, die einen Nachrichtentransportmechanismus zum Senden einer E-Mail-Nachricht modelliert. |
| javax.mail.Store | Eine abstrakte Klasse, die einen Nachrichtenspeicher und sein Zugriffsprotokoll zum Speichern und Abrufen von Nachrichten modelliert. Ein Geschäft ist in Ordner unterteilt. |
| javax.mail.Folder | Eine abstrakte Klasse, die einen Ordner mit E-Mail-Nachrichten darstellt. Es kann Unterordner enthalten. |
| javax.mail.internet.MimeMessage | Nachricht ist eine abstrakte Klasse und muss daher mit einer Unterklasse arbeiten. In den meisten Fällen verwenden Sie eine MimeMessage. Eine MimeMessage ist eine E-Mail-Nachricht, die MIME-Typen und -Header versteht. |
| javax.mail.internet.InternetAddress | Diese Klasse repräsentiert eine Internet-E-Mail-Adresse mit der Syntax von RFC822. Die typische Adressensyntax hat die Form [email protected] oder Personal Name <[email protected]> . |
Hier ist ein Beispiel zum Senden einer einfachen E-Mail. Hier haben wir den JangoSMTP-Server verwendet, über den E-Mails an unsere Ziel-E-Mail-Adresse gesendet werden. Das Setup wird im Kapitel Umgebungs-Setup erläutert .
Um eine einfache E-Mail zu senden, gehen Sie wie folgt vor:
Holen Sie sich eine Sitzung
Erstellen Sie ein Standard-MimeMessage-Objekt und legen Sie in der Nachricht Von, Bis, Betreff fest .
Stellen Sie die aktuelle Nachricht wie folgt ein:
message.setText("your text goes here");Senden Sie die Nachricht mit dem Transportobjekt.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei SendEmail, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendEmail {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
final String username = "manishaspatil";//change accordingly
final String password = "******";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "relay.jangosmtp.net";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "25");
// Get the Session object.
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// Now set the actual message
message.setText("Hello, this is sample for to check send " +
"email using JavaMailAPI ");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}Da wir den vom Host-Anbieter JangoSMTP bereitgestellten SMTP-Server verwenden, müssen wir den Benutzernamen und das Kennwort authentifizieren. Die Klasse javax.mail.PasswordAuthentication wird zur Authentifizierung des Kennworts verwendet.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse SendEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
Sent message successfully....Wenn ich über JangoSMTP eine E-Mail an meine Google Mail-Adresse sende, wird die folgende E-Mail in meinem Posteingang des Google Mail-Kontos empfangen:
Hier ist ein Beispiel zum Senden einer E-Mail mit Anhang von Ihrem Computer. Die Datei auf dem lokalen Computer istfile.txtplatziert bei / home / manisha / . Hier haben wir den JangoSMTP-Server verwendet, über den E-Mails an unsere Ziel-E-Mail-Adresse gesendet werden. Das Setup wird im Kapitel Umgebungs-Setup erläutert .
Um eine E-Mail mit einem Inline-Bild zu senden, gehen Sie folgendermaßen vor:
Holen Sie sich eine Sitzung
Erstellen Sie ein Standard-MimeMessage-Objekt und legen Sie in der Nachricht Von, Bis, Betreff fest .
Stellen Sie die aktuelle Nachricht wie folgt ein:
messageBodyPart.setText("This is message body");Erstellen Sie ein MimeMultipart-Objekt. Fügen Sie diesem mehrteiligen Objekt das obige messageBodyPart mit der darin festgelegten tatsächlichen Nachricht hinzu.
Fügen Sie als Nächstes den Anhang hinzu, indem Sie einen Datahandler wie folgt erstellen:
messageBodyPart = new MimeBodyPart(); String filename = "/home/manisha/file.txt"; DataSource source = new FileDataSource(filename); messageBodyPart.setDataHandler(new DataHandler(source)); messageBodyPart.setFileName(filename); multipart.addBodyPart(messageBodyPart);Stellen Sie als nächstes das Multipart in der Nachricht wie folgt ein:
message.setContent(multipart);Senden Sie die Nachricht mit dem Transportobjekt.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei SendAttachmentInEmail, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.util.Properties;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class SendAttachmentInEmail {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
final String username = "manishaspatil";//change accordingly
final String password = "******";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "relay.jangosmtp.net";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "25");
// Get the Session object.
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// Create the message part
BodyPart messageBodyPart = new MimeBodyPart();
// Now set the actual message
messageBodyPart.setText("This is message body");
// Create a multipar message
Multipart multipart = new MimeMultipart();
// Set text message part
multipart.addBodyPart(messageBodyPart);
// Part two is attachment
messageBodyPart = new MimeBodyPart();
String filename = "/home/manisha/file.txt";
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);
// Send the complete message parts
message.setContent(multipart);
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}Da wir den vom Host-Anbieter JangoSMTP bereitgestellten SMTP-Server verwenden, müssen wir den Benutzernamen und das Kennwort authentifizieren. Die Klasse javax.mail.PasswordAuthentication wird zur Authentifizierung des Kennworts verwendet.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse SendAttachmentInEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
Sent message successfully....Wenn ich über JangoSMTP eine E-Mail an meine Google Mail-Adresse sende, wird die folgende E-Mail in meinem Posteingang des Google Mail-Kontos empfangen:
Hier ist ein Beispiel zum Senden einer HTML-E-Mail von Ihrem Computer. Hier haben wir den JangoSMTP-Server verwendet, über den E-Mails an unsere Ziel-E-Mail-Adresse gesendet werden. Das Setup wird im Kapitel Umgebungs-Setup erläutert .
Dieses Beispiel ist dem Senden einfacher E-Mails sehr ähnlich, außer dass wir hier die Methode setContent () verwenden, um Inhalte festzulegen, deren zweites Argument "text / html" ist, um anzugeben, dass der HTML-Inhalt in der Nachricht enthalten ist. In diesem Beispiel können Sie so viel HTML-Inhalt senden, wie Sie möchten.
Um eine E-Mail mit HTML-Inhalten zu senden, gehen Sie folgendermaßen vor:
Holen Sie sich eine Sitzung
Erstellen Sie ein Standard-MimeMessage-Objekt und legen Sie in der Nachricht Von, Bis, Betreff fest .
Stellen Sie die tatsächliche Nachricht mit der Methode setContent () wie folgt ein:
message.setContent("<h1>This is actual message embedded in HTML tags</h1>", "text/html");Senden Sie die Nachricht mit dem Transportobjekt.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei SendHTMLEmail, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendHTMLEmail {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
final String username = "manishaspatil";//change accordingly
final String password = "******";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "relay.jangosmtp.net";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "25");
// Get the Session object.
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// Send the actual HTML message, as big as you like
message.setContent(
"<h1>This is actual message embedded in HTML tags</h1>",
"text/html");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
}Da wir den vom Host-Anbieter JangoSMTP bereitgestellten SMTP-Server verwenden, müssen wir den Benutzernamen und das Kennwort authentifizieren. Die Klasse javax.mail.PasswordAuthentication wird zur Authentifizierung des Kennworts verwendet.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse SendHTMLEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
Sent message successfully....Wenn ich über JangoSMTP eine E-Mail an meine Google Mail-Adresse sende, wird die folgende E-Mail in meinem Posteingang des Google Mail-Kontos empfangen:
Hier ist ein Beispiel zum Senden einer HTML-E-Mail von Ihrem Computer mit Inline-Bild. Hier haben wir den JangoSMTP-Server verwendet, über den E-Mails an unsere Ziel-E-Mail-Adresse gesendet werden. Das Setup wird im Kapitel Umgebungs-Setup erläutert .
Um eine E-Mail mit einem Inline-Bild zu senden, gehen Sie folgendermaßen vor:
Holen Sie sich eine Sitzung
Erstellen Sie ein Standard-MimeMessage-Objekt und legen Sie in der Nachricht Von, Bis, Betreff fest .
Erstellen Sie ein MimeMultipart-Objekt.
In unserem Beispiel haben wir einen HTML-Teil und ein Bild in der E-Mail. Erstellen Sie also zuerst den HTML-Inhalt und legen Sie ihn im mehrteiligen Objekt wie folgt fest:
// first part (the html) BodyPart messageBodyPart = new MimeBodyPart(); String htmlText = "<H1>Hello</H1><img src=\"cid:image\">"; messageBodyPart.setContent(htmlText, "text/html"); // add it multipart.addBodyPart(messageBodyPart);Fügen Sie als Nächstes das Bild hinzu, indem Sie einen Datahandler wie folgt erstellen:
// second part (the image) messageBodyPart = new MimeBodyPart(); DataSource fds = new FileDataSource( "/home/manisha/javamail-mini-logo.png"); messageBodyPart.setDataHandler(new DataHandler(fds)); messageBodyPart.setHeader("Content-ID", "<image>");Stellen Sie als nächstes das Multipart in der Nachricht wie folgt ein:
message.setContent(multipart);Senden Sie die Nachricht mit dem Transportobjekt.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei SendInlineImagesInEmail, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.util.Properties;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class SendInlineImagesInEmail {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
final String username = "manishaspatil";//change accordingly
final String password = "******";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "relay.jangosmtp.net";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "25");
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// This mail has 2 part, the BODY and the embedded image
MimeMultipart multipart = new MimeMultipart("related");
// first part (the html)
BodyPart messageBodyPart = new MimeBodyPart();
String htmlText = "<H1>Hello</H1><img src=\"cid:image\">";
messageBodyPart.setContent(htmlText, "text/html");
// add it
multipart.addBodyPart(messageBodyPart);
// second part (the image)
messageBodyPart = new MimeBodyPart();
DataSource fds = new FileDataSource(
"/home/manisha/javamail-mini-logo.png");
messageBodyPart.setDataHandler(new DataHandler(fds));
messageBodyPart.setHeader("Content-ID", "<image>");
// add image to the multipart
multipart.addBodyPart(messageBodyPart);
// put everything together
message.setContent(multipart);
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}Da wir den vom Host-Anbieter JangoSMTP bereitgestellten SMTP-Server verwenden, müssen wir den Benutzernamen und das Kennwort authentifizieren. Die Klasse javax.mail.PasswordAuthentication wird zur Authentifizierung des Kennworts verwendet.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse SendInlineImagesInEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
Sent message successfully....Wenn ich über JangoSMTP eine E-Mail an meine Google Mail-Adresse sende, wird die folgende E-Mail in meinem Posteingang des Google Mail-Kontos empfangen:
Bevor Sie mit diesem Kapitel fortfahren, müssen Sie zwei Aspekte verstehen. Sie sindCheck und Fetch.
CheckDas Senden einer E-Mail in JavaMail ist ein Prozess, bei dem wir den entsprechenden Ordner in der Mailbox öffnen und jede Nachricht abrufen. Hier überprüfen wir nur den Header jeder Nachricht, dh den Betreff Von, Bis . Inhalt wird nicht gelesen.
FetchDas Senden einer E-Mail in JavaMail ist ein Prozess, bei dem wir den entsprechenden Ordner in der Mailbox öffnen und jede Nachricht abrufen. Neben dem Header lesen wir auch den Inhalt, indem wir den Inhaltstyp erkennen.
Zum Überprüfen oder Abrufen einer E-Mail mithilfe der JavaMail-API benötigen wir POP- oder IMAP-Server. Zum Überprüfen und Abrufen der E-Mails werden Ordner- und Speicherklassen benötigt. Hier haben wir den POP3-Server von GMAIL (pop.gmail.com) verwendet. In diesem Kapitel erfahren Sie, wie Sie E-Mails mit der JavaMail-API abrufen. Das Abrufen wird in den folgenden Kapiteln behandelt. So überprüfen Sie E-Mails:
Holen Sie sich eine Sitzung
Erstellen Sie ein pop3 Store-Objekt und stellen Sie eine Verbindung mit dem Pop-Server her.
Ordnerobjekt erstellen. Öffnen Sie den entsprechenden Ordner in Ihrer Mailbox.
Erhalten Sie Ihre Nachrichten.
Schließen Sie die Store- und Folder-Objekte.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei CheckingMails, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.Session;
import javax.mail.Store;
public class CheckingMails {
public static void check(String host, String storeType, String user,
String password)
{
try {
//create properties field
Properties properties = new Properties();
properties.put("mail.pop3.host", host);
properties.put("mail.pop3.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
Session emailSession = Session.getDefaultInstance(properties);
//create the POP3 store object and connect with the pop server
Store store = emailSession.getStore("pop3s");
store.connect(host, user, password);
//create the folder object and open it
Folder emailFolder = store.getFolder("INBOX");
emailFolder.open(Folder.READ_ONLY);
// retrieve the messages from the folder in an array and print it
Message[] messages = emailFolder.getMessages();
System.out.println("messages.length---" + messages.length);
for (int i = 0, n = messages.length; i < n; i++) {
Message message = messages[i];
System.out.println("---------------------------------");
System.out.println("Email Number " + (i + 1));
System.out.println("Subject: " + message.getSubject());
System.out.println("From: " + message.getFrom()[0]);
System.out.println("Text: " + message.getContent().toString());
}
//close the store and folder objects
emailFolder.close(false);
store.close();
} catch (NoSuchProviderException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String host = "pop.gmail.com";// change accordingly
String mailStoreType = "pop3";
String username = "[email protected]";// change accordingly
String password = "*****";// change accordingly
check(host, mailStoreType, username, password);
}
}Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse CheckingMails.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMailsÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
messages.length---4
---------------------------------
Email Number 1
Subject: Test Mail--Fetch
From: <[email protected]>
Text: javax.mail.internet.MimeMultipart@327a5b7f
---------------------------------
Email Number 2
Subject: testing ----checking simple email
From: <[email protected]>
Text: javax.mail.internet.MimeMultipart@7f0d08bc
---------------------------------
Email Number 3
Subject: Email with attachment
From: <[email protected]>
Text: javax.mail.internet.MimeMultipart@30b8afce
---------------------------------
Email Number 4
Subject: Email with Inline image
From: <[email protected]>
Text: javax.mail.internet.MimeMultipart@2d1e165fHier haben wir die Anzahl der Nachrichten in der INBOX gedruckt, in diesem Fall 4. Wir haben auch Betreff, Von-Adresse und Text für jede E-Mail-Nachricht gedruckt.
Im vorherigen Kapitel haben wir gelernt, wie man E-Mails abruft. Lassen Sie uns nun sehen, wie Sie jede E-Mail abrufen und ihren Inhalt lesen. Schreiben wir eine Java-KlasseFetchingEmail Hier werden folgende Arten von E-Mails gelesen:
Einfache E-Mail
E-Mail mit Anhang
E-Mail mit Inline-Bild
Grundlegende Schritte im Code sind wie folgt:
Holen Sie sich das Session-Objekt.
Erstellen Sie ein POP3-Geschäftsobjekt und stellen Sie eine Verbindung zum Geschäft her.
Erstellen Sie ein Ordnerobjekt und öffnen Sie den entsprechenden Ordner in Ihrer Mailbox.
Nachrichten abrufen.
Schließen Sie den Ordner und speichern Sie die Objekte.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei FetchingEmail, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.Properties;
import javax.mail.Address;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.NoSuchProviderException;
import javax.mail.Part;
import javax.mail.Session;
import javax.mail.Store;
public class FetchingEmail {
public static void fetch(String pop3Host, String storeType, String user,
String password) {
try {
// create properties field
Properties properties = new Properties();
properties.put("mail.store.protocol", "pop3");
properties.put("mail.pop3.host", pop3Host);
properties.put("mail.pop3.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
Session emailSession = Session.getDefaultInstance(properties);
// emailSession.setDebug(true);
// create the POP3 store object and connect with the pop server
Store store = emailSession.getStore("pop3s");
store.connect(pop3Host, user, password);
// create the folder object and open it
Folder emailFolder = store.getFolder("INBOX");
emailFolder.open(Folder.READ_ONLY);
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
// retrieve the messages from the folder in an array and print it
Message[] messages = emailFolder.getMessages();
System.out.println("messages.length---" + messages.length);
for (int i = 0; i < messages.length; i++) {
Message message = messages[i];
System.out.println("---------------------------------");
writePart(message);
String line = reader.readLine();
if ("YES".equals(line)) {
message.writeTo(System.out);
} else if ("QUIT".equals(line)) {
break;
}
}
// close the store and folder objects
emailFolder.close(false);
store.close();
} catch (NoSuchProviderException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String host = "pop.gmail.com";// change accordingly
String mailStoreType = "pop3";
String username =
"[email protected]";// change accordingly
String password = "*****";// change accordingly
//Call method fetch
fetch(host, mailStoreType, username, password);
}
/*
* This method checks for content-type
* based on which, it processes and
* fetches the content of the message
*/
public static void writePart(Part p) throws Exception {
if (p instanceof Message)
//Call methos writeEnvelope
writeEnvelope((Message) p);
System.out.println("----------------------------");
System.out.println("CONTENT-TYPE: " + p.getContentType());
//check if the content is plain text
if (p.isMimeType("text/plain")) {
System.out.println("This is plain text");
System.out.println("---------------------------");
System.out.println((String) p.getContent());
}
//check if the content has attachment
else if (p.isMimeType("multipart/*")) {
System.out.println("This is a Multipart");
System.out.println("---------------------------");
Multipart mp = (Multipart) p.getContent();
int count = mp.getCount();
for (int i = 0; i < count; i++)
writePart(mp.getBodyPart(i));
}
//check if the content is a nested message
else if (p.isMimeType("message/rfc822")) {
System.out.println("This is a Nested Message");
System.out.println("---------------------------");
writePart((Part) p.getContent());
}
//check if the content is an inline image
else if (p.isMimeType("image/jpeg")) {
System.out.println("--------> image/jpeg");
Object o = p.getContent();
InputStream x = (InputStream) o;
// Construct the required byte array
System.out.println("x.length = " + x.available());
int i = 0;
byte[] bArray = new byte[x.available()];
while ((i = (int) ((InputStream) x).available()) > 0) {
int result = (int) (((InputStream) x).read(bArray));
if (result == -1)
break;
}
FileOutputStream f2 = new FileOutputStream("/tmp/image.jpg");
f2.write(bArray);
}
else if (p.getContentType().contains("image/")) {
System.out.println("content type" + p.getContentType());
File f = new File("image" + new Date().getTime() + ".jpg");
DataOutputStream output = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(f)));
com.sun.mail.util.BASE64DecoderStream test =
(com.sun.mail.util.BASE64DecoderStream) p
.getContent();
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = test.read(buffer)) != -1) {
output.write(buffer, 0, bytesRead);
}
}
else {
Object o = p.getContent();
if (o instanceof String) {
System.out.println("This is a string");
System.out.println("---------------------------");
System.out.println((String) o);
}
else if (o instanceof InputStream) {
System.out.println("This is just an input stream");
System.out.println("---------------------------");
InputStream is = (InputStream) o;
is = (InputStream) o;
int c;
while ((c = is.read()) != -1)
System.out.write(c);
}
else {
System.out.println("This is an unknown type");
System.out.println("---------------------------");
System.out.println(o.toString());
}
}
}
/*
* This method would print FROM,TO and SUBJECT of the message
*/
public static void writeEnvelope(Message m) throws Exception {
System.out.println("This is the message envelope");
System.out.println("---------------------------");
Address[] a;
// FROM
if ((a = m.getFrom()) != null) {
for (int j = 0; j < a.length; j++)
System.out.println("FROM: " + a[j].toString());
}
// TO
if ((a = m.getRecipients(Message.RecipientType.TO)) != null) {
for (int j = 0; j < a.length; j++)
System.out.println("TO: " + a[j].toString());
}
// SUBJECT
if (m.getSubject() != null)
System.out.println("SUBJECT: " + m.getSubject());
}
}Sie können das Debuggen aktivieren, indem Sie die Anweisung emailSession.setDebug (true) auskommentieren.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse FetchingEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
messages.length---3
---------------------------------
This is the message envelope
---------------------------
FROM: XYZ <[email protected]>
TO: ABC <[email protected]>
SUBJECT: Simple Message
----------------------------
CONTENT-TYPE: multipart/alternative; boundary=047d7b343d6ad3e4ea04e8ec6579
This is a Multipart
---------------------------
----------------------------
CONTENT-TYPE: text/plain; charset=ISO-8859-1
This is plain text
---------------------------
Hi am a simple message string....
--
Regards
xyz
This is the message envelope
---------------------------
FROM: XYZ <[email protected]>
TO: ABC <[email protected]>
SUBJECT: Attachement
----------------------------
CONTENT-TYPE: multipart/mixed; boundary=047d7b343d6a99180904e8ec6751
This is a Multipart
---------------------------
----------------------------
CONTENT-TYPE: text/plain; charset=ISO-8859-1
This is plain text
---------------------------
Hi I've an attachment.Please check
--
Regards
XYZ
----------------------------
CONTENT-TYPE: application/octet-stream; name=sample_attachement
This is just an input stream
---------------------------
Submit your Tutorials, White Papers and Articles into our Tutorials Directory. This is a tutorials database where we are keeping all the tutorials shared by the internet community for the benefit of others.
This is the message envelope
---------------------------
FROM: XYZ <[email protected]>
TO: ABC <[email protected]>
SUBJECT: Inline Image
----------------------------
CONTENT-TYPE: multipart/related; boundary=f46d04182582be803504e8ece94b
This is a Multipart
---------------------------
----------------------------
CONTENT-TYPE: text/plain; charset=ISO-8859-1
This is plain text
---------------------------
Hi I've an inline image
[image: Inline image 3]
--
Regards
XYZ
----------------------------
CONTENT-TYPE: image/png; name="javamail-mini-logo.png"
content typeimage/png; name="javamail-mini-logo.png"Hier sehen Sie drei E-Mails in unserer Mailbox. Zuerst eine einfache Mail mit der Nachricht "Hi am a simple message string ....". Die zweite Mail hat einen Anhang. Der Inhalt des Anhangs wird ebenfalls wie oben dargestellt gedruckt. Die dritte Mail hat ein Inline-Bild.
Wir werden unsere CheckingMails.java aus dem Kapitel Checking Emails ändern . Sein Inhalt ist wie folgt:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Authenticator;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Store;
public class CheckingMails {
public static void check(String host, String storeType, String user,
String password)
{
try {
// create properties field
Properties properties = new Properties();
properties.put("mail.pop3s.host", host);
properties.put("mail.pop3s.port", "995");
properties.put("mail.pop3s.starttls.enable", "true");
// Setup authentication, get session
Session emailSession = Session.getInstance(properties,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
"[email protected]", "manisha123");
}
});
// emailSession.setDebug(true);
// create the POP3 store object and connect with the pop server
Store store = emailSession.getStore("pop3s");
store.connect();
// create the folder object and open it
Folder emailFolder = store.getFolder("INBOX");
emailFolder.open(Folder.READ_ONLY);
// retrieve the messages from the folder in an array and print it
Message[] messages = emailFolder.getMessages();
System.out.println("messages.length---" + messages.length);
for (int i = 0, n = messages.length; i < n; i++) {
Message message = messages[i];
System.out.println("---------------------------------");
System.out.println("Email Number " + (i + 1));
System.out.println("Subject: " + message.getSubject());
System.out.println("From: " + message.getFrom()[0]);
System.out.println("Text: " + message.getContent().toString());
}
// close the store and folder objects
emailFolder.close(false);
store.close();
} catch (NoSuchProviderException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String host = "pop.gmail.com";// change accordingly
String mailStoreType = "pop3";
String username = "[email protected]";// change accordingly
String password = "*****";// change accordingly
check(host, mailStoreType, username, password);
}
}Sie können das Debuggen aktivieren, indem Sie die Anweisung emailSession.setDebug (true) auskommentieren.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse CheckingMails.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMailsÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole wird eine ähnliche Meldung wie unten angezeigt:
messages.length---3
---------------------------------
Email Number 1
Subject: Today is a nice day
From: XYZ <[email protected]>
Text: javax.mail.internet.MimeMultipart@45f676cb
---------------------------------
Email Number 2
Subject: hiiii....
From: XYZ <[email protected]>
Text: javax.mail.internet.MimeMultipart@37f12d4f
---------------------------------
Email Number 3
Subject: helloo
From: XYZ <[email protected]>
Text: javax.mail.internet.MimeMultipart@3ad5ba3aIn diesem Kapitel erfahren Sie, wie Sie mit der JavaMail-API auf eine E-Mail antworten. Grundlegende Schritte im folgenden Programm sind:
Rufen Sie das Sitzungsobjekt mit POP- und SMTP-Serverdetails in den Eigenschaften ab. Wir benötigen POP-Details zum Abrufen von Nachrichten und SMTP-Details zum Senden von Nachrichten.
Erstellen Sie ein POP3-Geschäftsobjekt und stellen Sie eine Verbindung zum Geschäft her.
Erstellen Sie ein Ordnerobjekt und öffnen Sie den entsprechenden Ordner in Ihrer Mailbox.
Nachrichten abrufen.
Durchlaufen Sie die Nachrichten und geben Sie "Y" oder "y" ein, wenn Sie antworten möchten.
Holen Sie sich alle Informationen (An, Von, Betreff, Inhalt) der Nachricht.
Erstellen Sie die Antwortnachricht mit der Methode Message.reply (). Diese Methode konfiguriert eine neue Nachricht mit dem richtigen Empfänger und Betreff. Die Methode verwendet einen booleschen Parameter, der angibt, ob nur auf den Absender (false) oder auf alle (true) geantwortet werden soll.
Legen Sie in der Nachricht Von, Text und Antwort an fest und senden Sie sie über die Instanz des Transportobjekts.
Schließen Sie die Transport-, Ordner- und Speicherobjekte.
Hier haben wir den JangoSMTP-Server verwendet, über den E-Mails an unsere Ziel-E-Mail-Adresse gesendet werden. Das Setup wird im Kapitel Umgebungs-Setup erläutert .
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei ReplyToEmail, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.Properties;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Store;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class ReplyToEmail {
public static void main(String args[])
{
Date date = null;
Properties properties = new Properties();
properties.put("mail.store.protocol", "pop3");
properties.put("mail.pop3s.host", "pop.gmail.com");
properties.put("mail.pop3s.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.starttls.enable", "true");
properties.put("mail.smtp.host", "relay.jangosmtp.net");
properties.put("mail.smtp.port", "25");
Session session = Session.getDefaultInstance(properties);
// session.setDebug(true);
try
{
// Get a Store object and connect to the current host
Store store = session.getStore("pop3s");
store.connect("pop.gmail.com", "[email protected]",
"*****");//change the user and password accordingly
Folder folder = store.getFolder("inbox");
if (!folder.exists()) {
System.out.println("inbox not found");
System.exit(0);
}
folder.open(Folder.READ_ONLY);
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
Message[] messages = folder.getMessages();
if (messages.length != 0) {
for (int i = 0, n = messages.length; i < n; i++) {
Message message = messages[i];
date = message.getSentDate();
// Get all the information from the message
String from = InternetAddress.toString(message.getFrom());
if (from != null) {
System.out.println("From: " + from);
}
String replyTo = InternetAddress.toString(message
.getReplyTo());
if (replyTo != null) {
System.out.println("Reply-to: " + replyTo);
}
String to = InternetAddress.toString(message
.getRecipients(Message.RecipientType.TO));
if (to != null) {
System.out.println("To: " + to);
}
String subject = message.getSubject();
if (subject != null) {
System.out.println("Subject: " + subject);
}
Date sent = message.getSentDate();
if (sent != null) {
System.out.println("Sent: " + sent);
}
System.out.print("Do you want to reply [y/n] : ");
String ans = reader.readLine();
if ("Y".equals(ans) || "y".equals(ans)) {
Message replyMessage = new MimeMessage(session);
replyMessage = (MimeMessage) message.reply(false);
replyMessage.setFrom(new InternetAddress(to));
replyMessage.setText("Thanks");
replyMessage.setReplyTo(message.getReplyTo());
// Send the message by authenticating the SMTP server
// Create a Transport instance and call the sendMessage
Transport t = session.getTransport("smtp");
try {
//connect to the SMTP server using transport instance
//change the user and password accordingly
t.connect("abc", "****");
t.sendMessage(replyMessage,
replyMessage.getAllRecipients());
} finally {
t.close();
}
System.out.println("message replied successfully ....");
// close the store and folder objects
folder.close(false);
store.close();
} else if ("n".equals(ans)) {
break;
}
}//end of for loop
} else {
System.out.println("There is no msg....");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}Sie können das Debuggen aktivieren, indem Sie die Anweisung session.setDebug (true) auskommentieren.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse ReplyToEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden auszuführenden Befehl aus:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
From: ABC <[email protected]>
Reply-to: [email protected]
To: XYZ <[email protected]>
Subject: Hi today is a nice day
Sent: Thu Oct 17 15:58:37 IST 2013
Do you want to reply [y/n] : y
message replied successfully ....Überprüfen Sie den Posteingang, an den die E-Mail gesendet wurde. In unserem Fall sieht die empfangene Nachricht wie folgt aus:
In diesem Kapitel erfahren Sie, wie Sie eine E-Mail mithilfe der JavaMail-API weiterleiten. Grundlegende Schritte im folgenden Programm sind:
Rufen Sie das Sitzungsobjekt mit POP- und SMTP-Serverdetails in den Eigenschaften ab. Wir benötigen POP-Details zum Abrufen von Nachrichten und SMTP-Details zum Senden von Nachrichten.
Erstellen Sie ein POP3-Geschäftsobjekt und stellen Sie eine Verbindung zum Geschäft her.
Erstellen Sie ein Ordnerobjekt und öffnen Sie den entsprechenden Ordner in Ihrer Mailbox.
Nachrichten abrufen.
Durchlaufen Sie die Nachrichten und geben Sie "Y" oder "y" ein, wenn Sie weiterleiten möchten.
Holen Sie sich alle Informationen (An, Von, Betreff, Inhalt) der Nachricht.
Erstellen Sie die Weiterleitungsnachricht, indem Sie mit den Teilen arbeiten, aus denen eine Nachricht besteht. Der erste Teil wäre der Text der Nachricht und ein zweiter Teil wäre die weiterzuleitende Nachricht. Kombinieren Sie die beiden zu einem mehrteiligen. Dann fügen Sie das Multipart zu einer richtig adressierten Nachricht hinzu und senden es.
Schließen Sie die Transport-, Ordner- und Speicherobjekte.
Hier haben wir den JangoSMTP-Server verwendet, über den E-Mails an unsere Ziel-E-Mail-Adresse gesendet werden. Das Setup wird im Kapitel Umgebungs-Setup erläutert .
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei ForwardEmail, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.Properties;
import javax.mail.BodyPart;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Store;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class ForwardEmail {
public static void main(String[] args) {
Properties properties = new Properties();
properties.put("mail.store.protocol", "pop3");
properties.put("mail.pop3s.host", "pop.gmail.com");
properties.put("mail.pop3s.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.host", "relay.jangosmtp.net");
properties.put("mail.smtp.port", "25");
Session session = Session.getDefaultInstance(properties);
try {
// session.setDebug(true);
// Get a Store object and connect to the current host
Store store = session.getStore("pop3s");
store.connect("pop.gmail.com", "[email protected]",
"*****");//change the user and password accordingly
// Create a Folder object and open the folder
Folder folder = store.getFolder("inbox");
folder.open(Folder.READ_ONLY);
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
Message[] messages = folder.getMessages();
if (messages.length != 0) {
for (int i = 0, n = messages.length; i < n; i++) {
Message message = messages[i];
// Get all the information from the message
String from = InternetAddress.toString(message.getFrom());
if (from != null) {
System.out.println("From: " + from);
}
String replyTo = InternetAddress.toString(message
.getReplyTo());
if (replyTo != null) {
System.out.println("Reply-to: " + replyTo);
}
String to = InternetAddress.toString(message
.getRecipients(Message.RecipientType.TO));
if (to != null) {
System.out.println("To: " + to);
}
String subject = message.getSubject();
if (subject != null) {
System.out.println("Subject: " + subject);
}
Date sent = message.getSentDate();
if (sent != null) {
System.out.println("Sent: " + sent);
}
System.out.print("Do you want to reply [y/n] : ");
String ans = reader.readLine();
if ("Y".equals(ans) || "y".equals(ans)) {
Message forward = new MimeMessage(session);
// Fill in header
forward.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(from));
forward.setSubject("Fwd: " + message.getSubject());
forward.setFrom(new InternetAddress(to));
// Create the message part
MimeBodyPart messageBodyPart = new MimeBodyPart();
// Create a multipart message
Multipart multipart = new MimeMultipart();
// set content
messageBodyPart.setContent(message, "message/rfc822");
// Add part to multi part
multipart.addBodyPart(messageBodyPart);
// Associate multi-part with message
forward.setContent(multipart);
forward.saveChanges();
// Send the message by authenticating the SMTP server
// Create a Transport instance and call the sendMessage
Transport t = session.getTransport("smtp");
try {
//connect to the SMTP server using transport instance
//change the user and password accordingly
t.connect("abc", "*****");
t.sendMessage(forward, forward.getAllRecipients());
} finally {
t.close();
}
System.out.println("message forwarded successfully....");
// close the store and folder objects
folder.close(false);
store.close();
}// end if
}// end for
}// end if
} catch (Exception e) {
e.printStackTrace();
}
}
}Sie können das Debuggen aktivieren, indem Sie die Anweisung session.setDebug (true) auskommentieren.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse ForwardEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden auszuführenden Befehl aus:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
From: ABC <[email protected]>
Reply-to: [email protected]
To: XYZ <[email protected]>
Subject: Hi today is a nice day
Sent: Thu Oct 17 15:58:37 IST 2013
Do you want to reply [y/n] : y
message forwarded successfully....Überprüfen Sie den Posteingang, an den die E-Mail gesendet wurde. In unserem Fall würde die weitergeleitete Nachricht wie folgt aussehen:
In diesem Kapitel erfahren Sie, wie Sie eine E-Mail mithilfe der JavaMail-API löschen. Das Löschen von Nachrichten umfasst das Arbeiten mit den Flags, die den Nachrichten zugeordnet sind. Es gibt verschiedene Flags für verschiedene Zustände, einige systemdefiniert und einige benutzerdefiniert. Die vordefinierten Flags werden in der inneren Klasse Flags.Flag definiert und sind unten aufgeführt:
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
Das POP-Protokoll unterstützt nur das Löschen der Nachrichten.
Grundlegende Schritte im Löschprogramm sind:
Rufen Sie das Sitzungsobjekt mit POP- und SMTP-Serverdetails in den Eigenschaften ab. Wir benötigen POP-Details zum Abrufen von Nachrichten und SMTP-Details zum Senden von Nachrichten.
Erstellen Sie ein POP3-Geschäftsobjekt und stellen Sie eine Verbindung zum Geschäft her.
Erstellen Sie ein Ordnerobjekt und öffnen Sie den entsprechenden Ordner in Ihrem Postfach im READ_WRITE-Modus.
Ruft Nachrichten aus dem Posteingangsordner ab.
Durchlaufen Sie die Nachrichten und geben Sie "Y" oder "y" ein, wenn Sie die Nachricht löschen möchten, indem Sie die Methode setFlag (Flags.Flag.DELETED, true) für das Nachrichtenobjekt aufrufen.
Die mit DELETED gekennzeichneten Nachrichten werden erst gelöscht, wenn wir die expunge () -Methode für das Folder-Objekt aufrufen oder den Ordner schließen, wenn expunge auf true gesetzt ist.
Schließen Sie das Speicherobjekt.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei ForwardEmail, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;
import javax.mail.Flags;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.Session;
import javax.mail.Store;
public class DeleteEmail {
public static void delete(String pop3Host, String storeType, String user,
String password)
{
try
{
// get the session object
Properties properties = new Properties();
properties.put("mail.store.protocol", "pop3");
properties.put("mail.pop3s.host", pop3Host);
properties.put("mail.pop3s.port", "995");
properties.put("mail.pop3.starttls.enable", "true");
Session emailSession = Session.getDefaultInstance(properties);
// emailSession.setDebug(true);
// create the POP3 store object and connect with the pop server
Store store = emailSession.getStore("pop3s");
store.connect(pop3Host, user, password);
// create the folder object and open it
Folder emailFolder = store.getFolder("INBOX");
emailFolder.open(Folder.READ_WRITE);
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
// retrieve the messages from the folder in an array and print it
Message[] messages = emailFolder.getMessages();
System.out.println("messages.length---" + messages.length);
for (int i = 0; i < messages.length; i++) {
Message message = messages[i];
System.out.println("---------------------------------");
System.out.println("Email Number " + (i + 1));
System.out.println("Subject: " + message.getSubject());
System.out.println("From: " + message.getFrom()[0]);
String subject = message.getSubject();
System.out.print("Do you want to delete this message [y/n] ? ");
String ans = reader.readLine();
if ("Y".equals(ans) || "y".equals(ans)) {
// set the DELETE flag to true
message.setFlag(Flags.Flag.DELETED, true);
System.out.println("Marked DELETE for message: " + subject);
} else if ("n".equals(ans)) {
break;
}
}
// expunges the folder to remove messages which are marked deleted
emailFolder.close(true);
store.close();
} catch (NoSuchProviderException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
} catch (IOException io) {
io.printStackTrace();
}
}
public static void main(String[] args) {
String host = "pop.gmail.com";// change accordingly
String mailStoreType = "pop3";
String username = "[email protected]";// change accordingly
String password = "*****";// change accordingly
delete(host, mailStoreType, username, password);
}
}Sie können das Debuggen aktivieren, indem Sie die Anweisung emailSession.setDebug (true) auskommentieren.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse DeleteEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden auszuführenden Befehl aus:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
messages.length---1
---------------------------------
Email Number 1
Subject: Testing
From: ABC <[email protected]>
Do you want to delete this message [y/n] ? y
Marked DELETE for message: TestingIn allen vorherigen Kapiteln haben wir den JangoSMTP-Server zum Senden von E-Mails verwendet. In diesem Kapitel erfahren Sie mehr über den von Google Mail bereitgestellten SMTP-Server. Google Mail bietet (unter anderem) die kostenlose Nutzung seines öffentlichen SMTP-Servers an.
Details zum Google Mail SMTP-Server finden Sie hier . Wie Sie in den Details sehen können, können wir entweder eine TLS- oder eine SSL-Verbindung verwenden, um E-Mails über den Google Mail-SMTP-Server zu senden.
Das Verfahren zum Senden von E-Mails über den Google Mail-SMTP-Server ist ähnlich wie im Kapitel Senden von E-Mails beschrieben , außer dass wir den Host-Server ändern würden. Voraussetzung ist, dass die Absender-E-Mail-Adresse ein aktives Google Mail-Konto ist. Versuchen wir ein Beispiel.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Datei SendEmailUsingGMailSMTP, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendEmailUsingGMailSMTP {
public static void main(String[] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";//change accordingly
// Sender's email ID needs to be mentioned
String from = "[email protected]";//change accordingly
final String username = "abc";//change accordingly
final String password = "*****";//change accordingly
// Assuming you are sending email through relay.jangosmtp.net
String host = "smtp.gmail.com";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", "587");
// Get the Session object.
Session session = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
try {
// Create a default MimeMessage object.
Message message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
// Set Subject: header field
message.setSubject("Testing Subject");
// Now set the actual message
message.setText("Hello, this is sample for to check send "
+ "email using JavaMailAPI ");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}Hier wird der Host als smtp.gmail.com und der Port als 587 festgelegt . Hier haben wir die TLS-Verbindung aktiviert.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse SendEmailUsingGMailSMTP.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTPÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
Sent message successfully....Bisher haben wir in unseren vorherigen Kapiteln hauptsächlich mit dem INBOX-Ordner gearbeitet. Dies ist der Standardordner, in dem sich die meisten E-Mails befinden. Einige Systeme nennen es möglicherweise INBOX, andere nennen es möglicherweise einen anderen Namen. Sie können jedoch jederzeit über die JavaMail-API unter dem Namen INBOX darauf zugreifen.
Die JavaMail-API repräsentiert Ordner als Instanzen der abstrakten Ordnerklasse:
public abstract class Folder extends ObjectDiese Klasse deklariert Methoden zum Anfordern benannter Ordner von Servern, zum Löschen von Nachrichten aus Ordnern, zum Suchen nach bestimmten Nachrichten in Ordnern, zum Auflisten der Nachrichten in einem Ordner usw.
Ordner öffnen
Wir können keinen Ordner direkt erstellen, da der einzige Konstruktor in der Folder- Klasse geschützt ist . Wir können einen Ordner erhalten von:
eine Sitzung
ein Laden
oder ein anderer Ordner
Alle oben genannten Klassen haben eine ähnliche getFolder () -Methode mit ähnlicher Signatur:
public abstract Folder getFolder(String name) throws MessagingExceptionEinige der Methoden, die beim Abrufen des Ordnerobjekts hilfreich sind, sind:
| Methode | Beschreibung |
|---|---|
| Boolescher Wert existiert () | Überprüft, ob der Ordner wirklich vorhanden ist. Verwenden Sie diese Methode, bevor Sie das Ordnerobjekt abrufen. |
| abstrakte Leere offen (int-Modus) | Wenn Sie einen Ordner erhalten , ist dieser geschlossen. Verwenden Sie diese Methode, um es zu öffnen. Der Modus kann Folder.READ_ONLY oder Folder.READ_WRITE sein. |
| abstrakter boolescher Wert isOpen () | Diese Methode gibt true zurück , wenn der Ordner geöffnet ist, false, wenn er geschlossen ist |
| abstrakte Leere schließen (boolean expunge) | Schließt den Ordner. Wenn das Expunge- Argument wahr ist , werden alle gelöschten Nachrichten im Ordner aus der tatsächlichen Datei auf dem Server gelöscht. Andernfalls werden sie einfach als gelöscht markiert , die Nachrichten können jedoch weiterhin gelöscht werden. |
Grundlegende Ordnerinformationen
Im Folgenden finden Sie einige Methoden in der Ordnerklasse, die grundlegende Informationen zu einem Ordner zurückgeben:
| Methode | Beschreibung |
|---|---|
| abstrakter String getName () | Gibt den Namen des Ordners zurück, z. B. "TutorialsPoint Mail". |
| abstrakter String getFullName () | Gibt den vollständigen hierarchischen Namen aus dem Stammverzeichnis zurück, z. B. "books / Manisha / TutorialsPoint Mail". |
| URLName getURLName () | Geben Sie einen URL-Namen zurück, der diesen Ordner darstellt. |
| abstrakter Ordner getParent () | Gibt den Namen des Ordners zurück, der diesen Ordner enthält, dh den übergeordneten Ordner. ZB "Manisha" aus dem vorherigen Beispiel "TutorialsPoint Mail". |
| abstract int getType () | Gibt ein int zurück, das angibt, ob der Ordner Nachrichten und / oder andere Ordner enthalten kann. |
| int getMode () | Es gibt eine der beiden benannten Konstanten Folder.READ_ONLY oder Folder.READ_WRITE oder -1 zurück, wenn der Modus unbekannt ist. |
| Speichern Sie getStore () | Gibt das Store-Objekt zurück, aus dem dieser Ordner abgerufen wurde. |
| abstrakter char getSeparator () | Geben Sie das Trennzeichen zurück, das den Pfadnamen dieses Ordners von den Namen der unmittelbaren Unterordner trennt. |
Ordner verwalten
Im Folgenden finden Sie einige Methoden zur Verwaltung des Ordners:
| Methode | Beschreibung |
|---|---|
| abstraktes boolesches create (int type) | Dadurch wird ein neuer Ordner im Store dieses Ordners erstellt. Wo Typ wäre: Folder.HOLDS_MESSAGES oder Folder.HOLDS_FOLDERS. Gibt true zurück, wenn der Ordner erfolgreich erstellt wurde. Andernfalls wird false zurückgegeben . |
| abstrakte boolesche Löschung (boolesche Rekursion) | Dadurch wird der Ordner nur gelöscht, wenn der Ordner geschlossen ist. Andernfalls wird eine IllegalStateException ausgelöst . Wenn recurse ist wahr , werden dann Unterordner gelöscht. |
| abstrakter boolescher RenameTo (Ordner f) | Dies ändert den Namen dieses Ordners. Ein Ordner muss geschlossen sein, um umbenannt zu werden. Andernfalls wird eine IllegalStateException ausgelöst. |
Verwalten von Nachrichten in Ordnern
Im Folgenden finden Sie einige Methoden, mit denen Sie die Nachrichten im Ordner verwalten können:
| Methode | Beschreibung |
|---|---|
| abstract void appendMessages (Message [] messages) | Wie der Name schon sagt, werden die Nachrichten im Array am Ende dieses Ordners platziert. |
| void copyMessages (Message [] -Nachrichten, Ordnerziel ) | Dadurch werden Nachrichten aus diesem Ordner in einen angegebenen Ordner kopiert, der als Argument angegeben wird. |
| abstrakte Nachricht [] expunge () | Um eine Nachricht aus einem Ordner zu löschen, setzen Sie das Flag Flags.Flag.DELETED auf true. Um gelöschte Nachrichten physisch aus einem Ordner zu entfernen, müssen Sie diese Methode aufrufen. |
Auflisten des Inhalts eines Ordners
Es gibt vier Methoden, um die Ordner aufzulisten, die ein Ordner enthält:
| Methode | Beschreibung |
|---|---|
| Ordner [] Liste () | Dies gibt ein Array zurück, das die Ordner auflistet, die dieser Ordner enthält. |
| Ordner [] listSubscribed () | Dies gibt ein Array zurück, das alle abonnierten Ordner auflistet, die dieser Ordner enthält. |
| abstrakte Ordner [] Liste (String-Muster) | Dies ähnelt der list () -Methode, mit der Ausnahme, dass Sie ein Muster angeben können. Das Muster ist eine Zeichenfolge, die den Namen der übereinstimmenden Ordner angibt. |
| Ordner [] listSubscribe ( Zeichenfolgenmuster ) | Dies ähnelt der Methode listSubscribe () , mit der Ausnahme, dass Sie ein Muster angeben können. Das Muster ist eine Zeichenfolge, die den Namen der übereinstimmenden Ordner angibt. |
Nach Mail suchen
| Methode | Beschreibung |
|---|---|
| abstract int getMessageCount () | Diese Methode kann für einen geöffneten oder geschlossenen Ordner aufgerufen werden. Im Fall eines geschlossenen Ordners kann diese Methode jedoch -1 zurückgeben (oder auch nicht), um anzuzeigen, dass die genaue Anzahl der Nachrichten nicht leicht verfügbar ist. |
| abstrakter Boolescher Wert hasNewMessages () | Dies gibt true zurück , wenn dem Ordner seit dem letzten Öffnen neue Nachrichten hinzugefügt wurden. |
| int getNewMessageCount () | Es gibt die Anzahl der neuen Nachrichten zurück, indem Nachrichten in dem Ordner überprüft werden, dessen RECENT-Flag gesetzt ist. |
| int getUnreadMessageCount () | Dies kann entweder in einem offenen oder einem geschlossenen Ordner aufgerufen werden. Im Fall eines geschlossenen Ordners kann jedoch -1 zurückgegeben werden, um anzuzeigen, dass die tatsächliche Antwort zu teuer wäre, um sie zu erhalten. |
Nachrichten aus Ordnern abrufen
Die Folder-Klasse bietet vier Methoden zum Abrufen von Nachrichten aus geöffneten Ordnern:
| Methode | Beschreibung |
|---|---|
| abstrakte Nachricht getMessage (int messageNumber) | Dies gibt die n-te Nachricht im Ordner zurück. Die erste Nachricht im Ordner ist Nummer 1. |
| Nachricht [] getMessages () | Dies gibt ein Array von Nachrichtenobjekten zurück , die alle Nachrichten in diesem Ordner darstellen. |
| Nachricht [] getMessages (int start, int end) | Dies gibt ein Array von Nachrichtenobjekten aus dem Ordner zurück, beginnend mit start und endend mit end einschließlich. |
| Nachricht [] getMessages (int [] messageNumbers) | Dies gibt ein Array zurück, das nur die Nachrichten enthält, die speziell durch die Nummer im Array messageNumbers identifiziert wurden . |
| void fetch (Message [] Nachrichten, FetchProfile fp) | Rufen Sie die im FetchProfile angegebenen Elemente für die angegebenen Nachrichten vor. Das Argument FetchProfile gibt an, welche Header in den Nachrichten vorab abgerufen werden sollen. |
Ordner durchsuchen
Wenn der Server die Suche unterstützt (wie viele IMAP-Server und die meisten POP-Server nicht), ist es einfach, einen Ordner nach Nachrichten zu durchsuchen, die bestimmte Kriterien erfüllen. Die Kriterien werden in SearchTerm-Objekten codiert. Es folgen die beiden Suchmethoden:
| Methode | Beschreibung |
|---|---|
| Nachricht [] Suche (Suchbegriff term) | Durchsuchen Sie diesen Ordner nach Nachrichten, die dem angegebenen Suchkriterium entsprechen. Gibt ein Array zurück, das die übereinstimmenden Nachrichten enthält. Gibt ein leeres Array zurück, wenn keine Übereinstimmungen gefunden wurden. |
| Nachricht [] Suche (Suchbegriff Begriff, Nachricht [] Nachrichten) | Durchsuchen Sie das angegebene Nachrichtenarray nach Nachrichten, die dem angegebenen Suchkriterium entsprechen. Gibt ein Array zurück, das die übereinstimmenden Nachrichten enthält. Gibt ein leeres Array zurück, wenn keine Übereinstimmungen gefunden wurden. Die angegebenen Nachrichtenobjekte müssen zu diesem Ordner gehören. |
Flaggen
Die Änderung von Flags ist nützlich, wenn Sie Flags für den gesamten Nachrichtensatz in einem Ordner ändern müssen. Im Folgenden sind die in der Ordnerklasse bereitgestellten Methoden aufgeführt:
| Methode | Beschreibung |
|---|---|
| void setFlags (Message [] Nachrichten, Flags Flag, Boolescher Wert) | Setzt die angegebenen Flags für die im Array angegebenen Nachrichten. |
| void setFlags (int start, int end, Flags-Flag, boolescher Wert) | Setzt die angegebenen Flags für die Nachrichten, die von Anfang bis Ende nummeriert sind, sowohl Start als auch Ende einschließlich. |
| void setFlags (int [] messageNumbers, Flags-Flag, boolescher Wert) | Setzt die angegebenen Flags für die Nachrichten, deren Nachrichtennummern sich im Array befinden. |
| abstrakte Flags getPermanentFlags () | Gibt die Flags zurück, die dieser Ordner für alle Nachrichten unterstützt. |
Ein Kontingent in JavaMail ist eine begrenzte oder feste Anzahl oder Anzahl von Nachrichten in einem E-Mail-Speicher. Jede Mail-Dienstanforderung wird auf das JavaMail-API-Aufrufkontingent angerechnet. Ein E-Mail-Dienst kann Folgendes Kontingentkriterium anwenden:
Maximale Größe ausgehender E-Mail-Nachrichten, einschließlich Anhängen.
Maximale Größe eingehender E-Mail-Nachrichten, einschließlich Anhänge.
Maximale Nachrichtengröße, wenn ein Administrator Empfänger ist
Für die Kontingentverwaltung verfügt JavaMail über folgende Klassen:
| Klasse | Beschreibung |
|---|---|
| öffentliche Klasse Quote | Diese Klasse repräsentiert eine Reihe von Kontingenten für eine bestimmte Kontingentwurzel. Jeder Kontingentstamm verfügt über eine Reihe von Ressourcen, die durch die Quota.Resource-Klasse dargestellt werden. Jede Ressource hat einen Namen (z. B. "STORAGE"), eine aktuelle Verwendung und ein Nutzungslimit. Dies hat nur eine Methode setResourceLimit (String name, long limit) . |
| öffentliche statische Klasse Quota.Resource | Stellt eine einzelne Ressource in einem Kontingentstamm dar. |
| öffentliche Schnittstelle QuotaAwareStore | Eine von Stores implementierte Schnittstelle, die Kontingente unterstützt. Die Methoden getQuota und setQuota unterstützen das durch die IMAP QUOTA-Erweiterung definierte Kontingentmodell. GmailSSLStore, GmailStore, IMAPSSLStore, IMAPStore sind die bekannten Implementierungsklassen dieser Schnittstelle. |
Lassen Sie uns in den folgenden Abschnitten ein Beispiel sehen, in dem der Name, das Limit und die Verwendung des E-Mail-Speichers überprüft werden.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei QuotaExample, deren Inhalt wie folgt ist:
package com.tutorialspoint;
import java.util.Properties;
import javax.mail.Quota;
import javax.mail.Session;
import javax.mail.Store;
import com.sun.mail.imap.IMAPStore;
public class QuotaExample
{
public static void main(String[] args)
{
try
{
Properties properties = new Properties();
properties.put("mail.store.protocol", "imaps");
properties.put("mail.imaps.port", "993");
properties.put("mail.imaps.starttls.enable", "true");
Session emailSession = Session.getDefaultInstance(properties);
// emailSession.setDebug(true);
// create the IMAP3 store object and connect with the pop server
Store store = emailSession.getStore("imaps");
//change the user and password accordingly
store.connect("imap.gmail.com", "[email protected]", "*****");
IMAPStore imapStore = (IMAPStore) store;
System.out.println("imapStore ---" + imapStore);
//get quota
Quota[] quotas = imapStore.getQuota("INBOX");
//Iterate through the Quotas
for (Quota quota : quotas) {
System.out.println(String.format("quotaRoot:'%s'",
quota.quotaRoot));
//Iterate through the Quota Resource
for (Quota.Resource resource : quota.resources) {
System.out.println(String.format(
"name:'%s', limit:'%s', usage:'%s'", resource.name,
resource.limit, resource.usage));
}
}
} catch (Exception e)
{
e.printStackTrace();
}
}
}Hier finden Sie eine Verbindung zum Google Mail-Dienst über den IMAP-Server (imap.gmail.com), da IMAPStore den QuotaAwareStore implementiert. Wenn Sie das Store-Objekt erhalten haben, rufen Sie das Quota-Array ab, durchlaufen Sie es und drucken Sie die relevanten Informationen.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse QuotaExample.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExampleÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte eine ähnliche Meldung angezeigt werden:
imapStore ---imaps://abc%[email protected]
quotaRoot:''
name:'STORAGE', limit:'15728640', usage:'513'Eine Nachricht kann aus mehreren Gründen zurückgeschickt werden. Dieses Problem wird unter rfc1211 ausführlich erörtert . Nur ein Server kann das Vorhandensein eines bestimmten Postfachs oder Benutzernamens feststellen. Wenn der Server einen Fehler feststellt, gibt er eine Nachricht mit dem Grund für den Fehler an den Absender der ursprünglichen Nachricht zurück.
Es gibt viele Internetstandards für Zustellstatusbenachrichtigungen, aber eine große Anzahl von Servern unterstützt diese neuen Standards nicht, sondern verwendet Ad-hoc-Techniken zum Zurückgeben solcher Fehlermeldungen. Daher bekommt es sehr schwierig , die korrelieren prallte Nachricht mit der ursprünglichen Nachricht, die das Problem verursacht.
JavaMail unterstützt das Parsen von Zustellungsstatusbenachrichtigungen. Es gibt eine Reihe von Techniken und Heuristiken, um dieses Problem zu lösen. Eine der Techniken sind Variable Envelope Return Paths. Sie können den Rückweg im Umschlag wie im folgenden Beispiel gezeigt einstellen. Dies ist die Adresse, an die Bounce-Mails gesendet werden. Möglicherweise möchten Sie eine andere generische Adresse als den From: -Header festlegen, damit Sie Remote-Bounces verarbeiten können. Dies erfolgt durch Festlegen der Eigenschaft mail.smtp.from in JavaMail.
Erstellen Sie eine Java-Klasse
Erstellen Sie eine Java-Klassendatei SendEmail, deren Inhalt wie folgt ist:
import java.util.Properties;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendEmail {
public static void main(String[] args) throws Exception {
String smtpServer = "smtp.gmail.com";
int port = 587;
final String userid = "youraddress";//change accordingly
final String password = "*****";//change accordingly
String contentType = "text/html";
String subject = "test: bounce an email to a different address " +
"from the sender";
String from = "[email protected]";
String to = "[email protected]";//some invalid address
String bounceAddr = "[email protected]";//change accordingly
String body = "Test: get message to bounce to a separate email address";
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", smtpServer);
props.put("mail.smtp.port", "587");
props.put("mail.transport.protocol", "smtp");
props.put("mail.smtp.from", bounceAddr);
Session mailSession = Session.getInstance(props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(userid, password);
}
});
MimeMessage message = new MimeMessage(mailSession);
message.addFrom(InternetAddress.parse(from));
message.setRecipients(Message.RecipientType.TO, to);
message.setSubject(subject);
message.setContent(body, contentType);
Transport transport = mailSession.getTransport();
try {
System.out.println("Sending ....");
transport.connect(smtpServer, port, userid, password);
transport.sendMessage(message,
message.getRecipients(Message.RecipientType.TO));
System.out.println("Sending done ...");
} catch (Exception e) {
System.err.println("Error Sending: ");
e.printStackTrace();
}
transport.close();
}// end function main()
}Hier können wir sehen, dass die Eigenschaft mail.smtp.from anders als die from- Adresse festgelegt ist.
Kompilieren und ausführen
Nachdem unsere Klasse fertig ist, lassen Sie uns die obige Klasse kompilieren. Ich habe die Klasse SendEmail.java im Verzeichnis gespeichert:/home/manisha/JavaMailAPIExercise. Wir müssten die Gläser javax.mail.jar und activation.jar in dem Classpath. Führen Sie den folgenden Befehl aus, um die Klasse (beide Jars befinden sich im Verzeichnis / home / manisha /) an der Eingabeaufforderung zu kompilieren:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.javaFühren Sie nach dem Kompilieren der Klasse den folgenden Befehl aus, um Folgendes auszuführen:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailÜberprüfen Sie die Ausgabe
Auf der Befehlskonsole sollte die folgende Meldung angezeigt werden:
Sending ....
Sending done ...SMTP ist eine Abkürzung für Simple Mail Transfer Protocol. Es ist ein Internetstandard für die E-Mail-Übertragung über IP-Netzwerke (Internet Protocol). SMTP verwendet den TCP-Port 25. Durch SSL gesicherte SMTP-Verbindungen sind der Kurzform SMTPS bekannt, obwohl SMTPS kein eigenständiges Protokoll ist.
JavaMail API hat Paket com.sun.mail.smtpdie als SMTP-Protokollanbieter für den Zugriff auf einen SMTP-Server fungieren. In der folgenden Tabelle sind die in diesem Paket enthaltenen Klassen aufgeführt:
| Klasse | Beschreibung |
|---|---|
| SMTPMessage | Diese Klasse ist eine Spezialisierung der MimeMessage-Klasse, mit der Sie verschiedene SMTP-Optionen und -Parameter angeben können, die beim Senden dieser Nachricht über SMTP verwendet werden. |
| SMTPSSLTransport | Diese Klasse implementiert die abstrakte Transportklasse mithilfe von SMTP über SSL für die Nachrichtenübermittlung und den Transport. |
| SMTPTransport | Diese Klasse implementiert die abstrakte Transportklasse mithilfe von SMTP für die Nachrichtenübermittlung und den Transport. |
In der folgenden Tabelle sind die ausgelösten Ausnahmen aufgeführt:
| Ausnahme | Beschreibung |
|---|---|
| SMTPAddressFailedException | Diese Ausnahme wird ausgelöst, wenn die Nachricht nicht gesendet werden kann. |
| SMTPAddressSucceededException | Diese Ausnahme wird von einer SendFailedException verkettet, wenn die Eigenschaft mail.smtp.reportsuccess wahr ist. |
| SMTPSenderFailedException | Diese Ausnahme wird ausgelöst, wenn die Nachricht nicht gesendet werden kann. |
| SMTPSendFailedException | Diese Ausnahme wird ausgelöst, wenn die Nachricht nicht gesendet werden kann. Die Ausnahme enthält die Absenderadresse, die der Mailserver abgelehnt hat. |
Das com.sun.mail.smtpAnbieter verwenden optional die SMTP-Authentifizierung. Um die SMTP-Authentifizierung verwenden zu können, müssen Sie die Eigenschaft mail.smtp.auth festlegen oder dem SMTP-Transport einen Benutzernamen und ein Kennwort geben, wenn Sie eine Verbindung zum SMTP-Server herstellen. Sie können dies mit einem der folgenden Ansätze tun:
Geben Sie beim Erstellen Ihrer Mail-Sitzung ein Authenticator-Objekt an und geben Sie während des Authenticator-Rückrufs den Benutzernamen und das Kennwort an. Die Eigenschaft mail.smtp.user kann so festgelegt werden, dass ein Standardbenutzername für den Rückruf angegeben wird. Das Kennwort muss jedoch weiterhin explizit angegeben werden. Mit diesem Ansatz können Sie die statische Transport-Sendemethode zum Senden von Nachrichten verwenden. Zum Beispiel:
Transport.send(message);Rufen Sie die Transport connect-Methode explizit mit Benutzernamen- und Kennwortargumenten auf. Zum Beispiel:
Transport tr = session.getTransport("smtp");
tr.connect(smtphost, username, password);
msg.saveChanges();
tr.sendMessage(msg, msg.getAllRecipients());
tr.close();Der SMTP-Protokollanbieter unterstützt die folgenden Eigenschaften, die im JavaMail-Sitzungsobjekt festgelegt werden können. Die Eigenschaften werden immer als Zeichenfolgen festgelegt. Zum Beispiel:
props.put("mail.smtp.port", "587");IMAP ist die Abkürzung für Internet Message Access Protocol. Es handelt sich um ein Internetprotokoll der Anwendungsschicht, mit dem ein E-Mail-Client auf einem Remote-Mailserver auf E-Mails zugreifen kann. Ein IMAP-Server überwacht normalerweise den bekannten Port 143. IMAP über SSL (IMAPS) wird der Portnummer 993 zugewiesen.
IMAP unterstützt sowohl Online- als auch Offline-Betriebsarten. E-Mail-Clients, die IMAP verwenden, hinterlassen im Allgemeinen Nachrichten auf dem Server, bis der Benutzer sie explizit löscht.
Paket com.sun.mail.imapist ein IMAP-Protokollanbieter für die JavaMail-API, der den Zugriff auf einen IMAP-Nachrichtenspeicher ermöglicht. In der folgenden Tabelle sind die Schnittstelle und Klassen dieses Anbieters aufgeführt:
| Klasse / Schnittstelle | Beschreibung |
|---|---|
| IMAPFolder.ProtocolCommand | Dies ist eine einfache Schnittstelle für benutzerdefinierte IMAP-Protokollbefehle. |
| ACL | Dies ist eine Klasse. Ein Eintrag in der Zugriffssteuerungsliste für eine bestimmte Authentifizierungskennung (Benutzer oder Gruppe). |
| IMAPFolder | Diese Klasse implementiert einen IMAP-Ordner. |
| IMAPFolder.FetchProfileItem | Dies ist eine Klasse zum Abrufen von Headern. |
| IMAPMessage | Diese Klasse implementiert ein ReadableMime-Objekt. |
| IMAPMessage.FetchProfileCondition | Diese Klasse implementiert den Test, der für jede Nachricht im Ordner durchgeführt werden soll. |
| IMAPSSLStore | Diese Klasse bietet Zugriff auf einen IMAP-Nachrichtenspeicher über SSL. |
| IMAPStore | Diese Klasse bietet Zugriff auf einen IMAP-Nachrichtenspeicher. |
| Rechte | Diese Klasse repräsentiert die Rechte für eine Authentifizierungskennung (z. B. einen Benutzer oder eine Gruppe). |
| Rechte | Diese innere Klasse repräsentiert ein individuelles Recht. |
| SortTerm | Ein bestimmtes Sortierkriterium gemäß RFC 5256. |
Einige Punkte, die über diesem Anbieter zu beachten sind:
Dieser Anbieter unterstützt sowohl das IMAP4- als auch das IMAP4rev1-Protokoll.
Ein verbundener IMAPStore verwaltet einen Pool von IMAP-Protokollobjekten zur Verwendung bei der Kommunikation mit dem IMAP-Server. Wenn Ordner geöffnet werden und neue IMAP-Protokollobjekte benötigt werden, stellt der IMAPStore diese aus dem Verbindungspool bereit oder erstellt sie, wenn keine verfügbar sind. Wenn ein Ordner geschlossen wird, wird sein IMAP-Protokollobjekt an den Verbindungspool zurückgegeben, wenn der Pool vorhanden ist.
Das verbundene IMAPStore-Objekt kann ein separates IMAP-Protokollobjekt verwalten oder nicht, das dem Speicher eine dedizierte Verbindung zum IMAP-Server bereitstellt.
Post Office Protocol (POP) ist ein Internet-Standardprotokoll auf Anwendungsebene, das von lokalen E-Mail-Clients verwendet wird, um E-Mails von einem Remote-Server über eine TCP / IP-Verbindung abzurufen. POP unterstützt einfache Download- und Löschanforderungen für den Zugriff auf Remote-Postfächer. Ein POP3-Server überwacht den bekannten Port 110.
Paket com.sun.mail.pop3ist ein POP3-Protokollanbieter für die JavaMail-API, der den Zugriff auf einen POP3-Nachrichtenspeicher ermöglicht. In der folgenden Tabelle sind die Klassen in diesem Paket aufgeführt:
| Name | Beschreibung |
|---|---|
| POP3Folder | Ein POP3-Ordner (kann nur "INBOX" sein). |
| POP3Message | Eine POP3-Nachricht. |
| POP3SSLStore | Ein POP3-Nachrichtenspeicher mit SSL. |
| POP3Store | Ein POP3-Nachrichtenspeicher. |
Einige Punkte, die über diesem Anbieter zu beachten sind:
Der POP3-Anbieter unterstützt nur einen einzigen Ordner mit dem Namen INBOX. Aufgrund der Einschränkungen des POP3-Protokolls sind viele der JavaMail-API-Funktionen wie Ereignisbenachrichtigung, Ordnerverwaltung, Flaggenverwaltung usw. nicht zulässig.
Auf den POP3-Anbieter wird über die JavaMail-APIs unter Verwendung des Protokollnamens pop3 oder einer URL der Form pop3: // Benutzer: Kennwort @ Host: Port / INBOX "zugegriffen .
POP3 unterstützt keine permanenten Flags. Beispielsweise wird das Flag Flags.Flag.RECENT für POP3-Nachrichten niemals gesetzt. Es ist auf die Anwendung zu bestimmen , welche Nachrichten in einem POP3 - Postfach sind neu .
POP3 unterstützt die Folder.expunge () -Methode nicht. Um Nachrichten zu löschen und zu löschen, setzen Sie das Flag Flags.Flag.DELETED für die Nachrichten und schließen Sie den Ordner mit der Methode Folder.close (true).
POP3 gibt kein Empfangsdatum an , daher gibt die Methode getReceivedDate null zurück.
Wenn auf die Header einer POP3-Nachricht zugegriffen wird, ruft der POP3-Anbieter mit dem Befehl TOP alle Header ab, die dann zwischengespeichert werden.
Wenn auf den Inhalt einer POP3-Nachricht zugegriffen wird, verwendet der POP3-Anbieter den Befehl RETR, um die gesamte Nachricht abzurufen.
Die Methode POP3Message.invalidate kann verwendet werden, um zwischengespeicherte Daten ungültig zu machen, ohne den Ordner zu schließen.