JavaWeb学习记录1、基本概念 1.1、前言 web开发： web，网页的意思，www.baidu.com 静态we

1、基本概念

1.1、前言

web开发：

web，网页的意思，www.baidu.com
静态web
- html，css
- 提供给所有人看的数据始终不会发生变化！
动态web
- 淘宝，几乎是所有的网站；
- 提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！
- 技术栈：Servlet/JSP，ASP，PHP

在java中，动态web资源开发的技术统称为JavaWeb；

1.2、web应用程序

web应用程序：可以提供浏览器访问的程序；

a.html、b.html……多个web资源，这些web资源可以被外界访问，对外界提供服务；
你们能访问到的任何一个页面或者资源，都存在于这个世界的某一个角落的计算机上。
URL
这个统一的web资源会被放在同一个文件夹下，web应用程序-->Tomcat：服务器
一个web应用由多部分组成（静态web，动态web）
- html，css，js
- jsp，servlet
- Java程序
- jar包
- 配置文件（Properties）

1.3 静态web存在的缺点

Web页面无法动态更新，所有用户看到都是同一个页面
- 轮播图，点击特效：伪动态
- JavaScript [实际开发中，它用的最多]
- VBScript
它无法和数据库交互（数据无法持久化，用户无法交互）

1.4、动态web

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

缺点：

加入服务器的动态web资源出现了错误，我们需要重新编写我们的后台程序,重新发布；
- 停机维护

优点：

Web页面可以动态更新，所有用户看到都不是同一个页面
它可以与数据库交互

2、web服务器

ASP:

微软：国内最早流行的就是ASP；
在HTML中嵌入了VB的脚本， ASP + COM；
在ASP开发中，基本一个页面都有几千行的业务代码，页面极其换乱
维护成本高！
C#

php:

PHP开发速度很快，功能很强大，跨平台，代码很简单（70%, WP）
无法承载大访问量的情况（局限性）

JSP/Servlet：

B/S：浏览和服务器

C/S：客户端和服务器

sun公司主推的B/S架构
基于Java语言的 (所有的大公司，或者一些开源的组件，都是用Java写的)
可以承载三高问题带来的影响；
语法像ASP ， ASP-->JSP , 加强市场强度；

……

3.Tomcat

启动与关闭

测试连接：http://localhost:8080/

可能遇到的问题：

Java环境变量没有配置
闪退问题：需要配置兼容性
乱码问题：配置文件中设置

配置

tomcat的默认端口号为：8080
mysql：3306
http：80
https：443

可以配置主机的名称

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

高难度面试题：

请你谈谈网站是如何进行访问的！

输入一个域名；回车
检查本机的 C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名映射；
1. 有：直接返回对应的ip地址，这个地址中，有我们需要访问的web程序，可以直接访问
```
127.0.0.1    localhost  //这表示把127这个ip给localhost
```
2. 没有：去DNS服务器找，找到的话就返回，找不到就返回找不到；

发布一个web网站

不会就先模仿

将自己写的网站，放到服务器(Tomcat)中指定的web应用的文件夹（webapps）下，就可以访问了

网站应该有的结构

--webapps ：Tomcat服务器的web目录
  -ROOT
  -kuangstudy ：网站的目录名
    - WEB-INF
      -classes ：java程序
      -lib：web应用所依赖的jar包
      -web.xml ：网站配置文件
    - index.html 默认的首页
    - static
      -css
        -style.css
      -js
      -img
      -.....

4、Http

4.1、什么是HTTP

HTTP（超文本传输协议）是一个简单的请求-响应协议，它通常运行在TCP之上。

文本：html，字符串，～…
超文本：图片，音乐，视频，定位，地图……
80

Https：安全的

4.2、两个时代

http1.0
- HTTP/1.0：客户端可以与web服务器连接后，只能获得一个web资源，随后断开连接
http2.0
- HTTP/1.1：客户端可以与web服务器连接后，可以获得多个web资源。

4.3、Http请求

客户端---发请求（Request）---服务器

百度：

1 Request URL:<https://www.baidu.com/>   请求地址

2 Request Method:GET                get方法/post方法

3 Status Code:200 OK                  状态码：200

4 Remote（远程） Address:14.215.177.39:443

1 Accept:text/html

2 Accept-Encoding:gzip, deflate, br

3 Accept-Language:zh-CN,zh;q=0.9 语言

4 Cache-Control:max-age=0

5 Connection:keep-alive

1、请求行

请求行中的请求方式：GET
请求方式：Get，Post，HEAD,DELETE,PUT,TRACT...
- get：请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效
- post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效。

2、消息头

1 Accept: 告诉浏览器，它所支持的数据类型

2 Accept-Encoding: 支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1

3 Accept-Language: 告诉浏览器，它的语言环境

4 Cache-Control: 缓存控制

5 Connection: 告诉浏览器，请求完成是断开还是保持连接

6 HOST: 主机.....

2、响应状态码

200：请求响应成功 200

3xx：请求重定向

重定向：你重新到我给你新位置去；

4xx：找不到资源 404
资源不存在；

5xx：服务器代码错误 500 502:网关错误

常见面试题：

当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来，经历了什么？

5、Maven

我为什么要学习这个技术？

在Javaweb开发中，需要使用大量的jar包，我们手动去导入；
如何能够让一个东西自动帮我导入和配置这个jar包。

由此，Maven诞生了！

5.1 Maven项目架构管理工具

我们目前用来就是方便导入jar包的！

5.3 配置环境变量

在我们的系统环境变量中

配置如下配置：

M2_HOME maven目录下的bin目录
MAVEN_HOME maven的目录
在系统的path中配置 %MAVEN_HOME%\bin

5.4 阿里云镜像

镜像：mirrors
- 作用：加速我们的下载
国内建议使用阿里云的镜像

 <mirror>
		<id>aliyunmaven</id>
		<mirrorOf>*</mirrorOf>
		<name>阿里云公共仓库</name>
		<url>https://maven.aliyun.com/repository/public</url>
	</mirror>

5.5 本地仓库

在本地的仓库，远程仓库；

建立一个本地仓库：localRepository

<localRepository>D:\Environment\apache-maven-3.6.2\maven-repo</localRepository>

在IDEA中使用MAVEN

创建maven项目

IDEA导入tomcat

使用Maven仓库

官网：mvnrepository.com/

6、Servlet

6.1、Servlet简介

Servlet就是sun公司开发动态web的一门技术
Sun在这些API中提供一个接口叫做：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：
- 编写一个类，实现Servlet接口
- 把开发好的Java类部署到web服务器中。

把实现了Servlet接口的Java程序叫做，Servlet

6.2、HelloServlet

构建一个普通的Maven项目，删掉里面的src目录，在这个项目里面建立Moudel；这个空的工程就是Maven主工程；
关于Maven父子工程的理解：

父项目中会有

   <modules>

        <module>servlet-01</module>

    </modules>

子项目会有

<parent>

    <artifactId>javaweb-02-servlet</artifactId>

    <groupId>com.kuang</groupId>
    
    <version>1.0-SNAPSHOT</version>

</parent>

父项目中的java子项目可以直接使用

优化servlet结构

Maven 骨架（webapp 模板）是 20 年前的，如果使用它的模板生成webapp会生成一个老掉牙的模板头，不支持诸多特性，建议读者自己去百度一下最新的，下面是我百度的

<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_6_0.xsd" 
         version="6.0"> 
    <display-name>Archetype Created Web Application</display-name> </web-app>

src是源代码目录，下建java和resources，java下域名和类包

编写一个Servlet程序
编写一个普通类
实现Servlet接口，这里我们直接继承HttpServlet

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

编写Servlet的映射

为什么需要映射：我们写的是JAVA程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要再web服务中注册我们写的Servlet，还需给他一个浏览器能够访问的路径；

   
<!--  注册Servlet-->
 <servlet>
   <servlet-name>hello</servlet-name>
   <servlet-class>HelloServlet</servlet-class>
 </servlet>
<!--  Servlet的请求路径-->
 <servlet-mapping>
   <servlet-name>hello</servlet-name>
   <url-pattern>/hello</url-pattern>
 </servlet-mapping>

配置Tomcat

Java Web应用的标准打包格式是WAR包，它是一个压缩文件（本质是ZIP格式），内部包含了Web应用运行所需的全部资源
Tomcat运行的前提是有一个完整的Web应用可供加载。在IDEA等开发工具中，“Run/Debug Configurations”的Before launch步骤，本质是在启动Tomcat前，确保Web应用已经打包成WAR文件

6.3 Servlet原理

6.4 Mapping问题

一个Servlet可以指定一个映射路径

<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>/hello</url-pattern>
</servlet-mapping>

一个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>/hello2</url-pattern>
</servlet-mapping>

<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>/hello3</url-pattern>

一个Servlet可以指定通用映射路径

<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>/hello1/*</url-pattern>
</servlet-mapping>

指定一些后缀或者前缀等等

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

*.zhang不能有前导符/
所有以.zhang结尾的全部被指定，如：'a.zhang'; '/hello/a.zhang'

Tomcat多个模块却只能选择一个webapp时，刷新Maven就行了

6.5、ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用；

1. 共享数据

我在这个Servlet中保存的数据，可以在另外一个servlet中拿到；

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name="张磊";
        resp.setContentType("text/html");
        ServletContext context = this.getServletContext();
        context.setAttribute("name",name);
        PrintWriter out = resp.getWriter();
        out.println("Hello Servlet");
        out.close();
    }
}

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String name = (String) context.getAttribute("name");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("UTF-8");
        PrintWriter out = resp.getWriter();
        out.println("名字：" + name);
    }
}

web映射配置

<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_6_0.xsd"
         version="6.0">
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.zhang.servlet.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
  <servlet>
    <servlet-name>get</servlet-name>
    <servlet-class>com.zhang.servlet.GetServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>get</servlet-name>
    <url-pattern>/get</url-pattern>
  </servlet-mapping>
</web-app>

访问第一个存的servlet后再访问get，得到下面的结果

2.获取初始化参数

在web映射里定义一个参数

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

在servlet里获取参数

public class Servlet03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("UTF-8");
        ServletContext context = this.getServletContext();
        String url = context.getInitParameter("url");
        PrintWriter out = resp.getWriter();
        out.println(url);
    }
}

配置映射后的结果

3. 请求转发

public class Servlet04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        RequestDispatcher dispatcher = context.getRequestDispatcher("/03");//设定转发的路径
        dispatcher.forward(req, resp);//forward转发请求
    }
}

结果

请求转发是服务器内部转发，客户端不知情，url不变；重定向是服务器告诉客户端重新请求新地址。

4. 获取配置资源

加载配置

public class Servlet05 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream in = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties prop = new Properties();
        prop.load(in);
        String user = prop.getProperty("user");
        String password = prop.getProperty("password");
        resp.setContentType("text/html");
        PrintWriter out = resp.getWriter();
        out.println(user+":"+password);
    }

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

6.6、HttpServletResponse

web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象，代表响应的一个HttpServletResponse；

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

1、简单分类

负责向浏览器发送数据的方法

ServletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOException;

负责向浏览器发送响应头的方法

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);

2、常见应用

向浏览器输出消息
下载文件
1. 要获取下载文件的路径
2. 下载的文件名是啥？
3. 设置想办法让浏览器能够支持下载我们需要的东西
4. 获取下载文件的输入流
5. 创建缓冲区
6. 获取OutputStream对象
7. 将FileOutputStream流写入到buffer缓冲区
8. 使用OutputStream将缓冲区中的数据输出到客户端！

public class Servlet06 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

//        1.  要获取下载文件的路径
        String resourcePaths = getServletContext().getRealPath("/WEB-INF/classes/测试.png");
        System.out.println("真实路径"+resourcePaths);
//        1.  下载的文件名是啥？
        String fileName = resourcePaths.substring(resourcePaths.lastIndexOf("\") + 1);
//        1.  设置想办法让浏览器能够支持下载我们需要的东西,URLEncoder.encode把url里可能出现的字符编码问题解决
        resp.setHeader("Content-disposition", "attachment;filename="+ URLEncoder.encode(fileName, "UTF-8"));
//        1.  获取下载文件的输入流
        FileInputStream in = new FileInputStream(resourcePaths);
//        1.  创建缓冲区
        int length = 0;
        byte[] buffer = new byte[1024];
//        1.  获取OutputStream对象
        OutputStream out = resp.getOutputStream();
//        1.  将FileOutputStream流写入到buffer缓冲区
        while ((length=in.read(buffer))!=-1){
            out.write(buffer,0,length);
        }
//        1.  使用OutputStream将缓冲区中的数据输出到客户端！
        in.close();
        out.close();
    }

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

重定向

B一个web资源收到客户端A请求后，B他会通知A客户端去访问另外一个web资源C，这个过程叫重定向

常见场景：

• 用户登录

public class Servlet07 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.sendRedirect("/servlet_02_war/06");
    }

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

6.7 HttpServletRequest

获取参数，请求转发

public class RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       req.setCharacterEncoding("UTF-8");
       resp.setCharacterEncoding("UTF-8");
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobbies");
        System.out.println("======================");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbies));
        System.out.println("======================");
        //服务器内转发不用加根目录路径
        this.getServletContext().getRequestDispatcher("/success.jsp").forward(req, resp);
    }

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>登录</title>
  </head>
  <body>
  <div>
    <form action="${pageContext.request.contextPath}/01" method="post">
        用户名：<input type="text" name="username"><br>
      密码：<input type="password" name="password"><br>
      爱好：<input type="checkbox" name="hobbies" value="music">音乐
      <input type="checkbox" name="hobbies" value="code">代码
      <input type="checkbox" name="hobbies" value="movie">电影
      <input type="checkbox" name="hobbies" value="art">艺术
      <br>
      <input type="submit" value="提交">
    </form>
  </div>
  </body>
</html>

7、Cookie、Session

7.1、会话

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话

会话是用户在网站上进行一系列连续操作期间，服务器用于跟踪和维持其状态（如登录信息、购物车）的交互过程。

7.2、保存会话的两种技术

客户端技术（响应，请求）

session

服务器技术，利用这个技术，可以保存用户的会话信息？我们可以把信息或者数据放在Session中！

常见常见：网站登录之后，你下次不用再登录了，第二次访问直接就上去了！

7.3、Cookie

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

Cookie 值不能包含：空格、逗号、分号、中文等特殊字符

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

URLEncoder编码

7.4、Session

Session和cookie的区别：

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

使用场景：

保存一个登录用户的信息；
购物车信息；
在整个网站中经常会使用的数据，我们将它保存在Session中；

8.JSP

8.1、什么是JSP

Java Server Pages : Java服务器端页面，也和Servlet一样，用于动态Web技术！

最大的特点：

写JSP就像在写HTML
区别：
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入JAVA代码，为用户提供动态数据；

浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！

8.2 原理

JSP最终也会被转换成为一个Java类！

JSP 本质上就是一个Servlet


//初始化

public void _jspInit() {

}

//销毁

public void _jspDestroy() {

}

//JSPService

public void _jspService(.HttpServletRequest request,HttpServletResponse response)

以上对象JSP帮我们创建了，不用再自己创建

在JSP页面中；

只要是JAVA代码就会原封不动的输出；

如果是HTML代码，就会被转换为：

out.write("\r\n");

这样的格式，输出到前端！

8.3、JSP基础语法

任何语言都有自己的语法，JAVA中有，。JSP 作为java技术的一种应用，它拥有一些自己扩充的语法（了解，知道即可！），Java所有语法都支持！

JSP表达式

<%-- JSP表达式
作用：用来将程序的输出，输出到客户端
<%= 变量或者表达式%>
--%>
<%= new Date()%>
</body>
</html>

jsp脚本片段

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

脚本片段的再实现

<%--在Java代码中嵌入html代码--%>
<%
    for (int i = 0; i < 10; i++) {
%>
<h2>hello world  <%=i%></h2>    <%--在html代码中嵌入java代码--%>
<%
    }//这个关联的是上一个Java代码片段里的{
%>

jsp声明

在<%!中的代码会具有更高的作用域，直接编译到了class文件中，而不是像其他的是编译到的jsp专门处理Java代码的方法里，相当于和处理Java代码的方法并排放到了一起

8.4、JSP指令

<%@page args.... %>

<%@include file=""%>
<%--@include会将两个页面合二为一--%>

<%@include file="common/header.jsp"%>

网页主体

<%@include file="common/footer.jsp"%>

<hr>

<%--jsp标签

jsp:include：拼接页面，本质还是三个--%>

<jsp:include page="/common/header.jsp"/>

网页主体

<jsp:include page="/common/footer.jsp"/>

指定错误页面

<%@page errorPage="..." %>指令只能作用于定义了该指令的当前JSP页面。

8.5、9大内置对象

PageContext 保存的数据只在一个页面中有效

pageContext也可实现简单的转发，用forward("")

Request 保存的数据只在一次请求中有效，请求转发会携带这个数据
Session 保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
Application 【ServletContext】保存的数据在服务器中有效，从打开服务器到关闭服务器

这四个用来存取数据

request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！

session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；

application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据：

Response
config 【ServletConfig】
out
page
exception

8.6、JSP标签、JSTL标签、EL表达式

</dependency>
<!-- Source: https://mvnrepository.com/artifact/jakarta.servlet.jsp.jstl/jakarta.servlet.jsp.jstl-api -->
<dependency>
    <groupId>jakarta.servlet.jsp.jstl</groupId>
    <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
    <version>3.0.2</version>
    <scope>compile</scope>
</dependency>
<!-- Source: https://mvnrepository.com/artifact/taglibs/standard -->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
    <scope>compile</scope>
</dependency>

EL表达式：${}

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

JSP标签


<%--jsp:include 这个用来引用其他jsp，比如一个网站统一的头尾--%>

<%--

<http://localhost:8080/jspTag.jsp?name=kuangshen&age=12>

带参数的转发--%>

<jsp:forward page="/jsptag2.jsp">

<jsp:param name="name" value="kuangshen"></jsp:param>

<jsp:param name="age" value="12"></jsp:param>

</jsp:forward>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，标签的功能和Java代码一样！

格式化标签

SQL标签

XML标签

核心标签（掌握部分） JSTL标签库使用步骤

引入对应的 taglib
使用其中的方法
在Tomcat 也需要引入 jstl的包，否则会报错：JSTL解析错误

9、JavaBean

实体类

JavaBean有特定的写法：

必须要有一个无参构造
属性必须私有化
必须有对应的get/set方法；

一般用来和数据库的字段做映射 ORM；

ORM：对象关系映射

表--->类
字段-->属性
行记录---->对象

10、MVC三层架构

什么是MVC： Model view Controller 模型、视图、控制器

10.1、原由

早些年：用户直接访问控制层，控制层就可以直接操作数据库；

servlet--CRUD-->数据库

弊端：程序十分臃肿，不利于维护

servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码

架构：没有什么是加一层解决不了的！

程序猿调用

|

JDBC

|

Mysql oracle SqlServer ....

现在：

10.2 现代三层架构

Model

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

View

展示数据
提供链接发起Servlet请求（a，form，img...）

Controller （Servlet）

接收用户的请求：（req：请求参数、Session信息....）
交给业务层处理对应的代码
控制视图的跳转

1 登录--->接收用户的登录请求--->处理用户的请求（获取用户登录的参数，username，password）
----->交给业务层处理登录业务（判断用户名密码是否正确：事务）--->
Dao层查询用户名和密码是否正确-->数据库

11、Filter

Filter：过滤器，用来过滤网站的数据；

处理中文乱码
登录验证....

Filter开发步骤：

导包
编写过滤器

package com.zhang.filter;

import jakarta.servlet.*;

import java.io.IOException;

public class CharacterEncodingFilter implements Filter {
    @Override
//    初始化方法，在web服务器启动时就调用，随时监听程序
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter init");
    }
//过滤特定请求
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
//        将当前请求传递给过滤器链（Filter Chain）中的下一个组件。没有这个就会拦截在这里
//        就像是当前安检关卡说：“检查通过，去下一个关卡（或最终目的地）
        chain.doFilter(request, response);

    }
//  销毁：在服务器关闭时销毁
    @Override
    public void destroy() {
        System.out.println("CharacterEncodingFilter destroy");
    }
}

导包不要错

4. 在web.xml中配置Filter

    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.zhang.filter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
<!--        在指定url下的请求会全部进入过滤-->
        <url-pattern>/servlet/*</url-pattern>
    </filter-mapping>

12、监听器

实现一个监听器的接口；（有N种）

编写一个监听器

2. web.xml中注册监听器

<listener>

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

</listener>

看情况是否使用！

13、过滤器、监听器常见应用

监听器：GUI编程中经常使用；

用户登录之后才能进入主页！用户注销后就不能进入主页了！

用户登录之后，向Sesison中放入用户的数据
进入主页的时候要判断用户是否已经登录；要求：在过滤器中实现！

HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;

if (request.getSession().getAttribute(Constant.USER_SESSION)==null){
    response.sendRedirect("/error.jsp");
}

chain.doFilter(request,response);

14、JDBC

什么是JDBC：Java连接数据库！

public class TestJDBC {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf-8";
        String user = "root";
        String password = "123456";
        Class.forName("com.mysql.cj.jdbc.Driver");
        Connection conn = DriverManager.getConnection(url, user, password);
        PreparedStatement statement = conn.prepareStatement("select * from users");
        ResultSet resultSet = statement.executeQuery();
        resultSet.next();
        while (resultSet.next()) {
            System.out.println(resultSet.getInt("id"));
            System.out.println(resultSet.getString("NAME"));
            System.out.println(resultSet.getString("PASSWORD"));
            System.out.println(resultSet.getString("birthday"));

        }
        resultSet.close();
        statement.close();
        conn.close();
    }
}

JDBC 固定步骤：

加载驱动
连接数据库,代表数据库
向数据库发送SQL的对象Statement : CRUD
编写SQL（根据业务，不同的SQL）
执行SQL
关闭连接

单元测试能跑通、能正常查询数据库 → 说明你的驱动、代码、配置全都是对的但是浏览器访问 login → 提交表单到 Servlet → 立刻报找不到 MySQL 驱动

这是 Java Web 项目最经典、最典型的坑！我直接告诉你根本原因 + 100% 解决方法，不用排查，直接修！

🔥 根本原因（只有这一个）

** 单元测试用的是 IDEA 的类路径，能找到驱动；

但 Tomcat 运行 Web 项目时，找不到驱动！**

简单说：你把驱动依赖加在了项目里，但没让 Tomcat 真正加载到！

出现这个问题 99% 是下面这 2 种情况之一：

✅ 解决方案（按顺序做，1 分钟解决）

如果你是 Maven 项目（最常见）

打开你的 pom.xml必须给 mysql 驱动添加 <scope>compile</scope> 或者不写 scope！

错误写法（你大概率是这个）：

xml

<scope>test</scope>   ❌ 只在测试时生效，Tomcat 访问不到！

正确写法：

xml

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.30</version>
    <!-- 不要写 scope 或者用 compile -->
</dependency>

为什么？

scope=test → 只有单元测试能用到
Tomcat 运行时 → 完全看不到这个驱动→ 所以报 ClassNotFoundException

检查 IDEA 有没有把依赖打包到 Tomcat

步骤：

File → Project Structure（项目结构）
点 Artifacts
找到你的 web 项目
看右边 Available Elements
找到你的 mysql 驱动包
右键 → Put into /WEB-INF/lib

然后重新部署 Tomcat → 解决！