1. 电子邮件服务器：这些邮件服务器就类似于邮局，它主要负责接收用户投递过来的邮件，并把邮件投递到邮件接收者的电子邮箱中，按功能划分有两种类型
    • SMTP邮件服务器：用户替用户发送邮件和接收外面发送给本地用户的邮件
    • POP3/IMAP邮件服务器：用户帮助用户读取SMTP邮件服务器接收进来的邮件
  2. 邮件传输协议：电子邮件需要在邮件客户端和邮件服务器之间，以及两个邮件服务器之间进行邮件传递，就需遵守一定的规则
    • SMTP协议：全称为 Simple Mail Transfer Protocol，简单邮件传输协议。它定义了邮件客户端软件和SMTP邮件服务器之间，以及两台SMTP邮件服务器之间的通信规则
    • POP3协议：全称为 Post Office Protocol，邮局协议。它定义了邮件客户端软件和POP3邮件服务器的通信规则
    • IMAP协议：全称为 Internet Message Access Protocol,Internet消息访问协议，它是对POP3协议的一种扩展，也是定义了邮件客户端软件和IMAP邮件服务器的通信规则
  3. 邮件格式：邮件内容的基本格式和具体细节分别是由 RFC822 文档和 MIME 协议定义的
    • RFC822文档中定义的文件格式包括两个部分：邮件头和邮件体
    • ME协议(Multipurpose Internet Mail Extensions )用于定义复杂邮件体的格式，使邮件的内容更加多样化
  4. 邮件发送与接收流程

      • 邮件客户端软件写好一封邮件，交到SMTP的QQ邮件服务器
      • QQ邮箱会解析用户发送的邮件，判断收件地址是否是自己的账户，如果收件也是QQ邮箱，会直接存放到自己的存储空间。如果不是QQ邮箱，而是163邮箱，那么QQ邮箱会将邮件转发到163邮箱服务器，转发协议也是SMTP
      • 163邮箱服务器接收到QQ邮箱转发过来的邮件，会判断收件地址是否是自己的，如果是自己的账户，就会将QQ邮箱转发过来的邮件存放到自己的内部存储空间
      • 用户A将邮件发送了之后，通知用户B去指定的邮箱收取邮件。用户B会通过邮件客户端软件先向163邮箱服务器请求，要求收取自己的邮件
      • 163邮箱服务器收到用户B的请求后，会从自己的存储空间中取出B未收取的邮件
      • 163邮箱服务器取出用户B未收取的邮件后，将邮件发给用户B，最后三步用户B收取邮件的过程，使用的协议是POP3

  • 使用之前应该申请qq邮箱的授权码（第三方的使用时，替代密码）

  • qq邮箱邮件服务器地址和端口（smtp.qq.com 端口465或587）

  • 导入依赖

    1. <!--发送邮件的jar 1.4 版本会出现javamail.providers 文件找不见 与其他jar包中文件冲突-->
    2. <dependency>
    3.    <groupId>javax.mail</groupId>
    4.    <artifactId>mail</artifactId>
    5. <version>1.4.4</version>
    6. </dependency>

  1. 邮件的基本信息类

    1. @Data
    2. public class JavaMailInfo {
    4.    /**
    5.     * 使用java mail 发送邮件 邮件的协议有SMTP POP IMAP MIME 等 协议具体内容可自行百度  SMTP 为简单邮件传输协议 比较常用
    6.     */
    8.    // 邮件服务器地址
    9.    private String mailSeverHost;
    11.    // 邮件服务器端口
    12.    private String mailServerPort;
    14.    // 邮件发送者
    15.    private String fromAddress;
    17.    // 发送者用户名
    18.    private String userName;
    20.    // 发送者密码
    21.    private String password;
    23.    // 收件人地址
    24.    private String toAddress;
    26.    // 邮件主题
    27.    private String subject;
    29.    // 邮件内容
    30.    private String content;
    32.    // 图片地址集合
    33.    private List<String> photoUrlList;
    35.    // 附件地址集合
    36.    private List<String> attachList;
    38.    /**
    39.     * 获取邮件会话属性 ，对邮件Session进行设置 此部分的内容可以通过加载配置文件的方式进行设置
    40.     * @return
    41.     */
    42.    public Properties getProperties() {
    43.        Properties properties = new Properties();
    44.        properties.put("mail.transport.protocol", "smtp");// 连接协议
    45.        properties.put("mail.smtp.host", this.mailSeverHost);// 主机名
    46.        properties.put("mail.smtp.port", this.mailServerPort);// 端口号
    47.        properties.put("mail.smtp.auth", "true");//设置smtp是否需要认证
    48.        properties.put("mail.smtp.ssl.enable", "true");// 设置是否使用ssl安全连接 ---一般都使用
    49.        properties.put("mail.debug", "true");// 设置是否显示debug信息 true 会在控制台显示相关信息
    50.        properties.put("mail.smtp.timeout", 20000);// 超时时间
    51.        return properties;
    52.    }
    54. }

  2. 权限认证类

    1. @Data
    2. @NoArgsConstructor
    3. @AllArgsConstructor
    4. public class MyJavaMailAuthenticator extends Authenticator {
    6.    private String userName = null;
    8.    private String password = null;
    10.    /**
    11.     * 此类用于储存授权时使用的用户名和密码 用于构建邮件Session对象 便于需要认证时邮件Session知道需要使用哪个类验证
    12.     * 以用户名、密码的方式访问那些受到保护的资源，在这里“资源”就是指邮件服务器
    13.     * 自定义的类需要继承Authenticator类 重写getPasswordAuthentication() 方法 注意导包 需要使用javax.mail包下的相关类
    14.     */
    15.    @Override
    16.    protected PasswordAuthentication getPasswordAuthentication() {
    17.        return new PasswordAuthentication(this.userName, this.password);
    18.    }
    19. }

  3. 发送邮件工具类

    1. public class JavaMailSendUtils {
    3.    /**
    4.     * 实际使用
    5.     * @param args
    6.     */
    7.    public static void main(String[] args) {
    8.        JavaMailInfo javaMailInfo = new JavaMailInfo();
    9.        javaMailInfo.setMailSeverHost("smtp.qq.com");
    10.        javaMailInfo.setMailServerPort("465");// 465或587(使用ssl)
    11.        javaMailInfo.setFromAddress("发件人");
    12.        javaMailInfo.setUserName("您邮箱用户名");
    13.        javaMailInfo.setPassword("您邮箱授权码");// 密码需要使用对应邮箱的授权码授权码
    14.        javaMailInfo.setToAddress("收件人");
    15.        javaMailInfo.setSubject("邮件主题");
    16.        javaMailInfo.setContent("邮件内容");
    17.        List<String> photoUrlList = new ArrayList<>();
    18.        photoUrlList.add("图片1");
    19.        photoUrlList.add("图片2");
    20.        javaMailInfo.setPhotoUrlList(photoUrlList);
    21.        List<String> attachList = new ArrayList<>();
    22.        attachList.add("附件1");
    23.        attachList.add("附件2");
    24.        javaMailInfo.setAttachList(attachList);
    25.        sendJavaMail(javaMailInfo);
    26.    }
    28.    /**
    29.     * 此工具类可根据邮件基本信息进行邮件的发送
    30.     */
    32.    /**
    33.     * 发送邮件方法
    34.     * @param javaMailInfo
    35.     * @return
    36.     */
    37.    public static boolean sendJavaMail(JavaMailInfo javaMailInfo) {
    38.        // 获取邮件session的相关配置参数
    39.        Properties properties = javaMailInfo.getProperties();
    40.        // 创建授权验证类
    41.        MyJavaMailAuthenticator myJavaMailAuthenticator = new MyJavaMailAuthenticator();
    42.        myJavaMailAuthenticator.setUserName(javaMailInfo.getUserName());
    43.        myJavaMailAuthenticator.setPassword(javaMailInfo.getPassword());
    44.        // 构建邮件Session会话对象 带不带default均可 查看源码可知 带default的是获取该类的属性 不带获取的是新创建的
    45.        Session mailSession = Session.getDefaultInstance(properties, myJavaMailAuthenticator);
    46.        // 开启debug properties中设置了此处就无须设置
    47.        // mailSession.setDebug(true);
    48.        // 邮差对象 也可使用静态方法进行发送
    49.        Transport transport = null;
    50.        try {
    51.            // 获取消息 也就是发送的内容
    52.            // Message message = createSimpleMail(mailSession, javaMailInfo);
    53.            // Message message = createImageMail(mailSession, javaMailInfo);
    54.            // Message message = createAttachMail(mailSession, javaMailInfo);
    55.            Message message = createPhotoAndAttachMail(mailSession, javaMailInfo);
    56.            // 设置规范 具体是什么规范呢？ 固定写法
    57.            MailcapCommandMap defaultCommandMap = (MailcapCommandMap) CommandMap.getDefaultCommandMap();
    58.            defaultCommandMap.addMailcap("text/html;; x-java-content-handler=com.sun.mail.handlers.text_html");
    59.            defaultCommandMap.addMailcap("text/xml;; x-java-content-handler=com.sun.mail.handlers.text_xml");
    60.            defaultCommandMap.addMailcap("text/plain;; x-java-content-handler=com.sun.mail.handlers.text_plain");
    61.            defaultCommandMap.addMailcap("multipart/*;; x-java-content-handler=com.sun.mail.handlers.multipart_mixed");
    62.            defaultCommandMap.addMailcap("message/rfc822;; x-java-content-handler=com.sun.mail.handlers.message_rfc822");
    63.            CommandMap.setDefaultCommandMap(defaultCommandMap);
    64.            // 发送邮件 Transport.send(message); 或者获取Transport对象发送
    65.            transport = mailSession.getTransport();
    66.            transport.connect(javaMailInfo.getUserName(), javaMailInfo.getUserName());
    67.            transport.sendMessage(message, message.getAllRecipients());
    68.            System.out.println("邮件发送成功");
    69.            return true;
    70.        } catch (MessagingException e) {
    71.            e.printStackTrace();
    72.            System.out.println("邮件发送失败");
    73.            return false;
    74.        } finally {
    75.            if (null != transport) {
    76.                try {
    77.                    transport.close();
    78.                } catch (MessagingException e) {
    79.                    e.printStackTrace();
    80.                }
    81.            }
    82.        }
    83.    }
    85.    /**
    86.     * 根据邮件Session和邮件信息创建邮件内容（文本类 html）
    87.     * @param mailSession
    88.     * @param javaMailInfo
    89.     * @return
    90.     */
    91.    private static Message createSimpleMail(Session mailSession, JavaMailInfo javaMailInfo) throws MessagingException {
    92.        /**
    93.         * Message是一 个抽象类,我们使用MimeMessage这个子类, 该类是使用MIME类型、MIME信息头的 邮箱信息
    94.         * 信息头只能使用US-ASCII字符，而非ASCII字符将通过编码转换为ASCII的方式使用
    95.         */
    96.        // 根据邮件session创建消息对象
    97.        MimeMessage mimeMessage = new MimeMessage(mailSession);
    98.        // 设置发件人 setFrom 和 setReplyTo 均可 有多个发件人使用 addFroms(Address[] addresses)
    99.        mimeMessage.setFrom(new InternetAddress(javaMailInfo.getFromAddress()));
    100.        // 设置收件人 收件人类型 Message.RecipientType.TO(接受者) Message.RecipientType.CC(抄送着) Message.RecipientType.BCC(密送者)
    101.        // setRecipients(Message.RecipientType var1, Address[] var2) 设置多个收件人
    102.        mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(javaMailInfo.getToAddress()));
    103.        // 设置标题
    104.        mimeMessage.setSubject(javaMailInfo.getSubject(), "text/plain;charset=utf-8");
    105.        // 设置内容 是文本可直接使用setText()
    106.        mimeMessage.setContent(javaMailInfo.getContent(), "text/html;charset=utf-8");
    107.        // 设置发送时间
    108.        mimeMessage.setSentDate(new Date());
    109.        mimeMessage.saveChanges();
    110.        return mimeMessage;
    111.    }
    113.    /**
    114.     * 根据邮件Session和邮件信息创建邮件内容（图片类 可多个图片）
    115.     * @param mailSession
    116.     * @param javaMailInfo
    117.     * @return
    118.     */
    119.    private static Message createImageMail(Session mailSession, JavaMailInfo javaMailInfo) throws MessagingException {
    120.        /**
    121.         * Message表示一个邮件，messgaes.getContent()返回一个Multipart对象。一个Multipart对象包含一个或多个BodyPart对象，来组成邮件的正文部分（包括附件）
    122.         * Multipart的content-type
    123.         * 总体来说，MIME消息由消息头和消息体两大部分组成。现在我们关注的是MIME邮件，因此在以下的讨论中姑且称“消息”为“邮件”。
    124.         * 邮件头包含了发件人、收件人、主题、时间、MIME版本、邮件内容的类型等重要信息。每条信息称为一个域，由域名后加“: ”和信息内容构成，可以是一行，较长的也可以占用多行。
    125.         * 域的首行必须“顶头”写，即左边不能有空白字符（空格和制表符）；续行则必须以空白字符打头，且第一个空白字符不是信息本身固有的，解码时要过滤掉。
    126.         * 邮件体包含邮件的内容，它的类型由邮件头的“Content-Type”域指出。常见的简单类型有text/plain(纯文本)和text/html(超文本)。有时也会出现的multipart类型，是MIME邮件的精髓。
    127.         * 邮件体被分为多个段，每个段又包含段头和段体两部分，这两部分之间也以空行分隔。常见的multipart类型有三种：multipart/mixed, multipart/related和multipart/alternative。
    128.         * multipart/mixed：附件。
    129.         * multipart/related：内嵌资源。
    130.         * multipart/alternative：纯文本与超文本共存。
    131.         */
    132.        MimeMessage mimeMessage = new MimeMessage(mailSession);
    133.        mimeMessage.setFrom(new InternetAddress(javaMailInfo.getFromAddress()));
    134.        mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(javaMailInfo.getToAddress()));
    135.        mimeMessage.setSubject(javaMailInfo.getSubject(), "text/plain;charset=utf-8");
    136.        List<String> photoUrlList = javaMailInfo.getPhotoUrlList();
    137.        // 创建消息体 以下方式每个图片都有一个标题
    138.        MimeMultipart mimeMultipart = new MimeMultipart();
    139.        if (!CollectionUtils.isEmpty(photoUrlList)) {
    140.            for (String photoUrl : photoUrlList) {
    141.                MimeBodyPart text = new MimeBodyPart();
    142.                // 设置图片标题 注意img标签的引用位置 用cid:开头
    143.                String cid = UUID.randomUUID().toString();
    144.                text.setContent(javaMailInfo.getContent() +"<br/><img src=\'cid:"+ cid +".jpg\'>", "text/html;charset=utf-8");
    145.                // 使用数据处理器处理图片
    146.                MimeBodyPart image = new MimeBodyPart();
    147.                image.setDataHandler(new DataHandler(new FileDataSource(photoUrl)));
    148.                image.setContentID(cid);
    149.                // 描述正文和图片的关系
    150.                MimeMultipart photo = new MimeMultipart();
    151.                photo.addBodyPart(text);
    152.                photo.addBodyPart(image);
    153.                photo.setSubType("related");
    154.                MimeBodyPart mimeBodyPart = new MimeBodyPart();
    155.                mimeBodyPart.setContent(photo);
    156.                // 将图片放入body中
    157.                mimeMultipart.addBodyPart(mimeBodyPart);
    158.            }
    159.        }
    161.        /*// 以下方式所有图片公用一个标题
    162.        MimeMultipart photo = new MimeMultipart();
    163.        MimeBodyPart text = new MimeBodyPart();
    164.        photo.addBodyPart(text);
    165.        StringBuilder textContent = new StringBuilder(javaMailInfo.getContent());
    166.        if (!CollectionUtils.isEmpty(photoUrlList)) {
    167.            for (String photoUrl : photoUrlList) {
    168.                // 设置图片标题 注意img标签的引用位置 用cid:开头
    169.                String cid = UUID.randomUUID().toString();
    170.                textContent.append("<br/><img src=\'cid:"+ cid +".jpg\'>");
    171.                // 使用数据处理器处理图片
    172.                MimeBodyPart image = new MimeBodyPart();
    173.                image.setDataHandler(new DataHandler(new FileDataSource(photoUrl)));
    174.                image.setContentID(cid);
    175.                // 描述正文和图片的关系
    176.                photo.addBodyPart(image);
    177.            }
    178.            photo.setSubType("related");
    179.        }
    180.        text.setContent(textContent.toString(), "text/html;charset=utf-8");*/
    181.        // 设置消息体
    182.        mimeMessage.setContent(mimeMultipart);
    183.        // mimeMessage.setContent(photo);
    184.        mimeMessage.setSentDate(new Date());
    185.        mimeMessage.saveChanges();
    186.        return mimeMessage;
    187.    }
    189.    /**
    190.     * 根据邮件Session和邮件信息创建邮件内容（附件类 可多个附件）
    191.     * @param mailSession
    192.     * @param javaMailInfo
    193.     * @return
    194.     */
    195.    private static Message createAttachMail(Session mailSession, JavaMailInfo javaMailInfo) throws MessagingException {
    196.        MimeMessage mimeMessage = new MimeMessage(mailSession);
    197.        mimeMessage.setFrom(new InternetAddress(javaMailInfo.getFromAddress()));
    198.        mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(javaMailInfo.getToAddress()));
    199.        mimeMessage.setSubject(javaMailInfo.getSubject(), "text/plain;charset=utf-8");
    200.        List<String> attachList = javaMailInfo.getAttachList();
    201.        // 创建消息体
    202.        MimeMultipart mimeMultipart = new MimeMultipart();
    203.        MimeBodyPart text = new MimeBodyPart();
    204.        text.setContent(javaMailInfo.getSubject(), "text/html;charset=utf-8");
    205.        mimeMultipart.addBodyPart(text);
    206.        if (!CollectionUtils.isEmpty(attachList)) {
    207.            for (String attach : attachList) {
    208.                // 创建附件
    209.                MimeBodyPart mimeBodyPart = new MimeBodyPart();
    210.                DataHandler dataHandler = new DataHandler(new FileDataSource(attach));
    211.                mimeBodyPart.setDataHandler(dataHandler);
    212.                mimeBodyPart.setFileName(dataHandler.getName());
    213.                // 加入最外面的容器
    214.                mimeMultipart.addBodyPart(mimeBodyPart);
    215.            }
    216.            // 描述关系
    217.            mimeMultipart.setSubType("mixed");
    218.        }
    219.        mimeMessage.setContent(mimeMultipart);
    220.        mimeMessage.setSentDate(new Date());
    221.        mimeMessage.saveChanges();
    222.        return mimeMessage;
    223.    }
    225.    /**
    226.     * 根据邮件Session和邮件信息创建邮件内容（多图片 多附件）
    227.     * @param mailSession
    228.     * @param javaMailInfo
    229.     * @return
    230.     */
    231.    private static Message createPhotoAndAttachMail(Session mailSession, JavaMailInfo javaMailInfo) throws MessagingException {
    232.        MimeMessage mimeMessage = new MimeMessage(mailSession);
    233.        mimeMessage.setFrom(new InternetAddress(javaMailInfo.getFromAddress()));
    234.        mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(javaMailInfo.getToAddress()));
    235.        List<String> photoUrlList = javaMailInfo.getPhotoUrlList();
    236.        // 获取所有的图片 公用一个主题
    237.        MimeMultipart photo = new MimeMultipart();
    238.        MimeBodyPart text = new MimeBodyPart();
    239.        photo.addBodyPart(text);
    240.        StringBuilder textContent = new StringBuilder(javaMailInfo.getContent());
    241.        if (!CollectionUtils.isEmpty(photoUrlList)) {
    242.            for (String photoUrl : photoUrlList) {
    243.                // 设置图片标题 注意img标签的引用位置 用cid:开头
    244.                String cid = UUID.randomUUID().toString();
    245.                textContent.append("<br/><img src=\'cid:"+ cid +".jpg\'>");
    246.                // 使用数据处理器处理图片
    247.                MimeBodyPart image = new MimeBodyPart();
    248.                image.setDataHandler(new DataHandler(new FileDataSource(photoUrl)));
    249.                image.setContentID(cid);
    250.                // 描述正文和图片的关系
    251.                photo.addBodyPart(image);
    252.            }
    253.            photo.setSubType("related");
    254.        }
    255.        text.setContent(textContent.toString(), "text/html;charset=utf-8");
    256.        // 将图片包裹成一个body 作为 其内容
    257.        MimeBodyPart content = new MimeBodyPart();
    258.        content.setContent(photo);
    259.        // 获取所有的附件
    260.        List<String> attachList = javaMailInfo.getAttachList();
    261.        MimeMultipart attach = new MimeMultipart();
    262.        if (!CollectionUtils.isEmpty(attachList)) {
    263.            for (String attachUrl : attachList) {
    264.                // 创建附件
    265.                MimeBodyPart mimeBodyPart = new MimeBodyPart();
    266.                DataHandler dataHandler = new DataHandler(new FileDataSource(attachUrl));
    267.                mimeBodyPart.setDataHandler(dataHandler);
    268.                mimeBodyPart.setFileName(dataHandler.getName());
    269.                // 加入最外面的容器
    270.                attach.addBodyPart(mimeBodyPart);
    271.            }
    272.        }
    273.        // 将图片body 和 附件组合
    274.        attach.addBodyPart(content);
    275.        attach.setSubType("mixed");
    276.        mimeMessage.setContent(attach);
    277.        mimeMessage.setSentDate(new Date());
    278.        mimeMessage.saveChanges();
    279.        return mimeMessage;
    280.    }
    281. }

  • spring提供的JavaMailSender是对原始的javax.mail进行了简化

  • 再其使用过程中可以注册到spring容器中，也可不用注册

  • 导入依赖

    1. javax.mail的依赖包
    2. <dependency>
    3.    <groupId>org.springframework</groupId>
    4.    <artifactId>spring-context-support</artifactId>
    5. </dependency>

  1. 邮件的基本信息类

    1. @Data
    2. public class JavaMailSenderInfo {
    4.    // 收件人地址
    5.    private String toAddress;
    7.    // 邮件主题
    8.    private String subject;
    10.    // 邮件内容
    11.    private String content;
    13.    // 是否是html 注意字段boolean类型 不要用is开头 idea会生成get,set方法会进行优化 isHtml -> isHtml(),getHtml() -- html -> isHtml(),getHtml()
    14.    private boolean html = false;
    16.    // 图片地址集合
    17.    private List<String> photoList;
    19.    // 附件地址集合
    20.    private List<String> attachList;
    22. }

  2. 准备mail.propertise配置文件（也就是设置会话的属性），文件放在resource目录下

    1. #传输协议
    2. mail.transport.protocol=smtp
    3. #服务器主机名
    4. mail.smtp.host=smtp.qq.com
    5. #服务器端口号 465或587(使用ssl)
    6. mail.smtp.port=465
    7. #是否进行用户名密码校验 配置了否 就不能配置 用户名和密码 否则会去获取用户名密码进行验证
    8. mail.smtp.auth=true
    9. #设置是否使用ssl安全连接 ---一般都使用
    10. mail.smtp.ssl.enable=true
    11. #设置是否显示debug信息 true 会在控制台显示相关信息
    12. mail.debug=true
    13. #设置超时时间
    14. mail.smtp.timeout=20000
    15. #编码格式
    16. mail.smtp.defaultEncoding=utf-8
    17. #你的邮箱地址
    18. mail.smtp.username=xxxxxx@qq.com
    19. #你的授权码(第三方使用时代替密码)
    20. mail.smtp.password=xxxxxx

  3. 加载配置文件，初始化JavaMailSender

    1. public class InitJavaMailSender {
    2.    /**
    3.     * 此类的作用是加载配置文件来创建JavaMailSender对象  JavaMailSenderImpl是该接口的实现类
    4.     * 因此我们需要对JavaMailSenderImpl进行配置 在spring的环境下 我们可以使用加载配置文件的方式 或者
    5.     * 在spring配置文件中直接配置该bean（由spring托管）使用时@Autowired直接注入即可
    6.     * <bean id="javaMailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
    7.     * 		<property name="host" value="${mail.smtp.host}" />
    8.     * 		<property name="username" value="${mail.smtp.username}" />
    9.     * 		<property name="password" value="${mail.smtp.password}" />
    10.     * 		<property name="defaultEncoding" value="${mail.smtp.defaultEncoding}" />
    11.     * 		<property name="javaMailProperties">
    12.     * 			<props>
    13.     * 				<prop key="mail.smtp.auth">${mail.smtp.auth}</prop>
    14.     * 				<prop key="mail.smtp.timeout">${mail.smtp.timeout}</prop>
    15.     * 			    ...
    16.     * 			</props>
    17.     * 		</property>
    18.     * 	</bean>
    19.     * 本次采用加载配置文件的方式
    20.     * 由spring提供 其底层使用的仍然是javax.mail进行邮件的发送
    21.     * JavaMailSenderImpl 依赖javax.mail 和 spring-context-support包
    22.     */
    23.    // 传输协议
    24.    private static String protocol;
    25.    // 服务器主机名
    26.    private static String host;
    27.    // 服务器端口号
    28.    private static String port;
    29.    // 是否进行用户名密码校验
    30.    private static String auth;
    31.    // 设置是否使用ssl安全连接
    32.    private static String enableSSL;
    33.    // 设置是否显示debug信息
    34.    private static String debug;
    35.    // 超时时间
    36.    private static String timeout;
    37.    // 编码格式
    38.    private static String defaultEncoding;
    39.    // 邮箱地址
    40.    public static String username;
    41.    // 授权码
    42.    private static String password;
    44.    private static volatile JavaMailSenderImpl javaMailSenderImpl;
    46.    static {
    47.        init();
    48.    }
    50.    private static void init() {
    51.        // 加载配置文件
    52.        Properties properties = new Properties();
    53.        InputStream resourceAsStream = JavaMailSender.class.getClassLoader().getResourceAsStream("mail.properties");
    54.        try {
    55.            properties.load(resourceAsStream);
    56.            protocol = properties.getProperty("mail.transport.protocol");
    57.            host = properties.getProperty("mail.smtp.host");
    58.            port = properties.getProperty("mail.smtp.port");
    59.            auth = properties.getProperty("mail.smtp.auth");
    60.            enableSSL = properties.getProperty("mail.smtp.ssl.enable");
    61.            debug = properties.getProperty("mail.debug");
    62.            timeout = properties.getProperty("mail.smtp.timeout");
    63.            defaultEncoding = properties.getProperty("mail.smtp.defaultEncoding");
    64.            username = properties.getProperty("mail.smtp.username");
    65.            password = properties.getProperty("mail.smtp.password");
    66.            System.out.println("mail.properties加载成功");
    67.        } catch (IOException e) {
    68.            e.printStackTrace();
    69.            System.out.println("mail.properties加载失败");
    70.        } finally {
    71.            if (null != resourceAsStream) {
    72.                try {
    73.                    resourceAsStream.close();
    74.                } catch (IOException e) {
    75.                    e.printStackTrace();
    76.                }
    77.            }
    78.        }
    79.    }
    81.    /**
    82.     * 使用单例获取JavaMailSender 双重检查既保证的线程安全 又保证了效率 又能起到延迟加载的作用
    83.     * @return
    84.     */
    85.    public static JavaMailSender getJavaMailSender() {
    86.        if (null == javaMailSenderImpl) {
    87.            synchronized (InitJavaMailSender.class) {
    88.                if (null == javaMailSenderImpl) {
    89.                    javaMailSenderImpl = new JavaMailSenderImpl();
    90.                    javaMailSenderImpl.setProtocol(protocol);
    91.                    javaMailSenderImpl.setHost(host);
    92.                    javaMailSenderImpl.setPort(Integer.parseInt(port));
    93.                    javaMailSenderImpl.setDefaultEncoding(defaultEncoding);
    94.                    javaMailSenderImpl.setUsername(username);
    95.                    javaMailSenderImpl.setPassword(password);
    96.                    Properties properties = new Properties();
    97.                    properties.setProperty("mail.smtp.auth", auth);
    98.                    properties.setProperty("mail.smtp.ssl.enable", enableSSL);
    99.                    properties.setProperty("mail.debug", debug);
    100.                    properties.setProperty("mail.smtp.timeout", timeout);
    101.                    javaMailSenderImpl.setJavaMailProperties(properties);
    102.                }
    103.            }
    104.        }
    105.        return javaMailSenderImpl;
    106.    }
    108. }

  4. 邮件发送工具类

    1. public class JavaMailSenderUtils {
    3.    /**
    4.     * 测试发送邮件 实际中可以在service中使用（若使用的spring配置的方式创建JavaMailSender，则需注入使用）
    5.     * 此处为方便使用main方法
    6.     * @param args
    7.     */
    8.    public static void main(String[] args) {
    9.        JavaMailSenderInfo javaMailSenderInfo = new JavaMailSenderInfo();
    10.        javaMailSenderInfo.setToAddress("发件人");
    11.        javaMailSenderInfo.setSubject("邮件主题");
    12.        javaMailSenderInfo.setContent("邮件内容");
    13.        javaMailSenderInfo.setHtml(true);
    14.        List<String> list = new ArrayList<>();
    15.        list.add("图片1");
    16.        // list.add("图片2");
    17.        // list.add("图片3");
    18.        // list.add("图片4");
    19.        javaMailSenderInfo.setPhotoList(list);
    20.        javaMailSenderInfo.setAttachList(list);
    21.        // JavaMailSenderUtils.sendSimpleMail(javaMailSenderInfo);
    22.        JavaMailSenderUtils.sendPhotoMail(javaMailSenderInfo);
    23.        // JavaMailSenderUtils.sendAttacheMail(javaMailSenderInfo);
    24.        // JavaMailSenderUtils.sendPhotoAndAttacheMail(javaMailSenderInfo);
    26.    }
    28.    private static final JavaMailSender javaMailSender = InitJavaMailSender.getJavaMailSender();
    30.    private static final String htmlStartStr = "<html><body>";
    32.    private static final String htmlEndStr = "</body></html>";
    34.    /**
    35.     * 发送简单邮件 文本 html
    36.     * @param javaMailSenderInfo
    37.     * @return
    38.     */
    39.    public static boolean sendSimpleMail(JavaMailSenderInfo javaMailSenderInfo) {
    40.        // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
    41.        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
    42.        MimeMessageHelper mimeMessageHelper = null;
    43.        try {
    44.            // 创建消息辅助器 参数二 为true时为多组件 html 等
    45.            mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
    46.            // 设置公共字段
    47.            setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
    48.            // 文本内容 可指定是否是html
    49.            mimeMessageHelper.setText(javaMailSenderInfo.getContent(), javaMailSenderInfo.isHtml());
    50.            javaMailSender.send(mimeMessage);
    51.            System.out.println("简单邮件发送成功");
    52.            return true;
    53.        } catch (MessagingException e) {
    54.            e.printStackTrace();
    55.            System.out.println("简单邮件发送失败");
    56.            return false;
    57.        }
    58.    }
    60.    /**
    61.     * 发送带图片的邮件
    62.     * @param javaMailSenderInfo
    63.     * @return
    64.     */
    65.    public static boolean sendPhotoMail(JavaMailSenderInfo javaMailSenderInfo) {
    66.        // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
    67.        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
    68.        MimeMessageHelper mimeMessageHelper = null;
    69.        try {
    70.            mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
    71.            setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
    72.            List<String> photoList = javaMailSenderInfo.getPhotoList();
    73.            // html内容
    74.            StringBuilder text = new StringBuilder(htmlStartStr);
    75.            text.append(javaMailSenderInfo.getContent());
    76.            if (!CollectionUtils.isEmpty(photoList)) {
    77.                for (String photo : photoList) {
    78.                    // 每个图片创建一个标题吧 每个图片关联一个cid
    79.                    String cid = UUID.randomUUID().toString();
    80.                    text.append("<br/><h1>"+ javaMailSenderInfo.getSubject() +"</h1><br/><img src=\'cid:"+ cid +"\'/>");
    81.                    mimeMessageHelper.addInline(cid, new File(photo));
    82.                }
    83.            }
    84.            // 为什么会有最后一个图片图裂不显示的问题（求大佬指点）
    85.            // String cid = UUID.randomUUID().toString();
    86.            // mimeMessageHelper.addInline(cid, new File(""));
    87.            text.append(htmlEndStr);
    88.            mimeMessageHelper.setText(text.toString(),true);
    89.            javaMailSender.send(mimeMessage);
    90.            System.out.println("带图片的邮件发送成功");
    91.            return true;
    92.        } catch (MessagingException e) {
    93.            e.printStackTrace();
    94.            System.out.println("带图片的邮件发送失败");
    95.            return false;
    96.        }
    97.    }
    99.    /**
    100.     * 发送带附件的邮件
    101.     * @param javaMailSenderInfo
    102.     * @return
    103.     */
    104.    public static boolean sendAttacheMail(JavaMailSenderInfo javaMailSenderInfo) {
    105.        // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
    106.        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
    107.        MimeMessageHelper mimeMessageHelper = null;
    108.        try {
    109.            mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
    110.            setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
    111.            List<String> attachList = javaMailSenderInfo.getAttachList();
    112.            // 邮件文本
    113.            mimeMessageHelper.setText(javaMailSenderInfo.getContent(), javaMailSenderInfo.isHtml());
    114.            if (!CollectionUtils.isEmpty(attachList)) {
    115.                for (String attach : attachList) {
    116.                    // 添加附件（最后一个附件是图片也存在图裂的问题，但可下载使用，求大佬指点）
    117.                    FileSystemResource fileSystemResource = new FileSystemResource(attach);
    118.                    // 参数一为附件名称
    119.                    mimeMessageHelper.addAttachment(fileSystemResource.getFilename(), fileSystemResource);
    120.                }
    121.            }
    122.            javaMailSender.send(mimeMessage);
    123.            System.out.println("带附件的邮件发送成功");
    124.            return true;
    125.        } catch (MessagingException e) {
    126.            e.printStackTrace();
    127.            System.out.println("带附件的邮件发送失败");
    128.            return false;
    129.        }
    130.    }
    132.    /**
    133.     * 发送带图片和附件的邮件
    134.     * @param javaMailSenderInfo
    135.     * @return
    136.     */
    137.    public static boolean sendPhotoAndAttacheMail(JavaMailSenderInfo javaMailSenderInfo) {
    138.        // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
    139.        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
    140.        MimeMessageHelper mimeMessageHelper = null;
    141.        try {
    142.            mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
    143.            setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
    144.            List<String> photoList = javaMailSenderInfo.getPhotoList();
    145.            // 放入图片和内容
    146.            StringBuilder text = new StringBuilder(htmlStartStr + javaMailSenderInfo.getContent());
    147.            if (!CollectionUtils.isEmpty(photoList)) {
    148.                for (String photo : photoList) {
    149.                    String cid = UUID.randomUUID().toString();
    150.                    text.append("<br/><img src=\'cid:"+ cid +"\'>");
    151.                    mimeMessageHelper.addInline(cid, new File(photo));
    152.                }
    153.            }
    154.            text.append(htmlEndStr);
    155.            mimeMessageHelper.setText(text.toString(),true);
    156.            // 放入附件
    157.            List<String> attachList = javaMailSenderInfo.getAttachList();
    158.            if (!CollectionUtils.isEmpty(attachList)) {
    159.                for (String attach : attachList) {
    160.                    // 添加附件
    161.                    FileSystemResource fileSystemResource = new FileSystemResource(attach);
    162.                    // 参数一为附件名称
    163.                    mimeMessageHelper.addAttachment(fileSystemResource.getFilename(), fileSystemResource);
    164.                }
    165.            }
    166.            javaMailSender.send(mimeMessage);
    167.            System.out.println("带图片和附件的邮件发送成功");
    168.            return true;
    169.        } catch (MessagingException e) {
    170.            e.printStackTrace();
    171.            System.out.println("带图片和附件邮件发送失败");
    172.            return false;
    173.        }
    174.    }
    176.    /**
    177.     * 发送由freemarker模板技术生成的邮件
    178.     * @param javaMailSenderInfo
    179.     * @return
    180.     */
    181.    public static boolean sendFreemarkerMail(JavaMailSenderInfo javaMailSenderInfo) {
    182.        // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
    183.        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
    184.        MimeMessageHelper mimeMessageHelper = null;
    185.        try {
    186.            mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
    187.            setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
    188.            /**
    189.             * 此处没有实现采用模板技术（可自行探索）
    190.             * 封装模板所需要的数据
    191.             * 读取freemarker的模板文件 xxx.ftl 进行静态化，生成html形式的字符串
    192.             * 将生成好的html字符串设置到邮件的正文中
    193.             */
    194.            javaMailSender.send(mimeMessage);
    195.            System.out.println("freemarker模板技术生成的邮件发送成功");
    196.            return true;
    197.        } catch (MessagingException e) {
    198.            e.printStackTrace();
    199.            System.out.println("freemarker模板技术生成的邮件发送失败");
    200.            return false;
    201.        }
    202.    }
    204.    /**
    205.     * 设置邮件的公共字段
    206.     * @param mimeMessageHelper
    207.     * @param javaMailSenderInfo
    208.     * @throws MessagingException
    209.     */
    210.    private static void setMailCommonField(MimeMessageHelper mimeMessageHelper, JavaMailSenderInfo javaMailSenderInfo) throws MessagingException {
    211.        // 发件人
    212.        mimeMessageHelper.setFrom(InitJavaMailSender.username);
    213.        // 收件人 多人用数组
    214.        mimeMessageHelper.setTo(javaMailSenderInfo.getToAddress());
    215.        // 主题
    216.        mimeMessageHelper.setSubject(javaMailSenderInfo.getSubject());
    217.        // 日期
    218.        mimeMessageHelper.setSentDate(new Date());
    219.    }
    221. }

  • 使用springboot发送邮件和使用spring提供的JavaMailSender发送邮件的方式一样

  • 在yml配置文件中配置相关的会话信息后

  • 在service层中直接注入使用即可

  • 导入依赖

    1. <!--springboot整合mail-->
    2. <dependency>
    3.    <groupId>org.springframework.boot</groupId>
    4.    <artifactId>spring-boot-starter-mail</artifactId>
    5. </dependency>

  1. 修改配置

    1. # 邮件的设置 导入mail启动包 使用时注入直接JavaMailSender即可
    2. spring:
    3.    mail:
    4.        protocol: smtp
    5.        host: smtp.qq.com
    6.        port: 465
    7.        default-encoding: utf-8
    8.        username: 邮箱用户名
    9.        password: 邮箱授权码
    10.        test-connection: true
    11.        properties:
    12.          mail:
    13.            debug: true
    14.            smtp:
    15.              auth: true
    16.              timeout: 20000
    17.              ssl:
    18.                enable: true

  2. 直接在service层中使用即可

    1. public MailServiceImpl {
    2.    
    3.    @Autowired
    4.    private JavaMailSender javaMailSender;
    5.    
    6.    // 以下代码使用即可
    7.    ...
    8. }

版权声明：本文为xiaokantianse原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/xiaokantianse/p/13948245.html