JavaWeb开发（全）

Tomcat服务器是一个开源的Java Servlet容器，它是Apache软件基金会的一个项目。它可以作为一个独立的Web服务器运行，也可以与其他Web服务器（如Apache HTTP服务器）结合使用。Tomcat提供了一个Java Servlet和JavaServer Pages（JSP）的运行环境，可以用于开发和部署Java Web应用程序。

Tomcat服务器的主要功能包括：

1. Servlet容器：Tomcat可以运行和管理Java Servlet，它负责接收和处理来自客户端的HTTP请求，并将其传递给相应的Servlet进行处理。

2. JSP容器：Tomcat还支持JavaServer Pages (JSP)，这是一种将Java代码嵌入到HTML页面中的技术。Tomcat可以编译和执行JSP页面，并将结果返回给客户端。

3. 静态文件服务：Tomcat可以作为一个简单的Web服务器，提供静态文件（如HTML、CSS、JavaScript、图片等）的服务。

4. 连接器支持：Tomcat支持多种连接器，可以与不同的Web服务器（如Apache）进行整合，以提供更高的性能和可靠性。

总之，Tomcat服务器是一个强大的Java Web应用服务器，广泛用于开发和部署Java Web应用程序。它提供了良好的性能和可靠性，并且易于配置和扩展。

我有篇文章学到，TCP\IP UDP协议，还基于TCP协议手写了一个Http服务器，使用浏览器作为客户端访问了服务器中的静态资源。文章链接：

Java中Socket编程_Jay/.的博客-CSDN博客

双击startup.batWindows批处理文件 *.sh文件为在Linux系统上运行的文件。

得到如上图所示界面，如果该界面编码错误，显示乱码，可删除上层目录conf 下的logging.properties文件中的命令行默认编码UTF-8，删除该行代码，即可解决。

若通过127.0.0.1:8080访问到此页面，则表示Tomcat已经成功安装并启动！！！

1.2 使用Tomcat服务器部署静态资源

在Tomcat服务器webapps文件夹下存放运行程序，可部署war包、jar包、静态资源。

以下演示存放静态资源：

在webapps目录下新建了一个文件夹study，在study里面存放了静态html页面，可通过完整路径访问静态资源127.0.0.1:8080/study/test.html

若不加上完整路径，也就是这样127.0.0.1:8080/study/ 就会默认访问index.html资源。

访问成功

logs目录用来存放Tomcat日志文件

libs目录用来存放启动后需要依赖的jar包

webapps是tomcat部署工程的目录

work目录是jsp文件在被翻译后，保存到这个目录下，session对象被序列化后也保存到这

1.3 修改tomcat端口号冲突

1.4 tomcat部署项目的四种方式

1.5 idea创建Tomcat项目

先创建一个普通Java项目，再添加框架支持Web项目，再添加Tomcat服务器运行，默认运行index.jsp。

1.6 Web项目目录结构

二、Servlet

2.1 什么是Servlet

Servlet是一种Java编程语言的服务器端组件，用于处理来自客户端的请求并生成响应。它是Java EE（Java Enterprise Edition）规范的一部分，用于构建基于Web的应用程序。

Servlet运行在Web服务器中，并根据客户端的请求执行相应的动作。它可以处理各种类型的请求，如HTTP请求（GET、POST等），并生成动态的HTML页面或其他类型的响应数据。

Servlet通过Java编程语言编写，并部署到支持Servlet规范的Web服务器中。它可以与其他Java技术（如JavaServer Pages（JSP））一起使用，以实现复杂的Web应用程序功能。

Servlet具有以下特点：
1. 可以处理并发请求：Servlet容器（如Apache Tomcat）会为每个请求创建一个独立的线程，从而实现并发处理。
2. 提供了与不同网络协议的集成能力：Servlet可处理多种协议，如HTTP、HTTPS和FTP等。
3. 可以生成动态内容：通过Java代码，Servlet可以生成动态的HTML页面或其他类型的响应数据。
4. 具有生命周期管理：Servlet具有初始化、销毁和服务等生命周期方法，可以进行资源初始化和释放操作。
5. 可以访问服务器端的API和服务：通过Servlet API，Servlet可以访问HTTP会话、Cookie、数据库连接池等服务器端的API和服务。

总而言之，Servlet是一种用于构建服务器端Web应用程序的Java组件，它提供了处理请求、生成响应和与服务器端 API 交互的能力。

2.2 idea配置Servlet

项目中导入servlet-api.jar包(在tomcat服务器文件夹中)

创建如图所示的软件包

在新创建的软件包下创建一个类名称为IndexServlet需要实现Servlet接口

加上注解@WebServlet("/lzx") 括号中的内容即为访问的路径

当访问到这个注解路径时，会执行重写的Service方法

2.3 在idea里面运行Servlet项目时，向控制台输出内容的时候乱码，如何解决？

本人在之前该项目SDK为Java19，默认编码为GBK，Java18也是，试过很多方法，最有效的方法就是：下载Java17版本并将项目SDK设置为Java17，因为Java17使用的是UTF-8编码。

2.4 Servlet执行流程

Servlet的执行流程可以概括为以下几步：

1. 客户端向服务器发送HTTP请求。
2. 服务器接收到请求后，根据请求的URL确定需要调用哪个Servlet进行处理，并创建一个Servlet实例。
3. 服务器将请求和响应对象作为参数传递给Servlet的service()方法。
4. Servlet的service()方法根据请求的类型（如GET、POST等）调用对应的doGet()、doPost()等方法进行处理。
5. 在doGet()、doPost()等方法中，可以通过请求对象获取请求的信息（如参数、头部信息等），并根据需要进行相应的逻辑处理。
6. 处理完请求后，Servlet可以通过响应对象设置响应的内容（如响应头、响应体等）。
7. Servlet处理完请求后，服务器将响应发送回客户端。
8. 客户端接收到响应后进行相应的处理，如渲染页面或执行下一步操作。

需要注意的是，Servlet的初始化和销毁也是在特定的时机进行的。服务器在启动时会创建Servlet实例并调用其init()方法进行初始化，在关闭服务器时会调用其destroy()方法进行销毁。另外，Servlet可以通过继承HttpServlet类来简化处理HTTP请求和响应的过程。

2.5 Servlet的生命周期

Servlet的生命周期由容器（例如Servlet容器，如Tomcat）管理，其生命周期包括以下几个阶段：

1. 加载：当服务器启动时，容器会加载Servlet类，并创建Servlet实例。这通常发生在第一次请求到达之前。加载的过程包括将Servlet类加载到内存中，实例化Servlet对象，并将Servlet对象保存在内存中，以便后续使用。

2. 初始化：在加载完Servlet类并创建实例后，容器会调用Servlet的init()方法进行初始化。在这个阶段，Servlet可以进行一些初始化操作，例如加载配置信息、建立数据库连接等。init()方法只会在Servlet生命周期内被调用一次。

3. 服务：一旦Servlet初始化完成，容器就会调用Servlet的service()方法来处理客户端的请求。在service()方法中，Servlet根据请求的类型（如GET、POST等）执行相关的业务逻辑，并生成相应的响应数据。service()方法在每次请求到达时都会被调用。

4. 销毁：当服务器关闭或重新加载应用程序时，容器会调用Servlet的destroy()方法来销毁Servlet实例。在destroy()方法中，可以执行一些清理操作，例如释放资源、关闭数据库连接等。destroy()方法在Servlet生命周期结束时只会被调用一次。

需要注意的是，除了init()和destroy()方法外，Servlet还可以重写其他一些方法，例如doGet()、doPost()等，用于处理特定类型的请求。这些方法由service()方法内部调用，根据请求类型选择执行相应的方法。

总结起来，Servlet的生命周期包括加载、初始化、服务和销毁这几个阶段，由容器管理和控制。在这个生命周期中，Servlet可以接收客户端请求、执行业务逻辑并生成响应数据。

2.6 Servlet线程安全性问题

Servlet线程安全性是一个在Web开发中需要重视的问题。由于Servlet容器使用多线程来处理来自多个客户端的并发请求，因此必须确保Servlet的代码在多线程环境中是安全的，避免出现竞态条件和数据不一致的问题。

以下是一些常见的Servlet线程安全性问题和相应的解决方法：

1. 实例变量共享：如果Servlet使用实例变量来存储状态信息，那么多个线程将共享这些变量。如果多个线程同时修改同一个实例变量，可能导致数据不一致。解决方法是避免在Servlet中使用实例变量，或者使用线程安全的数据结构或同步机制来保护实例变量的访问。

2. 静态变量共享：静态变量是所有实例之间共享的，所以多个线程对静态变量的修改可能会相互干扰。解决方法是使用线程安全的数据结构或同步机制来保护对静态变量的访问。

3. 线程安全的集合：如果Servlet使用集合（如List、Map等）存储数据，并且多个线程同时访问这些集合，那么可能会导致并发修改异常或数据不一致。解决方法是使用线程安全的集合类，如Vector、ConcurrentHashMap等。

4. 共享资源的同步：如果多个Servlet共享同一个资源（如数据库连接、文件等），那么需要确保对共享资源的访问是同步的，以避免并发访问引发的问题。可以使用同步关键字或锁来保护对共享资源的访问。

5. 请求信息共享：多个线程处理来自同一个客户端的多个请求时，可能会共享请求信息，如请求参数或请求属性。在处理请求时要小心处理这些共享的信息，避免出现竞态条件或数据混乱的情况。

总的来说，保证Servlet的线程安全性需要避免共享可变状态，使用线程安全的数据结构和同步机制，以及小心处理共享的请求信息。另外，合理设计Servlet的生命周期和线程模型也可以提高线程安全性。

2.7 Servlet中的重要方法介绍

1. init(ServletConfig config)：该方法在Servlet被实例化后立即调用，用于进行一次性的初始化工作。可以在该方法中读取和设置Servlet的配置信息，建立数据库连接，加载一些资源等。在整个生命周期中只调用一次。

2. service(HttpServletRequest request, HttpServletResponse response)：service方法是处理客户端请求的核心方法。当容器接收到一个请求时，会调用service方法来处理该请求。需要重写该方法，其中HttpServletRequest参数封装了客户端请求的信息，HttpServletResponse参数用于向客户端发送响应。

3. doGet(HttpServletRequest request, HttpServletResponse response)：当客户端发送GET请求时，容器会调用doGet方法来处理该请求。需要根据业务需求重写该方法，实现GET请求的处理逻辑。

4. doPost(HttpServletRequest request, HttpServletResponse response)：当客户端发送POST请求时，容器会调用doPost方法来处理该请求。同样需要根据业务需求重写该方法，实现POST请求的处理逻辑。

5. destroy()：当Servlet不再需要使用时，容器会调用destroy方法进行资源清理和释放。可以在该方法中关闭数据库连接，释放占用的资源等。在整个生命周期结束时调用一次。

这些方法组成了Servlet的生命周期，从实例化、初始化、请求处理，到销毁的完整流程。通过重写这些方法，可以实现自定义的业务逻辑和请求处理逻辑。

需要注意的是，Servlet规范还定义了其他方法，如doPut、doDelete等，用于处理其他HTTP请求方法。此外，还可以通过Servlet注解或配置来定义其他生命周期方法，如init、destroy等。

以上是Servlet中一些重要的方法介绍。了解和熟悉这些方法可以更好地理解和使用Servlet技术。

在idea中，还需要重写

public ServletConfig getServletConfig()方法和

String getServletInfo()两个方法

1. public ServletConfig getServletConfig()

该方法用于获取当前Servlet的配置对象 ServletConfig。ServletConfig 对象包含了当前Servlet的初始化参数和其他配置信息。通过调用 getServletConfig() 方法，可以在Servlet内部获取配置参数的值，以便进行一些初始化或个性化的逻辑处理。

该方法在Servlet生命周期中可随时调用，只需使用getServletConfig()语句即可返回Servlet的配置对象。

2. public String getServletInfo()

该方法返回一个字符串，其中包含了当前Servlet的一些信息描述。通常这个字符串可以包括Servlet的名称、版本、作者、用途等等。

getServletInfo() 方法通常被用于在部署描述符中配置Servlet的信息，也可以被开发人员用于日志记录或其他自定义逻辑中。

需要注意的是，虽然这个方法是重要的规范要求之一，但在实际开发中，可能很少用到它。

在idea中，不需要重写doGet()和doPost()方法

2.8 HttpServlet封装类的使用及原理

HttpServlet是Java Servlet规范中提供的一个抽象类，用于处理基于HTTP协议的请求和响应。它提供了一组方法以处理不同类型的HTTP请求（如GET、POST等），并生成相应的HTTP响应。

使用 HttpServlet 的主要步骤如下：

1. 继承 HttpServlet：创建一个新的类，并让它继承自 HttpServlet。

public class MyServlet extends HttpServlet {
       // ...
   }
   ```

2. 重写 doGet() 和/或 doPost() 方法：根据需要，重写 doGet() 和/或 doPost()（和其他可能需要的方法）来处理具体的请求。这些方法将在收到相应类型的HTTP请求时被调用。

@Override
   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       // 处理GET请求的逻辑
   }
   ```

@Override
   protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       // 处理POST请求的逻辑
   }
   ```

3. 部署和配置Servlet（通过注解方式也可以）：根据您使用的Servlet容器的不同，在部署和配置Servlet的过程中，可能需要在web.xml文件中进行一些额外的配置。

  <servlet>
       <servlet-name>MyServlet</servlet-name>
       <servlet-class>com.example.MyServlet</servlet-class>
   </servlet>
   <servlet-mapping>
       <servlet-name>MyServlet</servlet-name>
       <url-pattern>/myservlet</url-pattern>
   </servlet-mapping>
   ```

4. 运行和访问Servlet：启动您的Servlet容器，并通过HTTP请求访问您的Servlet对应的URL。

```
http://localhost:8080/myservlet
```

至于 HttpServlet 的实现原理，在Servlet容器启动时，会加载并实例化 HttpServlet 类。当收到HTTP请求时，Servlet容器会创建一个新的线程或使用线程池来处理请求，并使用已加载的 HttpServlet 实例来处理请求。具体而言，Servlet容器会调用适当的 doXXX() 方法，如 doGet() 或 doPost() 来处理请求，然后将结果返回给客户端。

HttpServlet 还提供了许多其他方法，如 init()、destroy()、service() 等，供开发人员在需要时进行重写，以实现更加全面和个性化的请求处理逻辑。

总结起来，HttpServlet 是一个用于处理基于HTTP协议的请求和响应的抽象类，通过继承它并重写相应的方法，可以创建自定义的Servlet，并在Servlet容器中运行和访问。

2.9 获取客户端请求内容

要获取到请求体只有post方法才有

package com.lzx.servlet;

import jakarta.servlet.ServletConfig;
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 java.io.BufferedReader;
import java.io.IOException;

@WebServlet("/lzx1")
public class HttpServletDemo extends HttpServlet {
    @Override
    public ServletConfig getServletConfig() {
        return super.getServletConfig();
    }
    /**
     * 模板方法设计模式
     *
     */

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        System.out.println(method);
        String contextPath = req.getContextPath();
        System.out.println(contextPath);
        String requestURI = req.getRequestURI();
        System.out.println(requestURI);
        StringBuffer requestURL = req.getRequestURL();
        System.out.println(requestURL);
        String queryString = req.getQueryString();
        System.out.println(queryString);

        //获取请求头的数据
        String header = req.getHeader("User-Agent");
        System.out.println(header);

        //获取传递的参数内容
        String userName = req.getParameter("userName");
        System.out.println(userName);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        BufferedReader reader = req.getReader();
        String s = reader.readLine();
        System.out.println(s);
        reader.close();
    }
}

运行结果：

2.10 手动封装Request封装参数方法

package com.lzx.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 java.io.BufferedReader;
import java.io.IOException;
import java.util.HashMap;

@WebServlet("/lzx2")
public class HttpServletDemo01 extends HttpServlet {
    /**
     * 只重写doGet方法，post请求不支持
     * 如果两个方法业务逻辑一样，则可以不用都写直接像下面这样调用doPost方法
     */

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

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        String parameterStr = null;
        //不同请求方式获取参数方式不一样
        switch (method){
            case "GET":
                parameterStr=req.getQueryString();
                break;
            case "POST":
                BufferedReader reader = req.getReader();
                parameterStr=reader.readLine();
                break;
        }

        //获取具体的内容

        String[] strings = parameterStr.split("&");
        HashMap<String, String> hashMap = new HashMap<>();
        for (int i = 0; i < strings.length; i++) {
            String[] split = strings[i].split("=");
            String key = split[0];
            String value = split[1];
            hashMap.put(key,value);
        }
        System.out.println(hashMap.get("userName"));
        System.out.println(hashMap.get("pwd"));
    }
}

启动服务器，运行结果：

没有任何问题。

2.11 通用的获取客户端传入的参数的方式

在源代码中，存放参数的Map集合为

Map<String,String[]>，后面一个参数为String数组，因为参数可能有多个

package com.lzx.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 java.io.BufferedReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@WebServlet("/lzx3")
public class HttpServletDemo02 extends HttpServlet {


    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
        System.out.println(req.getParameter("pwd"));
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Map<String, String[]> parameterMap = req.getParameterMap();

        parameterMap.forEach((k,v)->{
            System.out.print(k+"   ");
            System.out.println(Arrays.toString(v));
        });

        System.out.println(req.getParameter("userName"));
    }
}

使用API可统一获取到参数。

传入的地址为：localhost:8080/Tomcat_war_exploded/lzx3?userName=lzx&pwd=123456

获取到的结果为：

2.12 request请求转发

在服务器内部做资源跳转，相当于就是说，将原来客户端传过来的数据交给其它Servlet来运行。

创建了两个Servlet，在第一个servlet中加上了这行代码

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

访问第一个servlet的url时，会跳转到指定的servlet处理(/lzx4)。

数据共享：

也即一个servlet传递数据给另一个servlet

req.setAttribute("name","lzx");

另一边调用getAttribute即可获取到数据。

2.13 response响应数据及重定向

ServletResponse ----- 接口 Java提供的响应对象的根接口

HttpServletResponse -------接口（继承ServletResponse）Java提供的对Http协议封装响应对象接口。

加上这行代码 resp.setStatus(404);后，浏览器返回页面为：

可设置响应状态。

响应状态码为302即为重定向。

重定向后，浏览器地址栏会发生变化。相当于去了别的服务器。

也可以在服务器内部进行重定向。

2.13.1 重定向和转发的区别

三、实战及效果演示

3.1 servlet+jdbc实现登录和注册效果

常见错误：

项目已经放在原文中

需要学习前端。

四、jsp技术相关(淘汰)

基于servlet技术做封装

在jsp中，可以编写Java代码，使用<% %>包裹

底层还是会转化成servlet

4.1 el表达式

4.2 jstl-if标签

注意：使用jstl功能需要引入两个jstl的jar包

并在jsp文件第一行中包含标签

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

<c:if test="${age>18}">
<h1>年龄大于18岁</h1>
</c:if>

<c:if test="${age<18}">
<h1>年龄小于18岁</h1>
</c:if>

使用<c:if > </c:if>来实现

有很多标签使用

4.3 jstl-foreach的用法

可以用来遍历大部分集合。

五、基于JDBC+Servlet+jsp写机票管理系统

5.1 导包

需要导入四个包

并且需要将这四个包放在Tomcat的目录下。

编码以项目展示。

5.2 逻辑删除

新封装一个updateIsDelete函数，然后在删除时只调用它，将is_delete字段修改为1，然后在查询所有航班时加上条件where is_delete=0，就可实现逻辑删除（并不是真正删除，数据库中还有，只是不显示给用户）。

public int updateIsDelete(Integer id){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JdbcUtils.getConnection();
            JdbcUtils.beginTransaction(connection);
            String deleteSql = "UPDATE `flight`.`mayikt_flight` SET  `is_delete` = 1 WHERE `id` =?;";
            preparedStatement = connection.prepareStatement(deleteSql);
            preparedStatement.setInt(1,id);
            int update = preparedStatement.executeUpdate();
            JdbcUtils.commitTransaction(connection);
            return update;
        } catch (Exception e) {
            e.printStackTrace();
            JdbcUtils.rollBackTransaction(connection);
            return 0;
        } finally {
            JdbcUtils.closeConnection(connection,preparedStatement);
        }
    }

六、会话技术

6.1 cookie的用法原理及细节

基于Http协议

当客户端第一次访问时，通过在servlet中的doGet方法内，通过resp对象添加cookie信息，便于客户端在下一次访问时服务器容易识别出是哪一位用户，cookie信息保存在客户端（浏览器），重启服务器不会丢失。

6.2 session的用法原理及细节

基于cookie封装的，更安全，数据保存在服务器。

6.3 session与cookie的区别

6.4 注册图形验证码

网络上有许多图形验证码的工具类，比如将验证码的值保存在session中的

6.5 过滤器

在JavaWeb开发中，过滤器(Filter)是一种常用的组件，用于在请求到达Servlet之前或响应返回客户端之前，对请求和响应进行预处理和后处理操作。过滤器可以对请求参数、请求头、响应内容等进行拦截和修改，以实现诸如身份认证、日志记录、字符编码转换等功能。以下是使用过滤器的一般步骤：

1. 创建一个实现javax.servlet.Filter接口的类，并实现其doFilter()方法。

public class MyFilter implements Filter {
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化操作，可获取配置参数等
    }
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 在请求到达Servlet之前的预处理操作，例如身份认证、日志记录等
        
        // 执行下一个过滤器或Servlet
        chain.doFilter(request, response);
        
        // 在响应返回客户端之前的后处理操作，例如字符编码转换、内容修改等
    }
    
    @Override
    public void destroy() {
        // 销毁操作，释放资源
    }
}
```

2. 在`web.xml`配置文件中配置过滤器。

<filter>
    <filter-name>myFilter</filter-name>
    <filter-class>com.example.MyFilter</filter-class>
    <!-- 可配置其他参数 -->
</filter>

<filter-mapping>
    <filter-name>myFilter</filter-name>
    <url-pattern>/*</url-pattern>  <!-- 配置过滤的URL路径，也可使用servlet-name配置具体的Servlet -->
</filter-mapping>
```

3. 可选：配置过滤器的初始化参数。

<init-param>
    <param-name>param1</param-name>
    <param-value>value1</param-value>
</init-param>
```

4. 根据具体需求，在`doFilter()`方法中实现预处理和后处理逻辑。

过滤器链(Filter Chain)由容器维护，按照配置的顺序依次执行过滤器，最后调用目标Servlet或静态资源的处理。过滤器链中的`chain.doFilter()`方法用于将请求传递给下一个过滤器或目标Servlet，如果没有下一个过滤器，则直接将请求传递给目标Servlet进行处理。

可以根据具体的业务需求，编写多个过滤器并配置到`web.xml`中，形成过滤器链，实现多个过滤器依次处理请求和响应。

此方法表示放行（允许访问）

也是通过加上注解的形式来拦截请求

当一个项目中有多个过滤器时，按照类名首字母的顺序排序判断。都要走遍过滤器。

七、Axios及json

7.1 axios

ajax技术需要先引入axios类库，优点：不需要刷新页面可以发送很多请求。

axios函数（模板）：

<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

  // 1. 调用 axios 方法得到的返回值是 Promise 对象
   axios({
     // 请求方式
     method: 'GET',
     // 请求的地址
     url: '接口地址',
     // URL 中的查询参数
     params: {
       id: 1
     }
   }).then(function (result) {
     console.log(result)
   })

7.2 json

json语法：

json对象
{
name:"mayikt",
age:22,
isFlag:true
}
如果该json值是为最后一个的情况下  不需要写,
json数组
[
{
name:"mayikt1",
age:22,
isFlag:true
},
{
name:"mayikt2",
age:22,
isFlag:true
}
]
{
code:200,
msg:"ok",
data:[
{
name:"mayikt2",
age:22,
isFlag:true
},
{
name:"mayikt2",
age:22,
isFlag:true
}
]
}

常用json解析器：

fastjson是阿里巴巴开发的

Jay/.

关注

10
点赞
踩
16

收藏

觉得还不错? 一键收藏
打赏
4
评论
JavaWeb开发（全）

Servlet是一种Java编程语言的服务器端组件，用于处理来自客户端的请求并生成响应。它是Java EE（Java Enterprise Edition）规范的一部分，用于构建基于Web的应用程序。Servlet运行在Web服务器中，并根据客户端的请求执行相应的动作。它可以处理各种类型的请求，如HTTP请求（GET、POST等），并生成动态的HTML页面或其他类型的响应数据。Servlet通过Java编程语言编写，并部署到支持Servlet规范的Web服务器中。
复制链接

扫一扫