zoukankan      html  css  js  c++  java
  • 1.使用javax.mail, spring的JavaMailSender,springboot发送邮件

    一、java发邮件

    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

    二、使用javax.mail发送邮件(简单,带图片,带附件,带图片和附件)

    • 使用之前应该申请qq邮箱的授权码(第三方的使用时,替代密码)

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

    • 导入依赖

    • <!--发送邮件的jar 1.4 版本会出现javamail.providers 文件找不见 与其他jar包中文件冲突-->
      <dependency>
         <groupId>javax.mail</groupId>
         <artifactId>mail</artifactId>
      <version>1.4.4</version>
      </dependency>
      
    1. 邮件的基本信息类

      @Data
      public class JavaMailInfo {
      
         /**
          * 使用java mail 发送邮件 邮件的协议有SMTP POP IMAP MIME 等 协议具体内容可自行百度  SMTP 为简单邮件传输协议 比较常用
          */
      
         // 邮件服务器地址
         private String mailSeverHost;
      
         // 邮件服务器端口
         private String mailServerPort;
      
         // 邮件发送者
         private String fromAddress;
      
         // 发送者用户名
         private String userName;
      
         // 发送者密码
         private String password;
      
         // 收件人地址
         private String toAddress;
      
         // 邮件主题
         private String subject;
      
         // 邮件内容
         private String content;
      
         // 图片地址集合
         private List<String> photoUrlList;
      
         // 附件地址集合
         private List<String> attachList;
      
         /**
          * 获取邮件会话属性 ,对邮件Session进行设置 此部分的内容可以通过加载配置文件的方式进行设置
          * @return
          */
         public Properties getProperties() {
             Properties properties = new Properties();
             properties.put("mail.transport.protocol", "smtp");// 连接协议
             properties.put("mail.smtp.host", this.mailSeverHost);// 主机名
             properties.put("mail.smtp.port", this.mailServerPort);// 端口号
             properties.put("mail.smtp.auth", "true");//设置smtp是否需要认证
             properties.put("mail.smtp.ssl.enable", "true");// 设置是否使用ssl安全连接 ---一般都使用
             properties.put("mail.debug", "true");// 设置是否显示debug信息 true 会在控制台显示相关信息
             properties.put("mail.smtp.timeout", 20000);// 超时时间
             return properties;
         }
      
      }
      
    2. 权限认证类

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

      public class JavaMailSendUtils {
      
         /**
          * 实际使用
          * @param args
          */
         public static void main(String[] args) {
             JavaMailInfo javaMailInfo = new JavaMailInfo();
             javaMailInfo.setMailSeverHost("smtp.qq.com");
             javaMailInfo.setMailServerPort("465");// 465或587(使用ssl)
             javaMailInfo.setFromAddress("发件人");
             javaMailInfo.setUserName("您邮箱用户名");
             javaMailInfo.setPassword("您邮箱授权码");// 密码需要使用对应邮箱的授权码授权码
             javaMailInfo.setToAddress("收件人");
             javaMailInfo.setSubject("邮件主题");
             javaMailInfo.setContent("邮件内容");
             List<String> photoUrlList = new ArrayList<>();
             photoUrlList.add("图片1");
             photoUrlList.add("图片2");
             javaMailInfo.setPhotoUrlList(photoUrlList);
             List<String> attachList = new ArrayList<>();
             attachList.add("附件1");
             attachList.add("附件2");
             javaMailInfo.setAttachList(attachList);
             sendJavaMail(javaMailInfo);
         }
      
         /**
          * 此工具类可根据邮件基本信息进行邮件的发送
          */
      
         /**
          * 发送邮件方法
          * @param javaMailInfo
          * @return
          */
         public static boolean sendJavaMail(JavaMailInfo javaMailInfo) {
             // 获取邮件session的相关配置参数
             Properties properties = javaMailInfo.getProperties();
             // 创建授权验证类
             MyJavaMailAuthenticator myJavaMailAuthenticator = new MyJavaMailAuthenticator();
             myJavaMailAuthenticator.setUserName(javaMailInfo.getUserName());
             myJavaMailAuthenticator.setPassword(javaMailInfo.getPassword());
             // 构建邮件Session会话对象 带不带default均可 查看源码可知 带default的是获取该类的属性 不带获取的是新创建的
             Session mailSession = Session.getDefaultInstance(properties, myJavaMailAuthenticator);
             // 开启debug properties中设置了此处就无须设置
             // mailSession.setDebug(true);
             // 邮差对象 也可使用静态方法进行发送
             Transport transport = null;
             try {
                 // 获取消息 也就是发送的内容
                 // Message message = createSimpleMail(mailSession, javaMailInfo);
                 // Message message = createImageMail(mailSession, javaMailInfo);
                 // Message message = createAttachMail(mailSession, javaMailInfo);
                 Message message = createPhotoAndAttachMail(mailSession, javaMailInfo);
                 // 设置规范 具体是什么规范呢? 固定写法
                 MailcapCommandMap defaultCommandMap = (MailcapCommandMap) CommandMap.getDefaultCommandMap();
                 defaultCommandMap.addMailcap("text/html;; x-java-content-handler=com.sun.mail.handlers.text_html");
                 defaultCommandMap.addMailcap("text/xml;; x-java-content-handler=com.sun.mail.handlers.text_xml");
                 defaultCommandMap.addMailcap("text/plain;; x-java-content-handler=com.sun.mail.handlers.text_plain");
                 defaultCommandMap.addMailcap("multipart/*;; x-java-content-handler=com.sun.mail.handlers.multipart_mixed");
                 defaultCommandMap.addMailcap("message/rfc822;; x-java-content-handler=com.sun.mail.handlers.message_rfc822");
                 CommandMap.setDefaultCommandMap(defaultCommandMap);
                 // 发送邮件 Transport.send(message); 或者获取Transport对象发送
                 transport = mailSession.getTransport();
                 transport.connect(javaMailInfo.getUserName(), javaMailInfo.getUserName());
                 transport.sendMessage(message, message.getAllRecipients());
                 System.out.println("邮件发送成功");
                 return true;
             } catch (MessagingException e) {
                 e.printStackTrace();
                 System.out.println("邮件发送失败");
                 return false;
             } finally {
                 if (null != transport) {
                     try {
                         transport.close();
                     } catch (MessagingException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }
      
         /**
          * 根据邮件Session和邮件信息创建邮件内容(文本类 html)
          * @param mailSession
          * @param javaMailInfo
          * @return
          */
         private static Message createSimpleMail(Session mailSession, JavaMailInfo javaMailInfo) throws MessagingException {
             /**
              * Message是一 个抽象类,我们使用MimeMessage这个子类, 该类是使用MIME类型、MIME信息头的 邮箱信息
              * 信息头只能使用US-ASCII字符,而非ASCII字符将通过编码转换为ASCII的方式使用
              */
             // 根据邮件session创建消息对象
             MimeMessage mimeMessage = new MimeMessage(mailSession);
             // 设置发件人 setFrom 和 setReplyTo 均可 有多个发件人使用 addFroms(Address[] addresses)
             mimeMessage.setFrom(new InternetAddress(javaMailInfo.getFromAddress()));
             // 设置收件人 收件人类型 Message.RecipientType.TO(接受者) Message.RecipientType.CC(抄送着) Message.RecipientType.BCC(密送者)
             // setRecipients(Message.RecipientType var1, Address[] var2) 设置多个收件人
             mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(javaMailInfo.getToAddress()));
             // 设置标题
             mimeMessage.setSubject(javaMailInfo.getSubject(), "text/plain;charset=utf-8");
             // 设置内容 是文本可直接使用setText()
             mimeMessage.setContent(javaMailInfo.getContent(), "text/html;charset=utf-8");
             // 设置发送时间
             mimeMessage.setSentDate(new Date());
             mimeMessage.saveChanges();
             return mimeMessage;
         }
      
         /**
          * 根据邮件Session和邮件信息创建邮件内容(图片类 可多个图片)
          * @param mailSession
          * @param javaMailInfo
          * @return
          */
         private static Message createImageMail(Session mailSession, JavaMailInfo javaMailInfo) throws MessagingException {
             /**
              * Message表示一个邮件,messgaes.getContent()返回一个Multipart对象。一个Multipart对象包含一个或多个BodyPart对象,来组成邮件的正文部分(包括附件)
              * Multipart的content-type
              * 总体来说,MIME消息由消息头和消息体两大部分组成。现在我们关注的是MIME邮件,因此在以下的讨论中姑且称“消息”为“邮件”。
              * 邮件头包含了发件人、收件人、主题、时间、MIME版本、邮件内容的类型等重要信息。每条信息称为一个域,由域名后加“: ”和信息内容构成,可以是一行,较长的也可以占用多行。
              * 域的首行必须“顶头”写,即左边不能有空白字符(空格和制表符);续行则必须以空白字符打头,且第一个空白字符不是信息本身固有的,解码时要过滤掉。
              * 邮件体包含邮件的内容,它的类型由邮件头的“Content-Type”域指出。常见的简单类型有text/plain(纯文本)和text/html(超文本)。有时也会出现的multipart类型,是MIME邮件的精髓。
              * 邮件体被分为多个段,每个段又包含段头和段体两部分,这两部分之间也以空行分隔。常见的multipart类型有三种:multipart/mixed, multipart/related和multipart/alternative。
              * multipart/mixed:附件。
              * multipart/related:内嵌资源。
              * multipart/alternative:纯文本与超文本共存。
              */
             MimeMessage mimeMessage = new MimeMessage(mailSession);
             mimeMessage.setFrom(new InternetAddress(javaMailInfo.getFromAddress()));
             mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(javaMailInfo.getToAddress()));
             mimeMessage.setSubject(javaMailInfo.getSubject(), "text/plain;charset=utf-8");
             List<String> photoUrlList = javaMailInfo.getPhotoUrlList();
             // 创建消息体 以下方式每个图片都有一个标题
             MimeMultipart mimeMultipart = new MimeMultipart();
             if (!CollectionUtils.isEmpty(photoUrlList)) {
                 for (String photoUrl : photoUrlList) {
                     MimeBodyPart text = new MimeBodyPart();
                     // 设置图片标题 注意img标签的引用位置 用cid:开头
                     String cid = UUID.randomUUID().toString();
                     text.setContent(javaMailInfo.getContent() +"<br/><img src='cid:"+ cid +".jpg'>", "text/html;charset=utf-8");
                     // 使用数据处理器处理图片
                     MimeBodyPart image = new MimeBodyPart();
                     image.setDataHandler(new DataHandler(new FileDataSource(photoUrl)));
                     image.setContentID(cid);
                     // 描述正文和图片的关系
                     MimeMultipart photo = new MimeMultipart();
                     photo.addBodyPart(text);
                     photo.addBodyPart(image);
                     photo.setSubType("related");
                     MimeBodyPart mimeBodyPart = new MimeBodyPart();
                     mimeBodyPart.setContent(photo);
                     // 将图片放入body中
                     mimeMultipart.addBodyPart(mimeBodyPart);
                 }
             }
      
             /*// 以下方式所有图片公用一个标题
             MimeMultipart photo = new MimeMultipart();
             MimeBodyPart text = new MimeBodyPart();
             photo.addBodyPart(text);
             StringBuilder textContent = new StringBuilder(javaMailInfo.getContent());
             if (!CollectionUtils.isEmpty(photoUrlList)) {
                 for (String photoUrl : photoUrlList) {
                     // 设置图片标题 注意img标签的引用位置 用cid:开头
                     String cid = UUID.randomUUID().toString();
                     textContent.append("<br/><img src='cid:"+ cid +".jpg'>");
                     // 使用数据处理器处理图片
                     MimeBodyPart image = new MimeBodyPart();
                     image.setDataHandler(new DataHandler(new FileDataSource(photoUrl)));
                     image.setContentID(cid);
                     // 描述正文和图片的关系
                     photo.addBodyPart(image);
                 }
                 photo.setSubType("related");
             }
             text.setContent(textContent.toString(), "text/html;charset=utf-8");*/
             // 设置消息体
             mimeMessage.setContent(mimeMultipart);
             // mimeMessage.setContent(photo);
             mimeMessage.setSentDate(new Date());
             mimeMessage.saveChanges();
             return mimeMessage;
         }
      
         /**
          * 根据邮件Session和邮件信息创建邮件内容(附件类 可多个附件)
          * @param mailSession
          * @param javaMailInfo
          * @return
          */
         private static Message createAttachMail(Session mailSession, JavaMailInfo javaMailInfo) throws MessagingException {
             MimeMessage mimeMessage = new MimeMessage(mailSession);
             mimeMessage.setFrom(new InternetAddress(javaMailInfo.getFromAddress()));
             mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(javaMailInfo.getToAddress()));
             mimeMessage.setSubject(javaMailInfo.getSubject(), "text/plain;charset=utf-8");
             List<String> attachList = javaMailInfo.getAttachList();
             // 创建消息体
             MimeMultipart mimeMultipart = new MimeMultipart();
             MimeBodyPart text = new MimeBodyPart();
             text.setContent(javaMailInfo.getSubject(), "text/html;charset=utf-8");
             mimeMultipart.addBodyPart(text);
             if (!CollectionUtils.isEmpty(attachList)) {
                 for (String attach : attachList) {
                     // 创建附件
                     MimeBodyPart mimeBodyPart = new MimeBodyPart();
                     DataHandler dataHandler = new DataHandler(new FileDataSource(attach));
                     mimeBodyPart.setDataHandler(dataHandler);
                     mimeBodyPart.setFileName(dataHandler.getName());
                     // 加入最外面的容器
                     mimeMultipart.addBodyPart(mimeBodyPart);
                 }
                 // 描述关系
                 mimeMultipart.setSubType("mixed");
             }
             mimeMessage.setContent(mimeMultipart);
             mimeMessage.setSentDate(new Date());
             mimeMessage.saveChanges();
             return mimeMessage;
         }
      
         /**
          * 根据邮件Session和邮件信息创建邮件内容(多图片 多附件)
          * @param mailSession
          * @param javaMailInfo
          * @return
          */
         private static Message createPhotoAndAttachMail(Session mailSession, JavaMailInfo javaMailInfo) throws MessagingException {
             MimeMessage mimeMessage = new MimeMessage(mailSession);
             mimeMessage.setFrom(new InternetAddress(javaMailInfo.getFromAddress()));
             mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(javaMailInfo.getToAddress()));
             List<String> photoUrlList = javaMailInfo.getPhotoUrlList();
             // 获取所有的图片 公用一个主题
             MimeMultipart photo = new MimeMultipart();
             MimeBodyPart text = new MimeBodyPart();
             photo.addBodyPart(text);
             StringBuilder textContent = new StringBuilder(javaMailInfo.getContent());
             if (!CollectionUtils.isEmpty(photoUrlList)) {
                 for (String photoUrl : photoUrlList) {
                     // 设置图片标题 注意img标签的引用位置 用cid:开头
                     String cid = UUID.randomUUID().toString();
                     textContent.append("<br/><img src='cid:"+ cid +".jpg'>");
                     // 使用数据处理器处理图片
                     MimeBodyPart image = new MimeBodyPart();
                     image.setDataHandler(new DataHandler(new FileDataSource(photoUrl)));
                     image.setContentID(cid);
                     // 描述正文和图片的关系
                     photo.addBodyPart(image);
                 }
                 photo.setSubType("related");
             }
             text.setContent(textContent.toString(), "text/html;charset=utf-8");
             // 将图片包裹成一个body 作为 其内容
             MimeBodyPart content = new MimeBodyPart();
             content.setContent(photo);
             // 获取所有的附件
             List<String> attachList = javaMailInfo.getAttachList();
             MimeMultipart attach = new MimeMultipart();
             if (!CollectionUtils.isEmpty(attachList)) {
                 for (String attachUrl : attachList) {
                     // 创建附件
                     MimeBodyPart mimeBodyPart = new MimeBodyPart();
                     DataHandler dataHandler = new DataHandler(new FileDataSource(attachUrl));
                     mimeBodyPart.setDataHandler(dataHandler);
                     mimeBodyPart.setFileName(dataHandler.getName());
                     // 加入最外面的容器
                     attach.addBodyPart(mimeBodyPart);
                 }
             }
             // 将图片body 和 附件组合
             attach.addBodyPart(content);
             attach.setSubType("mixed");
             mimeMessage.setContent(attach);
             mimeMessage.setSentDate(new Date());
             mimeMessage.saveChanges();
             return mimeMessage;
         }
      }
      

    三、使用spring的JavaMailSender发送邮件(简单,带图片,带附件,带图片和附件,freemarker模板)

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

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

    • 导入依赖

    • javax.mail的依赖包
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context-support</artifactId>
      </dependency>
      
    1. 邮件的基本信息类

      @Data
      public class JavaMailSenderInfo {
      
         // 收件人地址
         private String toAddress;
      
         // 邮件主题
         private String subject;
      
         // 邮件内容
         private String content;
      
         // 是否是html 注意字段boolean类型 不要用is开头 idea会生成get,set方法会进行优化 isHtml -> isHtml(),getHtml() -- html -> isHtml(),getHtml()
         private boolean html = false;
      
         // 图片地址集合
         private List<String> photoList;
      
         // 附件地址集合
         private List<String> attachList;
      
      }
      
    2. 准备mail.propertise配置文件(也就是设置会话的属性),文件放在resource目录下

      #传输协议
      mail.transport.protocol=smtp
      #服务器主机名
      mail.smtp.host=smtp.qq.com
      #服务器端口号 465或587(使用ssl)
      mail.smtp.port=465
      #是否进行用户名密码校验 配置了否 就不能配置 用户名和密码 否则会去获取用户名密码进行验证
      mail.smtp.auth=true
      #设置是否使用ssl安全连接 ---一般都使用
      mail.smtp.ssl.enable=true
      #设置是否显示debug信息 true 会在控制台显示相关信息
      mail.debug=true
      #设置超时时间
      mail.smtp.timeout=20000
      #编码格式
      mail.smtp.defaultEncoding=utf-8
      #你的邮箱地址
      mail.smtp.username=xxxxxx@qq.com
      #你的授权码(第三方使用时代替密码)
      mail.smtp.password=xxxxxx
      
    3. 加载配置文件,初始化JavaMailSender

      public class InitJavaMailSender {
         /**
          * 此类的作用是加载配置文件来创建JavaMailSender对象  JavaMailSenderImpl是该接口的实现类
          * 因此我们需要对JavaMailSenderImpl进行配置 在spring的环境下 我们可以使用加载配置文件的方式 或者
          * 在spring配置文件中直接配置该bean(由spring托管)使用时@Autowired直接注入即可
          * <bean id="javaMailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
          * 		<property name="host" value="${mail.smtp.host}" />
          * 		<property name="username" value="${mail.smtp.username}" />
          * 		<property name="password" value="${mail.smtp.password}" />
          * 		<property name="defaultEncoding" value="${mail.smtp.defaultEncoding}" />
          * 		<property name="javaMailProperties">
          * 			<props>
          * 				<prop key="mail.smtp.auth">${mail.smtp.auth}</prop>
          * 				<prop key="mail.smtp.timeout">${mail.smtp.timeout}</prop>
          * 			    ...
          * 			</props>
          * 		</property>
          * 	</bean>
          * 本次采用加载配置文件的方式
          * 由spring提供 其底层使用的仍然是javax.mail进行邮件的发送
          * JavaMailSenderImpl 依赖javax.mail 和 spring-context-support包
          */
         // 传输协议
         private static String protocol;
         // 服务器主机名
         private static String host;
         // 服务器端口号
         private static String port;
         // 是否进行用户名密码校验
         private static String auth;
         // 设置是否使用ssl安全连接
         private static String enableSSL;
         // 设置是否显示debug信息
         private static String debug;
         // 超时时间
         private static String timeout;
         // 编码格式
         private static String defaultEncoding;
         // 邮箱地址
         public static String username;
         // 授权码
         private static String password;
      
         private static volatile JavaMailSenderImpl javaMailSenderImpl;
      
         static {
             init();
         }
      
         private static void init() {
             // 加载配置文件
             Properties properties = new Properties();
             InputStream resourceAsStream = JavaMailSender.class.getClassLoader().getResourceAsStream("mail.properties");
             try {
                 properties.load(resourceAsStream);
                 protocol = properties.getProperty("mail.transport.protocol");
                 host = properties.getProperty("mail.smtp.host");
                 port = properties.getProperty("mail.smtp.port");
                 auth = properties.getProperty("mail.smtp.auth");
                 enableSSL = properties.getProperty("mail.smtp.ssl.enable");
                 debug = properties.getProperty("mail.debug");
                 timeout = properties.getProperty("mail.smtp.timeout");
                 defaultEncoding = properties.getProperty("mail.smtp.defaultEncoding");
                 username = properties.getProperty("mail.smtp.username");
                 password = properties.getProperty("mail.smtp.password");
                 System.out.println("mail.properties加载成功");
             } catch (IOException e) {
                 e.printStackTrace();
                 System.out.println("mail.properties加载失败");
             } finally {
                 if (null != resourceAsStream) {
                     try {
                         resourceAsStream.close();
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }
      
         /**
          * 使用单例获取JavaMailSender 双重检查既保证的线程安全 又保证了效率 又能起到延迟加载的作用
          * @return
          */
         public static JavaMailSender getJavaMailSender() {
             if (null == javaMailSenderImpl) {
                 synchronized (InitJavaMailSender.class) {
                     if (null == javaMailSenderImpl) {
                         javaMailSenderImpl = new JavaMailSenderImpl();
                         javaMailSenderImpl.setProtocol(protocol);
                         javaMailSenderImpl.setHost(host);
                         javaMailSenderImpl.setPort(Integer.parseInt(port));
                         javaMailSenderImpl.setDefaultEncoding(defaultEncoding);
                         javaMailSenderImpl.setUsername(username);
                         javaMailSenderImpl.setPassword(password);
                         Properties properties = new Properties();
                         properties.setProperty("mail.smtp.auth", auth);
                         properties.setProperty("mail.smtp.ssl.enable", enableSSL);
                         properties.setProperty("mail.debug", debug);
                         properties.setProperty("mail.smtp.timeout", timeout);
                         javaMailSenderImpl.setJavaMailProperties(properties);
                     }
                 }
             }
             return javaMailSenderImpl;
         }
      
      }
      
      
    4. 邮件发送工具类

      public class JavaMailSenderUtils {
      
         /**
          * 测试发送邮件 实际中可以在service中使用(若使用的spring配置的方式创建JavaMailSender,则需注入使用)
          * 此处为方便使用main方法
          * @param args
          */
         public static void main(String[] args) {
             JavaMailSenderInfo javaMailSenderInfo = new JavaMailSenderInfo();
             javaMailSenderInfo.setToAddress("发件人");
             javaMailSenderInfo.setSubject("邮件主题");
             javaMailSenderInfo.setContent("邮件内容");
             javaMailSenderInfo.setHtml(true);
             List<String> list = new ArrayList<>();
             list.add("图片1");
             // list.add("图片2");
             // list.add("图片3");
             // list.add("图片4");
             javaMailSenderInfo.setPhotoList(list);
             javaMailSenderInfo.setAttachList(list);
             // JavaMailSenderUtils.sendSimpleMail(javaMailSenderInfo);
             JavaMailSenderUtils.sendPhotoMail(javaMailSenderInfo);
             // JavaMailSenderUtils.sendAttacheMail(javaMailSenderInfo);
             // JavaMailSenderUtils.sendPhotoAndAttacheMail(javaMailSenderInfo);
      
         }
      
         private static final JavaMailSender javaMailSender = InitJavaMailSender.getJavaMailSender();
      
         private static final String htmlStartStr = "<html><body>";
      
         private static final String htmlEndStr = "</body></html>";
      
         /**
          * 发送简单邮件 文本 html
          * @param javaMailSenderInfo
          * @return
          */
         public static boolean sendSimpleMail(JavaMailSenderInfo javaMailSenderInfo) {
             // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
             MimeMessage mimeMessage = javaMailSender.createMimeMessage();
             MimeMessageHelper mimeMessageHelper = null;
             try {
                 // 创建消息辅助器 参数二 为true时为多组件 html 等
                 mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
                 // 设置公共字段
                 setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
                 // 文本内容 可指定是否是html
                 mimeMessageHelper.setText(javaMailSenderInfo.getContent(), javaMailSenderInfo.isHtml());
                 javaMailSender.send(mimeMessage);
                 System.out.println("简单邮件发送成功");
                 return true;
             } catch (MessagingException e) {
                 e.printStackTrace();
                 System.out.println("简单邮件发送失败");
                 return false;
             }
         }
      
         /**
          * 发送带图片的邮件
          * @param javaMailSenderInfo
          * @return
          */
         public static boolean sendPhotoMail(JavaMailSenderInfo javaMailSenderInfo) {
             // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
             MimeMessage mimeMessage = javaMailSender.createMimeMessage();
             MimeMessageHelper mimeMessageHelper = null;
             try {
                 mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
                 setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
                 List<String> photoList = javaMailSenderInfo.getPhotoList();
                 // html内容
                 StringBuilder text = new StringBuilder(htmlStartStr);
                 text.append(javaMailSenderInfo.getContent());
                 if (!CollectionUtils.isEmpty(photoList)) {
                     for (String photo : photoList) {
                         // 每个图片创建一个标题吧 每个图片关联一个cid
                         String cid = UUID.randomUUID().toString();
                         text.append("<br/><h1>"+ javaMailSenderInfo.getSubject() +"</h1><br/><img src='cid:"+ cid +"'/>");
                         mimeMessageHelper.addInline(cid, new File(photo));
                     }
                 }
                 // 为什么会有最后一个图片图裂不显示的问题(求大佬指点)
                 // String cid = UUID.randomUUID().toString();
                 // mimeMessageHelper.addInline(cid, new File(""));
                 text.append(htmlEndStr);
                 mimeMessageHelper.setText(text.toString(),true);
                 javaMailSender.send(mimeMessage);
                 System.out.println("带图片的邮件发送成功");
                 return true;
             } catch (MessagingException e) {
                 e.printStackTrace();
                 System.out.println("带图片的邮件发送失败");
                 return false;
             }
         }
      
         /**
          * 发送带附件的邮件
          * @param javaMailSenderInfo
          * @return
          */
         public static boolean sendAttacheMail(JavaMailSenderInfo javaMailSenderInfo) {
             // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
             MimeMessage mimeMessage = javaMailSender.createMimeMessage();
             MimeMessageHelper mimeMessageHelper = null;
             try {
                 mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
                 setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
                 List<String> attachList = javaMailSenderInfo.getAttachList();
                 // 邮件文本
                 mimeMessageHelper.setText(javaMailSenderInfo.getContent(), javaMailSenderInfo.isHtml());
                 if (!CollectionUtils.isEmpty(attachList)) {
                     for (String attach : attachList) {
                         // 添加附件(最后一个附件是图片也存在图裂的问题,但可下载使用,求大佬指点)
                         FileSystemResource fileSystemResource = new FileSystemResource(attach);
                         // 参数一为附件名称
                         mimeMessageHelper.addAttachment(fileSystemResource.getFilename(), fileSystemResource);
                     }
                 }
                 javaMailSender.send(mimeMessage);
                 System.out.println("带附件的邮件发送成功");
                 return true;
             } catch (MessagingException e) {
                 e.printStackTrace();
                 System.out.println("带附件的邮件发送失败");
                 return false;
             }
         }
      
         /**
          * 发送带图片和附件的邮件
          * @param javaMailSenderInfo
          * @return
          */
         public static boolean sendPhotoAndAttacheMail(JavaMailSenderInfo javaMailSenderInfo) {
             // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
             MimeMessage mimeMessage = javaMailSender.createMimeMessage();
             MimeMessageHelper mimeMessageHelper = null;
             try {
                 mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
                 setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
                 List<String> photoList = javaMailSenderInfo.getPhotoList();
                 // 放入图片和内容
                 StringBuilder text = new StringBuilder(htmlStartStr + javaMailSenderInfo.getContent());
                 if (!CollectionUtils.isEmpty(photoList)) {
                     for (String photo : photoList) {
                         String cid = UUID.randomUUID().toString();
                         text.append("<br/><img src='cid:"+ cid +"'>");
                         mimeMessageHelper.addInline(cid, new File(photo));
                     }
                 }
                 text.append(htmlEndStr);
                 mimeMessageHelper.setText(text.toString(),true);
                 // 放入附件
                 List<String> attachList = javaMailSenderInfo.getAttachList();
                 if (!CollectionUtils.isEmpty(attachList)) {
                     for (String attach : attachList) {
                         // 添加附件
                         FileSystemResource fileSystemResource = new FileSystemResource(attach);
                         // 参数一为附件名称
                         mimeMessageHelper.addAttachment(fileSystemResource.getFilename(), fileSystemResource);
                     }
                 }
                 javaMailSender.send(mimeMessage);
                 System.out.println("带图片和附件的邮件发送成功");
                 return true;
             } catch (MessagingException e) {
                 e.printStackTrace();
                 System.out.println("带图片和附件邮件发送失败");
                 return false;
             }
         }
      
         /**
          * 发送由freemarker模板技术生成的邮件
          * @param javaMailSenderInfo
          * @return
          */
         public static boolean sendFreemarkerMail(JavaMailSenderInfo javaMailSenderInfo) {
             // 创建邮件消息 简单邮件可直接使用SimpleMailMessage
             MimeMessage mimeMessage = javaMailSender.createMimeMessage();
             MimeMessageHelper mimeMessageHelper = null;
             try {
                 mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "utf-8");
                 setMailCommonField(mimeMessageHelper, javaMailSenderInfo);
                 /**
                  * 此处没有实现采用模板技术(可自行探索)
                  * 封装模板所需要的数据
                  * 读取freemarker的模板文件 xxx.ftl 进行静态化,生成html形式的字符串
                  * 将生成好的html字符串设置到邮件的正文中
                  */
                 javaMailSender.send(mimeMessage);
                 System.out.println("freemarker模板技术生成的邮件发送成功");
                 return true;
             } catch (MessagingException e) {
                 e.printStackTrace();
                 System.out.println("freemarker模板技术生成的邮件发送失败");
                 return false;
             }
         }
      
         /**
          * 设置邮件的公共字段
          * @param mimeMessageHelper
          * @param javaMailSenderInfo
          * @throws MessagingException
          */
         private static void setMailCommonField(MimeMessageHelper mimeMessageHelper, JavaMailSenderInfo javaMailSenderInfo) throws MessagingException {
             // 发件人
             mimeMessageHelper.setFrom(InitJavaMailSender.username);
             // 收件人 多人用数组
             mimeMessageHelper.setTo(javaMailSenderInfo.getToAddress());
             // 主题
             mimeMessageHelper.setSubject(javaMailSenderInfo.getSubject());
             // 日期
             mimeMessageHelper.setSentDate(new Date());
         }
      
      }
      
      

    四、使用springboot发送邮件

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

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

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

    • 导入依赖

    • <!--springboot整合mail-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-mail</artifactId>
      </dependency>
      
    1. 修改配置

      # 邮件的设置 导入mail启动包 使用时注入直接JavaMailSender即可
      spring:
         mail:
             protocol: smtp
             host: smtp.qq.com
             port: 465
             default-encoding: utf-8
             username: 邮箱用户名
             password: 邮箱授权码
             test-connection: true
             properties:
               mail:
                 debug: true
                 smtp:
                   auth: true
                   timeout: 20000
                   ssl:
                     enable: true
      
    2. 直接在service层中使用即可

      public MailServiceImpl {
         
         @Autowired
         private JavaMailSender javaMailSender;
         
         // 以下代码使用即可
         ...
      }
      
  • 相关阅读:
    LinkedList源码解析
    四种List实现类的对比总结
    HashMap源码解析
    Flutter——Switch组件(开关组件)
    Flutter——Radio组件、RadioListTile组件(单选按钮组件)
    Flutter——Checkbox组件、CheckboxListTile(多选框组件)
    Flutter——TextField组件(文本框组件)
    Flutter——FloatingActionButton组件(浮动按钮组件)
    Flutter中的按钮组件介绍
    Flutter——Drawer、DrawerHeader、UserAccountsDrawerHeader组件(侧边栏组件)
  • 原文地址:https://www.cnblogs.com/xiaokantianse/p/13948245.html
Copyright © 2011-2022 走看看