API JavaMail - Guia rápido
A API JavaMail fornece uma estrutura independente de plataforma e protocolo para construir aplicativos de correio e mensagens. A API JavaMail fornece um conjunto de classes abstratas que definem objetos que compõem um sistema de correio. É um pacote opcional (extensão padrão) para leitura, composição e envio de mensagens eletrônicas.
JavaMail fornece elementos que são usados para construir uma interface para um sistema de mensagens, incluindo componentes e interfaces do sistema. Embora esta especificação não defina nenhuma implementação específica, JavaMail inclui várias classes que implementam os padrões de mensagens da Internet RFC822 e MIME. Essas classes são fornecidas como parte do pacote de classes JavaMail.
A seguir estão alguns dos protocolos com suporte na API JavaMail:
SMTP: Acrônimo para Simple Mail Transfer Protocol. Ele fornece um mecanismo para entregar e-mail.
POP: Acrônimo para Post Office Protocol. POP é o mecanismo que a maioria das pessoas na Internet usa para obter seus e-mails. Ele define o suporte para uma única caixa de correio para cada usuário. RFC 1939 define este protocolo.
IMAP: Acrônimo para Internet Message Access Protocol. É um protocolo avançado para recebimento de mensagens. Ele fornece suporte para várias caixas de correio para cada usuário, além de que a caixa de correio pode ser compartilhada por vários usuários. É definido na RFC 2060.
MIME: Acrônimo para Multipurpose Internet Mail Extensions. . Não é um protocolo de transferência de correio. Em vez disso, define o conteúdo do que é transferido: o formato das mensagens, anexos e assim por diante. Existem muitos documentos diferentes que entram em vigor aqui: RFC 822, RFC 2045, RFC 2046 e RFC 2047. Como um usuário da API JavaMail, você geralmente não precisa se preocupar com esses formatos. No entanto, esses formatos existem e são usados por seus programas.
NNTP and Others: Existem muitos protocolos fornecidos por fornecedores terceirizados. Alguns deles são Network News Transfer Protocol (NNTP), Secure Multipurpose Internet Mail Extensions (S / MIME) etc.
Detalhes sobre isso serão abordados nos capítulos subsequentes.
Arquitetura
Como dito acima, o aplicativo Java usa a API JavaMail para compor, enviar e receber e-mails. A figura a seguir ilustra a arquitetura do JavaMail:
O mecanismo abstrato da API JavaMail é semelhante a outras APIs J2EE, como JDBC, JNDI e JMS. Conforme visto no diagrama de arquitetura acima, a API JavaMail é dividida em duas partes principais:
Uma parte independente do aplicativo: uma interface de programação de aplicativo (API) é usada pelos componentes do aplicativo para enviar e receber mensagens de correio, independentemente do provedor ou protocolo subjacente usado.
Uma parte dependente de serviço: uma interface de provedor de serviço (SPI) fala os idiomas específicos do protocolo, como SMTP, POP, IMAP e Network News Transfer Protocol (NNTP). É usado para conectar um provedor de serviço de e-mail à plataforma J2EE.
Para enviar um e-mail usando seu aplicativo Java é simples o suficiente, mas para começar você deve ter JavaMail API e Java Activation Framework (JAF) instalado em sua máquina.
Você vai precisar do JavaBeans Activation Framework (JAF)extensão que fornece o pacote javax.activation apenas quando você não está usando o Java SE 6 ou mais recente.
Você pode baixar a versão mais recente do JavaMail (versão 1.5.0) do site padrão do Java.
Você pode baixar a versão mais recente do JAF (Versão 1.1.1) do site padrão do Java.
Baixe e descompacte esses arquivos. Nos diretórios de nível superior recém-criados, você encontrará vários arquivos jar para ambos os aplicativos. Você precisa adicionarmail.jar e activation.jar arquivos em seu CLASSPATH.
Servidor SMTP
Para enviar e-mails, você deve ter um servidor SMTP responsável pelo envio de e-mails. Você pode usar uma das seguintes técnicas para obter o servidor SMTP:
Instale e use qualquer servidor SMTP, como servidor Postfix (para Ubuntu), servidor Apache James (Java Apache Mail Enterprise Server) etc. (ou)
Use o servidor SMTP fornecido pelo provedor de hospedagem para, por exemplo: SMTP gratuito fornecer pelo JangoSMTP site é relay.jangosmtp.net (ou)
Use o servidor SMTP fornecido por empresas, por exemplo, gmail, yahoo, etc.
Nos exemplos nos capítulos subsequentes, usamos o servidor JangoSMTP gratuito para enviar e-mail. Você pode criar uma conta visitando este site e configurar seu endereço de e-mail.
A API JavaMail consiste em algumas interfaces e classes usadas para enviar, ler e excluir mensagens de e-mail. Embora existam muitos pacotes na API JavaMail, vai cobrir os dois principais pacotes que são usados em Java correio API com frequência: javax.mail e javax.mail.internet pacote. Esses pacotes contêm todas as classes principais do JavaMail. Eles são:
| Classe | Descrição |
|---|---|
| javax.mail.Session | A classe principal da API. Um objeto multithread representa o connection factory. |
| javax.mail.Message | Uma classe abstrata que modela uma mensagem de e-mail. As subclasses fornecem as implementações reais. |
| javax.mail.Address | Uma classe abstrata que modela os endereços (de e para os endereços) em uma mensagem. As subclasses fornecem as implementações específicas. |
| javax.mail.Authenticator | Uma classe abstrata usada para proteger os recursos de correio no servidor de correio. |
| javax.mail.Transport | Uma classe abstrata que modela um mecanismo de transporte de mensagem para enviar uma mensagem de email. |
| javax.mail.Store | Uma classe abstrata que modela um armazenamento de mensagem e seu protocolo de acesso, para armazenar e recuperar mensagens. Uma loja é dividida em pastas. |
| javax.mail.Folder | Uma classe abstrata que representa uma pasta de mensagens de correio. Ele pode conter subpastas. |
| javax.mail.internet.MimeMessage | A mensagem é uma classe abstrata, portanto, deve funcionar com uma subclasse; na maioria dos casos, você usará um MimeMessage. Uma MimeMessage é uma mensagem de e-mail que compreende tipos e cabeçalhos MIME. |
| javax.mail.internet.InternetAddress | Esta classe representa um endereço de e-mail da Internet usando a sintaxe de RFC822. A sintaxe de endereço típica tem o formato usuá[email protected] ou Nome pessoal <usuá[email protected]> . |
Aqui está um exemplo para enviar um e-mail simples. Aqui, usamos o servidor JangoSMTP, por meio do qual os e-mails são enviados ao nosso endereço de e-mail de destino. A configuração é explicada no capítulo Configuração do ambiente .
Para enviar um e-mail simples, as etapas a seguir são:
Faça uma sessão
Crie um objeto MimeMessage padrão e defina De, Para, Assunto na mensagem.
Defina a mensagem real como:
message.setText("your text goes here");Envie a mensagem usando o objeto Transporte.
Criar classe Java
Crie um arquivo de classe java SendEmail, cujos conteúdos são os seguintes:
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);
}
}
}Como estamos usando o servidor SMTP fornecido pelo provedor de hospedagem JangoSMTP, precisamos autenticar o nome de usuário e a senha. A classe javax.mail.PasswordAuthentication é usada para autenticar a senha.
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe SendEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
Sent message successfully....Como estou enviando um e-mail para meu endereço do gmail por meio do JangoSMTP, o seguinte e-mail seria recebido na caixa de entrada da minha conta do gmail:
Aqui está um exemplo para enviar um e-mail com anexo de sua máquina. O arquivo na máquina local éfile.txtcolocado em / home / manisha / . Aqui, usamos o servidor JangoSMTP, por meio do qual os e-mails são enviados ao nosso endereço de e-mail de destino. A configuração é explicada no capítulo Configuração do ambiente .
Para enviar um e-mail com uma imagem embutida, as etapas a seguir são:
Faça uma sessão
Crie um objeto MimeMessage padrão e defina De, Para, Assunto na mensagem.
Defina a mensagem real conforme abaixo:
messageBodyPart.setText("This is message body");Crie um objeto MimeMultipart. Adicione a messageBodyPart acima com a mensagem real definida nela, a este objeto multiparte.
Em seguida, adicione o anexo criando um Datahandler da seguinte maneira:
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);Em seguida, defina a multiparte na mensagem da seguinte maneira:
message.setContent(multipart);Envie a mensagem usando o objeto Transporte.
Criar classe Java
Crie um arquivo de classe java SendAttachmentInEmail, cujos conteúdos são os seguintes:
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);
}
}
}Como estamos usando o servidor SMTP fornecido pelo provedor de hospedagem JangoSMTP, precisamos autenticar o nome de usuário e a senha. A classe javax.mail.PasswordAuthentication é usada para autenticar a senha.
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe SendAttachmentInEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
Sent message successfully....Como estou enviando um e-mail para meu endereço do gmail por meio do JangoSMTP, o seguinte e-mail seria recebido na caixa de entrada da minha conta do gmail:
Aqui está um exemplo para enviar um e-mail HTML de sua máquina. Aqui, usamos o servidor JangoSMTP, por meio do qual os e-mails são enviados ao nosso endereço de e-mail de destino. A configuração é explicada no capítulo Configuração do ambiente .
Este exemplo é muito semelhante ao envio de e-mail simples, exceto que, aqui estamos usando o método setContent () para definir o conteúdo cujo segundo argumento é "text / html" para especificar que o conteúdo HTML está incluído na mensagem. Usando este exemplo, você pode enviar o conteúdo HTML que desejar.
Para enviar um e-mail com conteúdo HTML, as etapas seguidas são:
Faça uma sessão
Crie um objeto MimeMessage padrão e defina De, Para, Assunto na mensagem.
Defina a mensagem real usando o método setContent () conforme abaixo:
message.setContent("<h1>This is actual message embedded in HTML tags</h1>", "text/html");Envie a mensagem usando o objeto Transporte.
Criar classe Java
Crie um arquivo de classe java SendHTMLEmail, cujos conteúdos são os seguintes:
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);
}
}
}Como estamos usando o servidor SMTP fornecido pelo provedor de hospedagem JangoSMTP, precisamos autenticar o nome de usuário e a senha. A classe javax.mail.PasswordAuthentication é usada para autenticar a senha.
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe SendHTMLEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
Sent message successfully....Como estou enviando um e-mail para meu endereço do gmail por meio do JangoSMTP, o seguinte e-mail seria recebido na caixa de entrada da minha conta do gmail:
Aqui está um exemplo para enviar um e-mail HTML de sua máquina com imagem embutida. Aqui, usamos o servidor JangoSMTP, por meio do qual os e-mails são enviados ao nosso endereço de e-mail de destino. A configuração é explicada no capítulo Configuração do ambiente .
Para enviar um e-mail com uma imagem embutida, as etapas a seguir são:
Faça uma sessão
Crie um objeto MimeMessage padrão e defina De, Para, Assunto na mensagem.
Crie um objeto MimeMultipart.
Em nosso exemplo teremos uma parte HTML e uma imagem no e-mail. Portanto, primeiro crie o conteúdo HTML e defina-o no objeto multiparte como:
// 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);Em seguida, adicione a imagem criando um Datahandler da seguinte maneira:
// 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>");Em seguida, defina a multiparte na mensagem da seguinte maneira:
message.setContent(multipart);Envie a mensagem usando o objeto Transporte.
Criar classe Java
Crie um arquivo de classe java SendInlineImagesInEmail, cujos conteúdos são os seguintes:
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);
}
}
}Como estamos usando o servidor SMTP fornecido pelo provedor de hospedagem JangoSMTP, precisamos autenticar o nome de usuário e a senha. A classe javax.mail.PasswordAuthentication é usada para autenticar a senha.
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe SendInlineImagesInEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
Sent message successfully....Como estou enviando um e-mail para meu endereço do gmail por meio do JangoSMTP, o seguinte e-mail seria recebido na caixa de entrada da minha conta do gmail:
Há dois aspectos que precisam ser entendidos antes de prosseguir com este capítulo. Eles sãoCheck e Fetch.
Checkenviar um e-mail em JavaMail é um processo em que abrimos a respectiva pasta na caixa de correio e obtemos cada mensagem. Aqui, verificamos apenas o cabeçalho de cada mensagem, ou seja , o assunto De, Para . O conteúdo não é lido.
Fetchenviar um e-mail em JavaMail é um processo em que abrimos a respectiva pasta na caixa de correio e obtemos cada mensagem. Junto com o cabeçalho, também lemos o conteúdo, reconhecendo o tipo de conteúdo.
Para verificar ou buscar um e-mail usando a API JavaMail, precisaríamos de servidores POP ou IMAP. Para verificar e buscar os e-mails, classes de pasta e armazenamento são necessárias. Aqui usamos o servidor POP3 do GMAIL (pop.gmail.com). Neste capítulo, você aprenderá como verificar e-mails usando a API JavaMail. A busca será tratada nos capítulos subsequentes. Para verificar e-mails:
Faça uma sessão
Crie um objeto de armazenamento pop3 e conecte-se ao servidor pop.
Crie um objeto de pasta. Abra a pasta apropriada em sua caixa de correio.
Receba suas mensagens.
Feche os objetos Store e Folder.
Criar classe Java
Crie um arquivo de classe java CheckingMails, cujos conteúdos são os seguintes:
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);
}
}Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe CheckingMails.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMailsVerificar saída
Você deve ver a seguinte mensagem no console de comando:
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@2d1e165fAqui imprimimos o número de mensagens na CAIXA DE ENTRADA que é 4 neste caso. Também imprimimos Assunto, Endereço De e Texto para cada mensagem de e-mail.
No capítulo anterior, aprendemos como verificar e-mails. Agora vamos ver como obter cada e-mail e ler seu conteúdo. Vamos escrever uma classe JavaFetchingEmail que lerá os seguintes tipos de e-mails:
Email simples
Email com anexo
Email com imagem embutida
As etapas básicas seguidas no código são as seguintes:
Obtenha o objeto Session.
Crie um objeto de armazenamento POP3 e conecte-se ao armazenamento.
Crie o objeto Pasta e abra a pasta apropriada em sua caixa de correio.
Recupere mensagens.
Feche a pasta e armazene os objetos respectivamente.
Criar classe Java
Crie um arquivo de classe java FetchingEmail, cujo conteúdo é o seguinte:
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());
}
}Você pode ativar a depuração removendo o comentário da instrução emailSession.setDebug (true);
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe FetchingEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
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"Aqui você pode ver que há três emails em nossa caixa de correio. Primeiro, um e-mail simples com a mensagem "Olá, sou uma string de mensagem simples ....". O segundo e-mail contém um anexo. O conteúdo do anexo também é impresso conforme visto acima. O terceiro e-mail tem uma imagem embutida.
Vamos modificar nosso CheckingMails.java do capítulo Checking Emails . Seu conteúdo é o seguinte:
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);
}
}Você pode ativar a depuração removendo o comentário da instrução emailSession.setDebug (true);
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe CheckingMails.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMailsVerificar saída
Você pode ver uma mensagem semelhante à abaixo no console de comando:
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@3ad5ba3aNeste capítulo, veremos como responder a um e-mail usando a API JavaMail. As etapas básicas seguidas no programa abaixo são:
Obtenha o objeto Session com os detalhes dos servidores POP e SMTP nas propriedades. Precisaríamos dos detalhes do POP para recuperar mensagens e dos detalhes do SMTP para enviar mensagens.
Crie um objeto de armazenamento POP3 e conecte-se ao armazenamento.
Crie o objeto Pasta e abra a pasta apropriada em sua caixa de correio.
Recupere mensagens.
Repita as mensagens e digite "Y" ou "y" se quiser responder.
Obtenha todas as informações (Para, De, Assunto, Conteúdo) da mensagem.
Construa a mensagem de resposta, usando o método Message.reply (). Este método configura uma nova mensagem com o destinatário e assunto adequados. O método usa um parâmetro booleano que indica se deve responder apenas ao remetente (falso) ou responder a todos (verdadeiro).
Defina De, Texto e Responder para na mensagem e envie-a por meio da instância do objeto Transporte.
Feche os objetos de transporte, pasta e armazenamento, respectivamente.
Aqui, usamos o servidor JangoSMTP, por meio do qual os e-mails são enviados ao nosso endereço de e-mail de destino. A configuração é explicada no capítulo Configuração do ambiente .
Criar classe Java
Crie um arquivo de classe java ReplyToEmail, cujos conteúdos são os seguintes:
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();
}
}
}Você pode ativar a depuração removendo o comentário da instrução session.setDebug (true);
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe ReplyToEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail.javaAgora que a classe está compilada, execute o seguinte comando para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
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 ....Verifique a caixa de entrada para a qual o e-mail foi enviado. No nosso caso, a mensagem recebida é a seguinte:
Neste capítulo, veremos como encaminhar um e-mail usando a API JavaMail. As etapas básicas seguidas no programa abaixo são:
Obtenha o objeto Session com os detalhes dos servidores POP e SMTP nas propriedades. Precisaríamos dos detalhes do POP para recuperar mensagens e dos detalhes do SMTP para enviar mensagens.
Crie um objeto de armazenamento POP3 e conecte-se ao armazenamento.
Crie o objeto Pasta e abra a pasta apropriada em sua caixa de correio.
Recupere mensagens.
Repita as mensagens e digite "Y" ou "y" se desejar encaminhar.
Obtenha todas as informações (Para, De, Assunto, Conteúdo) da mensagem.
Construa a mensagem de encaminhamento trabalhando com as partes que constituem uma mensagem. A primeira parte seria o texto da mensagem e a segunda parte seria a mensagem a ser encaminhada. Combine os dois em uma multiparte. Em seguida, você adiciona a multiparte a uma mensagem endereçada adequadamente e a envia.
Feche os objetos de transporte, pasta e armazenamento, respectivamente.
Aqui, usamos o servidor JangoSMTP, por meio do qual os e-mails são enviados ao nosso endereço de e-mail de destino. A configuração é explicada no capítulo Configuração do ambiente .
Criar classe Java
Crie um arquivo de classe java ForwardEmail, cujos conteúdos são os seguintes:
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();
}
}
}Você pode ativar a depuração removendo o comentário da instrução session.setDebug (true);
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe ForwardEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail.javaAgora que a classe está compilada, execute o seguinte comando para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
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....Verifique a caixa de entrada para a qual o e-mail foi enviado. Em nosso caso, a mensagem encaminhada seria a seguinte:
Neste capítulo, veremos como excluir um e-mail usando a API JavaMail. A exclusão de mensagens envolve o trabalho com os sinalizadores associados às mensagens. Existem diferentes sinalizadores para diferentes estados, alguns definidos pelo sistema e alguns definidos pelo usuário. Os sinalizadores predefinidos são definidos na classe interna Flags.Flag e estão listados abaixo:
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
O protocolo POP suporta apenas a exclusão das mensagens.
As etapas básicas seguidas no programa de exclusão são:
Obtenha o objeto Session com os detalhes dos servidores POP e SMTP nas propriedades. Precisaríamos dos detalhes do POP para recuperar mensagens e dos detalhes do SMTP para enviar mensagens.
Crie um objeto de armazenamento POP3 e conecte-se ao armazenamento.
Crie o objeto Pasta e abra a pasta apropriada em sua caixa de correio no modo READ_WRITE.
Recupera mensagens da pasta da caixa de entrada.
Repita as mensagens e digite "Y" ou "y" se quiser excluir a mensagem invocando o método setFlag (Flags.Flag.DELETED, true) no objeto Message.
As mensagens marcadas como DELETED não são realmente excluídas, até que chamemos o método expunge () no objeto Folder ou fechemos a pasta com expunge definido como true.
Feche o objeto da loja.
Criar classe Java
Crie um arquivo de classe java ForwardEmail, cujos conteúdos são os seguintes:
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);
}
}Você pode ativar a depuração removendo o comentário da instrução emailSession.setDebug (true);
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe DeleteEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail.javaAgora que a classe está compilada, execute o seguinte comando para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
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: TestingEm todos os capítulos anteriores, usamos o servidor JangoSMTP para enviar emails. Neste capítulo, aprenderemos sobre o servidor SMTP fornecido pelo Gmail. O Gmail (entre outros) oferece o uso de seu servidor SMTP público gratuitamente.
Os detalhes do servidor SMTP do Gmail podem ser encontrados aqui . Como você pode ver nos detalhes, podemos usar a conexão TLS ou SSL para enviar e-mail através do servidor SMTP do Gmail.
O procedimento para enviar e-mail usando o servidor SMTP do Gmail é semelhante ao explicado no capítulo Enviando e-mails , exceto que mudaríamos o servidor host. Como pré-requisito, o endereço de e-mail do remetente deve ser uma conta ativa do gmail. Vamos tentar um exemplo.
Criar classe Java
Crie um arquivo Java SendEmailUsingGMailSMTP, cujo conteúdo é o seguinte:
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);
}
}
}Aqui, o host é definido como smtp.gmail.com e a porta é definida como 587 . Aqui, habilitamos a conexão TLS.
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe SendEmailUsingGMailSMTP.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTPVerificar saída
Você deve ver a seguinte mensagem no console de comando:
Sent message successfully....Até agora, trabalhamos em nossos capítulos anteriores principalmente com a pasta INBOX. Esta é a pasta padrão na qual reside a maioria dos e-mails. Alguns sistemas podem chamá-lo como INBOX e alguns outros podem chamá-lo por algum outro nome. Mas, você sempre pode acessá-lo da API JavaMail usando o nome INBOX.
A API JavaMail representa pastas como instâncias da classe abstrata Folder:
public abstract class Folder extends ObjectEssa classe declara métodos para solicitar pastas nomeadas de servidores, excluir mensagens de pastas, pesquisar mensagens específicas em pastas, listar as mensagens em uma pasta e assim por diante.
Abrindo uma pasta
Não podemos criar uma pasta diretamente, pois o único construtor da classe Folder é protegido . Podemos obter uma pasta em:
uma sessão
uma loja
ou outra pasta
Todas as classes acima têm um método getFolder () semelhante com assinatura semelhante:
public abstract Folder getFolder(String name) throws MessagingExceptionAlguns dos métodos que ajudam a obter o objeto Folder são:
| Método | Descrição |
|---|---|
| booleano existe () | Verifica se a pasta realmente existe. Use este método antes de obter o objeto Folder. |
| abstract void open (modo int) | Quando você obtém uma pasta , ela é fechada. Use este método para abri-lo. modo pode ser Folder.READ_ONLY ou Folder.READ_WRITE. |
| isOpen booleano abstrato () | Este método retorna verdadeiro se a pasta estiver aberta, falso se estiver fechada |
| abstract void close (expunge booleano) | Fecha a pasta. Se o argumento expunge for verdadeiro , todas as mensagens excluídas da pasta serão excluídas do arquivo real no servidor. Caso contrário, eles são simplesmente marcados como excluídos , mas as mensagens ainda podem ser recuperadas. |
Informações básicas da pasta
A seguir estão alguns dos métodos na classe Folder que retornam informações básicas sobre uma pasta:
| Método | Descrição |
|---|---|
| String abstrata getName () | Retorna o nome da pasta, como "TutorialsPoint Mail" |
| Abstract String getFullName () | Retorna o nome hierárquico completo da raiz, como “books / Manisha / TutorialsPoint Mail”. |
| URLName getURLName () | Retorne um URLName representando esta pasta. |
| abstract Folder getParent () | Retorna o nome da pasta que contém esta pasta, ou seja, a pasta pai. Por exemplo, "Manisha" do exemplo anterior "TutorialsPoint Mail". |
| abstract int getType () | Retorna um int indicando se a pasta pode conter mensagens e / ou outras pastas. |
| int getMode () | Ele retorna uma das duas constantes nomeadas Folder.READ_ONLY ou Folder.READ_WRITE ou -1 quando o modo é desconhecido. |
| Store getStore () | Retorna o objeto Store do qual esta pasta foi recuperada. |
| char getSeparator abstrato () | Retorne o caractere delimitador que separa o nome do caminho desta pasta dos nomes das subpastas imediatas. |
Gerenciando pasta
A seguir estão alguns dos métodos que ajudam a gerenciar a pasta:
| Método | Descrição |
|---|---|
| criação booleana abstrata (tipo int) | Isso cria uma nova pasta na Loja desta pasta. Onde o tipo seria: Folder.HOLDS_MESSAGES ou Folder.HOLDS_FOLDERS. Retorna verdadeiro se a pasta for criada com sucesso, caso contrário, retorna falso . |
| exclusão booleana abstrata (recurse boolean) | Isso exclui a pasta apenas se ela estiver fechada. Caso contrário, ele lança uma IllegalStateException . Se recurse for true , as subpastas serão excluídas. |
| renameTo booleano abstrato (pasta f) | Isso muda o nome desta pasta. Uma pasta deve ser fechada para ser renomeada. Caso contrário, uma IllegalStateException é lançada. |
Gerenciando mensagens em pastas
A seguir estão alguns dos métodos que ajudam a gerenciar as mensagens na pasta:
| Método | Descrição |
|---|---|
| abstract void appendMessages (Message [] messages) | Como o nome indica, as mensagens na matriz são colocadas no final desta pasta. |
| void copyMessages (Message [] messages, Folder destination) | Isso copia as mensagens desta pasta para uma pasta especificada fornecida como argumento. |
| Abstract Message [] expunge () | Para excluir uma mensagem de uma pasta, defina seu sinalizador Flags.Flag.DELETED como verdadeiro. Para remover fisicamente mensagens excluídas de uma pasta, você deve chamar este método. |
Listando o conteúdo de uma pasta
Existem quatro métodos para listar as pastas que uma pasta contém:
| Método | Descrição |
|---|---|
| Pasta [] a lista () | Isso retorna uma matriz listando as pastas que esta pasta contém. |
| Pasta [] listSubscribed () | Isso retorna uma matriz que lista todas as pastas assinadas que esta pasta contém. |
| Lista abstrata de pastas [] (padrão de string) | Isso é semelhante ao método list () , exceto que permite que você especifique um padrão. O padrão é uma string que fornece o nome das pastas correspondentes. |
| Folder [] listSubscribed (padrão de string) | Isso é semelhante ao método listSubscribed () , exceto que permite que você especifique um padrão. O padrão é uma string que fornece o nome das pastas correspondentes. |
Verificando se há correio
| Método | Descrição |
|---|---|
| abstract int getMessageCount () | Este método pode ser chamado em uma pasta aberta ou fechada. No entanto, no caso de uma pasta fechada, este método pode (ou não) retornar -1 para indicar que o número exato de mensagens não está facilmente disponível. |
| abstract boolean hasNewMessages () | Isso retorna verdadeiro se novas mensagens foram adicionadas à pasta desde que foi aberta pela última vez. |
| int getNewMessageCount () | Ele retorna a nova contagem de mensagens verificando as mensagens na pasta cujo sinalizador RECENTE está definido. |
| int getUnreadMessageCount () | Isso pode ser invocado em uma pasta aberta ou fechada. No entanto, no caso de uma pasta fechada, pode retornar -1 para indicar que a resposta real seria muito cara de se obter. |
Recebendo mensagens de pastas
A classe Folder fornece quatro métodos para recuperar mensagens de pastas abertas:
| Método | Descrição |
|---|---|
| Abstract Message getMessage (int messageNumber) | Isso retorna a enésima mensagem na pasta. A primeira mensagem da pasta é a número 1. |
| Message [] getMessages () | Isso retorna uma matriz de objetos Message representando todas as mensagens nesta pasta. |
| Message [] getMessages (int start, int end) | Isso retorna uma matriz de objetos Message da pasta, começando com start e terminando com end, inclusive. |
| Message [] getMessages (int [] messageNumbers) | Isso retorna uma matriz contendo apenas as mensagens especificamente identificadas por número na matriz messageNumbers . |
| void fetch (Message [] messages, FetchProfile fp) | Pré-busca os itens especificados no FetchProfile para as mensagens fornecidas. O argumento FetchProfile especifica quais cabeçalhos nas mensagens devem ser pré-buscados. |
Pesquisando Pastas
Se o servidor oferecer suporte à pesquisa (como muitos servidores IMAP e a maioria dos servidores POP não), será fácil pesquisar em uma pasta as mensagens que atendem a determinados critérios. Os critérios são codificados em objetos SearchTerm. A seguir estão os dois métodos de pesquisa:
| Método | Descrição |
|---|---|
| Pesquisa de mensagem [] (termo SearchTerm) | Pesquise esta pasta por mensagens que correspondam ao critério de pesquisa especificado. Retorna uma matriz contendo as mensagens correspondentes. Retorna uma matriz vazia se nenhuma correspondência for encontrada. |
| Pesquisa de mensagem [] (termo de SearchTerm, mensagens de mensagem []) | Pesquise a matriz de mensagens fornecida para aquelas que correspondem ao critério de pesquisa especificado. Retorna uma matriz contendo as mensagens correspondentes. Retorna uma matriz vazia se nenhuma correspondência for encontrada. Os objetos Message especificados devem pertencer a esta pasta. |
Bandeiras
A modificação de sinalizadores é útil quando você precisa alterar os sinalizadores para todo o conjunto de mensagens em uma pasta. A seguir estão os métodos fornecidos na classe Folder:
| Método | Descrição |
|---|---|
| void setFlags (Message [] messages, Flags flag, boolean value) | Define os sinalizadores especificados nas mensagens especificadas na matriz. |
| void setFlags (int start, int end, sinalizadores sinalizadores, valor booleano) | Define os sinalizadores especificados nas mensagens numeradas do início ao fim, inclusive início e fim. |
| void setFlags (int [] messageNumbers, sinalizador sinalizador, valor booleano) | Define os sinalizadores especificados nas mensagens cujos números de mensagem estão na matriz. |
| Abstract Flags getPermanentFlags () | Retorna os sinalizadores que esta pasta suporta para todas as mensagens. |
Uma cota em JavaMail é um número limitado ou fixo ou uma quantidade de mensagens em um armazenamento de e-mail. Cada solicitação de serviço de correio conta para a cota de chamadas de API JavaMail. Um serviço de e-mail pode aplicar o seguinte critério de cota:
Tamanho máximo das mensagens de e-mail enviadas, incluindo anexos.
Tamanho máximo das mensagens de correio recebidas, incluindo anexos.
Tamanho máximo da mensagem quando um administrador é um destinatário
Para gerenciamento de cotas, o JavaMail tem as seguintes classes:
| Classe | Descrição |
|---|---|
| cota de classe pública | Esta classe representa um conjunto de cotas para uma determinada raiz de cota. Cada raiz de cota possui um conjunto de recursos, representado pela classe Quota.Resource. Cada recurso tem um nome (por exemplo, "ARMAZENAMENTO"), um uso atual e um limite de uso. Este possui apenas um método setResourceLimit (String name, long limit) . |
| public static class Quota.Resource | Representa um recurso individual em uma raiz de cota. |
| interface pública QuotaAwareStore | Uma interface implementada por Stores que suporta cotas. Os getQuota e setquota métodos suportar o modelo de quota definida pela extensão IMAP quota. GmailSSLStore, GmailStore, IMAPSSLStore, IMAPStore são as classes de implementação conhecidas desta interface. |
Vamos ver um exemplo nas seções a seguir que verifica o nome de armazenamento de correio, limite e seu uso.
Criar classe Java
Crie um arquivo de classe java QuotaExample, cujos conteúdos são os seguintes:
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();
}
}
}Aqui estão as conexões com o serviço gmail via servidor IMAP (imap.gmail.com), já que IMAPStore implementa o QuotaAwareStore. Depois de obter o objeto Store, busque o array Quota, itere por meio dele e imprima as informações relevantes.
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe QuotaExample.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExampleVerificar saída
Você deve ver uma mensagem semelhante no console de comando:
imapStore ---imaps://abc%[email protected]
quotaRoot:''
name:'STORAGE', limit:'15728640', usage:'513'Uma mensagem pode ser devolvida por vários motivos. Este problema é discutido em profundidade em rfc1211 . Apenas um servidor pode determinar a existência de uma determinada caixa de correio ou nome de usuário. Quando o servidor detecta um erro, ele retorna uma mensagem indicando o motivo da falha para o remetente da mensagem original.
Existem muitos padrões de Internet que cobrem notificações de status de entrega, mas um grande número de servidores não suporta esses novos padrões, em vez de usar técnicas ad hoc para retornar essas mensagens de falha. Portanto, fica muito difícil correlacionar a mensagem devolvida com a mensagem original que causou o problema.
JavaMail inclui suporte para análise de notificações de status de entrega. Existem várias técnicas e heurísticas para lidar com esse problema. Uma das técnicas sendo Caminhos de retorno de envelope variável. Você pode definir o caminho de retorno no envelopador conforme mostrado no exemplo abaixo. Este é o endereço para onde os emails devolvidos são enviados. Você pode querer definir isso para um endereço genérico, diferente do cabeçalho De :, para que possa processar devoluções remotas. Isso é feito definindo a propriedade mail.smtp.from em JavaMail.
Criar classe Java
Crie um arquivo de classe java SendEmail, cujos conteúdos são os seguintes:
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()
}Aqui podemos ver que a propriedade mail.smtp.from é definida de forma diferente do endereço de origem.
Compilar e executar
Agora que nossa classe está pronta, vamos compilar a classe acima. Salvei a classe SendEmail.java no diretório:/home/manisha/JavaMailAPIExercise. Precisamos dos jars javax.mail.jar e activation.jar no classpath. Execute o comando abaixo para compilar a classe (ambos os jars são colocados no diretório / home / manisha /) no prompt de comando:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.javaAgora que a classe está compilada, execute o comando abaixo para executar:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailVerificar saída
Você deve ver a seguinte mensagem no console de comando:
Sending ....
Sending done ...SMTP é um acrônimo para Simple Mail Transfer Protocol. É um padrão da Internet para transmissão de correio eletrônico (e-mail) em redes de protocolo da Internet (IP). O SMTP usa a porta TCP 25. As conexões SMTP protegidas por SSL são conhecidas pela abreviatura SMTPS, embora SMTPS não seja um protocolo por si só.
API JavaMail tem pacote com.sun.mail.smtpque atuam como provedor de protocolo SMTP para acessar um servidor SMTP. A tabela a seguir lista as classes incluídas neste pacote:
| Classe | Descrição |
|---|---|
| SMTPMessage | Esta classe é uma especialização da classe MimeMessage que permite especificar várias opções e parâmetros de SMTP que serão usados quando esta mensagem for enviada por SMTP. |
| SMTPSSLTransport | Esta classe implementa a classe abstrata Transporte usando SMTP sobre SSL para envio e transporte de mensagens. |
| SMTPTransport | Esta classe implementa a classe abstrata Transport usando SMTP para envio e transporte de mensagens. |
A tabela a seguir lista as exceções lançadas:
| Exceção | Descrição |
|---|---|
| SMTPAddressFailedException | Essa exceção é lançada quando a mensagem não pode ser enviada. |
| SMTPAddressSucceededException | Esta exceção é encadeada fora de uma SendFailedException quando a propriedade mail.smtp.reportsuccess é verdadeira. |
| SMTPSenderFailedException | Essa exceção é lançada quando a mensagem não pode ser enviada. |
| SMTPSendFailedException | Essa exceção é lançada quando a mensagem não pode ser enviada. A exceção inclui o endereço do remetente, que o servidor de e-mail rejeitou. |
o com.sun.mail.smtpprovedor usa autenticação SMTP opcionalmente. Para usar a autenticação SMTP, você precisará definir a propriedade mail.smtp.auth ou fornecer ao Transporte SMTP um nome de usuário e uma senha ao se conectar ao servidor SMTP. Você pode fazer isso usando uma das seguintes abordagens:
Forneça um objeto Autenticador ao criar sua sessão de e-mail e forneça as informações de nome de usuário e senha durante o retorno de chamada do Autenticador. A propriedade mail.smtp.user pode ser configurada para fornecer um nome de usuário padrão para o retorno de chamada, mas a senha ainda precisará ser fornecida explicitamente. Essa abordagem permite que você use o método de envio de transporte estático para enviar mensagens. Por exemplo:
Transport.send(message);Chame o método de conexão de transporte explicitamente com argumentos de nome de usuário e senha. Por exemplo:
Transport tr = session.getTransport("smtp");
tr.connect(smtphost, username, password);
msg.saveChanges();
tr.sendMessage(msg, msg.getAllRecipients());
tr.close();O provedor de protocolo SMTP suporta as seguintes propriedades, que podem ser definidas no objeto JavaMail Session. As propriedades são sempre definidas como strings. Por exemplo:
props.put("mail.smtp.port", "587");IMAP é um acrônimo para Internet Message Access Protocol. É um protocolo de Internet da camada de aplicativo que permite que um cliente de e-mail acesse o e-mail em um servidor de e-mail remoto. Um servidor IMAP geralmente escuta na porta 143 conhecida. IMAP sobre SSL (IMAPS) é atribuído ao número de porta 993.
IMAP suporta modos de operação on-line e off-line. Os clientes de e-mail que usam IMAP geralmente deixam mensagens no servidor até que o usuário as exclua explicitamente.
Pacote com.sun.mail.imapé um provedor de protocolo IMAP para a API JavaMail que fornece acesso a um armazenamento de mensagem IMAP. A tabela a seguir lista a interface e as classes deste provedor:
| Classe / Interface | Descrição |
|---|---|
| IMAPFolder.ProtocolCommand | Esta é uma interface simples para comandos de protocolo IMAP definidos pelo usuário. |
| ACL | Esta é uma aula. Uma entrada da lista de controle de acesso para um identificador de autenticação específico (usuário ou grupo). |
| IMAPFolder | Esta classe implementa uma pasta IMAP. |
| IMAPFolder.FetchProfileItem | Esta é uma classe para buscar cabeçalhos. |
| IMAPMessage | Esta classe implementa um objeto ReadableMime. |
| IMAPMessage.FetchProfileCondition | Esta classe implementa o teste a ser feito em cada mensagem da pasta. |
| IMAPSSLStore | Esta classe fornece acesso a um armazenamento de mensagens IMAP por SSL. |
| IMAPStore | Esta classe fornece acesso a um armazenamento de mensagens IMAP. |
| Direitos | Esta classe representa o conjunto de direitos para um identificador de autenticação (por exemplo, um usuário ou grupo). |
| Rights.Right | Esta classe interna representa um direito individual. |
| SortTerm | Um critério de classificação específico, conforme definido pela RFC 5256. |
Alguns pontos a serem observados acima deste provedor:
Este provedor oferece suporte aos protocolos IMAP4 e IMAP4rev1.
Um IMAPStore conectado mantém um pool de objetos de protocolo IMAP para uso na comunicação com o servidor IMAP. Conforme as pastas são abertas e novos objetos de protocolo IMAP são necessários, o IMAPStore os fornecerá do pool de conexão ou os criará se nenhum estiver disponível. Quando uma pasta é fechada, seu objeto de protocolo IMAP é retornado ao pool de conexão se o pool.
O objeto IMAPStore conectado pode ou não manter um objeto de protocolo IMAP separado que fornece ao armazenamento uma conexão dedicada ao servidor IMAP.
Post Office Protocol (POP) é um protocolo padrão de camada de aplicativo da Internet usado por clientes de e-mail locais para recuperar e-mail de um servidor remoto por meio de uma conexão TCP / IP. O POP oferece suporte a requisitos simples de download e exclusão para acesso a caixas de correio remotas. Um servidor POP3 escuta na conhecida porta 110.
Pacote com.sun.mail.pop3é um provedor de protocolo POP3 para a API JavaMail que fornece acesso a um armazenamento de mensagens POP3. A tabela abaixo lista as classes neste pacote:
| Nome | Descrição |
|---|---|
| POP3Folder | Uma pasta POP3 (só pode ser "INBOX"). |
| POP3Message | Uma mensagem POP3. |
| POP3SSLStore | Um armazenamento de mensagens POP3 usando SSL. |
| POP3Store | Um armazenamento de mensagens POP3. |
Alguns pontos a serem observados acima deste provedor:
O provedor POP3 suporta apenas uma única pasta chamada INBOX. Devido às limitações do protocolo POP3, muitos dos recursos da API JavaMail, como notificação de eventos, gerenciamento de pastas, gerenciamento de sinalizadores, etc., não são permitidos.
O provedor POP3 é acessado através das APIs JavaMail usando o nome do protocolo POP3 ou uma URL da forma POP3: // utilizador: senha @ host: port / INBOX" .
POP3 não oferece suporte a sinalizadores permanentes. Por exemplo, o sinalizador Flags.Flag.RECENT nunca será definido para mensagens POP3. Cabe ao aplicativo determinar quais mensagens em uma caixa de correio POP3 são novas .
O POP3 não oferece suporte ao método Folder.expunge (). Para excluir e eliminar mensagens, defina o sinalizador Flags.Flag.DELETED nas mensagens e feche a pasta usando o método Folder.close (true).
POP3 não fornece uma data de recebimento , portanto, o método getReceivedDate retornará nulo.
Quando os cabeçalhos de uma mensagem POP3 são acessados, o provedor POP3 usa o comando TOP para buscar todos os cabeçalhos, que são armazenados em cache.
Quando o conteúdo de uma mensagem POP3 é acessado, o provedor POP3 usa o comando RETR para buscar a mensagem inteira.
O método POP3Message.invalidate pode ser usado para invalidar os dados armazenados em cache sem fechar a pasta.