JavaWeb

JavaWeb

前期内容

  1. Java基础(Java语法，面向对象概念，集合)
  2. MySql、Oracle
  3. JDBC(SpringJDBCTemplate)、数据库连接池
  4. HTML、CSS，JavaScript，Vue.js

后期内容

  1. JavaWeb、AJAX(axios)
  2. 框架(SSM)
    • SpringMVC
    • Spring
    • Mabits
  3. SpringBoot

JavaWeb相关概念

软件架构

  1. C/S：client/Server，客户端/服务器
    • 客户端需要安装专用的客户端软件
    • 客户端要负责绝大多数的业务逻辑和UI的展示，又称为胖客户端，它充分利用两端硬件，将任务分配到client和Server端，降低了系统的通讯开销
    • 缺点:增加了系统维护和升级的支出成本
  2. B/S：Browser/Server，浏览器/服务器
    • 只要有浏览器就可以，不需要单独安装
    • 主要事务逻辑在服务器端实现，这样使得客户端电脑负荷大大简化，称为瘦客户端
    • 好处：减轻了系统维护和升级的支出成本

Web

Web是全球广域网，也称为万维网(www.)，能够通过浏览器访问网站

Web开发的三要素

  1. URL：统一资源定位服务
  2. HTTP：超文本传输协议，主要定义了请求和响应的数据格式
  3. HTML：超文本标记语言，用来编写网页，由浏览器解释并展示

URL

统一资源定位符，用来完整地描述Internet上网页和其他资源的地址的一种表示方法

  • 组成：协议+服务器地址(端口号)+具体的资源路径
    • 如：http://192.168.6.156:8080/index.html
    • IP：在网络上标识唯一主机
    • 端口号：应用程序在计算机中的唯一软件标识，0——65536
    • 传输协议：规定了数据传输的规则，如：http、ftp等

资源分类

  1. 静态资源：所有用户访问后得到的结果都是一样的，静态资源可以直接被浏览器解释
    • 如：html、css、JavaScript、图片
  2. 动态资源：每个用户访问相同资源后，得到的结果可能不一样，需要先转换为静态资源，再返回给浏览器
    • 如：Servlet、JSP、php、sap.net

JavaWeb

就是使用java语言开发动态web应用程序的技术

Web服务器软件

用途：接受用户的请求，处理请求，并给出响应

常用的Web服务器软件
  • Tomcat：是一种小型轻量级的支持JSP和Servlet技术的Web服务器
  • IIS：Windows服务器自带的一种web服务器，支持：asp、asp、net
  • Apache：世界排名第一，免费开源的web服务器(只支持静态资源访问)
  • Nginx：是一种高性能的web和反向代理服务器
  • 商业化
    • websphere：IBM公司
    • webLogic：Oracle公司

HTTP

超文本传输协议，规定了浏览器和服务器之间数据传输规则

HTTP协议的特点
  • 基于TCP协议：面向连接、安全
    • TCP是一种面向连接(建立的时候连接之前是需要经过三次握手)、可靠的，基于字节流的传输层工具通信协议，在传输数据上是更安全的
      • UDP：非面向连接、不是特别安全可靠
  • 基于请求-响应模式：一次请求对应一次响应
  • HTTP协议是无状态的协议：对于事务处理没有记忆能力，每次请求-响应都是独立的
    • 通过Cookie，Session技术，保证会话完整，在一个会话过程中共享数据
格式介绍
http请求分为三部分
  1. 请求行
    • 请求方式：GET、POST
    • 请求的URL路径
    • 协议和版本号
  2. 请求头：第二行开始，格式：key:value形式
    • Host：表示请求的主机名
    • User-Agent：浏览器的版本
    • Accept：表示浏览器能接收到的资源类型，如：text/html,image/png
  3. 请求体
    • post请求的最后一部分，存储请求的参数(格式：键值对形式)
      • ?username=tom&password=111
http响应数据格式

分为三部分

  1. 响应行：响应数据的第一行，三部分组成，协议名和版本号，响应状态码，状态码的描述
  2. 响应头：第二行开始，格式：key:value形式
    • content-type：表示响应内容的类型，如：text/html，image/jpg
    • content-length：表示响应内容的长度(字节数)
  3. 响应体：最后一部分，存放响应的内容
响应状态码

200：ok，客户端请求成功

404：Not found，请求的资源不存在

500：Internal Server Error，服务器端发生不可预期的错误(服务器异常)

Tomcat

概述

  • 免费，开源的JavaWeb服务器
  • 是一种JSP和Servlet容器
  • 是Apache软件基金会的一个核心项目
  • Web服务器软件是一个应用软件，对HTTP协议的操作进行了封装，使得程序员不必直接对协议进行操作，开发更方便

使用

  • 下载：Apache Tomcat® - Welcome!
  • 安装：解压(先安装和配置jdk)
  • 卸载：删除目录即可
  • 启动服务器：
    • bin/startup.bat双击运行
    • 可能遇到的问题
      • 黑窗口一闪而过
        • 主要原因：JDK的配置问题
      • 端口被占用
  • 关闭
    • 正常关闭
      • bin/shutdown.bat
    • 强制关闭
      • 关闭窗口
      • Ctrl+C
  • Tomcat目录结构
    • bin：Tomcat运行的核心文件
    • conf：配置文件
    • lib：存放服务器启动需要的jar包
    • logs：日志
    • temp：临时文件
    • webapps：存放所有web应用程序的地方，这里的每一个文件夹就是一个web应用程序
    • work：存放由JSP生成的Servlet代码的地方

JavaWeb应用程序的目录结构

  • /app_name：web应用的根目录，web应用的所有文件和文件夹都放在这个下面
  • /app_name/WEB-INF：
    • 存放web应用的部署描述文件(web.xml)
    • 该目录受到保护，里面的文件不能被用户直接访问到
  • /app_name/WEB-INF/classes：java字节码文件
  • /app_name/WEB-INF/lib：存放依赖包(jdbc驱动)
  • /app_name/META-INF：存放配置应用程序，扩展程序的文件(数据库连接池)

Servlet

Server Applet，运行在服务器的小程序

作用

  1. 读取客户信息(接受请求)
  2. 数据处理
  3. 发送响应给客户端浏览器

创建

  1. 导入Servlet依赖包

  2. 定义一个类，继承HttpServlet类

    package com.neu.servlet;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet(value = "/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //得到响应对象中的输出流对象
        resp.getWriter().println("Hello World!");
    }

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

Servlet生命周期

  1. 生命周期：指的是一个对象被创建到被销毁的整个过程（默认情况下，Servlet是单例的）
  2. 分为4个阶段
    • 加载和实例化：默认情况下，当Servlet第一次被访问的时候，由容器创建Servlet对象
      • @WebServlet(value = “/LoginServlet”,loadOnStartup = 1)，其中loadOnStartup 的值为0或正数，表示容器启动的时候创建，默认值为-1
    • 初始化：调用init()方法，该方法只执行一次
    • 请求处理：调用service()方法每处理一个请求，调用一次
      • 在HttpServlet中，重写Service()方法，根据请求的method值，来调用doGet或doPost等方法
    • 服务终止：调用destroy()方法，在容器关闭的时候会释放这个Servlet实例，会调用这个方法

Servlet的体系结构

Servlet 接口
	|
GenericServlet 抽象类，重写了除service()方法之外的其他方法
	|
HttpServlet 重写了 service()、doGet()、doPost()等方法
	|
自定义的Servlet 重写 doGet()、doPost()

urlPattern配置

  1. 一个Servlet，可以配置多个urlPattern

    @WebServlet(urlPatterns = {"/LoginServlet","/login"})

  2. urlPattern配置规则

    • 精确匹配

      @WebServlet(urlPatterns = {"/LoginServlet","/login"})

    • 目录匹配

      @WebServlet(urlPatterns = {"/admin/*"})

http://localhost:8090/javawebdemo3/admin/a/b

      精确匹配的优先级高于目录匹配

    • 扩展名匹配

      @WebServlet(urlPatterns = {"*.do"})

http://localhost:8090/javawebdemo3/a.do
      • 常见错误：/*.do, /a/*.do

    • 任意匹配

      @WebServlet(urlPatterns = {"/*"})

http://localhost:8090/javawebdemo3/a.action

HttpServletRequest

  1. 定义：请求对象，封装了用户通过浏览器提交的所有数据

  2. 得到请求数据

    • getMethod():获取请求方式

    • getContextPath():获取项目部署时候的名称（应用程序上下文名）

    • getRequestURL():获取请求地址

    • getRequestURI()获取请求资源名称

      • URI：统一资源标识符
      • URL：统一资源定位符，是在互联网上，通过网址定位资源的一种方式，是URI的子集

    • getHeader(String name):根据请求头名称获取其值

      String host = req.getHeader("Host");

    • getReader():得到请求体（字符类型），注意：只有post请求有请求体

      BufferedReader reader = req.getReader();
String s = reader.readLine();

    • getInputStream():得到请求体（返回字节流，字节数据，如：文件）

      ServletInputStream inputStream = req.getInputStream();

BufferedReader reader  = new BufferedReader(new InputStreamReader(inputStream));

String s = reader.readLine();

    • 得到请求参数：通过表单提交的数据，或者附加在get请求的地址后的数据

      • ?username=tom&password=123

      • getParameter(String name)

      • getParameterValues(String name):根据请求参数名得到一组值（字符串数组）

        http://localhost:8090/javawebdemo666/LoginServlet?hobby=java&hobby=game

String[] hobbies = req.getParameterValues("hobby");
System.out.println(Arrays.toString(hobbies));

      • Map<String,String[]> getParameterMap():得到所有的请求参数

        Map<String, String[]> parameterMap = req.getParameterMap();
for(String key : parameterMap.keySet()){
   System.out.println(key+":"+Arrays.toString(parameterMap.get(key)));
}

  3. 中文乱码问题

    • get方法：tomcat9以上版本，已经解决

    • post方法

      //在第一次得到请求参数之前调用
req.setCharacterEncoding("utf-8");

req.getParameter("username");

  4. 请求转发

    • 一种在服务器内部的资源跳转方式

           ~~~

   - 注意：

     - 地址栏显示的是请求资源的地址
     - 只能访问当前应用的其他资源，不能访问外部资源
     - 一次请求一次响应

5. 传递数据

   - request.setAttribute(String key,Object object)：放置键值对
   - Object request.getAtrribute(String key)：根据key得到值
   - request.removeAttribute(String key)：根据key移除键值对

#### HttpRequestResponse

1. 响应对象，封装了响应相关的操作

2. 常用方法

   - 响应行

     - setStatus(int code):设置响应编码

   - 响应头

     - setHeader(String key,String value)

       ~~~java
       //        resp.setHeader("Content-Type","text/html;charset=utf-8");
               resp.setContentType("text/html;charset=utf-8");

    • 响应体

      • 得到字符输出流：PrintWrite getWriter()

        resp.getWriter().println("<html>");
resp.getWriter().println("<body>");
resp.getWriter().println("<h1>Other Servlet</h1>");
resp.getWriter().println("</body>");
resp.getWriter().println("</html>");

      • 得到字节输出流：

        ServletOutputStream getOutputStream()

  5. 重定向

    • 是一种资源跳转的方式

      resp.sendRedirect("/javaWebDemo2/OtherServlet");

    • 注意：

      • 地址栏中显示的是最终响应资源的地址
      • 二次请求，二次响应

在一个Servlet中处理多个请求

package com.neu.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/UserServlet")
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //UserServlet?action=login
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        String action = req.getParameter("action");
        if ("login".equals(action)){
            doLogin(req,resp);
        } else if ("regist".equals(action)) {
            doRegist(req,resp);
        }
    }

    private void doRegist(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().println("注册成功");
    }

    private void doLogin(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().println("登录成功");
    }

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

Get和Post的区别

  1. get和post是两种不同的http的请求方法，用于在客户端和服务器之间传递数据，但是在使用和用途上有一些明显的区别
  2. Get请求：
    • 用途：用于从服务器获取数据，通常用于读取数据(查询)
    • 数据传输：通过URL参数传递的数据，数据附加在URL的末尾
    • 数据长度限制：有限制，因为URL的长度受限制，通常是2048个字符
    • 安全性：较不安全，因为数据在URL中可见，容易被拦截，不适用于敏感数据
    • 缓存：可以被缓存，浏览器可以缓存get请求，以提高性能
  3. Post请求
    • 用途：用于向服务器提交数据，通常用于写入操作，如添加，修改，删除
    • 数据传输：通过HTTP请求体传递数据，数据在URL中不可见
    • 数据长度限制：较大，通常没有固定的长度限制，但是服务器和浏览器可能有各自的配置限制
    • 安全性：相对较安全，因为数据在URL中不可见，更适合传递敏感数据
    • 缓存：通常不缓存，因为post请求通常会对服务器状态进行更改，而不适合被缓存

RESTFull编程风格

Http动词
  • GET:用于获取资源的信息(查询)
  • POST:用于创建新资源(添加)
  • PUT:用于更新资源(修改)
  • DELETE:用于删除资源

前端向后端传输数据

  1. 传输查询字符串

    • POST http://localhost:8080/newsdemo/SecondTitleServlet
Content-Type: application/x-www-form-urlencoded

titleName=news999&creator=tom&newContent=jxl&parentTitleId=2

      
- 后端

  ~~~java
  String titleName = request.getParameter("titleName");

    • http客户端中测试

      GET http://localhost:8080/newsdemo/SecondTitleServlet?action=getAll

###
GET http://localhost:8080/newsdemo/SecondTitleServlet?action=Search&sid=1

###
GET http://localhost:8080/newsdemo/SecondTitleServlet?action=getByPaged&pageNum=2&pageSize=3

###

POST http://localhost:8080/newsdemo/SecondTitleServlet
Content-Type: application/x-www-form-urlencoded

titleName=news999&creator=tom&newContent=jxl&parentTitleId=2


###


DELETE http://localhost:8080/newsdemo/SecondTitleServlet?sid=6


###

PUT http://localhost:8080/newsdemo/SecondTitleServlet?sid=6&titleName=news1145&creator=tom&newContent=jxl&parentTitleId=2



###

  2. 传输JSON数据格式

    • {
    "titleName":"news666",
     "creator":"tom",
     "newContent":"888",
     "parentTitleId":1,
     "sid":1
         
}

      
- ~~~java
  //得到JSON数据字符串
   BufferedReader reader = req.getReader();
          StringBuilder stb = new StringBuilder();
          String line;
          while ((line = reader.readLine()) != null){
              stb.append(line);
          }
          
  //解析JSON字符串为对象，可以使用Gson.jar来解析
          Gson gson = new Gson();
          SecondTitle secondTitle = gson.fromJson(stb.toString(), SecondTitle.class);
          System.out.println(secondTitle);

ServletUtils

package com.neu.news.utils;
import com.google.gson.Gson;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;

public class ServletUtils {
    private static Gson gson = new Gson();
    public static <T> T parseJSONRequest(HttpServletRequest request,Class<T> clazz) throws IOException {
        StringBuffer jsonBuilder = new StringBuffer();
        try(BufferedReader reader = request.getReader()) {
            String line;
            while ((line = reader.readLine()) != null){
                jsonBuilder.append(line);
            }
        }
        String jsonData = jsonBuilder.toString();
        return gson.fromJson(jsonData,clazz);
    }

    public  static void sendJsonResponse(HttpServletResponse response,Object obj) throws IOException {
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().println(gson.toJson(obj));
        response.getWriter().flush();
    }
}
//查询
    private void doGetByPaged(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        int pageNum = Integer.parseInt(req.getParameter("pageNum"));
        int pageSize = Integer.parseInt(req.getParameter("pageSize"));
        List<SecondTitle> list = secondTitleDao.getByPaged(pageNum, pageSize);
        ServletUtils.sendJsonResponse(resp,list);
    }

    private void doGetAll(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        List<SecondTitle> all = secondTitleDao.getAll();
        ServletUtils.sendJsonResponse(resp,all);

    }

    private void doSeacher(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        int sid = Integer.parseInt(req.getParameter("sid"));
        SecondTitle byId = secondTitleDao.getById(sid);
        ServletUtils.sendJsonResponse(resp,byId);

    }
//得到java对象从JSON对象
SecondTitle secondTitle = ServletUtils.parseJSONRequest(req, SecondTitle.class);

  1. 定义：是一小段的文本信息，web服务器将它发送到浏览器，之后浏览器在访问同一网站的时候又将它原封不动地返回给服务器

  2. 创建

    Cookie cookie = new Cookie(string name,string value);//value中不能有空格

  3. 发送给浏览器

    response.addCookie(cookie);

  4. 得到Cookie

    Cookie[] cookies = req.getCookies();
String lastTime = null;
for(Cookie cookie : Cookies){
    if(cookie.getName().equals("lastTime")){
        lastTime = cookie.getValue();
        break;
    }
}
    • getName():得到当前cookie的名字
    • getValue():得到当前cookie的值

  5. 持久化Cookie

    • void setMaxAge(int)：设置cookie的最大生存期，以秒为单位
    • 参数值为正数，表示cookie将在经过该值表示的秒数后到期
    • 负值意味着cookie不会被持久化，将在内存中，将在浏览器退出的时候就删除
    • 0表示让浏览器删除cookie

  6. 缺点：

    • 保存在客户端，相对不安全，保存数据的时候最好加密
    • 增加了请求的数据量
    • 客户端可以禁用Cookie

Session

  1. HttpSession：会话对象，保存会话期间当前用户的信息，其他用户不能访问

  2. 得到Session对象

    HttpSession session = request.getSession();

  3. 向Session中添加数据

    session.setAttribute(string key,Object obj);

  4. 得到Session中的数据

    Object obj = session.getAttribute(string key);

  5. 注销Session

    session.invalidate();

  6. 设置最大间隔时间

    session.setMaxInactiveInterval(60*30);//单位为秒

  7. 注意：session信息放到服务器中，不到万不得已，不要用

  8. 原理：

    • 当第一次访问服务器并调用了getSession()方法，服务器会创建一个SessionID和一个Session对象，并将他们关联起来，然后把SessionID放到cookie里，cookie随着响应发送给用户浏览器
    • 用户在会话结束前，再次访问服务器的时候，浏览器会把上次送来的包含SessionID的Cookie，发送回服务器
    • 服务器根据SessionID找到之前关联的用户的HttpSession对象

Filter

  1. 定义：对Servlet容器的请求和响应对象进行检查和修改

  2. 过滤的内容：Servlet，JSP，html，图片，css等

  3. 使用

    • 定义一个类，实现Filter接口，重写抽象方法
      • init()：初始化方法，只执行一次
      • doFilter()：过滤的方法，每拦截一次请求，该方法执行一次
      • destroy()：销毁的时候执行的方法，只执行一次
    • FilterChain：过滤器链，用来调用下一个组件(Filter、Servlet)
    • 在一个web应用中都可以部署多个过滤器，这些过滤器组成了一个过滤器链

  4. 编码过滤器

    package com.neu.servlet;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebFilter(value = "/*",initParams = {@WebInitParam(name="encoding",value = "utf-8")})
public class EncodingFilter implements Filter {

    private String encoding;
    /**
     * @param servletRequest
     * @param servletResponse
     * @param filterChain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
//        servletResponse.setContentType("application/json;charset=utf-8");
        ((HttpServletResponse)servletResponse).setCharacterEncoding("utf-8");
        //放行，调用下一个组件(另一个filter，Servlet)
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        filterConfig.getInitParameter("encoding");
    }
}
登录检查Filter
package com.neu.servlet;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
@WebFilter(value="/*")
public class CheckLoginFilter implements Filter {
    /**
     * @param servletRequest
     * @param servletResponse
     * @param filterChain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = ((HttpServletRequest) servletRequest);
        HttpServletResponse response = ((HttpServletResponse) servletResponse);
        String uri = request.getRequestURI();
        if (!(uri.endsWith("login.html")||uri.endsWith("LoginServlet"))){
            HttpSession session = request.getSession();
            Object username = session.getAttribute("username");
            if (username == null){
                response.sendRedirect(request.getContextPath()+"/login.html");
            }

        }
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

AJAX

  1. 定义：Asynchronous 异步的 JavaScriptjav And和XML
  2. 异步的：它允许在发送请求后继续执行其他任务，不必等待服务器响应，当服务器返回响应后，会触发回调函数来处理请求，好处：提高用户体验
  3. 同步的：同步请求是阻塞的，浏览器在发送请求后会一直等待服务器响应直到响应返回或超时为止，缺点：用户体验差

Axios

  1. 定义：对原生的Ajax进行了封装，简化书写

  2. 安装

    npm install axios

  3. 跨域问题(Cross Origin Resource Share，CORS)，是一个常见的安全问题，它涉及到在一个网页中加载来自不同域名(或协议、端口号)的资源时的安全限制，这是浏览器实施的一种安全的策略

    package com.neu.news.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebFilter(value = "/*")
public class CORSFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;

        // 允许的跨域来源，这里设置为允许所有来源，你可以根据需要进行配置
        httpResponse.setHeader("Access-Control-Allow-Origin", "*");

        // 允许的 HTTP 方法，例如 GET、POST、PUT、DELETE 等
        httpResponse.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");

        // 允许的自定义请求头字段，可以根据你的需求添加
        httpResponse.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");

        // 允许发送凭据（例如，带有 cookie 的请求）
        httpResponse.setHeader("Access-Control-Allow-Credentials", "true");

        // 预检请求的有效期，单位为秒
        httpResponse.setHeader("Access-Control-Max-Age", "3600");

        // 继续执行过滤链
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

  4. 发送Get请求

    • 路径参数

      const url = `http://localhost:8080/newsdemo/UserServlet?action=login&username=${username.value}&password=${password.value}`;
   axios.get(url).then(resp =>{
       if (resp.data.status == 200){
           alert("用户"+resp.data.data.username+"登录成功")
       }else {
           alert(resp.data.msg)
       }
   })

    • url参数

      const url = `http://localhost:8080/newsdemo/UserServlet?action=login`;
   axios.get(url,{
       params:{
           username:username.value,
           password:password.value
       }
   }).then(resp =>{
       if (resp.data.status == 200){
           alert("用户"+resp.data.data.username+"登录成功")
       }else {
           alert(resp.data.msg)
       }
   })

  5. 发送POST请求

    • 通过data选项发送数据(json)

      import {reactive} from "vue";
import axios from "axios";

const firstTitle = reactive({
    titleName:"",
    creator:""
})
const addFirst = ()=>{
    const url = "http://localhost:8080/newsdemo/FirstTitleServlet"
    axios.post(url,firstTitle).then(resp=>{
        if (resp.data.status == 200 && resp.data.data == 1){
            alert(resp.data.msg)
        }else {
            alert("添加失败")
        }
    })
}