MyBatis快速入门（上）

一、MyBatis 简介
- 1、概述
- 2、JDBC、Hibernate、MyBatis 对比
二、MyBatis 框架搭建
- 1、开发环境
- 2、创建maven工程
- 3、创建MyBatis的核心配置文件
- 4、创建mapper接口
- 5、创建MyBatis的映射文件
- 6、通过junit测试功能
- 7、加入log4j2日志功能
三、MyBatis 基础功能
- 1、核心配置文件
- - （1）environments 标签
  - （2）properties 配置文件
  - （3）typeAliases 标签
  - （4）mappers 标签
- 2、idea中配置核心配置文件和映射文件模板
- - （1）核心配置文件
  - （2）映射文件
- 3、实现增删改查
- - 简述
  - （1）文件目录
  - （2）pom.xml
  - （3）配置文件 mybatis-config.xml
  - （4）配置文件 jdbc.properties
  - （5）日志文件 log4j2.xml
  - （6）实体类 User
  - （7）mapper 接口
  - （8）mapper 映射文件
  - （9）SqlSessionUtils 工具类
  - （10）测试类
- 4、获取 mapper 接口方法参数值的两种方式
- - （1）${} 和 #{}
  - （2）mapper 接口方法参数类型分类
  - - （2.1）单个字面量类型参数
    - （2.2）多个字面量类型参数
    - （2.3） map 集合类型参数
    - （2.4）实体类型参数
    - （2.5）使用 @Param 注解命名参数
  - （3）总结
  - （4）代码示例
- 5、各种查询功能
- - （5.1）查询结果分类及接收方式
  - - （1）概述
    - （2）代码示例
  - （5.2）模糊查询
  - - （1）概述
    - （2）代码示例
  - （5.3）批量删除
  - - （1）简述
    - （2）方式一： `${}`
    - （2）方式二： `#{}`
  - （5.4）动态设置表名
  - - （1）概述
    - （2） `${}`
  - （5.5）添加功能获取自增的主键
  - - （1）概述
    - （2）代码示例
    - （3）使用场景
- 🎈 第（3~5）章节全量代码
- - （1）文件目录
  - （2）pom.xml
  - （3）配置文件 mybatis-config.xml
  - （4）配置文件 jdbc.properties
  - （5）日志文件 log4j2.xml
  - （6）实体类 User
  - （7）mapper 接口
  - - 😀 `（3~4）章节代码`
    - 😀 `（5.1）章节代码`
    - 😀 `（5.2 ~ 5.5）章节代码`
  - （8）mapper 映射文件
  - - 😀 `（3~4）章节代码`
    - 😀 `（5.1）章节代码`
    - 😀 `（5.2 ~ 5.5）章节代码`
  - （9）SqlSessionUtils 工具类
  - （10）测试类
  - - 😀 `（3~4）章节代码`
    - 😀 `（5.1）章节代码`
    - 😀 `（5.2 ~ 5.5）章节代码`

一、MyBatis 简介

官方文档

Mybatis常见面试题总结

1、概述

MyBatis 是一流的持久性框架，支持自定义 SQL、存储过程和高级映射。MyBatis 几乎消除了所有 JDBC 代码和参数的手动设置以及结果的检索。MyBatis 可以使用简单的 XML 或注释来配置和映射基元、映射接口和 Java POJOs（Plain Ordinary Java Object 简单的Java对象，即普通JavaBeans）到数据库记录。

在这里插入图片描述

public class User {
    private String name;
    private int age;
    
    // getter and setter methods
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

在这个例子中，User类是一个典型的POJO，没有任何框架的依赖，
只包含属性name和age，以及它们的getter和setter方法。
POJO类常用于Java中的数据传输或对象映射。

2、JDBC、Hibernate、MyBatis 对比

在这里插入图片描述

在这里插入图片描述
HQL是Hibernate Query Language的缩写，意思是Hibernate查询语言。它是Hibernate框架中的一种面向对象的查询语言，用于对数据库进行查询操作。

在这里插入图片描述

二、MyBatis 框架搭建

1、开发环境

IDE： idea 2024.1.3
构建工具： Maven 3.8.8
MySQL 版本： MySQL 8.0
MyBatis 版本： MyBatis 3.5.11
JDK 版本： Java 17

2、创建maven工程

（1）打包方式：jar

maven工程默认打包方式就是 jar

也可以直接显示的声明：<packaging>jar</packaging>

（2）引入依赖

        <!--mybatis核心文件-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <!--junit测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <!--MySQL驱动链接-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>
        <!--Lombok插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>

3、创建MyBatis的核心配置文件

在这里插入图片描述

<?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>
    <!--配置链接数据库的环境-->
    <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://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

4、创建mapper接口

在这里插入图片描述

package com.ningxia.mybatis.pojo;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private Character sex;
    private String email;
}

package com.ningxia.mybatis.mapper;

import com.ningxia.mybatis.pojo.User;

public interface UserMapper {
    /**
     * MyBatis 面向接口编程的两个一致
     * 1、映射文件的 namespace 要和 mapper接口中的全类名保持一致
     * 2、映射文件的 SQL 语句的id 要和 mapper接口中的方法名保持一致
     **/


    /**
     * 添加用户信息
     **/
    int insertUser();
}

5、创建MyBatis的映射文件

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ningxia.mybatis.mapper.UserMapper">
    <insert id="insertUser">
        insert into  t_user values(1,"tom","123456",23,"男","tom@163.com")
    </insert>
</mapper>

6、通过junit测试功能

在这里插入图片描述

package com.ningxia.mybatis.test;

import com.ningxia.mybatis.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.Test;

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


public class MyBatisTest {
    @Test
    public void testMybatis() throws IOException {
        // 加载核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        // 获取 SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 获取 SqlSessionFactory
        SqlSessionFactory factory = builder.build(is);
        // 获取 SqlSession
        SqlSession session = factory.openSession();
        // 获取 mapper 接口对象
        UserMapper mapper = session.getMapper(UserMapper.class);
        //调用接口方法
        int result = mapper.insertUser();
        //提交事务
        session.commit();
        System.out.println("执行结果：" + result);
    }
}

7、加入log4j2日志功能

（1）加入依赖

        <!--Log4j2日志 以下是Log4j2 完整的日志记录实现所必需的-->
        <!--log4j-core 是实际处理日志输出的核心实现-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.17.1</version>
        </dependency>
        <!--log4j-api 只是定义了日志记录的接口-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.17.1</version>
        </dependency>

（2）加入log4j2的配置文件

注意：日志配置文件命名一定和依赖版本一致，否则无法打印信息

因为pom.xml配置文件中加入的日志的依赖是log4j2，所以日志配置文件也要命名为 log4j2.xml
日志配置文件也要放在src/main/resources/下

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <!-- 定义日志输出的目标 -->
    <Appenders>
        <!-- 控制台输出 -->
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>

        <!-- 日志文件输出 -->
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="logs/app-%d{yyyy-MM-dd}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>
            <Policies>
                <!-- 基于文件大小的滚动策略 -->
                <SizeBasedTriggeringPolicy size="10MB"/>
                <!-- 每天创建新的日志文件 -->
                <TimeBasedTriggeringPolicy interval="1"/>
            </Policies>
        </RollingFile>
    </Appenders>

    <!-- 日志器配置 -->
    <Loggers>
        <!-- Root 日志级别设为 debug，确保输出所有日志信息 -->
        <Root level="debug">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="RollingFile"/>
        </Root>

        <!-- MyBatis 日志配置 -->
        <Logger name="org.apache.ibatis" level="debug" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>
    </Loggers>
</Configuration>

在这里插入图片描述

三、MyBatis 基础功能

1、核心配置文件

（1）environments 标签

配置多个链接数据库的环境

mybatis-config.xml

    <!--environments：配置多个链接数据库的环境
            default：设置默认使用环境的id

        id：设置链接数据库环境的唯一标识，不能重复
        transactionManager：设置事务管理方式
            属性：type= "JDBC|MANAGED"
                   JDBC:表示当前环境中，执行SQL时，使用jdbc中原生的事务管理方式，事务的提交或回滚需要手动处理
                   MANAGED:被管理，例如 Spring
        dataSource：配置数据源
            属性：type= "POOLED|UNPOOLED|JNDI"
                   POOLED:表示使用数据库连接池缓存数据库链接
                   UNPOOLED:表示不使用数据库连接池
                   JNDI:表示使用上下文中的数据源

        property下面的属性设置一些链接数据库的信息：比如：驱动、地址、用户名、密码
    -->

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

（2）properties 配置文件

.properties 配置文件：存放数据库的一些链接信息

把数据库的一些链接信息放在一个.properties 配置文件中，在mybatis-config.xml配置文件中引入jdbc.properties，通过读取配置文件信息，来获取数据库链接信息，文件内容为了见名知意，最好添加一个文件名的前缀，表示什么样功能的数据库链接；
比如下述jdbc.properties中的驱动、地址、用户名、密码前都添加jdbc.

jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=666666

（3）typeAliases 标签

typeAliases 标签的作用就是 给查询结果类型起别名
两种起别名方式（单个起别名和批量起别名）参考下述图片内容

在这里插入图片描述

（4）mappers 标签

引入映射文件
引入单个映射文件和多个映射文件，参考下述图片内容

在这里插入图片描述

2、idea中配置核心配置文件和映射文件模板

在这里插入图片描述

（1）核心配置文件

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--数据库配置信息文件引入-->
    <properties resource="jdbc.properties"/>
    <!--类型别名配置-->
    <typeAliases>
        <!--此处采用以包为批量起别名-->
        <package name="类型别名所在的包路径"/>
    </typeAliases>
    <!--数据库链接配置-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入mybatis映射文件-->
    <mappers>
        <!--实际中会有多个映射文件，因此此处采用以包为单位批量引入方式-->
        <package name="映射文件包完整路径"/>
    </mappers>
</configuration>

（2）映射文件

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mapper接口文件完整路径">
</mapper>

3、实现增删改查

简述

MyBatis 面向接口编程的两个一致

映射文件的 namespace 要和 mapper接口中的 全类名 保持一致
映射文件的 SQL 语句的id 要和 mapper接口中的 方法名 保持一致

（1）文件目录

在这里插入图片描述

（2）pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ningxia.mybatis</groupId>
    <artifactId>mybatis_demo2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--mybatis核心文件-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <!--junit测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <!--MySQL驱动链接-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>
        <!--Lombok插件：提供实体类的set、get及toString等方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <!--Log4j2日志 以下是Log4j2 完整的日志记录实现所必需的-->
        <!--log4j-core 是实际处理日志输出的核心实现-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.17.1</version>
        </dependency>
        <!--log4j-api 只是定义了日志记录的接口-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.17.1</version>
        </dependency>
    </dependencies>
</project>

（3）配置文件 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--数据库配置信息文件引入-->
    <properties resource="jdbc.properties"/>
    <!--类型别名配置-->
    <typeAliases>
        <!--此处采用以包为单位，批量起别名-->
        <package name="com.ningxia.mybatis.pojo"/>
    </typeAliases>
    <!--数据库链接配置-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入mybatis映射文件-->
    <mappers>
        <!--<mapper resource="org/mybatis/example/BlogMapper.xml"/>-->
        <!--实际中会有多个映射文件，因此此处采用以包为单位批量引入方式-->
        <package name="com.ningxia.mybatis.mapper"/>
    </mappers>
</configuration>

（4）配置文件 jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=666666

（5）日志文件 log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <!-- 定义日志输出的目标 -->
    <Appenders>
        <!-- 控制台输出 -->
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>

        <!-- 日志文件输出 -->
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="logs/app-%d{yyyy-MM-dd}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>
            <Policies>
                <!-- 基于文件大小的滚动策略 -->
                <SizeBasedTriggeringPolicy size="10MB"/>
                <!-- 每天创建新的日志文件 -->
                <TimeBasedTriggeringPolicy interval="1"/>
            </Policies>
        </RollingFile>
    </Appenders>

    <!-- 日志器配置 -->
    <Loggers>
        <!-- Root 日志级别设为 debug，确保输出所有日志信息 -->
        <Root level="debug">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="RollingFile"/>
        </Root>

        <!-- MyBatis 日志配置 -->
        <Logger name="org.apache.ibatis" level="debug" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>
    </Loggers>
</Configuration>

（6）实体类 User

package com.ningxia.mybatis.pojo;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private Character sex;
    private String email;
}

（7）mapper 接口

package com.ningxia.mybatis.mapper;

import com.ningxia.mybatis.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

public interface ParameterMapper {

    /**
     * 验证登录(多个参数使用注解)
     */
    User checkLoginByAnno(@Param("username") String username, @Param("password") String password);


    /**
     * 添加用户信息（mapper接口参数为一个实体类对象）
     */
    int addUserInfo(User user);


    /**
     * 验证登录(多个参数封装为map集合)
     */
    User checkLoginByMap(Map<String, Object> map);


    /**
     * 验证登录
     */
    User checkLogin(String username, String password);


    /**
     * 根据用户名获取用户信息
     */
    User getUserInfoByName(String name);

    /**
     * 获取所有用户信息
     */
    List<User> getUserList();


    /**
     * MyBatis 面向接口编程的两个一致
     * 1、映射文件的 namespace 要和 mapper接口中的全类名保持一致
     * 2、映射文件的 SQL 语句的id 要和 mapper接口中的方法名保持一致
     **/


    /**
     * 添加用户信息
     **/
    int insertUser();

    /**
     * 修改用户信息
     **/
    void updateUser();

    /**
     * 删除用户信息
     **/
    void deleteUser();

}

（8）mapper 映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ningxia.mybatis.mapper.ParameterMapper">
    <!--获取所有用户信息-->
    <select id="getUserList" resultType="User">
        select * from t_user
    </select>

    <!--根据用户名获取用户信息-->
    <select id="getUserInfoByName" resultType="User">
        <!-- select * from t_user where  username  = '${username}'-->
        select * from t_user where username = #{username}
    </select>

    <!--验证登录-->
    <select id="checkLogin" resultType="User">
        <!--
        select * from t_user where username = '${param1}' and password = '${param2}'
        select * from t_user where username = #{arg0} and password = #{arg1}
        select * from t_user where username = #{param1} and password = #{param2}
        select * from t_user where username = #{arg0} and password = #{param2}
        -->
        select * from t_user where username = #{param1} and password = #{param2}
    </select>
    <!--验证登录(多个参数封装为map集合)-->
    <select id="checkLoginByMap" resultType="User">
        <!--
        select * from t_user where username = '${username}' and password = '${password}'
        -->
        select * from t_user where username = #{username} and password = #{password}
    </select>

    <!--添加用户信息（mapper接口参数为一个实体类对象）-->
    <insert id="addUserInfo">
        <!-- insert into t_user values(null, '${username}', '${password}', '${age}', '${sex}', '${email}') -->
        insert into t_user values(null, #{username}, #{password}, #{age}, #{sex}, #{email})
    </insert>

    <!--验证登录(多个参数使用注解)-->
    <select id="checkLoginByAnno" resultType="User">
        <!--
        select * from t_user where username = '${username}' and password = '${password}'
        select * from t_user where username = #{param1} and password = #{param2}
        -->
        select * from t_user where username = #{username} and password = #{password}
    </select>



    <!--添加用户信息-->
    <insert id="insertUser">
        insert into t_user values(null,"wong","666",21,"男","wong@163.com")
    </insert>
    <!--修改用户信息-->
    <update id="updateUser">
        update t_user set username = 'zan' where id = 7
    </update>
    <!--删除用户信息-->
    <delete id="deleteUser">
        delete from t_user where username = "nima"
    </delete>

</mapper>

（9）SqlSessionUtils 工具类

package com.ningxia.mybatis.utils;


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

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

public class SqlSessionUtils {
    public static SqlSession getSqlSession() {
        SqlSession sqlSession = null;
        try {
            //获取配置文件
            InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
            //获取 sqlSessionFactory
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
            //获取 sqlSession
            sqlSession = sqlSessionFactory.openSession(true);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return sqlSession;
    }
}

（10）测试类

package com.ningxia.mybatis.test;

import com.ningxia.mybatis.mapper.ParameterMapper;
import com.ningxia.mybatis.pojo.User;
import com.ningxia.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ParameterMapperTest {
    /*
     * myBatis 获取参数值的两种方式：   ${} 和  #{}
     *   ${}：本质字符串拼接
     *   #{}：本质占位符赋值
     *
     *
     * myBatis 获取参数值的情况：
     * 1、mapper接口方法的参数为单个字面量类型
     *   可以通过 ${}和 #{} 以任意名称获取参数值，但是要注意${}的单引号问题
     * 2、mapper接口方法的参数为多个时
     *   此时 mybatis 会将这些参数放在一个map中，以两种方式进行存储
     *   ① 以 arg0,arg1,......为键，以参数为值
     *   ② 以 param1,param2,......为键，以参数为值
     *   可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     * 3、mapper接口方法的参数为多个时,可以将这些参数封装在一个map集合中
     *  可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     * 4、mapper接口方法的参数是实体类型的参数
     *  可以通过 ${}和 #{} 以属性值的方式访问参数值，但是要注意${}的单引号问题
     * 5、使用注解 @Param 命名参数
     *   此时 mybatis 会将这些参数放在一个map中，以两种方式进行存储
     *   ① 以  @Param 注解的值为键，以参数为值
     *   ② 以 param1,param2,......为键，以参数为值
     *   可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     *
     * */

    /**
     * 测试：验证登录(直接携带多个参数)
     */
    @Test
    public void testCheckLoginByAnno() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.checkLoginByAnno("dave", "888");
        System.out.println(user);
    }


    /**
     * 测试：验证登录(多个参数封装为map集合)
     */
    @Test
    public void testAddUserInfo() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final int result = mapper.addUserInfo(new User(null, "dog", "22", 18, '女', "dog@qq.com"));
        System.out.println(result);
    }

    /**
     * 测试：验证登录(多个参数封装为map集合)
     */
    @Test
    public void testCheckLoginByMap() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("username", "jef");
        map.put("password", "666");
        final User user = mapper.checkLoginByMap(map);
        System.out.println(user);
    }


    /**
     * 测试：验证登录(直接携带多个参数)
     */
    @Test
    public void testCheckLogin() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.checkLogin("jef", "666");
        System.out.println(user);
    }

    /**
     * 测试：根据用户名获取用户信息
     */
    @Test
    public void testGetUserInfoByName() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.getUserInfoByName("jack");
        System.out.println(user);
    }


    /**
     * 测试：获取全部用户信息
     */
    @Test
    public void testGetAllUserInfo() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final List<User> userList = mapper.getUserList();
        userList.forEach(System.out::println);
    }



    @Test
    public void testMybatisAdd() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        int result = mapper.insertUser();
        System.out.println("执行结果：" + result);

    }

    @Test
    public void testMybatisUpdate() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        //调用接口方法:根据id修改用户信息
        mapper.updateUser();
    }

    @Test
    public void testMybatisDelete() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        mapper.deleteUser();
    }
}

4、获取 mapper 接口方法参数值的两种方式

（1）${} 和 #{}

${}：本质 字符串拼接

多用于动态表名、列名或排序字段的拼接，直接拼接内容到 SQL 语句，适合动态构建 SQL 结构，但是有 SQL 注入的风险

示例：
SELECT * FROM ${tableName} WHERE ${columnName} = #{value}

如果 tableName 是 users，columnName 是 name，value 是 'Alice'，那么最终生成的 SQL 为：

SELECT * FROM users WHERE name = 'Alice'

在这里，tableName 和 columnName 是原样插入的。

#{}：本质 占位符赋值

常用于动态 SQL 查询条件的拼接，适合插入具体参数值的情况，能防止 SQL 注入的风险

示例：
SELECT * FROM users WHERE name = #{name}


如果 name 的值是 'Alice'，最终生成的 SQL 为：

SELECT * FROM users WHERE name = ?

然后由 JDBC 将 name 的值（即 'Alice'）设置到 ? 位置。

（2）mapper 接口方法参数类型分类

（2.1）单个字面量类型参数

可以通过 ${}和 #{} 以 任意名称 获取参数值，但是要注意${}的单引号问题

（2.2）多个字面量类型参数

mybatis 会将这些参数放在一个map中，以两种方式进行存储

以 arg0,arg1,…为键，以参数为值
以 param1,param2,…为键，以参数为值

可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题

（2.3） map 集合类型参数

mapper接口方法的参数为多个时,可以将这些参数封装在一个map集合中，可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题

（2.4）实体类型参数

可以通过 ${}和 #{} 以属性值的方式访问参数值，但是要注意${}的单引号问题

（2.5）使用 @Param 注解命名参数

mybatis 会将这些参数放在一个map中，以两种方式进行存储

以 @Param 注解的值为键，以参数为值
以 param1,param2,…为键，以参数为值

可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题

（3）总结

以上5中类型参数的情况，可以分为两大类

实体类型的参数
实体类型以外的参数（直接使用注解 @Param）

（4）代码示例

mapper接口方法

package com.ningxia.mybatis.mapper;

import com.ningxia.mybatis.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

public interface ParameterMapper {

    /**
     * 验证登录(多个参数使用注解)
     */
    User checkLoginByAnno(@Param("username") String username, @Param("password") String password);


    /**
     * 添加用户信息（mapper接口参数为一个实体类对象）
     */
    int addUserInfo(User user);


    /**
     * 验证登录(多个参数封装为map集合)
     */
    User checkLoginByMap(Map<String, Object> map);


    /**
     * 验证登录
     */
    User checkLogin(String username, String password);


    /**
     * 根据用户名获取用户信息
     */
    User getUserInfoByName(String name);

    /**
     * 获取所有用户信息
     */
    List<User> getUserList();


}

ParameterMapper.xml映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ningxia.mybatis.mapper.ParameterMapper">
    <!--获取所有用户信息-->
    <select id="getUserList" resultType="User">
        select * from t_user
    </select>

    <!--根据用户名获取用户信息-->
    <select id="getUserInfoByName" resultType="User">
        <!-- select * from t_user where  username  = '${username}'-->
        select * from t_user where username = #{username}
    </select>

    <!--验证登录-->
    <select id="checkLogin" resultType="User">
        <!--
        select * from t_user where username = '${param1}' and password = '${param2}'
        select * from t_user where username = #{arg0} and password = #{arg1}
        select * from t_user where username = #{param1} and password = #{param2}
        select * from t_user where username = #{arg0} and password = #{param2}
        -->
        select * from t_user where username = #{param1} and password = #{param2}
    </select>
    <!--验证登录(多个参数封装为map集合)-->
    <select id="checkLoginByMap" resultType="User">
        <!--
        select * from t_user where username = '${username}' and password = '${password}'
        -->
        select * from t_user where username = #{username} and password = #{password}
    </select>

    <!--添加用户信息（mapper接口参数为一个实体类对象）-->
    <insert id="addUserInfo">
        <!-- insert into t_user values(null, '${username}', '${password}', '${age}', '${sex}', '${email}') -->
        insert into t_user values(null, #{username}, #{password}, #{age}, #{sex}, #{email})
    </insert>

    <!--验证登录(多个参数使用注解)-->
    <select id="checkLoginByAnno" resultType="User">
        <!--
        select * from t_user where username = '${username}' and password = '${password}'
        select * from t_user where username = #{param1} and password = #{param2}
        -->
        select * from t_user where username = #{username} and password = #{password}
    </select>
</mapper>

测试方法

package com.ningxia.mybatis.test;

import com.ningxia.mybatis.mapper.ParameterMapper;
import com.ningxia.mybatis.pojo.User;
import com.ningxia.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ParameterMapperTest {
    /*
     * myBatis 获取参数值的两种方式：   ${} 和  #{}
     *   ${}：本质字符串拼接
     *   #{}：本质占位符赋值
     *
     *
     * myBatis 获取参数值的情况：
     * 1、mapper接口方法的参数为单个字面量类型
     *   可以通过 ${}和 #{} 以任意名称获取参数值，但是要注意${}的单引号问题
     * 2、mapper接口方法的参数为多个时
     *   此时 mybatis 会将这些参数放在一个map中，以两种方式进行存储
     *   ① 以 arg0,arg1,......为键，以参数为值
     *   ② 以 param1,param2,......为键，以参数为值
     *   可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     * 3、mapper接口方法的参数为多个时,可以将这些参数封装在一个map集合中
     *  可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     * 4、mapper接口方法的参数是实体类型的参数
     *  可以通过 ${}和 #{} 以属性值的方式访问参数值，但是要注意${}的单引号问题
     * 5、使用注解 @Param 命名参数
     *   此时 mybatis 会将这些参数放在一个map中，以两种方式进行存储
     *   ① 以  @Param 注解的值为键，以参数为值
     *   ② 以 param1,param2,......为键，以参数为值
     *   可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     *
     * */

    /**
     * 测试：验证登录(直接携带多个参数)
     */
    @Test
    public void testCheckLoginByAnno() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.checkLoginByAnno("dave", "888");
        System.out.println(user);
    }


    /**
     * 测试：验证登录(多个参数封装为map集合)
     */
    @Test
    public void testAddUserInfo() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final int result = mapper.addUserInfo(new User(null, "dog", "22", 18, '女', "dog@qq.com"));
        System.out.println(result);
    }

    /**
     * 测试：验证登录(多个参数封装为map集合)
     */
    @Test
    public void testCheckLoginByMap() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("username", "jef");
        map.put("password", "666");
        final User user = mapper.checkLoginByMap(map);
        System.out.println(user);
    }


    /**
     * 测试：验证登录(直接携带多个参数)
     */
    @Test
    public void testCheckLogin() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.checkLogin("jef", "666");
        System.out.println(user);
    }

    /**
     * 测试：根据用户名获取用户信息
     */
    @Test
    public void testGetUserInfoByName() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.getUserInfoByName("jack");
        System.out.println(user);
    }


    /**
     * 测试：获取全部用户信息
     */
    @Test
    public void testGetAllUserInfo() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final List<User> userList = mapper.getUserList();
        userList.forEach(System.out::println);
    }
}

5、各种查询功能

（5.1）查询结果分类及接收方式

（1）概述

假如有一张用户表：我们可能会根据不同的需求要获取不同的信息，也许是表中某个用户的信息、也许是表中所有用户的信息、或者统计该表中的总用户数…此时使用mybatis的查询功能可以将这些不同的场景分为3类，根据这3类情况分别选择不同的方式进行接收这些查询结果数据

查询的结果只有一条(例如：获取某个用户的信息)：

可以通过实体类对象接收查询结果
可以通过 list 集合接收查询结果
可以通过 map 集合接收查询结果

查询的结果有多条(例如：获取多个用户的信息)：

可以通过实体类类型的 list 集合接收查询结果
可以通过map 类型的 list 集合接收查询结果
可以在 map 接口方法上添加@MapKey注解接收查询结果；
- 此时可以就将每条数据转换为 map 集合作为值，以注解中的选择的字段值作为健，放在同一个map集合中

查询的结果为单行单列(例如：获取用户表中总记录数)：

Java 类型有许多内置类型别名，它们都是不区分大小写，具体可以参考官网

（2）代码示例

SelectMapper 接口方法

package com.ningxia.mybatis.mapper;

import com.ningxia.mybatis.pojo.User;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

public interface SelectMapper {

    /**
     * 根据名称查询某个用户信息
     */
    User getUserInfoByNm(@Param("username") String username);

    /**
     * 查询结果为一条数据的 list集合
     */
    List<User> getUserInfoByNmToList(@Param("nm") String nm);

    /**
     * 查询结果为一条数据的map集合
     */
    Map<String, Object> getUserInfoByNmToMap(@Param("nm") String nm);


    /**
     * 查询所有用户信息
     */
    List<User> getAllUserInfo();


    /**
     * 查询结果为多条数据的map集合
     * <p>
     * 方式一
     * List<Map<String, Object>> getAllUserInfoToMap();
     * 输出形式如下：
     * [{password=33, sex=女, id=2, age=13, email=rose@qq.com, username=rose} , {password=123, sex=男, id=3, age=14, email=jack@qq.com, username=jack}]
     * <p>
     * <p>
     * 方式二
     *
     * @MapKey("id") Map<String, Object> getAllUserInfoToMap();
     * 将每条数据转换为 map集合 作为值，以选择的id字段值作为健，以 map集合形式返回
     * 输出形式如下：
     * {2={password=33, sex=女, id=2, age=13, email=rose@qq.com, username=rose},
     * 3={password=123, sex=男, id=3, age=14, email=jack@qq.com, username=jack}}
     */
//    List<Map<String, Object>> getAllUserInfoToMap();
    @MapKey("id")
    Map<String, Object> getAllUserInfoToMap();

    /**
     * 统计表中用户数
     */
    Integer getCountUser();
}

SelectMapper.xml 映射文件

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

    <!--  根据名称查询用户信息  -->
    <select id="getUserInfoByNm" resultType="User">
        select * from t_user where username = #{username}
    </select>

    <!--  查询结果为一条数据的 list集合  -->
    <select id="getUserInfoByNmToList" resultType="User">
        select * from t_user where username = #{nm}
    </select>


    <!--  查询结果为一条用户数据的map集合 -->
    <select id="getUserInfoByNmToMap" resultType="map">
        select * from t_user where username = #{nm}
    </select>


    <!--  查询所有用户信息   List<User> getAllUserInfo(); -->
    <select id="getAllUserInfo" resultType="User">
        select * from t_user
    </select>


    <!--  查询结果为多条数据的map集合  -->
    <select id="getAllUserInfoToMap" resultType="map">
        select * from t_user
    </select>

    <!--  统计表中用户数  -->
    <select id="getCountUser" resultType="int">
        select count(*) from t_user
    </select>



</mapper>

SelectMapperTest测试类

package com.ningxia.mybatis.test;


import com.ningxia.mybatis.mapper.SelectMapper;
import com.ningxia.mybatis.pojo.User;
import com.ningxia.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;
import java.util.Map;

public class SelectMapperTest {

    /**
     * 根据名称查询用户信息
     */
    @Test
    public void testGetUserInfoByNm() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        User user = mapper.getUserInfoByNm("rose");
        System.out.println(user);
    }


    /**
     * 查询结果为一条数据的 list集合
     */
    @Test
    public void testGetUserInfoByNmToList() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<User> userList = mapper.getUserInfoByNmToList("jack");
        userList.forEach(System.out::println);
    }


    /**
     * 查询结果为一条数据的map集合
     */
    @Test
    public void testGetUserInfoByNmToMap() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        Map<String, Object> map = mapper.getUserInfoByNmToMap("jack");
        System.out.println(map);
    }


    /**
     * 查询所有用户信息
     */
    @Test
    public void testGetAllUserInfo() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<User> userList = mapper.getAllUserInfo();
        userList.forEach(System.out::println);
    }


    /**
     * 查询结果为多条数据的map集合
     */
    @Test
    public void testGetAllUserInfoToMap() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        System.out.println(mapper.getAllUserInfoToMap());
    }

    /**
     * 统计表中用户数
     */
    @Test
    public void testGetCountUser() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        System.out.println("t_user表中一共有 "+mapper.getCountUser()+" 条数！");
    }
}

（5.2）模糊查询

（1）概述

示例：获取 t_user 表中名称中带 j 的所有用户信息；like 关键字后可以使用下述3种方式拼接参数（推荐使用第3种）

'%${参数名}%'
concat('%',#{参数名},'%')
"%"#{参数名}"%"

（2）代码示例

mapper接口方法

package com.ningxia.mybatis.mapper;

import com.ningxia.mybatis.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface SqlMapper {

    /**
     * 查询 t_user 表中名字中带 'j'的用户信息
     */
    List<User> selectAllUserByNm(@Param("nm") String nm);


}

mapper映射文件语句

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

    <!-- 查询 t_user 表中名字中带 'j'的用户信息-->
    <select id="selectAllUserByNm" resultType="User">
        <!--
        方式一：select * from t_user where username like '%${nm}%'
        方式二：select * from t_user where username like concat('%',#{nm},'%')
        方式三(推荐)：select * from t_user where username like "%"#{nm}"%"
        -->
        select * from t_user where username like "%"#{nm}"%"

    </select>
</mapper>

测试类方法

package com.ningxia.mybatis.test;

import com.ningxia.mybatis.mapper.SqlMapper;
import com.ningxia.mybatis.pojo.User;
import com.ningxia.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class SqlMapperTest {


    /**
     * 查询 t_user 表中名字中带 'j'的用户信息
     */
    @Test
    public void testGetUserByNm() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
        List<User> userList = mapper.selectAllUserByNm("j");
        userList.forEach(System.out::println);
    }

}

（5.3）批量删除

（1）简述

示例：批量删除: 删除 t_user 表中某些 id 用户

（2）方式一： `${}`

mapper 接口方法

/**
 * 2、批量删除
 * 删除  t_user 表中某些 id 用户
 */
int deleteUserById(@Param("ids") String ids);

mapper 映射文件内容

<!--
2、批量删除 删除  t_user 表中某些 id 用户
-->
<delete id="deleteUserById">
	delete from t_user where id in (${ids})
</delete>

测试方法

    /**
     * 2、批量删除
     * 			删除  t_user 表中某些 id 用户
     */
    @Test
    public void testDeleteUserById() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
		int result = mapper.deleteUserById("2,3");
        System.out.println("一共删除数据 " + result + " 条");
    }

（2）方式二： `#{}`

mapper 接口方法

/**
 * 2、批量删除
 * 删除  t_user 表中某些 id 用户
 */
int deleteUserById(@Param("ids") List<String> ids);

mapper 映射文件内容

<!--
2、批量删除 删除  t_user 表中某些 id 用户
-->
<delete id="deleteUserById">
    DELETE FROM t_user WHERE id IN
    <foreach item="id" collection="ids" open="(" separator="," close=")">
        #{id}
    </foreach>
</delete>

测试方法

    /**
     * 2、批量删除
     *     删除  t_user 表中某些 id 用户
     */
    @Test
    public void testDeleteUserById() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
        List<String> ids = Arrays.asList("1", "2", "3");
        int result = mapper.deleteUserById(ids);
        System.out.println("一共删除数据 " + result + " 条");
    }

（5.4）动态设置表名

（1）概述

示例：动态设置表名 查询所有用户信息

（2） `${}`

mapper 接口方法

 /**
  * 3、动态设置表名 查询所有用户信息
  */
 List<User> getAllUser(@Param("tableName") String tableName);

mapper 映射文件内容

<!-- 3、动态设置表名 查询所有用户信息 -->
<select id="getAllUser" resultType="User">
    select * from ${tableName}
</select>

测试方法

/**
 * 3、动态设置表名 查询所有用户信息
 */
@Test
public void testGetAllUser() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
    List<User> userList = mapper.getAllUser("t_user");
    userList.forEach(System.out::println);
}

（5.5）添加功能获取自增的主键

（1）概述

在MyBatis中，要实现插入数据并获取数据库自增的主键，我们可以使用useGeneratedKeys="true"和keyProperty属性。以下是一个具体的示例，说明如何在MyBatis中通过insert语句获取自增主键。

（2）代码示例

mapper 接口方法

/**
 * 4、插入数据并获取数据库自增的主键
 */
void insertUser(User user);

mapper 映射文件内容

<!-- 4、插入数据并获取数据库自增的主键 -->
<insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO t_user (username, password, age, sex, email)
    VALUES (#{username}, #{password}, #{age}, #{sex}, #{email})
</insert>

测试方法

 /**
  * 4、插入数据并获取数据库自增的主键
  */
 @Test
 public void testInsertUser() {
     SqlSession sqlSession = SqlSessionUtils.getSqlSession();
     SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
     User user = new User(null,"lili","111",19,'女',"lili@163.com");
     mapper.insertUser(user);
     // 输出插入后的用户 ID
     System.out.println("生成的自增主键 ID：" + user.getId());
 }

（3）使用场景

在这里插入图片描述

// 示例：在订单生成后，插入订单详情
Order order = new Order();
orderMapper.insertOrder(order);  // 获取生成的订单 ID
int orderId = order.getId();

// 使用生成的订单 ID 插入订单详情
OrderDetail detail = new OrderDetail(orderId, "item1", 2);
orderDetailMapper.insertOrderDetail(detail);

在这里插入图片描述

// 示例：在 API 控制器中返回插入后的对象
@PostMapping("/users")
public User createUser(@RequestBody User user) {
    userMapper.insertUser(user); // 获取自增主键
    return user; // 返回包含 ID 的完整用户信息
}

在这里插入图片描述

🎈 第（3~5）章节全量代码

（1）文件目录

在这里插入图片描述

（2）pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ningxia.mybatis</groupId>
    <artifactId>mybatis_demo2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--mybatis核心文件-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <!--junit测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <!--MySQL驱动链接-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>
        <!--Lombok插件：提供实体类的set、get及toString等方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <!--Log4j2日志 以下是Log4j2 完整的日志记录实现所必需的-->
        <!--log4j-core 是实际处理日志输出的核心实现-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.17.1</version>
        </dependency>
        <!--log4j-api 只是定义了日志记录的接口-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.17.1</version>
        </dependency>
    </dependencies>
</project>

（3）配置文件 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--数据库配置信息文件引入-->
    <properties resource="jdbc.properties"/>
    <!--类型别名配置-->
    <typeAliases>
        <!--此处采用以包为单位，批量起别名-->
        <package name="com.ningxia.mybatis.pojo"/>
    </typeAliases>
    <!--数据库链接配置-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入mybatis映射文件-->
    <mappers>
        <!--<mapper resource="org/mybatis/example/BlogMapper.xml"/>-->
        <!--实际中会有多个映射文件，因此此处采用以包为单位批量引入方式-->
        <package name="com.ningxia.mybatis.mapper"/>
    </mappers>
</configuration>

（4）配置文件 jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=666666

（5）日志文件 log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <!-- 定义日志输出的目标 -->
    <Appenders>
        <!-- 控制台输出 -->
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout charset="UTF-8" pattern="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>

        <!-- 日志文件输出 -->
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="logs/app-%d{yyyy-MM-dd}-%i.log.gz">
            <PatternLayout  charset="UTF-8"  pattern="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>
            <Policies>
                <!-- 基于文件大小的滚动策略 -->
                <SizeBasedTriggeringPolicy size="10MB"/>
                <!-- 每天创建新的日志文件 -->
                <TimeBasedTriggeringPolicy interval="1"/>
            </Policies>
        </RollingFile>
    </Appenders>

    <!-- 日志器配置 -->
    <Loggers>
        <!-- Root 日志级别设为 debug，确保输出所有日志信息 -->
        <Root level="debug">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="RollingFile"/>
        </Root>

        <!-- MyBatis 日志配置 -->
        <Logger name="org.apache.ibatis" level="debug" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>
    </Loggers>
</Configuration>

（6）实体类 User

package com.ningxia.mybatis.pojo;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private Character sex;
    private String email;


}

（7）mapper 接口

😀 `（3~4）章节代码`

package com.ningxia.mybatis.mapper;

import com.ningxia.mybatis.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

public interface ParameterMapper {

    /**
     * 验证登录(多个参数使用注解)
     */
    User checkLoginByAnno(@Param("username") String username, @Param("password") String password);


    /**
     * 添加用户信息（mapper接口参数为一个实体类对象）
     */
    int addUserInfo(User user);


    /**
     * 验证登录(多个参数封装为map集合)
     */
    User checkLoginByMap(Map<String, Object> map);


    /**
     * 验证登录
     */
    User checkLogin(String username, String password);


    /**
     * 根据用户名获取用户信息
     */
    User getUserInfoByName(String name);

    /**
     * 获取所有用户信息
     */
    List<User> getUserList();


    /**
     * MyBatis 面向接口编程的两个一致
     * 1、映射文件的 namespace 要和 mapper接口中的全类名保持一致
     * 2、映射文件的 SQL 语句的id 要和 mapper接口中的方法名保持一致
     **/


    /**
     * 添加用户信息
     **/
    int insertUser();

    /**
     * 修改用户信息
     **/
    void updateUser();

    /**
     * 删除用户信息
     **/
    void deleteUser();
}

😀 `（5.1）章节代码`

package com.ningxia.mybatis.mapper;

import com.ningxia.mybatis.pojo.User;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

public interface SelectMapper {

    /**
     * 根据名称查询某个用户信息
     */
    User getUserInfoByNm(@Param("username") String username);

    /**
     * 查询结果为一条数据的 list集合
     */
    List<User> getUserInfoByNmToList(@Param("nm") String nm);

    /**
     * 查询结果为一条数据的map集合
     */
    Map<String, Object> getUserInfoByNmToMap(@Param("nm") String nm);


    /**
     * 查询所有用户信息
     */
    List<User> getAllUserInfo();


    /**
     * 查询结果为多条数据的map集合
     * <p>
     * 方式一
     * List<Map<String, Object>> getAllUserInfoToMap();
     * 输出形式如下：
     * [{password=33, sex=女, id=2, age=13, email=rose@qq.com, username=rose} , {password=123, sex=男, id=3, age=14, email=jack@qq.com, username=jack}]
     * <p>
     * <p>
     * 方式二
     *
     * @MapKey("id") Map<String, Object> getAllUserInfoToMap();
     * 将每条数据转换为 map集合 作为值，以选择的id字段值作为健，以 map集合形式返回
     * 输出形式如下：
     * {2={password=33, sex=女, id=2, age=13, email=rose@qq.com, username=rose},
     * 3={password=123, sex=男, id=3, age=14, email=jack@qq.com, username=jack}}
     */
//    List<Map<String, Object>> getAllUserInfoToMap();
    @MapKey("id")
    Map<String, Object> getAllUserInfoToMap();

    /**
     * 统计表中用户数
     */
    Integer getCountUser();



}

😀 `（5.2 ~ 5.5）章节代码`

package com.ningxia.mybatis.mapper;

import com.ningxia.mybatis.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface SqlMapper {

    /**
     * 1、模糊查询
     * 查询 t_user 表中名字中带 'j'的用户信息
     */
    List<User> selectAllUserByNm(@Param("nm") String nm);


    /**
     * 2、批量删除
     * 删除  t_user 表中某些 id 用户
     * 方式一：
     * int deleteUserById(@Param("ids") String ids);
     * 方式二：
     * int deleteUserById(@Param("ids") List<String> ids);
     */
    int deleteUserById(@Param("ids") List<String> ids);


    /**
     * 3、动态设置表名 查询所有用户信息
     */
    List<User> getAllUser(@Param("tableName") String tableName);


    /**
     * 4、插入数据并获取数据库自增的主键
     */
    void insertUser(User user);


}

（8）mapper 映射文件

😀 `（3~4）章节代码`

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ningxia.mybatis.mapper.ParameterMapper">
    <!--获取所有用户信息-->
    <select id="getUserList" resultType="User">
        select * from t_user
    </select>

    <!--根据用户名获取用户信息-->
    <select id="getUserInfoByName" resultType="User">
        <!-- select * from t_user where  username  = '${username}'-->
        select * from t_user where username = #{username}
    </select>

    <!--验证登录-->
    <select id="checkLogin" resultType="User">
        <!--
        select * from t_user where username = '${param1}' and password = '${param2}'
        select * from t_user where username = #{arg0} and password = #{arg1}
        select * from t_user where username = #{param1} and password = #{param2}
        select * from t_user where username = #{arg0} and password = #{param2}
        -->
        select * from t_user where username = #{param1} and password = #{param2}
    </select>
    <!--验证登录(多个参数封装为map集合)-->
    <select id="checkLoginByMap" resultType="User">
        <!--
        select * from t_user where username = '${username}' and password = '${password}'
        -->
        select * from t_user where username = #{username} and password = #{password}
    </select>

    <!--添加用户信息（mapper接口参数为一个实体类对象）-->
    <insert id="addUserInfo">
        <!-- insert into t_user values(null, '${username}', '${password}', '${age}', '${sex}', '${email}') -->
        insert into t_user values(null, #{username}, #{password}, #{age}, #{sex}, #{email})
    </insert>

    <!--验证登录(多个参数使用注解)-->
    <select id="checkLoginByAnno" resultType="User">
        <!--
        select * from t_user where username = '${username}' and password = '${password}'
        select * from t_user where username = #{param1} and password = #{param2}
        -->
        select * from t_user where username = #{username} and password = #{password}
    </select>



    <!--添加用户信息-->
    <insert id="insertUser">
        insert into t_user values(null,"wong","666",21,"男","wong@163.com")
    </insert>
    <!--修改用户信息-->
    <update id="updateUser">
        update t_user set username = 'zan' where id = 7
    </update>
    <!--删除用户信息-->
    <delete id="deleteUser">
        delete from t_user where username = "nima"
    </delete>

</mapper>

😀 `（5.1）章节代码`

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

    <!--  根据名称查询用户信息  -->
    <select id="getUserInfoByNm" resultType="User">
        select * from t_user where username = #{username}
    </select>

    <!--  查询结果为一条数据的 list集合  -->
    <select id="getUserInfoByNmToList" resultType="User">
        select * from t_user where username = #{nm}
    </select>


    <!--  查询结果为一条用户数据的map集合 -->
    <select id="getUserInfoByNmToMap" resultType="map">
        select * from t_user where username = #{nm}
    </select>


    <!--  查询所有用户信息   List<User> getAllUserInfo(); -->
    <select id="getAllUserInfo" resultType="User">
        select * from t_user
    </select>


    <!--  查询结果为多条数据的map集合  -->
    <select id="getAllUserInfoToMap" resultType="map">
        select * from t_user
    </select>

    <!--  统计表中用户数  -->
    <select id="getCountUser" resultType="int">
        select count(*) from t_user
    </select>



</mapper>

😀 `（5.2 ~ 5.5）章节代码`

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ningxia.mybatis.mapper.SqlMapper">
    <!--  1、模糊查询 查询 t_user 表中名字中带 'j'的用户信息-->
    <select id="selectAllUserByNm" resultType="User">
        <!--
        方式一：select * from t_user where username like '%${nm}%'
        方式二：select * from t_user where username like concat('%',#{nm},'%')
        方式三(推荐)：select * from t_user where username like "%"#{nm}"%"
        -->
        select * from t_user where username like "%"#{nm}"%"
    </select>

    <!--
    2、批量删除 删除  t_user 表中某些 id 用户
        方式一：
                <delete id="deleteUserById">
                    delete from t_user where id in (${ids})
                </delete>
        方式二：
                <delete id="deleteUserById">
                    DELETE FROM t_user WHERE id IN
                    <foreach item="id" collection="ids" open="(" separator="," close=")">
                        #{id}
                    </foreach>
                </delete>
    -->
    <delete id="deleteUserById">
        DELETE FROM t_user WHERE id IN
        <foreach item="id" collection="ids" open="(" separator="," close=")">
            #{id}
        </foreach>
    </delete>

    <!-- 3、动态设置表名 查询所有用户信息 -->
    <select id="getAllUser" resultType="User">
        select * from ${tableName}
    </select>


    <!-- 4、插入数据并获取数据库自增的主键 -->
    <insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO t_user (username, password, age, sex, email)
        VALUES (#{username}, #{password}, #{age}, #{sex}, #{email})
    </insert>

</mapper>

（9）SqlSessionUtils 工具类

package com.ningxia.mybatis.utils;


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

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

public class SqlSessionUtils {
    public static SqlSession getSqlSession() {
        SqlSession sqlSession = null;
        try {
            //获取配置文件
            InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
            //获取 sqlSessionFactory
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
            //获取 sqlSession
            sqlSession = sqlSessionFactory.openSession(true);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return sqlSession;
    }
}

（10）测试类

😀 `（3~4）章节代码`

package com.ningxia.mybatis.test;

import com.ningxia.mybatis.mapper.ParameterMapper;
import com.ningxia.mybatis.pojo.User;
import com.ningxia.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ParameterMapperTest {
    /*
     * myBatis 获取参数值的两种方式：   ${} 和  #{}
     *   ${}：本质字符串拼接
     *   #{}：本质占位符赋值
     *
     *
     * myBatis 获取参数值的情况：
     * 1、mapper接口方法的参数为单个字面量类型
     *   可以通过 ${}和 #{} 以任意名称获取参数值，但是要注意${}的单引号问题
     * 2、mapper接口方法的参数为多个时
     *   此时 mybatis 会将这些参数放在一个map中，以两种方式进行存储
     *   ① 以 arg0,arg1,......为键，以参数为值
     *   ② 以 param1,param2,......为键，以参数为值
     *   可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     * 3、mapper接口方法的参数为多个时,可以将这些参数封装在一个map集合中
     *  可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     * 4、mapper接口方法的参数是实体类型的参数
     *  可以通过 ${}和 #{} 以属性值的方式访问参数值，但是要注意${}的单引号问题
     * 5、使用注解 @Param 命名参数
     *   此时 mybatis 会将这些参数放在一个map中，以两种方式进行存储
     *   ① 以  @Param 注解的值为键，以参数为值
     *   ② 以 param1,param2,......为键，以参数为值
     *   可以通过 ${}和 #{} 以键的方式访问参数值，但是要注意${}的单引号问题
     *
     * */

    /**
     * 测试：验证登录(直接携带多个参数)
     */
    @Test
    public void testCheckLoginByAnno() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.checkLoginByAnno("dave", "888");
        System.out.println(user);
    }


    /**
     * 测试：验证登录(多个参数封装为map集合)
     */
    @Test
    public void testAddUserInfo() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final int result = mapper.addUserInfo(new User(null, "dog", "22", 18, '女', "dog@qq.com"));
        System.out.println(result);
    }

    /**
     * 测试：验证登录(多个参数封装为map集合)
     */
    @Test
    public void testCheckLoginByMap() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("username", "jef");
        map.put("password", "666");
        final User user = mapper.checkLoginByMap(map);
        System.out.println(user);
    }


    /**
     * 测试：验证登录(直接携带多个参数)
     */
    @Test
    public void testCheckLogin() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.checkLogin("jef", "666");
        System.out.println(user);
    }

    /**
     * 测试：根据用户名获取用户信息
     */
    @Test
    public void testGetUserInfoByName() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final User user = mapper.getUserInfoByName("jack");
        System.out.println(user);
    }


    /**
     * 测试：获取全部用户信息
     */
    @Test
    public void testGetAllUserInfo() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        final List<User> userList = mapper.getUserList();
        userList.forEach(System.out::println);
    }



    @Test
    public void testMybatisAdd() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        int result = mapper.insertUser();
        System.out.println("执行结果：" + result);

    }

    @Test
    public void testMybatisUpdate() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        //调用接口方法:根据id修改用户信息
        mapper.updateUser();
    }

    @Test
    public void testMybatisDelete() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        final ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        mapper.deleteUser();
    }
}

😀 `（5.1）章节代码`

package com.ningxia.mybatis.test;


import com.ningxia.mybatis.mapper.SelectMapper;
import com.ningxia.mybatis.pojo.User;
import com.ningxia.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;
import java.util.Map;

public class SelectMapperTest {

    /**
     * 根据名称查询用户信息
     */
    @Test
    public void testGetUserInfoByNm() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        User user = mapper.getUserInfoByNm("rose");
        System.out.println(user);
    }


    /**
     * 查询结果为一条数据的 list集合
     */
    @Test
    public void testGetUserInfoByNmToList() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<User> userList = mapper.getUserInfoByNmToList("jack");
        userList.forEach(System.out::println);
    }


    /**
     * 查询结果为一条数据的map集合
     */
    @Test
    public void testGetUserInfoByNmToMap() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        Map<String, Object> map = mapper.getUserInfoByNmToMap("jack");
        System.out.println(map);
    }


    /**
     * 查询所有用户信息
     */
    @Test
    public void testGetAllUserInfo() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<User> userList = mapper.getAllUserInfo();
        userList.forEach(System.out::println);
    }


    /**
     * 查询结果为多条数据的map集合
     */
    @Test
    public void testGetAllUserInfoToMap() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        System.out.println(mapper.getAllUserInfoToMap());
    }

    /**
     * 统计表中用户数
     */
    @Test
    public void testGetCountUser() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        System.out.println("t_user表中一共有 "+mapper.getCountUser()+" 条数！");
    }
}

😀 `（5.2 ~ 5.5）章节代码`

package com.ningxia.mybatis.test;

import com.ningxia.mybatis.mapper.SqlMapper;
import com.ningxia.mybatis.pojo.User;
import com.ningxia.mybatis.utils.SqlSessionUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;

public class SqlMapperTest {


    /**
     * 1、模糊查询
     * 查询 t_user 表中名字中带 'j'的用户信息
     */
    @Test
    public void testGetUserByNm() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
        List<User> userList = mapper.selectAllUserByNm("j");
        userList.forEach(System.out::println);
    }

    /**
     * 2、批量删除
     * 删除 t_user 表中某些 id 用户
     */
    @Test
    public void testDeleteUserById() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
//      方式一：
//      int result = mapper.deleteUserById("2,3");
//      方式二：
        List<String> ids = Arrays.asList("1", "2", "3");
        int result = mapper.deleteUserById(ids);
        System.out.println("一共删除数据 " + result + " 条");
    }

    /**
     * 3、动态设置表名 查询所有用户信息
     */
    @Test
    public void testGetAllUser() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
        List<User> userList = mapper.getAllUser("t_user");
        userList.forEach(System.out::println);
    }


    /**
     * 4、插入数据并获取数据库自增的主键
     */
    @Test
    public void testInsertUser() {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlMapper mapper = sqlSession.getMapper(SqlMapper.class);
        User user = new User(null,"lili","111",19,'女',"lili@163.com");
        mapper.insertUser(user);
        // 输出插入后的用户 ID
        System.out.println("生成的自增主键 ID：" + user.getId());
    }



}