亲宝软件园·资讯

展开

使用Java-mail 发送邮件

Amour恋空 人气:0

首先：

我们准备工作需要准备 

jar包   mail.jar

POP3/SMTP服务  以qq为例

发送邮箱的账号  *********.@qq.com

发送邮箱授权码  获取流程如下

进入邮箱，点击设置

 

 

 

拉到最后，将POP3服务开启

之后生成授权码

 

获取授权码 

这样 准备工作基本完成就可以写代码了

这是自己写的一个工具类，注释也加上了，虽然自带debug信息，但是那个比较多，所以在每个方法中打印输出了一下，默认使用的是qq的邮箱，更改至于要修改相应位置的属性就行

 
  1. import java.io.File;
  2. import java.io.IOException;
  3. import java.io.UnsupportedEncodingException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.ArrayList;
  6. import java.util.Date;
  7. import java.util.HashMap;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.Properties;
  11. import javax.activation.DataHandler;
  12. import javax.activation.DataSource;
  13. import javax.activation.FileDataSource;
  14. import javax.mail.Address;
  15. import javax.mail.Authenticator;
  16. import javax.mail.BodyPart;
  17. import javax.mail.Message;
  18. import javax.mail.MessagingException;
  19. import javax.mail.Multipart;
  20. import javax.mail.PasswordAuthentication;
  21. import javax.mail.Session;
  22. import javax.mail.Transport;
  23. import javax.mail.internet.AddressException;
  24. import javax.mail.internet.InternetAddress;
  25. import javax.mail.internet.MimeBodyPart;
  26. import javax.mail.internet.MimeMessage;
  27. import javax.mail.internet.MimeMultipart;
  28. import javax.mail.internet.MimeUtility;
  29.  
  30.  
  31. /**
  32. *
  33. * 项目名称：JavaMail
  34. * 类名称：SendMail
  35. * 类描述：
  36. * 创建人：Ai
  37. * 创建时间：2018年5月2日 下午3:49:45
  38. * 修改人：Ai
  39. * 修改时间：2018年5月2日 下午3:49:45
  40. * 修改备注：javaMail封装代码
  41. * @version JM-0.1
  42. *
  43. */
  44. public class SendMail {
  45. 	private final String username = "*****@qq.com"; //发送邮件的邮箱
  46. 	private final String password = "*********";   //发送邮箱的授权码
  47. 	private Authenticator auth = null;
  48. 	private MimeMessage mimeMessage = null;
  49. 	private Properties pros = null;
  50. 	private Multipart multipart = null;
  51. 	private BodyPart bodypart = null;
  52.  
  53. 	/**
  54. 	 * 初始化账号密码并验证 创建MimeMessage对象 发送邮件必须的步骤:1
  55. 	 * 
  56. 	 * @param username
  57. 	 * @param password
  58. 	 */
  59. 	public SendMail() {
  60. 		Map<String, String> map = new HashMap<String, String>();
  61. 		// 你的发送邮箱账号 POP3/SMTP服务 授权码
  62. 		map.put("mail.smtp.host", "smtp.qq.com");
  63. 		map.put("mail.smtp.auth", "true");
  64. 		map.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
  65. 		map.put("mail.smtp.port", "465");
  66. 		map.put("mail.smtp.socketFactory.port", "465");
  67. 		setPros(map);
  68. 		initMessage();
  69. 	}
  70. 	 
  71. 	/**
  72. 	 * 设置email系统参数 接收一个map集合key为string类型，值为String 发送邮件必须的步骤:2
  73. 	 * 
  74. 	 * @param map
  75. 	 */
  76. 	public boolean setPros(Map<String, String> map) {
  77. 		pros = new Properties();
  78. 		try {
  79. 			for (Map.Entry<String, String> entry : map.entrySet()) {
  80. 				pros.setProperty(entry.getKey(), entry.getValue());
  81. 			}
  82. 			System.out.println("设置email参数成功!");
  83. 			return true;
  84. 		} catch (Exception e) {
  85. 			return false;
  86. 		}
  87. 	}
  88.  
  89. 	/**
  90. 	 * 初始化MimeMessage对象 发送邮件必须的步骤:3
  91. 	 */
  92. 	public boolean initMessage() {
  93. 		this.auth = new Email_Autherticator();
  94. 		try {
  95. 			Session session = Session.getDefaultInstance(pros, auth);
  96. 			session.setDebug(false); // 设置获取 debug 信息
  97. 			mimeMessage = new MimeMessage(session);
  98. 			System.out.println("初始化成功!");
  99. 			return true;
  100. 		} catch (Exception e) {
  101. 			return false;
  102. 		}
  103. 	}
  104.  
  105. 	/**
  106. 	 * 验证账号密码 发送邮件必须的步骤
  107. 	 * 
  108. 	 * @author Administrator
  109. 	 *
  110. 	 */
  111. 	public class Email_Autherticator extends Authenticator {
  112. 		public PasswordAuthentication getPasswordAuthentication() {
  113. 			return new PasswordAuthentication(username, password);
  114. 		}
  115. 	}
  116.  
  117. 	/**
  118. 	 * 设置发送邮件的基本参数(去除繁琐的邮件设置)
  119. 	 * 
  120. 	 * @param sub
  121. 	 *            设置邮件主题
  122. 	 * @param text
  123. 	 *            设置邮件文本内容
  124. 	 * @param rec
  125. 	 *            设置邮件接收人
  126. 	 * @throws MessagingException
  127. 	 * @throws UnsupportedEncodingException
  128. 	 */
  129. 	public boolean setDefaultMessagePros(String sub, String text, String rec)
  130. 			throws MessagingException, UnsupportedEncodingException {
  131. 		try {
  132. 			mimeMessage.setSubject(sub);
  133. 			mimeMessage.setText(text);
  134. 			mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(rec));
  135. 			mimeMessage.setSentDate(new Date());
  136. 			mimeMessage.setFrom(new InternetAddress(username, username));
  137. 			System.out.println("设置邮件发送基本参数成功!（主题、内容、接收人）");
  138. 			return true;
  139. 		} catch (Exception e) {
  140. 			return false;
  141. 		}
  142. 	}
  143.  
  144. 	/**
  145. 	 * 设置主题
  146. 	 * 
  147. 	 * @param subject
  148. 	 * @throws MessagingException
  149. 	 */
  150. 	public boolean setSubject(String subject) throws MessagingException {
  151. 		try {
  152. 			mimeMessage.setSubject(subject);
  153. 			System.out.println("设置邮件主题[" + subject + "]成功!");
  154. 			return true;
  155. 		} catch (Exception e) {
  156. 			return false;
  157. 		}
  158. 	}
  159.  
  160. 	/**
  161. 	 * 设置日期
  162. 	 * 
  163. 	 * @param date
  164. 	 *            邮件发送的日期
  165. 	 * @throws MessagingException
  166. 	 */
  167. 	public boolean setDate(Date date) throws MessagingException {
  168.  
  169. 		try {
  170. 			mimeMessage.setSentDate(date);
  171. 			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  172. 			String format = sdf.format(date);
  173. 			System.out.println("设置邮件发送日期[" + format + "]成功!");
  174. 			return true;
  175. 		} catch (Exception e) {
  176.  
  177. 			return false;
  178. 		}
  179. 	}
  180.  
  181. 	/**
  182. 	 * 设置日期
  183. 	 * 
  184. 	 * @param millisecond
  185. 	 *            邮件延时发送时间(毫秒)  //暂不好使
  186. 	 * @throws MessagingException
  187. 	 */
  188. 	public boolean setDate(long millisecond) throws MessagingException {
  189. 		Date date = new Date();
  190. 		System.out.println(date);
  191. 		date.setTime(date.getTime() + millisecond);
  192. 		try {
  193. 			mimeMessage.setSentDate(date);
  194. 			System.out.println("设置邮件发送延时[" + millisecond + "]毫秒成功!");
  195. 		} catch (Exception e) {
  196. 			System.out.println("设置邮件发送日期[" + millisecond + "]失败!");
  197. 			return false;
  198. 		}
  199. 		return true;
  200.  
  201. 	}
  202.  
  203.  
  204. 	/**
  205. 	 * 设置邮件接收人地址 <单人发送>
  206. 	 * 
  207. 	 * @param recipient
  208. 	 * @throws MessagingException
  209. 	 */
  210. 	public boolean setRecipient(String recipient) throws MessagingException {
  211. 		try {
  212. 			if (recipient.isEmpty()) {
  213. 				System.out.println("接收人地址为空!");
  214. 				return false;
  215. 			} else {
  216. 				mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(recipient));
  217. 				System.out.println("设置接收人地址为[" + recipient + "]成功!");
  218. 				return true;
  219. 			}
  220. 		} catch (Exception e) {
  221. 			return false;
  222. 		}
  223. 	}
  224.  
  225. 	/**
  226. 	 * 设置邮件接收人地址 <多人发送>
  227. 	 * 
  228. 	 * @param list
  229. 	 * @throws MessagingException
  230. 	 * @throws AddressException
  231. 	 */
  232. 	public boolean setRecipients(List<String> recs) throws AddressException, MessagingException {
  233. 		try {
  234. 			if (recs.isEmpty()) {
  235. 				System.out.println("接收人地址为空!");
  236. 				return false;
  237. 			}
  238. 			for (String str : recs) {
  239. 				mimeMessage.addRecipient(Message.RecipientType.TO, new InternetAddress(str));
  240. 			}
  241. 			System.out.println("设置接收人地址" + recs + "成功!");
  242. 			return true;
  243. 		} catch (Exception e) {
  244. 			return false;
  245. 		}
  246. 	}
  247.  
  248. 	/**
  249. 	 * 设置邮件接收人地址 <多人发送>
  250. 	 * 
  251. 	 * @param StringBuffer<parms,parms2,parms.....>
  252. 	 * @throws MessagingException
  253. 	 * @throws AddressException
  254. 	 */
  255. 	@SuppressWarnings("static-access")
  256. 	public boolean setRecipients(StringBuffer sb) throws AddressException, MessagingException {
  257. 		try {
  258. 			if (sb == null || "".equals(sb)) {
  259. 				System.out.println("字符串数据为空!");
  260. 				return false;
  261. 			}
  262. 			Address[] address = new InternetAddress().parse(sb.toString());
  263. 			mimeMessage.addRecipients(Message.RecipientType.TO, address);
  264. 			System.out.println("设置接收人地址[" + sb + "]成功!");
  265. 			return true;
  266. 		} catch (Exception e) {
  267. 			return false;
  268. 		}
  269. 	}
  270.  
  271. 	/**
  272. 	 * 设置邮件发送人的名字
  273. 	 * 
  274. 	 * @param from
  275. 	 * @throws UnsupportedEncodingException
  276. 	 * @throws MessagingException
  277. 	 */
  278. 	public boolean setFrom(String from) throws UnsupportedEncodingException, MessagingException {
  279. 		try {
  280. 			if (from.isEmpty()) {
  281. 				System.out.println("邮件发送人名字为空!");
  282. 				return false;
  283. 			} else {
  284. 				mimeMessage.setFrom(new InternetAddress(username, from));
  285. 				System.out.println("设置邮件发送人名字[" + from + "]成功!");
  286. 				return true;
  287. 			}
  288. 		} catch (Exception e) {
  289. 			return false;
  290. 		}
  291. 	}
  292.  
  293. 	/**
  294. 	 * 发送邮件<单人发送> return 是否发送成功
  295. 	 * 
  296. 	 * @throws MessagingException
  297. 	 *             发送异常
  298. 	 */
  299. 	public boolean sendMessage() {
  300. 		try {
  301. 			Transport.send(mimeMessage);
  302. 			System.out.println("----------------发送成功----------------");
  303. 			return true;
  304. 		} catch (MessagingException e) {
  305. 			return false;
  306. 		}
  307. 	}
  308.  
  309. 	/**
  310. 	 * 设置附件
  311. 	 * 
  312. 	 * @param file
  313. 	 *            发送文件的路径
  314. 	 * @throws MessagingException
  315. 	 *             发送异常
  316. 	 * @throws IOException
  317. 	 *             文件IO异常
  318. 	 * 
  319. 	 */
  320. 	public boolean setMultipart(String file) throws MessagingException, IOException {
  321. 		try {
  322. 			if (multipart == null) {
  323. 				multipart = new MimeMultipart();
  324. 			}
  325. 			multipart.addBodyPart(writeFiles(file));
  326. 			mimeMessage.setContent(multipart);
  327. 			System.out.println("设置邮件附件" + file + "成功!");
  328. 			return true;
  329. 		} catch (Exception e) {
  330. 			return false;
  331. 		}
  332. 	}
  333.  
  334. 	/**
  335. 	 * 设置附件<添加多附件>
  336. 	 * 
  337. 	 * @param fileList<接收List集合>
  338. 	 * @throws MessagingException
  339. 	 *             发送异常
  340. 	 * @throws IOException
  341. 	 *             文件IO异常
  342. 	 */
  343. 	public boolean setMultiparts(List<String> fileList) throws MessagingException, IOException {
  344. 		try {
  345. 			if (multipart == null) {
  346. 				multipart = new MimeMultipart();
  347. 			}
  348. 			for (String s : fileList) {
  349. 				multipart.addBodyPart(writeFiles(s));
  350. 			}
  351. 			mimeMessage.setContent(multipart);
  352. 			System.out.println("设置邮件附件" + fileList + "成功!");
  353. 			return true;
  354. 		} catch (Exception e) {
  355. 			return false;
  356. 		}
  357. 	}
  358.  
  359. 	/**
  360. 	 * 发送文本内容，设置编码方式 <方法与发送附件配套使用> <发送普通的文本内容请使用setText()方法>
  361. 	 * 
  362. 	 * @param s
  363. 	 *            发送的文本内容
  364. 	 * @param type
  365. 	 *            编码格式
  366. 	 * @throws MessagingException
  367. 	 */
  368. 	public boolean setContent(String s, String type) throws MessagingException {
  369. 		try {
  370. 			if (multipart == null) {
  371. 				multipart = new MimeMultipart();
  372. 			}
  373. 			bodypart = new MimeBodyPart();
  374. 			bodypart.setContent(s, type);
  375. 			multipart.addBodyPart(bodypart);
  376. 			mimeMessage.setContent(multipart);
  377. 			mimeMessage.saveChanges();
  378. 			System.out.println("设置邮件内容[" + s + "]成功!");
  379. 			return true;
  380. 		} catch (Exception e) {
  381. 			return false;
  382. 		}
  383. 	}
  384.  
  385. 	/**
  386. 	 * 读取附件
  387. 	 * 
  388. 	 * @param filePath
  389. 	 *            文件路径
  390. 	 * @return
  391. 	 * @throws IOException
  392. 	 * @throws MessagingException
  393. 	 */
  394. 	public BodyPart writeFiles(String filePath) throws IOException, MessagingException {
  395. 		File file = new File(filePath);
  396. 		if (!file.exists()) {
  397. 			throw new IOException("文件不存在!请确定文件路径是否正确");
  398. 		}
  399. 		bodypart = new MimeBodyPart();
  400. 		DataSource dataSource = new FileDataSource(file);
  401. 		bodypart.setDataHandler(new DataHandler(dataSource));
  402. 		// 文件名要加入编码，不然出现乱码
  403. 		bodypart.setFileName(MimeUtility.encodeText(file.getName()));
  404. 		return bodypart;
  405. 	}
  406. 	
  407. //----------------------------------------------------------------------------------------------------------------------------
  408. 	public static void main(String[] args) throws MessagingException, IOException {
  409. 		SendMail mail = new SendMail();
  410.  
  411. 		/*
  412. 		 * 调用setRecipients(list);发送list集合类型 List<String> list = new
  413. 		 * ArrayList<String>(); list.add("********@qq.com");
  414. 		 */
  415. 		  List<String> list = new ArrayList<String>();
  416. 		  list.add("45244445@qq.com"); 
  417. 		  mail.setRecipients(list); // 输出信息
  418. 	
  419. 		// 邮件主题
  420. 		mail.setSubject("AI测试Java邮箱功能");
  421. 		
  422. 		// 发送时间 Date类型(默认即时发送)
  423. 		mail.setDate(new Date()); 
  424. 		//mail.setDate(100);
  425. 		
  426. 		// 发送者昵称
  427. 		mail.setFrom("AI");
  428.  
  429. 		// 邮件内容
  430. 		mail.setContent("你的验证码为:<a>fds</a>", "text/html; charset=UTF-8");
  431.  
  432. 		// 附件集合
  433. 		List<String> fileList = new ArrayList<String>();
  434.  
  435. 		// 添加附件
  436. 		fileList.add("D:1.jpg");
  437. 		mail.setMultiparts(fileList);
  438.  
  439. 		mail.sendMessage(); // 是否发送成功
  440. 	}
  441. }

我将代码整理了一下封装了简单的发生方法

  1. package com.yunhe.day1023;
  2.  
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.io.UnsupportedEncodingException;
  6. import java.text.SimpleDateFormat;
  7. import java.util.ArrayList;
  8. import java.util.Date;
  9. import java.util.HashMap;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Properties;
  13. import javax.activation.DataHandler;
  14. import javax.activation.DataSource;
  15. import javax.activation.FileDataSource;
  16. import javax.mail.Address;
  17. import javax.mail.Authenticator;
  18. import javax.mail.BodyPart;
  19. import javax.mail.Message;
  20. import javax.mail.MessagingException;
  21. import javax.mail.Multipart;
  22. import javax.mail.PasswordAuthentication;
  23. import javax.mail.Session;
  24. import javax.mail.Transport;
  25. import javax.mail.internet.AddressException;
  26. import javax.mail.internet.InternetAddress;
  27. import javax.mail.internet.MimeBodyPart;
  28. import javax.mail.internet.MimeMessage;
  29. import javax.mail.internet.MimeMultipart;
  30. import javax.mail.internet.MimeUtility;
  31.  
  32. /**
  33.  *
  34.  * 项目名称：JavaMail 类名称：SendMail 类描述： 创建人：Ai 创建时间：2018年5月2日 下午3:49:45 修改人：Ai
  35.  * 修改时间：2018年5月2日 下午3:49:45 修改备注：javaMail封装代码
  36.  * 
  37.  * @version JM-0.1
  38.  *
  39.  */
  40. /**
  41.  * @author Administrator
  42.  *
  43.  */
  44. /**
  45.  * @author Administrator
  46.  *
  47.  */
  48. public class SendMail {
  49. 	private final String username = ""; // 发送邮件的邮箱
  50. 	private final String password = "";// 发送邮箱的授权码
  51. 	private Authenticator auth = null;
  52. 	private MimeMessage mimeMessage = null;
  53. 	private Properties pros = null;
  54. 	private Multipart multipart = null;
  55. 	private BodyPart bodypart = null;
  56.  
  57. 	/**
  58. 	 * 初始化账号密码并验证 创建MimeMessage对象 发送邮件必须的步骤:1
  59. 	 * 
  60. 	 * @param username
  61. 	 * @param password
  62. 	 */
  63. 	public SendMail() {
  64. 		Map<String, String> map = new HashMap<String, String>();
  65. 		// 你的发送邮箱账号 POP3/SMTP服务 授权码
  66. 		map.put("mail.smtp.host", "smtp.qq.com");
  67. 		map.put("mail.smtp.auth", "true");
  68. 		map.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
  69. 		map.put("mail.smtp.port", "465");
  70. 		map.put("mail.smtp.socketFactory.port", "465");
  71. 		setPros(map);
  72. 		initMessage();
  73. 	}
  74.  
  75. 	/**
  76. 	 * 设置email系统参数 接收一个map集合key为string类型，值为String 发送邮件必须的步骤:2
  77. 	 * 
  78. 	 * @param map
  79. 	 */
  80. 	public boolean setPros(Map<String, String> map) {
  81. 		pros = new Properties();
  82. 		try {
  83. 			for (Map.Entry<String, String> entry : map.entrySet()) {
  84. 				pros.setProperty(entry.getKey(), entry.getValue());
  85. 			}
  86. 			//System.out.println("设置email参数成功!");
  87. 			return true;
  88. 		} catch (Exception e) {
  89. 			return false;
  90. 		}
  91. 	}
  92.  
  93. 	/**
  94. 	 * 初始化MimeMessage对象 发送邮件必须的步骤:3
  95. 	 */
  96. 	public boolean initMessage() {
  97. 		this.auth = new Email_Autherticator();
  98. 		try {
  99. 			Session session = Session.getDefaultInstance(pros, auth);
  100. 			session.setDebug(false); // 设置获取 debug 信息
  101. 			mimeMessage = new MimeMessage(session);
  102. 			//System.out.println("初始化成功!");
  103. 			return true;
  104. 		} catch (Exception e) {
  105. 			return false;
  106. 		}
  107. 	}
  108.  
  109. 	/**
  110. 	 * 验证账号密码 发送邮件必须的步骤
  111. 	 * 
  112. 	 * @author Administrator
  113. 	 *
  114. 	 */
  115. 	public class Email_Autherticator extends Authenticator {
  116. 		public PasswordAuthentication getPasswordAuthentication() {
  117. 			return new PasswordAuthentication(username, password);
  118. 		}
  119. 	}
  120.  
  121. 	/**
  122. 	 * 设置发送邮件的基本参数(去除繁琐的邮件设置)
  123. 	 * 
  124. 	 * @param sub
  125. 	 *            设置邮件主题
  126. 	 * @param text
  127. 	 *            设置邮件文本内容
  128. 	 * @param rec
  129. 	 *            设置邮件接收人
  130. 	 * @throws MessagingException
  131. 	 * @throws UnsupportedEncodingException
  132. 	 */
  133. 	public boolean setDefaultMessagePros(String sub, String text, String rec)
  134. 			throws MessagingException, UnsupportedEncodingException {
  135. 		try {
  136. 			mimeMessage.setSubject(sub);
  137. 			mimeMessage.setText(text);
  138. 			mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(rec));
  139. 			mimeMessage.setSentDate(new Date());
  140. 			mimeMessage.setFrom(new InternetAddress(username, username));
  141. 			//System.out.println("设置邮件发送基本参数成功!（主题、内容、接收人）");
  142. 			return true;
  143. 		} catch (Exception e) {
  144. 			return false;
  145. 		}
  146. 	}
  147.  
  148. 	/**
  149. 	 * 设置主题
  150. 	 * 
  151. 	 * @param subject
  152. 	 * @throws MessagingException
  153. 	 */
  154. 	public boolean setSubject(String subject) throws MessagingException {
  155. 		try {
  156. 			mimeMessage.setSubject(subject);
  157. 			//System.out.println("设置邮件主题[" + subject + "]成功!");
  158. 			return true;
  159. 		} catch (Exception e) {
  160. 			return false;
  161. 		}
  162. 	}
  163.  
  164. 	/**
  165. 	 * 设置日期
  166. 	 * 
  167. 	 * @param date
  168. 	 *            邮件发送的日期
  169. 	 * @throws MessagingException
  170. 	 */
  171. 	public boolean setDate(Date date) throws MessagingException {
  172.  
  173. 		try {
  174. 			mimeMessage.setSentDate(date);
  175. 			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  176. 			String format = sdf.format(date);
  177. 			//System.out.println("设置邮件发送日期[" + format + "]成功!");
  178. 			return true;
  179. 		} catch (Exception e) {
  180.  
  181. 			return false;
  182. 		}
  183. 	}
  184.  
  185. 	/**
  186. 	 * 设置日期
  187. 	 * 
  188. 	 * @param millisecond
  189. 	 *            邮件延时发送时间(毫秒) //暂不好使
  190. 	 * @throws MessagingException
  191. 	 */
  192. 	public boolean setDate(long millisecond) throws MessagingException {
  193. 		Date date = new Date();
  194. 		//System.out.println(date);
  195. 		date.setTime(date.getTime() + millisecond);
  196. 		try {
  197. 			mimeMessage.setSentDate(date);
  198. 			//System.out.println("设置邮件发送延时[" + millisecond + "]毫秒成功!");
  199. 		} catch (Exception e) {
  200. 			//System.out.println("设置邮件发送日期[" + millisecond + "]失败!");
  201. 			return false;
  202. 		}
  203. 		return true;
  204.  
  205. 	}
  206.  
  207. 	/**
  208. 	 * 设置邮件接收人地址 <单人发送>
  209. 	 * 
  210. 	 * @param recipient
  211. 	 * @throws MessagingException
  212. 	 */
  213. 	public boolean setRecipient(String recipient) throws MessagingException {
  214. 		try {
  215. 			if (recipient.isEmpty()) {
  216. 				//System.out.println("接收人地址为空!");
  217. 				return false;
  218. 			} else {
  219. 				mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(recipient));
  220. 				//System.out.println("设置接收人地址为[" + recipient + "]成功!");
  221. 				return true;
  222. 			}
  223. 		} catch (Exception e) {
  224. 			return false;
  225. 		}
  226. 	}
  227.  
  228. 	/**
  229. 	 * 设置邮件接收人地址 <多人发送>
  230. 	 * 
  231. 	 * @param list
  232. 	 * @throws MessagingException
  233. 	 * @throws AddressException
  234. 	 */
  235. 	public boolean setRecipients(List<String> recs) throws AddressException, MessagingException {
  236. 		try {
  237. 			if (recs.isEmpty()) {
  238. 				//System.out.println("接收人地址为空!");
  239. 				return false;
  240. 			}
  241. 			for (String str : recs) {
  242. 				mimeMessage.addRecipient(Message.RecipientType.TO, new InternetAddress(str));
  243. 			}
  244. 			//System.out.println("设置接收人地址" + recs + "成功!");
  245. 			return true;
  246. 		} catch (Exception e) {
  247. 			return false;
  248. 		}
  249. 	}
  250.  
  251. 	/**
  252. 	 * 设置邮件接收人地址 <多人发送>
  253. 	 * 
  254. 	 * @param StringBuffer<parms,parms2,parms.....>
  255. 	 * @throws MessagingException
  256. 	 * @throws AddressException
  257. 	 */
  258. 	@SuppressWarnings("static-access")
  259. 	public boolean setRecipients(StringBuffer sb) throws AddressException, MessagingException {
  260. 		try {
  261. 			if (sb == null || "".equals(sb)) {
  262. 				//System.out.println("字符串数据为空!");
  263. 				return false;
  264. 			}
  265. 			Address[] address = new InternetAddress().parse(sb.toString());
  266. 			mimeMessage.addRecipients(Message.RecipientType.TO, address);
  267. 			//System.out.println("设置接收人地址[" + sb + "]成功!");
  268. 			return true;
  269. 		} catch (Exception e) {
  270. 			return false;
  271. 		}
  272. 	}
  273.  
  274. 	/**
  275. 	 * 设置邮件发送人的名字
  276. 	 * 
  277. 	 * @param from
  278. 	 * @throws UnsupportedEncodingException
  279. 	 * @throws MessagingException
  280. 	 */
  281. 	public boolean setFrom(String from) throws UnsupportedEncodingException, MessagingException {
  282. 		try {
  283. 			if (from.isEmpty()) {
  284. 				//System.out.println("邮件发送人名字为空!");
  285. 				return false;
  286. 			} else {
  287. 				mimeMessage.setFrom(new InternetAddress(username, from));
  288. 				//System.out.println("设置邮件发送人名字[" + from + "]成功!");
  289. 				return true;
  290. 			}
  291. 		} catch (Exception e) {
  292. 			return false;
  293. 		}
  294. 	}
  295.  
  296. 	/**
  297. 	 * 发送邮件<单人发送> return 是否发送成功
  298. 	 * 
  299. 	 * @throws MessagingException
  300. 	 *             发送异常
  301. 	 */
  302. 	public boolean sendMessage() {
  303. 		try {
  304. 			Transport.send(mimeMessage);
  305. 			System.out.println("----------------发送成功----------------");
  306. 			return true;
  307. 		} catch (MessagingException e) {
  308. 			return false;
  309. 		}
  310. 	}
  311.  
  312. 	/**
  313. 	 * 设置附件
  314. 	 * 
  315. 	 * @param file
  316. 	 *            发送文件的路径
  317. 	 * @throws MessagingException
  318. 	 *             发送异常
  319. 	 * @throws IOException
  320. 	 *             文件IO异常
  321. 	 * 
  322. 	 */
  323. 	public boolean setMultipart(String file) throws MessagingException, IOException {
  324. 		try {
  325. 			if (multipart == null) {
  326. 				multipart = new MimeMultipart();
  327. 			}
  328. 			multipart.addBodyPart(writeFiles(file));
  329. 			mimeMessage.setContent(multipart);
  330. 			//System.out.println("设置邮件附件" + file + "成功!");
  331. 			return true;
  332. 		} catch (Exception e) {
  333. 			return false;
  334. 		}
  335. 	}
  336.  
  337. 	/**
  338. 	 * 设置附件<添加多附件>
  339. 	 * 
  340. 	 * @param fileList<接收List集合>
  341. 	 * @throws MessagingException
  342. 	 *             发送异常
  343. 	 * @throws IOException
  344. 	 *             文件IO异常
  345. 	 */
  346. 	public boolean setMultiparts(List<String> fileList) throws MessagingException, IOException {
  347. 		try {
  348. 			if (multipart == null) {
  349. 				multipart = new MimeMultipart();
  350. 			}
  351. 			for (String s : fileList) {
  352. 				multipart.addBodyPart(writeFiles(s));
  353. 			}
  354. 			mimeMessage.setContent(multipart);
  355. 			//System.out.println("设置邮件附件" + fileList + "成功!");
  356. 			return true;
  357. 		} catch (Exception e) {
  358. 			return false;
  359. 		}
  360. 	}
  361.  
  362. 	/**
  363. 	 * 发送文本内容，设置编码方式 <方法与发送附件配套使用> <发送普通的文本内容请使用setText()方法>
  364. 	 * 
  365. 	 * @param s
  366. 	 *            发送的文本内容
  367. 	 * @param type
  368. 	 *            编码格式
  369. 	 * @throws MessagingException
  370. 	 */
  371. 	public boolean setContent(String s, String type) throws MessagingException {
  372. 		try {
  373. 			if (multipart == null) {
  374. 				multipart = new MimeMultipart();
  375. 			}
  376. 			bodypart = new MimeBodyPart();
  377. 			bodypart.setContent(s, type);
  378. 			multipart.addBodyPart(bodypart);
  379. 			mimeMessage.setContent(multipart);
  380. 			mimeMessage.saveChanges();
  381. 			//System.out.println("设置邮件内容[" + s + "]成功!");
  382. 			return true;
  383. 		} catch (Exception e) {
  384. 			return false;
  385. 		}
  386. 	}
  387.  
  388. 	/**
  389. 	 * 读取附件
  390. 	 * 
  391. 	 * @param filePath
  392. 	 *            文件路径
  393. 	 * @return
  394. 	 * @throws IOException
  395. 	 * @throws MessagingException
  396. 	 */
  397. 	public BodyPart writeFiles(String filePath) throws IOException, MessagingException {
  398. 		File file = new File(filePath);
  399. 		if (!file.exists()) {
  400. 			throw new IOException("文件不存在!请确定文件路径是否正确");
  401. 		}
  402. 		bodypart = new MimeBodyPart();
  403. 		DataSource dataSource = new FileDataSource(file);
  404. 		bodypart.setDataHandler(new DataHandler(dataSource));
  405. 		// 文件名要加入编码，不然出现乱码
  406. 		bodypart.setFileName(MimeUtility.encodeText(file.getName()));
  407. 		return bodypart;
  408. 	}
  409.  
  410. 	//带附件集合发生方法
  411. 	public boolean send(String getMail, String subject, String nick, String content, List<String> fileList) {
  412. 		try {
  413. 			setRecipient(getMail); // 输出信息
  414. 			// 邮件主题
  415. 			setSubject(subject);
  416. 			// 发送时间 Date类型(默认即时发送)
  417. 			setDate(new Date());
  418. 			// 发送者昵称
  419. 			setFrom(nick);
  420. 			// 邮件内容
  421. 			setContent(content, "text/html; charset=UTF-8");
  422. 			// 添加附件
  423. 			setMultiparts(fileList);
  424. 		} catch (Exception e) {
  425. 			return false;
  426. 		}
  427. 		return sendMessage(); // 是否发送成功;
  428. 	}
  429. 	//不带附件集合发生方法
  430. 	public boolean send(String getMail, String subject, String nick, String content) {
  431.  
  432. 		try {
  433. 			setRecipient(getMail); // 输出信息
  434. 			// 邮件主题
  435. 			setSubject(subject);
  436. 			// 发送时间 Date类型(默认即时发送)
  437. 			setDate(new Date());
  438. 			// 发送者昵称
  439. 			setFrom(nick);
  440. 			// 邮件内容
  441. 			setContent(content, "text/html; charset=UTF-8");
  442. 		} catch (Exception e) {
  443. 			return false;
  444. 		}
  445. 		return sendMessage(); // 是否发送成功;
  446. 	}
  447. 	// ----------------------------------------------------------------------------------------------------------------------------
  448. 	public static void main(String[] args) throws MessagingException, IOException {
  449. 		SendMail mail = new SendMail();
  450. 		mail.send("868626@qq.com", "aaaa", "bbb","hello!");
  451.  
  452. 	}
  453.  
  454. 	
  455. }

 

加载全部内容
相关教程
猜你喜欢
用户评论