Mybatis学习笔记[完结]

水晶心泉

已于 2022-02-15 19:58:08 修改

阅读量653

点赞数

分类专栏：后端文章标签： java mybatis

于 2021-12-06 14:54:39 首次发布

本文链接：https://blog.csdn.net/zidieq/article/details/121747006

版权

后端专栏收录该内容

24 篇文章 2 订阅

订阅专栏

Mybatis详细操作

在书写SQL语句时，注意大小写的问题，不论是数据库中还是sql语句中，尽量全部使用小写

配置中的别名问题

https://mybatis.org/mybatis-3/zh/configuration.html#typeAliases

配置文件中如果有配置type-aliases-package的包路径，则在设置的resultType时，如果要设置的对象处于该包下，则可以直接写类名首字母小写的非限定名，或是@Alias("author")注解指定的值

<select id="findById" resultType="com.jt.pojo.User">
    select * from demo_user where id = #{id}
</select>

可以简化成下面这样

<select id="findById" resultType="User">
    select * from demo_user where id = #{id}
</select>

参数传递问题

Mybatis只支持单个参数，所以如果需要同时传递多个参数时，需要想办法对所有的参数进行封装

使用对象封装
当要传递的参数个数较多时，请考虑使用对象来封装数，如下面的例子中，getUserListByNameAndAge方法目前其实只需要传name和age这两个参数，我们也可以直接使用两个形参来接收，但是使用User对象传递参数时，后面即使要传递的参数增加了，调用者也不需要修改代码。

List<User> getUserListByNameAndAge(User user);

使用Map<String,Object>
通用性更好一些，可以根据自己的需求对各种自定义名称的参数进行封装

int minAge = 18;
int maxAge = 100;
Map<String,Integer> map = new HashMap<>();
map.put("minAge",minAge);
map.put("maxAge",maxAge);
List<User> userList = userMapper.findUserByAge(map);
System.out.println(userList);

特殊字符实体 < > &
如果需要在xml文件中输入以下字符时需要使用字符实体来避免出现问题

字符	对应实体
`<`	`<`
`>`	`>`
`&`	`&`

<!--UserMapper.xml-->
<select id="findByAge" resultType="user">
    select  * from demo_user where age &lt; #{maxAge} and age  &gt; #{minAge}
</select>

也可以使用<![CDATA[书写内容]]>

<!--UserMapper.xml-->
<select id="findByAge" resultType="user">
    <![CDATA[select  * from demo_user where age < #{maxAge} and age > #{minAge}]]>
</select>

Mybatis支持单个参数的传递，如果需要传递多个参数，使用对象、map都不方便的时候，可以使用@Param("键名")注解来标明每个参数，并取个别名，此别名不能重复，意思是把所有添加了注解的参数都封装到同一个Map里面，变成单个参数值

//UserMapper 接口中
List<User> findByAge2(@Param("minAge") int minAge, @Param("maxAge")int maxAge);

调用时

// 测试类中
userMapper.findByAge2(10,23).forEach(e -> {
  System.out.println(e);
});

sql标签

主要用于抽取公共部分的sql语句，有时会简化代码量，但是会一定程度上降低可读性

<select id="findByNA">
	select <include refid="publiccolumns"/> from demo_user
</select>

<sql id = "publiccolumns">
	id,name,age,sex
</sql>

foreach标签

collection属性指需要遍历的集合，有以下几种

数据类型	对应的`collection`的值
数组	`array`/`list`
list集合	`array`/`list`
`Map`<`key`,`array`/`list`>	`key`

open和close属性用于定义最终结果的前缀和后缀字符，也可以不写，直接在<foreach>标签外面
separator分隔符，用于指定对所有的元素进行拼接时，使用什么符号区分开
item正在遍历数据的当前轮的元素的变量名称，内存中指向真正的元素
#{item}取出4中定义的item属性里面的值
index是当前迭代的序号
当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。

接口中

// UserMapper 接口中
List<User> findByIn(int[] ids);

映射文件中

<!-- UserMapper.xml中 -->
<select id="findByIn" resultType="User">
    select *
    from demo_user
    where id in
    <foreach collection="array" item="id" index="index" open="(" separator="," close=")">
        #{id}
    </foreach>
</select>

调用时

userMapper.findByIn(new int[]{1,3,5,6,7}).forEach(System.out::println);

动态SQL

sql-where

解决需求：根据对象中不为null的数据，动态拼接SQL语句
在*Mapper.xml文件中使用where标签生成动态sql时，会自动去除开头的and拼接符，以满足sql语法

@Mapper
public interface UserMapper2 {
    List<User> getUserByUser(User user);
}

<?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">

<!--namespace是mybaits映射文件的唯一标识,与接口对应-->
<mapper namespace="com.jt.mapper.UserMapper2">

    <select id="getUserByUser" resultType="com.jt.pojo.User">
        select *
        from demo_user
        <where>
            <if test="id!=null">id = #{id}</if>

            <if test="name!=null">and name = #{name}</if>

            <if test="age!=null">and age = #{age}</if>

            <if test="sex!=null">and sex = #{sex}</if>
        </where>
    </select>
</mapper>

package com.jt;

import com.jt.mapper.UserMapper;
import com.jt.mapper.UserMapper2;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class TestMyBatis2 {
    @Autowired
    private UserMapper2 userMapper;

    @Test
    public void Test() {
        User user = new User();
        user
//                .setId(5)
                .setName("唐僧")
//                .setAge(30)
                .setSex("男");
        System.out.println(userMapper.getClass().getName());
        userMapper.getUserByUser(user).forEach(System.out::println);
    }
}

set

执行update操作时，需要根据对象中不为null的属性来动态生成set中的语句，会自动去除语句中最后的一个逗号,，以满足sql语句的合法性

@Mapper
public interface UserMapper2 {
    int updateUser(User user);
}

<?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">

<!--namespace是mybaits映射文件的唯一标识,与接口对应-->
<mapper namespace="com.jt.mapper.UserMapper2">
    <update id="updateUser">
        update demo_user
        <set>
            <if test="name!=null">name=#{name},</if>
            <if test="age!=null">age=#{age},</if>
            <if test="sex!=null">sex=#{sex},</if>
        </set>
        where id = #{id}
    </update>
</mapper>

package com.jt;
import com.jt.mapper.UserMapper2;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TestMyBatis2 {
    @Autowired
    private UserMapper2 userMapper;

    @Test
    public void Test() {
        User user = new User();
        user
                .setId(100)
                .setName("聪哥")
                .setAge(31)
                .setSex("男")
                ;
        int rows = userMapper.updateUser(user);
        System.out.println("影响行数:"+rows);
    }
}

choose、when、otherwise

解决需求：如果不想使用所有的条件可以使用choose类似于java中的switch语法
举例：如果name有值则按照name查询，否则按sex查询数据

@Mapper
public interface UserMapper2 {
    List<User> getUserByNS(User user);
}

<?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">

<!--namespace是mybaits映射文件的唯一标识,与接口对应-->
<mapper namespace="com.jt.mapper.UserMapper2">
    <select id="getUserByNS" resultType="com.jt.pojo.User">
        select * from demo_user
        <!--使用此种形式时，如果choose里面的所有when都不满足，又没有otherwise标签时，则最终的sql中不会出现where子句-->
        <where>
        	<!--表示所包裹的when和otherwise标签只会选择一个输出-->
            <choose>
            	<!--当条件成立时，就不再执行下面的判断了-->
                <when test="name!=null">
                    name=#{name}
                </when>
                <when test="age!=null">
                    age=#{age}
                </when>
                <!--当所有的when都不满足时，不论此处的sex是否为null都会进行拼接-->
                <otherwise>
                    sex = #{sex}
                </otherwise>
            </choose>
        </where>
    </select>
</mapper>

package com.jt;

import com.jt.mapper.UserMapper2;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TestMyBatis2 {
    @Autowired
    private UserMapper2 userMapper;

    @Test
    public void Test() {
        User user = new User();
        user
                .setId(100)
//                .setName("聪哥")
//                .setAge(31)
                .setSex("男");
        userMapper.getUserByNS(user).forEach(System.out::println);
    }
}

resultMap

当pojo的对象的属性与数据库中的字段名不完全一致时
resultType ：只适用于pojo的各属性名称与数据库表中的字段名称一致时
resultMap ：可以支持任意类型的映射

# 数据库中创建表dog
CREATE TABLE `dog` (
  `dog_id` int(11) NOT NULL AUTO_INCREMENT,
  `dog_name` varchar(4) DEFAULT NULL COMMENT '名字',
  `age` int(11) DEFAULT NULL,
  `dog_type` char(1) DEFAULT NULL,
  PRIMARY KEY (`dog_id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8

package com.jt.mapper;

import com.jt.pojo.Dog;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface DogMapper {
    List<Dog> getAll();
}

<?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">

<!--namespace是mybaits映射文件的唯一标识,与接口对应-->
<mapper namespace="com.jt.mapper.DogMapper">
    <select id="getAll" resultMap="dogRM">
        select * from dog
    </select>
    <!--此处是type，用于指定Java的pojo对象类型-->
    <resultMap id="dogRM" type="dog">
        <!--主键-->
        <!--column属性指的是数据库表中的列名-->
        <!--property属性指的是当前类中的对象的属性值-->
        <id column="dog_id" property="dogId"></id>
        <!--其他映射，可以有多个-->
        <result column="dog_name" property="dogName"></result>
        <result column="dog_type" property="dogType"></result>
        <!--如果还有其他列，但列名可以与对象名匹配上，则可以不配置，也会拿得到值-->
    </resultMap>
</mapper>

package com.jt;

import com.jt.mapper.DogMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TestDogMapper {

    @Autowired
    DogMapper dogMapper;
    
    @Test
    public void test(){
        dogMapper.getAll().forEach(System.out::println);
    }
}

驼峰规则映射配置

在src/main/resources/application.yml配置文件中开启如下配置，则可以将驼峰形式转成_分隔的形式
例：userNameOfOrigin可以对应数据库里面的user_name_of_origin

mybatis:
  configuration:
    map-underscore-to-camel-case: true

关联查询

常见关联关系

关系类型	例子
一对一	一夫一妻
一对多	老师对学生
多对多	学生对课程

示例
先准备具有一对多的关系

# 创建数据表
CREATE TABLE `emp` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `dept_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `dept` (
  `dept_id` int(11) NOT NULL AUTO_INCREMENT,
  `dept_name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`dept_id`)
) ENGINE=InnoDB AUTO_INCREMENT=201 DEFAULT CHARSET=utf8;

# 分别向两张表中插入数据
INSERT INTO `emp`(`id`, `name`, `age`, `dept_id`) VALUES (1, '貂蝉', 18, 100);
INSERT INTO `emp`(`id`, `name`, `age`, `dept_id`) VALUES (2, '西施', 19, 200);
INSERT INTO `emp`(`id`, `name`, `age`, `dept_id`) VALUES (3, '王昭君', 20, 100);

INSERT INTO `dept`(`dept_id`, `dept_name`) VALUES (100, '财务部');
INSERT INTO `dept`(`dept_id`, `dept_name`) VALUES (200, '销售部');

准备pojo类

package com.jt.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class Emp implements Serializable {
    private  Integer  id;
    private String name;
    private Integer age;
    private Dept dept;
}

package com.jt.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class Dept implements Serializable {
    private Integer deptId;
    private String deptName;
    private List<Emp> emps;
}

一对一

映射文件,Mybatis中多表关联时，结果集里面不要有重名的字段resultMap
resultMap中的在不包含association标签时，除id列外，其他的列会根据命名规则自动映射到属性上。但是添加了association标签后，就需要手动设置autoMapping属性值为true才可以正常获得值，且此属性只会影响当前标签所指定的类型的自动映射，不会影响到association标签里面的映射。如果association里面也需要自动映射，则需要为association标签也添加autoMapping属性并设置为true[^1]

<?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">

<!--namespace是mybaits映射文件的唯一标识,与接口对应-->
<mapper namespace="com.jt.mapper.EmpMapper">

	<!--为了关联映射能正常解析,使用精确指定列名的方式来查询,以去掉重复的列名-->
    <select id="findAll" resultMap="empRM">
        select ta.id, ta.name, ta.age, ta.dept_id, tb.dept_name
        from emp as ta
                 join dept as tb on ta.dept_id = tb.dept_id
    </select>
	<!--autoMapping只能作用于当前级别的标签上,比如此处只对empRM生效-->
    <resultMap id="empRM" type="Emp" autoMapping="true">
        <id column="id" property="id"></id>
        <!--此处的autoMapping只对association标签生效-->
        <!--且上面的autoMapping也不会对association标签生效-->
        <association property="dept" javaType="Dept" autoMapping="true">
        	<!--主键也是需要指定的-->
            <id column="dept_id" property="deptId"></id>
        </association>
    </resultMap>
</mapper>

测试

package com.jt;

import com.jt.mapper.EmpMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TestEmp {

    @Autowired
    EmpMapper empMapper;

    @Test
    public void test(){
        empMapper.findAll().forEach(System.out::println);
    }
}

一对多

<?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">

<!--namespace是mybaits映射文件的唯一标识,与接口对应-->
<mapper namespace="com.jt.mapper.DeptMapper">

    <select id="findAll" resultMap="deptRM">
        select dept.dept_name,emp.* from dept left join emp on dept.dept_id=emp.dept_id
    </select>
    
    <resultMap id="deptRM" type="Dept" autoMapping="true">
        <id property="deptId" column="dept_id"/>
        <!--一对多关联时使用collection标签-->
        <!-- ofType属性表示集合里面的元素的类型-->
        <collection property="emps" ofType="Emp" autoMapping="true">
            <id property="id" column="id"/>
        </collection>
    </resultMap>
</mapper>

package com.jt;

import com.jt.mapper.DeptMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TestDept {
    @Autowired
    DeptMapper deptMapper;

    @Test
    public void test(){
        deptMapper.findAll().forEach(System.out::println);
    }
}

注解开发

映射器注解 : https://mybatis.org/mybatis-3/zh/java-api.html

缓存

SpringBoot在整合mybatis后每次操作都是单独的sqlSession所以默认情况下无法使用一级缓存
SpringBoot中如果添加了事务的注解@Transactional，则默认采用同一个sqlSession

一级缓存

在同一个sqlSession内实现数据的共享

二级缓存

在由同一个sqlSessionFactory生产的sqlSession间数据共享
如要在使用SpringBoot的情况下开启二级缓存，需要在src/main/resources/mappers/*Mapper.xml文件中添加<cache/>标签

<?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">

<!--namespace是mybaits映射文件的唯一标识,与接口对应-->
<mapper namespace="com.jt.mapper.UserAnnoMapper">
	<!--此标签用于开启全局的二级缓存-->
    <cache/>
    <select id="findAll" resultType="com.jt.pojo.User">
        select * from demo_user
    </select>
    <select id="findById" resultType="com.jt.pojo.User">
        select * from demo_user where id = #{id}
    </select>
</mapper>

如果是注解形式开发，则需要在src/main/com.jt.mapper.*Mapper中@Mapper注解同级添加@CacheNameSpace注解

@Mapper
@CacheNamespace
public interface UserAnnoMapper {

    @Select("select * from demo_user")
    List<User> findAll();

    @Select("select * from demo_user where id = #{id}")
    User findById(Integer id);
}