「课件」原创 => Java WEB【转载请标明出处】

第一章·包名更改的 坑 ~

javax.* => jakarta.*

感兴趣的可以了解一下为什么名称被修改了：

Eclipse基金会在2019年对 Java EE 标准的每个规范进行了重命名，阐明了每个规范在Jakarta EE平台未来的角色。

新的名称Jakarta EE是Java EE的第二次重命名。2006年5月，“J2EE”一词被弃用，并选择了Java EE这个名称。在YouTube还只是一家独立的公司的时候，数字2就就从名字中消失了，而且当时冥王星仍然被认为是一颗行星。同样，作为Java SE 5（2004）的一部分，数字2也从J2SE中删除了，那时谷歌还没有上市。

因为不能再使用javax名称空间，Jakarta EE提供了非常明显的分界线。

• Jakarta 9（2019及以后）使用jakarta命名空间。
• Java EE 5（2005）到Java EE 8（2017）使用javax命名空间。
• Java EE 4使用javax命名空间。

我们可以将项目直接打包为war包（默认），打包好之后，放入webapp文件夹，就可以直接运行我们通过Java编写的Web应用程序了，访问路径为文件的名称。

1. pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>WebTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>WebTest</name>
    <packaging>war</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.source>1.8</maven.compiler.source>
        <junit.version>5.9.2</junit.version>
    </properties>

    <dependencies>
        <!--tomcat 10 用的是这个-->
        <dependency>
            <groupId>jakarta.servlet</groupId>
            <artifactId>jakarta.servlet-api</artifactId>
            <version>5.0.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.2</version>
            </plugin>
        </plugins>
    </build>
</project>

2. 更改项目访问的 URL

第二章·手动让 Tomcat 服务程序 加载 war 包

1. 先 package 双击，然后打包出 war 包

2. war 包复制到 Tomcat 的 webapp 目录下
   

3. 双击 bin 下面的 startup.bat 启动 Tomcat 服务

4. 然后 访问 http://localhost:8080/manager/html 查看下，我们写的 WEB 程序是否已经加载！

5. 访问 http://localhost:8080/WebTest-1.0-SNAPSHOT/

第三章·简单编写 Servlet 程序

1. 注册 Servlet 程序

1.1 web.xml 配置方式

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--全局初始化参数 可以在这里设置，然后Java代码使用 context.getInitParameter("NBLOVE") 进行获取-->
    <context-param>
        <param-name>NBLOVE</param-name>
        <param-value>我是全局初始化参数</param-value>
    </context-param>
    <!--下方仅仅是在不使用 注解注册时 进行的配置，如果使用了注解 请删除！-->
    <servlet>
        <servlet-name>test</servlet-name>
        <servlet-class>org.example.webtest.TestServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>test</servlet-name>
        <url-pattern>/test</url-pattern>
    </servlet-mapping>
</web-app>

继承 Servlet 方式

package org.example.webtest;

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebServlet;

import java.io.IOException;

public class TestServlet implements Servlet {

    // 请求发过来时，进行的初始化操作写在这里
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    // 专门设置 Servlet 配置的
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    // 进行信息传输的核心方法，拿到 请求方对象 和 浏览器响应对象
    // 然后去分析 相关的请求方 拿到的东西，进而 去用 响应对象在 网页上进行数据展示等响应
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {

    }

    // 设置 Servlet 信息打印
    @Override
    public String getServletInfo() {
        return null; // null 就是使用默认
    }

    // 连接中断后，我们要做什么事情
    @Override
    public void destroy() {

    }
}

1.2 web.xml 隐藏配置（实现了 可以直接访问 .jsp 静态资源的原因）

<!-- The mapping for the default servlet -->
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- The mappings for the JSP servlet -->
    <servlet-mapping>
        <servlet-name>jsp</servlet-name>
        <url-pattern>*.jsp</url-pattern>
        <url-pattern>*.jspx</url-pattern>
    </servlet-mapping>

1.3 注解方式（主推）=> 以继承 Servlet 举例

package org.example.webtest;

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebServlet;

import java.io.IOException;

// @WebServlet("/test") 把 /test 是注册到 Web 服务器
// 然后你用 根URL/test 即 http://localhost:8080/hello/ 配置项 的值test 就可以访问
@WebServlet(value = "/test",initParams = {
    /*@WebInitParam 是初始化参数，一般放一些 配置项 的值*/
        @WebInitParam(name = "test", value = "我是一个默认的初始化参数")
})
public class TestServlet implements Servlet {

    public TestServlet(){
        // 构造方法是在初始化之前执行的
        System.out.println("我是构造方法");
    }

    // 请求发过来时，进行的初始化操作写在这里
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        getInitParameter("test"); // 拿到 注解处设置的 初始化参数，其实是一个很鸡肋的东西
        System.out.println("初始化");
    }

    // 专门设置 Servlet 配置的
    @Override
    public ServletConfig getServletConfig() {
        System.out.println("ServletConfig");
        return null;
    }

    // 进行信息传输的核心方法，拿到 请求方对象 和 浏览器响应对象
    // 然后去分析 相关的请求方 拿到的东西，进而 去用 响应对象在 网页上进行数据展示等响应
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        // 如果加载静态资源的话，可能还会去进行请求
        System.out.println("service");
    }

    // 设置 Servlet 信息打印
    @Override
    public String getServletInfo() {
        System.out.println("getServletInfo");
        return null; // null 就是使用默认
    }

    // 连接中断后，我们要做什么事情
    @Override
    public void destroy() {
        System.out.println("destroy");
    }
}

• 首先执行构造方法完成 Servlet 初始化
• Servlet 初始化后调用 init () 方法。
• Servlet 调用 service() 方法来处理客户端的请求。
• Servlet 销毁前调用 destroy() 方法。
• 最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

2. 可能需要观看的流程图

3. 继承 HttpServlet 方式

3.1 关于 @WebServlet 注解

我们接着来看WebServlet注解，我们前面已经得知，可以直接使用此注解来快速注册一个Servlet，那么我们来想细看看此注解还有什么其他的玩法。

首先name属性就是Servlet名称，而urlPatterns和value实际上是同样功能，就是代表当前Servlet的访问路径，它不仅仅可以是一个固定值，还可以进行通配符匹配：

@WebServlet("/test/*")

上面的路径表示，所有匹配/test/随便什么的路径名称，都可以访问此Servlet，我们可以在浏览器中尝试一下。

也可以进行某个扩展名称的匹配：

@WebServlet("*.js")

这样的话，获取任何以js结尾的文件，都会由我们自己定义的Servlet处理。

那么如果我们的路径为/呢？

@WebServlet("/")

此路径和Tomcat默认为我们提供的Servlet冲突，会直接替换掉默认的，而使用我们的，此路径的意思为，如果没有找到匹配当前访问路径的Servlet，那么久会使用此Servlet进行处理。

我们还可以为一个Servlet配置多个访问路径：

@WebServlet({"/test1", "/test2"})

我们接着来看loadOnStartup属性，此属性决定了是否在Tomcat启动时就加载此Servlet，默认情况下，Servlet只有在被访问时才会加载，它的默认值为-1，表示不在启动时加载，我们可以将其修改为大于等于0的数，来开启启动时加载。并且数字的大小决定了此Servlet的启动优先级。

@Log
@WebServlet(value = "/test", loadOnStartup = 1)
public class TestServlet extends HttpServlet {

    @Override
    public void init() throws ServletException {
        super.init();
        log.info("我被初始化了！");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        resp.getWriter().write("<h1>恭喜你解锁了全新玩法</h1>");
    }
}

其他内容都是Servlet的一些基本配置，这里就不详细讲解了。

4. ServletContext 对象

ServletContext全局唯一，它是属于整个Web应用程序的，我们可以通过getServletContext()来获取到此对象。有些数据就应该放在 一个公共的容器当中进行保存，然后让所有的请求都能够拿到！

• 赋值

ServletContext context = getServletContext();
context.setAttribute("test", "我是重定向之前的数据");
resp.sendRedirect("time");

• 拿到 webapp 根目录下的 资源文件

ServletContext context = getServletContext();
InputStream inputStream = context.getResourceAsStream("/path/to/resource");

需要注意的是，路径参数应该以斜杠 / 开头，表示相对于 webapp 根目录的路径。如果资源文件位于 WEB-INF 目录下，可以使用 /WEB-INF/ 开头的路径。

想要 拿到 resource 目录下资源文件的话，就用 Resources.getResourceAsStream()

第四章·关于下载和上传

1. 下载

• 下载链接的写法

<hr>
<a href="file" download="icon.png">点我下载高清资源</a>

@WebServlet("/file")
public class FileServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("image/png");
        OutputStream outputStream = resp.getOutputStream();
        InputStream inputStream = Resources.getResourceAsStream("icon.png");
        // 直接使用copy方法完成转换
        // 其实 这个工具类 我们都可以自己写，就是对IO 进一步的封装，仅此而已
        IOUtils.copy(inputStream, outputStream);
    }
}

2. 上传

<form method="post" action="file" enctype="multipart/form-data">
    <div>
        <input type="file" name="test-file">
    </div>
    <div>
        <button>上传文件</button>
    </div>
</form>

@MultipartConfig
@WebServlet("/file")
public class FileServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        try(FileOutputStream stream = new FileOutputStream("/Users/nagocoler/Documents/IdeaProjects/WebTest/test.png")){
            Part part = req.getPart("test-file");
            IOUtils.copy(part.getInputStream(), stream);
            resp.setContentType("text/html;charset=UTF-8");
            resp.getWriter().write("文件上传成功！");
        }
    }
}

第五章·发送 xhr 请求向后端

我推荐大家直接学这个js中原生态的 xhr，而不是 jquery 中二次封装的 ajax（而且现在主流也不用它了，什么兼容IE真的变为了行外人的一个梗了~ 都什么年代了，你看现在哪家公司还搞这个？？在手机用户为主流的时代，IE？？你脑袋抽了？），咳咳 ~ 因为 ajax 其实并没有添附什么其他的东西和代码上的优化，仅仅只是 做了 类似于语法糖的处理。就是你用起来方便了。。

在早期的时候，我们真的就是 通过 JS 的发送 xhr 请求向后端，来实现 页面与用户 交互的 ！所以千万别瞧不起这种方式！！

1. js 代码的 xhr 发送 => 代码模板

function updateTime() {
    let xhr = new XMLHttpRequest();
    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4 && xhr.status === 200) {
            document.getElementById("time").innerText = xhr.responseText
        }
    };
    xhr.open('GET', '访问的url', true);
    xhr.send();
}

2. 前端代码模板

<hr>
<div id="time"></div>
<br>
<button onclick="updateTime()">更新数据</button>
<script>
    updateTime()
</script>

3. java 后端 代码模板

@WebServlet("/time")
public class TimeServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String date = dateFormat.format(new Date());
        resp.setContentType("text/html;charset=UTF-8");
        resp.getWriter().write(date);
    }
}

第六章·重定向和请求转发

重定向：跳转（重新请求）到某个页面（根据提供url地址），此时响应的状态码会被设置为302！并且响应头中添加了一个Location属性，此属性表示，需要重定向到哪一个网址。

resp.sendRedirect("time");

请求转发：服务器后端程序内部进行的跳转，即把当前的 Servlet 请求，转发给 其他的 Servlet 请求去进行处理，然后返回结果。所以请求转发，是会携带着所有参数 转发到另一个 Servlet 的过程！

req.getRequestDispatcher("/time").forward(req, resp);

我们可以注意到的是，在转发的时候，我们把 当前的请求者对象、响应对象 全都传过去了。所以当然是携带着所有信息过去的。

最后总结，两者的区别为：

• 请求转发是一次请求，重定向是两次请求
• 请求转发地址栏不会发生改变， 重定向地址栏会发生改变
• 请求转发可以共享请求参数 ，重定向之后，就获取不了共享参数了
• 请求转发只能转发给内部的Servlet

第七章·Cookie、Session

1. Cookie

• cookie：保存在浏览器中的一些信息，就是放到 cookie 里面的。

// resp 响应过去一些 cookie 让浏览器保存
Cookie cookie = new Cookie("test", "yyds");
resp.addCookie(cookie);
resp.sendRedirect("time");
// 获取 req 携带过来的 cookie 都是个啥
for (Cookie cookie : req.getCookies()) {
    System.out.println(cookie.getName() + ": " + cookie.getValue());
}

我们可以观察一下，在HttpServletResponse中添加Cookie之后，浏览器的响应头中会包含一个Set-Cookie属性，同时，在重定向之后，我们的请求头中，会携带此Cookie作为一个属性，同时，我们可以直接通过HttpServletRequest来快速获取有哪些Cookie信息。

Cookie包含哪些信息：

• name - Cookie的名称，Cookie一旦创建，名称便不可更改
• value - Cookie的值，如果值为Unicode字符，需要为字符编码。如果为二进制数据，则需要使用BASE64编码
• maxAge - Cookie失效的时间，单位秒。如果为正数，则该Cookie在maxAge秒后失效。如果为负数，该Cookie为临时Cookie，关闭浏览器即失效，浏览器也不会以任何形式保存该Cookie。如果为0，表示删除该Cookie。默认为-1。
• secure - 该Cookie是否仅被使用安全协议传输。安全协议。安全协议有HTTPS，SSL等，在网络上传输数据之前先将数据加密。默认为false。
• path - Cookie的使用路径。如果设置为“/sessionWeb/”，则只有contextPath为“/sessionWeb”的程序可以访问该Cookie。如果设置为“/”，则本域名下contextPath都可以访问该Cookie。注意最后一个字符必须为“/”。
• domain - 可以访问该Cookie的域名。如果设置为“.google.com”，则所有以“google.com”结尾的域名都可以访问该Cookie。注意第一个字符必须为“.”。
• comment - 该Cookie的用处说明，浏览器显示Cookie信息的时候显示该说明。
• version - Cookie使用的版本号。0表示遵循Netscape的Cookie规范，1表示遵循W3C的RFC 2109规范

我们发现，最关键的其实是name、value、maxAge、domain属性。

我们通常 是用这玩意，去保存一些 登陆过的用户名和密码，就是 前端页面 单选框选中的 "请记住我" 然后人家就把你记住了，浏览器记住之后，每次访问页面发送请求的时候，后端的服务器程序 先判断 Cookie 中是否有 这些信息。

<div>
    <label>
        <input type="checkbox" placeholder="记住我" name="remember-me">
        记住我
    </label>
</div>

• 登陆成功后 => 让浏览器保存的 Cookie 信息

Map<String, String[]> parameterMap = req.getParameterMap();
if(parameterMap.containsKey("remember-me")){   //若勾选了勾选框，那么会此表单信息
    Cookie cookie_username = new Cookie("username", username);
    cookie_username.setMaxAge(30);
    Cookie cookie_password = new Cookie("password", password);
    cookie_password.setMaxAge(30);
    resp.addCookie(cookie_username);
    resp.addCookie(cookie_password);
}

• 请求登录的时候 => 判断 Cookie 的模板

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    Cookie[] cookies = req.getCookies();
    if(cookies != null){
        String username = null;
        String password = null;
        for (Cookie cookie : cookies) {
            if(cookie.getName().equals("username")) username = cookie.getValue();
            if(cookie.getName().equals("password")) password = cookie.getValue();
        }
        if(username != null && password != null){
            //登陆校验
            try (SqlSession sqlSession = factory.openSession(true)){
                UserMapper mapper = sqlSession.getMapper(UserMapper.class);
                User user = mapper.getUser(username, password);
                if(user != null){
                    resp.sendRedirect("time");
                    return;   //直接返回
                }
            }
        }
    }
    req.getRequestDispatcher("/").forward(req, resp);   //正常情况还是转发给默认的Servlet帮我们返回静态页面
}

2. Session

通常用来 判断用户是否用该浏览器访问过我们的网页，进行过登录等请求。如果一次都没有进行过，然后还有 cookie，那我们可以怀疑 并不是 用户用浏览器进行的正经的访问，可能是爬虫。。

由于HTTP是无连接的，那么如何能够辨别当前的请求是来自哪个用户发起的呢？Session就是用来处理这种问题的，每个用户的会话都会有一个自己的Session对象，来自同一个浏览器的所有请求，就属于同一个会话。

它会给浏览器设定一个叫做 JSESSIONID 的 Cookie，这个值是一个随机的排列组合，也是用这个Cookie 来判断你属于哪一个会话，只要我们的浏览器携带此Cookie访问服务器，服务器就会通过Cookie的值进行辨别，得到对应的Session对象，因此，这样就可以追踪到底是哪一个浏览器在访问服务器。

需要强调的是：Session 并不是存放在浏览器中的，而是存放在服务器端的。它只不过是在与 浏览器建立会话的时候 把这个会话的 唯一标识 Session ID 保存到了 名字为 "JSESSIONID" 的 Cookie 里面！

而后端代码层面上，我们要想拿到 这个 存储到 服务器端的 Session 对象，就需要 用 请求者 通过 保存的 Session ID 去进行获取。

代码就变成了这样：HttpSession session = req.getSession();

所以不要感觉这个代码看起来很怪，它并不奇怪，它的意思是说 我们依赖于 保存在 浏览器上面的 Session ID 在我们的 后端服务器程序上，拿到 内存里面 的 Session 建立对应会话的 Session 对象。（这里很多人都讲不清楚呀~ 然后还出来误人子弟。。）

• 拿到 session 并添加 信息

HttpSession session = req.getSession();
session.setAttribute("user", user);

• 判断 Session 中是否有 保存的信息

HttpSession session = req.getSession();
User user = (User) session.getAttribute("user");
if(user == null) {
    resp.sendRedirect("login");
    return;
}

Session并不是永远都存在的，它有着自己的过期时间，默认时间为30分钟，若超过此时间，Session将丢失，我们可以在配置文件中修改过期时间：

<session-config>
    <session-timeout>1</session-timeout>
</session-config>

我们也可以在代码中使用invalidate方法来使Session立即失效：

session.invalidate();

现在，通过Session，我们就可以更好地控制用户对于资源的访问，只有完成登陆的用户才有资格访问首页。

第八章·过滤器 Filter、监听器 Listener

在设计之初的时候，我们发现只要通过Session，就可以很好地控制用户的登陆验证了，即只有授权的用户，才可以访问一些页面，但是我们需要一个一个去进行配置，还是太过复杂，能否一次性地过滤掉没有登录验证的用户呢？

Filter 过滤器就出现了，它的本质实际上也是 一个 Servlet，原理是说，我们无论什么样的请求，都需要先经过它这个 Servlet 去进行一些特判，然后 再决定是否 转发到 目标的 Servlet。

添加一个过滤器非常简单，只需要实现Filter接口，并添加@WebFilter注解即可：

@WebFilter("/*")
public class MainFilter extends HttpFilter {
    @Override
    protected void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {
        String url = req.getRequestURL().toString();
        //判断是否为静态资源
        if(!url.endsWith(".js") && !url.endsWith(".css") && !url.endsWith(".png")){
            HttpSession session = req.getSession();
            User user = (User) session.getAttribute("user");
            //判断是否未登陆
            if(user == null && !url.endsWith("login")){
                res.sendRedirect("login");
                return;
            }
        }
        //交给过滤链处理
        chain.doFilter(req, res);
    }
}

1. 存在多个 Filter 过滤器

由于我们整个应用程序可能存在多个过滤器，那么这行代码 chain.doFilter(req, res); 的意思实际上是将此请求继续传递给下一个过滤器，当没有下一个过滤器时，才会到达对应的Servlet进行处理，我们可以再来创建一个过滤器看看

@WebFilter("/*")
public class TestFilter2 implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("我是2号过滤器");
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

切记：过滤器的过滤顺序是按照类名的自然排序进行的，因此我们要把这些过滤器的名字都要进行个调整，才能非常顺利的按照我们想要的过滤顺序去执行。

2. Listener

在开发中，如果我们希望，在应用程序加载的时候，或是Session创建的时候，亦或是在Request对象创建的时候进行一些操作，那么这个时候，我们就可以使用监听器来实现。

默认为我们提供了很多类型的监听器，我们这里就演示一下监听Session的创建即可：

@WebListener
public class TestListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        System.out.println("有一个Session被创建了");
    }
}