MyBatis系统学习 - 使用Mybatis完成查询单条，多条数据，模糊查询，动态设置表名，获取自增主键

上篇博客我们围绕Mybatis链接数据库进行了相关概述，并对Mybatis的配置文件进行详细的描述，本篇博客也是建立在上篇博客之上进行的，在上面博客搭建的框架基础上，我们对MyBatis实现简单的增删改查操作进行重点概述，在MyBatis中实现简单的增删改查，算是我们在处理业务的时候经常干的事情，使用Mybatis可以帮助我们将数据库操作封装在映射文件或者映射接口中，让开发人员可以通过简单的配置或者接口方法来执行数据库操作，进而无需重复编写繁琐的SQL,并且可以灵活编写SQL语句，可以根据实际需求进行SQL拼接，从而提高数据库操作的灵活性和可用性。

项目目录结构

在这里插入图片描述
PS: 上述的Service层是我为了按照规范进行开发创建的相关类，实际开发中则需要按照上述规范进行，而本篇博客我们将不会使用到service层，所以，读者可以无需创建Service和ServiceImpl。

关注点：

MyBatis实现简单的增删改查也会实现MyBatis实现一些相对复杂的查询功能，其中包括查询List集合，查询一个实体类对象，以及查询单个数据，查询单条为Map的集合和多条Map的集合。
MyBatis获取参数值的两种方式： ${}和#{}
特殊SQL的执行：模糊查询，批量删除，动态设置表名，添加功能获取自增的主键
自定义映射resultMap，多对一和一对多映射关系处理

数据库

CREATE TABLE `test`.`user`  (
       `id` int(11) NOT NULL,
       `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
       `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
       `sex` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
       PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_bin ROW_FORMAT = Dynamic;

CREATE TABLE `test`.`book`  (
            `uid` int(11) NOT NULL COMMENT '用户id',
            `book` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '用户借的书的名称',
            `cool` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT 'cool星级',
            PRIMARY KEY (`uid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_bin ROW_FORMAT = Dynamic;

实体Bean

public class Book {

    private Integer uid;

    private String book;

    private String cool;

    public Book() {
    }

    public Book(Integer uid, String book, String cool) {
        this.uid = uid;
        this.book = book;
        this.cool = cool;
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getBook() {
        return book;
    }

    public void setBook(String book) {
        this.book = book;
    }

    public String getCool() {
        return cool;
    }

    public void setCool(String cool) {
        this.cool = cool;
    }

    @Override
    public String toString() {
        return "Book{" +
                ", uid=" + uid +
                ", book='" + book + '\'' +
                ", cool='" + cool + '\'' +
                '}';
    }
}

public class User {

    private int id;

    private String name;

    private  String username;

    private String sex;

    private Book book;

    private Integer uid;

    private String bookName;

    private String cool;

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

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getCool() {
        return cool;
    }

    public void setCool(String cool) {
        this.cool = cool;
    }

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getUsername() {
        return username;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public User(int id, String name, String username, String sex) {
        this.id = id;
        this.name = name;
        this.username = username;
        this.sex = sex;
    }

    public User() {
    }
}

Mapper映射层接口

@Mapper
public interface UserMapper {

    /**
     * 查询用户对象
     */
    User selectUser(@Param("user") User user);

    /**
     * 插入用户数据
     */
    int insertUser(User user);

    /**
     * 更新数据
     */
    int updateUser(@Param("user") User user);


    /**
     * 删除用户数据
     */
    int deleteUser(int id);

    /**
     * 批量删除用户数据
     */
    int  deleteUserBatch(@Param("ids") String ids);

    /**
     * 查询所有用户数据
     */
    List<User> selectAll();

    /**
     * 查询单条数据，并转化为Map对象数据
     */
    Map<String,Object> getUserToMap(@Param("id") int id);

    /**
     * 查询多条数据斌并转化为Map对象数据
     */

    List<Map<String,Object>> get100UserToMap();

    /**
     * 查询多条数据并转换为Map对象的数据的第二种方式
     */
    @MapKey("id")
    Map<Integer,User> get100UserToMap2();

    /**
     * 模糊查询
     */
    List<User> selectUserLike(@Param("user") User user);

    /**
     * 动态设置表名查询数据
     */
    List<User> selectUserByTableName(@Param("tableName") String tableName);

	/** 根据用户id查询信息*/
	User getUserById(int id);
	/** 管理其他表一对一查询 */
    User getUserBookById(int id);
}

Mapper接口对应的映射xml文件

关注

Mapper文件我们需要注意的是：
resultType：resultType用于指定查询结果的类型。它可以是Java的基本数据类型（如int、String等），也可以是自定义的Java对象。MyBatis会根据查询结果的列名和resultType的类型进行自动映射。示例代码如下：

<select id="getUser" resultType="com.example.User">
    SELECT * FROM users WHERE id = #{id}
</select>

resultType指定了查询结果的类型为com.example.User，MyBatis会将查询结果自动映射到User对象中。

parameterType：parameterType用于指定SQL语句的参数类型。它可以是Java的基本数据类型、Java对象或者是一个Map。示例代码如下：

<insert id="insertUser" parameterType="com.example.User">
   INSERT INTO users (id, name, age) VALUES (#{id}, #{name}, #{age})
</insert>

parameterType指定了插入语句的参数类型为com.example.User，MyBatis会将User对象的属性值作为参数传递给SQL语句。

id：id用于唯一标识映射文件（或注解）中的语句。它是一个字符串，可以自定义命名，用于在代码中调用对应的SQL语句。示例代码如下：

<select id="getUserById" resultType="com.example.User">
    SELECT * FROM users WHERE id = #{id}
</select>

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.miaow.mybatis.mapper.UserMapper">


    <!--
    resultMap：设置自定义映射
    属性：
    id：表示自定义映射的唯一标识
    type：查询的数据要映射的实体类的类型
    子标签：
    id：设置主键的映射关系
    result：设置普通字段的映射关系
    association：设置多对一的映射关系
    collection：设置一对多的映射关系
    属性：
    property：设置映射关系中实体类中的属性名
    column：设置映射关系中表中的字段名
    -->

    <resultMap id="userMap" type="User">
<!--        实际山和我们数据库字段别名差不多-->
        <id property="id" column="id"></id>
        <result property="name" column="name"></result>
        <result property="username" column="username"></result>
        <result property="sex" column="sex"></result>
        <association property="book" javaType="Book">
            <id property="uid" column="uid"></id>
            <result property="book" column="bookName"></result>
            <result property="cool" column="cool"></result>
        </association>
    </resultMap>


<!--    根据resultMap获取相关数据-->
    <select id="getUserById" resultMap="userMap" parameterType="int">
        select * from user where id = #{id};
    </select>


<!--    管理其他表一对一查询 -->
    <select id="getUserBookById" resultMap="userMap" parameterType="int">
        select a.*,b.uid as uid,b.book as bookName ,b.cool as cool from user a
        left join book b on a.id = b.uid
        where a.id = #{id}
    </select>

    <!--    插入单条数据
    * useGeneratedKeys：设置使用自增的主键
    * keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中
    -->
    <insert id="insertUser" parameterType="com.miaow.mybatis.bean.User" useGeneratedKeys="true" keyProperty="id" >
    insert into user values(#{id},#{username},#{name},#{sex})
    </insert>

<!--    更新数据 -->
    <update id="updateUser" parameterType="com.miaow.mybatis.bean.User">
        update user set name = #{user.name} where id = #{user.id}
    </update>

    <!--    删除单条数据-->
    <delete id="deleteUser" parameterType="int">
        delete  from  user where id = #{id}
    </delete>
<!--    批量删除数据-->
    <delete id="deleteUserBatch" parameterType="java.lang.String">
        delete  from  user where id in (${ids})
    </delete>

    <!--   根据ID查询相关数据-->
    <select id="selectUser" resultType="com.miaow.mybatis.bean.User">
        select * from user where id = #{user.id}
    </select>
<!--    查询数据库所有数据-->
    <select id="selectAll" resultType="com.miaow.mybatis.bean.User">
    select * from user
    </select>


    <select id="getUserToMap" resultType="java.util.Map" parameterType="int">
        select * from user where id = #{id};
    </select>
    <select id="get100UserToMap" resultType="java.util.Map">
    select * from user limit 100;

    </select>
    <select id="get100UserToMap2" resultType="java.util.Map">
        select * from user limit 100;
    </select>

    <select id="selectUserLike" resultType="com.miaow.mybatis.bean.User"
            parameterType="com.miaow.mybatis.bean.User">
        select * from user where username like "%" #{user.username} "%"

    </select>
<!--    动态设置表名查询数据 -->
    <select id="selectUserByTableName" resultType="com.miaow.mybatis.bean.User"
            parameterType="java.lang.String">
        select * from ${tableName} limit 100
    </select>
</mapper>

我们根据上述的这个XML文件进行配置进行讲解：
MyBatis实现简单的增删改查也会实现MyBatis实现一些相对复杂的查询功能，其中包括查询List集合，查询一个实体类对象，以及查询单个数据，查询单条为Map的集合和多条Map的集合。

简单的新增

<insert id="insertUser" parameterType="com.miaow.mybatis.bean.User" useGeneratedKeys="true" keyProperty="id" >
    insert into user values(#{id},#{username},#{name},#{sex})
    </insert>

我们通过SQL语句和Xml的配置文件写入SQL，但是不知道眼尖的同学看到没有，这里边我写了插入id，实际上是我架构表的时候，没有使用自增，这算是我的锅，如果你配置了自增，我们有没有发现useGeneratedKeys="true" keyProperty="id" 这个语句？
useGeneratedKeys：设置使用自增的主键，默认为False。

我们在插入数据的时候，我们有时候需要直接插入数据的时候，这个时候我们可能不知道我们插入的主键id是多少
这个时候我们只需要配置 useGeneratedKeys=“true” keyProperty=“id” 然后我们就可以直接拿到我们插入数据的主键id，比如 int value = userMapper.insertUser(user); int id = userVo.getId();//获取插入数据后的主键id

keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中,比如我上面的是绑定的id，那么Mybatis就将返回的id值存入到实体类的与之相同的字段中。

删除单条数据

    <delete id="deleteUser" parameterType="int">
        delete  from  user where id = #{id}
    </delete>

删除多条数据

<!--    批量删除数据-->
    <delete id="deleteUserBatch" parameterType="java.lang.String">
        delete  from  user where id in (${ids})
    </delete>

    public void test8() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        String i = "5,6,7,8,9";
        int V = userMapper.deleteUserBatch(i);
        if(V > 0){
            System.out.println("success");
        }else {
            System.out.println("fail");
        }
    }

查询一个实体类对象

User getUserById(@Param("id") int id);

<select id="getUserById" resultType="com.miaow.mybatis.bean.User">
	select * from t_user where id = #{id}
</select>

`${}和#{}`

MyBatis获取参数值的两种方式： ${}和#{}

${}的本质就是字符串拼接，#{}的本质就是占位符赋值

#{}：#{}是预编译的占位符，它会将参数值作为参数对象的属性值进行处理，并使用预编译语句来执行数据库操作。这种方式可以提供更好的系统安全性，因为参数值会被自动转义，从而防止SQL注入攻击。使用#{}可以有效地防止恶意用户通过参数值注入恶意的SQL代码。

${}：${}是字符串替换的占位符，它会将参数值直接替换到SQL语句中。这种方式更加灵活，可以在SQL语句中使用动态的表名、列名或其他字符串。然而，使用${}也带来了一些安全风险，因参数值不会被自动转义，可能会导致SQL注入攻击。因此，使用${}时需要确保参数值的安全性，例如通过输入验证或白名单过滤来防止恶意输入。

${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；
但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

MyBatis中建议使用#{}，原因在于其可以预防SQL注入，而${}无法预防SQL注入

特殊SQL的执行：模糊查询，批量删除，动态设置表名，添加功能获取自增的主键

自定义映射

驼峰配置

主要为了解决java字段和数据库字段不一致问题。我们有两种方式，一种是自定义映射，一种是我们在MyBatis中配置驼峰命名的规则的自动映射。

<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

MyBatis的全局配置文件中开启驼峰命名规则的自动映射。通过设置mapUnderscoreToCamelCase属性为true，MyBatis会自动将数据库表的下划线命名转换为Java对象的驼峰命名。

自定义映射resultMap，多对一和一对多映射关系处理

resultMap：设置自定义映射
属性：
id：表示自定义映射的唯一标识
type：查询的数据要映射的实体类的类型
子标签：
id：设置主键的映射关系
result：设置普通字段的映射关系
association：设置多对一的映射关系
collection：设置一对多的映射关系
属性：
property：设置映射关系中实体类中的属性名
column：设置映射关系中表中的字段名

    <resultMap id="userMap" type="User">
<!--        实际山和我们数据库字段别名差不多-->
        <id property="id" column="id"></id>
        <result property="name" column="name"></result>
        <result property="username" column="username"></result>
        <result property="sex" column="sex"></result>
        <association property="book" javaType="Book">
            <id property="uid" column="uid"></id>
            <result property="book" column="bookName"></result>
            <result property="cool" column="cool"></result>
        </association>
    </resultMap>

自定义设置表名

<!--    动态设置表名查询数据 -->
    <select id="selectUserByTableName" resultType="com.miaow.mybatis.bean.User"
            parameterType="java.lang.String">
        select * from ${tableName} limit 100
    </select>

/**动态设置表名查询数据  可以通过@Param注解标识mapper接口中的方法参数此时，会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值；*/
List<User> selectUserByTableName(@Param("tableName") String tableName);

    // 动态设置表名查询数据
    @Test
    public void test9() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);
		//根据我们传入的表名查询对应的表信息
        List<User> users = userMapper.selectUserByTableName("user");
        for (User user : users) {
            System.out.println(user);
        }
    }

测试类

public class UserTest {

    @Resource
    private UserService userService;

    //插入单条数据
    @Test
    public void test() throws IOException {
        //仅仅属于Mybatis框架的相关知识解决相关问题
        //首先读取Mybatis配置文件
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession
        //第一个参数为是否自动提交，true为自动提交，false为手动提交，默认为false
        //SqlSession对象，此时通过sqlSession对象所操作的sql都会提交
       SqlSession session = sqlSessionFactory.openSession(true);
        //通过sqlSession对象获取mapper接口对象
        UserMapper userMapper = session.getMapper(UserMapper.class);
        //执行sql,插入数据的时候，我做了一个操作就获取主键的操作，调用的事Mybatis的主键回调功能
        int i = userMapper.insertUser(new User(1,"miaow","罗小黑","1"));
        if(i > 0){
            System.out.println("success");
        }else {
            System.out.println("fail");
        }
        //提交事务
        //session.commit();
        //关闭session
        session.close();
    }

    //查询表中所有数据
    @Test
    public void test2() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        List<User> users = userMapper.selectAll();
        if(users == null && users.size() == 0){
            System.out.println("你查询的表无数据");
            return;
        }
        for (User user : users) {
            System.out.println(user);
        }

        session.close();
    }

    //根据ID查询相关数据
    @Test
    public void test3() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        User user = new User();
        user.setId(82);
        User findById = userMapper.selectUser(user);
        System.out.println(findById);

    }

    //查询单条数据
    @Test
    public void findByIdData() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        User user = userMapper.getUserById(86);
        System.out.println(user);

    }

    //查询单条数据为map集合
    @Test
    public void test4() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        Map<String, Object> userToMap  = userMapper.getUserToMap(520);
        System.out.println(userToMap);

    }

    //查询前100条数据并将数据转换为Map集合
    @Test
    public void test5() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        List<Map<String,Object>> userToMapList = userMapper.get100UserToMap();
        for (Map<String, Object> map : userToMapList) {
            System.out.println(map);
        }
    }

    //查询前100条数据并将数据转换为Map集合方式2
    @Test
    public void findData() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        Map<Integer, User> map = userMapper.get100UserToMap2();
        Set<Integer> integers = map.keySet();
        for (Integer integer : integers) {
            System.out.println(map.get(integer));
        }
    }


    //删除单条数据
    @Test
    public void test6() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        int i = userMapper.deleteUser(82);
        if(i > 0){
            System.out.println("success");
        }else {
            System.out.println("fail");
        }
    }

    //批量删除数据
    @Test
    public void test8() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        String i = "5,6,7,8,9";
        int V = userMapper.deleteUserBatch(i);
        if(V > 0){
            System.out.println("success");
        }else {
            System.out.println("fail");
        }
    }

    //模糊查询
    @Test
    public void test7() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        User user = new User();
        user.setUsername("K");
        List<User> users = userMapper.selectUserLike(user);
        for (User user1 : users) {
            System.out.println(user1);
        }
    }


    // 动态设置表名查询数据
    @Test
    public void test9() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        List<User> users = userMapper.selectUserByTableName("user");
        for (User user : users) {
            System.out.println(user);
        }
    }

    //更新表中数据
    @Test
    public void test10() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        User user = new User();
        user.setId(58);
        user.setName("罗小黑");

        int i = userMapper.updateUser(user);

        if(i > 0){
            System.out.println("success");
        }else {
            System.out.println("fail");
        }
    }

//  association一对一联查
    @Test
    public void test11() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = sqlSessionFactory.openSession(true);
        UserMapper userMapper = session.getMapper(UserMapper.class);

        User user = userMapper.getUserBookById(520);
        System.out.println(user);
    }
}