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ć [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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail

Sprawdź 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail

Sprawdź 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail

Sprawdź 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail

Sprawdź 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails

Sprawdź 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@2d1e165f

Tutaj 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail

Sprawdź 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails

Sprawdź 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@3ad5ba3a

W 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.java

Teraz, gdy klasa jest skompilowana, wykonaj następujące polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail

Sprawdź 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.java

Teraz, gdy klasa jest skompilowana, wykonaj następujące polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail

Sprawdź 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.java

Teraz, gdy klasa jest skompilowana, wykonaj następujące polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail

Sprawdź 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: Testing

We 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP

Sprawdź 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 Object

Ta 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 MessagingException

Oto 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample

Sprawdź 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.java

Teraz, gdy klasa jest skompilowana, wykonaj poniższe polecenie, aby uruchomić:

java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail

Sprawdź 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.