说明:1、本程序可实现网页文件、普通文件的发送。

      2、实现邮件发送需要三个jar包的支持:commons-codec-1.3.jarcommons-httpclient-3.0.jar(这两个jar包实现抓取互联网网页内容)以及mail.jar
 
具体实现:
一、首先建立MailAuthenticator类,继承自javax.mail.Authenticator类。此类实现发件箱的登陆验证。
  1. package com.company.simplemail;   
  2.  
  3. import javax.mail.Authenticator;   
  4.  
  5. import javax.mail.PasswordAuthentication;   
  6.  
  7. /**   
  8. * 服务器邮箱登录验证   
  9. */   
  10. public class MailAuthenticator extends Authenticator {   
  11.       
  12. //     用户名(登录邮箱)   
  13.   private String username;   
  14.  
  15. //     密码   
  16.   private String password;   
  17.  
  18.   /**   
  19.     * 初始化邮箱和密码   
  20.     * @param username 邮箱   
  21.     * @param password 密码   
  22.     */   
  23.   public MailAuthenticator(String username, String password){   
  24.     this.username = username;   
  25.     this.password = password;   
  26.   }   
  27.  
  28.   String getPassword() {   
  29.     return password;   
  30.   }   
  31.  
  32.   @Override   
  33.   protected PasswordAuthentication getPasswordAuthentication() {   
  34.     return new PasswordAuthentication(username, password);   
  35.   }   
  36.  
  37.   String getUsername() {   
  38.     return username;   
  39.   }   
  40.  
  41.   public void setPassword(String password) {   
  42.     this.password = password;   
  43.   }   
  44.  
  45.   public void setUsername(String username) {   
  46.     this.username = username;   
  47.   }   
  48.  
  49. }  
二、 建立SimpleMailSender类,此类实现邮件的单发、群发等等,是邮件发送的核心类
  1. package com.company.simplemail;   
  2.  
  3. import java.util.List;   
  4. import java.util.Properties;   
  5.  
  6. import javax.mail.MessagingException;   
  7. import javax.mail.Multipart;   
  8. import javax.mail.Session;   
  9. import javax.mail.Transport;   
  10. import javax.mail.internet.AddressException;   
  11. import javax.mail.internet.InternetAddress;   
  12. import javax.mail.internet.MimeBodyPart;   
  13. import javax.mail.internet.MimeMessage;   
  14. import javax.mail.internet.MimeMessage.RecipientType;   
  15. import javax.mail.internet.MimeMultipart;   
  16.  
  17.  
  18. /**   
  19. * 简单邮件发送器,可单发,群发。   
  20. */   
  21. public class SimpleMailSender {   
  22. //  发送邮件的props文件   
  23.   private final transient Properties props = System.getProperties();   
  24.  
  25. //    邮件服务器登录验证   
  26.   private transient MailAuthenticator authenticator;   
  27.  
  28. //    邮箱session   
  29.   private transient Session session;   
  30.       
  31.   /**   
  32.     * 初始化邮件发送器   
  33.     * @param smtpHostName SMTP邮件服务器地址   
  34.     * @param username 发送邮件的用户名(地址)   
  35.     * @param password 发送邮件的密码   
  36.     */   
  37.   public SimpleMailSender(final String smtpHostName, final String username,   
  38.       final String password) {   
  39.     init(username, password, smtpHostName);   
  40.   }   
  41.  
  42.   /**   
  43.     * 初始化邮件发送器   
  44.     * @param username 发送邮件的用户名(地址),并以此解析SMTP服务器地址   
  45.     * @param password 发送邮件的密码   
  46.     */   
  47.   public SimpleMailSender(final String username, final String password) {   
  48.     // 通过邮箱地址解析出smtp服务器,对大多数邮箱都管用   
  49.     final String smtpHostName = "smtp." + username.split("@")[1];   
  50.     init(username, password, smtpHostName);   
  51.   }   
  52.  
  53.   /**   
  54.     * 初始化   
  55.     * @param username 发送邮件的用户名(地址)   
  56.     * @param password 密码   
  57.     * @param smtpHostName SMTP主机地址   
  58.     */   
  59.   private void init(String username, String password, String smtpHostName) {   
  60.     // 初始化props   
  61.     props.put("mail.smtp.auth""true");   
  62.     props.put("mail.smtp.host", smtpHostName);   
  63.     // 验证   
  64.     authenticator = new MailAuthenticator(username, password);   
  65.     // 创建session   
  66.     session = Session.getInstance(props, authenticator);   
  67.   }   
  68.  
  69.   /**   
  70.     * 发送邮件   
  71.     * @param recipient收件人邮箱地址   
  72.     * @param subject邮件主题   
  73.     * @param content邮件内容   
  74.     * @throws AddressException   
  75.     * @throws MessagingException   
  76.     */   
  77.   public void send(String recipient, String subject, String content)   
  78.       throws AddressException, MessagingException {   
  79.     // 创建mime类型邮件   
  80.     final MimeMessage message = new MimeMessage(session);   
  81.     // 设置发信人   
  82.     message.setFrom(new InternetAddress(authenticator.getUsername()));   
  83.     // 设置收件人   
  84.     message.setRecipient(RecipientType.TO, new InternetAddress(recipient));   
  85.     // 设置主题   
  86.     message.setSubject(subject);   
  87.     // 设置邮件内容   
  88.     Multipart mp = new MimeMultipart("related");   
  89.                 MimeBodyPart mbp = new MimeBodyPart();   
  90.                 mbp.setContent(content.toString(),"text/html;charset=utf-8");   
  91.                 mp.addBodyPart(mbp);   
  92.                 message.setContent(mp);   
  93.        
  94.        
  95.     // 设置邮件内容   
  96.   //  message.setContent(content.toString(), "text/html;charset=utf-8");   
  97.     // 发送   
  98.     Transport.send(message);   
  99.   }   
  100.  
  101.   /**   
  102.     * 群发邮件   
  103.     * @param recipients收件人们   
  104.     * @param subject 主题   
  105.     * @param content 内容   
  106.     * @throws AddressException   
  107.     * @throws MessagingException   
  108.     */   
  109.   public void send(List<String> recipients, String subject, String content)   
  110.       throws AddressException, MessagingException {   
  111.     // 创建mime类型邮件   
  112.     final MimeMessage message = new MimeMessage(session);   
  113.     // 设置发信人   
  114.     message.setFrom(new InternetAddress(authenticator.getUsername()));   
  115.     // 设置收件人们   
  116.     final int num = recipients.size();   
  117.     InternetAddress[] addresses = new InternetAddress[num];   
  118.     for (int i = 0; i < num; i++) {   
  119.       addresses[i] = new InternetAddress(recipients.get(i));   
  120.     }   
  121.     message.setRecipients(RecipientType.TO, addresses);   
  122.     // 设置主题   
  123.     message.setSubject(subject);   
  124.     // 设置邮件内容   
  125.     message.setContent(content.toString(), "text/html;charset=utf-8");   
  126.     // 发送   
  127.     Transport.send(message);   
  128.   }   
  129.  
  130.   /**   
  131.     * 发送邮件   
  132.     * @param recipient收件人邮箱地址   
  133.     * @param mail邮件对象   
  134.     * @throws AddressException   
  135.     * @throws MessagingException   
  136.     *                             
  137.     */   
  138.   public void send(String recipient, SimpleMail mail)   
  139.       throws AddressException, MessagingException {   
  140.     send(recipient, mail.getSubject(), mail.getContent());   
  141.   }   
  142.  
  143.   /**   
  144.     * 群发邮件   
  145.     * @param recipients 收件人们   
  146.     * @param mail 邮件对 象    
  147.     * @throws AddressException   
  148.     * @throws MessagingException   
  149.     */   
  150.   public void send(List<String> recipients, SimpleMail mail)   
  151.       throws AddressException, MessagingException {   
  152.     send(recipients, mail.getSubject(), mail.getContent());   
  153.   }   
  154. }  
  1. package com.company.simplemail;   
  2.  
  3. public class SimpleMail {   
  4.   //邮件中的主题   
  5.   private String subject;   
  6.   //邮件的内容(正文)   
  7.   private String content;   
  8.   //可根据需要增加其他邮件元素   
  9.  
  10.   public void setSubject(String subject) {   
  11.     this.subject = subject;   
  12.   }   
  13.  
  14.   public void setContent(String content) {   
  15.     this.content = content;   
  16.   }   
  17.  
  18.   public String getSubject() {   
  19.     return subject;   
  20.   }   
  21.  
  22.   public String getContent() {   
  23.     return content;   
  24.   }   
  25. }  
四、建立ReadHtmlFile类,此类用来读取网页文件(当然也能读取普通文件),将文件转换成String用来发送
  1. package com.company.util;   
  2.  
  3. import java.io.BufferedInputStream;   
  4. import java.io.File;   
  5. import java.io.FileInputStream;   
  6. import java.io.IOException;   
  7. import java.io.InputStream;   
  8. import java.io.InputStreamReader;   
  9. import java.io.Reader;   
  10.  
  11. import org.apache.commons.httpclient.HttpClient;   
  12. import org.apache.commons.httpclient.HttpException;   
  13. import org.apache.commons.httpclient.methods.GetMethod;   
  14.  
  15. public class ReadHtmlFile {   
  16.  
  17.   public static HttpClient client = new HttpClient();   
  18.       
  19.   //读取普通文件   
  20.   public static String readFile(String filename) {   
  21.     File file = new File(filename);   
  22.     Reader reader = null;   
  23.     StringBuffer stb = new StringBuffer();   
  24.     int charread = 0;   
  25.     char[] temps = new char[100];   
  26.     try {   
  27.       reader = new InputStreamReader(new FileInputStream(file));   
  28.       while ((charread = reader.read(temps)) != -1) {   
  29.         if (charread == temps.length) {   
  30.           stb.append(temps);   
  31.           temps = new char[100];   
  32.           charread = 0;   
  33.         }   
  34.       }   
  35.       stb.append(temps);   
  36.       reader.close();   
  37.     } catch (Exception e) {   
  38.       e.printStackTrace();   
  39.     }   
  40.     String str = stb.toString();   
  41.     return str;   
  42.   }   
  43.  
  44.   /**   
  45.     *      
  46.     * 所要发送的网页中,不要使用外联样式,脚本等,   
  47.     * 因为各大邮箱后台的过滤算法会过滤掉css,script等   
  48.     * 样式用标签style属性写   
  49.     * 图片、链接必须使用绝对地址 (http://.....) 形式才能接收显示   
  50.     * */   
  51.   public static String getSource(String url) {   
  52.  
  53.     GetMethod method = new GetMethod(url);   
  54.  
  55.     try {   
  56.       client.executeMethod(method);   
  57.     } catch (HttpException e) {   
  58.       e.printStackTrace();   
  59.     } catch (IOException e) {   
  60.       e.printStackTrace();   
  61.     }   
  62.     InputStream in = null;   
  63.     try {   
  64.       in = method.getResponseBodyAsStream();   
  65.     } catch (IOException e1) {   
  66.  
  67.       // e1.printStackTrace();   
  68.     }   
  69.     in = new BufferedInputStream(in);   
  70.     Reader r = new InputStreamReader(in);   
  71.     int c;   
  72.     StringBuffer buffer = new StringBuffer();   
  73.  
  74.     try {   
  75.       while ((c = r.read()) != -1)   
  76.         buffer.append((char) c);   
  77.     } catch (IOException e) {   
  78.       e.printStackTrace();   
  79.     }   
  80.     try {   
  81.       in.close();   
  82.     } catch (IOException e) {   
  83.       e.printStackTrace();   
  84.     }   
  85.     method.releaseConnection();   
  86.  
  87.     return buffer.toString();   
  88.   }   
  89. }   
  90.  
五、建立测试类,可以发送邮件了!!!
 
  1. package com.company.simplemail;   
  2.  
  3. import java.util.ArrayList;   
  4. import java.util.List;   
  5.  
  6. import org.junit.Test;   
  7.  
  8. import com.company.util.ReadHtmlFile;   
  9.  
  10. public class MailTest {   
  11.   /**   
  12.     * 单发   
  13.     * */   
  14.   @Test   
  15.   public void testSingleSend(){   
  16.     SimpleMail sm=new SimpleMail();   
  17.     sm.setSubject("第一封邮件");   
  18.     String str = ReadHtmlFile.getSource("http://www.baidu.com");   
  19.     //String str = ReadHtmlFile.readFile("这里填写你需要发送的本地文件路径");   
  20.     System.out.println(str);   
  21.     sm.setContent(str);   
  22.     SimpleMailSender sms=new SimpleMailSender(""这里填写你的发件箱","这里填写你的发件箱密码");   
  23.     try {   
  24.       sms.send("这里需要填写接收邮件的邮箱", sm);   
  25.       System.out.println("执行完成!!");   
  26.     } catch (Exception e) {   
  27.       e.printStackTrace();   
  28.     }   
  29.   }   
  30.       
  31.       
  32.   /**   
  33.     * 群发   
  34.     *      
  35.     * */   
  36.   @Test   
  37.   public void testMassSend(){   
  38.     SimpleMail sm=new SimpleMail();   
  39.     sm.setSubject("第一封邮件");   
  40.     String str = ReadHtmlFile.getSource("http://www.baidu.com");   
  41.     //String str = ReadHtmlFile.readFile("这里填写需要发送的本地文件路径");   
  42.     System.out.println(str);   
  43.     sm.setContent(str);   
  44.     SimpleMailSender sms=new SimpleMailSender("这里填写你的发件箱","这里填写你的发件箱密码");   
  45.     List<String> recipients=new ArrayList<String>();   
  46.     recipients.add("这里需要填写接收邮件的邮箱");   
  47.     recipients.add("这里需要填写接收邮件的邮箱");   
  48.     recipients.add("这里需要填写接收邮件的邮箱");   
  49.     recipients.add("这里需要填写接收邮件的邮箱");   
  50.     try {   
  51.       sms.send(recipients, sm);   
  52.       System.out.println("执行完成!!");   
  53.     } catch (Exception e) {   
  54.       e.printStackTrace();   
  55.     }   
  56.   }   
  57. }   
最后再次强调:
     1,所要发送的网页中,不要使用外联样式,脚本等,因为各大邮箱后台的过滤算法会过滤掉css,script等。
     2,样式用标签style属性写
     3,图片、链接必须使用绝对地址 (http://.....) 形式才能接收显示