Request（获取请求数据） & Response（设置响应数据） 的概念和使用

最新推荐文章于 2023-11-23 17:41:10 发布
最新推荐文章于 2023-11-23 17:41:10 发布
阅读量6.4k 收藏 24
点赞数 1
分类专栏： java框架 文章标签： servlet java tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/habe33/article/details/125698965
版权

1，Request和Response的概述

  • request对象是用来封装请求数据的对象
  • response对象是用来封装响应数据的对象

Request是请求对象，Response是响应对象。这两个对象在我们使用Servlet的时候有看到：
在这里插入图片描述

request和response这两个参数的作用是什么?
在这里插入图片描述

  • request:获取请求数据
    • 浏览器会发送HTTP请求到后台服务器[Tomcat]
    • HTTP的请求中会包含很多请求数据[请求行+请求头+请求体]
    • 后台服务器[Tomcat] 会对HTTP请求中的 数据进行解析并把解析结果存入到一个对象中
    • 所存入的对象即为request对象，所以我们可以从request对象中获取请求的相关参数
    • 获取到数据后就可以继续后续的业务，比如获取用户名和密码就可以实现登录操作的相关业务
  • response:设置响应数据
    • 业务处理完后，后台就需要给前端返回业务处理的结果即响应数据
    • 把响应数据封装到response对象中
    • 后台服务器[Tomcat]会解析 response对象,按照 [响应行+响应头+响应体]格式拼接 结果
    • 浏览器最终解析结果，把内容展示在浏览器给用户浏览

对于上述所讲的内容，我们通过一个案例来初步体验下request和response对象的使用。

@WebServlet("/demo3")
public class ServletDemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //使用request对象 获取请求数据
        String name = request.getParameter("name");//url?name=zhangsan

        //使用response对象 设置响应数据
        response.setHeader("content-type","text/html;charset=utf-8");
        response.getWriter().write("<h1>"+name+",欢迎您！</h1>");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("Post...");
    }
}

启动成功后就可以通过浏览器来访问，并且根据传入参数(name)的不同就可以在页面上展示不同的内容

2，Request对象

  • request继承体系
  • request获取请求参数
  • request请求转发

2.1 Request继承体系

  • 当我们的Servlet类实现的是Servlet接口的时候，service方法中的参数是ServletRequest和ServletResponse
  • 当我们的Servlet类继承的是HttpServlet类的时候，doGet和doPost方法中的参数就变成HttpServletRequest和HttpServletReponse

在这里插入图片描述

所以ServletRequest和HttpServletRequest是继承关系，并且两个都是接口，接口是无法创建对象，需要使用Request继承体系中的RequestFacade实现类创建对象:

RequestFacade:

  • 该类实现了HttpServletRequest接口，也间接实现了ServletRequest接口。
  • Servlet类中的service方法、doGet方法或者是doPost方法最终都是由Web服务器[Tomcat]来调用的，所以Tomcat提供了方法参数接口的具体实现类，并完成了对象的创建
  • 要想了解RequestFacade中都提供了哪些方法，我们可以直接查看JavaEE的API文档中关于ServletRequest和HttpServletRequest的接口文档，因为RequestFacade实现了其接口就需要重写接口中的方法

小结

  • Request的继承体系为ServletRequest–>HttpServletRequest–>RequestFacade
  • Tomcat需要解析请求数据，封装为request对象,并且创建request对象传递到service方法
  • 使用request对象，可以查阅JavaEE API文档的HttpServletRequest接口中方法说明

2.2 Request获取请求数据

HTTP请求数据总共分为三部分内容，分别是请求行、请求头、请求体，如何获取?
在这里插入图片描述

介绍完上述方法后，咱们通过代码把上述方法都使用下:

/**
 * request 获取请求数据
 */
@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// String getMethod()：获取请求方式： GET
        String method = req.getMethod();
        System.out.println(method);//GET
        // String getContextPath()：获取虚拟目录(项目访问路径)：/request-demo
        String contextPath = req.getContextPath();
        System.out.println(contextPath);
        // StringBuffer getRequestURL(): 获取URL(统一资源定位符)：http://localhost:8080/request-demo/req1
        StringBuffer url = req.getRequestURL();
        System.out.println(url.toString());
        // String getRequestURI()：获取URI(统一资源标识符)： /request-demo/req1
        String uri = req.getRequestURI();
        System.out.println(uri);
        // String getQueryString()：获取请求参数（GET方式）： username=zhangsan
        String queryString = req.getQueryString();
        System.out.println(queryString);
        
//获取请求头: user-agent: 浏览器的版本信息
        String agent = req.getHeader("user-agent");
		System.out.println(agent);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//获取post 请求体：请求参数
        //1. 获取字符输入流，getInputStream()//文件数据
        BufferedReader br = req.getReader();//纯文本数据
        //2. 读取数据
        String line = br.readLine();
        System.out.println(line);
    }
}

启动服务器，访问http://localhost:8080/request-demo/req1?username=zhangsan&passwrod=123，查看获取的结果

2.2.1 获取请求行数据

请求行包含三块内容，分别是请求方式、请求资源路径、HTTP协议及版本

对于这三部分内容，request对象都提供了对应的API方法来获取，具体如下:

  • 获取请求方式: GET
String getMethod()
  • 获取虚拟目录(项目访问路径): /request-demo
String getContextPath()
  • 获取URL(统一资源定位符): http://localhost:8080/request-demo/req1
StringBuffer getRequestURL()
  • 获取URI(统一资源标识符): /request-demo/req1
String getRequestURI()
  • 获取请求参数(GET方式): username=zhangsan&password=123
String getQueryString()
2.2.2 获取请求头数据

请求头的数据，格式为key: value
请求头名称获取对应值的方法为:

String getHeader(String name)
2.2.3 获取请求体数据

浏览器在发送GET请求的时候是没有请求体的，所以需要把请求方式变更为POST

  • 获取字节输入流，如果前端发送的是字节数据，比如传递的是文件数据，则使用该方法
ServletInputStream getInputStream()
该方法可以获取字节
  • 获取字符输入流，如果前端发送的是纯文本数据，则使用该方法
BufferedReader getReader()

接下来，大家需要思考，要想获取到请求体的内容该如何实现?

具体实现的步骤如下:

1.准备一个页面，在页面中添加form表单,用来发送post请求

2.在Servlet的doPost方法中获取请求体数据

3.在doPost方法中使用request的getReader()或者getInputStream()来获取

4.访问测试

  1. 在项目的webapp目录下添加一个html页面，名称为：req.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<!-- 
    action:form表单提交的请求地址
    method:请求方式，指定为post
-->
<form action="/request-demo/req1" method="post">
    <input type="text" name="username">
    <input type="password" name="password">
    <input type="submit">
</form>
</body>
</html>
  1. 在Servlet的doPost方法中获取数据
/**
 * request 获取请求数据
 */
@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //在此处获取请求体中的数据
    }
}
  1. 调用getReader()或者getInputStream()方法，因为目前前端传递的是纯文本数据，所以我们采用getReader()方法来获取
/**
 * request 获取请求数据
 */
@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         //获取post 请求体：请求参数
        //1. 获取字符输入流
        BufferedReader br = req.getReader();
        //2. 读取数据
        String line = br.readLine();
        System.out.println(line);
    }
}

注意

BufferedReader流是通过request对象来获取的，当请求完成后request对象就会被销毁，request对象被销毁后，BufferedReader流就会自动关闭，所以此处就不需要手动关闭流了。

2.2.4 获取请求参数的通用方式

在这里插入图片描述

2.什么是请求数据?

  • 请求数据则是包含请求行、请求头和请求体的所有数据

3.请求参数和请求数据的关系是什么?

  • 3.1 请求参数是请求数据中的部分内容
  • 3.2 如果是GET请求，请求参数在请求行中
  • 3.3 如果是POST请求，请求参数一般在请求体中

对于请求参数的获取,常用的有以下两种:

  • GET方式:
String getQueryString()
  • POST方式:
BufferedReader getReader();

//获取请求方式
        String method = req.getMethod();
        //获取请求参数
        String params = "";
        if("GET".equals(method)){
            params = req.getQueryString();
        }else if("POST".equals(method)){
            BufferedReader reader = req.getReader();
            params = reader.readLine();
        }
解决方案二:调用request提供的获取请求参数方法 常用

request对象已经将获取请求参数的方法进行了封装，并且request提供的方法实现的功能更强大，只需要调用request提供的方法即可：

(1)根据不同的请求方式获取请求参数，

(2)把获取到的内容进行分割，

(3)把分割后端数据，存入到一个Map集合中:

注意:因为参数的值可能是一个，也可能有多个，所以Map的值的类型为String数组。

基于上述理论，request对象为我们提供了如下方法:

  • 获取所有参数Map集合
Map<String,String[]> getParameterMap()
  • 根据名称获取参数值（数组）
String[] getParameterValues(String name)
  • 根据名称获取参数值(单个值)
String getParameter(String name)

小结

  • req.getParameter()方法使用的频率会比较高

  • 以后我们再写代码的时候，就只需要按照如下格式来编写:

public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       //采用request提供的获取请求参数的通用方式来获取请求参数
       //1. 获取所有参数的Map集合
        Map<String, String[]> map = req.getParameterMap();
        for (String key : map.keySet()) {
            // username:zhangsan lisi
            System.out.print(key+":");

            //获取值
            String[] values = map.get(key);
            for (String value : values) {
                System.out.print(value + " ");
            }

            System.out.println();
        }
       //编写其他的业务代码...
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

2.4 请求参数中文乱码问题

小结

  1. 中文乱码解决方案

  • POST请求和GET请求的参数中如果有中文，后台接收数据就会出现中文乱码问题

    GET请求在Tomcat8.0以后的版本就不会出现了

  • POST请求解决方案是:设置输入流的编码

    request.setCharacterEncoding("UTF-8");
注意:设置的字符集要和页面保持一致

  • 通用方式（GET/POST）：需要先解码，再编码

    new String(username.getBytes("ISO-8859-1"),"UTF-8");
  1. URL编码实现方式:

  • 编码:

    URLEncoder.encode(str,"UTF-8");

  • 解码:

    URLDecoder.decode(s,"ISO-8859-1");

不管是GET还是POST请求，在发送的请求参数中如果有中文，在后台接收的时候，都接收数据会出现中文乱码的问题。

  • 分析出现中文乱码的原因：
    • 页面设置的编码格式为UTF-8*
    • TOMCAT在获取流的时候采用的编码是ISO-8859-1(底层默认，不可更改）
    • 浏览器把中文参数按照UTF-8进行URL编码
    • Tomcat对获取到的内容进行了ISO-8859-1的URL解码
    • ISO-8859-1编码是不支持中文的，所以会出现乱码
2.4.1 POST请求解决方案：request.setCharacterEncoding(“UTF-8”);

POST的请求参数是通过request的getReader()来获取流中的数据

  • 解决方案：
    • 通过request.setCharacterEncoding(“UTF-8”)设置输入流编码,UTF-8也可以写成小写
      （这种方案不适用于GET请求）
      修改后的代码为:
/**
 * 中文乱码问题解决方案
 */
@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 解决乱码: POST getReader()
        //设置字符输入流的编码，设置的字符集要和页面保持一致
        request.setCharacterEncoding("UTF-8");
       //2. 获取username
       String username = request.getParameter("username");
       System.out.println(username);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

重新发送POST请求，就会在控制台看到正常展示的中文结果。

2.4.2 GET请求解决方案

POST请求的中文乱码解决方案为什么不适用GET请求？

  • GET请求获取请求参数的方式是request.getQueryString()
  • POST请求获取请求参数的方式是request.getReader()
  • request.setCharacterEncoding(“utf-8”)是设置request处理流的编码
  • getQueryString方法并没有通过流的方式获取数据

URL编码和URL解码，什么是URL编码，什么又是URL解码呢?

URL编码(了解）

这块知识我们只需要了解下即可,具体编码过程分两步，分别是:

(1)将字符串按照编码方式转为二进制

(2)每个字节转为2个16进制数并在前边加上%

编码:

java.net.URLEncoder.encode("需要被编码的内容","字符集(UTF-8)")

解码:

java.net.URLDecoder.decode("需要被解码的内容","字符集(UTF-8)")

  • 在进行编码和解码的时候，不管使用的是哪个字符集，他们对应的进制值也是一样的

  • 为所以我们可以考虑把å¼ ä¸‰转换成字节，在把字节转换成张三，在转换的过程中是它们的编码一致，就可以解决中文乱码问题。

  • 解决方案：

  • 1.按照ISO-8859-1编码获取乱码å¼ ä¸‰对应的字节数组

    byte[] bytes = decode.getBytes(“ISO-8859-1”);

  • 2.按照UTF-8编码获取字节数组对应的字符串

    String s = new String(bytes, “utf-8”);

  • 即：username = new String(username.getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8);

实现代码如下:
/**
 * 中文乱码问题解决方案
 */
@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 解决乱码：POST，getReader()
        //request.setCharacterEncoding("UTF-8");//设置字符输入流的编码

        //2. 获取username
        String username = request.getParameter("username");
        System.out.println("解决乱码前："+username);

        //3. GET,获取参数的方式：getQueryString
        // 乱码原因：tomcat进行URL解码，默认的字符集ISO-8859-1
       /* //3.1 先对乱码数据进行编码：转为字节数组
        byte[] bytes = username.getBytes(StandardCharsets.ISO_8859_1);
        //3.2 字节数组解码
        username = new String(bytes, StandardCharsets.UTF_8);*/

        username  = new String(username.getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8);

        System.out.println("解决乱码后："+username);

    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

2.5 Request请求转发

  1. 请求转发(forward):一种在服务器内部的资源跳转方式。
    (1)浏览器发送请求给服务器，服务器中对应的资源A接收到请求
    (2)资源A处理完请求后将请求发给资源B
    (3)资源B处理完后将结果响应给浏览器
    (4)请求从资源A到资源B的过程就叫请求转发

  2. 请求转发的实现方式:
    req.getRequestDispatcher("资源B路径").forward(req,resp);
    在这里插入图片描述

  3. 请求转发的特点

  • 浏览器地址栏路径不发生变化
    虽然后台从/req5转发到/req6,但是浏览器的地址一直是/req5,未发生变化
  • 只能转发到当前服务器的内部资源
    不能从一个服务器通过转发访问另一台服务器
  • 一次请求，可以在转发资源间使用request共享数据
    • 操作Request对象的方法：setAttribute/getAttribute/removeAttribute
    • 虽然后台从/req5转发到/req6，但是这个只有一次请求

3，Response对象

前面讲解完Request对象，接下来我们回到刚开始的那张图:

  • Request:使用request对象来获取请求数据
  • Response:使用response对象来设置响应数据

Reponse的继承体系和Request的继承体系也非常相似:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GIrNPhVA-1657372660979)(assets/1628857761317.png)]

介绍完Response的相关体系结构后，接下来对于Response我们需要学习如下内容:

  • Response设置响应数据的功能介绍
  • Response完成重定向
  • Response响应字符数据
  • Response响应字节数据
    在这里插入图片描述
    在这里插入图片描述

3.1 Response设置响应数据功能介绍

HTTP响应数据总共分为三部分内容，分别是响应行、响应头、响应体，对于这三部分内容的数据，respone对象都提供了哪些方法来进行设置?

  1. 响应行：设置响应状态码:
void setStatus(int sc);
  1. 响应头：设置响应头键值对：
void setHeader(String name,String value);
  1. 响应体：通过字符、字节输出流的方式往浏览器写，

获取字符输出流:

PrintWriter getWriter();

获取字节输出流

ServletOutputStream getOutputStream();

3.2 Respones请求重定向

  1. Response重定向(redirect):一种资源跳转方式。
    在这里插入图片描述

(1)浏览器发送请求给服务器，服务器中对应的资源A接收到请求

(2)资源A现在无法处理该请求，就会给浏览器响应一个302的状态码+location的一个访问资源B的路径

(3)浏览器接收到响应状态码为302就会重新发送请求到location对应的访问地址去访问资源B

(4)资源B接收到请求后进行处理并最终给浏览器响应结果，这整个过程就叫重定向

  1. 重定向的实现方式:
resp.setStatus(302);
resp.setHeader("location","资源B的访问路径");

//简化方式完成重定向
        //动态获取虚拟目录
        String contextPath = request.getContextPath();
        response.sendRedirect(contextPath+"/resp2");

  1. 与请求转发对比：
    在这里插入图片描述

  2. 重定向的特点

  • 浏览器地址栏路径发送变化
    当进行重定向访问的时候，由于是由浏览器发送的两次请求，所以地址会发生变化

  • 可以重定向到任何位置的资源(服务内容、外部均可)
    因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。

  • 两次请求，不能在多个资源使用request共享数据
    因为浏览器发送了两次请求，是两个不同的request对象，就无法通过request对象进行共享数据

3.3 路径问题

  1. 问题1：转发的时候路径上没有加/request-demo而重定向加了，那么到底什么时候需要加，什么时候不需要加呢?
    判断依据
  • 浏览器使用:需要加虚拟目录(项目访问路径)（重定向）
  • 服务端使用:不需要加虚拟目录（转发）

需要加

  • <a href='路劲'>
  • <form action='路径'>
  • resp.sendRedirect(“路径”)

不需要加

  • req.getRequestDispatcher(“路径”)

//动态获取虚拟目录
String contextPath = request.getContextPath();

3.4 Response响应字符数据

在这里插入图片描述

要想将字符数据写回到浏览器，我们需要两个步骤:

  • 通过Response对象获取字符输出流： PrintWriter writer = resp.getWriter();

  • 通过字符输出流写数据: writer.write(“aaa”);

接下来，我们实现通过些案例把响应字符数据给实际应用下:

  1. 返回一个简单的字符串aaa
/**
 * 响应字符数据：设置字符数据的响应体
 */
@WebServlet("/resp3")
public class ResponseDemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        //1. 获取字符输出流
        PrintWriter writer = response.getWriter();
		 writer.write("aaa");
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xNn0Ey1v-1657372661024)(assets/1628863905362.png)]

  1. 返回一串html字符串，并且能被浏览器解析
//设置响应的数据格式及数据的编码
response.setContentType("text/html;charset=utf-8");//有中文字符时
PrintWriter writer = response.getWriter();
//content-type，告诉浏览器返回的数据类型是HTML类型数据，这样浏览器才会解析HTML标签
//response.setHeader("content-type","text/html");
writer.write("<h1>aaa</h1>");
//一次请求响应结束后，response对象就会被销毁掉，由服务器关闭所以不要手动关闭流。

3.3 Response响应字节数据

在这里插入图片描述

要想将字节数据写回到浏览器，我们需要两个步骤:

  • 通过Response对象获取字节输出流：ServletOutputStream outputStream = resp.getOutputStream();

  • 通过字节输出流写数据: outputStream.write(字节数据);

代码实现：

  1. 返回一个图片文件到浏览器
/**
 * 响应字节数据：设置字节数据的响应体
 */
@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 读取文件
        FileInputStream fis = new FileInputStream("d://a.jpg");
        //2. 获取response字节输出流
        ServletOutputStream os = response.getOutputStream();
        //3. 完成流的copy
        	//fis:输入流
			//os:输出流
		IOUtils.copy(fis,os);
        fis.close();
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

需要 pom.xml添加依赖

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

4，用户注册登录案例

接下来我们通过两个比较常见的案例，一个
是注册，一个是登录来对今天学习的内容进行一个实战演练，首先来实现用户登录。

4.1 用户登录

4.1.1 需求分析

用户登录：在这里插入图片描述

  1. 用户在登录页面输入用户名和密码，提交请求给LoginServlet
  2. 在LoginServlet中接收请求和数据[用户名和密码]
  3. 在LoginServlt中通过Mybatis实现调用UserMapper来根据用户名和密码查询数据库表
  4. 将查询的结果封装到User对象中进行返回
  5. 在LoginServlet中判断返回的User对象是否为null
  6. 如果为nul，说明根据用户名和密码没有查询到用户，则登录失败，返回"登录失败"数据给前端
  7. 如果不为null,则说明用户存在并且密码正确，则登录成功，返回"登录成功"数据给前端
4.1.2 环境准备

  1. 复制资料中的静态页面到项目的webapp目录下

  2. 创建db1数据库，创建tb_user表，创建User实体类
    2.1 将资料\1. 登陆注册案例\2. MyBatis环境\tb_user.sql中的sql语句执行下:

2.2 将资料\1. 登陆注册案例\2. MyBatis环境\User.java拷贝到com.itheima.pojo

  1. 在项目的pom.xml导入Mybatis和Mysql驱动坐标
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.34</version>
</dependency>
  1. 创建mybatis-config.xml核心配置文件，UserMapper.xml映射文件,UserMapper接口

4.1 将资料\1. 登陆注册案例\2. MyBatis环境\mybatis-config.xml拷贝到resources目录下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--起别名-->
    <typeAliases>
        <package name="com.itheima.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--
                    useSSL:关闭SSL安全连接 性能更高
                    useServerPrepStmts:开启预编译功能
                    &amp; 等同于 & ,xml配置文件中不能直接写 &符号
                -->
                <property name="url" value="jdbc:mysql:///db1?useSSL=false&amp;useServerPrepStmts=true"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--扫描mapper-->
        <package name="com.itheima.mapper"/>
    </mappers>
</configuration>

4.2 在com.itheima.mapper包下创建UserMapper接口

public interface UserMapper {

}

4.3 将资料\1. 登陆注册案例\2. MyBatis环境\UserMapper.xml拷贝到resources目录下

注意：在resources下创建UserMapper.xml的目录时，要使用/分割

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zwRlPhSp-1657372661087)(assets/1628867237329.png)]

至此我们所需要的环境就都已经准备好了，具体该如何实现?

4.1.3 代码实现
  1. 在UserMapper接口中提供一个根据用户名和密码查询用户对象的方法
/**
     * 根据用户名和密码查询用户对象
     * @param username
     * @param password
     * @return
     */
    @Select("select * from tb_user where username = #{username} and password = #{password}")
    User select(@Param("username") String username,@Param("password")  String password);

说明

@Param注解的作用:用于传递参数,是方法的参数可以与SQL中的字段名相对应。

  1. 修改loign.html
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>login</title>
    <link href="css/login.css" rel="stylesheet">
</head>

<body>
<div id="loginDiv">
    <form action="/request-demo/loginServlet" method="post" id="form">
        <h1 id="loginMsg">LOGIN IN</h1>
        <p>Username:<input id="username" name="username" type="text"></p>

        <p>Password:<input id="password" name="password" type="password"></p>

        <div id="subDiv">
            <input type="submit" class="button" value="login up">
            <input type="reset" class="button" value="reset">&nbsp;&nbsp;&nbsp;
            <a href="register.html">没有账号？点击注册</a>
        </div>
    </form>
</div>

</body>
</html>
  1. 编写LoginServlet
@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 接收用户名和密码
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        //2. 调用MyBatis完成查询
        //2.1 获取SqlSessionFactory对象
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //2.2 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //2.3 获取Mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //2.4 调用方法
        User user = userMapper.select(username, password);
        //2.5 释放资源
        sqlSession.close();


        //获取字符输出流，并设置content type
        response.setContentType("text/html;charset=utf-8");
        PrintWriter writer = response.getWriter();
        //3. 判断user释放为null
        if(user != null){
            // 登陆成功
            writer.write("登陆成功");
        }else {
            // 登陆失败
            writer.write("登陆失败");
        }
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}
  1. 启动服务器测试

4.1 如果用户名和密码输入错误，则

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1VEINTP5-1657372661090)(assets/1628867761245.png)]

4.2 如果用户名和密码输入正确，则

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b1viQhAQ-1657372661092)(assets/1628867801708.png)]

至此用户的登录功能就已经完成了~

4.2 用户注册

4.2.1 需求分析

在这里插入图片描述

  1. 用户在注册页面输入用户名和密码，提交请求给RegisterServlet
  2. 在RegisterServlet中接收请求和数据[用户名和密码]
  3. 在RegisterServlet中通过Mybatis实现调用UserMapper来根据用户名查询数据库表
  4. 将查询的结果封装到User对象中进行返回
  5. 在RegisterServlet中判断返回的User对象是否为null
  6. 如果为nul，说明根据用户名可用，则调用UserMapper来实现添加用户
  7. 如果不为null,则说明用户不可以，返回"用户名已存在"数据给前端
4.2.2 代码编写
  1. 编写UserMapper提供根据用户名查询用户数据方法和添加用户方法
/**
* 根据用户名查询用户对象
* @param username
* @return
*/
@Select("select * from tb_user where username = #{username}")
User selectByUsername(String username);

/**
* 添加用户
* @param user
*/
@Insert("insert into tb_user values(null,#{username},#{password})")
void add(User user);
  1. 修改register.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>欢迎注册</title>
    <link href="css/register.css" rel="stylesheet">
</head>
<body>

<div class="form-div">
    <div class="reg-content">
        <h1>欢迎注册</h1>
        <span>已有帐号？</span> <a href="login.html">登录</a>
    </div>
    <form id="reg-form" action="/request-demo/registerServlet" method="post">

        <table>

            <tr>
                <td>用户名</td>
                <td class="inputs">
                    <input name="username" type="text" id="username">
                    <br>
                    <span id="username_err" class="err_msg" style="display: none">用户名不太受欢迎</span>
                </td>

            </tr>

            <tr>
                <td>密码</td>
                <td class="inputs">
                    <input name="password" type="password" id="password">
                    <br>
                    <span id="password_err" class="err_msg" style="display: none">密码格式有误</span>
                </td>
            </tr>

        </table>

        <div class="buttons">
            <input value="注 册" type="submit" id="reg_btn">
        </div>
        <br class="clear">
    </form>

</div>
</body>
</html>
  1. 创建RegisterServlet类
@WebServlet("/registerServlet")
public class RegisterServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 接收用户数据
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        //封装用户对象
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);

        //2. 调用mapper 根据用户名查询用户对象
        //2.1 获取SqlSessionFactory对象
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //2.2 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //2.3 获取Mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //2.4 调用方法
        User u = userMapper.selectByUsername(username);

        //3. 判断用户对象释放为null
        if( u == null){
            // 用户名不存在，添加用户
            userMapper.add(user);

            // 提交事务
            sqlSession.commit();
            // 释放资源
            sqlSession.close();
        }else {
            // 用户名存在，给出提示信息
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("用户名已存在");
        }

    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}
  1. 启动服务器进行测试

4.1 如果测试成功，则在数据库中就能查看到新注册的数据

4.2 如果用户已经存在，则在页面上展示 用户名已存在 的提示信息

4.3 SqlSessionFactory工具类抽取

在这里插入图片描述

上面两个功能已经实现，但是在写Servlet的时候，因为需要使用Mybatis来完成数据库的操作，所以对于Mybatis的基础操作就出现了些重复代码，如下

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new 
	SqlSessionFactoryBuilder().build(inputStream);

有了这些重复代码就会造成一些问题:

  • 重复代码不利于后期的维护
  • SqlSessionFactory工厂类进行重复创建
    • 就相当于每次买手机都需要重新创建一个手机生产工厂来给你制造一个手机一样，资源消耗非常大但性能却非常低。所以这么做是不允许的。

那如何来优化呢？

  • 代码重复可以抽取工具类
  • 对指定代码只需要执行一次可以使用静态代码块

有了这两个方向后，代码具体该如何编写?

public class SqlSessionFactoryUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        //静态代码块会随着类的加载而自动执行，且只执行一次
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static SqlSessionFactory getSqlSessionFactory(){
        return sqlSessionFactory;
    }
}

工具类抽取以后，以后在对Mybatis的SqlSession进行操作的时候，就可以直接使用

SqlSessionFactory sqlSessionFactory =SqlSessionFactoryUtils.getSqlSessionFactory();

这样就可以很好的解决上面所说的代码重复和重复创建工厂导致性能低的问题了。

小孙努力学
关注
  • 1
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python接口测试get请求过程详解
12-20
python 做借口测试用到的是requests模块，首先要导入requests库，pip install requests 1、get直接请求方式 　　以豆瓣网为例： url = 'https://read.douban.com/' respose = requests.get(url=url) # status_code 为返回的状态码 print(respose.status_code) # text为返回的数据 print(respose.text) 　　请求结果：返回状态码为200，表明请求的服务器响应正常，但不能说明该接口正常 　　　　　　判断接口正常，看返回数据，如果返回数据达
一、Python网络数据获取1.0
01-20
Python网络数据获取相关学习知识一、抓取理论知识二、抓取实战内容**豆瓣影评为例****道指成分股数据**三、解析理论知识四、解析实战内容 相关学习知识 有些情况下，网页内容可能是动态生成的，此时网页的源代码并不对应网页所显示的内容。比如：股票数据信息，其数据经常在变化。 网络数据如何获取（爬取）？=抓取网页内容，解析网页内容 一、抓取理论知识 1、定义：客户机发送一个请求requests给服务器，服务器会返回一个响应response。 Urllib 内建模型—urllib.request—方便抓取网页内容 Requests第三方库—很适合中小型的的网络爬虫开发 Requests库是更简单
Laravel中GraphQL接口请求频率实战记录
01-21
前言 起源:通常在产品的运行过程,我们可能会做数据埋点,以此来知道用户触发的行为,访问了多少页面,做了哪些操作,来方便产品根据用户喜好的做不同的调整和推荐,同样在服务端开发层面,也要做好“数据埋点”,去记录接口的响应时长、接口调用频率,参数频率等,方便我们从后端角度去分析和优化问题,如果遇到异常行为或者大量攻击来源,我们可以具体针对到某个接口去进行优化。 项目环境: framework:laravel 5.8+ cache : redis >= 2.6.0 目前项目中几乎都使用的是 graphql 接口,采用的 package 是 php lighthouse graphql,那么主要
调用第三方接口使用进行传参和接收响应参数 ，post请求和delete请求方式
weixin_47056195的博客
03-28 2859
开发中 和第三方联调的时候 需要用到调用第三方接口，在此以作笔记，仅供学习参考使用 1. 将需要的传的参数转JSON // 1. 转为JSON String params = JSONObject.toJSONString(restVerb); log.info("请求接口地址==============="+OPEN_URL); //2. 调用请求接口doPost（方法名自定义） // OPEN_URL url为第三方的接口请求地址
API接口常用参数：路径参数、查询参数、请求参数、响应参数...
最新发布
small red red的博客
11-23 968
包含在HTTP请求体中，通常用于POST、PUT等请求方法，传递客户端向服务器提交的数据。包含在HTTP响应头部中，用于传递响应的元数据，例如内容类型、缓存控制等。包含在HTTP请求头部中，用于传递额外的信息，例如授权信息、内容类型等。包含在HTTP响应体中，传递服务器对请求的响应数据。用于标识资源的URL唯一标识符或标识特定资源的属性。后面附加的键值对形式传递的，不同参数之间使用。用于身份验证，例如用户名、密码、访问令牌等。查询参数是在 URL 中通过。
java获取response对象_Java 获取Request,Response对象方法
weixin_42525343的博客
02-12 3012
第一种、参数@RequestMapping("/test")@ResponseBodypublic void saveTest(HttpServletRequest req, HttpServletResponse resp){}第二种、注解@Autowired private HttpServletRequest request;第三种、上下文获取1、在web.xml配置监听器org.spr...
[转]在Controller中获取request和response对象的五种方式，分析各自的线程安全性
weixin_63161524的博客
04-08 3501
在使用Spring MVC开发Web系统时，经常需要在处理请求时使用request对象，比如获取客户端ip地址、请求的url、header中的属性（如cookie、授权信息）、body中的数据等。由于在Spring MVC中，处理请求的Controller、Service等对象都是单例的，因此获取request对象时最需要注意的问题，便是request对象是否是线程安全的：当有大量并发请求时，能否保证不同请求/线程中使用不同的request对象。
Response对象及常用方法
热门推荐
WBA
08-25 1万+
void addCookie(Cookie cookie）给客户端添加一个Cookie对象，以保存客户端的信息 void addDateHeader(String name,long value) 添加一个日期类型的HTTP首部信息，覆盖同名的HTTP首部 void addIntHeader(String name,int value) 添加一个整型的HTTP首部，并覆盖旧的HTTP首部 S...
Javaweb中的Request(请求)和Response（响应）
快乐学习
12-20 5220
目录 一、概念 二、请求（Request） 1.例子简介 2.Request继承体系 3.Request获取请求数据 （1）请求行 （2）请求头 （3）请求体 4.优化请求体参数的获取 5.解决请求参数乱码问题 6.请求转发 请求转发的特点 三、响应（Response） 1.Response继承体系 2.设置响应数据功能介绍 （1）响应行 （2）响应头 （3）响应体 3.重定向 （1）实现方式： （2）重定向特点 4.资源路径问题 （1）怎么判断
Java后端--封装响应值给前端
IT利刃出鞘的博客
08-14 4176
本文介绍封装Rest返回值给前端的方法。
浅谈web服务器项目中request请求和response的相关响应处理
08-18
主要介绍了浅谈web服务器项目中request请求和response的相关响应处理，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
response响应数据变成???&使用jquery发送带中文参数数据的get请求得到响应数据乱码解决过程
01-08
request请求数据设置编码使用：request.setCharacterEncoding(“UTF-8”); response响应数据设置编码使用:response.setContentType(“text/html; charset=UTF-8”);点击按钮，发送请求，响应回来的数据还是显示”???...
WinForm窗体程序中使用CefSharp获取加载后的资源、截取request参数、拦截response数据、注入jquery文件和js代码。
07-10
环境：vs2019、.net 4.6。 WinForm窗体程序中使用CefSharp获取加载后的资源、截取request参数、拦截response数据、注入jquery文件和js代码。有问题可联系q369628105
burp-copy-request-response:Burp扩展名，用于快速复制请求响应数据
05-28
打p扩展名：复制请求和响应描述编写良好的报告是渗透测试/安全评估的关键，因为这是交付给客户的最终结果。 应该以某种方式描述漏洞，以便客户可以理解并重现该问题。 对于Web应用程序最严格的测试，最好的方法通常...
Response笔记
juxiaaaaa的博客
05-22 860
Response设置响应数据功能介绍 Response完成重定向 重定向时，资源路径为加上项目的虚拟路径： /request-demo/resp2 简化方式完成重定向 response.sendRedirect("/request-demo/resp2"); 路径问题
【 HTTP 响应 (Response) 】
qq_64317046的博客
03-25 2599
HTTP响应各个部分中的属性基本与请求一致，重点掌握状态码
springmvc request与response获取
riant110的博客
05-04 1637
request与response是Tomcat服务器在收到客户端请求后自己生成的，无需我们自己创建，但是在使用的时候可以有以下三种方式去获取 1、Controller直接使用 方法上直接使用，通过DispatcherServlet将参数传到MethodHandler直接使用 @RequestMapping(path = {"/test10"}, method = RequestMethod.POST) @ResponseBody public BaseRes test10(HttpS
Response响应对象详解
weixin_62458944的博客
07-24 2967
HTTP响应数据总共分为三部分内容，分别是响应行、响应头、响应体，对于这三部分内容的数据，respone对象都提供了哪些方法来进行设置?1、响应行2、响应头3、响应体对于响应体，是通过字符、字节输出流的方式往浏览器写，获取字节输出流介绍完这些方法后，后面我们会通过案例把这些方法都用一用，首先先来完成下重定向的功能开发。
spring中获取request和response
m0_67403076的博客
04-27 2645
在spring项目中，我们通常有几种方法可以获取request对象， 1直接参数获取 @RequestMapping("/path") public String getReqAndRes(HttpServletRequest request, HttpServletResponse response){ /** 相关业务代码 此时可以直接使用request response对象 */ } 2.在代码里面获取可以通过RequestContextHolder的静态方法g
playwright拦截请求，获取响应数据
07-22
使用Playwright拦截请求并获取响应数据，可以按照以下步骤进行操作： 1. 导入所需的Playwright模块和相关类： ```python from playwright.sync_api import sync_playwright ``` 2. 初始化Playwright并创建一个浏览器实例： ```python with sync_playwright() as playwright: browser = playwright.chromium.launch() context = browser.new_context() page = context.new_page() ``` 3. 使用`page.route()`方法拦截请求，并在回调函数中获取响应数据： ```python def handle_request(route, request): # 获取请求的URL url = request.url # 获取请求的方法 method = request.method # 获取请求的头部信息 headers = request.headers # 获取请求的主体数据 body = request.post_data # 继续处理请求，获取响应数据 response = route.continue_() # 获取响应的状态码 status = response.status # 获取响应的头部信息 response_headers = response.headers # 获取响应的主体数据 response_body = response.body() # 在这里对请求和响应进行处理或保存数据等操作 # 拦截所有请求，并调用上面定义的回调函数处理请求和响应 page.route("**/*", handle_request) # 打开一个网页，触发请求拦截 page.goto("https://www.example.com") # 关闭浏览器实例 context.close() browser.close() ``` 在上面的代码中，`handle_request`函数是用来处理请求和响应的回调函数。在这个函数中，你可以获取请求的URL、方法、头部信息和主体数据，以及获取响应的状态码、头部信息和主体数据。你可以在这里对请求和响应进行处理或保存数据等操作。 请注意，上面的代码使用了Playwright的同步API，在异步环境中使用时，需要使用异步版本的相关方法和修饰器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值