BlogJava-study-随笔分类-JavaMail

J2EE: 用Javamail发送邮件(转贴)

JAVA之路 — Tue, 19 Sep 2006 05:06:00 GMT

/*
在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。

本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。

此篇仅介绍用javamail实现发送邮件功能，其中涉及smtp认证，邮件附件发送，及HTML内容邮件等。
其它有关多邮箱的实现，接收POP3邮件及IMAP等内容，将在后续文章中介绍。

如下程序需要：javamail，JAF包，j2ee.jar包含了上述两个包，建议大家安装J2SDKEE或直接拷贝j2ee.jar，将其添加到jbuilder的library中，或系统ClassPath中

package com.me.util.mail;

/**
* @author Zhangkun aistill@msn.com
* @version 1.0
*/

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import java.util.Date;
import javax.activation.*;
import java.io.*;
import com.me.util.*;

public class sendMail {

private MimeMessage mimeMsg; //MIME邮件对象

private Session session; //邮件会话对象
private Properties props; //系统属性
private boolean needAuth = false; //smtp是否需要认证

private String username = ""; //smtp认证用户名和密码
private String password = "";

private Multipart mp; //Multipart对象,邮件内容,标题,附件等内容均添加到其中后再生成MimeMessage对象

/**
*
*/
public sendMail() {
setSmtpHost(getConfig.mailHost);//如果没有指定邮件服务器,就从getConfig类中获取
createMimeMessage();
}

public sendMail(String smtp){
setSmtpHost(smtp);
createMimeMessage();
}

/**
* @param hostName String
*/
public void setSmtpHost(String hostName) {
System.out.println("设置系统属性：mail.smtp.host = "+hostName);
if(props == null)props = System.getProperties(); //获得系统属性对象

props.put("mail.smtp.host",hostName); //设置SMTP主机
}

/**
* @return boolean
*/
public boolean createMimeMessage()
{
    try{
      System.out.println("准备获取邮件会话对象！";
      session = Session.getDefaultInstance(props,null);   //获得邮件会话对象
    }
    catch(Exception e){
      System.err.println("获取邮件会话对象时发生错误！"+e);
      return false;
    }

    System.out.println("准备创建MIME邮件对象！";
    try{
      mimeMsg = new MimeMessage(session);                 //创建MIME邮件对象
      mp = new MimeMultipart();

      return true;
    }
    catch(Exception e){
      System.err.println("创建MIME邮件对象失败！"+e);
      return false;
    }
}

/**
* @param need boolean
*/
public void setNeedAuth(boolean need) {
System.out.println("设置smtp身份认证：mail.smtp.auth = "+need);
if(props == null)props = System.getProperties();

    if(need){
      props.put("mail.smtp.auth","true";
    }else{
      props.put("mail.smtp.auth","false";
    }
}

/**
* @param name String
* @param pass String
*/
public void setNamePass(String name,String pass) {
username = name;
password = pass;
}

/**
* @param mailSubject String
* @return boolean
*/
public boolean setSubject(String mailSubject) {
    System.out.println("设置邮件主题！";
    try{
      mimeMsg.setSubject(mailSubject);
      return true;
    }
    catch(Exception e) {
      System.err.println("设置邮件主题发生错误！";
      return false;
    }
}

/**
* @param mailBody String
*/
public boolean setBody(String mailBody) {
    try{
      BodyPart bp = new MimeBodyPart();
      bp.setContent(""+mailBody,"text/html;charset=GB2312";
      mp.addBodyPart(bp);

      return true;
    }
    catch(Exception e){
      System.err.println("设置邮件正文时发生错误！"+e);
      return false;
    }
}

/**
* @param name String
* @param pass String
*/
public boolean addFileAffix(String filename) {

System.out.println("增加邮件附件："+filename);

try{
      BodyPart bp = new MimeBodyPart();
      FileDataSource fileds = new FileDataSource(filename);
      bp.setDataHandler(new DataHandler(fileds));
      bp.setFileName(fileds.getName());

mp.addBodyPart(bp);

      return true;
    }
    catch(Exception e){
      System.err.println("增加邮件附件："+filename+"发生错误！"+e);
      return false;
    }
}

/**
* @param name String
* @param pass String
*/
public boolean setFrom(String from) {
    System.out.println("设置发信人！";
    try{
      mimeMsg.setFrom(new InternetAddress(from));             //设置发信人
      return true;
    }
    catch(Exception e)
    { return false; }
}

/**
* @param name String
* @param pass String
*/
public boolean setTo(String to){
if(to == null)return false;

    try{
      mimeMsg.setRecipients(Message.RecipientType.TO,InternetAddress.parse(to));
      return true;
    }
    catch(Exception e)
    {   return false;   }

}

/**
* @param name String
* @param pass String
*/
public boolean setCopyTo(String copyto)
{
    if(copyto == null)return false;
    try{
      mimeMsg.setRecipients(Message.RecipientType.CC,(Address[])InternetAddress.parse(copyto));
      return true;
    }
    catch(Exception e)
    { return false; }
}

/**
* @param name String
* @param pass String
*/
public boolean sendout()
{
    try{
      mimeMsg.setContent(mp);
      mimeMsg.saveChanges();
      System.out.println("正在发送邮件....";

      Session mailSession = Session.getInstance(props,null);
      Transport transport = mailSession.getTransport("smtp";
      transport.connect((String)props.get("mail.smtp.host",username,password);
      transport.sendMessage(mimeMsg,mimeMsg.getRecipients(Message.RecipientType.TO));
      //transport.send(mimeMsg);

System.out.println("发送邮件成功！";
transport.close();

      return true;
    }
    catch(Exception e)
    {
      System.err.println("邮件发送失败！"+e);
      return false;
    }
}

/**
* Just do it as this
*/
public static void main(String[] args) {

String mailbody = ""+
"

csdn

sendMail themail = new sendMail("smtp.msn.com";
themail.setNeedAuth(true);

    if(themail.setSubject("标题" == false) return;
    if(themail.setBody(mailbody) == false) return;
    if(themail.setTo("gates@msn.com" == false) return;
    if(themail.setFrom("bill@msn.com" == false) return;
    if(themail.addFileAffix("c:\\boot.ini" == false) return;
    themail.setNamePass("user","password";

if(themail.sendout() == false) return;
}
}

JAVA之路 2006-09-19 13:06 发表评论

JavaMail实例详解

JAVA之路 — Tue, 19 Sep 2006 05:03:00 GMT

Java Mail API的开发是SUN为Java开发者提供公用API框架的持续努力的良好例证。提倡公用框架，反对受限于供应商的解决方案，
充分预示着一个日益开放的开发环境的建立。Java Mail API的结构本身证明了它的开发者的基本目标之一
--软件开发的工作量应该取决于应用程序本身的复杂程度以及开发者所要求的控制程度。
换句话说，Java Mail API尽可能地保持简单。乍看起来，Java Mail API所拥有的类总数以及类之间的关系可能让人误解为要花费漫长
的学习时间。实际上，一旦正式开始使用，你就会发现该API不失为在应用程序中加入健壮的邮件/通讯支持的简单工具

该实例是一个发送电子邮件的简单实例，由一个填写邮件内容的HTML页面index.html。和负责发送邮件的JSP页面构成。对于初学者有
很好的借鉴作用,内附有详细的注解

一、index.html

填写邮件信息

二、sendMail.jsp
<%@ page contentType="text/html;charset=GB2312" %>

<%@ page import="java.util.*"%>
<%@ page import="javax.mail.*"%>
<%@ page import="javax.mail.internet.*"%>

发送邮件

<%
try{
//从html表单中获取邮件信息
String tfrom=request.getParameter("from");
String tto=request.getParameter("to");
String ttitle=request.getParameter("title");
String tcontent=request.getParameter("content");

//JavaMail需要Properties来创建一个session对象。它将寻找字符串"mail.smtp.host"，属性值就是发送邮件的主机.
//Properties对象获取诸如邮件服务器、用户名、密码等信息，以及其他可在整个应用程序中共享的信息。

Properties props=new Properties();//也可用Properties props = System.getProperties();
props.put("mail.smtp.host","smtp.21cn.com");//存储发送邮件服务器的信息
props.put("mail.smtp.auth","true");//同时通过验证

//方法二：(如果是在weblogin配置JavaMail：则需指定JNDI名检索
//Context ctx=new InitialContext();
//Session s=(Session)ctx.lookup("MailSession");
//Message msg=new MimeMessage(s);

//这个Session类代表JavaMail 中的一个邮件session. 每一个基于 JavaMail的应用程序至少有一个session但是可以有任意多的session。
//Session类定义全局和每个用户的与邮件相关的属性。这此属性说明了客房机和服务器如何交流信息。

Session s=Session.getInstance(props,null);//根据属性新建一个邮件会话，null参数是一种Authenticator(验证程序) 对象
s.setDebug(true);//设置调试标志,要查看经过邮件服务器邮件命令，可以用该方法

// 一旦创建了自己的Session对象，就是该去创建要发送的消息的时候了。这时就要用到消息类型(MimeMessage是其中一种类型)。
//　Message对象将存储我们实际发送的电子邮件信息，Message对象被作为一个MimeMessage对象来创建并且需要知道应当选择哪一个JavaMail session。
// Message类表示单个邮件消息，它的属性包括类型，地址信息和所定义的目录结构。

Message message=new MimeMessage(s);//由邮件会话新建一个消息对象

//message.setContent("hello","test/plain");//设置消息的内容类型,如果发送的格式有HTML格式就必须设置，
//message.setText("Hello");//发送一般文本格式的消息

//设置邮件,一旦您创建了 Session 和 Message，并将内容填入消息后，就可以用Address确定信件地址了。
//如果想让一个名字出现在电子邮件地址后，也可以将其传递给构造器：
//Address from=new InternetAddress("xmqds@21cn.com","qdison");//发件人的邮件地址

Address from=new InternetAddress(tfrom);//发件人的邮件地址
message.setFrom(from);//设置发件人

Address to=new InternetAddress(tto);//收件人的邮件地址
message.setRecipient(Message.RecipientType.TO,to);//设置收件人,并设置其接收类型为TO,还有3种预定义类型如下：

//Message.RecipientType.TO
//Message.RecipientType.CC
//Message.RecipientType.BCC

message.setSubject(ttitle);//设置主题
message.setText(tcontent);//设置信件内容
message.setSentDate(new Date());//设置发信时间

message.saveChanges();//存储邮件信息

// Transport 是用来发送信息的，
// 用于邮件的收发打操作。
Transport transport=s.getTransport("smtp");
transport.connect("smtp.21cn.com","你的用户名","你的密码");//以smtp方式登录邮箱
transport.sendMessage(message,message.getAllRecipients());//发送邮件,其中第二个参数是所有已设好的收件人地址
transport.close();

发送成功!

再发一封

<%
}catch(MessagingException e){
out.println(e.toString());
}
%>

JAVA之路 2006-09-19 13:03 发表评论

JavaMail API详解

JAVA之路 — Tue, 19 Sep 2006 05:01:00 GMT

JavaMail API详解

版权声明：本文可以自由转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
作者:cleverpig(作者的Blog:http://blog.matrix.org.cn/page/cleverpig)
原文:http://www.matrix.org.cn/resource/article/44/44101_JavaMail.html
关键字:java,mail,pop,smtp

一、JavaMail API简介
JavaMail API是读取、撰写、发送电子信息的可选包。我们可用它来建立如Eudora、Foxmail、MS Outlook Express一般的邮件用户代理程序（Mail User Agent,简称MUA）。而不是像sendmail或者其它的邮件传输代理（Mail Transfer Agent，简称MTA）程序那样可以传送、递送、转发邮件。从另外一个角度来看，我们这些电子邮件用户日常用MUA程序来读写邮件，而MUA依赖着MTA处理邮件的递送。
在清楚了到MUA与MTA之间的关系后，让我们看看JavaMail API是如何提供信息访问功能的吧！JavaMail API被设计用于以不依赖协议的方式去发送和接收电子信息，这个API被分为两大部分：

基本功能：如何以不依赖于协议的方式发送接收电子信息，这也是本文所要描述的，不过在下文中，大家将看到这只是一厢情愿而已。
第二个部分则是依赖特定协议的，比如SMTP、POP、IMAP、NNTP协议。在这部分的JavaMail API是为了和服务器通讯，并不在本文的内容中。

二、相关协议一览
在我们步入JavaMail API之前，先看一下API所涉及的协议。以下便是大家日常所知、所乐于使用的4大信息传输协议：
SMTP
POP
IMAP
MIME
当然，上面的4个协议，并不是全部，还有NNTP和其它一些协议可用于传输信息，但是由于不常用到，所以本文便不提及了。理解这4个基本的协议有助于我们更好的使用JavaMail API。然而JavaMail API是被设计为与协议无关的，目前我们并不能克服这些协议的束缚。确切的说，如果我们使用的功能并不被我们选择的协议支持，那么JavaMail API并不可能如魔术师一样神奇的赋予我们这种能力。

1．SMTP
简单邮件传输协议定义了递送邮件的机制。在下文中，我们将使用基于Java-Mail的程序与公司或者ISP的SMTP服务器进行通讯。这个SMTP服务器将邮件转发到接收者的SMTP服务器，直至最后被接收者通过POP或者IMAP协议获取。这并不需要SMTP服务器使用支持授权的邮件转发，但是却的确要注意SMTP服务器的正确设置（SMTP服务器的设置与JavaMail API无关）。

2．POP
POP是一种邮局协议，目前为第3个版本，即众所周知的POP3。POP定义了一种用户如何获得邮件的机制。它规定了每个用户使用一个单独的邮箱。大多数人在使用POP时所熟悉的功能并非都被支持，例如查看邮箱中的新邮件数量。而这个功能是微软的Outlook内建的，那么就说明微软Outlook之类的邮件客户端软件是通过查询最近收到的邮件来计算新邮件的数量来实现前面所说的功能。因此在我们使用JavaMail API时需要注意，当需要获得如前面所讲的新邮件数量之类的信息时，我们不得不自己进行计算。

3．IMAP
IMAP使用在接收信息的高级协议，目前版本为第4版，所以也被称为IMAP4。需要注意的是在使用IMAP时，邮件服务器必须支持该协议。从这个方面讲，我们并不能完全使用IMAP来替代POP，不能期待IMAP在任何地方都被支持。假如邮件服务器支持IMAP，那么我们的邮件程序将能够具有以下被IMAP所支持的特性：每个用户在服务器上可具有多个目录，这些目录能在多个用户之间共享。
其与POP相比高级之处显而易见，但是在尝试采取IMAP时，我们认识到它并不是十分完美的：由于IMAP需要从其它服务器上接收新信息，将这些信息递送给用户，维护每个用户的多个目录，这都为邮件服务器带来了高负载。并且IMAP与POP的一个不同之处是POP用户在接收邮件时将从邮件服务器上下载邮件，而IMAP允许用户直接访问邮件目录，所以在邮件服务器进行备份作业时，由于每个长期使用此邮件系统的用户所用的邮件目录会占有很大的空间，这将直接导致邮件服务器上磁盘空间暴涨。

4．MIME
MIME并不是用于传送邮件的协议，它作为多用途邮件的扩展定义了邮件内容的格式：信息格式、附件格式等等。一些RFC标准都涉及了MIME：RFC 822, RFC 2045, RFC 2046, RFC 2047，有兴趣的Matrixer可以阅读一下。而作为JavaMail API的开发者，我们并不需关心这些格式定义，但是这些格式被用在了程序中。

5．NNTP和其它的第三方协议
正因为JavaMail API在设计时考虑到与第三方协议实现提供商之间的分离，故我们可以很容易的添加一些第三方协议。SUN维护着一个第三方协议实现提供商的列表：http://java.sun.com/products/javamail/Third_Party.html，通过此列表我们可以找到所需要的而又不被SUN提供支持的第三方协议：比如NNTP这个新闻组协议和S/MIME这个安全的MIME协议。

三、安装
1．安装JavaMail
为了使用JavaMail API，需要从http://java.sun.com/products/javamail/downloads/index.html下载文件名格式为javamail-[version].zip的文件（这个文件中包括了JavaMail实现），并将其中的mail.jar文件添加到CLASSPATH中。这个实现提供了对SMTP、IMAP4、POP3的支持。
注意：在安装JavaMail实现之后，我们将在demo目录中发现许多有趣的简单实例程序。
在安装了JavaMail之后,我们还需要安装JavaBeans Activation Framework，因为这个框架是JavaMail API所需要的。如果我们使用J2EE的话，那么我们并无需单独下载JavaMail，因为它存在于J2EE.jar中，只需将J2EE.jar加入到CLASSPATH即可。

2．安装JavaBeans Activation Framework
从http://java.sun.com/products/javabeans/glasgow/jaf.html下载JavaBeans Activation Framework，并将其添加到CLASSPATH中。此框架增加了对任何数据块的分类、以及对它们的处理的特性。这些特性是JavaMail API需要的。虽然听起来这些特性非常模糊，但是它对于我们的JavaMail API来说只是提供了基本的MIME类型支持。
到此为止，我们应当把mail.jar和activation.jar都添加到了CLASSPATH中。
当然如果从方便的角度讲，直接把这两个Jar文件复制到JRE目录的lib/ext目录中也可以。

四、初次认识JavaMail API
1．了解我们的JavaMail环境
A．纵览JavaMail核心类结构
打开JavaMail.jar文件，我们将发现在javax.mail的包下面存在着一些核心类：Session、Message、Address、Authenticator、Transport、Store、Folder。而且在javax.mail.internet包中还有一些常用的子类。
B．Session
Session类定义了基本的邮件会话。就像Http会话那样，我们进行收发邮件的工作都是基于这个会话的。Session对象利用了java.util.Properties对象获得了邮件服务器、用户名、密码信息和整个应用程序都要使用到的共享信息。
Session类的构造方法是私有的，所以我们可以使用Session类提供的getDefaultInstance()这个静态工厂方法获得一个默认的Session对象：

				
Properties props = new Properties();
// fill props with any information
Session session = Session.getDefaultInstance(props, null);

或者使用getInstance()这个静态工厂方法获得自定义的Session:

				
Properties props = new Properties();
// fill props with any information
Session session = Session.getInstance(props, null);

从上面的两个例子中不难发现，getDefaultInstance()和getInstance()方法的第二个参数都是null，这是因为在上面的例子中并没有使用到邮件授权，下文中将对授权进行详细介绍。
从很多的实例看，在对mail server进行访问的过程中使用共享的Session是足够的，即使是工作在多个用户邮箱的模式下也不例外。

C．Message
当我们建立了Session对象后，便可以被发送的构造信息体了。在这里SUN提供了Message类型来帮助开发者完成这项工作。由于Message是一个抽象类，大多数情况下，我们使用javax.mail.internet.MimeMessage这个子类，该类是使用MIME类型、MIME信息头的邮箱信息。信息头只能使用US-ASCII字符，而非ASCII字符将通过编码转换为ASCII的方式使用。
为了建立一个MimeMessage对象，我们必须将Session对象作为MimeMessage构造方法的参数传入：

				
MimeMessage message = new MimeMessage(session);

注意：对于MimeMessage类来讲存在着多种构造方法，比如使用输入流作为参数的构造方法。

在建立了MimeMessage对象后，我们需要设置它的各个part，对于MimeMessage类来说，这些part就是MimePart接口。最基本的设置信息内容的方法就是通过表示信息内容和米么类型的参数调用setContent()方法：

				
message.setContent("Hello", "text/plain");

然而，如果我们所使用的MimeMessage中信息内容是文本的话，我们便可以直接使用setText()方法来方便的设置文本内容。

				
message.setText("Hello");

前面所讲的两种方法，对于文本信息，后者更为合适。而对于其它的一些信息类型，比如HTML信息，则要使用前者。
别忘记了，使用setSubject()方法对邮件设置邮件主题：

				
message.setSubject("First");

D．Address
到这里，我们已经建立了Session和Message，下面将介绍如何使用邮件地址类：Address。像Message一样，Address类也是一个抽象类，所以我们将使用javax.mail.internet.InternetAddress这个子类。
通过传入代表邮件地址的字符串，我们可以建立一个邮件地址类：

				
Address address = new InternetAddress("president@whitehouse.gov");

如果要在邮件地址后面增加名字的话，可以通过传递两个参数：代表邮件地址和名字的字符串来建立一个具有邮件地址和名字的邮件地址类：

				
Address address = new InternetAddress("president@whitehouse.gov", "George Bush");

本文在这里所讲的邮件地址类是为了设置邮件信息的发信人和收信人而准备的，在建立了邮件地址类后，我们通过message的setFrom()和setReplyTo()两种方法设置邮件的发信人：

				
message.setFrom(address);
message.setReplyTo(address);

若在邮件中存在多个发信人地址，我们可用addForm()方法增加发信人：

				
Address address[] = ...;
message.addFrom(address);

为了设置收信人，我们使用addRecipient()方法增加收信人，此方法需要使用Message.RecipientType的常量来区分收信人的类型：

				
message.addRecipient(type, address)

下面是Message.RecipientType的三个常量:
Message.RecipientType.TO
Message.RecipientType.CC
Message.RecipientType.BCC
因此，如果我们要发送邮件给总统，并发用一个副本给第一夫人的话，下面的方法将被用到：

				
Address toAddress = new InternetAddress("vice.president@whitehouse.gov");
Address ccAddress = new InternetAddress("first.lady@whitehouse.gov");
message.addRecipient(Message.RecipientType.TO, toAddress);
message.addRecipient(Message.RecipientType.CC, ccAddress);

JavaMail API并没有提供检查邮件地址有效性的机制。当然我们可以自己完成这个功能：验证邮件地址的字符是否按照RFC822规定的格式书写或者通过DNS服务器上的MX记录验证等。

E．Authenticator
像java.net类那样，JavaMail API通过使用授权者类（Authenticator）以用户名、密码的方式访问那些受到保护的资源，在这里“资源”就是指邮件服务器。在javax.mail包中可以找到这个JavaMail的授权者类（Authenticator）。
在使用Authenticator这个抽象类时，我们必须采用继承该抽象类的方式，并且该继承类必须具有返回PasswordAuthentication对象（用于存储认证时要用到的用户名、密码）getPasswordAuthentication()方法。并且要在Session中进行注册，使Session能够了解在认证时该使用哪个类。
下面代码片断中的MyAuthenticator就是一个Authenticator的子类。

				
Properties props = new Properties();
// fill props with any information
Authenticator auth = new MyAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

F．Transport
在发送信息时，Transport类将被用到。这个类实现了发送信息的协议（通称为SMTP），此类是一个抽象类，我们可以使用这个类的静态方法send()来发送消息：

				
Transport.send(message);

当然，方法是多样的。我们也可由Session获得相应协议对应的Transport实例。并通过传递用户名、密码、邮件服务器主机名等参数建立与邮件服务器的连接，并使用sendMessage()方法将信息发送，最后关闭连接：

				
message.saveChanges(); // implicit with send()
Transport transport = session.getTransport("smtp");
transport.connect(host, username, password);
transport.sendMessage(message, message.getAllRecipients());
transport.close();

评论：上面的方法是一个很好的方法，尤其是在我们在同一个邮件服务器上发送多个邮件时。因为这时我们将在连接邮件服务器后连续发送邮件，然后再关闭掉连接。send()这个基本的方法是在每次调用时进行与邮件服务器的连接的，对于在同一个邮件服务器上发送多个邮件来讲可谓低效的方式。
注意：如果需要在发送邮件过程中监控mail命令的话，可以在发送前设置debug标志：

				
session.setDebug(true)。

G．Store和Folder
接收邮件和发送邮件很类似都要用到Session。但是在获得Session后，我们需要从Session中获取特定类型的Store，然后连接到Store，这里的Store代表了存储邮件的邮件服务器。在连接Store的过程中，极有可能需要用到用户名、密码或者Authenticator。

				
// Store store = session.getStore("imap");
Store store = session.getStore("pop3");
store.connect(host, username, password);

在连接到Store后，一个Folder对象即目录对象将通过Store的getFolder()方法被返回，我们可从这个Folder中读取邮件信息：

				
Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);
Message message[] = folder.getMessages();

上面的例子首先从Store中获得INBOX这个Folder（对于POP3协议只有一个名为INBOX的Folder有效），然后以只读（Folder.READ_ONLY）的方式打开Folder，最后调用Folder的getMessages()方法得到目录中所有Message的数组。

注意：对于POP3协议只有一个名为INBOX的Folder有效，而对于IMAP协议，我们可以访问多个Folder（想想前面讲的IMAP协议）。而且SUN在设计Folder的getMessages()方法时采取了很智能的方式：首先接收新邮件列表，然后再需要的时候（比如读取邮件内容）才从邮件服务器读取邮件内容。
在读取邮件时，我们可以用Message类的getContent()方法接收邮件或是writeTo()方法将邮件保存，getContent()方法只接收邮件内容（不包含邮件头），而writeTo()方法将包括邮件头。

				
System.out.println(((MimeMessage)message).getContent());

在读取邮件内容后，别忘记了关闭Folder和Store。

				
folder.close(aBoolean);
store.close();

传递给Folder.close()方法的boolean 类型参数表示是否在删除操作邮件后更新Folder。

H．继续向前进！
在讲解了以上的七个Java Mail核心类定义和理解了简单的代码片断后，下文将详细讲解怎样使用这些类实现JavaMail API所要完成的高级功能。

五、使用JavaMail API
在明确了JavaMail API的核心部分如何工作后，本人将带领大家学习一些使用Java Mail API任务案例。
1．发送邮件
在获得了Session后，建立并填入邮件信息，然后发送它到邮件服务器。这便是使用Java Mail API发送邮件的过程，在发送邮件之前，我们需要设置SMTP服务器：通过设置Properties的mail.smtp.host属性。

				
String host = ...;
String from = ...;
String to = ...;

// Get system properties
Properties props = System.getProperties();

// Setup mail server
props.put("mail.smtp.host", host);

// Get session
Session session = Session.getDefaultInstance(props, null);

// Define message
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));
message.setSubject("Hello JavaMail");
message.setText("Welcome to JavaMail");
// Send message
Transport.send(message);

由于建立邮件信息和发送邮件的过程中可能会抛出异常，所以我们需要将上面的代码放入到try-catch结构块中。

2．接收邮件
为了在读取邮件，我们获得了session，并且连接到了邮箱的相应store，打开相应的Folder，然后得到我们想要的邮件，当然别忘记了在结束时关闭连接。

				
String host = ...;
String username = ...;
String password = ...;

// Create empty properties
Properties props = new Properties();

// Get session
Session session = Session.getDefaultInstance(props, null);

// Get the store
Store store = session.getStore("pop3");
store.connect(host, username, password);

// Get folder
Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);

// Get directory
Message message[] = folder.getMessages();

for (int i=0, n=message.length; i   System.out.println(i + ": " + message[i].getFrom()[0] 
     + "\t" + message[i].getSubject());
}

// Close connection 
folder.close(false);
store.close();

上面的代码所作的是从邮箱中读取每个邮件，并且显示邮件的发信人地址和主题。从技术角度讲，这里存在着一个异常的可能：当发信人地址为空时，getFrom()[0]将抛出异常。

下面的代码片断有效的说明了如何读取邮件内容，在显示每个邮件发信人和主题后，将出现用户提示从而得到用户是否读取该邮件的确认，如果输入YES的话，我们可用Message.writeTo(java.io.OutputStream os)方法将邮件内容输出到控制台上，关于Message.writeTo()的具体用法请看JavaMail API。

				
BufferedReader reader = new BufferedReader (
  new InputStreamReader(System.in));

// Get directory
Message message[] = folder.getMessages();
for (int i=0, n=message.length; i  System.out.println(i + ": " + message[i].getFrom()[0] 
    + "\t" + message[i].getSubject());

  System.out.println("Do you want to read message? " +
    "[YES to read/QUIT to end]");
  String line = reader.readLine();
  if ("YES".equals(line)) {
    message[i].writeTo(System.out);
  } else if ("QUIT".equals(line)) {
    break;
  }
}

3．删除邮件和标志
设置与message相关的Flags是删除邮件的常用方法。这些Flags表示了一些系统定义和用户定义的不同状态。在Flags类的内部类Flag中预定义了一些标志：
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
但需要在使用时注意的：标志存在并非意味着这个标志被所有的邮件服务器所支持。例如，对于删除邮件的操作，POP协议不支持上面的任何一个。所以要确定哪些标志是被支持的——通过访问一个已经打开的Folder对象的getPermanetFlags()方法，它将返回当前被支持的Flags类对象。
删除邮件时，我们可以设置邮件的DELETED标志：

				
message.setFlag(Flags.Flag.DELETED, true);

但是首先要采用READ_WRITE的方式打开Folder：

				
folder.open(Folder.READ_WRITE);

在对邮件进行删除操作后关闭Folder时，需要传递一个true作为对删除邮件的擦除确认。

				
folder.close(true);

Folder类中另一种用于删除邮件的方法expunge()也同样可删除邮件，但是它并不为sun提供的POP3实现支持，而其它第三方提供的POP3实现支持或者并不支持这种方法。
另外，介绍一种检查某个标志是否被设置的方法：Message.isSet(Flags.Flag flag)方法，其中参数为被检查的标志。

4．邮件认证
我们在前面已经学会了如何使用Authenticator类来代替直接使用用户名和密码这两字符串作为Session.getDefaultInstance()或者Session.getInstance()方法的参数。在前面的小试牛刀后，现在我们将了解到全面认识一下邮件认证。
我们在此取代了直接使用邮件服务器主机名、用户名、密码这三个字符串作为连接到POP3 Store的方式，使用存储了邮件服务器主机名信息的属性文件，并在获得Session时传入自定义的Authenticator实例：

				
// Setup properties
Properties props = System.getProperties();
props.put("mail.pop3.host", host);

// Setup authentication, get session
Authenticator auth = new PopupAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

// Get the store
Store store = session.getStore("pop3");
store.connect();

PopupAuthenticator类继承了抽象类Authenticator，并且通过重载Authenticator类的getPasswordAuthentication()方法返回PasswordAuthentication类对象。而getPasswordAuthentication()方法的参数param是以逗号分割的用户名、密码组成的字符串。

				
import javax.mail.*;
import java.util.*;

public class PopupAuthenticator extends Authenticator {

  public PasswordAuthentication getPasswordAuthentication(String param) {
    String username, password;

    StringTokenizer st = new StringTokenizer(param, ",");
    username = st.nextToken();
    password = st.nextToken();

    return new PasswordAuthentication(username, password);
  }

}

5．回复邮件
回复邮件的方法很简单：使用Message类的reply()方法，通过配置回复邮件的收件人地址和主题（如果没有提供主题的话，系统将默认将“Re：”作为邮件的主体），这里不需要设置任何的邮件内容，只要复制发信人或者reply-to到新的收件人。而reply()方法中的boolean参数表示是否将邮件回复给发送者（参数值为false），或是恢复给所有人（参数值为true）。
补充一下，reply-to地址需要在发信时使用setReplyTo()方法设置。

				
MimeMessage reply = (MimeMessage)message.reply(false);
reply.setFrom(new InternetAddress("president@whitehouse.gov"));
reply.setText("Thanks");
Transport.send(reply);

6．转发邮件
转发邮件的过程不如前面的回复邮件那样简单，它将建立一个转发邮件，这并非一个方法就能做到。
每个邮件是由多个部分组成，每个部分称为一个邮件体部分，是一个BodyPart类对象，对于MIME类型邮件来讲就是MimeBodyPart类对象。这些邮件体包含在成为Multipart的容器中对于MIME类型邮件来讲就是MimeMultiPart类对象。在转发邮件时，我们建立一个文字邮件体部分和一个被转发的文字邮件体部分，然后将这两个邮件体放到一个Multipart中。说明一下，复制一个邮件内容到另一个邮件的方法是仅复制它的DataHandler（数据处理者）即可。这是由JavaBeans Activation Framework定义的一个类，它提供了对邮件内容的操作命令的访问、管理了邮件内容操作，是不同的数据源和数据格式之间的一致性接口。

				
// Create the message to forward
Message forward = new MimeMessage(session);

// Fill in header
forward.setSubject("Fwd: " + message.getSubject());
forward.setFrom(new InternetAddress(from));
forward.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(
  "Here you go with the original message:\n\n");

// Create a multi-part to combine the parts
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Create and fill part for the forwarded content
messageBodyPart = new MimeBodyPart();
messageBodyPart.setDataHandler(message.getDataHandler());

// Add part to multi part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
forward.setContent(multipart);

// Send message
Transport.send(forward);

7．使用附件
附件作为与邮件相关的资源经常以文本、表格、图片等格式出现，如流行的邮件客户端一样，我们可以用JavaMail API从邮件中获取附件或是发送带有附件的邮件。

A．发送带有附件的邮件
发送带有附件的邮件的过程有些类似转发邮件，我们需要建立一个完整邮件的各个邮件体部分，在第一个部分（即我们的邮件内容文字）后，增加一个具有DataHandler的附件而不是在转发邮件时那样复制第一个部分的DataHandler。

如果我们将文件作为附件发送，那么要建立FileDataSource类型的对象作为附件数据源；如果从URL读取数据作为附件发送，那么将要建立URLDataSource类型的对象作为附件数据源。

然后将这个数据源（FileDataSource或是URLDataSource）对象作为DataHandler类构造方法的参数传入，从而建立一个DataHandler对象作为数据源的DataHandler。

接着将这个DataHandler设置为邮件体部分的DataHandler。这样就完成了邮件体与附件之间的关联工作，下面的工作就是BodyPart的setFileName()方法设置附件名为原文件名。

最后将两个邮件体放入到Multipart中，设置邮件内容为这个容器Multipart，发送邮件。

				
// Define message
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));
message.setSubject("Hello JavaMail Attachment");

// Create the message part 
BodyPart messageBodyPart = new MimeBodyPart();

// Fill the message
messageBodyPart.setText("Pardon Ideas");

Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Part two is attachment
messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);

// Put parts in message
message.setContent(multipart);

// Send the message
Transport.send(message);

如果我们使用servlet实现发送带有附件的邮件，则必须上传附件给servlet，这时需要注意提交页面form中对编码类型的设置应为multipart/form-data。

				
    method=post action="/myservlet">

B．读取邮件中的附件
读取邮件中的附件的过程要比发送它的过程复杂一点。因为带有附件的邮件是多部分组成的，我们必须处理每一个部分获得邮件的内容和附件。
但是如何辨别邮件信息内容和附件呢？Sun在Part类（BodyPart类实现的接口类）中提供了getDisposition()方法让开发者获得邮件体部分的部署类型，当该部分是附件时，其返回之将是Part.ATTACHMENT。但附件也可以没有部署类型的方式存在或者部署类型为Part.INLINE，无论部署类型为Part.ATTACHMENT还是Part.INLINE，我们都能把该邮件体部分导出保存。

				
Multipart mp = (Multipart)message.getContent();

for (int i=0, n=multipart.getCount(); i  Part part = multipart.getBodyPart(i));

  String disposition = part.getDisposition();

  if ((disposition != null) && 
      ((disposition.equals(Part.ATTACHMENT) || 
       (disposition.equals(Part.INLINE))) {
    saveFile(part.getFileName(), part.getInputStream());
  }
}

下列代码中使用了saveFile方法是自定义的方法，它根据附件的文件名建立一个文件，如果本地磁盘上存在名为附件的文件，那么将在文件名后增加数字表示区别。然后从邮件体中读取数据写入到本地文件中（代码省略）。

				
// from saveFile()
File file = new File(filename);
for (int i=0; file.exists(); i++) {
  file = new File(filename+i);
}

以上是邮件体部分被正确设置的简单例子，如果邮件体部分的部署类型为null，那么我们通过获得邮件体部分的MIME类型来判断其类型作相应的处理，代码结构框架如下：

				
if (disposition == null) {
  // Check if plain
  MimeBodyPart mbp = (MimeBodyPart)part;
  if (mbp.isMimeType("text/plain")) {
    // Handle plain
  } else {
    // Special non-attachment cases here of 
    // image/gif, text/html, ...
  }
...
}

8．处理HTML邮件
前面的例子中发送的邮件都是以文本为内容的（除了附件），下面将介绍如何接收和发送基于HTML的邮件。
A．发送HTML邮件
假如我们需要发送一个HTML文件作为邮件内容，并使邮件客户端在读取邮件时获取相关的图片或者文字的话，只要设置邮件内容为html代码，并设置内容类型为text/html即可：

				
String htmlText = "Hello
" + 
  "";
message.setContent(htmlText, "text/html"));

请注意：这里的图片并不是在邮件中内嵌的，而是在URL中定义的。邮件接收者只有在线时才能看到。
在接收邮件时，如果我们使用JavaMail API接收邮件的话是无法实现以HTML方式显示邮件内容的。因为JavaMail API邮件内容视为二进制流。所以要显示HTML内容的邮件，我们必须使用JEditorPane或者第三方HTML展现组件。

以下代码显示了如何使用JEditorPane显示邮件内容：

				
if (message.getContentType().equals("text/html")) {
  String content = (String)message.getContent();
  JFrame frame = new JFrame();
  JEditorPane text = new JEditorPane("text/html", content);
  text.setEditable(false);
  JScrollPane pane = new JScrollPane(text);
  frame.getContentPane().add(pane);
  frame.setSize(300, 300);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.show();
}

B．在邮件中包含图片
如果我们在邮件中使用HTML作为内容，那么最好将HTML中使用的图片作为邮件的一部分，这样无论是否在线都会正确的显示HTML中的图片。处理方法就是将HTML中用到的图片作为邮件附件并使用特殊的cid URL作为图片的引用，这个cid就是对图片附件的Content-ID头的引用。
处理内嵌图片就像向邮件中添加附件一样，不同之处在于我们必须通过设置图片附件所在的邮件体部分的header中Content-ID为一个随机字符串，并在HTML中img的src标记中设置为该字符串。这样就完成了图片附件与HTML的关联。

				
String file = ...;

// Create the message
Message message = new MimeMessage(session);

// Fill its headers
message.setSubject("Embedded Image");
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
String htmlText = "Hello
" + 
  "";
messageBodyPart.setContent(htmlText, "text/html");

// Create a related multi-part to combine the parts
MimeMultipart multipart = new MimeMultipart("related");
multipart.addBodyPart(messageBodyPart);

// Create part for the image
messageBodyPart = new MimeBodyPart();

// Fetch the image and associate to part
DataSource fds = new FileDataSource(file);
messageBodyPart.setDataHandler(new DataHandler(fds));
messageBodyPart.setHeader("Content-ID","");

// Add part to multi-part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
message.setContent(multipart);

9．在邮件中搜索短语
JavaMail API提供了过滤器机制，它被用来建立搜索短语。这个短语由javax.mail.search包中的SearchTerm抽象类来定义，在定义后我们便可以使用Folder的Search()方法在Folder中查找邮件：

				
SearchTerm st = ...;
Message[] msgs = folder.search(st);

下面有22个不同的类（继承了SearchTerm类）供我们使用：
AND terms (class AndTerm)
OR terms (class OrTerm)
NOT terms (class NotTerm)
SENT DATE terms (class SentDateTerm)
CONTENT terms (class BodyTerm)
HEADER terms (FromTerm / FromStringTerm, RecipientTerm / RecipientStringTerm, SubjectTerm, etc.)
使用这些类定义的断语集合，我们可以构造一个逻辑表达式，并在Folder中进行搜索。下面是一个实例：在Folder中搜索邮件主题含有“ADV”字符串或者发信人地址为friend@public.com的邮件。

				
SearchTerm st = 
  new OrTerm(
    new SubjectTerm("ADV:"), 
    new FromStringTerm("friend@public.com"));
Message[] msgs = folder.search(st);

六、参考资源
JavaMail API Home
Sun’s JavaMail API基础
 JavaBeans Activation Framework Home
javamail-interest mailing list
Sun's JavaMail FAQ
jGuru's JavaMail FAQ
Third Party Products List

JAVA之路 2006-09-19 13:01 发表评论

JavaMail类

JAVA之路 — Tue, 19 Sep 2006 04:57:00 GMT

<转>JavaMail的三个主要类：
1、Session类
Session类表示了一个基本的邮件会话过程，它提供了一个邮件的生存过程。Session对象需要java.util.Properties对象对其配置邮件环境属性，它利用Properties对象来获取诸如邮件服务器、用户名、密码等信息，以及其他可在整个应用程序中共享的信息。

2、Message类
在创建了一个邮件会话Session后，再用Message类提供了一封邮件的所有信息。它是一个抽象类，必须由其子类来构造。
MimeMessage message=new MimeMessage(sendsession);
//MimeMessage是Message的子类，可以使用当前的Session对象创建一个新的MimeMessage对象，然后就可以对其进行各种操作。
message.setSubject("This is subject of the e-mail");
//设置邮件的标题
message.setText("Hello,I am a e-mail");
//设置纯文本邮件的内容
InternetAddress sender=new InternetAddress(" cx19830801@163.com ");
//InternetAddress类通过一个合法的e-mail构造出e-mail地址对象
message.setForm(sender);
//设置邮件的发送方地址
InternetAddress receiver=new InternetAddress(" Webmaster@hudax.com ");
message.addRecipient(receiver,RecipientType.TO);
//设置接收方地址
设置接收方地址使用addRecipient方法，地址类型有三种：
RecipientType.TO:e-mail的发送地址；
RecipientType.CC:抄送地址，可以为多个；
RecipientType.BCC:暗送地址，可以为多个。

3、Transport类
邮件发送类。
邮件发送方法：send(message);

e.g
Properties props=new Properties();
Session sendsession = Session.getInstance(props, null);
//使用getInstance方法获取到这个信息
props.put("mail.smtp.host", "smtp.163.com");
//向属性中写入SMTP服务器的地址，为Session设置一个SMTP邮件服务器
props.put("mail.smtp.auth","true");
//用Properties对象的put方法设置了SMTP邮件服务器需要进行权限的认证；
sendsession.setDebug(true);
//用Session对象的setDebug方法设置输出发送邮件时的调试信息；可在Tomcat服务器上看到同SMTP邮件服务器交互过程中的输出信息。
MimeMessage message=new MimeMessage(sendsession);
//MimeMessage是Message的子类，可以使用当前的Session对象创建一个新的MimeMessage对象，然后就可以对其进行各种操作。
message.setFrom(new InternetAddress(request.getParameter("from")));
//设置发信人地址
message.setRecipient(Message.RecipientType.TO,new InternetAddress(request.getParameter("to")));
//设置收信人地址
message.setSubject(new String(request.getParameter("subject").getBytes("ISO8859_1"),"GBK"));
//设置e-mail标题
message.setSentDate(new Date());
//设置e-mail发送时间
message.setText(new String(request.getParameter("text").getBytes("ISO8859_1"),"GBK"));
//设置e-mail内容
message.saveChanges();
//保存对于Email的修改,用message对象的saveChanges方法将邮件信息保存起来；
Transport transport=sendsession.getTransport("smtp");
//由当前的session对象使用方法getTransport创建并初始化Transport对象
transport.connect("smtp.163.com","username","password");
//连接到SMTP服务器
transport.sendMessage(message,message.getAllRecipients());
//发送e-mail
transport.close();
//关闭Transport连接

发送带有附件的邮件：
1、BodyPart类
BodyPart类表示多部分的MIME信息中某一个部分的信息内容，它是一个抽象类，需要用其子类MimeBodyPart创建。
BodyPart messageBodyPart=new MimeBodyPart();
通常邮件的正文是一个BodyPart对象，附件则是另一个BodyPart对象。

2、MultiPart类
MultiPart类表示多部分的MIME信息的内容，它是一个抽象类，需要用其子类MimeMultipart来创建。还可以通过其方法addBodyPart()来创建。
Multipart multipart=new MimeMultipart();
将代表邮件正文的BodyPart对象和代表邮件附件的BodyPart对象分别加入到MimeMultipart对象中。

3、DataSource类
DataSource类表示本地文件和服务器可以直接访问的资源，它是一个抽象类，用其子类FileDataSource来创建。
FileDataSource fds=new FileDataSource("c:/test.doc");

4、DataHandler类
DataHandler为不同的数据源和数据格式提供提供了一个统一的接口。
messageBodyPart.setDataHandler(new DataHandler(fds));
附件被封装到一个DataHandler对象，BodyPart对象可以用方法setDataHandler将封装了附件的DataHandler对象加进来。

发送附件时的处理过程：
BodyPart messageBodyPart=new MimeBodyPart();
Multipart multipart=new MimeMultipart();
multipart.addBodyPart(messageBodyPart);
//在要发送附件时，先建立代表邮件正文的BodyPart对象，并把它加到Multipart对象中去
messageBodyPart=new MimeBodyPart();
//建立代表邮件附件部分的BodyPart对象
DataSource source=new FileDataSource(attachment);
messageBodyPart.setDataHandler(new DataHandler(source));
用setDataHandler方法将获取到的附件包含进来
messageBodyPart.setFileName(attachment);
//设置附件文件名
multipart.addBodyPart(messageBodyPart);
//将与附件相关的内容设置好之后，就可以把代表此附件部分的BodyPart对象加到Multipart对象中去了，最后将Multipart对象放到代表邮件信息的Message对象中，这样就可以发送带有附件的邮件了。

接收邮件：
1、URLName类
URLName类实际上是对于某台邮件服务器上某个用户的一次操作的唯一标识，它的格式为：
协议名称：//用户名：密码@邮件服务器/
URLName irln=new URLName("pop3://username:password@163.com/");

2、Store类
Store类是用于接收邮件的类，它对邮件进行读、写、监视、查找等操作。接收邮件时首先要连接到邮件服务器上的一个邮箱，这需要调用Session对象的getStore方法来创建一个Store对象。
Store store=session.getStore("pop3");
//这个方法要设置Store对象所使用的协议，通常为POP3；
store.connect("pop.163.com","username","password");
//在创建了Store对象之后，可以使用它的connect方法连接到远程邮件服务器中的邮箱。

3、Folder类
在连接到邮箱之后，就可以打开包含邮件的消息文件夹了，打开消息文件夹需要先使用Store对象的getFolder方法创建一个Folder对象作为消息文件夹。
Folder folder=store.getFolder("INBOX");
//参数用来设置消息文件夹的名字，通常设为INBOX，因为POP3协议只支持唯一的消息文件夹INBOX。
使用Folder类的open方法来打开消息文件夹：
folder.open(Folder.READ_ONLY);
它有两种可选模式：READ_ONLY和READ_WRITE
要从消息文件夹中取出邮件，可以使用Folder类的getMessage方法或getMessages方法。
Message message=inbox.getMessage(i);
//方法getMessage返回以其参数为索引的Message对象
Message message[]=folder.getMessages();
//方法getMessages返回一个Message对象数组
int count=folder.getMessageCount();
//使用Folder类的getMessageCount()得到消息文件夹中的邮件总数

4、Message类
与前面的Message类相同，在这里介绍它在显示邮件列表和删除邮件时所使用的一些方法。
(1)、方法getSubject得到一封邮件的标题；
(2)、方法isSet用来判断一封邮件是否被标记为删除(DELETED)、是否用户已经收取过(SEEN)、是否被回复过(ANSWERED)、是否是一个草稿(DRAFT)等等；
(3)、方法setFlag设置一封邮件为待删除。

在接收和检索邮件之后，还要关闭程序使用到的资源，
folder.close(true);
store.cloase();
这两个方法关闭收件箱和到邮件服务器的连接。

显示邮件详细信息的Message类的方法：
1、Address[] getFrom()：得到发件人的地址，返回一个Address类的对象数组；
2、Address[] getRecipients(Message.RecipientType.TO):得到收件人的地址列表；
3、Address[] getSubject():得到邮件标题
4、Address[] getContent():得到普通文本邮件的详细内容；
5、Date getSentDate():得到邮件发送的时间；
6、Date getReceivedDate():得到接受邮件的时间；
7、Boolean isMimeType("text/plain"):判断邮件的MIME(多用途的Internet邮件扩展)类型；
Address类是邮件的地址，它是一个抽象类，可以由其子类InternetAddress来实现。

接收带附件的邮件：
先用Message对象的isMimeType方法判断该邮件是否是一个多部分内容的邮件：
if(message.isMimeType("multipart/*"))
如果是的话，就表明该邮件带有附件，这是可以用Message对象的getContent方法获得代表该邮件的多部分内容的Multipart对象：
Multipart multipart=(Multipart)message.getContent();
然后依次获取Multipart对象的每个部分，并用方法getDisposition获得该部分的属性：
Part p=multipart.getBodypart(i);
String disposition=p.getDisposition();
如果该部分的属性是Part.ATTACHMENT或Part.INLINE，就表明它是附件的内容；如果该部分的属性为null，就表明它是普通文本的内容，在对属性进行判断之后，就可以进行相应的处理了：
if((disposition!=null)&&(disposition.equals(Part.ATTACHMENT)||disposition.equals(Part.INLINE)))
{
........
}
else if(disposition==null)
{
if(p.isMimeType("text/plain"))
{
.....
}
}

下载附件的处理：
先设置附件的类型属性，并生成下载的头信息：
response.setContentType(p.getContentType());
response.setHeader("Content-Disposition","attachment;filename=\""+p.getFileName()+"\"");
然后设置下载过程中的输入流和输出流，为下载附件做好准备工作：
OutputStream os=response.getOutputStream();
InputStream is=p.getInputStream();
最后就可以执行下载的操作了：
int c=is.read();
while(c!=-1)
{
os.write(c);
c=is.read();
}

邮件过滤：
要对邮件进行过滤，需要先查找出所有符合过滤条件的邮件，然后对这些邮件设置待删除标记，最后在关闭消息文件夹时真正删除它们。JavaMail提供了一个包javax.mail.search专门用来查找符合条件的邮件，因此可以这样来实现对邮件的过滤：
建立一个SearchTerm对象，它是一个抽象类，需要用其子类来构造，常用的有以下这些子类，这些字类的构造方法中参数就是过滤的规则，满足这些规则的邮件将被过滤掉。
AndTerm:查找同时满足多个条件的邮件；
OrTerm:只要邮件满足多个条件中的某一个条件，就查找出来；
NotTerm:查找不满足条件的邮件；
SentDateTerm:查找某个特定时间发送出来的邮件；
BodyTerm:查找正文部分的内容符合条件的邮件；
SubjectTerm:查找标题部分内容符合条件的邮件；
FromTerm:如果邮件的发件人地址头满足条件，就查找出来；
FromStringTerm:如果邮件发件人的地址字符串满足条件，就查找出来；
RecipientTerm:如果邮件的收件人地址头满足条件，就查找出来；
RecipientStringTerm:如果邮件收件人的地址字符串满足条件，就查找出来
例如：要设立这样的一个过滤规则，凡是标题中含有“惊喜”的邮件或者是由 webmaster@hudax.com 发送过来的邮件都将被过滤。
SearchTerm st=new OrTerm(new SubjectTerm("惊喜"),new FromStringTerm(" webmaster@hudax.com "));
//建立SearchTerm对象；
Message[] message=folder.search(st);
//设立了过滤规则之后，调用Folder对象的search方法在接收到的邮件中寻找符合过滤条件的邮件；并将它们作为Message的对象数组返回；
message.setflsg(Flags.Flag.DELETED,true);
//将过滤出的所有邮件设置删除标志；

JAVA之路 2006-09-19 12:57 发表评论

发件人地址:
收信人地址:
主题: