JavaWeb 文件上传与邮件发送

一、JavaWeb 文件上传

1.1 概述

• 配置 Servlet 和 jsp 环境；

• 文件上传需要的 jar 包：

  • commons-io-2.11.0.jar
  • commons-fileupload-1.4.jar

• 或导入 Maven 依赖：

  <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.11.0</version>
  </dependency>
  
  <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.4</version>
  </dependency>
  复制代码

• 文件上传，注意事项：

  • 为保证服务器安全，上传文件应放在外界无法直接访问的目录下，如：WEB-INF 目录下；
  • 为防止文件被覆盖，要为上传文件，生成一个 唯一的文件名；
  • 要 限制 上传文件的 最大值；
  • 可以限制上传文件的类型，在收到上传文件名时，判断后缀名是否合法；
  • 表单 method 属性，应该设置为 POST 方法，不能使用 GET 方法；

1.2 使用到的类

1. ServletFileUpload

• 负责处理上传的文件数据，并将表单中每个输入项，封装成一个 FileItem 对象；
  • parseRequest(HttpServletRequest) 方法，可以将表单中，每一个 HTML 标签提交的数据，封装成一个 FileItem 对象，然后以 List 列表的形式返回；
• 在使用 ServletFileUpload 对象解析请求时，需要用到 DiskFileItemFactory 对象，所以，使用前，需要先构造好 DiskFileItemFactory 对象；
• 通过 ServletFileUpload 对象的构造方法，或 setFileItemFactory() 方法，设置ServletFileUpload 对象的 fileItemFactory 属性。

2. FileItem

• 必须设置 input 输入项的 name 属性为 file，否则，浏览器不会发送上传文件的数据；

  • <input type="file" name="filename">；

• 表单如果包含一个文件上传输入项的话，这个表单的 enctype 属性就必须设置为multipart/form-data；

• 表单：

  <%--
    通过表单上传文件
    get：上传文件大小由限制
    post：大小没限制
  --%>
  <form action="" enctype="multipart/form-data" method="post">
      <p><input type="file" name="fileName"></p>
      <p>
          <input type="submit" name="submit">
          <input type="reset" name="reset">
      </p>
  </form>
  复制代码

• 浏览器表单的类型，如果为 multipart/form-data，在服务器端要获取数据，就要通过流。

• 常用方法：

方法名	描述
boolean isFormField()	判断是否是文本表单，是返回 true，否则返回 false
string getFieldName()	返回表单标签 name 的属性值
string getstring()	数据流内容，以字符串返回
string getName()	获得上传文件名
Inputstream getInputstream()	以流的形式，返回上传文件的数据内容
void delete()	删除文件

3. DiskFileItemFactory

• 将请求消息实体中的每一个项目，封装成单独的 DiskFileItem ；
• FileItem 接口的实现对象，由 FileItemFactory 接口，默认实现 DiskFileItemFactory；
• 当上传的文件较小时，直接保存在内存中（速度快），文件较大时，以临时文件的形式，保存在磁盘临时文件夹（速度慢，但是内存资源是有限的）。

1.3 代码的实现逻辑

1. 判断用户上传的文件，是普通表单，还是带文件的表单，如果是普通文件，直接返回（return）；
2. 创建文件上传保存的路径，WEB-INF 路径下是安全的，用户无法直接访问；
3. 创建临时文件路径，如果文件超过预期大小，放到一个临时文件中；
4. 创建 DiskFileItemFactory 对象，设置文件临时路径 setRepository，或大小的限制（设置缓冲区，setSizeThreshold）；
5. 获取 ServletFileUpload 对象，处理乱码问题 setHeaderEncoding ，设置单个文件的最大值 setFileSizeMax ，设置总共能够上传文件的大小 setSizeMax ，还可选择监听文件上传进度 setProgressListener；
6. 通过 ServletFileUpload 对象的 parseRequest 方法，把前端请求解析，封装成一个FileItem 对象；
7. 判断上传的文件，是普通的表单，还是带文件的表单 isFormField ，getFieldName 获取前端表单控件的 name；
8. 通过 FileItem 的 getName 方法，获取文件名，并判断是否为空，可以使用 UUID 保证文件名唯一性；
9. 拼接文件真实存在路径，并给每个文件，创建一个对应的文件夹；
10. 通过 FileItem 的 getInputStream 方法获取文件上传的流，并创建一个文件输出流，将文件写入真实保存路径，最后关闭流；
11. 上传成功，将页面转发到新的提示页面。

1.4 代码实现

• 前端页面：文件上传 upload.jsp

<form action="${pageContext.request.contextPath}/upload.do" enctype="multipart/form-data" method="post">
    <p>上传用户：<input type="text" name="username"></p>
    <p>上传文件：<input type="file" name="file1"></p>
    <p>上传文件：<input type="file" name="file2"></p>
    <p>
        <input type="submit" name="submit"> | <input type="reset" name="reset">
    </p>
</form>
复制代码

• servlet：

package com.study.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.ProgressListener;
import org.apache.commons.fileupload.RequestContext;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.UUID;

@WebServlet("/upload.do")
public class UploadServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 判断上传文件是普通表单,还是带文件的表单
        if (!ServletFileUpload.isMultipartContent(new Rc(req))) {
            // 普通表单，终止方法运行，直接返回
            return;
        }
        // 创建文件保存路径，建议WEB-INF目录下，安全，用户无法直接访问
        String uploadPath = this.getServletContext().getRealPath("/WEB-INF/upload");
        System.out.println(uploadPath);
        File uploadFile = new File(uploadPath);
        // 文件夹不存在就创建
        if (!uploadFile.exists()) {
            uploadFile.mkdir();
        }
        // 缓存：临时路径,文件超过预期大小，放到临时文件夹中，过几天自动删除，或者提醒用户转存为永久
        String tmpPath = this.getServletContext().getRealPath("WEB-INF/tmp");
        File file = new File(tmpPath);
        if (!file.exists()) {
            file.mkdir();
        }

        // 处理上传的文件，一般通过流来获取，可以使用request.getInputStream(),原生态的文件上传流获取，十分麻烦；
        // 建议使用 Apache的文件上传组件来实现，common-fileupload，它需要依赖于 commons-io组件；

        // 1、创建DiskFileItemFactory对象，处理文件上传路径或大小的限制
        DiskFileItemFactory factory = getDiskFileItemFactory(uploadFile);
        // 2、获取ServletFileUpload
        ServletFileUpload upload = getServletFileUpload(factory);
        // 3、处理上传的文件
        try {
            String msg = uploadParseRequest(upload, req, uploadPath);
            req.setAttribute("msg", msg);
            req.getRequestDispatcher("info.jsp").forward(req, resp);
        } catch (FileUploadException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }

    /**
     * 处理文件上传路径或大小的限制：文件大小、编码有默认设置
     *
     * @param file
     * @return
     */
    public static DiskFileItemFactory getDiskFileItemFactory(File file) {
        DiskFileItemFactory factory = new DiskFileItemFactory();
        // 工厂设置：缓冲区大小（上传的文件大于这个缓冲区的时，存放到临时文件中）
        // 缓冲区大小为1M，可以不设置，有默认设置
        factory.setSizeThreshold(1024 * 1024);
        // 临时文件目录，需要一个File
        factory.setRepository(file);
        return factory;
    }

    /**
     * 获取ServletFileUpload
     *
     * @param factory
     * @return
     */
    public static ServletFileUpload getServletFileUpload(DiskFileItemFactory factory) {
        ServletFileUpload upload = new ServletFileUpload(factory);
        // 可选部分,可不设置==========================
        // 监听文件上传进度
        upload.setProgressListener(new ProgressListener() {
            @Override
            // pBytesRead：已经读取到的文件大小
            // pContentLength：文件大小
            public void update(long pBytesRead, long pContentLength, int pItems) {
                System.out.println("总大小：" + pContentLength + "已上传" + pBytesRead);
            }
        });
        // 处理乱码问题
        upload.setHeaderEncoding("utf-8");
        // 设置单个文件的最大值 10M
        upload.setFileSizeMax(1024 * 1024 * 10);
        // 设置总共能够上传文件的大小
        upload.setSizeMax(1024 * 1024 * 10);
        // =====================================
        return upload;
    }

    /**
     * 处理上传的文件
     *
     * @param upload
     * @param req
     * @param uploadPath
     * @return
     * @throws FileUploadException
     * @throws IOException
     */
    public static String uploadParseRequest(ServletFileUpload upload, HttpServletRequest req,
                                            String uploadPath) throws FileUploadException, IOException {
        String msg = "";
        // 把前端请求解析，封装成一个FileItem对象（tomcat10 req需要处理，非则报错）
        List<FileItem> fileItems = upload.parseRequest(new Rc(req));
        for (FileItem fileItem : fileItems) {
            if (fileItem.isFormField()) {
                String name = fileItem.getFieldName();
                String value = fileItem.getString("UTF-8");
                System.out.println(name + ":" + value);
            } else {
                //****************************处理文件****************************
                // 拿到文件名字
                String uploadFileName = fileItem.getName();
                System.out.println("上传的文件名：" + uploadFileName);
                if (uploadFileName.trim().equals("") || uploadFileName == null) {
                    continue;
                }
                // 获得上传的文件名
                String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/") + 1);
                // 获得文件的后缀名
                String fileExName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1);

                // 如果文件后缀名fileExName不是所需的直接return，不进行处理，告诉用户文件类型不对
                System.out.println("文件信息 [文件名：" + fileName + "---文件类型" + fileExName + "]");

                // UUID.randomUUID，随机生一个唯一识别的通用码
                // 网络传输中的东西，都需要序列化
                // pojo，实体类，如果想要在多个电脑运行，传输--->需要吧对象都序列化了
                // JNI=java Native Interface
                // implements Serializable ：标记接口，JVM--->java栈 本地方法栈 native-->c++
                // 可以使用UUID（唯一识别通用码）保证文件名唯一（生成目录）
                String uuidPath = UUID.randomUUID().toString();
                //****************************处理文件完毕****************************
                // 设置存储路径：创建目录/UUID生成目录
                String realPath = uploadPath + "/" + uuidPath;
                // 给每个文件创建一个对应的文件夹
                File realPathFile = new File(realPath);
                if (!realPathFile.exists()) {
                    realPathFile.mkdir();
                }
                //****************************存放地址完毕*****************************
                // 获得文件上传的流
                InputStream inputStream = fileItem.getInputStream();
                // 创建一个文件输出流
                // realPath是真实的文件夹
                FileOutputStream fos = new FileOutputStream(realPath + "/" + fileName);
                // 创建一个缓冲区
                byte[] buffer = new byte[1024 * 1024];
                // 判断是否读取完毕
                int len = 0;
                while ((len = inputStream.read(buffer)) > 0) {
                    fos.write(buffer, 0, len);
                }
                // 关闭流
                fos.close();
                inputStream.close();
                msg = "文件上传成功";
                // 上传成功，清除临时文件
                fileItem.delete();
                //*************************文件传输完毕**************************
            }
        }
        return msg;
    }

    // tomcat10 处理req，非则报错
    static class Rc implements RequestContext {
        HttpServletRequest request = null;

        public Rc(HttpServletRequest request) {
            this.request = request;
        }

        @Override
        public String getCharacterEncoding() {
            return request.getCharacterEncoding();
        }

        @Override
        public String getContentType() {
            return request.getContentType();
        }

        @Override
        public int getContentLength() {
            return request.getContentLength();
        }

        @Override
        public InputStream getInputStream() throws IOException {
            return request.getInputStream();
        }
    }
}
复制代码

• 返回页面：info.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>消息提示</title>
</head>
<body>
${msg}
</body>
</html>
复制代码

• 注册 Servlet：配置 web.xml 或通过注解 @WebServlet("/upload.do")

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                      https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
    <servlet>
        <servlet-name>UploadServlet</servlet-name>
        <servlet-class>com.study.servlet.UploadServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>UploadServlet</servlet-name>
        <url-pattern>/upload.do</url-pattern>
    </servlet-mapping>
</web-app>
复制代码

• 测试结果：

  

二、文件下载

2.1 概述

• 文件下载，可以通过 Servlet 类、输入和输出流实现；
• HTTP 协议中设置响应头，告知处理数据的方式为下载方式：

// 二进制文件
resp.addHeader("Content-Type","application/octet-stream");
// 这是一个附件下载
resp.addHeader("Content-Disposition","attachment;filename="+filename);      
复制代码

• 当点击下载链接时，把请求传给 Servelt，在 Servlet 中：
  1. 获取下载文件的地址，并根据地址，创建文件字节输入流；
  2. 通过流，读取下载的文件内容，最后将读取的内容，通过输出流写入目标文件中。

2.2 代码实现

• 前端页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件下载</title>
</head>
<body>
<a href="${pageContext.request.contextPath}/download?filename=1.xlsx">文件下载</a>
</body>
</html>
复制代码

• Servlet：

@WebServlet("/download")
public class DownloadServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1.从前端获取下载文件名
        String fileName = req.getParameter("filename");
        // 2.获取下载路径
        String realPath = this.getServletContext().getRealPath("/download/" + fileName);
        // 3. 设置浏览器的下载支持(Content-Disposition)，并将文件名转码，避免乱码
        resp.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
        // 4.获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
        // 5.创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
        // 6.获取 OutputStream 对象
        ServletOutputStream out = resp.getOutputStream();
        // 7.将 FileOutputStream 流写入到 buffer 缓冲区,使用 OutputStream，将缓冲区中的数据，输出到客户端
        while ((len = in.read(buffer)) > 0) {
            out.write(buffer, 0, len);
        }
        // 8.关闭流
        in.close();
        out.close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
复制代码

• 注册 Servlet：配置 web.xml 或通过注解方式 @WebServlet("/download")

三、邮件发送

3.1 邮件的发送与接收原理

• 要实现电子邮件功能，必须有专门的 电子邮件服务器；

  

• 电子邮箱（E-Mail 地址）的获得，需要在邮件服务器上进行申请：

  • 以 QQ邮箱 为例，需要从账户设置中开启 POP3/SMTP 服务。

    

• 用户连接邮件服务器，需要遵循一定的通讯规则：

  • 发送：SMTP 协议；
  • 接收：POP3 协议；

3.2 邮件的发送与接收过程

模拟邮件发送与接收：

• 发送：[email protected] 通过 smtp 协议，连接到 QQ 邮箱的 smtp 服务器，并将邮件发送给服务器，接着，QQ 邮箱的 smtp 服务器，将邮件 转投 给 163 的 smtp 服务器；

• 接收：163 的 smtp 服务器，将接收到的邮件，存储到 [email protected] 的存储空间中，[email protected]通过 POP3 协议，连接到 163 的 POP3 服务器上，收取邮件，POP3 服务器从 [email protected] 账号的存储空间中，取出该邮件，并回送给 [email protected] 账户；

3.3 代码实现邮件的发送

• 用到的包：

  • mail-2.1.0.jar
  • activation-2.1.0.jar

• 或 Maven 导入依赖：

  <dependency>
      <groupId>com.sun.mail</groupId>
      <artifactId>jakarta.mail</artifactId>
      <version>2.0.1</version>
  </dependency>
  
  <dependency>
      <groupId>jakarta.activation</groupId>
      <artifactId>jakarta.activation-api</artifactId>
      <version>2.1.0</version>
  </dependency>
  复制代码

• QQ 邮箱，需获取授权码

  • QQ 邮箱 -> 设置 -> 帐户 -> 开启 pop3/smtp 服务 -> 生成授权码（需手机验证）;

1. 简单邮件发送（没有图片和附件）

• 实现过程：

  1. 创建 session 对象；

  2. 创建 Transport 对象；

  3. 使用邮箱的用户名和授权码，连上邮件服务器；

  4. 创建 Message 对象（需传递 session）message 需要指明发件人、收件人以及文件内容；

     

  5. 发送邮件；

  6. 关闭连接；

• 实例：

package com.sutdy.mail;

import com.sun.mail.util.MailSSLSocketFactory;
import jakarta.mail.*;
import jakarta.mail.internet.InternetAddress;
import jakarta.mail.internet.MimeMessage;

import java.util.Properties;

public class MailDemo01 {
    public static void main(String[] args) throws Exception {
        Properties prop = new Properties();
        // 设置邮件服务器
        prop.setProperty("mail.host", "smtp服务器地址");
        // 邮件发送协议
        prop.setProperty("mail.transport.protocol", "smtp");
        // 需要验证用户密码
        prop.setProperty("mail.smtp.auth", "true");

        /* QQ邮箱需要设置SSL加密(其它邮箱不需要)
        MailSSLSocketFactory sf = new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.smtp.ssl.enable", "true");
        prop.put("mail.smtp.ssl.socketFactory", sf);
        */

        // 使用javaMail发送邮件的6个步骤
        // 1.创建定义整个应用程序所需要的环境信息的session对象
         
        /* QQ邮箱需要，其它不需要
        Session session = Session.getDefaultInstance(prop, new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("邮箱", "授权码");
            }
        });
        */

        Session session = Session.getDefaultInstance(prop);
        // 开启session的debug模式，这样可以查看到程序发送Email的运行状态
        session.setDebug(true);
        // 2.通过session得到transport对象
        Transport ts = session.getTransport();
        // 3.使用邮箱的用户名和密码连上邮件服务器（QQ邮箱：密码为 授权码）
        ts.connect("smtp服务器地址", "邮箱用户名", "邮箱密码");
        // 4.创建邮件：写文件
        // 注意需要传递session
        MimeMessage message = new MimeMessage(session);
        // 指明邮件的发件人
        message.setFrom(new InternetAddress("发件人邮箱"));
        // 指明邮件的收件人
        message.setRecipient(Message.RecipientType.TO, new InternetAddress("收件人邮箱"));
        // 邮件标题
        message.setSubject("标题");
        
        // 邮件的内容：文本（如有附件，图片等，只需更改此处内容）
        message.setContent("内容", "text/html;charset=UTF-8");
        
        // 5.发送邮件
        ts.sendMessage(message, message.getAllRecipients());
        // 6.关闭连接
        ts.close();
    }
}
复制代码

2. 复杂的邮件发送（带图片和附件）

• MIME：多用途互联网邮件扩展类型；

• MimeBodyPart 类：

  • jakarta.mail.internet.MimeBodyPart 类，表示 MIME 消息，和 MimeMessage 类一样，从 Part 接口继承过来；

• MimeMultipart 类：

  • jakarta.mail.internet.MimeMultipart 类，是抽象类 Mulitipart 的实现子类，用来组合多个 MIME 消息，一个 MimeMultipart 对象可以包含多个代表 MIME 消息的 MimeBodyPart 对象。

• 每一个文本、图片、附件，可以分为一个 MimeBodyPart，由 MimeMultipart 完成组装；

  

• 实例：邮件的内容部分，其余代码不变

// ===================邮件的内容：带图片和附件===================
// （1.1）准备图片内容
MimeBodyPart image = new MimeBodyPart();
// 图片需要经过数据化的处理
DataHandler dh = new DataHandler(new FileDataSource("图片路径"));
// 在part中放入,处理过图片的数据
image.setDataHandler(dh);
// 给这个part设置ID名字,后面通过 src的cid使用
image.setContentID("bz.jpg");

// （1.2）准备正文内容
MimeBodyPart text = new MimeBodyPart();
text.setContent("这是一张正文<img src='cid:bz.jpg'>", "text/html;charset=UTF-8");

// （1.3）准备附件内容
MimeBodyPart file = new MimeBodyPart();
file.setDataHandler(new DataHandler(new FileDataSource("文件路径")));
// 给附件设置别名
file.setFileName("1.txt");

// （2.1）描述数据关系
MimeMultipart multipart1 = new MimeMultipart();
multipart1.addBodyPart(image);
multipart1.addBodyPart(text);
// alternative 只能发送  文本
// related  发送文本 + 图片
// mixed    发送文本 + 图片 + 附件
multipart1.setSubType("related");

// （2.2）正文内容：图片+文本
MimeBodyPart contentText = new MimeBodyPart();
contentText.setContent(multipart1);

// （2.3）拼接所有内容：正文 + 附件
MimeMultipart allFile = new MimeMultipart();
// 添加附件
allFile.addBodyPart(file);
// 添加正文内容
allFile.addBodyPart(contentText);
allFile.setSubType("mixed");

// （3）设置到消息中，保存修改
// 把编辑好的邮件放到消息中
message.setContent(allFile);
// 保存修改
message.saveChanges();

// 5.发送邮件
ts.sendMessage(message, message.getAllRecipients());
// 6.关闭连接
ts.close();
复制代码

3. JavaWeb 发送邮件

• 实现：用户注册成功后，系统自动给用户邮箱发送邮件；

• 创建项目，并导入 JavaWeb 所需的相关依赖；

• 项目结构：

  

• 前端注册页面：index.jsp

<form action="${pageContext.request.contextPath}/RegisterServlet.do" method="post">
    <p>
        <label for="username">用户名：</label>
        <input type="text" name="username" id="username">
    </p>
    <p>
        <label for="pwd">密码：</label>
        <input type="text" name="password" id="pwd">
    </p>
    <p>
        <label for="email">邮箱：</label>
        <input type="text" name="email" id="email">
    </p>
    <p><input type="submit" value="注册"></p>
</form>
复制代码

• 前端响应页面：info.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>注册成功</title>
</head>
<body>
${message}
</body>
</html>
复制代码

• 工具类：邮件发送核心类；

public class Sendmail extends Thread {
    // 用于发送邮件的邮箱
    private String from = "发件邮箱";
    // 邮箱用户名
    private String username = "发件邮箱用户名";
    // 邮箱密码
    private String password = "发件邮箱密码";
	// 邮箱服务器 smtp
    private String host = "发件邮箱服务器";
    
    // 调用User类
    private User user;  
    public Sendmail(User user) {
        this.user = user;
    }

    @Override
    // 重写run方法，在run方法中发送邮件给指定用户
    public void run() {
        try {
            Properties prop = new Properties();
            // 设置邮件服务器
            prop.setProperty("mail.host", host);
            // 邮件发送协议
            prop.setProperty("mail.transport.protocol", "smtp");
            // 需要验证用户密码
            prop.setProperty("mail.smtp.auth", "true");

            /* QQ邮箱需要设置SSL加密(其它邮箱不需要)
               MailSSLSocketFactory sf = new MailSSLSocketFactory();
               sf.setTrustAllHosts(true);
               prop.put("mail.smtp.ssl.enable", "true");
               prop.put("mail.smtp.ssl.socketFactory", sf);
             */

            // 使用javaMail发送邮件的6个步骤
            // 1.创建定义整个应用程序所需要的环境信息的session对象

            /* QQ邮箱需要，其它不需要
                Session session = Session.getDefaultInstance(prop, new Authenticator() {
                    @Override
                    protected PasswordAuthentication getPasswordAuthentication() {
                        return new PasswordAuthentication("发件邮箱", "授权码");
                    }
                });
             */

            Session session = Session.getDefaultInstance(prop);
            // 开启session的debug模式，这样可以查看到程序发送Email的运行状态
            session.setDebug(true);
            // 2.通过session得到transport对象
            Transport ts = null;
            ts = session.getTransport();
            // 3.使用邮箱的用户名和授权码连上邮件服务器
            ts.connect(host, username, password);
            // 4.创建邮件：写文件
            // 注意需要传递session
            MimeMessage message = new MimeMessage(session);
            // 指明邮件的发件人
            message.setFrom(new InternetAddress(from));
            // 指明邮件的收件人：前端获取 user.getEmail()
            message.setRecipient(Message.RecipientType.TO, new InternetAddress(user.getEmail()));
            // 邮件标题
            message.setSubject("注册通知");

            // 邮件的文本内容（只需更换此处内容）
            String info = "恭喜您注册成功，您的用户名：" + user.getUsername() + " ,密码：" + user.getPassword();
            message.setContent(info, "text/html;charset=UTF-8");

            // 5.发送邮件
            ts.sendMessage(message, message.getAllRecipients());
            // 6.关闭连接
            ts.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
复制代码

• servlet：

@WebServlet("/RegisterServlet.do")
public class RegisterServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 前端获取属性值
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String email = req.getParameter("email");
        // 创建User对象，存储属性值
        User user = new User(username, password, email);

        // 用户注册成功后，给用户发送邮件
        // 使用线程发送邮件，防止出现耗时和网站人多的情况
        Sendmail send = new Sendmail(user);
        // 启动线程，线程启动后就会执行run方法，发送邮件
        send.start();
        System.out.println("success");

        // 注册用户，响应页面
        req.setAttribute("message", "注册成功！已发送邮件，请注意查收");
        req.getRequestDispatcher("info.jsp").forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
复制代码

• 注册 Servlet：配置 web.xml 或通过注解方式 @WebServlet("/RegisterServlet.do")

• 出现异常：

  

• 解决方法：将 jar 包，复制到 Tomcat 的 lib 目录下：

  

4. springboot 实现邮件发送

• 创建 springboot 空项目；
• 导入依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>   
</dependency>
复制代码

• 测试类：

@SpringBootTest
class Demo1ApplicationTests {
    // 注入Java邮件发送包
    @Autowired
    JavaMailSenderImpl javaMailSender;

    // 普通文本邮件
    @Test
    void contextLoads() {
        // 发送邮件
        // 邮件接收人
        // 内容
        // 创建邮件消息
        SimpleMailMessage message = new SimpleMailMessage();
        // 设置主题
        message.setSubject("SpringBoot 发送邮件");
        // 设置文本内容
        message.setText("SpringBoot 邮件测试");
        // 发送者
        message.setFrom("发件人邮箱");
        // 接受者
        message.setTo("收件人邮箱");
        // 发送
        javaMailSender.send(message);
    }

    // 带附件的邮件
    @Test
    void test() throws Exception {
        // 带附件带图片  需要创建发送消息
        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
        // 创建处理类   处理 mimeMessage   true  为更改编码
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);

        helper.setSubject("SpringBoot 带附件的邮件");
        helper.setText("<h1>SpringBoot 带附件的邮件</h1>", true);

        // new File()  指向文件的路径 + 文件名字
        helper.addAttachment("测试文档.txt", new File("路径"));
        helper.addAttachment("测试图片.png", new File("路径"));
        helper.setFrom("发件人邮箱");
        helper.setTo("收件人邮箱");
        javaMailSender.send(mimeMessage);
    }
}
复制代码

• 编写 springboot 配置文件：

# 邮箱的用户名
spring.mail.username=邮箱的用户名
# 邮箱的密码  QQ邮箱为：授权码
spring.mail.password=邮箱的密码
# smtp服务器
spring.mail.host=smtp服务器
# 需要验证用户密码  设置为安全的
spring.mail.properties.mail.smtyp.ssl.enable=true
复制代码