JavaWeb

B站狂神说的JavaWeb学习的笔记

1.Java Web

Web应用程序

一个web应用由多个部分组成（静态web，动态web）

• html、css、js
• jsp、servlet
• java程序
• jar包
• 配置文件（properties）

静态Web

• .html,.htm 这些都是网页的后缀
• 静态web的缺点
  • Web页面无法动态更新，所有用户看到都是同一个页面
  • 他无法和数据库交互（数据无法持久化，用户无法交互）

动态Web

• 页面会动态展示：“Web页面展示的效果因人而异”；

2.Web服务器

1.技术

ASP:

• 微软:国内最早流行的就是ASP

PHP:

• 开发速度快,功能很强大,跨平台,代码简单
• 无法承载大访问的情况(局限性)

JSP/Servlet:

• sun工资主推的B/S架构
• 基于Java语言的(所有的大公司,或者开源的组件,都是Java写的)
• 可以承载三高问题带来的我影响
• 语法像ASP

2.web服务器

服务器是一种被动的操作,用来处理用户的一些请求和给用户一些响应信息

IIS

• 微软的服务器
• ASP,Windows中自带的

Tomcat

• Tomcat实际上运行JSP页面和Servlet,具有处理HTML页面的功能
• 他还是一个Servlet和Jsp容器
• 最新版本9.0

3.Tomcat

在config中的server.xml中配置

• 配置端口号

  • Tomcat默认:8080
  • Mysql默认:3306
  • Oracle默认:1521
  • Http默认:80
  • Https默认:443

   <Connector port="8080" protocol="HTTP/1.1"
                 connectionTimeout="20000"
                 redirectPort="8443"
  	URIEncoding="UTF-8" />
  

• 配置主机的名称

  • 默认主机名:localhost->127.0.0.1
  • 默认网站应用存放的位置为:webapps

  <Host name="localhost"  appBase="webapps"
              unpackWARs="true" autoDeploy="true">
  

  高难度面试题

  谈谈网站是如何访问的

  1. 输入一个域名;回车
  2. 检查本机的C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名的映射;
     • 有:直接返回对应的ip地址
     • 没有:去DNS服务器找

4.Http

1.什么是Http

Http(超文本传输协议)是一个简单的请求响应协议,它通常运行在TCP之上

• 文本:html,字符串,…
• 超文本:图片,音乐,视频…
• 80

Https:更安全的

• 443

2.两个时代

• http1.0
  • http/1.0: 客户端可以与web服务器连接后,只能获得一个web资源,断开连接
• http2.0
  • http/1.1: 客户端可以与web服务器连接后,可以获得多个web资源.

3.Http请求

• 客户端—>发请求Rrequest)—>服务器

1. 请求行

   请求方式: Get/Post/HEAD/DELETE/PUT…

   • Get:请求携带的参数少,大小有限制,会在URL显示,高效
   • Post:参数无限制,不会在URL显示,没有Get高效

2. 消息头

   Accept:告诉浏览器,它支持的数据类型
   Accept-Encoding:支持那种编码格式 GBK UTF-8
   Accept-Language:语言环境
   Cache-Control:缓存控制
   Connection:是否保持连接
   HOST:主机
   

4.Http响应

• 服务器—>响应—>客户端

1. 响应体

   Accept:告诉浏览器,它支持的数据类型
   Accept-Encoding:支持那种编码格式 GBK UTF-8
   Accept-Language:语言环境
   Cache-Control:缓存控制
   Connection:是否保持连接
   HOST:主机
   Refresh:设置自动刷新
   Location:让网页重新定位
   

2. 响应状态码

   200:请求响应成功

   3××:请求重定向

   404:找不到资源

   5××:服务器代码错误 500 502:网管错误

常见面试题

当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示,过程

5.Maven

• Maven项目架构管理工具
• Maven的核心思想:约定大于配置

使用Maven

1. 下载安装Maven

   下载完解压即可

2. 配置环境变量

   • M2_HOME Maven下的bin目录
   • MAVEN_HOME Maven的目录
   • 系统的path中配置 Maven下的bin目录

3. 配置阿里云镜像

    <mirrors>
    	<mirror>
   	<id>nexus-aliyun</id>  
    	 <name>nexus aliyun</name>  
     <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
     	<mirrorOf>*,!jeecg,!jeecg-snapshots</mirrorOf> 
   	</mirror>
       </mirrors>
   

4. 配置本地仓库

       <localRepository>D:\apache-maven\Maven-pro</localRepository>
   

5. 在IDEA中使用Maven

   1. 打开IDEA
   2. 创建Maven项目
   3. 选择maven-archetype-webapp(一个简单的mavenweb项目)
   4. 选择配置文件和本地仓库
   5. IDEA中的Maven设置(setting—>Build—>Maven)
   6. 在src下创建java和resource文件夹

6. 在IDEA中配置Tomcat

7. pom.xml文件

   <?xml version="1.0" encoding="UTF-8"?>
   <!--Maven本本和头文件-->
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
   
   <!-- 这里就是创建项目时配置的 -->
     <groupId>org.example</groupId>
     <artifactId>JavaWeb-01-Maven</artifactId>
     <version>1.0-SNAPSHOT</version>
   <!--
   package：项目打包方式
   jar：java应用
   war：javaweb应用
     -->
     <packaging>war</packaging>
   
     <name>JavaWeb-01-Maven Maven Webapp</name>
     <!-- FIXME change it to the project's website -->
     <url>http://www.example.com</url>
   
   
     <!--配置-->
     <properties>
   <!-- 项目默认构建编码   -->
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   <!--  编码版本  -->
       <maven.compiler.source>1.7</maven.compiler.source>
       <maven.compiler.target>1.7</maven.compiler.target>
     </properties>
   
   <!-- 项目依赖 -->
     <dependencies>
   <!--  具体依赖的jar包  -->
       <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.11</version>
       </dependency>
     </dependencies>
   
   <!-- 项目构建用的东西 -->
     <build>
       <finalName>JavaWeb-01-Maven</finalName>
       <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
         <plugins>
           <plugin>
             <artifactId>maven-clean-plugin</artifactId>
             <version>3.1.0</version>
           </plugin>
           <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
           <plugin>
             <artifactId>maven-resources-plugin</artifactId>
             <version>3.0.2</version>
           </plugin>
           <plugin>
             <artifactId>maven-compiler-plugin</artifactId>
             <version>3.8.0</version>
           </plugin>
           <plugin>
             <artifactId>maven-surefire-plugin</artifactId>
             <version>2.22.1</version>
           </plugin>
           <plugin>
             <artifactId>maven-war-plugin</artifactId>
             <version>3.2.2</version>
           </plugin>
           <plugin>
             <artifactId>maven-install-plugin</artifactId>
             <version>2.5.2</version>
           </plugin>
           <plugin>
             <artifactId>maven-deploy-plugin</artifactId>
             <version>2.8.2</version>
           </plugin>
         </plugins>
       </pluginManagement>
     </build>
   </project>
   

8. 配置资源导出问题

   <!-- 在build中配置resource,防止资源导出失败   -->
       <build>
           <resources>
               <resource>
                   <directory>src/main/resources</directory>
                   <includes>
                       <include>**/*.properties</include>
                       <include>**/*.xml</include>
                   </includes>
                   <filtering>true</filtering>
               </resource>
               <resource>
                   <directory>src/main/java</directory>
                   <includes>
                       <include>**/*.properties</include>
                       <include>**/*.xml</include>
                   </includes>
                   <filtering>true</filtering>
               </resource>
           </resources>
       </build>
   

6.Servlet

1.Servlet简介

• servlet就是sun公司开发动态web的一门技术
• 开发Servlet需要两步
  • 编写一个类,实现Servlet接口
  • 把写好的java类部署到web服务器中
• 把实现了Servlet接口的程序叫做,Servlet

2.Hello Servlet

• 编写Servler类

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter out = resp.getWriter();
        out.println("Hello Servlet!!!!!!");
    }

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

• web服务器配置servlet映射

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.dong.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

​ 一个Servlet可以对应多个servlet-mapping

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.dong.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello1</url-pattern>
</servlet-mapping>

可以自定义后缀

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

3.ServletContext(servlet上下文)

在web容器启动时,为每个servlet创建一个对应的ServletContext对象,代表当前应用

1.共享数据

在一个servlet中存入数据,可以在另外一个servlet中读取

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //this.getInitParameter();//初始化参数
        //this.getServletConfig();//配置信息
        ServletContext s = this.getServletContext();//Servlet上下文
        String username = "东";
        s.setAttribute("username",username);
    }
}

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext s = this.getServletContext();
        String username = (String) s.getAttribute("username");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("名字"+username);
    }

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

2.获取初始化参数

<context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306/mysql</param-value>
</context-param>

public class DemoServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String url = context.getInitParameter("url");
        resp.getWriter().print(url);
    }

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

3.请求转发

public class Demo4Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        System.out.println("进入了ServletDemo4");
       // RequestDispatcher requestDispatcher = context.getRequestDispatcher("/demo");//请求的路径
        //requestDispatcher.forward(req,resp);//请求转发
        context.getRequestDispatcher("/demo").forward(req,resp);
    }

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

4.读取项目资源

username = root
password = 123456

public class Demo5Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream in = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties properties = new Properties();
        properties.load(in);
        String name = properties.getProperty("username");
        String pwd = properties.getProperty("password");
        resp.getWriter().print(name+":"+pwd);
    }

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

4.HttpServletResponse

web服务器就收到客户端的http请求,针对这个请求,分别创建一个代表请求的Request,和代表响应的Response

• 如果要获取客户端请求过来的参数:找HttpServletRequest
• 如果要给客户端响应一些信息:找HttpServletResponse

1.简单分类

1. 负责向浏览器发送数据的

ServletOutputStream getOutputStream();
PrintWriter
getWriter();

2. 负责向浏览器发送响应头的

void setCharacterEncoding(String var1);
void setContentLength(int var1);
void setContentLengthLong(long var1);
void setContentType(String var1);
void setDateHeader(String var1,long var2);
void addDateHeader(String var1,long var2);
void setHeader(String var1,String var2);
void addHeader(String var1,String var2);
void setIntHeader(String var1,int var2);
void addIntHeader(String var1,int var2);

3. 响应状态码

2.下载文件

1. 向浏览器输出信息

2. 下载文件

   1. 要获取下载文件的路径
   2. 下载的文件名
   3. 设置让浏览器下载
   4. 获取下载文件的输入流
   5. 创建缓冲器
   6. 获取OutPutStream
   7. 将FileOutPutStream流写入buffer缓冲区
   8. 使用OutputStream将缓冲区中的数据输出到客户端

   public class FileServlet extends HttpServlet {
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           //1. 要获取下载文件的路径
           String realPath = "G:\\IDEA\\JavaWeb\\JavaWeb-03\\target\\classes\\1.jpg";
           System.out.println("要下载的路径:"+realPath);
           //2. 下载的文件名
           String filename = realPath.substring(realPath.lastIndexOf("//") + 1);
           //3. 设置让浏览器下载
           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缓冲区
           while ((len = in.read(buffer))>0){
               out.write(buffer,0,len);
           }
           in.close();
           out.close();
           //8. 使用OutputStream将缓冲区中的数据输出到客户端
   
       }
   
       @Override
       protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           doGet(req, resp);
       }
   }
   

3.验证码功能

• 前端实现
• 后端实现,需要用到Java的图片类,生成图片

public class ImgServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //让浏览器3秒刷新一次
        resp.setHeader("refresh","3");
        //在内存中创建图片
        BufferedImage image = new BufferedImage(80, 20,BufferedImage.TYPE_INT_RGB);
        //得到图片,获得画笔
        Graphics2D graphics = (Graphics2D) image.getGraphics();
        //设置背景颜色
        graphics.setColor(Color.white);
        graphics.fillRect(0,0,80,20);
        //给图片写数据
        //给画笔换颜色
        graphics.setColor(Color.blue);
        graphics.setFont(new Font(null,Font.BOLD,20));
        graphics.drawString(makeNum(),0,20);
        //告诉浏览器,这个请求用图片的方式打开
        resp.setContentType("image/jpg");
        //网站缓存,不允许缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");
        //把图片写个浏览器
        ImageIO.write(image,"jpg",resp.getOutputStream());

    }
    //创建随机数
    private String makeNum(){
        Random random = new Random();
        String num = random.nextInt(9999999) + "";
        StringBuffer sb = new StringBuffer();
        //保证数字是7位的
        for (int i = 0; i<7-num.length() ; i++) {
            sb.append("0");
        }
        String s = sb.toString()+num;
        return s;
    }

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

4.实现重定向

void sendRedirect();

public class RedirectSetvlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*
        * 重定向原理
        * resp.setHeader("Location","/image");
          resp.setStatus(302);
        * */
       resp.sendRedirect("/image");
    }

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

面试题:重定向和转发的区别?

相同点:

• 都会实现页面跳转

不同点:

• 请求转发的时候,url不会发生变化 307
• 重定向的时候,url会发生变化 302

5.HttpServletRequest

可以通过Request的方法获得客户端的信息

1.获得前端的参数

String request.getParameter(String s);
String[] request.getParameterValues(String s);

2.请求转发

req.getRequestDispatcher(String url).forward(req,resp);

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbys = req.getParameterValues("hobbys");
        System.out.println("===========================");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbys));
        req.getRequestDispatcher("/success.jsp").forward(req,resp);
    }

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

7.Session,Cookie

1.会话

会话 : 用户打开一个浏览器,点击了很多超连接,访问多个web资源,关闭浏览器,这个过程称为会话

2.保存会话的两种技术

cookie :

• 客户端技术(响应,请求)

session :

• 服务器技术,利用这个技术可以保存用户的会话信息

3.Cookie

1. 从请求中拿到cookie信息
2. 服务器响应给客户端cookie

 Cookie[] cookies = req.getCookies();//获得cookie
 c.getName();//得到cookie中的key
 c.getValue();//得到cookie中的value
new Cookie(String key,String value);//新建一个cookie
 cookie.setMaxAge(24*60*60);//设置cookie的有效期
 resp.addCookie(cookie);//响应给客户端一个cookie
 

public class CookieDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        PrintWriter out = resp.getWriter();
        //保存上一次访问的时间
        //Cookie,服务器从客户端获取
        Cookie[] cookies = req.getCookies();
        //判断cookie是否存在
        if(cookies!=null){
            out.write("你上一次访问的时间是");
            for (int i =0;i<cookies.length;i++) {
                Cookie c = cookies[i];
                //获取cookie的名字
               if(c.getName().equals("time")){
                   //获取cookie中的值
                   String value = c.getValue();
                   long l = Long.parseLong(value);
                   Date date = new Date(l);
                   out.write(date.toLocaleString());
               }

            }
        }else{
            out.write("这个您第一次访问网站");
        }
        //服务器给客户端响应cookie
        Cookie cookie = new Cookie("time",System.currentTimeMillis()+"");
        cookie.setMaxAge(24*60*60);
        resp.addCookie(cookie);

    }

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

cookie : 一般保存在本地用户目录下

解决乱码问题

URLEncoder.encode("东董","utf-8");//编码
URLDecoder.decode(c.getValue(),"utf-8");//解码

4.Session(重点)

• 服务器会给每一个用户(浏览器)创建一个Session对象
• 一个Session独占一个浏览器,只要浏览器没有关闭,这个Session就存在
• 保存用户的信息;保存购物车的信息

public class SessionDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决乱码
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        //得到Session
        HttpSession session = req.getSession();
        //给Session存东西
        session.setAttribute("name","东董");
        session.setAttribute("person",new Person("东董",18));
        //获取Session的id
        String id = session.getId();
        //判断session是不是新创建的
        boolean aNew = session.isNew();
        if (aNew){
            resp.getWriter().write("session创建成功,ID="+id);
        }else {
            resp.getWriter().write("已经存在,ID="+id);
        }

    }

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

public class SessionDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决乱码
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        //得到Session
        HttpSession session = req.getSession();
        //取出session中的值
        String name = (String) session.getAttribute("name");
        System.out.println(name);
        System.out.println((Person) session.getAttribute("person"));
    }

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

public class SessionDemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决乱码
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        //得到Session
        HttpSession session = req.getSession();
        //移除session中的值
        session.removeAttribute("name");
        session.removeAttribute("person");
        //注销session
        session.invalidate();

    }

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

<!--配置Session的自动失效时间-->
<session-config>
    <!-- 15分钟后 session自动失效 -->
    <session-timeout>15</session-timeout>
</session-config>

session和cookie的区别

• Cookie是把用户的数据写给用户的浏览器,浏览器保存(可以保存多个)
• Session把用户的数据写给用户独占Session中,服务器端保存(保存重要的信息,减少服务器资源的浪费)
• Session对象由服务创建

8.JSP

1.jsp原理

​ 发现页面转变成java程序

• tomcat中有一个work目录

• 发现页面转变成java程序

• 实际上是一个Servlet

  生命周期

  public void _jspInit() {
    }
  
    public void _jspDestroy() {
    }
  
    public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {
        
        
    }
  

  内置对象

  final javax.servlet.jsp.PageContext pageContext;
      javax.servlet.http.HttpSession session = null;
      final javax.servlet.ServletContext application;
      final javax.servlet.ServletConfig config;
      javax.servlet.jsp.JspWriter out = null;
      final java.lang.Object page = this;
      javax.servlet.jsp.JspWriter _jspx_out = null;
      javax.servlet.jsp.PageContext _jspx_page_context = null;
  

  输出页面增加的代码

   response.setContentType("text/html");
        pageContext = _jspxFactory.getPageContext(this, request, response,
        			null, true, 8192, true);
        _jspx_page_context = pageContext;
        application = pageContext.getServletContext();
        config = pageContext.getServletConfig();
        session = pageContext.getSession();
        out = pageContext.getOut();
        _jspx_out = out;
  

  以上的对象我们可以在Jsp页面中直接使用

2.Jsp基础语法

Jsp表达式

<%-- JSP表达式
 作用:将程序的输出,输出到客户端 
 <%=变量或者表达式%>
 --%>
<%= new java.util.Date()%>

Jsp脚本片段

<%-- Jsp脚本片段 --%>
<%
  int sum = 0;
  for (int i=1;i<100;i++){
    sum+=i;}
  out.println("<h1>Sum="+sum+"</h1>");
%>

Jsp声明

<%-- Jsp声明 --%>
<%! 
  static {
  System.out.println("静态方法"); }
  private int globaVar = 0;
  public void dong(){
    System.out.println("进入方法dong");
  }
%>

Jsp的注释不会在客户端出现,HTML的注释会在审查元素中查看

Jsp指令

<%-- 指定编码和语言--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%-- 导入其他网页,静态导入,本质上是一个页面--%>
<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%@include file="common/footer.jsp"%>

<%-- 指定错误页面,发生错误时跳转指定页面--%>
<%@ page errorPage="error/500.jsp" %>

<!-- 在web.xml文件中配置错误页面   -->
<error-page>
    <error-code>500</error-code>
    <location>/error/500.jsp</location>
</error-page>
<error-page>
    <error-code>404</error-code>
    <location>/error/404.jsp</location>
</error-page>

Jsp动作

<%--Jsp动作,动态导入,本质上时三个页面--%>
<jsp:include page="common/header.jsp"/>
<h1>网页主体2</h1>
<jsp:include page="common/footer.jsp"/>

3.九大内置对象

• PageContext
• Request
• Response
• Session
• Application (ServletContext)
• config (ServletConfig)
• out
• page
• exception

<%--内置對象--%>
<%
    pageContext.setAttribute("name1","冬冬1");//只在一个页面有效
    request.setAttribute("name2","冬冬2");//只在一次请求有效
    session.setAttribute("name3","冬冬3");//只在一次会话有效
    application.setAttribute("name4","冬冬4");//在整个服务器有效
%>
<%--
    pagecontext通过寻找的方式取出保存的值
    从底层到高层(作用域)
    --%>
<%
    String name1 = (String) pageContext.findAttribute("name1");
    String name2 = (String) pageContext.findAttribute("name2");
    String name3 = (String) pageContext.findAttribute("name3");
    String name4 = (String) pageContext.findAttribute("name4");
    String name5 = (String) pageContext.findAttribute("name5");
%>
<%--使用EL表達式输出--%>
<h1>取出的值</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<h3>${name5}</h3>
<%--pageContext在Session中创建对象--%>
<%
    pageContext.setAttribute("name1","冬冬1",PageContext.SESSION_SCOPE);
%>
<%--使用pageContext实现转发--%>
<%
    pageContext.forward("/error/500.jsp");
%>

4.Jsp标签、Jstl标签、EL表达式

<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/taglibs/standard -->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

EL表达式：${ }

• 获取数据
• 执行运算
• 获取web开发的常用对象

Jsp标签：

<%--
jsp：include  动态包含页面
jsp：forward  请求转发
jsp: param    定义参数
--%>
<jsp:forward page="error/500.jsp">
    <jsp:param name="name" value="东董"/>
    <jsp:param name="age" value="12"/>
</jsp:forward>

Jstl表达式：

引入Jstl标签库

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

• c:if c:out

  <form method="get" action="coreif.jsp">
      <input type="text" name="username" value="${param.username}">
      <input type="submit" value="登录">
  </form>
  <%--判断是否是管理员--%>
  <c:if var="isAdmin" test="${param.username=='admin'}">
      <c:out value="管理员登陆成功"></c:out>
  </c:if>
  

• c:when c:set

  <%--定义一个变量--%>
  <c:set var="score" value="85"/>
  <c:choose>
      <c:when test="${score>=90}">
          你的成绩为优秀
      </c:when>
      <c:when test="${score>=80}">
          你的成绩为较好
      </c:when>
      <c:when test="${score>=70}">
          你的成绩为良好
      </c:when>
      <c:when test="${score>=60}">
          你的成绩为及格
      </c:when>
  </c:choose>
  

• c:foreach

  <%
      ArrayList<String> people = new ArrayList<>();
      people.add(0,"张三");
      people.add(1,"李四");
      people.add(2,"王五");
      people.add(3,"田六");
      request.setAttribute("list",people);
  %>
  
  <c:forEach items="${list}" var="people">
   <c:out value="${people}"/><br>
  </c:forEach>
  <hr>
  <%--大于等于1  小于等于2 step：步长--%>
  <c:forEach items="${list}" var="people" begin="1" end="2" step="1">
      <c:out value="${people}"/><br>
  </c:forEach>
  

9.JavaBean

实体类

JavaBean有特殊写法

• 必须有无参构造
• 属性必须私有化
• 必须有set和get方法

<jsp:useBean id="people" class="com.dong.pojo.People" scope="page"/>
<jsp:setProperty name="people" property="id" value="123"/>
<jsp:setProperty name="people" property="name" value="东董"/>
<jsp:setProperty name="people" property="age" value="18"/>
<jsp:setProperty name="people" property="address" value="山东"/>
<jsp:getProperty name="people" property="id"/>
<jsp:getProperty name="people" property="name"/>
<jsp:getProperty name="people" property="age"/>
<jsp:getProperty name="people" property="address"/>

10.MVC三层架构

Model

• 业务处理：业务逻辑（Service）
• 数据持久层：CRUD（Dao）

View

• 展示数据
• 提供链接发起Servlet请求

Controller（Servlet）

• 接受用户请求
• 交给业务层处理对应的代码
• 控制试图的跳转

11.过滤器

Filter：过滤器，用来过滤网页的数据，实现Filter接口

public class CharacterEncodingFilter implements Filter {
// web服务器启动的时候初始化
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化");
    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
       servletRequest.setCharacterEncoding("utf-8");
       servletResponse.setCharacterEncoding("utf-8");
       servletResponse.setContentType("text/html;charset=utf-8");
//        让过滤器继续执行，不写的话就会卡住，不会继续执行
        filterChain.doFilter(servletRequest, servletResponse);
    }
//服务器关闭时销毁
    public void destroy() {
        System.out.println("销毁");
    }
}

<filter>
    <filter-name>encoding</filter-name>
    <filter-class>com.dong.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

12.监听器

实现监听器接口(很多接口，这里直实现了Session的监听器)

public class OnlineCountListener implements HttpSessionListener {
    //创建Session监听：一旦创建Session就会触发一次这个事件
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        System.out.println(se.getSession().getId());
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
        if(onlineCount==null){
            onlineCount=new Integer(1);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count+1);
        }
        ctx.setAttribute("OnlineCount",onlineCount);
    }
    //销毁Session监听
    /**
     *销毁session的两种方法
     * 1.重启服务器
     * 2.手动销毁  se.getSession().invalidate();
     * 3.自动销毁（配式过期时间）
     */

    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
        if(onlineCount==null){
            onlineCount=new Integer(0);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count-1);
        }
        ctx.setAttribute("OnlineCount",onlineCount);
    }
}

配置监听器

<listener>
    <listener-class>com.dong.listener.OnlineCountListener</listener-class>
</listener>

13.监听器和过滤器的常见应用

监听器：GUI编程中经常使用（关闭窗口的监听）

public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("端午快乐");//新建一个窗体
        Panel panel = new Panel(null);//面板
        frame.setLayout(null);//设置窗体的布局
        frame.setBounds(300,300,500,500);
        frame.setBackground(new Color(0,0,255));//设置背景颜色
        panel.setBounds(50,50,300,300);
        panel.setBackground(new Color(0,255,0));
        frame.add(panel);
        frame.setVisible(true);

        //监听事件，关闭窗口的监听事件
        frame.addWindowListener(new WindowListener() {
            public void windowOpened(WindowEvent e) {
                System.out.println("打开");
            }

            public void windowClosing(WindowEvent e) {
                System.out.println("关闭ing");
                System.exit(0);
            }

            public void windowClosed(WindowEvent e) {
                System.out.println("关闭ed");
            }

            public void windowIconified(WindowEvent e) {

            }

            public void windowDeiconified(WindowEvent e) {

            }

            public void windowActivated(WindowEvent e) {
                System.out.println("激活");
            }

            public void windowDeactivated(WindowEvent e) {
                System.out.println("未激活");
            }
        });
    }
}

14.JDBC

JDBC：Java连接数据库；

需要导入驱动Jar包

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.20</version>
</dependency>

连接数据库运行查询sql

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&relaxAutoCommit=true&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=UTC";
        String username = "root";
        String password = "password";
        //加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //链接数据库,connection代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //向数据库发送SQL的对象
        Statement statement = connection.createStatement();
        //写SQL语句
        String sql = "select * from users";
        //执行SQL，接受结果集
        ResultSet resultSet = statement.executeQuery(sql);
        while (resultSet.next()){
            System.out.println("id="+resultSet.getObject("id"));
            System.out.println("name="+resultSet.getObject("name"));
            System.out.println("password="+resultSet.getObject("password"));
            System.out.println("email="+resultSet.getObject("email"));
            System.out.println("birthday="+resultSet.getObject("birthday"));
        }
        //关闭连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

JDBC 固定步骤

• 加载驱动 Class.forName(“com.mysql.cj.jdbc.Driver”);
• 连接数据库 Connection connection = DriverManager.getConnection();
• 向数据库发送SQL的对象 Statement PreparedStatement
• 编写SQL
• 执行SQL
• 关闭连接

public class TestJdbc2 {
    public static void main(String[] args) throws Exception {
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&relaxAutoCommit=true&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=UTC";
        String username = "root";
        String password = "password";
        //加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //链接数据库,connection代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //写SQL语句
        String sql = "insert into users(id, name, password, email, birthday) VALUES (?,?,?,?,?)";
        //向数据库发送SQL的对象
        PreparedStatement ps = connection.prepareStatement(sql);
        //赋值
        ps.setInt(1,7);
        ps.setString(2,"东董");
        ps.setString(3,"112233123");
        ps.setString(4,"112233123.@qq.com");
        ps.setDate(5,new java.sql.Date(new java.util.Date().getTime()));
        //执行SQL，接受结果集
        int i = ps.executeUpdate();
        System.out.println(i);
        //关闭连接
        ps.close();
        connection.close();
    }
}

事务

ACID原则，保证数据的安全

public class TestJdbc3 {
    @Test
    public void test(){
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&relaxAutoCommit=true&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=UTC";
        String username = "root";
        String password = "password";
        Connection connection = null;
        PreparedStatement ps = null;
        try{
        Class.forName("com.mysql.cj.jdbc.Driver");
        connection = DriverManager.getConnection(url, username, password);
        //开启事务(令自动提交为false)
        connection.setAutoCommit(false);
        String sql = "update account set money = money-100 where name = 'A'";
        ps = connection.prepareStatement(sql);
        int i = ps.executeUpdate();
        //制造错误
            int k = 1/0;
        String sql2 = "update account set money = money+100 where name = 'B'";
        ps = connection.prepareStatement(sql2);
        int j = ps.executeUpdate();
            if(i>0&&j>0){
                connection.commit();
            }
        }catch(Exception e){
            try {
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }finally {
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

15.文件上传

注意事项（调优）：

1. 为了保证服务器安全，上传文件应该放在外界无法直接访问的目录下，比如放于WEB-INF目录下。
2. 为了防止文件覆盖的现象发生，要为上床文件产生一个唯一的文件名。（时间戳，uuid，md5等等）
3. 要限制上传文件的最大值。
4. 可以限制上传文件的类型，在收到上传文件名时，判断后缀名是否合法。

1.FileItem

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

<%--
get:上传大小有限制
post：上传大小无限制
  --%>
<form action="" method="post" enctype="multipart/form-data">
    <p>上传用户：<input type="text" name="username"></p>
    <p><input type="file" name="file1"></p>
    <p><input type="submit"></p>
</form>

【常用方法介绍】

//isFormField方法用于判断FileItem类对象封装的数据是一个普通文本表单
//还是一个文件表单，如果是普通表单返回true，否则返回false
boolean isFormField();
//getFieldName方法用于返回表单标签name属性的值
String getFieldName();
//getString方法用于将FileItem对象中保存的数据流内容以一个字符串返回
String getString();
//getName方法用于获得文件上传字段中的文件名
String getName();
//以流的形式返回上传文件的数据内容
InputStream getInputStream();
//delete方法用来清空FileItem类对象中存放的主题内容
//如果主体内容被保存在临时文件中，delete方法将删除该临时文件
void delete();

2.ServletFileUpload

负责上传的文件数据，并将表单中每个输入项封装成一个FileItem对象中，使用其**parseRequest(HttpServletRequest)**方法可以将通过表单中每一个HTML标签提交的数据封装成一个FileItem对象，然后以List列表的形式返回。使用该方法处理上传文件简单容易。

public class FileServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // 判断上传的文件普通表单还是带文件的表单
        if (!ServletFileUpload.isMultipartContent(request)) {
            return;//终止方法运行,说明这是一个普通的表单,直接返回
        }
        //创建上传文件的保存路径,建议在WEB-INF路径下,安全,用户无法直接访间上传的文件;
        String uploadPath =this.getServletContext().getRealPath("/WEB-INF/upload");
        File uploadFile = new File(uploadPath);
        if (!uploadFile.exists()){
            uploadFile.mkdir(); //创建这个月录
        }

        // 创建上传文件的保存路径，建议在WEB-INF路径下，安全，用户无法直接访问上传的文件
        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组件;
        try {
            // 创建DiskFileItemFactory对象，处理文件路径或者大小限制
            DiskFileItemFactory factory = getDiskFileItemFactory(file);
            /*
             * //通过这个工厂设置一个缓冲区,当上传的文件大于这个缓冲区的时候,将他放到临时文件 factory.setSizeThreshold(1024 *
             * 1024); //缓存区大小为1M factory.setRepository (file);//临时目录的保存目录,需要一个File
             */

            // 2、获取ServletFileUpload
            ServletFileUpload upload = getServletFileUpload(factory);

            // 3、处理上传文件
            // 把前端请求解析，封装成FileItem对象，需要从ServletFileUpload对象中获取
            String msg = uploadParseRequest(upload, request, uploadPath);

            // Servlet请求转发消息
            System.out.println(msg);
            if(msg == "文件上传成功!") {
                // Servlet请求转发消息
                request.setAttribute("msg",msg);
                request.getRequestDispatcher("info.jsp").forward(request, response);
            }else {
                msg ="请上传文件";
                request.setAttribute("msg",msg);
                request.getRequestDispatcher("info.jsp").forward(request, response);
            }

        } catch (FileUploadException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }

    public static DiskFileItemFactory getDiskFileItemFactory(File file) {
        DiskFileItemFactory factory = new DiskFileItemFactory();
        // 通过这个工厂设置一个缓冲区,当上传的文件大于这个缓冲区的时候,将他放到临时文件中;
        factory.setSizeThreshold(1024 * 1024);// 缓冲区大小为1M
        factory.setRepository(file);// 临时目录的保存目录,需要一个file
        return factory;
    }

    public static ServletFileUpload getServletFileUpload(DiskFileItemFactory factory) {
        ServletFileUpload upload = new ServletFileUpload(factory);
        // 监听长传进度
        upload.setProgressListener(new ProgressListener() {

            // pBYtesRead:已读取到的文件大小
            // pContextLength:文件大小
            public void update(long pBytesRead, long pContentLength, int pItems) {
                System.out.println("总大小：" + pContentLength + "已上传：" + pBytesRead);
            }
        });

        // 处理乱码问题
        upload.setHeaderEncoding("UTF-8");
        // 设置单个文件的最大值
        upload.setFileSizeMax(1024 * 1024 * 10);
        // 设置总共能够上传文件的大小
        // 1024 = 1kb * 1024 = 1M * 10 = 10м

        return upload;
    }

    public static String uploadParseRequest(ServletFileUpload upload, HttpServletRequest request, String uploadPath)
            throws FileUploadException, IOException {

        String msg = "";

        // 把前端请求解析，封装成FileItem对象
        List<FileItem> fileItems = upload.parseRequest(request);
        for (FileItem fileItem : fileItems) {
            if (fileItem.isFormField()) {// 判断上传的文件是普通的表单还是带文件的表单
                // getFieldName指的是前端表单控件的name;
                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;
                }

                // 获得上传的文件名/images/girl/paojie.png
                String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/") + 1);
                // 获得文件的后缀名
                String fileExtName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1);

                /*
                 * 如果文件后缀名fileExtName不是我们所需要的 就直按return.不处理,告诉用户文件类型不对。
                 */

                System.out.println("文件信息[件名: " + fileName + " ---文件类型" + fileExtName + "]");
                // 可以使用UID（唯一识别的通用码),保证文件名唯
                // 0UID. randomUUID(),随机生一个唯一识别的通用码;
                String uuidPath = UUID.randomUUID().toString();

                // ================处理文件完毕==============

                // 存到哪? uploadPath
                // 文件真实存在的路径realPath
                String realPath = uploadPath + "/" + uuidPath;
                // 给每个文件创建一个对应的文件夹
                File realPathFile = new File(realPath);
                if (!realPathFile.exists()) {
                    realPathFile.mkdir();
                }
                // ==============存放地址完毕==============


                // 获得文件上传的流
                InputStream inputStream = fileItem.getInputStream();
                // 创建一个文件输出流
                // realPath =真实的文件夹;
                // 差了一个文件;加上翰出文件的名产"/"+uuidFileName
                FileOutputStream fos = new FileOutputStream(realPath + "/" + fileName);

                // 创建一个缓冲区
                byte[] buffer = new byte[1024 * 1024];
                // 判断是否读取完毕
                int len = 0;
                // 如果大于0说明还存在数据;
                while ((len = inputStream.read(buffer)) > 0) {
                    fos.write(buffer, 0, len);
                }
                // 关闭流
                fos.close();
                inputStream.close();

                msg = "文件上传成功!";
                fileItem.delete(); // 上传成功,清除临时文件
                //=============文件传输完成=============
            }
        }
        return msg;

    }
}

16.邮件发送

SMTP协议（发送协议）

POP3协议（接受协议）

需要两个Jar包

发送简单邮件（没有附件，只有文本）

package com.dong;

import com.sun.mail.util.MailSSLSocketFactory;

import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import java.security.GeneralSecurityException;
import java.util.Properties;

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

        //关于QQ邮箱，还需要设置SSL加密，加上以下代码
        MailSSLSocketFactory sf = new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.stmp.ssl.enable","true");
        prop.put("mail.stmp.ssl.socketFactory",sf);

        //发送邮件的5个步骤
        //1.创建Sesssion对象 QQ才有 其他没有
        Session session = Session.getDefaultInstance(prop, new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("420846418@qq.com", "shsetcvwkraxbjdg");
            }
        });
        //开启debug模式，查看运行状态
        session.setDebug(true);
        //2.通过Session得到transport
        Transport transport = session.getTransport();
        //3.使用邮箱的用户名和授权码连上邮件服务器
        transport.connect("smtp.qq.com","shsetcvwkraxbjdg");
        //4.创建邮件
        MimeMessage message = new MimeMessage(session);
        message.setSubject("简单邮件");//邮件主题
        message.setFrom(new InternetAddress("420846418@qq.com"));//发件人
        message.setRecipient(Message.RecipientType.TO,new InternetAddress("1597572914@qq.com"));
         //邮件的文本内容
        message.setContent("<h1 style='color:red'>上号吧，别学了</h1>","text/html;charset=utf-8");

        //5.发送邮件 2505316829
        transport.sendMessage(message,message.getAllRecipients());
        //6.关闭连接
        transport.close();
    }
}

发送复杂文件

public class MailDemo02 {
    public static void main(String[] args) throws GeneralSecurityException, MessagingException {
        Properties prop = new Properties();
        prop.setProperty("mail.host","smtp.qq.com");//设置QQ邮箱服务器
        prop.setProperty("mail.transport.protocol","smtp");//邮件发送协议
        prop.setProperty("mail.smtp.auth","true");//需要验证用户名和密码

        //关于QQ邮箱，还需要设置SSL加密，加上以下代码
        MailSSLSocketFactory sf = new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.stmp.ssl.enable","true");
        prop.put("mail.stmp.ssl.socketFactory",sf);

        //发送邮件的5个步骤
        //1.创建Sesssion对象 QQ才有 其他没有
        Session session = Session.getDefaultInstance(prop, new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("420846418@qq.com", "shsetcvwkraxbjdg");
            }
        });
        //开启debug模式，查看运行状态
        session.setDebug(true);
        //2.通过Session得到transport
        Transport transport = session.getTransport();
        //3.使用邮箱的用户名和授权码连上邮件服务器
        transport.connect("smtp.qq.com","shsetcvwkraxbjdg");
        //4.创建邮件
        MimeMessage message = new MimeMessage(session);
        message.setSubject("简单邮件");//邮件主题
        message.setFrom(new InternetAddress("420846418@qq.com"));//发件人
        message.setRecipient(Message.RecipientType.TO,new InternetAddress("1597572914@qq.com"));

        //================复杂内容================
        //准备图片数据
        MimeBodyPart image = new MimeBodyPart();
        DataHandler dh = new DataHandler(new FileDataSource("G:\\IDEA\\JavaWeb\\JavaWeb-10-mail\\src\\main\\resources\\wallhaven-g87mvq.jpg"));
        //在我们的Body中放入这张图片的数据
        image.setDataHandler(dh);
        //设置图片的ID，后面使用
        image.setContentID("bz");
        //准备正文数据
        MimeBodyPart text = new MimeBodyPart();
        text.setContent("这是一份邮件正文带图片<img src='cid:bz'>的邮件","text/html;charset=utf-8");
        //描述数据关系
        MimeMultipart mm = new MimeMultipart();
        mm.addBodyPart(text);
        mm.addBodyPart(image);
        mm.setSubType("mixed");
        //设置到消息中，保存修改
        //把最后编辑好的邮件放到消息中
        message.setContent(mm);
        message.saveChanges();

        //================================

        //5.发送邮件 2505316829
        transport.sendMessage(message,message.getAllRecipients());
        //6.关闭连接
        transport.close();
    }
}

17.注册邮件验证

1.前端注册页面

<form action="${pageContext.request.contextPath}/RegisterServlet.do" method="post">
  <p>用户名：<input type="text" name="username"></p><br>
  <p>密码：<input type="password" name="password"></p><br>
  <p>邮箱：<input type="text" name="email"></p><br>
  <p><input type="submit"></p>
</form>

2.POJO类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private String username;
    private String password;
    private String email;
}

3.发邮件的工具类

这里使用多线程，可以让发送邮件的期间就可以实现页面跳转

（这里发送邮件的时间很长，如果等待发送完毕再跳转页面用户体验不好，使用线程解决这一问题）

import com.dong.pojo.User;
import com.sun.mail.util.MailSSLSocketFactory;

import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import java.util.Properties;

//多线程 实现用户体验 异步处理
public class Sendmail extends Thread {
    //用于给用户发送邮件的邮箱
    private String from = "420846418@qq.com";
    //邮箱的用户名
    private String username = "420846418@qq.com";
    //邮箱的密码
    private String password = "shsetcvwkraxbjdg";
    //发送邮件的服务器地址
    private String host = "smtp.qq.com";

    private User user;
    public Sendmail(User user){
        this.user = user;
    }

    //重写run方法的实现，在run方法中发送邮件给指定的用户
    @Override
    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);

            //1、创建定义整个应用程序所需的环境信息的 Session 对象
            Session session = Session.getDefaultInstance(prop, new Authenticator() {
                public PasswordAuthentication getPasswordAuthentication() {
                    //发件人邮件用户名、授权码
                    return new PasswordAuthentication(from, password);
                }
            });

            //开启Session的debug模式，这样就可以查看到程序发送Email的运行状态
            session.setDebug(true);

            //2、通过session得到transport对象
            Transport ts = session.getTransport();

            //3、使用邮箱的用户名和授权码连上邮件服务器
            ts.connect(host, username, password);

            //4、创建邮件
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress(from)); //发件人
            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");
            message.saveChanges();

            //发送邮件
            ts.sendMessage(message, message.getAllRecipients());
            ts.close();
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

4.Servlet

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 = new User(username, password, email);
        Sendmail sendmail = new Sendmail(user);
        //启动线程
        sendmail.start();
        //注册用户
        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>
    <servlet-name>RegisterServlet</servlet-name>
    <servlet-class>com.dong.servlet.RegisterServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>RegisterServlet</servlet-name>
    <url-pattern>/RegisterServlet.do</url-pattern>
</servlet-mapping>

5.网页接受数据