程序博客网 > 网络销售只要做些什么

java mail学习笔记4——Message类详解

来源：互联网 发布：网络销售只要做些什么 编辑：程序博客网 时间：2024/06/04 08:39

Message类

在Java Mail 中Message类是所有电子邮件的的超类它的定义如下：
public abstract class javax.mail.Message implements javax.mail.Part

1.标准的Java Mail API中有一个Message的子类：MimeMessage，它可用于电子邮件和Usenet新闻消息。除此之外，其他厂商可以自由扩展Message来满足自身需求。
Message类主要声明了定义大多数消息公共属性的抽象获取和设置方法。这些属性包括
（1）消息地址
（2）消息接收方
（3）消息主题和主体等
可以将这些属性视为包含消息的信封。

2.Message还实现了Part接口。Part接口用于处理消息的主体

创建消息

Message类有三个构造函数可以创建消息：

protected Message();

protected Message(Folder folder,int messageNumber);

protected Message(Session);

其中，第二个方法的参数说明如下：

folder - 包含文件夹
msgnum - 在这个文件夹中消息的序列号

回复消息

如果已经有了一个Message对象，要创建一个新的Message对象，可以使用：
public abstract Message reply(boolean replyAll)throws MessagingException
此方法用加了前缀“Re:”的相同主题和最初消息的发送方地址创建一个新的Message对象。如果参数为true，
消息会寻址到最初消息的所有接收方。消息的内容为空。如果要引用初始消息，就必须自己来完成这个工作。

From地址

下面四个方法用来获得和设置消息的“From”

public abstract Address[] getFrom()                           throws MessagingException
public abstract void setFrom()                      throws MessagingException
public abstract void addFrom(Address[] addresses)                      throws MessagingException
public abstract void addFrom(Address[] addresses)                      throws MessagingException

Reply-to地址

有些消息包含一个Reply-to，指示回复消息应当发送到与发送消息不同的地址。有两个方法可以设置和获得这些地址：

public Address[] getReplyTo()                     throws MessagingException

Get the addresses to which replies should be directed.

public void setReplyTo(Address[] addresses)                throws MessagingException
Set the addresses to which replies should be directed

接收方地址

消息的发送方一般只存在于From：首部中，而消息的接收方却分为To，Cc，Bcc三个字段。在Java Mail中，这三个字段分别是：

Message.RecipientType.TO

Message.RecipientType.CC

Message.RecipientType.BCC


获取Message的接收方地址有两个方法：

public abstract Address[] getRecipients(Message.RecipientType type)                                 throws MessagingException
public Address[] getAllRecipients()                           throws MessagingException

消息主题

主要有两个方法：

public abstract void setSubject(String subject)                         throws MessagingException
public abstract String getSubject()                           throws MessagingException

消息日期

消息还有发送、接收日期：

public abstract Date getSentDate()                          throws MessagingException
public abstract void setSentDate(Date date)                          throws MessagingException
public abstract Date getReceivedDate()                              throws MessagingException



[java] view plain copy
  1. package com.mail;  
  2.   
  3. import java.util.Date;  
  4. import java.util.Properties;  
  5.   
  6. import javax.mail.*;  
  7. import javax.mail.internet.InternetAddress;  
  8.   
  9. public class HeaderClient {  
  10.   
  11.     /** 
  12.      * @param args 
  13.      */  
  14.     public static void main(String[] args) {  
  15.         try {  
  16.             Properties props=new Properties();    
  17.             props.setProperty("mail.transport.protocol", "pop3");    
  18.             props.setProperty("mail.host", "pop3.sina.com");  
  19.             Session session=Session.getDefaultInstance(props,   
  20.                     new Authenticator()    
  21.             {    
  22.   
  23.                 protected PasswordAuthentication getPasswordAuthentication()    
  24.                 {    
  25.                     return new PasswordAuthentication("yananlemon@sina.com","111111");    
  26.                 }    
  27.             }  );  
  28.   
  29.             //连接服务器，并打开文件夹  
  30.              Store store=session.getStore("pop3");    
  31.                 store.connect("pop3.sina.com", "yananlemon@sina.com", "1111111");  
  32.             Folder folder=store.getFolder("INBOX");  
  33.             if(folder==null){  
  34.                 System.out.println("Folder not found!");  
  35.                 System.exit(1);  
  36.             }  
  37.             folder.open(Folder.READ_ONLY);  
  38.             //从服务器获取消息  
  39.             Message[] ms=folder.getMessages();  
  40.             for(int i=0;i<ms.length;i++){  
  41.                 System.out.println("--------------Message"+(i+1)+"---------------");  
  42.                 String from =InternetAddress.toString(ms[i].getFrom());  
  43.                 if(from!=null){  
  44.                     System.out.println("消息来自："+from);  
  45.                 }  
  46.                 String to=InternetAddress.toString(ms[i].getRecipients(Message.RecipientType.TO));  
  47.                 if(to!=null){  
  48.                     System.out.println("消息去往："+to);  
  49.                 }  
  50.                 String replyTo=InternetAddress.toString(ms[i].getReplyTo());  
  51.                 if(replyTo!=null){  
  52.                     System.out.println("消息回复给："+replyTo);  
  53.                 }  
  54.                 String cc=InternetAddress.toString(ms[i].getRecipients(Message.RecipientType.CC));  
  55.                 if(cc!=null){  
  56.                     System.out.println("消息抄送："+cc);  
  57.                 }  
  58.                 Date sent=ms[i].getSentDate();  
  59.                 if(sent!=null){  
  60.                     System.out.println("消息发送时间：："+sent);  
  61.                 }  
  62.                 String subject=ms[i].getSubject();  
  63.                 if(subject!=null){  
  64.                     System.out.println("消息主题："+subject);  
  65.                 }  
  66.                 Date received=ms[i].getReceivedDate();  
  67.                 if(received!=null){  
  68.                     System.out.println("消息接收时间："+received);  
  69.                 }  
  70.                 System.out.println();  
  71.   
  72.             }  
  73.             folder.close(false);  
  74.             store.close();  
  75.         } catch (MessagingException e) {  
  76.             e.printStackTrace();  
  77.         }  
  78.     }  
  79.   
  80. }  

下面是输出：

标志


标志类代表了消息上的标志集合。它是系统标志的预定义的组成，也包括用户自定义的标志。

在Message中与标志有关的方法如下：

public abstract Flags getFlags()                        throws MessagingException
public boolean isSet(Flags.Flag flag)              throws MessagingException
public void setFlag(Flags.Flag flag,                    boolean set)             throws MessagingException
public abstract void setFlags(Flags flag,                              boolean set)                       throws MessagingException
其中，最后两个方法用于设置或取消设置（取决于第二个参数）由第一个参数指示的标志，例如：

[java] view plain copy
  1. ms[i].setFlag(Flags.Flag.DELETED,true)  

上面一行代码会删除消息，这只是标记消息已经删除，它并没有实际从服务器上清除其文件。在消息被清除前，

仍然可以将Flags.Flag.DELETED设回false来完成取消删除。

Flags类包括一个static的Flag字段，该字段预定义了七个常量：

static Flags.FlagANSWERED 
          This message has been answered.static Flags.FlagDELETED 
          This message is marked deleted.static Flags.FlagDRAFT 
          This message is a draft.static Flags.FlagFLAGGED 
          This message is flagged.static Flags.FlagRECENT 
          This message is recent.static Flags.FlagSEEN 
          This message is seen.static Flags.FlagUSER 
          A special flag that indicates that this folder supports user defined flags.


值得注意的是，pop3服务器不会报告标志，只有存储并转发消息的协议（如IMAP协议）才会报告标志。

下面的代码用来显示电子邮件的标志信息：

[java] view plain copy
  1. //测试标志  
  2.                 if(ms[i].isSet(Flags.Flag.DELETED)){  
  3.                     System.out.println("deleted!");  
  4.                 }  
  5.                 if(ms[i].isSet(Flags.Flag.ANSWERED)){  
  6.                     System.out.println("answered!");  
  7.                 }  
  8.                 if(ms[i].isSet(Flags.Flag.DRAFT)){  
  9.                     System.out.println("draft!");  
  10.                 }  
  11.                 if(ms[i].isSet(Flags.Flag.FLAGGED)){  
  12.                     System.out.println("flagged!");  
  13.                 }  
  14.                 if(ms[i].isSet(Flags.Flag.RECENT)){  
  15.                     System.out.println("recent!");  
  16.                 }  
  17.                 if(ms[i].isSet(Flags.Flag.SEEN)){  
  18.                     System.out.println("seen!");  
  19.                 }  
  20.                 if(ms[i].isSet(Flags.Flag.USER)){  
  21.                     //预先不知道用户标志是什么  
  22.                     //所以它们返回字符串数组  
  23.                     String[] userFlags=ms[i].getFlags().getUserFlags();  
  24.                     for(int k=0;i<userFlags.length;k++){  
  25.                         System.out.println("用户标志："+userFlags[i]);                             
  26.                     }  
  27.                 }  

搜索

如果服务器支持搜索（很多IMAP服务器支持，而大多数POP服务器不支持），就很容易在文件夹中搜索满足条件的消息。

Message提供了搜索邮件的接口：

[java] view plain copy
  1. public boolean match(SearchTerm term)  
  2.               throws MessagingException  
它将根据SearchTerm类型的对象来搜索Message，返回值告诉调用者是否搜索到了满足条件的Message。

SearchTerm是一个抽象类，它的常用子类可以分为：

组合搜索相关：
AndTerm类
ComparisonTerm类
NotTerm类
OrTerm类
具体条件相关：
AddressTerm类
FromTerm类
SentDateTerm类等等
下面例子搜索了内容包括了“test”的邮件

[java] view plain copy
  1. import java.util.Date;  
  2. import java.util.Properties;  
  3.   
  4. import javax.mail.internet.InternetAddress;  
  5. import javax.mail.internet.MimeUtility;  
  6. import javax.mail.search.BodyTerm;  
  7. import javax.mail.search.SearchTerm;  
  8. import javax.mail.*;  
  9. public class SearchMailTest {  
  10.   
  11.     /** 
  12.      * @param args 
  13.      */  
  14.     public static void main(String[] args) {  
  15.          try {    
  16.                 Properties props=new Properties();      
  17.                 props.setProperty("mail.transport.protocol", "imap");      
  18.                 props.setProperty("mail.host", "imap.sina.com");    
  19.                 Session session=Session.getDefaultInstance(props,     
  20.                         new Authenticator()      
  21.                 {      
  22.         
  23.                     protected PasswordAuthentication getPasswordAuthentication()      
  24.                     {      
  25.                         return new PasswordAuthentication("yananlemon@sina.com","******");      
  26.                     }      
  27.                 }  );    
  28.         
  29.                 //连接服务器，并打开文件夹    
  30.                  Store store=session.getStore("imap");      
  31.                     store.connect("imap.sina.com", "yananlemon@sina.com", "******");    
  32.                 Folder folder=store.getFolder("INBOX");    
  33.                 if(folder==null){    
  34.                     System.out.println("Folder not found!");    
  35.                     System.exit(1);    
  36.                 }    
  37.                 folder.open(Folder.READ_WRITE);    
  38.                 //从服务器获取消息    
  39.                 SearchTerm search= new BodyTerm("test");  
  40.                 Message[] ms=folder.search(search);  
  41.                 System.out.println("搜索到"+ms.length+"封符合条件的邮件,正在打印.....");  
  42.                 for(int i=0;i<ms.length;i++){    
  43.                     System.out.println("--------------Message"+(i+1)+"---------------");    
  44.                     String from =InternetAddress.toString(ms[i].getFrom());    
  45.                     if(from!=null){    
  46.                         from=MimeUtility.decodeText(from);  
  47.                         System.out.println("消息来自："+from);    
  48.                     }    
  49.                     String to=InternetAddress.toString(ms[i].getRecipients(Message.RecipientType.TO));    
  50.                     if(to!=null){    
  51.                         to=MimeUtility.decodeText(to);  
  52.                         System.out.println("消息去往："+to);    
  53.                     }    
  54.                     String replyTo=InternetAddress.toString(ms[i].getReplyTo());    
  55.                     if(replyTo!=null){   
  56.                         replyTo=MimeUtility.decodeText(replyTo);  
  57.                         System.out.println("消息回复给："+replyTo);    
  58.                     }    
  59.                     String cc=InternetAddress.toString(ms[i].getRecipients(Message.RecipientType.CC));    
  60.                     if(cc!=null){    
  61.                         System.out.println("消息抄送："+cc);    
  62.                     }    
  63.                     Date sent=ms[i].getSentDate();    
  64.                     if(sent!=null){    
  65.                         System.out.println("消息发送时间：："+sent);    
  66.                     }    
  67.                     String subject=ms[i].getSubject();    
  68.                     if(subject!=null){  
  69.                         subject=MimeUtility.decodeText(subject);  
  70.                         System.out.println("消息主题："+subject);    
  71.                     }    
  72.                     Date received=ms[i].getReceivedDate();    
  73.                     if(received!=null){    
  74.                         System.out.println("消息接收时间："+received);    
  75.                     }    
  76.                     System.out.println("消息内容：");  
  77.                     if(ms[i].isMimeType("multipart/*")){  
  78.                         Multipart mp=(Multipart) ms[i].getContent();  
  79.                         int bodyNum=mp.getCount();  
  80.                         for(int k=0;k<bodyNum;k++){  
  81.                             if(mp.getBodyPart(k).isMimeType("text/html")){  
  82.                                 String content=(String) mp.getBodyPart(k).getContent();  
  83.                                 System.out.println(content);  
  84.                             }  
  85.                         }  
  86.                     }else{  
  87.                         System.out.println("不支持的邮件类型！");  
  88.                     }  
  89.         
  90.                 }    
  91.                 folder.close(false);    
  92.                 store.close();    
  93.             } catch (Exception e) {    
  94.                 e.printStackTrace();    
  95.                 System.exit(1);  
  96.             }   
  97.     }  
  98.   
  99. }  

Part接口

Message和BodyPart都实现了Part接口。每个Message都是一个Part，但有些Part可能包含其他部分。Part接口声明了三种方法：

获取和设置部分属性的方法

获取和设置部分首部的方法

获取和设置部分内容的方法

部分属性是类似消息大小或接收日期的内容，其细节未在消息首部中显示指定；与之相反，首部则是包含在部分前面的名-值对；部分

的内容是消息传输的实际数据。

首部

Java mail API 定义了五个部分属性：

size：部分的字节大小

line count：部分的行数

description：部分的简短文本概括说明

desposition：标示部分是否为附件或者是否应当在内部显示

file name:附件的文件名

不是所有部分都有所有属性。例如，不表示附件的部分不可能有filename属性。每个属性都映射到一个获取它的方法，例如：


String getDisposition()                      throws MessagingException
int getSize()            throws MessagingException

int getLineCount()                 throws MessagingException
String getFileName()                   throws MessagingException

String getDescription()                      throws MessagingException




注意：如果部分没有所请求的属性，获取方法就会返回null或者-1。


getDisprsition()方法返回一个字符串，指示内容应当在内部显示，还是作为附件显示。返回值应当是下面三种：

null

Part.INLINE

Part.ATTACHMENT

下面的程序展示了消息首部的控制台输出：


[java] view plain copy
  1. package com.mail;  
  2. import java.util.Properties;  
  3. import javax.mail.*;  
  4. public class MailAttributeTest {  
  5.   
  6.     /** 
  7.      * @param args 
  8.      */  
  9.     public static void main(String[] args) {  
  10.         try {    
  11.             Properties props=new Properties();      
  12.             props.setProperty("mail.transport.protocol", "imap");      
  13.             props.setProperty("mail.host", "imap.sina.com");    
  14.             Session session=Session.getDefaultInstance(props,     
  15.                     new Authenticator()      
  16.             {      
  17.   
  18.                 protected PasswordAuthentication getPasswordAuthentication()      
  19.                 {      
  20.                     return new PasswordAuthentication("yananlemon@sina.com","1111111");      
  21.                 }      
  22.             }  );    
  23.   
  24.             //连接服务器，并打开文件夹    
  25.             Store store=session.getStore("imap");      
  26.             store.connect("imap.sina.com", "yananlemon@sina.com", "1111111");    
  27.             Folder folder=store.getFolder("INBOX");    
  28.             if(folder==null){    
  29.                 System.out.println("Folder not found!");    
  30.                 System.exit(1);    
  31.             }    
  32.             folder.open(Folder.READ_WRITE);    
  33.             //从服务器获取消息    
  34.             Message[] ms=folder.getMessages();  
  35.             for(int i=0;i<ms.length;i++){    
  36.                 System.out.println("-----------下面是Message"+(i+1)+"的属性打印------------");    
  37.                 System.out.println("Message size(byte) is:"+ms[i].getSize());  
  38.                 System.out.println("Message lineCount is:"+ms[i].getLineCount());  
  39.                 System.out.println("Message subject is"+ms[i].getSubject());  
  40.                 String desc=ms[i].getDescription();  
  41.                 if(desc!=null){  
  42.                     System.out.println("Message description is:"+desc);  
  43.                 }  
  44.                 if(ms[i].getContent() instanceof Multipart){  
  45.                     //该方法只是显示了附件的名字，如果消息包含附件的话  
  46.                     processMultipart(ms[i]);  
  47.                 }  
  48.                 System.out.println("-----------Message"+(i+1)+"的属性结束------------");  
  49.             }    
  50.             folder.close(false);    
  51.             store.close();    
  52.         } catch (Exception e) {    
  53.             e.printStackTrace();    
  54.             System.exit(1);  
  55.         }   
  56.     }  
  57.   
  58.     /** 
  59.      * if the message contains attachment 
  60.      * this method will show the name of attachment 
  61.      * @param ms 
  62.      * @throws Exception 
  63.      */  
  64.     private static void processMultipart(Message ms) throws Exception{  
  65.         Multipart multipart=(Multipart) ms.getContent();  
  66.         for(int k=0;k<multipart.getCount();k++){  
  67.             Part part=multipart.getBodyPart(k);  
  68.             String disposition=part.getDisposition();  
  69.             if(disposition==null);  
  70.             if(disposition.equalsIgnoreCase(Part.INLINE)){  
  71.                 System.out.println("This part should be displayed inline");  
  72.             }  
  73.             if(disposition!=null&&disposition.equalsIgnoreCase(Part.ATTACHMENT)){  
  74.                 System.out.println("This part is an attachment");  
  75.                 String fileName=part.getFileName();  
  76.                 if(fileName!=null){  
  77.                     System.out.println("The file name of this attachment is"+fileName);  
  78.                 }  
  79.             }  
  80.   
  81.         }  
  82.     }  
  83.   
  84. }  

下面是运行结果：





内容

每个部分都有可以表现为字节序列的内容。例如，在简单电子邮件消息的部分中，内容是消息的主体。但是在多部分消息中，内容本身

可以包含其他部分。

读取部分内容


Part接口声明了两个可以确定部分的MIME内容类型的方法。

getContentType()

isMimeType(String mimeType)

下面程序，显示了如何处理带有附件的多部分消息：

[java] view plain copy
  1. package com.mail;  
  2. import java.io.BufferedInputStream;  
  3. import java.io.BufferedOutputStream;  
  4. import java.io.File;  
  5. import java.io.FileOutputStream;  
  6. import java.io.InputStream;  
  7. import java.io.OutputStream;  
  8. import java.util.Enumeration;  
  9. import java.util.Properties;  
  10. import javax.mail.*;  
  11. public class AllPartsClient {  
  12.   
  13.     /** 
  14.      * @param args 
  15.      */  
  16.     public static void main(String[] args) {  
  17.          try {    
  18.                 Properties props=new Properties();      
  19.                 props.setProperty("mail.transport.protocol", "imap");      
  20.                 props.setProperty("mail.host", "imap.sina.com");    
  21.                 Session session=Session.getDefaultInstance(props,     
  22.                         new Authenticator()      
  23.                 {      
  24.         
  25.                     protected PasswordAuthentication getPasswordAuthentication()      
  26.                     {      
  27.                         return new PasswordAuthentication("yananlemon@sina.com","111111");      
  28.                     }      
  29.                 }  );    
  30.         
  31.                 //连接服务器，并打开文件夹    
  32.                  Store store=session.getStore("imap");      
  33.                     store.connect("imap.sina.com", "yananlemon@sina.com", "111111");    
  34.                 Folder folder=store.getFolder("INBOX");    
  35.                 if(folder==null){    
  36.                     System.out.println("Folder not found!");    
  37.                     System.exit(1);    
  38.                 }    
  39.                 folder.open(Folder.READ_WRITE);    
  40.                 //从服务器获取消息    
  41.                 Message[] ms=folder.getMessages();  
  42.                 for(int i=0;i<ms.length;i++){  
  43.                     System.out.println("-----------Message"+i+"begin-----------");  
  44.                     //显示消息首部  
  45.                     Enumeration headers=ms[i].getAllHeaders();  
  46.                     while(headers.hasMoreElements()){  
  47.                         Header header=(Header) headers.nextElement();  
  48.                         System.out.println(header.getName()+" : "+header.getValue());  
  49.                     }  
  50.                     System.out.println();  
  51.                     //枚举各个部分  
  52.                     Object obj=ms[i].getContent();  
  53.                     if(obj instanceof Multipart){  
  54.                         processMultipart((Multipart)obj);  
  55.                     }else{  
  56.                         processPart(ms[i]);  
  57.                     }  
  58.                       
  59.                 }  
  60.                 folder.close(false);    
  61.                 store.close();    
  62.             } catch (Exception e) {    
  63.                 e.printStackTrace();    
  64.                 System.exit(1);  
  65.             }   
  66.     }  
  67.   
  68.     private static void processPart(Part part) {  
  69.         try {  
  70.             String fileName=part.getFileName();  
  71.             String disposition=part.getDisposition();  
  72.             String contentType=part.getContentType();  
  73.             if(contentType.toLowerCase().startsWith("multipart/*")){  
  74.                 processMultipart((Multipart)part.getContent());  
  75.             }else if((fileName==null)&&(Part.ATTACHMENT.equalsIgnoreCase(disposition))  
  76.                     ||(!contentType.equalsIgnoreCase("text/plain"))){  
  77.                 if(fileName!=null){  
  78.                     if(fileName.endsWith(".jpg")){                        
  79.                         fileName=File.createTempFile("attachment", ".jpg").getName();                     
  80.                     }else{  
  81.                         fileName=File.createTempFile("attachment", ".txt").getName();  
  82.                     }  
  83.                 }  
  84.                   
  85.             }  
  86.             if(fileName==null){  
  87.                 //可能是内部邮件  
  88.                 part.writeTo(System.out);  
  89.             }else{  
  90.                 File f=new File(fileName);  
  91.                 for(int i=1;f.exists();i++){  
  92.                     String newName=fileName+"_"+i;  
  93.                     f=new File(newName);  
  94.                 }  
  95.                 OutputStream output=new BufferedOutputStream(new FileOutputStream(f));  
  96.                 InputStream input=new BufferedInputStream(part.getInputStream());  
  97.                 int b;  
  98.                 while((b=input.read())!=-1){  
  99.                     output.write(b);  
  100.                 }  
  101.                 output.flush();  
  102.                 output.close();  
  103.                 input.close();  
  104.                 System.out.println("附件"+f.getAbsolutePath()+"成功下载!");  
  105.             }  
  106.         } catch (Exception e) {  
  107.             e.printStackTrace();  
  108.         }  
  109.     }  
  110.   
  111.     private static void processMultipart(Multipart obj) throws MessagingException {  
  112.         for(int i=0;i<obj.getCount();i++){  
  113.             processPart(obj.getBodyPart(i));  
  114.         }  
  115.     }  
  116.   
  117. }  

然后总结下解析邮件的流程：

1.当得到一个Message对象时，调用它的getSubject(),getFrom()等等方法，可以得到邮件的基本信息。

2.调用Messag.getContentType()方法来判断邮件的类型

（1）如果邮件类型是“text/plain”或者“text/html”，说明邮件

是纯文本，可以调用getContent()来获取邮件内容并加以显示。


（2）如果邮件类型是“multipart/*”，表示邮件类型是复合类型，此时需将邮件的getContent()方法返回的对象

转换成Multipart。

3.调用Multipart的getCount()方法来检测Multipart中包含多少BodyPart对象，通过循环取出每个BodyPart对象

在处理每个BodyPart对象时，调用它的getContent()方法确定它的类型，有三种情况：

（1）当其类型是”text/*“表示是纯文本

（2）当其类型是”multipart/*“需要重复2.（2）->3步骤

（3）当其表示图片，音频等二进制内容时，可以调用getInputStream()获取原始的二进制内容。


写入部分内容

setText(String text)

setContent(Object o,String type)

writeTo(OutputStream out)

之前的文章发送电子邮件，只是发送的简单文本而已，这对于现在的电子邮件客户端而言，是非常简单的；在创建复杂邮件之前，先要弄明白一些概念：


1.MimeMessage :继承Message，表示整封邮件

2.MimeBodyPart:表示邮件的一个MIME消息

3.MimeMultipart:表示一个由多个MIME消息组合成的组合MIME消息。

故：

1.复杂邮件和简单文本邮件一样，都是有MimeMesage表示的

2.对于复杂邮件，不能简单的用MimeMessage.setText 方法生成，而是要将MimeMultipart对象设置到MimeMessage对象中

3.MimeMultipart 用来组合一个或者多个MimeBodyPart对象，其中每个MimeBodyPart对象使用MimeMultipart.addBodyPart(BodyPart part)方法

将一个MIME消息添加到MimeMultipart对象中

4.MimeBodyPart 对象表示的MIME消息，可能还是一个MIME组合消息，那么它的内容就需要使用一个MimeMultipart表示，这一步只是重复上述步骤而已。


可见，不管邮件体重的数据层次关系多么复杂，我们都可以用MimeBodyPart和MimeMultipart对象的这种相互嵌套关系，来组织并封装复杂邮件。

下面，是一个示例：

[java] view plain copy
  1. package com.mail;  
  2.   
  3. import java.io.File;  
  4. import java.util.Properties;  
  5. import javax.activation.DataHandler;  
  6. import javax.activation.FileDataSource;  
  7. import javax.mail.Authenticator;  
  8. import javax.mail.Message;  
  9. import javax.mail.Part;  
  10. import javax.mail.PasswordAuthentication;  
  11. import javax.mail.Session;  
  12. import javax.mail.Transport;  
  13. import javax.mail.internet.InternetAddress;  
  14. import javax.mail.internet.MimeBodyPart;  
  15. import javax.mail.internet.MimeMessage;  
  16. import javax.mail.internet.MimeMultipart;  
  17. import javax.mail.internet.MimeMessage.RecipientType;  
  18.   
  19. public class SendMail {  
  20.   
  21.     /** 
  22.      * @param args 
  23.      */  
  24.     public static void main(String[] args) {  
  25.         Properties props=new Properties();  
  26.         props.setProperty("mail.smtp.auth", "true");  
  27.         props.setProperty("mail.transport.protocol", "smtp");  
  28.         props.setProperty("mail.host", "smtp.sina.com");//smtp.sina.com  
  29.         Session session=Session.getInstance(props,   
  30.                 new Authenticator()  
  31.         {  
  32.   
  33.             protected PasswordAuthentication getPasswordAuthentication()  
  34.             {  
  35.                 return new PasswordAuthentication("yananlemon@sina.com","111111");  
  36.             }  
  37.         }  
  38.         );  
  39.         Message msg=new MimeMessage(session);  
  40.         try {  
  41.             String body="在天愿为比翼鸟，在地愿为连理枝。<br/>"+"<img src=\"cid:yanan\">";  
  42.             msg.setFrom(new InternetAddress("yananlemon@sina.com"));  
  43.             msg.setSubject("test");  
  44.             msg.setRecipients(RecipientType.TO, InternetAddress.parse("877581150@qq.com"));//yananzx@yeah.net  
  45.             MimeBodyPart contentPart=(MimeBodyPart) createContent(body,"contentFilePath");;  
  46.             MimeBodyPart part=(MimeBodyPart) createAttachment("attachmentFilePath");  
  47.             MimeMultipart mime=new MimeMultipart("mixed");  
  48.             mime.addBodyPart(contentPart);  
  49.             mime.addBodyPart(part);  
  50.             msg.setContent(mime);  
  51.             Transport.send(msg);  
  52.             System.out.println("success");  
  53.               
  54.         } catch (Exception e) {  
  55.             e.printStackTrace();  
  56.         }  
  57.     }  
  58.     static Part createContent(String content,String fileName){  
  59.         MimeBodyPart contentPart=null;  
  60.         try {  
  61.             contentPart=new MimeBodyPart();  
  62.             MimeMultipart contentMultipart=new MimeMultipart("related");  
  63.             MimeBodyPart htmlPart=new MimeBodyPart();  
  64.             htmlPart.setContent(content, "text/html;charset=gbk");  
  65.             contentMultipart.addBodyPart(htmlPart);  
  66.             MimeBodyPart gifBodyPart=new MimeBodyPart();  
  67.             FileDataSource fds=new FileDataSource(new File(fileName));  
  68.             gifBodyPart.setDataHandler(new DataHandler(fds));  
  69.             gifBodyPart.setFileName(fds.getName());  
  70.             gifBodyPart.setContentID("yanan");  
  71.             contentMultipart.addBodyPart(gifBodyPart);  
  72.             contentPart.setContent(contentMultipart);  
  73.         } catch (Exception e) {  
  74.             e.printStackTrace();  
  75.         }  
  76.         return contentPart;  
  77.           
  78.     }  
  79.     static Part createAttachment(String fileName){  
  80.         Part part=new MimeBodyPart();  
  81.         FileDataSource fds=new FileDataSource(new File(fileName));  
  82.         try {  
  83.             part.setDataHandler(new DataHandler(fds));  
  84.             part.setFileName(fds.getName());  
  85.         } catch (Exception e) {  
  86.             e.printStackTrace();  
  87.         }  
  88.         return part;  
  89.     }  
  90.   
  91.   
  92. }  

0 0
网络销售只要做些什么 网络销售只要做些什么
原创粉丝点击
热门IT博客
mac 麻将游戏mac 麻将游戏
淘宝古着店灵异经过淘宝古着店灵异经过
chrome os软件
网络的利与弊征文1000
网游加速器 for mac
淘宝客服行为规范
淘宝手机电子发票
地球数据化
linux打开vi
支付宝免签约接口源码
酒鬼蔷薇圣斗 知乎
淘宝卖燕窝怎么程序
索尼l36h支持4g网络吗
淘宝助理干什么用的
java通讯协议有哪些
鲱鱼罐头淘宝
全民微信时代知乎
淘宝上的xbox one手柄
淘宝官网首页
网络与新媒体专业介绍
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 洱海介绍 洱海 攻略 苍山洱海经典句子 大理洱海图片 洱海一圈多少公里 大理古城到洱海 大理洱海一日游路线图 大理古城洱海 洱海在哪里个城市 环洱海开车路线图 环洱海多少公里 洱海公园有必要去吗 洱海艺术酒店 洱海在什么地方 洱海包车一日游多少钱 昆明到洱海怎么走 洱海旅游攻略自驾游攻 昆明到洱海多远 洱海有什么好玩的 洱海公园门票 洱海图片风景图片 洱海是海还是湖 苍山洱海在哪 洱海环海路线 洱海是什么意思 洱海旅游费用 洱海哪里好玩 洱海旅游住宿 云南洱海在哪里 洱海门票价格 云南大理洱海住宿 洱海旅游报价 双廊洱海旅游攻略 大理洱海门票 洱海自助旅游攻略 大理洱海大游船 云南丽江洱海 云南大理洱海旅游攻略 大理到洱海多少公里 洱海要门票吗 洱海旅游价格

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里