JavaMail使用详解

CSDN IE QQ 百度 我挖 Google POCO Yahoo 新浪 365Key 天极 和讯 博拉 Live 奇客 鲜果 收客 饭否 叽歪 挖客

核心提示：在Java EE应用程序中，经常需要发送E-mail。Java EE框架为应用提供了JavaMail接口，通过JavaMail相关的接口可以读取邮件服务器的邮件，并且可以完成邮件的发送过程。 本章的主要内容包括： E-mail体系结构 JavaMail API 如何使用JavaMail API发送邮件 如何使

在Java EE应用程序中，经常需要发送E-mail。Java EE框架为应用提供了JavaMail接口，通过JavaMail相关的接口可以读取邮件服务器的邮件，并且可以完成邮件的发送过程。

本章的主要内容包括：

—  E-mail体系结构

—  JavaMail API

— 如何使用JavaMail API发送邮件

— 如何使用JavaMail API接收邮件

29.1  E-mail体系结构
29.1.1  什么是E-mail
E-mail是用户间或应用程序间交换信息的 Internet标准。每个用户都有自己的网上邮箱，发送方把信息发送到自己的网上信箱，并声明信息的接收方；该信箱所在的“邮局”会把信息发送到接收方 的“邮局”，接收方从接收方的“邮局”中自己的信箱获取信息。这样就完成了信息从发送方到接收方的传递。所以，要发送或者接收邮件首先应该有自己的邮箱。

E-mail消息可以包含普通文本，也可以包含更为复杂的多媒体数据类型和图像声音等。这样，用户就可以交换各种各样的信息。

每个E-mail消息的头信息中都包含消息的发出者、发送的目的地和其他相关信息。

29.1.2  E-mail体系结构
要完成消息的交互，需要几方面的支持：邮件发送客户端程序、邮件接收客户端程序、邮件发送服务器和邮件接收服务器，此外，还需要相关的通信协议。

邮件发送客户端程序和邮件接收客户端程序可以是相同的，例如经常使用的微软的Outlook既可以发送邮件，也可以接收邮件。

邮件发送服务器和邮件接收服务器也可以是相同的服务器。在与邮件服务器交互的过程中，主要完成两个动作，把邮件发送到邮件服务器，以及从邮件服务器读取邮件。所以，主要使用两类协议，分别进行邮件的发送和接收。

邮件从发送方到接收方的传递过程（参见图29.1）如下：

（1）邮件发送方通过邮件发送客户端把邮件发送到发送方的邮件服务器，在发送的过程中需要用到SMTP协议。

（2）发送方的邮件服务器把邮件发送到接收方的邮件服务器，使用的协议也是SMTP。

（3）邮件接收方从接收方邮件服务器接收邮件，使用POP3协议或者IMAP协议。

邮件

发送方
 
发送方邮件

服务器
 
接收方邮件

服务器
 
邮件

接收方
 
SMTP
 
SMTP
 
IMAP
 
POP3

图29.1  邮件从发送方到接收方的传递过程

29.1.3  E-mail相关的协议
— 简单邮件传输协议（SMTP）

在邮件发送方把邮件发送到发送方邮件服务器的时候，需要用到简单邮件传输协议（Simple Mail Transport Protocol，简称SMTP），发送方邮件服务器把邮件发送到接收方邮件服务器的时候，也要用到SMTP。SMTP是应用程序与邮件服务器通信并发送 邮件的Internet标准，SMTP通信基于TCP协议端口25之上。

— 邮箱协议（POP3）

邮件接收方从接收方邮件服务器接收邮件的时候，需要使用检索协议，可以使用POP3或者IMAP。POP3是Post Office Protocol的简称，是用于接收方从邮件服务器上检索E-mail消息的协议，工作在TCP协议端口110之上。

—  Internet消息访问协议（IMAP）

IMAP是Internet Message Access Protocol的简称，与POP3基本相同。完成的主要功能是从邮件服务器接收邮件，使用的端口是293。

29.1.4  什么是Java Mail
在Java EE应用中，经常需要通过E-mail与用户进行交互，主要是与邮件服务器的交互，例如向邮件服务器发送邮件，或者从邮件服务器接收邮件。如果是用户之间 直接进行交互可以使用邮件客户端程序，例如微软的Outlook。如果想在应用程序中发送邮件，就不能直接使用通用的客户端了，需要编写自己专门的邮件发 送和接收代码，并且需要与邮件服务器进行交互。可以通过Socket编程，使用相关的协议完成，但是这个过程非常复杂。而Java Mail提供了比较便利的解决方案。

JavaMail是Java EE中的标准API，是对邮件服务器访问过程的封装。使用JavaMail API则不需要编写与邮件服务器交互的详细过程，只需要调用相关接口即可。在接口中封装了与邮件服务器交互的详细过程。

本章的主要内容是介绍如何通过JavaMail API完成邮件的发送和接收。

29.2  JavaMail API                    
JavaMail API主要包括四个部分：Session，Message，Transport和InternetAddress。下面分别进行介绍。

29.2.1  Session
Session定义了全局的和每个用户的与邮件相关的属性，这些属性详细说明了客户机和服务器如何交流信息。Session中定义的属性如下：

—  mail.store.protocol：确定检索邮件所使用的协议。可以是IMAP（接收），也可以是POP3。

—  mail.transport.protocol：确定发送邮件所使用的协议，可以是SMTP（发送）。

—  mail.host：确定邮件服务器的主机名。

—  mail.user：确定检索邮件或者发送邮件的用户名。

—  mail.protocol.host：确定具体的发送邮件服务器或者接收邮件服务器。有时候发送邮件服务器和接收邮件服务器使用的主机不同，这时候需要详细指定各个协议使用的主机，如果不指定，则使用mail.host所确定的主机。

—  mail.protocol.user：为登录特定邮件服务器所使用的用户名，如果没有指定，使用mail.user所指定的用户。

—  mail.from：为邮件指定默认的回复地址，如果没有指定，使用mail.user所指定的用户。

29.2.2  Message
Message表示单个邮件消息，其属性包括消息类型、地址信息和所定义的目录结构。但是Message类是一个抽象类，必须实现它的一个子类。通常使用MimeMessage，它是Message类的一个派生类。

Message类的主要方法有两部分，第一部分主要在发送邮件的时候使用，用于设置邮件的相关信息，包括邮件的发送者、接收者、主题和发送时间等。这些方法如下：

—  setFrom()，用于设置邮件的发送者，值从“mail.user”属性中获取，如果这个值是默认的，则使用系统属性“user.name”。

—  setFrom（Address address），与上一个方法的作用相同，值是通过参数确定的，是Address的对象，通常使用其实现者InternetAddress的对象作为参数。

—  addFrom（Address[] addresses），在已有的邮件发送者中添加其他的邮件发送者，参数是要添加的邮件发送者的地址。

—  setSubject（String subject），用于设置邮件的标题。

—  setContent（String contentType），用于设置邮件的内容类型。

—  setSentDate（java.util.Date date），用于设置邮件发送的时间。

—  setRecipient（Message.RecipientType type, Address address），用于设置邮件的接收者。有两个参数，第一个参数是接收者的类型，第二个参数是接收者。接收者类型可以是 Message.RecipientType.TO，Message.RecipientType.CC和 Message.RecipientType.BCC，TO表示主要接收人，CC表示抄送人，BCC表示秘密抄送人。接收者与发送者一样，通常使用 InternetAddress的对象。

—  addRecipient（Message.RecipientType type, Address address），用于添加邮件的接收者，其参数与setRecipient方法的基本相同。

—  setRecipients（Message.RecipientType type, Address[] addresses），作用和setRecipient基本相同，区别在于该方法可以同时设置多个邮件的接收者。

—  addRecipients（Message.RecipientType type, Address[] addresses），用于添加邮件接收者，可以同时添加多个接收者。

—  setReplyTo（Address[] addresses），设置邮件的回复地址，参数用于确定要回复的地址。

—  setText（String text），用于设置邮件的文本，同时还将邮件的内容类型设置为text/plain。如果邮件的内容类型不是文本的，则需要通过setContent方法来设置内容类型。

第二部分用于获取邮件的相关信息，在接收邮件的时候使用：

—  Flags getFlags()，用于获取与邮件相关的标记属性。

—  Folder getFolder()，用于获取该邮件所在的文件夹。

—  Address getFrom()，用于获取邮件的发送者。

—  int getMessageNumber()，用于获取邮件的编号，该编号是邮件系统设置的。

—  Address[] getAllRecipients()，获取邮件的所有接收者。

—  java.util.Date getReceivedDate()，用于获取邮件的接收时间。

—  Address[] getRecipients(Message.RecipientType type)，用于获取指定接收类型的接收者，参数用于确定接收者的类型。

—  Address[] getReplyTo()，用于获取邮件的回复者，也就是邮件要给哪些人回复。

—  java.util.Date getSentDate()，用于获取邮件的发送时间。

—  java.lang.String getSubject()，用于获取邮件的主题。

29.2.3  Transport
Transport是一个抽象类，用于邮件的发送，主要的方法有：

—  public static void send(Message msg) throws MessagingException，用于发送邮件，参数就是要发送的邮件本身，该方法是一个静态方法，不需要实例化对象，可以直接使用。

—  public static void send(Message msg, Address[] addresses) throws MessagingException，也是用于发送邮件，有两个参数，第一个参数是要发送的邮件本身，第二个参数是邮件发送的目的地。该方法会忽略在邮 件中设置的接收者。

29.2.4  InternetAddress
InternetAddress把用户的E-mail地址映射为Internet地址。得 到的邮件发送者和接收者通常都是字符串，但是在Message中确定邮件的接收者和发送者，以及在发送邮件时候使用的都是Address的对象。 InternetAddress是Address的派生类，可以把字符串转换成InternetAddress类的对象。

构造函数如下：

InternetAddress( )，无参数的默认构造函数。

InternetAddress(java.lang.String address)，把一个字符串构造成一个InternetAddress，用得比较多。

InternetAddress(java.lang.String address, java.lang.String personal)，使用字符串和个人姓名构造一个InternetAddress。

InternetAddress(java.lang.String address, java.lang.String personal, java.lang.String charset)，使用字符串和个人姓名构造一个InternetAddress对象，名字的编码方式是第三个参数确定的。

要设置该对象所表示的Internet地址，可以通过下面的方法：

void setAddress(java.lang.String address)，参数确定了地址。

如果想把Internet地址转换成字符串，则使用下面的方法：

1. java.lang.String toString()  

29.3  WebLogic中邮件会话的配置
在介绍邮件发送和邮件接收程序之前，需要在WebLogic中配置邮件会话的相关信息。需要配置所使用的发送邮件服务器和接收邮件服务器。在WebLogic中的配置过程如下：

（1）进入到WebLogic Server的控制台；

（2）在控制台的左下方选择【Domain Structure】→【Service】→【Mail Sessions】；

（3）在控制台的左上方点击【Lock & Edit】；

（3）在界面的右边点击【New】；

（4）在接下来的过程中需要分别输入下面的信息：

— 会话的名字（Name）：MailSession。

— 会话的JNDI名字（JNDIName）：MailSession；会话的JNDI名字可以和会话的名字相同。

— 会话相关的属性：

1. mail.pop3.host =  218.25 . 154.4  （应该写你所使用的邮件服务器的IP地址）   
2.   
3. mail.transport.protocol = smtp （发送）   
4.   
5. mail.user = lixucheng    
6.   
7. mail.smtp.host =  218.25 . 154.6     
8.   
9. mail.store.protocol = pop3（接收）   

其中mail.pop3.host是所使用的接收邮件服务器，mail.transport.protocol是发送邮件所使用的协 议，mail.user是发送邮件和接收邮件时候的用户名，mail.smtp.host是所使用的发送邮件服务 器，mail.store.protocol是检索邮件所使用的协议。

输入完这些信息之后，点击【Save】，创建该邮件会话。

（5）把邮件会话部署到相应的服务器上：选择【Targets】页面，从服务器列表中选择相应的服务器，然后点击【Save】，就完成邮件会话的配置了。要让之前的配置起作用，需要点击左上角的【Activate Changes】（参见图29.2和图29.3）。

29.4  邮件发送示例程序
发送邮件的基本过程如下：

（1）得到会话对象

（2）构造邮件对象

（3）发送邮件

图29.2  邮件会话的配置

图29.3  把会话部署到相应的服务器上

29.4.1  得到会话对象
这里使用前面在WebLogic中配置好的邮件会话，所以首先要获取这个会话。下面的代码完成获取邮件会话的功能：

1. //获取上下文环境   
2.   
3. Context ctx =  new  InitialContext();   
4.   
5. //从JNDI中查找会话MailSession   
6.   
7. Session mailSession = (Session) ctx.lookup( "MailSession" );   

其中，MailSession是我们在前面配置的邮件会话中的JNDI名字。

如果不使用配置好的邮件会话，可以通过创建Properties对象设置相关会话属性，然后，通过Session.getInstance(propoties, null)创建会话对象。

29.4.2  构造邮件对象
发送一封邮件通常需要确定邮件发送者、邮件接收者、邮件的主题和邮件的内容，有时候还需要发送附件。这里先不考虑附件。其他的条件通过JSP界面接收，下面是构造邮件的代码：

1. //获取相关参数   
2.   
3. String to = request.getParameter( "to" );   
4.   
5. String subject = request.getParameter( "subject" );   
6.   
7. String from = request.getParameter( "from" );   
8.   
9. String message = request.getParameter( "message" );   
10.   
11. to =  new  String(to.getBytes( "8859_1" ));   
12.   
13. subject =  new  String(subject.getBytes( "8859_1" ));   
14.   
15. from =  new  String(from.getBytes( "8859_1" ));   
16.   
17. //创建消息对象   
18.   
19. Message msg =  new  MimeMessage(mailSession);   
20.   
21. //把邮件地址映射到Internet地址上   
22.   
23. InternetAddress dest =  new  InternetAddress(to);   
24.   
25. //设置消息内容   
26.   
27. msg.setFrom( new  InternetAddress(from));   
28.   
29. msg.setSubject(subject);        
30.   
31. msg.setRecipient(Message.RecipientType.TO, dest);   
32.   
33. msg.setContent(message,  "text/plain" );   

首先，通过request对象的getParameter方法获取邮件接收者、邮件发送者、邮件主题和邮件内容。然后，创建Message的对象。最后，通过Message的setXXX方法设置邮件的相关信息。

29.4.3  发送邮件
通过Transport的send(Message msg)方法发送构建好的消息。

1. Transport.send(msg);  

29.4.4  完整的代码
该实例的代码分为两部分，第一部分是发送邮件的界面，第二部分是发送邮件的处理代码。完整的代码如下：

1. < %@ page  import  = "java.util.*,    
2.   
3.              javax.mail.*,   
4.   
5.          javax.mail.internet.*,   
6.   
7.          javax.naming.*"   
8.   
9. % >   
10.   
11. < %@ page  contentType  =  "text/html;charset = gb2312" % >   
12.   
13. < html >   
14.   
15. < head >   
16.   
17. < title > Mail Sender JSP </ title >   
18.   
19. </ head >   
20.   
21. < body >   
22.   
23. < %   
24.   
25. if (request.getMethod().equals("POST")) {   
26.   
27. try {   
28.   
29.     //获取相关参数   
30.   
31.     String  to  =  request .getParameter("to");   
32.   
33.     String  subject  =  request .getParameter("subject");   
34.   
35.     String  from  =  request .getParameter("from");   
36.   
37.     String  message  =  request .getParameter("message");   
38.   
39.      to  =  new  String(to.getBytes("8859_1"));   
40.   
41.      subject  =  new  String(subject.getBytes("8859_1"));   
42.   
43.      from  =  new  String(from.getBytes("8859_1"));   
44.   
45.      message  =  new  String(message.getBytes("8859_1"));   
46.   
47.     //获取上下文环境   
48.   
49.     Context  ctx  =  new  InitialContext();   
50.   
51.     //从JNDI中查找会话MailSession   
52.   
53.     Session  mailSession  = (Session) ctx.lookup("MailSession");    
54.   
55.     //创建消息对象   
56.   
57.     Message  msg  =  new  MimeMessage(mailSession);   
58.   
59.        
60.   
61.     //把邮件地址映射到Internet地址上   
62.   
63.     InternetAddress  dest  =  new  InternetAddress(to);   
64.   
65.     //设置消息内容   
66.   
67.     msg.setFrom(new InternetAddress(from));   
68.   
69.     msg.setSubject(subject);        
70.   
71.     msg.setRecipient(Message.RecipientType.TO, dest);   
72.   
73.     msg.setContent(message, "text/plain");   
74.   
75.        
76.   
77.     //通过Transport类发送消息   
78.   
79.     Transport.send(msg);   
80.   
81.     out.println(" < h2 > 到 " + to + "的邮件发送成功! < h2 > ");   
82.   
83.   }   
84.   
85.   catch (Exception e) {   
86.   
87.     out.println(e);   
88.   
89.   }   
90.   
91. } else {   
92.   
93. % >   
94.   
95. < h1 > 发送邮件! </ h1 >   
96.   
97. < form   method  =  "post"   action  =  "mailsender.jsp" >   
98.   
99. To : < input   type  =  "text"   name  =  "to"   size  =  16 > < p >   
100.   
101. From : < input   type  =  "text"   name  =  "from"   size  =  16 > < p >   
102.   
103. Subject : < input   type  =  "text"   name  =  "subject"   size  =  16 > < p >   
104.   
105. Message : < input   type  =  "text"   name  =  "message"   size  =  16 >   
106.   
107. < p >   
108.   
109. < input   type  =  "submit"   value  =  "Submit"   name  =  "Command" >   
110.   
111. < %   
112.   
113. }   
114.   
115. % >   
116.   
117. </ body >   
118.   
119. </ html >   

29.4.5  程序的运行结果
直接访问mailsender.jsp文件时候的结果，这时候使用的请求方式是get，所以显示邮件发送的界面，参见图29.4。

图29.4  邮件发送的界面

图29.5显示了邮件发送成功的界面。填写完邮件的信息之后，提交给服务器，这时候的请求方式是Post。首先获取用户输入的与邮件相关的信息，然后把邮件发送出去。

图29.5  邮件发送成功的界面

29.4.6  发送HTML格式的邮件
HTML格式的邮件发送过程与前面文本类型邮件的发送过程基本相同，不同的是需要读取邮件的HTML文件，同时，需要设置邮件内容的格式。

先获取邮件的内容：

1. String content =  "" ;   
2.   
3. String file =  "source.htm" ;   
4.   
5. //要发送的html文件   
6.   
7. String line =  "" ;   
8.   
9. FileReader f =  new  FileReader(file);   
10.   
11. BufferedReader b =  new  BufferedReader(f);   
12.   
13. While((line = b.readline()) !=  null )   
14.   
15.    content += line;   

然后设置邮件的内容，把邮件的内容添加到邮件对象中：

1. message.setContent(content,  "text/html" );  

29.4.7  发送带附件的邮件
我们经常需要发送带附件的邮件。带附件的邮件发送过程与前面介绍的普通邮件发送过程基本相同，不同的是邮件本身的构造比较麻烦。下面我们介绍如何发送带附件的邮件，有些代码和前面是相同的，所以这里只介绍与前面不同的代码。

创建一个带附件的邮件的过程如下：

— 创建BodyPart对象，该对象表示邮件的主体或者邮件的附件。

— 把所有的BodyPart对象添加到MimeMultipart对象中。

— 把MimeMultipart对象添加到MimeMessage对象中。

（1）BodyPart对象的创建

BodyPart是抽象类，具体使用的是MimeBodyPart类的对象，而MimeBodyPart是BodyPart类的派生类。组成邮件的各部分都是MimeBodyPart的对象。

首先，创建邮件的主体部分：

1. BodyPart messagebody =  new  MimeBodyPart();   
2.   
3. //创建BodyPart类的对象   
4.   
5. messagebody.setText( "带附件的邮件，注意查看附件！" );   
6.   
7. //设置邮件的内容   

这样就创建了邮件的第一部分，也就是邮件的主体部分，下面创建邮件的附件部分。其中filename表示附件的名字。

1. BodyPart attachment =  new  MimeBodyPart();   
2.   
3. //创建BodyPart对象，用于表示邮件的附件   
4.   
5. String filename =  "filename" ;   
6.   
7. //要发送的邮件附件的名字   
8.   
9. DataSource ds =  new  FileDataSource(filename);   
10.   
11. //创建数据源，数据源指向附件文件   
12.   
13. attachment.setDataHandler( new  DataHandler(ds));   
14.   
15. //把附件BodyPart对象指向ds   
16.   
17. attachment.setFileName(filename);   
18.   
19. //设置附件的文件名   

这样把邮件的主体部分和邮件的附件部分全部创建完了。

（2）把Body对象添加到MimeMultipart对象中

邮件的各个组成部分不能独立添加到MimeMessage对象中，可以添加到其中的只能是Multipart的对象，而组成邮件的各个部分可以分别添加到Multipart对象中。下列代码完成的功能是把前面创建好的邮件的两部分添加到Multipart对象中。

1. Multipart multipart =  new  MimeMultipart();   
2.   
3. //创建MimeMultipart对象   
4.   
5. multipart.addBodyPart(messagebody);   
6.   
7. //把messagebody添加到multipart对象中   
8.   
9. multipart.addBodyPart(attachment);   
10.   
11. //把附件添加到multipart中   

（3）把MimeMultipart对象添加到MimeMessage中

把MimeMultipart对象添加到MimeMessage对象中的方法非常简单，与前面介绍的基本相同。

1. message.setContent(multipart);  

把MimeMultipart对象添加到message中之后，邮件的构造就完成了。邮件的发送过程与前面介绍的简单邮件的发送过程相同。

29.5  邮件接收示例程序
邮件接收的基本过程如下：

— 获得邮件会话；

— 创建Store对象；

— 连接到邮件服务器；

— 得到默认的文件夹；

— 得到所要操作的文件夹；

— 打开文件夹，可以获取与文件夹相关的信息；

— 获取文件夹中的所有邮件；

— 获取邮件相关的信息。

29.5.1  获得邮件会话
与发送邮件相同，接收邮件也需要获取相关的邮件会话。可以使用在WebLogic中配置好的邮件会话，也可以 通过Properties对象保存邮件会话相关的信息，然后通过该Properties对象创建邮件会话。下面的代码使用的是WebLogic中配置好的 邮件会话。在运行程序之前，需要保证配置好邮件会话。

1. Context ctx =  new  InitialContext();   
2.   
3. //创建上下文环   
4.   
5. Session mailsession = (Session)ctx.lookup( "MailSession" );   
6.   
7. //得到邮件会话   

29.5.2  创建Store对象
要检索邮件服务器上的邮件，需要连接到邮件服务器，与邮件服务器的连接可以通过Store对象来完成。Store对象是通过Session的getStore方法创建的。

1. Store store = mailsession.getStore();   
2.   
3. //创建存储对象   

29.5.3  连接到邮件服务器
连接到邮件服务器，需要知道邮件服务器的地址、连接邮件服务器的用户名以及该用户的口令。连接过程是通过Store对象的connect方法完成的。该方法需要三个参数，第一个参数为邮件服务器的地址、域名或者IP地址，第二个参数是用户名，第三个参数是口令。

1. store.connect( "218.25.154.4" , "lixucheng" , "123456" );   
2.   
3. //连接到邮件服务器   

29.5.4  得到默认的文件夹
连接到邮件服务器之后，可以得到一个默认的文件夹，通过它可以获得其他的文件夹。默认文件夹是通过Store对象的getDefaultFolder方法得到的。文件夹是邮件的存储地方。

1. Folder defaultFolder = store.getDefaultFolder();   
2.   
3. //得到默认的文件夹   

29.5.5  得到所要操作的文件夹
要访问邮件，需要得到邮件所在的文件夹，可以通过默认文件夹得到该文件夹，defaultFolder的list方法可以得到所有的文件夹。

1. Folder[] allfolder = defaultFolder.list();  

也可以通过Store对象的getFolder方法得到想要的文件夹。该方法需要一个参数，用于指定要打开的文件夹的名字。如果想得到INBOX文件夹，可以通过下面的方法。

1. Folder folder = store.getFolder( "INBOX" );  

29.5.6  打开文件夹，可以获取与文件夹相关的信息
可以通过Folder对象的open方法打开文件夹。该方法需要一个参数，指定了 文件夹的打开方式。文件夹的打开方式有两种：READ_ONLY和READ_WRITE。如果只是检索邮件信息而不改变其状态或内容，则应该使用 READ_ONLY打开方式。下面的代码是分别打开邮箱中的文件夹，并获得文件夹的相关信息。

1. for ( int  i =  0 ;i<allfolder.length;i++)   
2.   
3. {   
4.   
5.     allfolder[i].open(Folder.READ_ONLY);   
6.   
7.     out.println(allfolder[i].getName());   
8.   
9.     out.println( "\t" +allfolder[i].getMessageCount());   
10.   
11.     out.println( "\t" +allfolder[i].getNewMessageCount());   
12.   
13.     out.println( "\t" +allfolder[i].getUnreadMessageCount());   
14.   
15.     out.println( "<br>" );   
16.   
17.     allfolder[i].close( false );   
18.   
19. }   

其中，getName( )方法用于获取文件夹的名字，getMessageCount得到文件夹中邮件的数量，getNewMessageCount得到文件夹中新邮件的数 量，getUnreadMessageCount得到文件夹中未读邮件的数量。读取文件夹的信息之后，需要关闭文件夹。

29.5.7  获取文件夹中的所有邮件
要获取文件夹中的邮件，首先要打开文件夹。获取邮件是通过文件夹的getMessages方法来完成的。

1. defaultFolder = allfolder[ 0 ];   
2.   
3. defaultFolder.open(Folder.READ_ONLY);   
4.   
5. //打开该文件夹   
6.   
7. Message[] messages = defaultFolder.getMessages();   
8.   
9. //得到邮件信息   

29.5.8  获取邮件相关的信息
得到邮件对象Message之后，就可以获取邮件相关的信息以及邮件的内容了。下面的代码输出了邮件的相关信息：

1. Message message = messages[j];   
2.   
3. out.println( "<tr><td>" +message.getFrom()[ 0 ].toString()+ "</td>" );   
4.   
5. out.println( "<td>" +message.getSubject()+ "</td>" );   
6.   
7. out.println( "<td>" +message.getSentDate().toLocaleString()+ "</td>" );   
8.   
9. out.println( "<td>" +message.getSize()+ "</td></tr>" );   
10.   
11. out.println( "<td>" +(String)message.getContent()+ "</td></tr>" );   

其中，getFrom( )得到邮件的发送者，getSubject得到邮件的主题，getSentDate得到邮件的发送时间，getSize得到邮件的大小，getContent得到邮件的内容。

29.5.9  邮件的状态
邮件可以处于不同的状态，使用系统标记来标识邮件的状态，可以用Flags.Flag类中的静态成员变量来标记。共有七种：ANSWERED，DELETED，DRAFT，FLAGGED，RECENT，SEEN和USER。

ANSWERED表示该邮件已经被回复，当客户端对该信息回复后可以把该邮件标记为ANSWERED。

DELETED表示该邮件已经被删除，对某个文件夹的删除操作将删除该文件夹中所有标记为DELETED的邮件。

DRAFT表示该邮件是草稿，这样就不会被发送。

FLAGGED标记没有定义明确的语义，客户端可以根据自己的需要来使用该标记。

RECENT表示该邮件是最近一段时间的，是上次文件夹打开之后到达的邮件。

SEEN表示该邮件被查看过，当该邮件的内容以某种方式被用户得到后该邮件标记为SEEN，一般情况下调用Message的getInputStream和getContent方法会使得该标识得到设置。

USER是一个特殊的标志，表示文件夹支持用户自定义的标志。

getFlags( )可以得到邮件的标记，该方法返回的是Flags对象，要获得所有的标记，通过Flags对象的getSystemFlags方法获得具体标记的集合，而具体标记是Flags.Flag的对象。

isSet方法用于判断该邮件是否被设置了某个标记，而参数是某个给定的标志。如果邮件被设置了该标记，返回值是true；如果邮件没有被设置该标记，返回值为false。该方法通常用于判断邮件的状态。

setFlag用于设置邮件的状态，共有两个参数。第一个参数是所设置的标识的类型，第二个参数是值，取值为true或者false。

setFlags方法与setFlag方法的作用大致相同，不同之处在于可以同时设置多个标识。

29.5.10  接收邮件的完整代码
接收邮件的完整代码如下：

1. < %@ page  import  = "java.util.*,    
2.   
3.              javax.mail.*,   
4.   
5.          javax.mail.internet.*,   
6.   
7.          javax.naming.*"   
8.   
9. % >   
10.   
11. < %@ page  contentType  =  "text/html;charset = gb2312" % >   
12.   
13. <!doctype html public "-//w3c/dtd HTML 4.0//en" >   
14.   
15. < html >   
16.   
17. < head >   
18.   
19. < title > Mail Sender JSP </ title >   
20.   
21. </ head >   
22.   
23. < body >   
24.   
25. < %   
26.   
27.     try   
28.   
29. {   
30.   
31.         Context  ctx  =  new  InitialContext();   
32.   
33.         //创建上下文环   
34.   
35.         Session  mailsession  = (Session)ctx.lookup("MailSession");   
36.   
37.         //得到邮件会话   
38.   
39.         Store  store  =  mailsession .getStore();   
40.   
41.         //创建存储对象   
42.   
43.         store.connect("218.25.154.4","lixucheng","123456");   
44.   
45.         //连接到邮件服务器   
46.   
47.         Folder  defaultFolder  =  store .getDefaultFolder();   
48.   
49.         //得到默认的文件夹   
50.   
51.         Folder[]  allfolder  =  defaultFolder .list();   
52.   
53.         for(int  i  =  0 ;i < allfolder.length ;i++)   
54.   
55.         {   
56.   
57.             allfolder[i].open(Folder.READ_ONLY);   
58.   
59.             out.println(allfolder[i].getName());   
60.   
61.             out.println("\t"+allfolder[i].getMessageCount());   
62.   
63.             out.println("\t"+allfolder[i].getNewMessageCount());   
64.   
65.             out.println("\t"+allfolder[i].getUnreadMessageCount());   
66.   
67.             out.println(" < br > ");   
68.   
69.             allfolder[i].close(false);   
70.   
71.         }   
72.   
73.          defaultFolder  =  allfolder [0];   
74.   
75.         defaultFolder.open(Folder.READ_ONLY);   
76.   
77.         //打开默认文件夹   
78.   
79.         Message[]  messages  =  defaultFolder .getMessages();   
80.   
81.         //得到邮件信息   
82.   
83.         out.println("邮件的数量："+messages.length);   
84.   
85.         if(messages.length > 0)   
86.   
87.         {   
88.   
89.             out.println(" < table > ");   
90.   
91.             out.println(" < tr > < td > 发送者 </ td > < td > 主题 </ td > < td > 接收时间 </ td > < td > 大小 </ td > < td > 内容 </ td > </ hr > ");   
92.   
93.             for(int  j  =  0 ;j < messages.length ;j++)   
94.   
95.             {   
96.   
97.                 Message  message  =  messages [j];   
98.   
99. out.println(" < tr > < td > "+message.getFrom()[0].toString()+" </ td > ");   
100.   
101. out.println(" < td > "+message.getSubject()+" </ td > ");   
102.   
103. out.println(" < td > "+message.getSentDate().toLocaleString()+" </ td > ");   
104.   
105. out.println(" < td > "+message.getSize()+" </ td > </ tr > ");   
106.   
107. out.println(" < td > "+(String)message.getContent()+" </ td > </ tr > ");   
108.   
109.                        }   
110.   
111.             out.println(" </ table > ");   
112.   
113.         }   
114.   
115.         defaultFolder.close(false);   
116.   
117.         store.close();   
118.   
119.     }catch(Exception e)   
120.   
121.     {   
122.   
123.         out.println(e.toString());   
124.   
125.         e.printStackTrace();   
126.   
127.     }   
128.   
129. % >   
130.   
131. </ body >   
132.   
133. </ html >   

29.6  实验
29.6.1  实验目的
掌握JavaMail API中的主要接口和类，能够实现邮件的发送和接收。

29.6.2  实验内容
编写两个JSP文件，分别用于邮件的发送和接收。

29.6.3  实验过程
（1）先配置邮件会话，把邮件服务器的相关信息配置到邮件会话中。

（2）编写发送邮件的文件。

（3）编写接收邮件的文件。

（4）部署到WebLogic上运行。

转自：http://blog.csdn.net/steven_05514/archive/2008/12/08/3478776.aspx