利用Java实现电子邮件的批量发送

　　JAVA MAIL是利用现有的邮件账户发送邮件的工具，比如说，我在网易注册一个邮箱账户，通过JAVA Mail的操控，我可以不亲自登录网易邮箱，让程序自动的使用网易邮箱发送邮件。这一机制被广泛的用在注册激活和垃圾邮件的发送等方面。进行下载,并将mail.jar添加到classpath即可。如果你使用的是JAVA EE SDK，则可以在C:glassfishv3glassfishmodulesmail.jar找到所需的jar包，同样需要添加的classpath。

成都创新互联公司2013年成立，是专业互联网技术服务公司，拥有项目成都网站制作、成都网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元秦皇岛做网站,已为上家服务,为秦皇岛各地企业和个人服务,联系电话:028-86922220

　　JAVA邮件发送的大致过程是这样的的：

　　1、构建一个继承自javax.mail.Authenticator的具体类，并重写里面的getPasswordAuthentication()方法。此类是用作登录校验的，以确保你对该邮箱有发送邮件的权利。

　　2、构建一个properties文件，该文件中存放SMTP服务器地址等参数。

　　3、通过构建的properties文件和javax.mail.Authenticator具体类来创建一个javax.mail.Session。Session的创建，就相当于登录邮箱一样。剩下的自然就是新建邮件。

　　4、构建邮件内容，一般是javax.mail.internet.MimeMessage对象，并指定发送人，收信人，主题，内容等等。

　　5、使用javax.mail.Transport工具类发送邮件。

　　下面是我封装的代码，注释也比较详细。呼呼~~

　　1、首先是继承自javax.mail.Authenticator的一个具体类。getPasswordAuthentication()方法也就是构建一个PasswordAuthentication对象并返回，有点费解JAVA Mail这样的设计意图，可能是javax.mail.Authenticator为我们提供了附加的保证安全的验证措施吧。

 
 
 
    
  
  
  
  1. 　　package com.mzule.simplemail;  
    2.   
  
  
  2. 　　import javax.mail.Authenticator;  
    3.   
  
  
  3. 　　import javax.mail.PasswordAuthentication;  
    4.   
  
  
  4. 　　/**  
    5.   
  
  
  5. 　　* 服务器邮箱登录验证  
    6.   
  
  
  6. 　　*  
    7.   
  
  
  7. 　　* @author MZULE  
    8.   
  
  
  8. 　　*  
    9.   
  
  
  9. 　　*/ 
    10.   
  
  
  10. 　　public class MailAuthenticator extends Authenticator {  
    11.   
  
  
  11. 　　/**  
    12.   
  
  
  12. 　　* 用户名（登录邮箱）  
    13.   
  
  
  13. 　　*/ 
    14.   
  
  
  14. 　　private String username;  
    15.   
  
  
  15. 　　/**  
    16.   
  
  
  16. 　　* 密码  
    17.   
  
  
  17. 　　*/ 
    18.   
  
  
  18. 　　private String password;  
    19.   
  
  
  19. 　　/**  
    20.   
  
  
  20. 　　* 初始化邮箱和密码  
    21.   
  
  
  21. 　　*  
    22.   
  
  
  22. 　　* @param username 邮箱  
    23.   
  
  
  23. 　　* @param password 密码  
    24.   
  
  
  24. 　　*/ 
    25.   
  
  
  25. 　　public MailAuthenticator(String username, String password) {  
    26.   
  
  
  26. 　　this.username = username;  
    27.   
  
  
  27. 　　this.password = password;  
    28.   
  
  
  28. 　　}  
    29.   
  
  
  29. 　　String getPassword() {  
    30.   
  
  
  30. 　　return password;  
    31.   
  
  
  31. 　　}  
    32.   
  
  
  32. 　　@Override 
    33.   
  
  
  33. 　　protected PasswordAuthentication getPasswordAuthentication() {  
    34.   
  
  
  34. 　　return new PasswordAuthentication(username, password);  
    35.   
  
  
  35. 　　}  
    36.   
  
  
  36. 　　String getUsername() {  
    37.   
  
  
  37. 　　return username;  
    38.   
  
  
  38. 　　}  
    39.   
  
  
  39. 　　public void setPassword(String password) {  
    40.   
  
  
  40. 　　this.password = password;  
    41.   
  
  
  41. 　　}  
    42.   
  
  
  42. 　　public void setUsername(String username) {  
    43.   
  
  
  43. 　　this.username = username;  
    44.   
  
  
  44. 　　}  
    45.   
  
  
  45. 　　} 
    46.

　　2、邮件发送类，剩下的步骤都是在这个类实现的。代码中的SimpleMail是封装了邮件主题和内容的一个POJO。觉得在一个方法参数中既包含主题又包含内容，不太合适，故重载了此方法。还有就是因为大多数邮箱的SMTP服务器地址都是可以通过邮箱地址算出来，简单起见，提供了一个不需要SMTP服务器地址的构造器。

 
 
 
    
  
  
  
  1. 　　package com.mzule.simplemail;  
    2.   
  
  
  2. 　　import java.util.List;  
    3.   
  
  
  3. 　　import java.util.Properties;  
    4.   
  
  
  4. 　　import javax.mail.MessagingException;  
    5.   
  
  
  5. 　　import javax.mail.Session;  
    6.   
  
  
  6. 　　import javax.mail.Transport;  
    7.   
  
  
  7. 　　import javax.mail.internet.AddressException;  
    8.   
  
  
  8. 　　import javax.mail.internet.InternetAddress;  
    9.   
  
  
  9. 　　import javax.mail.internet.MimeMessage;  
    10.   
  
  
  10. 　　import javax.mail.internet.MimeMessage.RecipientType;  
    11.   
  
  
  11. 　　/**  
    12.   
  
  
  12. 　　* 简单邮件发送器，可单发，群发。  
    13.   
  
  
  13. 　　*  
    14.   
  
  
  14. 　　* @author MZULE  
    15.   
  
  
  15. 　　*  
    16.   
  
  
  16. 　　*/ 
    17.   
  
  
  17. 　　public class SimpleMailSender {  
    18.   
  
  
  18. 　　/**  
    19.   
  
  
  19. 　　* 发送邮件的props文件  
    20.   
  
  
  20. 　　*/ 
    21.   
  
  
  21. 　　private final transient Properties props = System.getProperties();  
    22.   
  
  
  22. 　　/**  
    23.   
  
  
  23. 　　* 邮件服务器登录验证  
    24.   
  
  
  24. 　　*/ 
    25.   
  
  
  25. 　　private transient MailAuthenticator authenticator;  
    26.   
  
  
  26. 　　/**  
    27.   
  
  
  27. 　　* 邮箱session  
    28.   
  
  
  28. 　　*/ 
    29.   
  
  
  29. 　　private transient Session session;  
    30.   
  
  
  30. 　　/**  
    31.   
  
  
  31. 　　* 初始化邮件发送器  
    32.   
  
  
  32. 　　*  
    33.   
  
  
  33. 　　* @param smtpHostName  
    34.   
  
  
  34. 　　* SMTP邮件服务器地址  
    35.   
  
  
  35. 　　* @param username  
    36.   
  
  
  36. 　　* 发送邮件的用户名(地址)  
    37.   
  
  
  37. 　　* @param password  
    38.   
  
  
  38. 　　* 发送邮件的密码  
    39.   
  
  
  39. 　　*/ 
    40.   
  
  
  40. 　　public SimpleMailSender(final String smtpHostName, final String username,  
    41.   
  
  
  41. 　　final String password) {  
    42.   
  
  
  42. 　　init(username, password, smtpHostName);  
    43.   
  
  
  43. 　　}  
    44.   
  
  
  44. 　　/**  
    45.   
  
  
  45. 　　* 初始化邮件发送器  
    46.   
  
  
  46. 　　*  
    47.   
  
  
  47. 　　* @param username  
    48.   
  
  
  48. 　　* 发送邮件的用户名(地址)，并以此解析SMTP服务器地址  
    49.   
  
  
  49. 　　* @param password  
    50.   
  
  
  50. 　　* 发送邮件的密码  
    51.   
  
  
  51. 　　*/ 
    52.   
  
  
  52. 　　public SimpleMailSender(final String username, final String password) {  
    53.   
  
  
  53. 　　//通过邮箱地址解析出smtp服务器，对大多数邮箱都管用  
    54.   
  
  
  54. 　　final String smtpHostName = "smtp." + username.split("@")[1];  
    55.   
  
  
  55. 　　init(username, password, smtpHostName);  
    56.   
  
  
  56. 　　}  
    57.   
  
  
  57. 　　/**  
    58.   
  
  
  58. 　　* 初始化  
    59.   
  
  
  59. 　　*  
    60.   
  
  
  60. 　　* @param username  
    61.   
  
  
  61. 　　* 发送邮件的用户名(地址)  
    62.   
  
  
  62. 　　* @param password  
    63.   
  
  
  63. 　　* 密码  
    64.   
  
  
  64. 　　* @param smtpHostName  
    65.   
  
  
  65. 　　* SMTP主机地址  
    66.   
  
  
  66. 　　*/ 
    67.   
  
  
  67. 　　private void init(String username, String password, String smtpHostName) {  
    68.   
  
  
  68. 　　// 初始化props  
    69.   
  
  
  69. 　　props.put("mail.smtp.auth", "true");  
    70.   
  
  
  70. 　　props.put("mail.smtp.host", smtpHostName);  
    71.   
  
  
  71. 　　// 验证  
    72.   
  
  
  72. 　　authenticator = new MailAuthenticator(username, password);  
    73.   
  
  
  73. 　　// 创建session  
    74.   
  
  
  74. 　　session = Session.getInstance(props, authenticator);  
    75.   
  
  
  75. 　　}  
    76.   
  
  
  76. 　　/**  
    77.   
  
  
  77. 　　* 发送邮件  
    78.   
  
  
  78. 　　*  
    79.   
  
  
  79. 　　* @param recipient  
    80.   
  
  
  80. 　　* 收件人邮箱地址  
    81.   
  
  
  81. 　　* @param subject  
    82.   
  
  
  82. 　　* 邮件主题  
    83.   
  
  
  83. 　　* @param content  
    84.   
  
  
  84. 　　* 邮件内容  
    85.   
  
  
  85. 　　* @throws AddressException  
    86.   
  
  
  86. 　　* @throws MessagingException  
    87.   
  
  
  87. 　　*/ 
    88.   
  
  
  88. 　　public void send(String recipient, String subject, Object content)  
    89.   
  
  
  89. 　　throws AddressException, MessagingException {  
    90.   
  
  
  90. 　　// 创建mime类型邮件  
    91.   
  
  
  91. 　　final MimeMessage message = new MimeMessage(session);  
    92.   
  
  
  92. 　　// 设置发信人  
    93.   
  
  
  93. 　　message.setFrom(new InternetAddress(authenticator.getUsername()));  
    94.   
  
  
  94. 　　// 设置收件人  
    95.   
  
  
  95. 　　message.setRecipient(RecipientType.TO, new InternetAddress(recipient));  
    96.   
  
  
  96. 　　// 设置主题  
    97.   
  
  
  97. 　　message.setSubject(subject);  
    98.   
  
  
  98. 　　// 设置邮件内容  
    99.   
  
  
  99. 　　message.setContent(content.toString(), "text/html;charset=utf-8");  
    100.   
  
  
  100. 　　// 发送  
    101.   
  
  
  101. 　　Transport.send(message);  
    102.   
  
  
  102. 　　}  
    103.   
  
  
  103. 　　/**  
    104.   
  
  
  104. 　　* 群发邮件  
    105.   
  
  
  105. 　　*  
    106.   
  
  
  106. 　　* @param recipients  
    107.   
  
  
  107. 　　* 收件人们  
    108.   
  
  
  108. 　　* @param subject  
    109.   
  
  
  109. 　　* 主题  
    110.   
  
  
  110. 　　* @param content  
    111.   
  
  
  111. 　　* 内容  
    112.   
  
  
  112. 　　* @throws AddressException  
    113.   
  
  
  113. 　　* @throws MessagingException  
    114.   
  
  
  114. 　　*/ 
    115.   
  
  
  115. 　　public void send(List recipients, String subject, Object content)  
    116.   
  
  
  116. 　　throws AddressException, MessagingException {  
    117.   
  
  
  117. 　　// 创建mime类型邮件  
    118.   
  
  
  118. 　　final MimeMessage message = new MimeMessage(session);  
    119.   
  
  
  119. 　　// 设置发信人  
    120.   
  
  
  120. 　　message.setFrom(new InternetAddress(authenticator.getUsername()));  
    121.   
  
  
  121. 　　// 设置收件人们  
    122.   
  
  
  122. 　　final int num = recipients.size();  
    123.   
  
  
  123. 　InternetAddress[] addresses = new InternetAddress[num];  
    124.   
  
  
  124. 　　for (int i = 0; i   
  
  
  125. 　　addresses[i] = new InternetAddress(recipients.get(i));  
    126.   
  
  
  126. 　　}  
    127.   
  
  
  127. 　　message.setRecipients(RecipientType.TO, addresses);  
    128.   
  
  
  128. 　　// 设置主题  
    129.   
  
  
  129. 　　message.setSubject(subject);  
    130.   
  
  
  130. 　　// 设置邮件内容  
    131.   
  
  
  131. 　　message.setContent(content.toString(), "text/html;charset=utf-8");  
    132.   
  
  
  132. 　　// 发送  
    133.   
  
  
  133. 　　Transport.send(message);  
    134.   
  
  
  134. 　　}  
    135.   
  
  
  135. 　　/**  
    136.   
  
  
  136. 　　* 发送邮件  
    137.   
  
  
  137. 　　*  
    138.   
  
  
  138. 　　* @param recipient  
    139.   
  
  
  139. 　　* 收件人邮箱地址  
    140.   
  
  
  140. 　　* @param mail  
    141.   
  
  
  141. 　　* 邮件对象  
    142.   
  
  
  142. 　　* @throws AddressException  
    143.   
  
  
  143. 　　* @throws MessagingException  
    144.   
  
  
  144. 　*/ 
    145.   
  
  
  145. 　　public void send(String recipient, SimpleMail mail)  
    146.   
  
  
  146. 　　throws AddressException, MessagingException {  
    147.   
  
  
  147. 　　send(recipient, mail.getSubject(), mail.getContent());  
    148.   
  
  
  148. 　　}  
    149.   
  
  
  149. 　　/**  
    150.   
  
  
  150. 　　* 群发邮件  
    151.   
  
  
  151. 　　*  
    152.   
  
  
  152. 　　* @param recipients  
    153.   
  
  
  153. 　　* 收件人们  
    154.   
  
  
  154. 　　* @param mail  
    155.   
  
  
  155. 　* 邮件对  
    156.   
  
  
  156. 　* @throws AddressException  
    157.   
  
  
  157. 　　* @throws MessagingException  
    158.   
  
  
  158. 　　*/ 
    159.   
  
  
  159. 　　public void send(List recipients, SimpleMail mail)  
    160.   
  
  
  160. 　　throws AddressException, MessagingException {  
    161.   
  
  
  161. 　　send(recipients, mail.getSubject(), mail.getContent());  
    162.   
  
  
  162. 　　}  
    163.   
  
  
  163. 　　} 
    164.

　　3、调用上面的邮箱发送器，可以构建一个工厂类，工厂类可以封装创建的过程，所以通过读配置文件获取邮箱用户名，密码都会变得十分方便。下面的代码是我在写观察者模式的时候写的，只是简单演示了工厂类。

 
 
 
    
  
  
  
  1. 　package com.mzule.dp.observer.factory;  
    2.   
  
  
  2. 　　import com.mzule.dp.observer.constant.MailSenderType;  
    3.   
  
  
  3. 　　import com.mzule.simplemail.SimpleMailSender;  
    4.   
  
  
  4. 　　/**  
    5.   
  
  
  5. 　　* 发件箱工厂  
    6.   
  
  
  6. 　　*  
    7.   
  
  
  7. 　　* @author MZULE  
    8.   
  
  
  8. 　　*  
    9.   
  
  
  9. 　　*/ 
    10.   
  
  
  10. 　　public class MailSenderFactory {  
    11.   
  
  
  11. 　　/**  
    12.   
  
  
  12. 　　* 服务邮箱  
    13.   
  
  
  13. 　　*/ 
    14.   
  
  
  14. 　　private static SimpleMailSender serviceSms = null;  
    15.   
  
  
  15. 　　/**  
    16.   
  
  
  16. 　　* 获取邮箱  
    17.   
  
  
  17. 　　*  
    18.   
  
  
  18. 　　* @param type 邮箱类型  
    19.   
  
  
  19. 　　* @return 符合类型的邮箱  
    20.   
  
  
  20. 　　*/ 
    21.   
  
  
  21. 　　public static SimpleMailSender getSender(MailSenderType type) {  
    22.   
  
  
  22. 　　if (type == MailSenderType.SERVICE) {  
    23.   
  
  
  23. 　　if (serviceSms == null) {  
    24.   
  
  
  24. 　　serviceSms = new SimpleMailSender("invisible@126.com",  
    25.   
  
  
  25. 　　"hidden");  
    26.   
  
  
  26. 　　}  
    27.   
  
  
  27. 　　return serviceSms;  
    28.   
  
  
  28. 　　}  
    29.   
  
  
  29. 　　return null;  
    30.   
  
  
  30. 　　}  
    31.   
  
  
  31. 　　} 
    32.

　　4、发送邮件，还是观察者模式DEMO里面的代码，呼呼。

 
 
 
    
  
  
  
  1. 　　package com.mzule.dp.observer.observer;  
    2.   
  
  
  2. 　　import java.util.ArrayList;  
    3.   
  
  
  3. 　　import java.util.List;  
    4.   
  
  
  4. 　　import java.util.Observable;  
    5.   
  
  
  5. 　　import java.util.Observer;  
    6.   
  
  
  6. 　　import javax.mail.MessagingException;  
    7.   
  
  
  7. 　　import javax.mail.internet.AddressException;  
    8.   
  
  
  8. 　　import com.mzule.dp.observer.constant.MailSenderType;  
    9.   
  
  
  9. 　　import com.mzule.dp.observer.factory.MailSenderFactory;  
    10.   
  
  
  10. 　　import com.mzule.dp.observer.po.Product;  
    11.   
  
  
  11. 　　import com.mzule.simplemail.SimpleMailSender;  
    12.   
  
  
  12. 　　public class ProductPriceObserver implements Observer {  
    13.   
  
  
  13. 　　@Override 
    14.   
  
  
  14. 　　public void update(Observable obj, Object arg) {  
    15.   
  
  
  15. 　　Product product = null;  
    16.   
  
  
  16. 　　if (obj instanceof Product) {  
    17.   
  
  
  17. 　　product = (Product) obj;  
    18.   
  
  
  18. 　　}  
    19.   
  
  
  19. 　　if (arg instanceof Float) {  
    20.   
  
  
  20. 　　Float price = (Float) arg;  
    21.   
  
  
  21. 　Float decrease = product.getPrice() - price;  
    22.   
  
  
  22. 　　if (decrease >0) {  
    23.   
  
  
  23. 　　// 发送邮件  
    24.   
  
  
  24. 　　SimpleMailSender sms = MailSenderFactory  
    25.   
  
  
  25. 　　.getSender(MailSenderType.SERVICE);  
    26.   
  
  
  26. 　　List recipients = new ArrayList();  
    27.   
  
  
  27. 　　recipients.add("invisible@qq.com");  
    28.   
  
  
  28. 　　recipients.add("invisible@gmail.com");  
    29.   
  
  
  29. 　　try {  
    30.   
  
  
  30. 　　for (String recipient : recipients) {  
    31.   
  
  
  31. 　　sms.send(recipient, "价格变动", "您关注的物品" 
    32.   
  
  
  32. 　　+ product.getName() + "降价了，由" 
    33.   
  
  
  33. 　　+ product.getPrice() + "元降到" + price + "元，降幅达" 
    34.   
  
  
  34. 　　+ decrease + "元人民币。赶快购物吧。");  
    35.   
  
  
  35. 　　}  
    36.   
  
  
  36. 　　} catch (AddressException e) {  
    37.   
  
  
  37. 　　e.printStackTrace();  
    38.   
  
  
  38. 　　} catch (MessagingException e) {  
    39.   
  
  
  39. 　　e.printStackTrace();  
    40.   
  
  
  40. 　　}  
    41.   
  
  
  41. 　　}  
    42.   
  
  
  42. 　　}  
    43.   
  
  
  43. 　　}  
    44.   
  
  
  44. 　　} 
    45.

　　5、剩下的就是去查看邮件是否发送成功了。呼呼~~

原文链接：http://www.cnblogs.com/codeplus/archive/2011/10/30/2229391.html

本文题目：利用Java实现电子邮件的批量发送
网站URL：http://www.36103.cn/qtweb/news4/21404.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

软件开发知识

同城分类信息

网络推广公司　　 　绵阳电信机房　　 　做网站　　 　SSL证书　　 　成都商城开发　　 　都江堰网站建设　　 　混凝土搅拌车　　 　广元双南建站　　 　云服务器　　 　虚拟主机　　 　甘孜州博瑞斯　　 　自贡主机托管　　 　小谭建站　　 　网络推广外包　　 　阿坝网站设计　　 　传美奇电器　　 　新都网站建设　　 　服务器托管　　 　成都橡塑保温管　　 　做网站的公司