JavaMail API - Szybki przewodnik
JavaMail API zapewnia niezależną od platformy i protokołu strukturę do tworzenia aplikacji do obsługi poczty i przesyłania wiadomości. JavaMail API udostępnia zestaw abstrakcyjnych klas definiujących obiekty składające się na system pocztowy. Jest to opcjonalny pakiet (standardowe rozszerzenie) do czytania, tworzenia i wysyłania wiadomości elektronicznych.
JavaMail zawiera elementy używane do konstruowania interfejsu do systemu przesyłania wiadomości, w tym komponenty i interfejsy systemu. Chociaż ta specyfikacja nie definiuje żadnej konkretnej implementacji, JavaMail zawiera kilka klas, które implementują standardy komunikacji internetowej RFC822 i MIME. Te klasy są dostarczane jako część pakietu klas JavaMail.
Oto niektóre z protokołów obsługiwanych w JavaMail API:
SMTP: Akronim dla Simple Mail Transfer Protocol. Zapewnia mechanizm dostarczania poczty elektronicznej.
POP: Akronim dla Post Office Protocol. POP jest mechanizmem używanym przez większość ludzi w Internecie do odbierania poczty. Definiuje obsługę jednej skrzynki pocztowej dla każdego użytkownika. RFC 1939 definiuje ten protokół.
IMAP: Akronim dla Internet Message Access Protocol. Jest to zaawansowany protokół do odbierania wiadomości. Zapewnia obsługę wielu skrzynek pocztowych dla każdego użytkownika, ponadto skrzynka pocztowa może być współużytkowana przez wielu użytkowników. Jest zdefiniowany w RFC 2060.
MIME: Akronim dla Multipurpose Internet Mail Extensions. . To nie jest protokół przesyłania poczty. Zamiast tego definiuje treść przesyłanych elementów: format wiadomości, załączników i tak dalej. Istnieje wiele różnych dokumentów, które wchodzą w życie w tym miejscu: RFC 822, RFC 2045, RFC 2046 i RFC 2047. Jako użytkownik JavaMail API zazwyczaj nie musisz się martwić o te formaty. Jednak te formaty istnieją i są używane przez Twoje programy.
NNTP and Others: Istnieje wiele protokołów udostępnianych przez dostawców zewnętrznych. Niektóre z nich to Network News Transfer Protocol (NNTP), Secure Multipurpose Internet Mail Extensions (S / MIME) itp.
Szczegóły tego zostaną omówione w kolejnych rozdziałach.
Architektura
Jak wspomniano powyżej, aplikacja java wykorzystuje API JavaMail do tworzenia, wysyłania i odbierania wiadomości e-mail. Poniższy rysunek ilustruje architekturę JavaMail:
Abstrakcyjny mechanizm interfejsu API JavaMail jest podobny do innych interfejsów API J2EE, takich jak JDBC, JNDI i JMS. Jak widać na powyższym diagramie architektury, JavaMail API jest podzielony na dwie główne części:
Część niezależna od aplikacji: interfejs programowania aplikacji (API) jest używany przez składniki aplikacji do wysyłania i odbierania wiadomości e-mail, niezależnie od dostawcy bazowego lub używanego protokołu.
Część zależna od usługi: interfejs dostawcy usług (SPI) mówi w językach specyficznych dla protokołu, takich jak SMTP, POP, IMAP i Network News Transfer Protocol (NNTP). Służy do podłączenia dostawcy usługi e-mail do platformy J2EE.
Wysłanie wiadomości e-mail za pomocą aplikacji Java jest dość proste, ale na początek powinieneś JavaMail API i Java Activation Framework (JAF) zainstalowany na twoim komputerze.
Będziesz potrzebował JavaBeans Activation Framework (JAF)rozszerzenie, które udostępnia pakiet javax.activation tylko wtedy, gdy nie używasz Java SE 6 lub nowszej.
Możesz pobrać najnowszą wersję JavaMail (wersja 1.5.0) ze standardowej witryny Java.
Możesz pobrać najnowszą wersję JAF (wersja 1.1.1) ze standardowej witryny Java.
Pobierz i rozpakuj te pliki, w nowo utworzonych katalogach najwyższego poziomu znajdziesz kilka plików jar dla obu aplikacji. Musisz dodaćmail.jar i activation.jar pliki w CLASSPATH.
Serwer SMTP
Aby wysyłać e-maile, musisz mieć serwer SMTP, który jest odpowiedzialny za wysyłanie e-maili. Możesz użyć jednej z następujących technik, aby uzyskać serwer SMTP:
Zainstaluj i używaj dowolnego serwera SMTP, takiego jak serwer Postfix (dla Ubuntu), serwer Apache James (serwer Java Apache Mail Enterprise Server) itp. (lub)
Skorzystaj z serwera SMTP dostarczonego przez dostawcę hosta, na przykład: bezpłatna witryna SMTP udostępniana przez JangoSMTP to relay.jangosmtp.net (lub)
Skorzystaj z serwera SMTP dostarczonego przez firmy, np. Gmail, yahoo itp.
W przykładach w kolejnych rozdziałach do wysyłania e-maili wykorzystaliśmy darmowy serwer JangoSMTP. Możesz utworzyć konto, odwiedzając tę witrynę i konfigurując swój adres e-mail.
API JavaMail składa się z niektórych interfejsów i klas używanych do wysyłania, czytania i usuwania wiadomości e-mail. Chociaż istnieje wiele pakietów w JavaMail API, obejmie dwa główne pakiety, które są często używane w Java Mail API: pakiet javax.mail i javax.mail.internet . Te pakiety zawierają wszystkie podstawowe klasy JavaMail. Oni są:
| Klasa | Opis |
|---|---|
| javax.mail.Session | Klasa klucza interfejsu API. Obiekt wielowątkowy reprezentuje fabrykę połączeń. |
| javax.mail.Message | Klasa abstrakcyjna modelująca wiadomość e-mail. Podklasy zapewniają rzeczywiste implementacje. |
| javax.mail.Address | Klasa abstrakcyjna, która modeluje adresy (od i do adresów) w wiadomości. Podklasy zapewniają określone implementacje. |
| javax.mail.Authenticator | Klasa abstrakcyjna używana do ochrony zasobów poczty na serwerze poczty. |
| javax.mail.Transport | Klasa abstrakcyjna modelująca mechanizm transportu wiadomości służący do wysyłania wiadomości e-mail. |
| javax.mail.Store | Klasa abstrakcyjna modelująca magazyn komunikatów i jego protokół dostępu do przechowywania i pobierania komunikatów. Sklep jest podzielony na foldery. |
| javax.mail.Folder | Klasa abstrakcyjna reprezentująca folder wiadomości e-mail. Może zawierać podfoldery. |
| javax.mail.internet.MimeMessage | Wiadomość jest klasą abstrakcyjną, dlatego musi działać z podklasą; w większości przypadków użyjesz MimeMessage. MimeMessage to wiadomość e-mail, która rozumie typy i nagłówki MIME. |
| javax.mail.internet.InternetAddress | Ta klasa reprezentuje internetowy adres e-mail przy użyciu składni RFC822. Typowa składnia adresu ma postać uż[email protected] lub Nazwa osobista <uż[email protected]> . |
Oto przykład wysyłania prostego e-maila. Tutaj użyliśmy serwera JangoSMTP, za pośrednictwem którego wiadomości e-mail są wysyłane na nasz docelowy adres e-mail. Konfiguracja jest opisana w rozdziale Konfiguracja środowiska .
Aby wysłać prostą wiadomość e-mail, wykonaj następujące czynności:
Uzyskaj sesję
Utwórz domyślny obiekt MimeMessage i ustaw Od, Do, Temat w wiadomości.
Ustaw aktualną wiadomość jako:
message.setText("your text goes here");Wyślij wiadomość za pomocą obiektu Transport.
Utwórz klasę Java
Utwórz plik klasy Java SendEmailktórych zawartość jest następująca:
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);
}
}
}Ponieważ korzystamy z serwera SMTP dostarczonego przez dostawcę hosta JangoSMTP, musimy uwierzytelnić nazwę użytkownika i hasło. Javax.mail.PasswordAuthentication klasa jest używana do uwierzytelniania hasła.
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę SendEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
Sent message successfully....Gdy wysyłam wiadomość e-mail na mój adres Gmail za pośrednictwem JangoSMTP, następująca poczta zostanie odebrana w skrzynce odbiorczej mojego konta Gmail:
Oto przykład wysyłania wiadomości e-mail z załącznikiem z komputera. Plik na komputerze lokalnym tofile.txtumieszczony w / home / manisha / . Tutaj użyliśmy serwera JangoSMTP, za pośrednictwem którego wiadomości e-mail są wysyłane na nasz docelowy adres e-mail. Konfiguracja jest opisana w rozdziale Konfiguracja środowiska .
Aby wysłać wiadomość e-mail z obrazem w wierszu, wykonaj następujące czynności:
Uzyskaj sesję
Utwórz domyślny obiekt MimeMessage i ustaw Od, Do, Temat w wiadomości.
Ustaw aktualny komunikat jak poniżej:
messageBodyPart.setText("This is message body");Utwórz obiekt MimeMultipart. Dodaj powyższą wiadomość messageBodyPart z ustawioną w niej aktualną wiadomością do tego obiektu wieloczęściowego.
Następnie dodaj załącznik, tworząc moduł Datahandler w następujący sposób:
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);Następnie ustaw multipart w wiadomości w następujący sposób:
message.setContent(multipart);Wyślij wiadomość za pomocą obiektu Transport.
Utwórz klasę Java
Utwórz plik klasy Java SendAttachmentInEmailktórych zawartość jest następująca:
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);
}
}
}Ponieważ korzystamy z serwera SMTP dostarczonego przez dostawcę hosta JangoSMTP, musimy uwierzytelnić nazwę użytkownika i hasło. Javax.mail.PasswordAuthentication klasa jest używana do uwierzytelniania hasła.
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę SendAttachmentInEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
Sent message successfully....Gdy wysyłam wiadomość e-mail na mój adres Gmail za pośrednictwem JangoSMTP, następująca poczta zostanie odebrana w skrzynce odbiorczej mojego konta Gmail:
Oto przykład wysyłania wiadomości e-mail w formacie HTML z komputera. Tutaj użyliśmy serwera JangoSMTP, za pośrednictwem którego wiadomości e-mail są wysyłane na nasz docelowy adres e-mail. Konfiguracja jest opisana w rozdziale Konfiguracja środowiska .
Ten przykład jest bardzo podobny do wysyłania prostych wiadomości e-mail, z tą różnicą, że używamy tutaj metody setContent () do ustawiania treści, której drugim argumentem jest „text / html”, aby określić, że treść HTML jest zawarta w wiadomości. Korzystając z tego przykładu, możesz wysyłać dowolną zawartość HTML.
Aby wysłać wiadomość e-mail z treścią HTML, wykonaj następujące czynności:
Uzyskaj sesję
Utwórz domyślny obiekt MimeMessage i ustaw Od, Do, Temat w wiadomości.
Ustaw aktualny komunikat za pomocą metody setContent () jak poniżej:
message.setContent("<h1>This is actual message embedded in HTML tags</h1>", "text/html");Wyślij wiadomość za pomocą obiektu Transport.
Utwórz klasę Java
Utwórz plik klasy Java SendHTMLEmailktórych zawartość jest następująca:
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);
}
}
}Ponieważ korzystamy z serwera SMTP dostarczonego przez dostawcę hosta JangoSMTP, musimy uwierzytelnić nazwę użytkownika i hasło. Javax.mail.PasswordAuthentication klasa jest używana do uwierzytelniania hasła.
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę SendHTMLEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
Sent message successfully....Gdy wysyłam wiadomość e-mail na mój adres Gmail za pośrednictwem JangoSMTP, następująca poczta zostanie odebrana w skrzynce odbiorczej mojego konta Gmail:
Oto przykład wysyłania wiadomości e-mail w formacie HTML z komputera z wbudowanym obrazem. Tutaj użyliśmy serwera JangoSMTP, za pośrednictwem którego wiadomości e-mail są wysyłane na nasz docelowy adres e-mail. Konfiguracja jest opisana w rozdziale Konfiguracja środowiska .
Aby wysłać wiadomość e-mail z obrazem w wierszu, wykonaj następujące czynności:
Uzyskaj sesję
Utwórz domyślny obiekt MimeMessage i ustaw Od, Do, Temat w wiadomości.
Utwórz obiekt MimeMultipart.
W naszym przykładzie będziemy mieć część HTML i obraz w wiadomości e-mail. Więc najpierw utwórz zawartość HTML i ustaw ją w obiekcie wieloczęściowym jako:
// 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);Następnie dodaj obraz, tworząc moduł Datahandler w następujący sposób:
// 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>");Następnie ustaw multipart w wiadomości w następujący sposób:
message.setContent(multipart);Wyślij wiadomość za pomocą obiektu Transport.
Utwórz klasę Java
Utwórz plik klasy Java SendInlineImagesInEmailktórych zawartość jest następująca:
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);
}
}
}Ponieważ korzystamy z serwera SMTP dostarczonego przez dostawcę hosta JangoSMTP, musimy uwierzytelnić nazwę użytkownika i hasło. Javax.mail.PasswordAuthentication klasa jest używana do uwierzytelniania hasła.
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę SendInlineImagesInEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
Sent message successfully....Gdy wysyłam wiadomość e-mail na mój adres Gmail za pośrednictwem JangoSMTP, następująca poczta zostanie odebrana w skrzynce odbiorczej mojego konta Gmail:
Przed przystąpieniem do tego rozdziału należy zrozumieć dwa aspekty. Oni sąCheck i Fetch.
Checkwysyłanie wiadomości e-mail w JavaMail to proces, w którym otwieramy odpowiedni folder w skrzynce pocztowej i odbieramy każdą wiadomość. Tutaj sprawdzamy tylko nagłówek każdej wiadomości, tj . Temat Od, Do,. Treść nie jest czytana.
Fetchwysyłanie wiadomości e-mail w JavaMail to proces, w którym otwieramy odpowiedni folder w skrzynce pocztowej i odbieramy każdą wiadomość. Wraz z nagłówkiem odczytujemy również treść, rozpoznając typ treści.
Aby sprawdzić lub pobrać wiadomość e-mail za pomocą JavaMail API, potrzebowalibyśmy serwerów POP lub IMAP. Aby sprawdzić i pobrać wiadomości e-mail, potrzebne są klasy Folder i Store. Tutaj użyliśmy serwera POP3 GMAIL (pop.gmail.com). W tym rozdziale dowiesz się, jak sprawdzać wiadomości e-mail za pomocą JavaMail API. Pobieranie zostanie omówione w kolejnych rozdziałach. Aby sprawdzić e-maile:
Uzyskaj sesję
Utwórz obiekt pop3 Store i połącz się z serwerem pop.
Utwórz obiekt folderu. Otwórz odpowiedni folder w swojej skrzynce pocztowej.
Otrzymuj wiadomości.
Zamknij obiekty Store i Folder.
Utwórz klasę Java
Utwórz plik klasy Java CheckingMailsktórych zawartość jest następująca:
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);
}
}Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę CheckingMails.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMailsSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
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@2d1e165fTutaj wypisaliśmy liczbę wiadomości w INBOX, która w tym przypadku wynosi 4. Dla każdej wiadomości e-mail wydrukowaliśmy również temat, adres nadawcy i tekst.
W poprzednim rozdziale dowiedzieliśmy się, jak sprawdzać e-maile. Zobaczmy teraz, jak pobrać każdą wiadomość e-mail i przeczytać jej zawartość. Napiszmy klasę JavyFetchingEmail który odczyta następujące rodzaje e-maili:
Prosty e-mail
E-mail z załącznikiem
E-mail z wbudowanym obrazem
Podstawowe kroki w kodzie są następujące:
Pobierz obiekt Session.
Utwórz obiekt sklepu POP3 i połącz się ze sklepem.
Utwórz obiekt folderu i otwórz odpowiedni folder w swojej skrzynce pocztowej.
Pobierz wiadomości.
Zamknij folder i odpowiednio przechowuj obiekty.
Utwórz klasę Java
Utwórz plik klasy Java FetchingEmailktórych zawartość jest jak poniżej:
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());
}
}Możesz włączyć debugowanie, usuwając komentarz z instrukcji emailSession.setDebug (true);
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę FetchingEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
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"Tutaj możesz zobaczyć, że w naszej skrzynce pocztowej są trzy e-maile. Najpierw zwykła wiadomość e-mail z wiadomością „Cześć, jestem prostą wiadomością ....” Druga wiadomość zawiera załącznik. Zawartość załącznika jest również drukowana, jak pokazano powyżej. Trzecia wiadomość zawiera wbudowany obraz.
Zmodyfikujemy nasz CheckingMails.java z rozdziału Sprawdzanie wiadomości e-mail . Jego zawartość jest następująca:
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);
}
}Możesz włączyć debugowanie, usuwając komentarz z instrukcji emailSession.setDebug (true);
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę CheckingMails.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMailsSprawdź wyjście
Możesz zobaczyć podobny komunikat jak poniżej w konsoli poleceń:
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@3ad5ba3aW tym rozdziale zobaczymy, jak odpowiedzieć na wiadomość e-mail za pomocą JavaMail API. Podstawowe kroki w poniższym programie to:
Pobierz obiekt sesji ze szczegółami serwera POP i SMTP we właściwościach. Potrzebowalibyśmy danych POP do pobierania wiadomości i szczegółów SMTP do wysyłania wiadomości.
Utwórz obiekt sklepu POP3 i połącz się ze sklepem.
Utwórz obiekt folderu i otwórz odpowiedni folder w swojej skrzynce pocztowej.
Pobierz wiadomości.
Powtarzaj wiadomości i wpisz „Y” lub „y”, jeśli chcesz odpowiedzieć.
Uzyskaj wszystkie informacje (Do, Od, Temat, Treść) wiadomości.
Utwórz wiadomość zwrotną, używając metody Message.reply (). Ta metoda konfiguruje nową wiadomość z odpowiednim odbiorcą i tematem. Metoda przyjmuje parametr boolowski wskazujący, czy odpowiedzieć tylko nadawcy (fałsz), czy odpowiedzieć wszystkim (prawda).
Ustaw Od, Tekst i Odpowiedź do w wiadomości i wyślij ją za pośrednictwem instancji obiektu Transport.
Zamknij odpowiednio Transport, folder i przechowuj obiekty.
Tutaj użyliśmy serwera JangoSMTP, za pośrednictwem którego wiadomości e-mail są wysyłane na nasz docelowy adres e-mail. Konfiguracja jest opisana w rozdziale Konfiguracja środowiska .
Utwórz klasę Java
Utwórz plik klasy Java ReplyToEmailktórych zawartość jest następująca:
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();
}
}
}Możesz włączyć debugowanie, usuwając komentarz z instrukcji session.setDebug (true);
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę ReplyToEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj następujące polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
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 ....Sprawdź skrzynkę odbiorczą, do której wiadomość została wysłana. W naszym przypadku otrzymana wiadomość wygląda jak poniżej:
W tym rozdziale zobaczymy, jak przekazać wiadomość e-mail za pomocą JavaMail API. Podstawowe kroki w poniższym programie to:
Pobierz obiekt sesji ze szczegółami serwera POP i SMTP we właściwościach. Potrzebowalibyśmy danych POP do pobierania wiadomości i szczegółów SMTP do wysyłania wiadomości.
Utwórz obiekt sklepu POP3 i połącz się ze sklepem.
Utwórz obiekt folderu i otwórz odpowiedni folder w swojej skrzynce pocztowej.
Pobierz wiadomości.
Powtarzaj wiadomości i wpisz „Y” lub „y”, jeśli chcesz przekazać dalej.
Uzyskaj wszystkie informacje (Do, Od, Temat, Treść) wiadomości.
Zbuduj przekaz do przodu, pracując z częściami, które składają się na wiadomość. Pierwsza część to treść wiadomości, a druga to wiadomość do przekazania. Połącz te dwa elementy w wieloczęściowy. Następnie dodajesz multipart do odpowiednio zaadresowanej wiadomości i wysyłasz ją.
Zamknij odpowiednio Transport, folder i przechowuj obiekty.
Tutaj użyliśmy serwera JangoSMTP, za pośrednictwem którego wiadomości e-mail są wysyłane na nasz docelowy adres e-mail. Konfiguracja jest opisana w rozdziale Konfiguracja środowiska .
Utwórz klasę Java
Utwórz plik klasy Java ForwardEmailktórych zawartość jest następująca:
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();
}
}
}Możesz włączyć debugowanie, usuwając komentarz z instrukcji session.setDebug (true);
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę ForwardEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj następujące polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
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....Sprawdź skrzynkę odbiorczą, do której wiadomość została wysłana. W naszym przypadku przekazana wiadomość wyglądałaby jak poniżej:
W tym rozdziale zobaczymy, jak usunąć wiadomość e-mail za pomocą JavaMail API. Usuwanie wiadomości wymaga pracy z flagami skojarzonymi z wiadomościami. Istnieją różne flagi dla różnych stanów, niektóre zdefiniowane przez system, a niektóre przez użytkownika. Predefiniowane flagi są zdefiniowane w klasie wewnętrznej Flags.Flag i są wymienione poniżej:
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
Protokół POP obsługuje tylko usuwanie wiadomości.
Podstawowe kroki wykonywane w programie usuwania to:
Pobierz obiekt sesji ze szczegółami serwera POP i SMTP we właściwościach. Potrzebowalibyśmy danych POP do pobierania wiadomości i szczegółów SMTP do wysyłania wiadomości.
Utwórz obiekt sklepu POP3 i połącz się ze sklepem.
Utwórz obiekt folderu i otwórz odpowiedni folder w swojej skrzynce pocztowej w trybie READ_WRITE.
Pobiera wiadomości z folderu skrzynki odbiorczej.
Powtarzaj komunikaty i wpisz „Y” lub „y”, jeśli chcesz usunąć wiadomość, wywołując metodę setFlag (Flags.Flag.DELETED, true) na obiekcie Message.
Wiadomości oznaczone jako DELETED nie są w rzeczywistości usuwane, dopóki nie wywołamy metody expunge () na obiekcie Folder lub nie zamkniemy folderu z expunge ustawionym na true.
Zamknij obiekt sklepu.
Utwórz klasę Java
Utwórz plik klasy Java ForwardEmailktórych zawartość jest następująca:
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);
}
}Możesz włączyć debugowanie, usuwając komentarz z instrukcji emailSession.setDebug (true);
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę DeleteEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj następujące polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
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: TestingWe wszystkich poprzednich rozdziałach używaliśmy serwera JangoSMTP do wysyłania e-maili. W tym rozdziale dowiemy się o serwerze SMTP udostępnianym przez Gmaila. Gmail (między innymi) oferuje bezpłatne korzystanie z publicznego serwera SMTP.
Szczegóły dotyczące serwera SMTP Gmaila można znaleźć tutaj . Jak widać po szczegółach, możemy użyć połączenia TLS lub SSL do wysyłania wiadomości e-mail za pośrednictwem serwera SMTP Gmaila.
Procedura wysyłania wiadomości e-mail przy użyciu serwera SMTP Gmaila jest podobna do opisanej w rozdziale Wysyłanie wiadomości e-mail , z tym wyjątkiem, że zmienilibyśmy serwer hosta. Warunkiem wstępnym jest, aby adres e-mail nadawcy był aktywnym kontem Gmail. Spróbujmy na przykładzie.
Utwórz klasę Java
Utwórz plik Java SendEmailUsingGMailSMTPktórych zawartość jest jak poniżej:
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);
}
}
}Tutaj host jest ustawiony jako smtp.gmail.com, a port jest ustawiony jako 587 . Tutaj mamy włączone połączenie TLS.
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę SendEmailUsingGMailSMTP.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTPSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
Sent message successfully....Do tej pory pracowaliśmy w poprzednich rozdziałach głównie z folderem INBOX. Jest to domyślny folder, w którym znajduje się większość poczty. Niektóre systemy mogą nazywać to jako INBOX, a inne mogą nazywać to inną nazwą. Ale zawsze możesz uzyskać do niego dostęp z JavaMail API, używając nazwy INBOX.
Interfejs API JavaMail reprezentuje foldery jako instancje abstrakcyjnej klasy Folder:
public abstract class Folder extends ObjectTa klasa deklaruje metody żądania nazwanych folderów z serwerów, usuwania wiadomości z folderów, wyszukiwania określonych wiadomości w folderach, wyświetlania wiadomości w folderze i tak dalej.
Otwieranie folderu
Nie możemy utworzyć folderu bezpośrednio, ponieważ jedyny konstruktor w klasie Folder jest chroniony . Folder możemy pobrać z:
Sesja
Sklep
lub inny folder
Wszystkie powyższe klasy mają podobną metodę getFolder () z podobną sygnaturą:
public abstract Folder getFolder(String name) throws MessagingExceptionOto niektóre metody, które pomagają w uzyskaniu obiektu Folder :
| metoda | Opis |
|---|---|
| boolean istnieje () | Sprawdza, czy folder naprawdę istnieje. Użyj tej metody przed pobraniem obiektu Folder. |
| abstract void open (tryb int) | Kiedy otrzymasz folder , jest zamknięty. Użyj tej metody, aby go otworzyć. trybem może być Folder.READ_ONLY lub Folder.READ_WRITE. |
| abstrakcyjny boolean isOpen () | Ta metoda zwraca wartość true, jeśli folder jest otwarty, false, jeśli jest zamknięty |
| abstrakcyjne void close (boolean expunge) | Zamyka folder. Jeśli argument niszczenia ma wartość true , wszelkie usunięte wiadomości w folderze są usuwane z rzeczywistego pliku na serwerze. W przeciwnym razie są po prostu oznaczane jako usunięte , ale nadal można cofnąć usunięcie wiadomości. |
Podstawowe informacje o folderze
Poniżej przedstawiono niektóre metody w klasie Folder, które zwracają podstawowe informacje o folderze:
| metoda | Opis |
|---|---|
| abstrakcyjny ciąg getName () | Zwraca nazwę folderu, na przykład „TutorialsPoint Mail” |
| abstrakcyjny ciąg getFullName () | Zwraca pełną hierarchiczną nazwę z katalogu głównego, na przykład „books / Manisha / TutorialsPoint Mail”. |
| URLName getURLName () | Zwróć URLName reprezentujący ten folder. |
| abstrakcyjny folder getParent () | Zwraca nazwę folderu zawierającego ten folder, tj. Folder nadrzędny. Np. „Manisha” z poprzedniego przykładu „TutorialsPoint Mail”. |
| streszczenie int getType () | Zwraca liczbę int wskazującą, czy folder może zawierać wiadomości i / lub inne foldery. |
| int getMode () | Zwraca jedną z dwóch nazwanych stałych Folder.READ_ONLY lub Folder.READ_WRITE lub -1, gdy tryb jest nieznany. |
| Sklep getStore () | Zwraca obiekt Store, z którego pobrano ten folder. |
| abstrakcyjny znak getSeparator () | Zwróć znak separatora, który oddziela ścieżkę tego folderu od nazw bezpośrednich podfolderów. |
Zarządzanie folderem
Oto niektóre metody, które pomagają w zarządzaniu folderem:
| metoda | Opis |
|---|---|
| abstrakcyjne tworzenie boolowskie (typ int) | Spowoduje to utworzenie nowego folderu w sklepie tego folderu. Gdzie typ byłby: Folder.HOLDS_MESSAGES lub Folder.HOLDS_FOLDERS. Zwraca wartość true, jeśli folder został pomyślnie utworzony, w przeciwnym razie zwraca wartość false . |
| abstrakcyjne boolowskie usuwanie (boolean recurse) | Spowoduje to usunięcie folderu tylko wtedy, gdy folder jest zamknięty. W przeciwnym razie zgłasza wyjątek IllegalStateException . Jeśli recurse ma wartość true , podfoldery są usuwane. |
| abstrakcyjne boolean renameTo (folder f) | Spowoduje to zmianę nazwy tego folderu. Aby zmienić nazwę folderu, należy go zamknąć. W przeciwnym razie zostanie zgłoszony wyjątek IllegalStateException. |
Zarządzanie wiadomościami w folderach
Oto niektóre metody, które pomagają w zarządzaniu wiadomościami w folderze:
| metoda | Opis |
|---|---|
| abstract void appendMessages (wiadomości Message []) | Jak sama nazwa wskazuje, wiadomości w tablicy są umieszczane na końcu tego folderu. |
| void copyMessages (wiadomości Message [], folder docelowy) | Powoduje to skopiowanie wiadomości z tego folderu do określonego folderu podanego jako argument. |
| streszczenie Wiadomość [] expunge () | Aby usunąć wiadomość z folderu, ustaw jej flagę Flags.Flag.DELETED na wartość true. Aby fizycznie usunąć usunięte wiadomości z folderu, musisz wywołać tę metodę. |
Lista zawartości folderu
Istnieją cztery metody wyświetlania listy folderów, które zawiera folder:
| metoda | Opis |
|---|---|
| Lista folderów [] () | Zwraca tablicę z listą folderów, które zawiera ten folder. |
| Lista folderów [] Subscribe () | Zwraca tablicę z listą wszystkich subskrybowanych folderów, które zawiera ten folder. |
| abstrakcyjna lista folderów [] (wzorzec ciągów) | Jest to podobne do metody list () , z tą różnicą, że umożliwia określenie wzorca. Wzorzec jest łańcuchem podającym nazwy folderów, które pasują. |
| Lista folderów [] subskrybowanych (wzór ciągu) | Jest to podobne do metody listSubscribe () , z tym wyjątkiem, że umożliwia określenie wzorca. Wzorzec jest łańcuchem podającym nazwy folderów, które pasują. |
Sprawdzanie poczty
| metoda | Opis |
|---|---|
| streszczenie int getMessageCount () | Tę metodę można wywołać w otwartym lub zamkniętym folderze. Jednak w przypadku folderu zamkniętego ta metoda może (ale nie musi) zwracać -1, aby wskazać, że dokładna liczba wiadomości nie jest łatwo dostępna. |
| abstract boolean hasNewMessages () | Zwraca to wartość true, jeśli nowe wiadomości zostały dodane do folderu od czasu jego ostatniego otwarcia. |
| int getNewMessageCount () | Zwraca liczbę nowych wiadomości, sprawdzając wiadomości w folderze, dla którego ustawiono flagę RECENT. |
| int getUnreadMessageCount () | Można to wywołać w otwartym lub zamkniętym folderze. Jednak w przypadku zamkniętego folderu może zwrócić -1, aby wskazać, że uzyskanie prawdziwej odpowiedzi byłoby zbyt kosztowne. |
Pobieranie wiadomości z folderów
Klasa Folder udostępnia cztery metody pobierania wiadomości z otwartych folderów:
| metoda | Opis |
|---|---|
| streszczenie Wiadomość getMessage (int messageNumber) | Zwraca n-tą wiadomość w folderze. Pierwsza wiadomość w folderze ma numer 1. |
| Wiadomość [] getMessages () | Zwraca tablicę obiektów Message reprezentujących wszystkie wiadomości w tym folderze. |
| Wiadomość [] getMessages (int start, int end) | Zwraca tablicę obiektów Message z folderu, zaczynając od początku i kończąc na końcu włącznie. |
| Wiadomość [] getMessages (int [] messageNumbers) | Zwraca tablicę zawierającą tylko te komunikaty, które są wyraźnie określone przez numer w tablicy messageNumbers . |
| void fetch (wiadomości Message [], FetchProfile fp) | Pobierz wstępnie elementy określone w FetchProfile dla danych Messages. Argument FetchProfile określa, które nagłówki wiadomości mają zostać pobrane z wyprzedzeniem. |
Wyszukiwanie folderów
Jeśli serwer obsługuje wyszukiwanie (jak wiele serwerów IMAP i większość serwerów POP nie), łatwo jest przeszukać folder pod kątem wiadomości spełniających określone kryteria. Kryteria są kodowane w obiektach SearchTerm. Poniżej przedstawiono dwie metody wyszukiwania:
| metoda | Opis |
|---|---|
| Wyszukiwanie wiadomości [] (hasło SearchTerm) | Przeszukaj ten folder pod kątem wiadomości pasujących do określonego kryterium wyszukiwania. Zwraca tablicę zawierającą pasujące komunikaty. Zwraca pustą tablicę, jeśli nie znaleziono żadnych dopasowań. |
| Wyszukiwanie wiadomości [] (termin SearchTerm, wiadomości Message []) | Przeszukuj podaną tablicę wiadomości pod kątem tych, które pasują do określonego kryterium wyszukiwania. Zwraca tablicę zawierającą pasujące komunikaty. Zwraca pustą tablicę, jeśli nie znaleziono żadnych dopasowań. Określone obiekty Message muszą należeć do tego folderu. |
Flagi
Modyfikacja flag jest przydatna, gdy trzeba zmienić flagi dla całego zestawu wiadomości w folderze. Poniżej przedstawiono metody zawarte w klasie Folder:
| metoda | Opis |
|---|---|
| void setFlags (Message [] wiadomości, flaga flagi, wartość logiczna) | Ustawia określone flagi dla komunikatów określonych w tablicy. |
| void setFlags (int start, int end, Flags flag, wartość logiczna) | Ustawia określone flagi dla wiadomości ponumerowanych od początku do końca, włącznie z początkiem i końcem. |
| void setFlags (int [] messageNumbers, flaga flagi, wartość logiczna) | Ustawia określone flagi dla wiadomości, których numery wiadomości znajdują się w tablicy. |
| abstract Flags getPermanentFlags () | Zwraca flagi obsługiwane przez ten folder dla wszystkich wiadomości. |
Limit w JavaMail to ograniczona lub stała liczba lub liczba wiadomości w sklepie e-mail. Każde żądanie usługi poczty jest wliczane do limitu wywołań interfejsu API JavaMail. Usługa poczty e-mail może stosować następujące kryterium limitu:
Maksymalny rozmiar wychodzących wiadomości e-mail wraz z załącznikami.
Maksymalny rozmiar przychodzących wiadomości e-mail wraz z załącznikami.
Maksymalny rozmiar wiadomości, gdy odbiorcą jest administrator
Do zarządzania limitami JavaMail ma następujące klasy:
| Klasa | Opis |
|---|---|
| klasa publiczna Quota | Ta klasa reprezentuje zestaw przydziałów dla danego korzenia przydziału. Każdy katalog główny przydziału ma zestaw zasobów reprezentowany przez klasę Quota.Resource. Każdy zasób ma nazwę (na przykład „MAGAZYN”), aktualne wykorzystanie i limit wykorzystania. Ma tylko jedną metodę setResourceLimit (nazwa ciągu, długi limit) . |
| publiczna klasa statyczna Quota.Resource | Reprezentuje pojedynczy zasób w katalogu głównym przydziału. |
| publiczny interfejs QuotaAwareStore | Interfejs zaimplementowany przez sklepy obsługujące limity. Metody getQuota i setQuota obsługują model kwot zdefiniowany przez rozszerzenie IMAP QUOTA. GmailSSLStore, GmailStore, IMAPSSLStore, IMAPStore to znane klasy implementacyjne tego interfejsu. |
Zobaczmy i zobaczmy przykład w poniższych sekcjach, które sprawdzają nazwę przechowywania poczty, limit i jego wykorzystanie.
Utwórz klasę Java
Utwórz plik klasy Java QuotaExamplektórych zawartość jest następująca:
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();
}
}
}Oto połączenie z usługą gmail przez serwer IMAP (imap.gmail.com), ponieważ IMAPStore implementuje QuotaAwareStore. Po uzyskaniu obiektu Store pobierz tablicę Quota, przejdź przez nią iteracyjnie i wydrukuj odpowiednie informacje.
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę QuotaExample.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExampleSprawdź wyjście
Powinieneś zobaczyć podobny komunikat w konsoli poleceń:
imapStore ---imaps://abc%[email protected]
quotaRoot:''
name:'STORAGE', limit:'15728640', usage:'513'Wiadomość może zostać odesłana z kilku powodów. Ten problem jest szczegółowo omówiony w rfc1211 . Tylko serwer może określić istnienie określonej skrzynki pocztowej lub nazwy użytkownika. Gdy serwer wykryje błąd, zwróci komunikat wskazujący przyczynę niepowodzenia nadawcy oryginalnej wiadomości.
Istnieje wiele standardów internetowych obejmujących powiadomienia o stanie dostarczenia, ale duża liczba serwerów nie obsługuje tych nowych standardów, zamiast tego używa technik ad hoc do zwracania takich komunikatów o błędach. Dlatego bardzo trudno jest skorelować odesłaną wiadomość z pierwotną wiadomością, która spowodowała problem.
JavaMail obejmuje obsługę analizowania powiadomień o stanie dostarczenia. Istnieje wiele technik i heurystyk radzenia sobie z tym problemem. Jedną z technik są ścieżki powrotu zmiennej obwiedni. Możesz ustawić ścieżkę zwrotną w kopercie, jak pokazano na poniższym przykładzie. Jest to adres, na który wysyłane są odsyłane wiadomości. Możesz chcieć ustawić to na ogólny adres, inny niż nagłówek From :, aby móc przetwarzać zdalne odbicia. Odbywa się to poprzez ustawienie właściwości mail.smtp.from w JavaMail.
Utwórz klasę Java
Utwórz plik klasy Java SendEmailktórych zawartość jest następująca:
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()
}Tutaj widzimy, że właściwość mail.smtp.from jest ustawiona inaczej niż adres nadawcy.
Skompiluj i uruchom
Teraz, gdy nasza klasa jest gotowa, skompilujmy powyższą klasę. Zapisałem klasę SendEmail.java w katalogu:/home/manisha/JavaMailAPIExercise. Potrzebowalibyśmy jars javax.mail.jar i aktywacja.jar w ścieżce klas. Wykonaj poniższe polecenie, aby skompilować klasę (oba słoiki są umieszczone w katalogu / home / manisha /) z wiersza polecenia:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.javaTeraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailSprawdź wyjście
W konsoli poleceń powinien pojawić się następujący komunikat:
Sending ....
Sending done ...SMTP to akronim od Simple Mail Transfer Protocol. Jest to internetowy standard przesyłania poczty elektronicznej (e-mail) w sieciach protokołu internetowego (IP). SMTP korzysta z portu TCP 25. Połączenia SMTP zabezpieczone przez SSL są znane pod skrótem SMTPS, chociaż SMTPS nie jest protokołem samym w sobie.
JavaMail API ma pakiet com.sun.mail.smtpktóre działają jako dostawca protokołu SMTP w celu uzyskania dostępu do serwera SMTP. Poniższa tabela zawiera listę klas zawartych w tym pakiecie:
| Klasa | Opis |
|---|---|
| SMTPMessage | Ta klasa jest specjalizacją klasy MimeMessage, która umożliwia określenie różnych opcji i parametrów SMTP, które będą używane podczas wysyłania tej wiadomości przez SMTP. |
| SMTPSSLTransport | Ta klasa implementuje klasę abstrakcyjną Transport przy użyciu protokołu SMTP przez SSL do przesyłania i transportu wiadomości. |
| SMTPTransport | Ta klasa implementuje klasę abstrakcyjną Transport przy użyciu protokołu SMTP do przesyłania i transportu wiadomości. |
W poniższej tabeli wymieniono zgłoszone wyjątki:
| Wyjątek | Opis |
|---|---|
| SMTPAddressFailedException | Ten wyjątek jest zgłaszany, gdy nie można wysłać wiadomości. |
| SMTPAddressSucceededException | Ten wyjątek jest przykuty off SendFailedException gdy mail.smtp.reportsuccess właściwość ma wartość true. |
| SMTPSenderFailedException | Ten wyjątek jest zgłaszany, gdy nie można wysłać wiadomości. |
| SMTPSendFailedException | Ten wyjątek jest zgłaszany, gdy wiadomość nie może zostać wysłana. Wyjątek obejmuje adres nadawcy, który serwer pocztowy odrzucił. |
Plik com.sun.mail.smtpdostawca opcjonalnie używa uwierzytelniania SMTP. Aby korzystać z uwierzytelniania SMTP, musisz ustawić właściwość mail.smtp.auth lub podać transportowi SMTP nazwę użytkownika i hasło podczas łączenia się z serwerem SMTP. Możesz to zrobić, stosując jedną z następujących metod:
Podaj obiekt Authenticator podczas tworzenia sesji poczty i podaj nazwę użytkownika i hasło podczas wywołania zwrotnego Authenticator. Można ustawić właściwość mail.smtp.user tak, aby zapewniała domyślną nazwę użytkownika dla wywołania zwrotnego, ale hasło nadal będzie musiało być podane jawnie. Takie podejście umożliwia użycie statycznej metody wysyłania Transport do wysyłania wiadomości. Na przykład:
Transport.send(message);Wywołaj metodę Transport connect jawnie z argumentami nazwy użytkownika i hasła. Na przykład:
Transport tr = session.getTransport("smtp");
tr.connect(smtphost, username, password);
msg.saveChanges();
tr.sendMessage(msg, msg.getAllRecipients());
tr.close();Dostawca protokołu SMTP obsługuje następujące właściwości, które można ustawić w obiekcie JavaMail Session. Właściwości są zawsze ustawiane jako ciągi. Na przykład:
props.put("mail.smtp.port", "587");IMAP to skrót od Internet Message Access Protocol. Jest to protokół internetowy warstwy aplikacji, który umożliwia klientowi poczty e-mail dostęp do poczty na zdalnym serwerze poczty. Serwer IMAP zwykle nasłuchuje na dobrze znanym porcie 143. IMAP przez SSL (IMAPS) jest przypisany do portu o numerze 993.
IMAP obsługuje tryby działania on-line i off-line. Klienci poczty e-mail korzystający z protokołu IMAP zazwyczaj pozostawiają wiadomości na serwerze, dopóki użytkownik ich nie usunie.
Pakiet com.sun.mail.imapjest dostawcą protokołu IMAP dla JavaMail API, który zapewnia dostęp do magazynu wiadomości IMAP. Poniższa tabela zawiera interfejs i klasy tego dostawcy:
| Klasa / interfejs | Opis |
|---|---|
| IMAPFolder.ProtocolCommand | To prosty interfejs dla poleceń protokołu IMAP zdefiniowanych przez użytkownika. |
| ACL | To jest klasa. Wpis na liście kontroli dostępu dla określonego identyfikatora uwierzytelniania (użytkownika lub grupy). |
| IMAPFolder | Ta klasa implementuje folder IMAP. |
| IMAPFolder.FetchProfileItem | To klasa do pobierania nagłówków. |
| IMAPMessage | Ta klasa implementuje obiekt ReadableMime. |
| IMAPMessage.FetchProfileCondition | Ta klasa implementuje test, który ma zostać wykonany dla każdej wiadomości w folderze. |
| IMAPSSLStore | Ta klasa zapewnia dostęp do magazynu wiadomości IMAP przez SSL. |
| IMAPStore | Ta klasa zapewnia dostęp do magazynu wiadomości IMAP. |
| Prawa | Ta klasa reprezentuje zestaw uprawnień dla identyfikatora uwierzytelniania (na przykład użytkownika lub grupy). |
| Prawa. Prawo | Ta klasa wewnętrzna reprezentuje indywidualne prawo. |
| SortTerm | Określone kryteria sortowania, zgodnie z definicją w dokumencie RFC 5256. |
Kilka punktów, na które należy zwrócić uwagę powyżej tego dostawcy:
Ten dostawca obsługuje protokoły IMAP4 i IMAP4rev1.
Połączony IMAPStore utrzymuje pulę obiektów protokołu IMAP do użytku w komunikacji z serwerem IMAP. Gdy foldery są otwierane i potrzebne są nowe obiekty protokołu IMAP, IMAPStore udostępni je z puli połączeń lub utworzy je, jeśli żadne nie są dostępne. Gdy folder jest zamknięty, jego obiekt protokołu IMAP jest zwracany do puli połączeń, jeśli jest to pula.
Połączony obiekt IMAPStore może, ale nie musi, utrzymywać oddzielny obiekt protokołu IMAP, który zapewnia sklepowi dedykowane połączenie z serwerem IMAP.
Post Office Protocol (POP) to standardowy protokół internetowy warstwy aplikacji używany przez lokalnych klientów poczty e-mail do pobierania wiadomości e-mail ze zdalnego serwera za pośrednictwem połączenia TCP / IP. POP obsługuje proste wymagania dotyczące pobierania i usuwania w celu uzyskania dostępu do zdalnych skrzynek pocztowych. Serwer POP3 nasłuchuje na dobrze znanym porcie 110.
Pakiet com.sun.mail.pop3jest dostawcą protokołu POP3 dla JavaMail API, który zapewnia dostęp do magazynu wiadomości POP3. Poniższa tabela zawiera listę klas w tym pakiecie:
| Nazwa | Opis |
|---|---|
| POP3Folder | Folder POP3 (może to być tylko „INBOX”). |
| POP3Message | Wiadomość POP3. |
| POP3SSLStore | Magazyn wiadomości POP3 korzystający z SSL. |
| POP3Store | Magazyn wiadomości POP3. |
Kilka punktów, na które należy zwrócić uwagę powyżej tego dostawcy:
Dostawca POP3 obsługuje tylko jeden folder o nazwie INBOX. Ze względu na ograniczenia protokołu POP3, wiele funkcji API JavaMail, takich jak powiadamianie o zdarzeniach, zarządzanie folderami, zarządzanie flagami itp., Jest niedozwolonych.
Dostęp do dostawcy POP3 uzyskuje się za pośrednictwem interfejsów API JavaMail przy użyciu nazwy protokołu pop3 lub adresu URL w postaci pop3: // użytkownik: hasło @ host: port / INBOX " .
POP3 nie obsługuje trwałych flag. Na przykład flaga Flags.Flag.RECENT nigdy nie zostanie ustawiona dla wiadomości POP3. Do aplikacji należy określenie, które wiadomości w skrzynce pocztowej POP3 są nowe .
POP3 nie obsługuje metody Folder.expunge (). Aby usunąć i zniszczyć wiadomości, ustaw flagę Flags.Flag.DELETED na wiadomościach i zamknij folder przy użyciu metody Folder.close (true).
POP3 nie podaje daty odebrania , więc metoda getReceivedDate zwróci wartość null.
Kiedy uzyskuje się dostęp do nagłówków wiadomości POP3, dostawca POP3 używa polecenia TOP, aby pobrać wszystkie nagłówki, które są następnie buforowane.
Gdy uzyskuje się dostęp do treści wiadomości POP3, dostawca POP3 używa polecenia RETR, aby pobrać całą wiadomość.
Metoda POP3Message.invalidate może służyć do unieważniania danych w pamięci podręcznej bez zamykania folderu.