JavaMail - 快速指南
JavaMail API提供了一个独立于平台且与协议无关的框架来构建邮件和消息传递应用程序。 JavaMail API提供了一组抽象类，用于定义组成邮件系统的对象。 它是一个可选包（标准扩展名），用于阅读，撰写和发送电子邮件。
JavaMail提供了用于构建消息传递系统接口的元素，包括系统组件和接口。 虽然此规范没有定义任何特定的实现，但JavaMail确实包含几个实现RFC822和MIME Internet消息传递标准的类。 这些类作为JavaMail类包的一部分提供。
以下是JavaMail API支持的一些协议:
SMTP : Simple Mail Transfer Protocol缩写。 它提供了一种传递电子邮件的机制。
POP : Post Office Protocol缩写。 POP是大多数人用来获取邮件的机制。 它定义了对每个用户的单个邮箱的支持。 RFC 1939定义了该协议。
IMAP : Internet Message Access Protocol缩写。 它是用于接收消息的高级协议。 它为每个用户提供多个邮箱支持，此外，邮箱可以由多个用户共享。 它在RFC 2060中定义。
MIME : Multipurpose Internet Mail Extensions缩写。 。 它不是邮件传输协议。 相反，它定义了传输内容:消息的格式，附件等。 这里有许多不同的文档:RFC 822，RFC 2045，RFC 2046和RFC 2047.作为JavaMail API的用户，您通常不需要担心这些格式。 但是，这些格式确实存在并由您的程序使用。
NNTP and Others :第三方提供商提供了许多协议。 其中一些是网络新闻传输协议（NNTP），安全多用途Internet邮件扩展（S/MIME）等。
这些细节将在随后的章节中介绍。
结构 (Architecture)
如上所述，java应用程序使用JavaMail API来编写，发送和接收电子邮件。下图说明了JavaMail的体系结构:
JavaMail API的抽象机制类似于其他J2EE API，例如JDBC，JNDI和JMS。 如上面的架构图所示，JavaMail API分为两个主要部分:
独立于应用程序的部分:应用程序组件使用应用程序编程接口（API）来发送和接收邮件消息，而与所使用的基础提供程序或协议无关。
依赖于服务的部分:服务提供者接口（SPI）说特定于协议的语言，例如SMTP，POP，IMAP和网络新闻传输协议（NNTP）。 它用于将电子邮件服务的提供者插入J2EE平台。
Environment Setup
使用Java应用程序发送电子邮件非常简单，但首先应该在您的计算机上安装JavaMail API和Java Activation Framework (JAF) 。
您将需要JavaBeans Activation Framework (JAF)扩展，仅当您不使用Java SE 6或更高版本时才提供javax.activation包。
您可以从Java的标准网站下载最新版本的JavaMail (Version 1.5.0) 。
您可以从Java的标准网站下载最新版本的JAF (Version 1.1.1) 。
下载并解压缩这些文件，在新创建的顶级目录中，您将找到两个应用程序的jar文件。 您需要在CLASSPATH中添加mail.jar和activation.jar文件。
SMTP服务器
要发送电子邮件，您必须拥有负责发送邮件的SMTP服务器。 您可以使用以下技术之一来获取SMTP服务器:
安装和使用任何SMTP服务器，如Postfix服务器（用于Ubuntu），Apache James服务器（Java Apache Mail Enterprise Server）等。 （要么）
使用主机提供商提供的SMTP服务器，例如: JangoSMTP站点提供的免费SMTP是relay.jangosmtp.net （或）
使用公司提供的SMTP服务器，例如gmail，yahoo等。
在后续章节中的示例中，我们使用了免费的JangoSMTP服务器来发送电子邮件。 您可以访问此站点并配置电子邮件地址来创建帐户。
Core Classes
JavaMail API包含一些用于发送，读取和删除电子邮件的接口和类。 虽然JavaMail API中有许多软件包，但它们将涵盖Java Mail API中经常使用的两个主要软件包: javax.mail和javax.mail.internet软件包。 这些包包含所有JavaMail核心类。 他们是:
| 类 | 描述 |
|---|---|
| javax.mail.Session | API的关键类。 多线程对象表示连接工厂。 |
| javax.mail.Message | 一个为电子邮件建模的抽象类。 子类提供实际的实现。 |
| javax.mail.Address | 一个抽象类，用于对消息中的地址（来自和到地址）进行建模。 子类提供特定的实现。 |
| javax.mail.Authenticator | 用于保护邮件服务器上的邮件资源的抽象类。 |
| javax.mail.Transport | 一种抽象类，用于模拟用于发送电子邮件的邮件传输机制。 |
| javax.mail.Store | 一种抽象类，用于为消息存储及其访问协议建模，用于存储和检索消息。 商店分为文件夹。 |
| javax.mail.Folder | 表示邮件消息文件夹的抽象类。 它可以包含子文件夹。 |
| javax.mail.internet。 MimeMessage | Message是一个抽象类，因此必须使用子类; 在大多数情况下，您将使用MimeMessage。 MimeMessage是一种了解MIME类型和标头的电子邮件。 |
| javax.mail.internet。 InternetAddress | 此类表示使用RFC822语法的Internet电子邮件地址。 典型的地址语法格式为user@host.domain或Personal Name <user@host.domain> 。 |
Sending Simple Emails
以下是发送简单电子邮件的示例。 在这里，我们使用了JangoSMTP服务器，通过该服务器将电子邮件发送到我们的目标电子邮件地址。 环境设置章节中介绍了该设置 。
发送简单的电子邮件步骤如下:
参加一个会议
创建一个默认的MimeMessage对象，并在消息中设置From, To, Subject 。
将实际消息设置为:
message.setText("your text goes here");使用Transport对象发送消息。
创建Java类 (Create Java Class)
创建一个java类文件SendEmail ，其内容如下:
package com.iowiki;
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 = "destinationemail@gmail.com";
// Sender's email ID needs to be mentioned
String from = "fromemail@gmail.com";
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);
}
}
}
由于我们使用主机提供商JangoSMTP提供的SMTP服务器，我们需要验证用户名和密码。 javax.mail.PasswordAuthentication类用于验证密码。
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类SendEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
Sent message successfully....
当我通过JangoSMTP向我的Gmail地址发送电子邮件时，我的gmail帐户收件箱中会收到以下邮件:
Sending Email With Attachment
以下是从您的计算机发送包含附件的电子邮件的示例。 本地机器上的文件是file.txt放在/home/manisha/ 。 在这里，我们使用了JangoSMTP服务器，通过该服务器将电子邮件发送到我们的目标电子邮件地址。 环境设置章节中介绍了该设置 。
要发送包含内嵌图像的电子邮件，请执行以下步骤:
参加一个会议
创建一个默认的MimeMessage对象，并在消息中设置From, To, Subject 。
设置实际消息如下:
messageBodyPart.setText("This is message body");创建一个MimeMultipart对象。 将上面带有实际消息的messageBodyPart添加到此multipart对象中。
接下来通过创建Datahandler添加附件，如下所示:
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);接下来在消息中设置multipart，如下所示:
message.setContent(multipart);使用Transport对象发送消息。
创建Java类 (Create Java Class)
创建一个java类文件SendAttachmentInEmail ，其内容如下:
package com.iowiki;
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 = "destinationemail@gmail.com";
// Sender's email ID needs to be mentioned
String from = "fromemail@gmail.com";
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);
}
}
}
由于我们使用主机提供商JangoSMTP提供的SMTP服务器，我们需要验证用户名和密码。 javax.mail.PasswordAuthentication类用于验证密码。
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类SendAttachmentInEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendAttachmentInEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
Sent message successfully....
当我通过JangoSMTP向我的Gmail地址发送电子邮件时，我的gmail帐户收件箱中会收到以下邮件:
Sending an HTML Email
以下是从您的计算机发送HTML电子邮件的示例。 在这里，我们使用了JangoSMTP服务器，通过该服务器将电子邮件发送到我们的目标电子邮件地址。 环境设置章节中介绍了该设置 。
此示例与发送简单电子邮件非常相似，不同之处在于，我们使用setContent（）方法设置第二个参数为“text/html”的内容，以指定HTML内容包含在消息中。 使用此示例，您可以发送与您喜欢的HTML内容一样大的内容。
要发送包含HTML内容的电子邮件，请按以下步骤操作:
参加一个会议
创建一个默认的MimeMessage对象，并在消息中设置From, To, Subject 。
使用setContent（）方法设置实际消息，如下所示:
message.setContent("<h1>This is actual message embedded in HTML tags</h1>", "text/html");使用Transport对象发送消息。
创建Java类 (Create Java Class)
创建一个java类文件SendHTMLEmail ，其内容如下:
package com.iowiki;
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 = "destinationemail@gmail.com";
// Sender's email ID needs to be mentioned
String from = "fromemail@gmail.com";
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);
}
}
}
由于我们使用主机提供商JangoSMTP提供的SMTP服务器，我们需要验证用户名和密码。 javax.mail.PasswordAuthentication类用于验证密码。
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类SendHTMLEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendHTMLEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
Sent message successfully....
当我通过JangoSMTP向我的Gmail地址发送电子邮件时，我的gmail帐户收件箱中会收到以下邮件:
Sending Email With Inline Images
以下是使用内嵌图像从您的计算机发送HTML电子邮件的示例。 在这里，我们使用了JangoSMTP服务器，通过该服务器将电子邮件发送到我们的目标电子邮件地址。 环境设置章节中介绍了该设置 。
要发送包含内嵌图像的电子邮件，请执行以下步骤:
参加一个会议
创建一个默认的MimeMessage对象，并在消息中设置From, To, Subject 。
创建一个MimeMultipart对象。
在我们的示例中，我们将在电子邮件中包含HTML部分和图像。 首先创建HTML内容并将其设置在multipart对象中:
// 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);接下来，通过创建Datahandler来添加图像，如下所示:
// 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>");接下来在消息中设置multipart，如下所示:
message.setContent(multipart);使用Transport对象发送消息。
创建Java类 (Create Java Class)
创建一个java类文件SendInlineImagesInEmail ，其内容如下:
package com.iowiki;
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 = "destinationemail@gmail.com";
// Sender's email ID needs to be mentioned
String from = "fromemail@gmail.com";
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);
}
}
}
由于我们使用主机提供商JangoSMTP提供的SMTP服务器，我们需要验证用户名和密码。 javax.mail.PasswordAuthentication类用于验证密码。
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类SendInlineImagesInEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendInlineImagesInEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
Sent message successfully....
当我通过JangoSMTP向我的Gmail地址发送电子邮件时，我的gmail帐户收件箱中会收到以下邮件:
Checking Emails
在继续本章之前，有两个方面需要理解。 它们是Check and Fetch 。
在JavaMail中Check电子邮件是我们打开邮箱中的相应文件夹并获取每条消息的过程。 这里我们只检查每条消息的标题，即From, To, subject 。 内容未被阅读。
在JavaMail中Fetch电子邮件是我们打开邮箱中的相应文件夹并获取每条消息的过程。 除了标题，我们还通过识别内容类型来阅读内容。
要使用JavaMail API检查或获取电子邮件，我们需要POP或IMAP服务器。 要检查和获取电子邮件，需要文件夹和商店类。 这里我们使用了GMAIL的POP3服务器（pop.gmail.com）。 本章将学习如何使用JavaMail API检查电子邮件。 后续章节将介绍提取。 要查看电子邮件:
参加一个会议
创建pop3 Store对象并与pop服务器连接。
创建文件夹对象。 打开邮箱中的相应文件夹。
收到你的消息。
关闭Store和Folder对象。
创建Java类 (Create Java Class)
创建一个java类文件CheckingMails ，其内容如下:
package com.iowiki;
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 = "yourmail@gmail.com";// change accordingly
String password = "*****";// change accordingly
check(host, mailStoreType, username, password);
}
}
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类CheckingMails.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
messages.length---4
---------------------------------
Email Number 1
Subject: Test Mail--Fetch
From: <abcd@gmail.com>
Text: javax.mail.internet.MimeMultipart@327a5b7f
---------------------------------
Email Number 2
Subject: testing ----checking simple email
From: <abcd@gmail.com>
Text: javax.mail.internet.MimeMultipart@7f0d08bc
---------------------------------
Email Number 3
Subject: Email with attachment
From: <abcd@gmail.com>
Text: javax.mail.internet.MimeMultipart@30b8afce
---------------------------------
Email Number 4
Subject: Email with Inline image
From: <abcd@gmail.com>
Text: javax.mail.internet.MimeMultipart@2d1e165f
这里我们打印了INBOX中的消息数量，在这种情况下为4。 我们还为每封电子邮件打印了主题，发件人地址和文本。
Fetching Emails
在上一章中，我们学习了如何查看电子邮件。 现在让我们看看如何获取每封电子邮件并阅读其内容。 让我们编写一个Java类FetchingEmail ，它将读取以下类型的电子邮件:
简单邮件
电子邮件附件
使用内联图片发送电子邮件
代码中遵循的基本步骤如下:
获取Session对象。
创建POP3商店对象并连接到商店。
创建文件夹对象并在邮箱中打开相应的文件夹。
检索邮件。
分别关闭文件夹和存储对象。
创建Java类 (Create Java Class)
创建java创建一个java类文件FetchingEmail ，其内容如下:
package com.iowiki;
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 =
"abc@gmail.com";// 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());
}
}
您可以通过取消注释语句emailSession.setDebug(true);来设置调试emailSession.setDebug(true);
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类FetchingEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: FetchingEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
messages.length---3
---------------------------------
This is the message envelope
---------------------------
FROM: XYZ <xyz@gmail.com>
TO: ABC <abc@gmail.com>
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 <xyz@gmail.com>
TO: ABC <abc@gmail.com>
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 <xyz@gmail.com>
TO: ABC <abc@gmail.com>
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"
在这里，您可以看到我们的邮箱中有三封电子邮件。 首先是一条简单的邮件，上面写着“你好是一个简单的消息字符串......”。 第二封邮件有附件。 附件的内容也如上所示打印。 第三封邮件有内嵌图片。
Authentication
我们将从“ 检查电子邮件 ”一章修改我们的CheckingMails.java。 其内容如下:
package com.iowiki;
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(
"manishapatil3may@gmail.com", "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 = "abc@gmail.com";// change accordingly
String password = "*****";// change accordingly
check(host, mailStoreType, username, password);
}
}
您可以通过取消注释语句emailSession.setDebug(true);来设置调试emailSession.setDebug(true);
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类CheckingMails.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: CheckingMails
验证输出 (Verify Output)
您可以在命令控制台上看到类似的消息:
messages.length---3
---------------------------------
Email Number 1
Subject: Today is a nice day
From: XYZ <xyz@gmail.com>
Text: javax.mail.internet.MimeMultipart@45f676cb
---------------------------------
Email Number 2
Subject: hiiii....
From: XYZ <xyz@gmail.com>
Text: javax.mail.internet.MimeMultipart@37f12d4f
---------------------------------
Email Number 3
Subject: helloo
From: XYZ <xyz@gmail.com>
Text: javax.mail.internet.MimeMultipart@3ad5ba3a
Replying Emails
在本章中，我们将了解如何使用JavaMail API回复电子邮件。 以下程序中遵循的基本步骤是:
在属性中获取具有POP和SMTP服务器详细信息的Session对象。 我们需要POP详细信息来检索邮件和SMTP详细信息以发送邮件。
创建POP3商店对象并连接到商店。
创建文件夹对象并在邮箱中打开相应的文件夹。
检索邮件。
如果要回复，请仔细检查消息并输入“Y”或“y”。
获取邮件的所有信息（收件人，发件人，主题，内容）。
使用Message.reply（）方法构建回复消息。 此方法使用正确的收件人和主题配置新邮件。 该方法采用布尔参数，指示是仅回复发件人（false）还是回复all（true）。
在消息中设置From，Text和Reply-to，并通过Transport对象的实例发送它。
分别关闭Transport，文件夹和存储对象。
在这里，我们使用了JangoSMTP服务器，通过该服务器将电子邮件发送到我们的目标电子邮件地址。 环境设置章节中介绍了该设置 。
创建Java类 (Create Java Class)
创建一个java类文件ReplyToEmail ，其内容如下:
package com.iowiki;
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", "xyz@gmail.com",
"*****");//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();
}
}
}
您可以通过取消注释语句session.setDebug(true);来设置调试session.setDebug(true);
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类ReplyToEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ReplyToEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
From: ABC <abc@gmail.com>
Reply-to: abc@trioteksolutions.com
To: XYZ <xyz@gmail.com>
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 ....
检查邮件发送到的收件箱。 在我们的案例中，收到的消息如下所示:
Forwarding Emails
在本章中，我们将了解如何使用JavaMail API转发电子邮件。 以下程序中遵循的基本步骤是:
在属性中获取具有POP和SMTP服务器详细信息的Session对象。 我们需要POP详细信息来检索邮件和SMTP详细信息以发送邮件。
创建POP3商店对象并连接到商店。
创建文件夹对象并在邮箱中打开相应的文件夹。
检索邮件。
如果要转发，请浏览消息并输入“Y”或“y”。
获取邮件的所有信息（收件人，发件人，主题，内容）。
通过使用组成消息的部分来构建转发消息。 第一部分是消息的文本，第二部分是要转发的消息。 将两者组合成一个多部分。 然后将多部分添加到正确寻址的消息并发送它。
分别关闭Transport，文件夹和存储对象。
在这里，我们使用了JangoSMTP服务器，通过该服务器将电子邮件发送到我们的目标电子邮件地址。 环境设置章节中介绍了该设置 。
创建Java类 (Create Java Class)
创建一个java类文件ForwardEmail ，其内容如下:
package com.iowiki;
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", "xyz@gmail.com",
"*****");//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();
}
}
}
您可以通过取消注释语句session.setDebug(true);来设置调试session.setDebug(true);
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类ForwardEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: ForwardEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
From: ABC <abc@gmail.com>
Reply-to: abc@trioteksolutions.com
To: XYZ <xyz@gmail.com>
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....
检查邮件发送到的收件箱。 在我们的例子中，转发的消息如下所示:
Deleting Emails
在本章中，我们将了解如何使用JavaMail API删除电子邮件。 删除消息涉及使用与消息关联的标志。 不同的状态有不同的标志，一些是系统定义的，一些是用户定义的。 预定义标志在内部类Flags.Flag中定义，如下所示:
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
POP协议仅支持删除消息。
删除程序中遵循的基本步骤是:
在属性中获取具有POP和SMTP服务器详细信息的Session对象。 我们需要POP详细信息来检索邮件和SMTP详细信息以发送邮件。
创建POP3商店对象并连接到商店。
创建文件夹对象并以READ_WRITE模式打开邮箱中的相应文件夹。
从收件箱文件夹中检索邮件。
如果要通过在Message对象上调用方法setFlag（Flags.Flag.DELETED，true）来删除消息，请迭代消息并键入“Y”或“y”。
在我们调用Folder对象上的expunge（）方法或关闭expunge设置为true的文件夹之前，标记为DELETED的消息实际上不会被删除。
关闭商店对象。
创建Java类 (Create Java Class)
创建一个java类文件ForwardEmail ，其内容如下:
package com.iowiki;
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 = "abc@gmail.com";// change accordingly
String password = "*****";// change accordingly
delete(host, mailStoreType, username, password);
}
}
您可以通过取消注释语句emailSession.setDebug(true);来设置调试emailSession.setDebug(true);
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类DeleteEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: DeleteEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
messages.length---1
---------------------------------
Email Number 1
Subject: Testing
From: ABC <abc@gmail.com>
Do you want to delete this message [y/n] ? y
Marked DELETE for message: Testing
Gmail SMTP Server
在之前的所有章节中，我们使用JangoSMTP服务器发送电子邮件。 在本章中，我们将了解Gmail提供的SMTP服务器。 Gmail（以及其他）免费提供其公共SMTP服务器。
Gmail SMTP服务器详细信息可在here找到。 正如您在详细信息中看到的，我们可以使用TLS或SSL连接通过Gmail SMTP服务器发送电子邮件。
使用Gmail SMTP服务器发送电子邮件的过程与发送电子邮件一章中说明的类似，只是我们会更改主机服务器。 作为先决条件，发件人电子邮件地址应该是活动的Gmail帐户。 让我们试一试。
创建Java类 (Create Java Class)
创建一个Java文件SendEmailUsingGMailSMTP ，其内容如下:
package com.iowiki;
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 = "xyz@gmail.com";//change accordingly
// Sender's email ID needs to be mentioned
String from = "abc@gmail.com";//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);
}
}
}
主机设置为smtp.gmail.com ，端口设置为587 。 这里我们启用了TLS连接。
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类SendEmailUsingGMailSMTP.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmailUsingGMailSMTP
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
Sent message successfully....
Folder Management
到目前为止，我们在前面的章节中主要使用了INBOX文件夹。 这是大多数邮件所在的默认文件夹。 有些系统可能将其称为INBOX，而另一些系统可能会将其称为其他名称。 但是，您始终可以使用名称INBOX从JavaMail API访问它。
JavaMail API将文件夹表示为抽象Folder类的实例:
public abstract class Folder extends Object
此类声明了从服务器请求命名文件夹，从文件夹中删除邮件，在文件夹中搜索特定邮件，在文件夹中列出邮件等的方法。
打开文件夹
我们无法直接创建文件夹，因为Folder类中唯一的构造函数protected 。 我们可以从以下位置获取Folder
一个会议
一家商店
或其他文件夹
以上所有类都有类似的getFolder（）方法，具有类似的签名:
public abstract Folder getFolder(String name) throws MessagingException
一些有助于获取Folder对象的方法是:
| 方法 | 描述 |
|---|---|
| boolean exists() | 检查文件夹是否确实存在。 在获取Folder对象之前使用此方法。 |
| abstract void open （int mode） | 当你得到一个Folder ，它关闭。 使用此方法打开它。 mode可以是Folder.READ_ONLY或Folder.READ_WRITE。 |
| abstract boolean isOpen （） | 如果文件夹处于打开状态，则此方法返回true如果文件夹已关闭，则返回false |
| abstract void close （boolean expunge） | 关闭文件夹。 如果expunge参数为true ，则从服务器上的实际文件中删除该文件夹中的所有已删除邮件。 否则，它们只是标记为deleted ，但仍然可以取消删除邮件。 |
基本文件夹信息
以下是Folder类中的一些返回文件夹基本信息的方法:
| 方法 | 描述 |
|---|---|
| abstract String getName （） | 返回文件夹的名称，例如“IoWiki Mail” |
| abstract String getFullName （） | 从根目录返回完整的层次结构名称，例如“books/Manisha/IoWiki Mail”。 |
| URLName getURLName （） | 返回表示此文件夹的URLName。 |
| abstract文件夹getParent （） | 返回包含此文件夹的文件夹的名称，即父文件夹。 例如，之前的“IoWiki Mail”示例中的“Manisha”。 |
| abstract int getType() | 返回一个int，指示文件夹是否可以包含消息和/或其他文件夹。 |
| int getMode() | 当模式未知时，它返回两个命名常量Folder.READ_ONLY或Folder.READ_WRITE中的一个或-1。 |
| 存储getStore （） | 返回从中检索此文件夹的Store对象。 |
| abstract char getSeparator （） | 返回将此文件夹的路径名与直接子文件夹的名称分隔开的分隔符。 |
管理文件夹
以下是一些有助于管理文件夹的方法:
| 方法 | 描述 |
|---|---|
| abstract boolean create （int type） | 这将在此文件夹的Store中创建一个新文件夹。 其中type是:Folder.HOLDS_MESSAGES或Folder.HOLDS_FOLDERS。 如果成功创建文件夹，则返回true ，否则返回false 。 |
| abstract boolean delete （boolean recurse） | 仅当文件夹关闭时，才会删除该文件夹。 否则，它会抛出IllegalStateException 。 如果recurse为true ，则删除子文件夹。 |
| abstract boolean renameTo （Folder f） | 这会更改此文件夹的名称。 必须关闭文件夹才能重命名。 否则，抛出IllegalStateException。 |
管理文件夹中的邮件
以下是一些有助于管理文件夹中的消息的方法:
| 方法 | 描述 |
|---|---|
| abstract void appendMessages （Message [] messages） | 顾名思义，数组中的消息放在此文件夹的末尾。 |
| void copyMessages （Message []消息，文件夹目标） | 这会将此文件夹中的消息复制到作为参数提供的指定文件夹中。 |
| 抽象消息[] expunge （） | 要从文件夹中删除邮件，请将其Flags.Flag.DELETED标志设置为true。 要从文件夹中物理删除已删除的邮件，您必须调用此方法。 |
列出文件夹的内容
列出文件夹包含的文件夹有四种方法:
| 方法 | 描述 |
|---|---|
| 文件夹[] list （） | 这将返回一个列出此文件夹包含的文件夹的数组。 |
| Folder [] listSubscribed （） | 这将返回一个列出该文件夹包含的所有已订阅文件夹的数组。 |
| abstract Folder [] list（String pattern） | 这与list()方法类似，只是它允许您指定模式。 模式是一个字符串，给出匹配的文件夹的名称。 |
| Folder [] listSubscribed （String pattern） | 这类似于listSubscribed()方法，但它允许您指定模式。 模式是一个字符串，给出匹配的文件夹的名称。 |
检查邮件
| 方法 | 描述 |
|---|---|
| abstract int getMessageCount （） | 可以在打开或关闭的文件夹上调用此方法。 但是，在关闭文件夹的情况下，此方法可能（或可能不）返回-1以指示不容易获得确切的消息数。 |
| abstract boolean hasNewMessages （） | 如果自上次打开以来已将新消息添加到文件夹，则返回true 。 |
| int getNewMessageCount （） | 它通过检查设置了RECENT标志的文件夹中的消息来返回新的消息计数。 |
| int getUnreadMessageCount （） | 这可以在打开或关闭的文件夹上调用。 但是，在关闭文件夹的情况下，它可能返回-1表示真正的答案太昂贵而无法获得。 |
从文件夹中获取邮件
Folder类提供了四种从打开的文件夹中检索消息的方法:
| 方法 | 描述 |
|---|---|
| abstract Message getMessage （int messageNumber） | 这将返回文件夹中的第n条消息。 文件夹中的第一条消息是数字1。 |
| 消息[] getMessages （） | 这将返回表示此文件夹中所有消息的Message对象数组。 |
| Message [] getMessages （int start，int end） | 这将从文件夹返回一个Message对象数组，从start开始，以end结束，包括end。 |
| Message [] getMessages （int [] messageNumbers） | 这将返回一个数组，该数组仅包含messageNumbers数组中由number特定标识的那些消息。 |
| void fetch （Message []消息，FetchProfile fp） | 为给定的消息预取FetchProfile中指定的项目。 FetchProfile参数指定要预取的消息中的哪些标头。 |
正在搜索文件夹
如果服务器支持搜索（许多IMAP服务器都支持搜索，而大多数POP服务器不支持），则可以轻松地在文件夹中搜索符合特定条件的邮件。 标准在SearchTerm对象中编码。 以下是两种搜索方法:
| 方法 | 描述 |
|---|---|
| 消息[] search （SearchTerm术语） | 在此文件夹中搜索与指定搜索条件匹配的邮件。 返回包含匹配消息的数组。 如果未找到匹配项，则返回空数组。 |
| 消息[] search （SearchTerm术语，消息[]消息） | 在给定的消息数组中搜索与指定搜索条件匹配的消息。 返回包含匹配消息的数组。 如果未找到匹配项，则返回空数组。 指定的Message对象必须属于此文件夹。 |
Flags
当您需要更改文件夹中整个消息集的标志时，标记修改很有用。 以下是Folder类中提供的方法:
| 方法 | 描述 |
|---|---|
| void setFlags （Message []消息，Flags标志，布尔值） | 在数组中指定的消息上设置指定的标志。 |
| void setFlags （int start，int end，Flags flag，boolean value） | 设置从开始到结束编号的消息上的指定标志，包括开始和结束。 |
| void setFlags （int [] messageNumbers，Flags flag，boolean value） | 在消息编号在数组中的消息上设置指定的标志。 |
| 抽象标志getPermanentFlags （） | 返回此文件夹支持所有消息的标志。 |
Quota Management
JavaMail中的配额是电子邮件存储中的有限或固定数量或消息量。 每个邮件服务请求都计入JavaMail API调用配额。 电子邮件服务可以应用以下配额标准:
传出邮件的最大大小，包括附件。
传入邮件的最大大小，包括附件。
管理员是收件人时的最大邮件大小
对于配额管理，JavaMail具有以下类:
| 类 | 描述 |
|---|---|
| public class Quota | 此类表示给定配额根的一组配额。 每个配额根都有一组资源，由Quota.Resource类表示。 每个资源都有一个名称（例如，“STORAGE”），当前使用情况和使用限制。 这只有一个方法setResourceLimit(String name, long limit) 。 |
| public static class Quota.Resource | 表示配额根目录中的单个资源。 |
| public interface QuotaAwareStore | 由商店实施的支持配额的界面。 getQuota和setQuota方法支持IMAP QUOTA扩展定义的配额模型。 GmailSSLStore, GmailStore, IMAPSSLStore, IMAPStore是此接口的已知实现类。 |
让我们在以下部分中查看和示例，它们检查邮件存储名称，限制及其用法。
创建Java类 (Create Java Class)
创建一个java类文件QuotaExample ，其内容如下:
package com.iowiki;
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", "abc@gmail.com", "*****");
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();
}
}
}
这是通过IMAP（imap.gmail.com）服务器连接到gmail服务，因为IMAPStore实现了QuotaAwareStore。 获得Store对象后，获取Quota数组并遍历它并打印相关信息。
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类QuotaExample.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: QuotaExample
验证输出 (Verify Output)
您应该在命令控制台上看到类似的消息:
imapStore ---imaps://abc%40gmail.com@imap.gmail.com
quotaRoot:''
name:'STORAGE', limit:'15728640', usage:'513'
Bounced Messages
由于多种原因，可以退回邮件。 rfc1211深入讨论了这个问题。 只有服务器才能确定是否存在特定邮箱或用户名。 当服务器检测到错误时，它将向原始消息的发送方返回一条消息，指示失败的原因。
有许多Internet标准涵盖了传递状态通知，但是大量服务器不支持这些新标准，而是使用ad hoc技术来返回此类故障消息。 因此，将bounced消息与导致问题的原始消息相关联变得非常困难。
JavaMail包括对解析传递状态通知的支持。 有许多技术和启发式方法可以解决这个问题。 其中一种技术是可变包络返回路径。 您可以在信封中设置返回路径，如下例所示。 这是发送退回邮件的地址。 您可能希望将其设置为与From:标头不同的通用地址，以便处理远程反弹。 这是通过在JavaMail中设置mail.smtp.from属性来完成的。
创建Java类 (Create Java Class)
创建一个java类文件SendEmail ，其内容如下:
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 = "youraddress@gmail.com";
String to = "bouncer@fauxmail.com";//some invalid address
String bounceAddr = "toaddress@gmail.com";//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()
}
在这里我们可以看到属性mail.smtp.from的设置与from地址不同。
编译和运行 (Compile and Run)
现在我们的课已经准备好了，让我们编译上面的类。 我已将类SendEmail.java保存到目录: /home/manisha/JavaMailAPIExercise 。 我们需要在类路径中使用jars javax.mail.jar和activation.jar 。 执行以下命令从命令提示符编译类（两个jar放在/ home/manisha /目录中）:
javac -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail.java
现在编译了类，执行以下命令来运行:
java -cp /home/manisha/activation.jar:/home/manisha/javax.mail.jar: SendEmail
验证输出 (Verify Output)
您应该在命令控制台上看到以下消息:
Sending ....
Sending done ...
SMTP Servers
SMTP是Simple Mail Transfer Protocol的首字母缩写。 它是跨Internet协议（IP）网络的电子邮件（电子邮件）传输的Internet标准。 SMTP使用TCP端口25.由SSL保护的SMTP连接以速记SMTPS为人所知，尽管SMTPS本身不是协议。
JavaMail API具有包com.sun.mail.smtp ，它作为SMTP协议提供程序来访问SMTP服务器。 下表列出了此包中包含的类:
| 类 | 描述 |
|---|---|
| SMTPMessage | 此类是MimeMessage类的特化，它允许您指定在通过SMTP发送此消息时将使用的各种SMTP选项和参数。 |
| SMTPSSLTransport | 此类使用SMTP over SSL实现传输抽象类，以便提交和传输消息。 |
| SMTPTransport | 此类使用SMTP实现传输抽象类以进行消息提交和传输。 |
下表列出了抛出的异常:
| 例外 | 描述 |
|---|---|
| SMTPAddressFailedException | 无法发送邮件时抛出此异常。 |
| SMTPAddressSucceededException | 当mail.smtp.reportsuccess属性为true时，此异常将链接到SendFailedException。 |
| SMTPSenderFailedException | 无法发送邮件时抛出此异常。 |
| SMTPSendFailedException | 无法发送邮件时抛出此异常。例外包括邮件服务器拒绝的发件人地址。 |
com.sun.mail.smtp提供程序可选择使用SMTP身份验证。 要使用SMTP身份验证，您需要设置mail.smtp.auth属性，或在连接到SMTP服务器时为SMTP传输提供用户名和密码。 您可以使用以下方法之一执行此操作:
在创建邮件会话时提供Authenticator对象，并在Authenticator回调期间提供用户名和密码信息。 mail.smtp.user属性可以设置为提供回调的默认用户名，但仍需要明确提供密码。 此方法允许您使用静态传输发送方法来发送消息。 例如:
Transport.send(message);
使用用户名和密码参数显式调用Transport connect方法。 例如:
Transport tr = session.getTransport("smtp");
tr.connect(smtphost, username, password);
msg.saveChanges();
tr.sendMessage(msg, msg.getAllRecipients());
tr.close();
SMTP协议提供程序支持以下属性，这些属性可以在JavaMail会话对象中设置。 属性始终设置为字符串。 例如:
props.put("mail.smtp.port", "587");
IMAP Servers
IMAP是Internet Message Access Protocol缩写。 它是一种应用层Internet协议，允许电子邮件客户端访问远程邮件服务器上的电子邮件。 IMAP服务器通常侦听众所周知的端口143.基于SSL的IMAP（IMAPS）被分配给端口号993。
IMAP支持在线和离线操作模式。 使用IMAP的电子邮件客户端通常会在服务器上保留消息，直到用户明确删除它们为止。
软件包com.sun.mail.imap是JavaMail API的IMAP协议提供程序，提供对IMAP消息存储的访问。 下表列出了此提供程序的接口和类:
| 类/接口 | 描述 |
|---|---|
| IMAPFolder.ProtocolCommand | 这是用户定义的IMAP协议命令的简单interface 。 |
| ACL | 这是一堂课。 用于特定认证标识符（用户或组）的访问控制列表条目。 |
| IMAPFolder | 此类实现IMAP文件夹。 |
| IMAPFolder.FetchProfileItem | 这是一个用于获取标题的类。 |
| IMAPMessage | 该类实现了一个ReadableMime对象。 |
| IMAPMessage.FetchProfileCondition | 此类实现对文件夹中的每条消息执行的测试。 |
| IMAPSSLStore | 此类提供对通过SSL的IMAP消息存储的访问。 |
| IMAPStore | 此类提供对IMAP消息存储的访问。 |
| Rights | 此类表示身份验证标识符（例如，用户或组）的权限集。 |
| Rights.Right | 这个内在阶级代表个人权利。 |
| SortTerm | RFC 5256定义的特定排序标准。 |
此提供商上方需要注意的一些要点:
此提供程序支持IMAP4和IMAP4rev1协议。
连接的IMAPStore维护一个IMAP协议对象池，用于与IMAP服务器通信。 当打开文件夹并需要新的IMAP协议对象时，IMAPStore将从连接池提供它们，或者如果没有可用的话创建它们。 关闭文件夹时，如果池，其IMAP协议对象将返回到连接池。
连接的IMAPStore对象可能维护也可能不维护单独的IMAP协议对象，该对象为存储提供与IMAP服务器的专用连接。
POP3 Servers
邮局协议（POP）是本地电子邮件客户端用于通过TCP/IP连接从远程服务器检索电子邮件的应用程序层Internet标准协议。 POP支持访问远程邮箱的简单下载和删除要求。 POP3服务器侦听已知端口110。
软件包com.sun.mail.pop3是JavaMail API的POP3协议提供程序，提供对POP3消息存储的访问。 下表列出了此包中的类:
| 名称 | 描述 |
|---|---|
| POP3Folder | POP3文件夹（只能是“INBOX”）。 |
| POP3Message | POP3消息。 |
| POP3SSLStore | 使用SSL的POP3邮件存储。 |
| POP3Store | POP3邮件存储。 |
此提供商上方需要注意的一些要点:
POP3提供程序仅支持名为INBOX的单个文件夹。 由于POP3协议的限制，不允许使用许多JavaMail API功能，如事件通知，文件夹管理，标记管理等。
可以使用协议名称pop3或pop3://user:password@host:port/INBOX"形式的URL通过JavaMail API访问POP3提供程序。
POP3不支持永久标志。 例如，永远不会为POP3消息设置Flags.Flag.RECENT标志。 应用程序可以确定POP3邮箱中的哪些邮件是new邮件。
POP3不支持Folder.expunge（）方法。 要删除和删除消息，请在消息上设置Flags.Flag.DELETED标志，然后使用Folder.close（true）方法关闭该文件夹。
POP3不提供received date ，因此getReceivedDate方法将返回null。
当访问POP3消息的标头时，POP3提供程序使用TOP命令来获取所有标头，然后缓存这些标头。
当访问POP3消息的内容时，POP3提供程序使用RETR命令来获取整个消息。
POP3Message.invalidate方法可用于在不关闭文件夹的情况下使缓存的数据无效。
