java 邮件

  　　使用java语言实现邮件的简单的发送和接受。

说明：使用Java应用程序发送E-mail比较简单，在使用下列程序之前，你需要将mail.jar和activation.jar 添加到你的CLASSPATH中。

1、这是一个简单的发送邮件的java程序，它可以向任何邮箱发送邮件，在使用过程中一定要注意，自己使用的发送邮件的邮箱需要开通SMTP服务，一般邮箱默认是不开通的。

（注意这个程序暂时还不能使用qq邮箱发送邮件，网上查阅说是因为qq邮箱使用了ssl加密）

  /**
      * java 发送邮件
      * 2016/5/19
      */
 package cn.mail;
 import java.util.Properties;
 import javax.mail.Message;
 import javax.mail.Session;
 import javax.mail.Transport;
 import javax.mail.internet.InternetAddress;
 import javax.mail.internet.MimeMessage;
 public class mail_163 {

     public static void main(String[] args) throws Exception {

         Properties prop = new Properties();
         prop.setProperty("mail.host", "smtp.sina.com");
         prop.setProperty("mail.transport.protocol", "smtp");
         prop.setProperty("mail.smtp.auth", "true");
         //使用JavaMail发送邮件的5个步骤
         //1、创建session
         Session session = Session.getInstance(prop);
         //开启Session的debug模式，这样就可以查看到程序发送Email的运行状态
         session.setDebug(true);
         //2、通过session得到transport对象
         Transport ts = session.getTransport();
         //3、使用邮箱的用户名和密码连上邮件服务器，发送邮件时，发件人需要提交邮箱的用户名和密码给smtp服务器，用户名和密码都通过验证之后才能够正常发送邮件给收件人。
         ts.connect("smtp.sina.com",25, "lvbiao_1995@sina.com", "1234567");
         //4、创建邮件
         Message message = createSimpleMail(session);
         //5、发送邮件
         ts.sendMessage(message, message.getAllRecipients());
         System.out.println("发送成功");
         ts.close();
     }
     //设置邮件内容
     public static MimeMessage createSimpleMail(Session session)
             throws Exception {
         //创建邮件对象
         MimeMessage message = new MimeMessage(session);
         //指明邮件的发件人
         message.setFrom(new InternetAddress("lvbiao_1995@sina.com"));
         //指明邮件的收件人，现在发件人和收件人是一样的，那就是自己给自己发
         message.setRecipient(Message.RecipientType.TO, new InternetAddress("lvbiao_1995@163.com"));
         //邮件的标题
         message.setSubject("snail发送 这是标题");
         //邮件的文本内容
         message.setContent("你好啊！这是我用java给qq邮箱发送的邮件，请您不用回复，这是文本内容", "text/html;charset=UTF-8");
         //返回创建好的邮件对象
         return message;
     }
 }

2、邮件发送改进版，可以使用qq邮箱发送，qq邮箱开启了ssl加密，必须在程序中使用qq邮箱自己生成的密码，而且要开启ssl加密。

下面这段代码开启了ssl加密

 //如果使用qq邮箱，需要加上下列代码，因为qq邮箱使用了ssl加密，下面代码是用来开启ssl加密的，而且密码也必须是qq邮箱生成的安全密码
         MailSSLSocketFactory sf = new MailSSLSocketFactory();
         sf.setTrustAllHosts(true);
         prop.put("mail.smtp.ssl.enable", "true");
         prop.put("mail.smtp.ssl.socketFactory", sf);

其他的代码和1是一样的，只需要改动密码部分。

3、使用qq邮箱同时给多人发送邮件

  /**
      * java 发送邮件  同时给多人发送邮件
      * 2016/5/19
      */
 package cn.mail;
 import java.util.Properties;

 import javax.mail.Address;
 import javax.mail.Message;
 import javax.mail.MessagingException;
 import javax.mail.Session;
 import javax.mail.Transport;
 import javax.mail.internet.InternetAddress;
 import javax.mail.internet.MimeMessage;

 import com.sun.mail.util.MailSSLSocketFactory;
 public class mail_qq_m {

     public static void main(String[] args) throws Exception {

         Properties prop = new Properties();
         prop.setProperty("mail.host", "smtp.sina.com");
         prop.setProperty("mail.transport.protocol", "smtp");
         prop.setProperty("mail.smtp.auth", "true");
         //如果使用qq邮箱，需要加上下列代码，因为qq邮箱使用了ssl加密，下面代码是用来开启ssl加密的，而且密码也必须是qq邮箱生成的安全密码
         MailSSLSocketFactory sf = new MailSSLSocketFactory();
         sf.setTrustAllHosts(true);
         prop.put("mail.smtp.ssl.enable", "true");
         prop.put("mail.smtp.ssl.socketFactory", sf);

         //使用JavaMail发送邮件的5个步骤
         //1、创建session
         Session session = Session.getInstance(prop);
         //开启Session的debug模式，这样就可以查看到程序发送Email的运行状态
         session.setDebug(true);
         //2、通过session得到transport对象
         Transport ts = session.getTransport();
         //3、使用邮箱的用户名和密码连上邮件服务器，发送邮件时，发件人需要提交邮箱的用户名和密码给smtp服务器，用户名和密码都通过验证之后才能够正常发送邮件给收件人。
         ts.connect("smtp.qq.com",465, "1396799517@qq.com", "12345");
         //4、创建邮件
         Message message = createSimpleMail(session);
         //5、发送邮件
         ts.sendMessage(message, message.getAllRecipients());
         System.out.println("发送成功");
         ts.close();
     }
     //设置邮件内容
     public static MimeMessage createSimpleMail(Session session)
             throws Exception {
         //创建邮件对象
         MimeMessage message = new MimeMessage(session);
         //指明邮件的发件人
         message.setFrom(new InternetAddress("1396799517@qq.com"));
         //指明邮件的收件人，同时给多人发送
         String to[] = {"lvbiao_1995@sina.com","lvbiao_1995@163.com","lvbiao_1995@qq.com"};
         String toList = getMailList(to);
         InternetAddress[] iaToList = new InternetAddress().parse(toList);
         message.setRecipients(Message.RecipientType.TO,iaToList); 

         //邮件的标题
         message.setSubject("snail发送 这是标题");
         //邮件的文本内容
         message.setContent("你好啊！这是我用java给qq邮箱发送的邮件，请您不用回复，这是文本内容,同时给多人发送的邮件～～～", "text/html;charset=UTF-8");
         //返回创建好的邮件对象
         return message;
     }
     //给多人发送邮件
     private static String getMailList(String[] mailArray){  

         StringBuffer toList = new StringBuffer();
     int length = mailArray.length;
         if(mailArray!=null && length <2){
              toList.append(mailArray[0]);
         }else{
              for(int i=0;i<length;i++){
                      toList.append(mailArray[i]);
                      if(i!=(length-1)){
                          toList.append(",");
                      }  

              }
          }
      return toList.toString();  

 }
 }

4、使用POP3协议收取邮件

 package cn.mail;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Properties;

 import javax.mail.Address;
 import javax.mail.BodyPart;
 import javax.mail.Flags;
 import javax.mail.Folder;
 import javax.mail.Message;
 import javax.mail.MessagingException;
 import javax.mail.Multipart;
 import javax.mail.Part;
 import javax.mail.Session;
 import javax.mail.Store;
 import javax.mail.internet.InternetAddress;
 import javax.mail.internet.MimeMessage;
 import javax.mail.internet.MimeMultipart;
 import javax.mail.internet.MimeUtility;

 import com.sun.mail.util.MailSSLSocketFactory;

 /**
  * 使用POP3协议接收邮件
  */
 public class POP3mail {

     public static void main(String[] args) throws Exception {
         receive();
     }

     /**
      * 接收邮件
      */
     public static void receive() throws Exception {
         // 准备连接服务器的会话信息
         Properties props = new Properties();
         props.setProperty("mail.store.protocol", "pop3");        // 协议
         props.setProperty("mail.pop3.port", "995");                // 端口
         props.setProperty("mail.pop3.host", "pop.qq.com");    // pop3服务器
         //如果使用qq邮箱，需要加上下列代码，因为qq邮箱使用了ssl加密，下面代码是用来开启ssl加密的，而且密码也必须是qq邮箱生成的安全密码
         MailSSLSocketFactory sf = new MailSSLSocketFactory();
         sf.setTrustAllHosts(true);
         props.put("mail.pop3.ssl.enable", "true");
         props.put("mail.pop3.ssl.socketFactory", sf);

         // 创建Session实例对象
         Session session = Session.getInstance(props);
         session.setDebug(true);
         Store store = session.getStore("pop3");
         store.connect("1396799517@qq.com", "12345");

         // 获得收件箱
         Folder folder = store.getFolder("INBOX");
         /* Folder.READ_ONLY：只读权限
          * Folder.READ_WRITE：可读可写（可以修改邮件的状态）
          */
         folder.open(Folder.READ_WRITE);    //打开收件箱

         // 由于POP3协议无法获知邮件的状态,所以getUnreadMessageCount得到的是收件箱的邮件总数
         System.out.println("未读邮件数: " + folder.getUnreadMessageCount());

         // 由于POP3协议无法获知邮件的状态,所以下面得到的结果始终都是为0
         System.out.println("删除邮件数: " + folder.getDeletedMessageCount());
         System.out.println("新邮件: " + folder.getNewMessageCount());

         // 获得收件箱中的邮件总数
         System.out.println("邮件总数: " + folder.getMessageCount());

         // 得到收件箱中的所有邮件,并解析
         Message[] messages = folder.getMessages();
         parseMessage(messages);

         //释放资源
         folder.close(true);
         store.close();
     }

     /**
      * 解析邮件
      * @param messages 要解析的邮件列表
      */
     public static void parseMessage(Message... messages) throws MessagingException, IOException {
         if (messages == null || messages.length < 1)
             throw new MessagingException("未找到要解析的邮件!");

         // 解析所有邮件
         for (int i = 0, count = messages.length; i < count; i++) {
             MimeMessage msg = (MimeMessage) messages[i];
             System.out.println("------------------解析第" + msg.getMessageNumber() + "封邮件-------------------- ");
             System.out.println("主题: " + getSubject(msg));
             System.out.println("发件人: " + getFrom(msg));
             System.out.println("收件人：" + getReceiveAddress(msg, null));
             System.out.println("发送时间：" + getSentDate(msg, null));
             System.out.println("是否已读：" + isSeen(msg));
             System.out.println("邮件优先级：" + getPriority(msg));
             System.out.println("是否需要回执：" + isReplySign(msg));
             System.out.println("邮件大小：" + msg.getSize() * 1024 + "kb");
             boolean isContainerAttachment = isContainAttachment(msg);
             System.out.println("是否包含附件：" + isContainerAttachment);
             if (isContainerAttachment) {
                 saveAttachment(msg, "/home/lvbiao/java/mail"+msg.getSubject() + "_"); //保存附件
             }
             StringBuffer content = new StringBuffer(30);
             getMailTextContent(msg, content);
             System.out.println("邮件正文：" + (content.length() > 100 ? content.substring(0,100) + "..." : content));
             System.out.println("------------------第" + msg.getMessageNumber() + "封邮件解析结束-------------------- ");
             System.out.println();
         }
     }

     /**
      * 获得邮件主题
      * @param msg 邮件内容
      * @return 解码后的邮件主题
      */
     public static String getSubject(MimeMessage msg) throws UnsupportedEncodingException, MessagingException {
         return MimeUtility.decodeText(msg.getSubject());
     }

     /**
      * 获得邮件发件人
      * @param msg 邮件内容
      * @return 姓名 <Email地址>
      * @throws MessagingException
      * @throws UnsupportedEncodingException
      */
     public static String getFrom(MimeMessage msg) throws MessagingException, UnsupportedEncodingException {
         String from = "";
         Address[] froms = msg.getFrom();
         if (froms.length < 1)
             throw new MessagingException("没有发件人!");

         InternetAddress address = (InternetAddress) froms[0];
         String person = address.getPersonal();
         if (person != null) {
             person = MimeUtility.decodeText(person) + " ";
         } else {
             person = "";
         }
         from = person + "<" + address.getAddress() + ">";

         return from;
     }

     /**
      * 根据收件人类型，获取邮件收件人、抄送和密送地址。如果收件人类型为空，则获得所有的收件人
      * <p>Message.RecipientType.TO  收件人</p>
      * <p>Message.RecipientType.CC  抄送</p>
      * <p>Message.RecipientType.BCC 密送</p>
      * @param msg 邮件内容
      * @param type 收件人类型
      * @return 收件人1 <邮件地址1>, 收件人2 <邮件地址2>, ...
      * @throws MessagingException
      */
     public static String getReceiveAddress(MimeMessage msg, Message.RecipientType type) throws MessagingException {
         StringBuffer receiveAddress = new StringBuffer();
         Address[] addresss = null;
         if (type == null) {
             addresss = msg.getAllRecipients();
         } else {
             addresss = msg.getRecipients(type);
         }

         if (addresss == null || addresss.length < 1)
             throw new MessagingException("没有收件人!");
         for (Address address : addresss) {
             InternetAddress internetAddress = (InternetAddress)address;
             receiveAddress.append(internetAddress.toUnicodeString()).append(",");
         }

         receiveAddress.deleteCharAt(receiveAddress.length()-1);    //删除最后一个逗号

         return receiveAddress.toString();
     }

     /**
      * 获得邮件发送时间
      * @param msg 邮件内容
      * @return yyyy年mm月dd日 星期X HH:mm
      * @throws MessagingException
      */
     public static String getSentDate(MimeMessage msg, String pattern) throws MessagingException {
         Date receivedDate = msg.getSentDate();
         if (receivedDate == null)
             return "";

         if (pattern == null || "".equals(pattern))
             pattern = "yyyy年MM月dd日 E HH:mm ";

         return new SimpleDateFormat(pattern).format(receivedDate);
     }

     /**
      * 判断邮件中是否包含附件
      * @param msg 邮件内容
      * @return 邮件中存在附件返回true，不存在返回false
      * @throws MessagingException
      * @throws IOException
      */
     public static boolean isContainAttachment(Part part) throws MessagingException, IOException {
         boolean flag = false;
         if (part.isMimeType("multipart/*")) {
             MimeMultipart multipart = (MimeMultipart) part.getContent();
             int partCount = multipart.getCount();
             for (int i = 0; i < partCount; i++) {
                 BodyPart bodyPart = multipart.getBodyPart(i);
                 String disp = bodyPart.getDisposition();
                 if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {
                     flag = true;
                 } else if (bodyPart.isMimeType("multipart/*")) {
                     flag = isContainAttachment(bodyPart);
                 } else {
                     String contentType = bodyPart.getContentType();
                     if (contentType.indexOf("application") != -1) {
                         flag = true;
                     }  

                     if (contentType.indexOf("name") != -1) {
                         flag = true;
                     }
                 }

                 if (flag) break;
             }
         } else if (part.isMimeType("message/rfc822")) {
             flag = isContainAttachment((Part)part.getContent());
         }
         return flag;
     }

     /**
      * 判断邮件是否已读
      * @param msg 邮件内容
      * @return 如果邮件已读返回true,否则返回false
      * @throws MessagingException
      */
     public static boolean isSeen(MimeMessage msg) throws MessagingException {
         return msg.getFlags().contains(Flags.Flag.SEEN);
     }

     /**
      * 判断邮件是否需要阅读回执
      * @param msg 邮件内容
      * @return 需要回执返回true,否则返回false
      * @throws MessagingException
      */
     public static boolean isReplySign(MimeMessage msg) throws MessagingException {
         boolean replySign = false;
         String[] headers = msg.getHeader("Disposition-Notification-To");
         if (headers != null)
             replySign = true;
         return replySign;
     }

     /**
      * 获得邮件的优先级
      * @param msg 邮件内容
      * @return 1(High):紧急  3:普通(Normal)  5:低(Low)
      * @throws MessagingException
      */
     public static String getPriority(MimeMessage msg) throws MessagingException {
         String priority = "普通";
         String[] headers = msg.getHeader("X-Priority");
         if (headers != null) {
             String headerPriority = headers[0];
             if (headerPriority.indexOf("1") != -1 || headerPriority.indexOf("High") != -1)
                 priority = "紧急";
             else if (headerPriority.indexOf("5") != -1 || headerPriority.indexOf("Low") != -1)
                 priority = "低";
             else
                 priority = "普通";
         }
         return priority;
     } 

     /**
      * 获得邮件文本内容
      * @param part 邮件体
      * @param content 存储邮件文本内容的字符串
      * @throws MessagingException
      * @throws IOException
      */
     public static void getMailTextContent(Part part, StringBuffer content) throws MessagingException, IOException {
         //如果是文本类型的附件，通过getContent方法可以取到文本内容，但这不是我们需要的结果，所以在这里要做判断
         boolean isContainTextAttach = part.getContentType().indexOf("name") > 0;
         if (part.isMimeType("text/*") && !isContainTextAttach) {
             content.append(part.getContent().toString());
         } else if (part.isMimeType("message/rfc822")) {
             getMailTextContent((Part)part.getContent(),content);
         } else if (part.isMimeType("multipart/*")) {
             Multipart multipart = (Multipart) part.getContent();
             int partCount = multipart.getCount();
             for (int i = 0; i < partCount; i++) {
                 BodyPart bodyPart = multipart.getBodyPart(i);
                 getMailTextContent(bodyPart,content);
             }
         }
     }

     /**
      * 保存附件
      * @param part 邮件中多个组合体中的其中一个组合体
      * @param destDir  附件保存目录
      * @throws UnsupportedEncodingException
      * @throws MessagingException
      * @throws FileNotFoundException
      * @throws IOException
      */
     public static void saveAttachment(Part part, String destDir) throws UnsupportedEncodingException, MessagingException,
             FileNotFoundException, IOException {
         if (part.isMimeType("multipart/*")) {
             Multipart multipart = (Multipart) part.getContent();    //复杂体邮件
             //复杂体邮件包含多个邮件体
             int partCount = multipart.getCount();
             for (int i = 0; i < partCount; i++) {
                 //获得复杂体邮件中其中一个邮件体
                 BodyPart bodyPart = multipart.getBodyPart(i);
                 //某一个邮件体也有可能是由多个邮件体组成的复杂体
                 String disp = bodyPart.getDisposition();
                 if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {
                     InputStream is = bodyPart.getInputStream();
                     saveFile(is, destDir, decodeText(bodyPart.getFileName()));
                 } else if (bodyPart.isMimeType("multipart/*")) {
                     saveAttachment(bodyPart,destDir);
                 } else {
                     String contentType = bodyPart.getContentType();
                     if (contentType.indexOf("name") != -1 || contentType.indexOf("application") != -1) {
                         saveFile(bodyPart.getInputStream(), destDir, decodeText(bodyPart.getFileName()));
                     }
                 }
             }
         } else if (part.isMimeType("message/rfc822")) {
             saveAttachment((Part) part.getContent(),destDir);
         }
     }

     /**
      * 读取输入流中的数据保存至指定目录
      * @param is 输入流
      * @param fileName 文件名
      * @param destDir 文件存储目录
      * @throws FileNotFoundException
      * @throws IOException
      */
     private static void saveFile(InputStream is, String destDir, String fileName)
             throws FileNotFoundException, IOException {
         BufferedInputStream bis = new BufferedInputStream(is);
         BufferedOutputStream bos = new BufferedOutputStream(
                 new FileOutputStream(new File(destDir + fileName)));
         int len = -1;
         while ((len = bis.read()) != -1) {
             bos.write(len);
             bos.flush();
         }
         bos.close();
         bis.close();
     }

     /**
      * 文本解码
      * @param encodeText 解码MimeUtility.encodeText(String text)方法编码后的文本
      * @return 解码后的文本
      * @throws UnsupportedEncodingException
      */
     public static String decodeText(String encodeText) throws UnsupportedEncodingException {
         if (encodeText == null || "".equals(encodeText)) {
             return "";
         } else {
             return MimeUtility.decodeText(encodeText);
         }
     }
 }

5、使用IMAP协议收取邮件

 package cn.mail;

 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.util.Properties;

 import javax.mail.Flags.Flag;
 import javax.mail.Folder;
 import javax.mail.Message;
 import javax.mail.Session;
 import javax.mail.Store;
 import javax.mail.internet.MimeUtility;

 import com.sun.mail.imap.IMAPMessage;
 import com.sun.mail.util.MailSSLSocketFactory;

 /**
  * <b>使用IMAP协议接收邮件</b><br/>
  * <p>POP3和IMAP协议的区别:</p>
  * <b>POP3</b>协议允许电子邮件客户端下载服务器上的邮件,但是在客户端的操作(如移动邮件、标记已读等)，不会反馈到服务器上，<br/>
  * 比如通过客户端收取了邮箱中的3封邮件并移动到其它文件夹，邮箱服务器上的这些邮件是没有同时被移动的。<br/>
  * <p><b>IMAP</b>协议提供webmail与电子邮件客户端之间的双向通信，客户端的操作都会同步反应到服务器上，对邮件进行的操作，服务
  * 上的邮件也会做相应的动作。比如在客户端收取了邮箱中的3封邮件，并将其中一封标记为已读，将另外两封标记为删除，这些操作会
  * 即时反馈到服务器上。</p>
  * <p>两种协议相比，IMAP 整体上为用户带来更为便捷和可靠的体验。POP3更易丢失邮件或多次下载相同的邮件，但IMAP通过邮件客户端
  * 与webmail之间的双向同步功能很好地避免了这些问题。</p>
  */
 public class IMAPmail {

     public static void main(String[] args) throws Exception {
         // 准备连接服务器的会话信息
         Properties props = new Properties();
         props.setProperty("mail.store.protocol", "imap");
         props.setProperty("mail.imap.host", "imap.qq.com");
         props.setProperty("mail.imap.port", "993");
       //如果使用qq邮箱，需要加上下列代码，因为qq邮箱使用了ssl加密，下面代码是用来开启ssl加密的，而且密码也必须是qq邮箱生成的安全密码
         MailSSLSocketFactory sf = new MailSSLSocketFactory();
         sf.setTrustAllHosts(true);
         props.put("mail.imap.ssl.enable", "true");
         props.put("mail.imap.ssl.socketFactory", sf);

         // 创建Session实例对象
         Session session = Session.getInstance(props);

         //开启session的debug模式，这样就可以查看到程序发送Email的运行状态
         session.setDebug(true);

         // 创建IMAP协议的Store对象
         Store store = session.getStore("imap");

         // 连接邮件服务器
         store.connect(null,"1396799517@qq.com", "123456");

         // 获得收件箱
         Folder folder = store.getFolder("INBOX");
         // 以读写模式打开收件箱
         folder.open(Folder.READ_WRITE);

         // 获得收件箱的邮件列表
         Message[] messages = folder.getMessages();

         // 打印不同状态的邮件数量
         System.out.println("收件箱中共" + messages.length + "封邮件!");
         System.out.println("收件箱中共" + folder.getUnreadMessageCount() + "封未读邮件!");
         System.out.println("收件箱中共" + folder.getNewMessageCount() + "封新邮件!");
         System.out.println("收件箱中共" + folder.getDeletedMessageCount() + "封已删除邮件!");

         System.out.println("------------------------开始解析邮件----------------------------------");

         // 解析邮件
         for (Message message : messages) {
             IMAPMessage msg = (IMAPMessage) message;
             String subject = MimeUtility.decodeText(msg.getSubject());
             System.out.println("[" + subject + "]未读，是否需要阅读此邮件（yes/no）？");
             BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
             String answer = reader.readLine();
             if ("yes".equalsIgnoreCase(answer)) {
                 POP3mail.parseMessage(msg);    // 解析邮件，使用的是POP3中的解析函数。
                 // 第二个参数如果设置为true，则将修改反馈给服务器。false则不反馈给服务器
                 msg.setFlag(Flag.SEEN, true);    //设置已读标志
             }
         }
         System.out.println("------------------------邮件解析结束----------------------------------");
         // 关闭资源
         folder.close(false);
         store.close();
     }
 }

6、发送带有附件的邮件

　　要发送带有附件的邮件，只需要在发送邮件的内容中加上下面的语句。

 // 向multipart对象中添加邮件的各个部分内容，包括文本内容和附件
     Multipart multipart = new MimeMultipart();
     // 添加邮件正文
     MimeBodyPart contentPart = new MimeBodyPart();
     contentPart.setContent("hi,This is  my Email .i am LvBiao.", "text/html;charset=UTF-8");
     multipart.addBodyPart(contentPart);
     File attachment = new File("/home/lvbiao/java/j.txt");
     // 添加附件的内容
     if (attachment != null) {
         MimeBodyPart attachmentBodyPart = new MimeBodyPart();
         FileDataSource source = new FileDataSource(attachment);
         attachmentBodyPart.setDataHandler(new DataHandler(source));
         //MimeUtility.encodeWord可以避免文件名乱码
         attachmentBodyPart.setFileName(MimeUtility.encodeWord(attachment.getName()));
         multipart.addBodyPart(attachmentBodyPart);
     }
     // 将multipart对象放到message中
     message.setContent(multipart);
     // 保存邮件
     message.saveChanges();