JavaWeb基础教程-----（8）Request&Response

最新推荐文章于 2024-08-01 15:05:06 发布

NQGL.

最新推荐文章于 2024-08-01 15:05:06 发布

阅读量175

点赞数

分类专栏： JavaWeb 文章标签： servlet java

本文链接：https://blog.csdn.net/weixin_45595929/article/details/130812138

版权

JavaWeb 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Request&Response

1 Request(请求)&Response(响应)介绍
2 Request
3 Response
4 案例

1 Request(请求)&Response(响应)介绍

Request：获取请求数据
Response：设置响应数据

2 Request

2.1 Request继承体系

在这里插入图片描述

ServletRequest和HttpServletRequest的关系是什么?
request对象是有谁来创建的?
request提供了哪些API,这些API从哪里查?

Tomcat需要解析请求数据，封装为request对象,并且创建request对象传递到service方法
使用Request对象，查阅JavaEE API文档的HttpServletRequest接口

2.2 Request获取请求数据

2.2.1 获取请求数据

HTTP请求数据总共分为三部分内容，分别是请求行、请求头、请求体
Request对象都提供了对应的API方法来获取对应的值：
在这里插入图片描述

请求行
Sring getMethod()获取请求方式：GET
Sring getContextPath()获取项目访问路径：/request-demo
SringBuffer getRequestURL()获取请求URL：http://localhost:8080/request-demo/req1
Sring getRequestURI()获取请求URI：/request-demo/req1
Sring getQueryString()获取GET请求方式的请求参数：username=zhangsan&password=123
请求头
String getHeader(String name)根据请求头名称获取其对应的值
请求体
注意: POST请求有请求体，GET请求无请求体
如果是纯文本数据: BufferedReader getReader()：获取字符输入流
如果是字节数据如文件数据:ServletInputStream getInputStream()：获取字节输入流

2.2.2 通用方式获取请求参数

请求参数获取方式：
GET方式：String getQueryString()
POST方式：BufferedReader getReader();

思考:
GET请求方式和POST请求方式区别主要在于获取请求参数的方式不一样, 是否可以提供一种统一获取请求参数的方式，从而统一doGet 和doPost方法内的代码?

request对象把分割后的请求参数，存入到一个Map集合中：
在这里插入图片描述

获取所有参数Map集合：Map<String,String[]> getParameterMap() //标签的name：value。值是数组，因为有时传来的同name键对应多个value，例如checkbox。
根据名称获取参数值（数组）：String[] getParameterValues(String name)
根据名称获取参数值(单个值)，最常用：String getParameter(String name)

【示例】

html页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/request-demo/req2" method="get">
    <input type="text" name="username"><br>
    <input type="password" name="password"><br>
    <input type="checkbox" name="hobby" value="1"> 游泳
    <input type="checkbox" name="hobby" value="2"> 爬山 <br>
    <input type="submit">
 
</form>
</body>
</html>

获取所有参数的Map集合

package com.zs.web;

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;
import java.util.Map;

@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //GET请求逻辑
        System.out.println("get....");
        //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. 根据key获取参数值（数组）
        String[] hobbies = req.getParameterValues("hobby");
        for (String hobby:hobbies) {
            System.out.println(hobby);
        }

控制台输出效果：
在这里插入图片描述
4. 根据名称获取参数值(单个值)

 //3. 根据key获取参数值(单个值)
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println(username);
        System.out.println(password);

控制台效果：
在这里插入图片描述

我们会发现post与get一样，在Servlet代码中获取页面传递POST请求的参数值；将req.html页面form表单的提交方式改成post；将doGet方法中的内容直接复制到doPost方法中同样可以实现

因此我们可以这样写doGet和doPost代码：

public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       //采用request提供的获取请求参数的通用方式来获取请求参数
       //编写其他的业务代码...
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

2.3 IDEA模板创建Servlet

Servlet模板创建

稍作修改模板内容：

#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "")package ${PACKAGE_NAME};#end
#parse("File Header.java")

#if ($JAVAEE_TYPE == "jakarta")
import jakarta.servlet.*;
import jakarta.servlet.http.*;
import jakarta.servlet.annotation.*;
#else
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
#end
import java.io.IOException;

@WebServlet("/${Entity_Name}")
public class ${Class_Name} extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

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

注意：新建文件里面没有Servlet解决办法：
参考文章：idea文件右键创建New没有Create New Servlet的解决办法

2.4 请求参数中文乱码问题（Tomcat8以后已解决）

乱码原因和解决思路
在这里插入图片描述

getParameter方法

post乱码原因：获取参数底层是获取请求体方法getReader()，获取到的参数编码为ISO-8859-1。
解决思路：设置请求编码为utf-8，或者将请求参数的字符串解码为utf-8。

get乱码原因：提交表单后，get请求参数会进行ISO-8859-1的url编码追加到地址栏链接后面，Tomcat7获取到的参数编码为ISO-8859-1的url编码，Tomcat8之后版本获取到的参数编码为utf-8的URL编码。
解决思路：使用Tomcat8之后版本或者先ISO-8859-1的url解码成字符数组，再utf-8编码。

POST请求解决方案：设置输入流的编码

request.setCharacterEncoding("UTF-8");    //注意HTML页面head里设置编码也要是utf-8

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

new String(username.getBytes("ISO-8859-1"),"UTF-8");

【示例】POST请求乱码问题

/**
 * 中文乱码问题解决方案
 */
@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");    //Tomcat8可以注释这句
       //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);
    }
}

【示例】GET请求乱码问题

@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.解决乱码
        request.setCharacterEncoding("UTF-8");//设置字符输入流编码

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

        //3.GET，获取参数的方式：getQueryString
        //乱码原因：tomcat进行URL解码默认的字符集时ISO-8859-1
        /*//先对乱码数据进行编码：转为字节数组
        byte[] bytes = username.getBytes(StandardCharsets.ISO_8859_1);
        //字节数组解码
        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);
    }
}

【扩展】URL编码解码
编码过程分两步
(1)将字符串按照编码方式转为二进制
(2)每个字节转为2个16进制数并在前边加上%

例如，张三按照UTF-8的方式转换成二进制的结果为：
1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001

Java中提供了编码和解码的API工具类可以让我们更快速的进行编码和解码
Java中url编码和解码的API工具类：

编码：

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

解码：

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

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
public class URLDemo {

    public static void main(String[] args) throws UnsupportedEncodingException {
        String username = "张三";
        //1. URL编码
        String encode = URLEncoder.encode(username, "utf-8");
        System.out.println(encode); //打印:%E5%BC%A0%E4%B8%89

        //2. URL解码
        //String decode = URLDecoder.decode(encode, "utf-8");//打印:张三
        String decode = URLDecoder.decode(encode, "ISO-8859-1");//打印:`å¼ ä¸ `
        System.out.println(decode);

        //3. 转换为字节数据
        byte[] bytes = decode.getBytes("ISO-8859-1");
        /*for (byte b:bytes) {
            System.out.print(b+" ");//-27 -68 -96 -28 -72 -119
        }*/

        //4. 将字节数组转换为字符串。解码
        String s = new String(bytes, "UTF-8");
        System.out.println(s);  //张三
    }
}

2.5 Request请求转发

请求转发(forward)：一种在服务器内部的资源跳转方式。
请求转发的实现方式:

req.getRequestDispatcher("资源B路径").forward(req,resp);

【示例】实现请求转发

@WebServlet("/req5")
public class RequestDemo5 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo5...");

        //请求转发
        request.getRequestDispatcher("/req6").forward(request,response);
    }

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

@WebServlet("/req6")
public class RequestDemo6 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo6..");

    }

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

在浏览器访问后，控制台有输出：
在这里插入图片描述

请求转发资源间共享数据：使用Request对象

存储数据到request域[范围,数据是存储在request对象]中
void setAttribute(String name,Object o);
根据key获取值
Object getAttribute(String name);
根据key删除该键值对
void removeAttribute(String name);

【示例】
req5：

		//存储数据
        request.setAttribute("msg","hello");

req6：

        //获取数据
        Object msg = request.getAttribute("msg");
        System.out.println(msg);

控制台输出结果：
在这里插入图片描述
请求转发的特点：
浏览器地址栏路径不发生变化
只能转发到当前服务器的内部资源。不能从一个服务器通过转发访问另一台服务器
一次请求，可以在转发资源间使用request共享数据

3 Response

Request：使用request对象来获取请求数据
Response：使用response对象来设置响应数据
在这里插入图片描述

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

响应数据分为三部分

3.2 Response完成重定向

重定向(redirect)：一种资源跳转方式
简单来说：浏览器请求资源A，A处理不了说B能处理，浏览器再请求资源B。
实现方式一：

resp.setStatus(302);
resp.setHeader("location","资源B的访问路径");

实现方式二：简化方式

resposne.sendRedirect("/request-demo/resp2")

重定向特点：（与请求转发特点正好相反）
浏览器地址栏路径发送变化（当进行重定向访问的时候，由于是由浏览器发送的两次请求，所以地址会发生变化）
可以重定向到任何位置的资源(服务内容、外部均可)因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。
两次请求，不能在多个资源使用request共享数据，因为浏览器发送了两次请求，是两个不同的request对象，就无法通过request对象进行共享数据
重定向刷新不会重新提交表单，效率低，适用于不同业务间。

【示例】重定向

@WebServlet("/resp1")
public class ResponseDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("resp1...");

        //重定向
        /*//1. 设置响应状态码302
        response.setStatus(302);
        //2. 设置响应头 Location
        response.setHeader("Location","/request-demo2/resp2");*/

        //简化方式完成重定向
        response.sendRedirect("/request-demo2/resp2");
    }

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

@WebServlet("/resp2")
public class ResponseDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("resp2...");
    }

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

控制台输出结果：
在这里插入图片描述

资源路径问题：

明确路径给谁使用
浏览器使用：需要加虚拟目录(项目访问路径)
服务端使用：不需要加虚拟目录
练习

<a href=‘路径’> 从浏览器发送，需要加
<form action=‘路径’> 从浏览器发送，需要加
req.getRequestDispatcher(“路径”) 从服务器内部跳转，不需要加
resp.sendRedirect(“路径”) 是由浏览器进行跳转，需要加。

防止后期通过Tomcat插件配置了项目的访问路径，那么所有需要重定向的地方都需要重新修改，在代码中动态去获取项目访问的虚拟目录，使用request对象中的请求行获取虚拟目录方法getContextPath()

@WebServlet("/resp1")
public class ResponseDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("resp1...");

        //重定向
        /*//1. 设置响应状态码302
        response.setStatus(302);
        //2. 设置响应头 Location
        response.setHeader("Location","/request-demo2/resp2");*/

        //简化方式完成重定向
        String contextPath = request.getContextPath();
        response.sendRedirect(contextPath+"/resp2");
    }

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

3.3 Response响应字符数据

设置内容类型contentType和编码：response.setContentType(“text/html;charset=utf-8”);
通过Response对象获取字符输出流： PrintWriter writer = resp.getWriter();
通过字符输出流写数据： writer.write(“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);
    }
}

在这里插入图片描述
返回一串html字符串，并且能被浏览器解析：

        //设置响应的数据格式以及字符集编码，否则中文会乱码
        response.setContentType("text/html;charset=utf-8");
        //1. 获取字符输出流
        PrintWriter writer = response.getWriter();
        //response.setHeader("content-type","text/html");
        writer.write("aaa");
        writer.write("<h1>aaa</h1>");

在这里插入图片描述

注意：

这里的流不用关闭，随着响应结束，reponse对象销毁，有服务器关闭
中文乱码问题：
原因：通过Response获取的字符输出流默认编码：ISO-885901
解决：response.setContentType(“text/html;charset=utf-8”);

3.4 Response响应字节数据

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

【示例】响应字节数据

/**
 * 响应字节数据：设置字节数据的响应体
 */
@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 读取数据
        FileInputStream fis = new FileInputStream("d://aa.jpg");
        //2. 获取response字节输出流
        ServletOutputStream os = response.getOutputStream();
        //3. 完成流的copy
        byte[] buff = new byte[1024];
        int len = 0;
        while ((len = fis.read(buff)) != -1){
            os.write(buff,0,len);
        }
        fis.close();
    }

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

注意：可以简写流的copy代码，使用IOUtils.copy(fis,os)进行流的复制（推荐）
IOUtils工具类使用
（1）pom.xml中导入坐标添加依赖

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

（2）使用：IOUtils.copy(输入流,输出流);

【示例】响应字节数据简化后代码

@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 读取数据
        FileInputStream fis = new FileInputStream("d://aa.jpg");
        //2. 获取response字节输出流
        ServletOutputStream os = response.getOutputStream();
        //3. 完成流的copy
        IOUtils.copy(fis,os);

        fis.close();
    }

4 案例

参考文章：JavaWeb小项目（一） - 用户登录（Request/Response综合应用）

4.1 用户登录

用户填写用户名密码，提交到LoginServlet
在LoginServlet中使用MyBatis查询数据库，验证用户名密码是否正确
如果正确，响应“登录成功”，如果错误，响应“登录失败”

准备环境：

将静态页面放到到项目的webapp目录下
创建db1数据库，创建tb_ user表，创建User实体类

 DROP TABLE IF EXISTS tb_user;
-- 创建用户表，在db1数据库下创建
CREATE TABLE tb_user(
	id int primary key auto_increment,
	username varchar(20) unique,
	password varchar(32)
);
 
-- 添加数据
INSERT INTO tb_user(username,password) values('zhangsan','123'),('lisi','234');
 
SELECT * FROM tb_user;

User实体类

package com.zs.pojo;

public class User {
    private Integer id;
    private String username;
    private String password;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

导入MyBatis坐标， MySQL 驱动坐标

<!-- 导入mybatis坐标 -->
<dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis</artifactId>
     <version>3.5.5</version>
</dependency>

<!--  
	注意事项：Mysql驱动需要尽可能用最新版本，否则版本过低会无法连接数据库
	导致报错
-->
<!-- 导入Mysql驱动 -->
<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.46</version>
</dependency>

创建mybatis-config.xml核心配置文件，UserMapper.xml映射文件, UserMapper接口

创建mybatis-config.xml核心配置文件

<?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.zs.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--<property name="url" value="jdbc:mysql:///db1?useSSL=false&amp;useServerPrepStmts=true"/>-->
                <property name="url" value="jdbc:mysql://localhost:3306/db1?serverTimezone=Asia/Shanghai&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;zeroDateTimeBehavior=convertToNull&amp;useSSL=false&amp;allowPublicKeyRetrieval=true"/>
                <property name="username" value="root"/>
                <property name="password" value="XXXX"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--扫描mapper-->
        <package name="com.zs.mapper"/>
    </mappers>
</configuration>

UserMapper.xml映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zs.mapper.UserMapper">

</mapper>

UserMapper接口：

package com.zs.mapper;

public interface UserMapper {
}

业务逻辑实现：
UserMapper 接口添加select功能：

public interface 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);
}

创建 LoginServlet，并实现对应的登录处理逻辑：

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        //1. 接受用户名密码
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        //2. 调用MyBatis完成查询
        //获取SqlSessionFactory对象
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取Mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //调用方法
        User user = userMapper.select(username, password);
        //释放资源
        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);
    }
}

4.2 用户注册

用户填写用户名、密码等信息，点击注册按钮，提交到RegisterServlet
在RegisterServlet中使用MyBatis保存数据
保存前，需要判断用户名是否已经存在：根据用户名查询数据库

业务逻辑实现：
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);

创建 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根据用户名查询用户对象
        //获取SqlSessionFactory对象
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取Mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //调用方法
        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);
    }
}

4.3 SqlSessionFactory工具类抽取

在这里插入图片描述

问题和解决办法：

重复代码不利于后期的维护；【工具类】
SqlSessionFactory工厂类进行重复创建（每一个SqlSessionFactory工厂都绑定了一个连接池，创建多个工厂就意味着有多个连接池，资源消耗会非常大）。【静态代码块（随着类的加载自动执行且只执行一次）】

【示例】简化代码
工具类：

package com.zs.util;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

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

简化后：

@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根据用户名查询用户对象
        //获取SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtils.getSqlSessionFactory();
        //获取SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取Mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //调用方法
        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);
    }
}

注意：
SqlSession sqlSession = sqlSessionFactory.openSession();
虽然上面语句也重复，但不能抽取到工具类里。因为SqlSession是一个连接、会话，每次连接数据库时候创建一次会话是合适，如果所有连接都共用一个会话会互相影响。
SqlSession是一个会话，相当于JDBC中的一个Connection对象，Mybatis中所有的数据库交互都由SqlSession来完成。

本篇参考文章