基于smtp协议的邮件系统（自己写的）

2022-01-08 20:28:07

最近几天做好了应用【贱泰迪】，其中有个意见反馈，发送邮件，
我知道可以调用系统发送邮件，但这种方法有个弊端，就是您的手机必须安装Mail的客户端，
因此我想不用系统发送邮件这种方式，能不能向任意邮箱发送邮件呢？给我自己丢下了一个命题。
于是我调查，发现SMTP发送email 无需系统支持,无需配置，
经过多次尝试，多次失败，终于完成了此项功能。
先来看应用【贱泰迪】的效果，
基于smtp协议的邮件系统（自己写的）

填写您的邮箱、密码等，我就能收到您的反馈意见，是不是很方便呢，
更多的效果，您可以下载贱泰迪（http://down.mumayi.com/464309）查看。
此贴，讲这个功能给扣出来了，并附上其他的两种方法发送邮件。
效果图如下：
基于smtp协议的邮件系统（自己写的）基于smtp协议的邮件系统（自己写的）

1、使用Mail客户端发送邮件
这种方法前提您的手机必须安装Mail客户端，您可以测试的时候下载QQ邮箱客户端，看看运行的效果。
  1. case R.id.button1:
  2.                         // 创建Intent
  3.                         Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
  4.                         // 设置内容类型
  5.                         emailIntent.setType("plain/text");
  6.                         // 设置额外信息
  7.                         emailIntent.putExtra(android.content.Intent.EXTRA_EMAIL,
  8.                                         new String[] { "收件人邮箱" });// 比如qq邮箱，测试的时候可以手机安装qq邮箱客户端
  9.                         emailIntent.putExtra(android.content.Intent.EXTRA_SUBJECT, "主题");
  10.                         emailIntent.putExtra(android.content.Intent.EXTRA_TEXT, "内容");
  11.                         // 启动Activity
  12.                         startActivity(Intent.createChooser(emailIntent, "发送邮件..."));
  13.                         break;
复制代码

2、使用SMTP发送邮件
这是此贴的重点所在，SMTP的全称是“Simple Mail Transfer Protocol”，即简单邮件传输协议。
它是一组用于从源地址到目的地址传输邮件的规范，通过它来控制邮件的中转方式。
SMTP 协议属于 TCP/IP 协议簇，它帮助每台计算机在发送或中转信件时找到下一个目的地。
SMTP 服务器就是遵循 SMTP 协议的发送邮件服务器。
它需要三个jar包，下载地址：https://code.google.com/p/javamail-android/downloads/list
下载后复制libs，即可。
下面介绍两种方法实现使用SMTP发送邮件
（1）方法一
  1. case R.id.button2:
  2.                         new Thread() {
  3.                                 @Override
  4.                                 public void run() {
  5.                                         EmailSender sender = new EmailSender();
  6.                                         // 设置服务器地址和端口，网上搜的到
  7.                                         sender.setProperties("smtp.qq.com", "465");
  8.                                         // 分别设置发件人，邮件标题和文本内容
  9.                                         try {
  10.                                                 sender.setMessage("发件人邮箱", "主题主题1", "内容内容1");
  11.                                                 sender.setReceiver(new String[] { "收件人邮箱" });
  12.                                                 sender.sendEmail("smtp.qq.com", "发件人邮箱", "发件人邮箱密码");
  13.                                         } catch (AddressException e) {
  14.                                                 e.printStackTrace();
  15.                                                 Log.e("wxl", "AddressException", e);
  16.                                         } catch (MessagingException e) {
  17.                                                 e.printStackTrace();
  18.                                                 Log.e("wxl", "MessagingException", e);
  19.                                         }
  20.                                 }
  21.                         }.start();

  23.                         break;
复制代码

这里需要EmailSender.java
  1. package com.xiaomolong.example.smtpmail;

  3. import java.io.File;
  4. import java.util.Date;
  5. import java.util.Properties;
  6. import javax.activation.DataHandler;
  7. import javax.activation.FileDataSource;
  8. import javax.mail.Address;
  9. import javax.mail.Message;
  10. import javax.mail.MessagingException;
  11. import javax.mail.Session;
  12. import javax.mail.Transport;
  13. import javax.mail.internet.AddressException;
  14. import javax.mail.internet.InternetAddress;
  15. import javax.mail.internet.MimeBodyPart;
  16. import javax.mail.internet.MimeMessage;
  17. import javax.mail.internet.MimeMultipart;

  19. public class EmailSender {
  20.         private Properties properties;
  21.         private Session session;
  22.         private Message message;
  23.         private MimeMultipart multipart;

  25.         public EmailSender() {
  26.                 super();
  27.                 this.properties = new Properties();
  28.         }

  30.         public void setProperties(String host, String post) {
  31.                 // 地址
  32.                 this.properties.put("mail.smtp.host", host);
  33.                 // 端口号
  34.                 this.properties.put("mail.smtp.post", post);
  35.                 // 是否验证
  36.                 this.properties.put("mail.smtp.auth", true);
  37.                 this.session = Session.getInstance(properties);
  38.                 this.message = new MimeMessage(session);
  39.                 this.multipart = new MimeMultipart("mixed");
  40.         }

  42.         /**
  43.          * 设置收件人
  44.          *
  45.          * @param receiver
  46.          * @throws MessagingException
  47.          */
  48.         public void setReceiver(String[] receiver) throws MessagingException {
  49.                 Address[] address = new InternetAddress[receiver.length];
  50.                 for (int i = 0; i < receiver.length; i++) {
  51.                         address[i] = new InternetAddress(receiver[i]);
  52.                 }
  53.                 this.message.setRecipients(Message.RecipientType.TO, address);
  54.         }

  56.         /**
  57.          * 设置邮件
  58.          *
  59.          * @param from
  60.          *            来源
  61.          * @param title
  62.          *            标题
  63.          * @param content
  64.          *            内容
  65.          * @throws AddressException
  66.          * @throws MessagingException
  67.          */
  68.         public void setMessage(String from, String title, String content)
  69.                         throws AddressException,

  71.                         MessagingException {
  72.                 this.message.setFrom(new InternetAddress(from));
  73.                 this.message.setSubject(title);
  74.                 // 纯文本的话用setText()就行，不过有附件就显示不出来内容了
  75.                 MimeBodyPart textBody = new MimeBodyPart();
  76.                 textBody.setContent(content, "text/html;charset=gbk");
  77.                 this.multipart.addBodyPart(textBody);
  78.         }

  80.         /**
  81.          * 添加附件
  82.          *
  83.          * @param filePath
  84.          *            文件路径
  85.          * @throws MessagingException
  86.          */
  87.         public void addAttachment(String filePath) throws MessagingException {
  88.                 FileDataSource fileDataSource = new FileDataSource(new File(filePath));
  89.                 DataHandler dataHandler = new DataHandler(fileDataSource);
  90.                 MimeBodyPart mimeBodyPart = new MimeBodyPart();
  91.                 mimeBodyPart.setDataHandler(dataHandler);
  92.                 mimeBodyPart.setFileName(fileDataSource.getName());
  93.                 this.multipart.addBodyPart(mimeBodyPart);
  94.         }

  96.         /**
  97.          * 发送邮件
  98.          *
  99.          * @param host
  100.          *            地址
  101.          * @param account
  102.          *            账户名
  103.          * @param pwd
  104.          *            密码
  105.          * @throws MessagingException
  106.          */
  107.         public void sendEmail(String host, String account, String pwd)
  108.                         throws MessagingException {
  109.                 // 发送时间
  110.                 this.message.setSentDate(new Date());
  111.                 // 发送的内容，文本和附件
  112.                 this.message.setContent(this.multipart);
  113.                 this.message.saveChanges();
  114.                 // 创建邮件发送对象，并指定其使用SMTP协议发送邮件
  115.                 Transport transport = session.getTransport("smtp");
  116.                 // 登录邮箱
  117.                 transport.connect(host, account, pwd);
  118.                 // 发送邮件
  119.                 transport.sendMessage(message, message.getAllRecipients());
  120.                 // 关闭连接
  121.                 transport.close();
  122.         }
  123. }
复制代码

（2）方法二
  1. case R.id.button3:
  2.                         new SendTask().execute();
  3.                         break;
复制代码
  1. class SendTask extends AsyncTask<Integer, Integer, String> {
  2.                 // 后面尖括号内分别是参数（例子里是线程休息时间），进度(publishProgress用到)，返回值 类型

  4.                 @Override
  5.                 protected void onPreExecute() {
  6.                         // 第一个执行方法

  8.                         super.onPreExecute();
  9.                 }

  11.                 @Override
  12.                 protected String doInBackground(Integer... params) {
  13.                         // contact, contactPsw, title, content;
  14.                         String isok = "";
  15.                         Mails m = new Mails("发件人邮箱", "发件人邮箱密码");
  16.                         m.set_debuggable(false);
  17.                         String[] toArr = { "收件人邮箱" };
  18.                         m.set_to(toArr);
  19.                         m.set_from("发件人邮箱");
  20.                         m.set_subject("主题主题2");
  21.                         m.setBody("内容内容2");
  22.                         try {
  23.                                 // m.addAttachment("/sdcard/filelocation");
  24.                                 if (m.send()) {

  26.                                         isok = "ok";
  27.                                 } else {
  28.                                         isok = "no";

  30.                                 }
  31.                         } catch (Exception e) {
  32.                                 Log.e("wxl", "Could not send email", e);
  33.                         }
  34.                         return isok;
  35.                 }

  37.                 @Override
  38.                 protected void onProgressUpdate(Integer... progress) {
  39.                         // 这个函数在doInBackground调用publishProgress时触发，虽然调用时只有一个参数
  40.                         // 但是这里取到的是一个数组,所以要用progesss[0]来取值
  41.                         // 第n个参数就用progress[n]来取值

  43.                         super.onProgressUpdate(progress);
  44.                 }

  46.                 @Override
  47.                 protected void onPostExecute(String result) {
  48.                         // doInBackground返回时触发，换句话说，就是doInBackground执行完后触发
  49.                         // 这里的result就是上面doInBackground执行后的返回值，所以这里是"执行完毕"
  50.                         // setTitle(result);
  51.                         if ("ok".equals(result)) {
  52.                                 Toast.makeText(getApplicationContext(), "发送成功",
  53.                                                 Toast.LENGTH_SHORT).show();
  54.                         } else {
  55.                                 Toast.makeText(getApplicationContext(), "发送失败",
  56.                                                 Toast.LENGTH_SHORT).show();
  57.                         }
  58.                         super.onPostExecute(result);
  59.                 }

  61.         }
复制代码

这里需要Mails.java
  1. package com.xiaomolong.example.smtpmail;

  3. import java.util.Date;
  4. import java.util.Properties;

  6. import javax.activation.CommandMap;
  7. import javax.activation.DataHandler;
  8. import javax.activation.DataSource;
  9. import javax.activation.FileDataSource;
  10. import javax.activation.MailcapCommandMap;
  11. import javax.mail.BodyPart;
  12. import javax.mail.Multipart;
  13. import javax.mail.PasswordAuthentication;
  14. import javax.mail.Session;
  15. import javax.mail.Transport;
  16. import javax.mail.internet.InternetAddress;
  17. import javax.mail.internet.MimeBodyPart;
  18. import javax.mail.internet.MimeMessage;
  19. import javax.mail.internet.MimeMultipart;

  21. public class Mails extends javax.mail.Authenticator {
  22.         private String _user;
  23.         private String _pass;
  24.         private String[] _to;
  25.         private String _from;
  26.         private String _port;
  27.         private String _sport;
  28.         private String _host;
  29.         private String _subject;
  30.         private String _body;
  31.         private boolean _auth;
  32.         private boolean _debuggable;
  33.         private Multipart _multipart;

  35.         public Mails() {
  36.                 _host = "smtp.qq.com"; // default smtp server
  37.                 _port = "465"; // default smtp port
  38.                 _sport = "465"; // default socketfactory port
  39.                 _user = ""; // username _pass = ""; // password
  40.                 _from = ""; // email sent from
  41.                 _subject = ""; // email subject
  42.                 _body = ""; // email body
  43.                 _debuggable = false; // debug mode on or off - default off
  44.                 _auth = true; // smtp authentication - default on
  45.                 _multipart = new MimeMultipart(); // There is something wrong with
  46.                                                                                         // MailCap, javamail can not find a
  47.                                                                                         // handler for the multipart/mixed
  48.                                                                                         // part, so this bit needs to be
  49.                                                                                         // added.
  50.                 MailcapCommandMap mc = (MailcapCommandMap) CommandMap
  51.                                 .getDefaultCommandMap();
  52.                 mc.addMailcap("text/html;; x-java-content-handler=com.sun.mail.handlers.text_html");
  53.                 mc.addMailcap("text/xml;; x-java-content-handler=com.sun.mail.handlers.text_xml");
  54.                 mc.addMailcap("text/plain;; x-java-content-handler=com.sun.mail.handlers.text_plain");
  55.                 mc.addMailcap("multipart/*;; x-java-content-handler=com.sun.mail.handlers.multipart_mixed");
  56.                 mc.addMailcap("message/rfc822;; x-java-content-handler=com.sun.mail.handlers.message_rfc822");
  57.                 CommandMap.setDefaultCommandMap(mc);
  58.         }

  60.         public String get_user() {
  61.                 return _user;
  62.         }

  64.         public void set_user(String _user) {
  65.                 this._user = _user;
  66.         }

  68.         public String get_pass() {
  69.                 return _pass;
  70.         }

  72.         public void set_pass(String _pass) {
  73.                 this._pass = _pass;
  74.         }

  76.         public String[] get_to() {
  77.                 return _to;
  78.         }

  80.         public void set_to(String[] _to) {
  81.                 this._to = _to;
  82.         }

  84.         public String get_from() {
  85.                 return _from;
  86.         }

  88.         public void set_from(String _from) {
  89.                 this._from = _from;
  90.         }

  92.         public String get_port() {
  93.                 return _port;
  94.         }

  96.         public void set_port(String _port) {
  97.                 this._port = _port;
  98.         }

  100.         public String get_sport() {
  101.                 return _sport;
  102.         }

  104.         public void set_sport(String _sport) {
  105.                 this._sport = _sport;
  106.         }

  108.         public String get_host() {
  109.                 return _host;
  110.         }

  112.         public void set_host(String _host) {
  113.                 this._host = _host;
  114.         }

  116.         public String get_subject() {
  117.                 return _subject;
  118.         }

  120.         public void set_subject(String _subject) {
  121.                 this._subject = _subject;
  122.         }

  124.         public String get_body() {
  125.                 return _body;
  126.         }

  128.         public void set_body(String _body) {
  129.                 this._body = _body;
  130.         }

  132.         public boolean is_auth() {
  133.                 return _auth;
  134.         }

  136.         public void set_auth(boolean _auth) {
  137.                 this._auth = _auth;
  138.         }

  140.         public boolean is_debuggable() {
  141.                 return _debuggable;
  142.         }

  144.         public void set_debuggable(boolean _debuggable) {
  145.                 this._debuggable = _debuggable;
  146.         }

  148.         public Multipart get_multipart() {
  149.                 return _multipart;
  150.         }

  152.         public void set_multipart(Multipart _multipart) {
  153.                 this._multipart = _multipart;
  154.         }

  156.         public Mails(String user, String pass) {
  157.                 this();
  158.                 _user = user;
  159.                 _pass = pass;
  160.         }

  162.         public boolean send() throws Exception {
  163.                 Properties props = _setProperties();
  164.                 if (!_user.equals("") && !_pass.equals("") && _to.length > 0
  165.                                 && !_from.equals("") && !_subject.equals("")
  166.                                 && !_body.equals("")) {
  167.                         Session session = Session.getInstance(props, this);
  168.                         MimeMessage msg = new MimeMessage(session);
  169.                         msg.setFrom(new InternetAddress(_from));
  170.                         InternetAddress[] addressTo = new InternetAddress[_to.length];
  171.                         for (int i = 0; i < _to.length; i++) {
  172.                                 addressTo[i] = new InternetAddress(_to[i]);
  173.                         }
  174.                         msg.setRecipients(MimeMessage.RecipientType.TO, addressTo);
  175.                         msg.setSubject(_subject);
  176.                         msg.setSentDate(new Date()); // setup message body
  177.                         BodyPart messageBodyPart = new MimeBodyPart();
  178.                         messageBodyPart.setText(_body);
  179.                         _multipart.addBodyPart(messageBodyPart); // Put parts in message
  180.                         msg.setContent(_multipart); // send email
  181.                         Transport.send(msg);
  182.                         return true;
  183.                 } else {
  184.                         return false;
  185.                 }
  186.         }

  188.         public void addAttachment(String filename) throws Exception {
  189.                 BodyPart messageBodyPart = new MimeBodyPart();
  190.                 DataSource source = new FileDataSource(filename);
  191.                 messageBodyPart.setDataHandler(new DataHandler(source));
  192.                 messageBodyPart.setFileName(filename);
  193.                 _multipart.addBodyPart(messageBodyPart);
  194.         }

  196.         @Override
  197.         public PasswordAuthentication getPasswordAuthentication() {
  198.                 return new PasswordAuthentication(_user, _pass);
  199.         }

  201.         private Properties _setProperties() {
  202.                 Properties props = new Properties();
  203.                 props.put("mail.smtp.host", _host);
  204.                 if (_debuggable) {
  205.                         props.put("mail.debug", "true");
  206.                 }
  207.                 if (_auth) {
  208.                         props.put("mail.smtp.auth", "true");
  209.                 }
  210.                 props.put("mail.smtp.port", _port);
  211.                 props.put("mail.smtp.socketFactory.port", _sport);
  212.                 props.put("mail.smtp.socketFactory.class",
  213.                                 "javax.net.ssl.SSLSocketFactory");
  214.                 props.put("mail.smtp.socketFactory.fallback", "false");
  215.                 return props;
  216.         } // the getters and setters

  218.         public String getBody() {
  219.                 return _body;
  220.         }

  222.         public void setBody(String _body) {

  224.                 this._body = _body;
  225.         } // more of the getters and setters 锟斤拷.. }
  226. }

复制代码

代码粘完了，这里采用了线程和异步，对于新手可以学学。【贱泰迪】采用的是第二种方法。
下面开始说一下注意点：
首先加上联网的权限，<uses-permission android:name="android.permission.INTERNET" />，这是小问题
以上代码完成没有问题，但是运行会抛这样的异常：
基于smtp协议的邮件系统（自己写的）

这是为什么，使用SMTP来发送E-mail，因此您的邮箱必须开启此项服务,
【QQ邮箱】【设置】【账户】【POP3/IMAP/SMTP/Exchange/CardDAV/CalDAV服务】如下图：
基于smtp协议的邮件系统（自己写的）

基于smtp协议的邮件系统（自己写的）


最后附上下载地址：http://download.csdn.net/detail/xiangzhihong8/6661655

上一篇：手机卫士04-自定义显示图片


下一篇：10倍处理能力 阿里云推云上首个支持12层4K非编NAS产品