抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

SukiEva

首页

归档

分类

标签

关于

MyBatis

发布于：2022年6月30日

更新于：2022年7月3日

字数：3.6k 字

时长：18 分钟

次浏览

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。

  • 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。

  • 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

XML 配置

更多配置参考：官方文档 XML配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<?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>
    <!-- 读取数据库配置文件 -->
    <properties resource="jdbc.properties"/>
    <!-- 设置日志输出 -->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <!-- 注册实体类别名 -->
    <typeAliases>
        <!-- 单个注册别名 -->
        <typeAlias type="com.proj.Student" alias="student"/>
        <!-- 批量注册别名：类名的驼峰命名 -->
        <!-- <package name="com.proj"/> -->
    </typeAliases>
    <!-- 数据库配置 -->
    <environments default="development">
        <environment id="development">
            <!-- type：事务管理器
                JDBC：程序员管理
                MANAGED：Spring管理
            -->
            <transactionManager type="JDBC"/>
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 注册mapper -->
    <mappers>
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

数据库连接池：

一个中间层，初始化多个连接，建立连接从连接池取出，断开连接放回连接池，开销比直接连接断开小得多。

XML 映射

占位符的区别

  • #{}: 对非字符串参数的占位符，可以有效防止 SQL 注入
    • 入参是简单数据类型（除 String），#{} 内可以任意写
    • 入参是对象类型，#{} 内必须是对象成员变量名称
  • ${}: 对字符串的拼接替换，可以替换列名和表名，存在 SQL 注入风险，尽量少用
    • 入参是基本数据类型（有 String），${} 内必须是 value
    • 入参是对象类型，${} 内必须是对象成员变量名称

使用 #{} 防止 SQL 注入：

  1. 遇到模糊查询需要拼接字符串时：where name like '%${name}%'
  2. 使用 concat 函数改为：where name like concat('%',#{name},'%')

字符串替换只能使用 ${} ，详见下一节代码

创建映射配置文件

更多配置参考：官方文档 XML映射器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?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：命名空间（包名），用来区分不同文件中相同的id属性 -->
<mapper namespace="com.proj.mapper.UsersMapper">
    <!-- 查询全部数据 -->
    <select id="getAll" resultType="users">
        select id, username, birthday, sex, address
        from users
    </select>
    <!-- 通过主键id查询 -->
    <select id="getById" parameterType="int" resultType="users">
        select id, username, birthday, sex, address
        from users
        where id = #{id}
    </select>
    <!-- 通过名称模糊查询 -->
    <select id="getByName" parameterType="string" resultType="users">
        select id, username, birthday, sex, address
        from users
        where username like concat('%', #{userName}, '%')
    </select>
    <!-- 插入数据
         - 参数对应实体类属性
         - 获取插入后的主键id
    -->
    <insert id="insert" parameterType="users">
        <selectKey keyProperty="id" resultType="int" order="AFTER">
            select last_insert_id()
        </selectKey>
        insert into users (username, birthday, sex, address)
        values (#{userName}, #{birthday}, #{sex}, #{address})
    </insert>
    <!-- 按主键删除数据 -->
    <delete id="delete" parameterType="int">
        delete
        from users
        where id = #{id}
    </delete>
    <!-- 更新数据 -->
    <update id="update" parameterType="users">
        update users
        set username=#{userName},
            birthday=#{birthday},
            sex=#{sex},
            address=#{address}
        where id = #{id}
    </update>
    <!-- 参数超过一个参数就不写 -->
    <select id="getByNameOrAddress" resultType="users">
        select id, username, birthday, sex, address
        from users
        where ${col} like concat('%', #{val}, '%')
    </select>
</mapper>

测试使用

增删改需要 commit ！！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class MyTest {
    SqlSession sqlSession;

    @Before
    public void openSqlSession() throws IOException {
        // 文件流读取核心配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 创建SqlSessionFactory工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        // 取出sqlSession对象
        sqlSession = factory.openSession();
    }

    @After
    public void closeSqlSession() {
       // 关闭sqlSession
        sqlSession.close();
    }    

    @Test
    public void test() {
        // 完成查询操作
        List<Student> list = sqlSession.selectList("om.proj.mapper.UsersMapper");
        list.forEach(System.out::println);
        // 增删改需要commit
        // sqlSession.commit();
    }
}

动态代理

动态代理后就不需要从 xml 中取出执行方法，通过统一的代理接口直接调用。

创建代理接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.proj.mapper;

import com.proj.pojo.Users;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface UsersMapper {

    List<Users> getAll();

    Users getById(int id);

    List<Users> getByName(String userName);

    int insert(Users users);

    int delete(int id);

    int update(Users users);
    
    // 多个参数使用@Param
    List<Users> getByNameOrAddress(
            @Param("col")
            String col,
            @Param("val")
            String val
    );
}

修改配置文件

更改为代理接口的 reference

1
2
3
4
5
6
7
8
9
<mappers>
     <!-- 修改前
    <mapper resource="StudentMapper.xml"/>
-->
    <!-- 单个注册 -->
    <mapper class="com.proj.mapper.UsersMapper"/>
    <!-- 批量注册：推荐 -->
    <package name="com.proj.mapper"/>
</mappers>

测试使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class MyTest {

    SqlSession sqlSession;
    UsersMapper usersMapper;
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");


    @Before
    public void openSqlSession() throws IOException {
        // 文件流读取核心配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 创建SqlSessionFactory工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        // 取出sqlSession对象
        sqlSession = factory.openSession();
        // 动态代理对象
        usersMapper = sqlSession.getMapper(UsersMapper.class);
    }

    @After
    public void closeSqlSession() {
        // 关闭sqlSession
        sqlSession.close();
    }

    @Test
    public void testGetAll() {
        List<Users> list = usersMapper.getAll();
        list.forEach(System.out::println);   
    }
  
    @Test
    public void testGetByNameOrAddress(){
        //  List<Users> list1 = usersMapper.getByNameOrAddress("username","小");
        //  list1.forEach(System.out::println);
        List<Users> list2= usersMapper.getByNameOrAddress("address","市");
        list2.forEach(System.out::println);
    }
    
    @Test
    public void testInsert() throws ParseException {
        Users u = new Users("新增", dateFormat.parse("2000-01-01"), "1", "北京市");
        int num = usersMapper.insert(u);
        sqlSession.commit();
        // 获取主键
        System.out.println(u.getId());
    }

动态 SQL

官方文档：动态SQL

动态 SQL 使条件判断更为简单：

  • 定义代码片段
  • 逻辑判断
  • 循环（批量）处理

<sql> 和 <include>

  • <sql>：定义代码片段
  • <include>：使用代码片段。
1
2
3
4
5
6
7
8
9
10
11
12
<mapper namespace="com.proj.mapper.UsersMapper">
    <!-- 定义代码片段 -->
    <sql id="allCols">
        id, username, birthday, sex, address
    </sql>
    <!-- 查询全部数据 -->
    <select id="getAll" resultType="users">
        select
        <include refid="allCols"/>
        from users
    </select>
</mapper>

<if>

  • <if>：条件判断

<where>

  • <where>：多条件拼接，在查删改使用

多条件拼接：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<select id="getByCondition" parameterType="users" resultType="users">
       select
       <include refid="allCols"/>
       from users
       <where>
           <if test="userName!=null and userName!=''">
               and username like concat('%',##{userName},'%')
           </if>
           <if test="birthday!=null">
               and birthday=##{userName}
           </if>
           <if test="sex!=null and sex!=''">
               and sex=##{sex}
           </if>
           <if test="address!=null and address!=''">
               and address like concat('%',##{address},'%')
           </if>
       </where>
   </select>

测试：

1
2
3
4
5
6
7
8
@Test
public void testGetByCondition() {
    Users u = new Users();
    u.setSex("1");
    u.setUserName("小");
    List<Users> list = usersMapper.getByCondition(u);
    list.forEach(System.out::println);
}

<set>

  • set：有选择地进行更新处理，至少更新一列

有选择地更新：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<update id="updateBySet" parameterType="users">
       update users
       <set>
           <if test="userName!=null and userName!=''">
               username=##{userName},
           </if>
           <if test="birthday!=null">
               birthday=##{userName},
           </if>
           <if test="sex!=null and sex!=''">
               sex=##{sex},
           </if>
           <if test="address!=null and address!=''">
               address=##{address},
           </if>
       </set>
       where id = ##{id}
   </update>

测试：

1
2
3
4
5
6
7
8
@Test
public void testUpdateBySet(){
    Users u = new Users();
    u.setId(3);
    u.setUserName("新名字");
    usersMapper.updateBySet(u);
    sqlSession.commit();
}

<foreach>

  • <foreach>：循环遍历，完成循环条件查询，批量增删改

批量操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  <select id="getByIds" resultType="users">
      select
      <include refid="allCols"/>
      from users
      where id in
      <foreach collection="array" item="item" separator="," open="(" close=")">
          ##{item}
      </foreach>
  </select>
<insert id="insertBatch">
      insert into users (username, birthday, sex, address)
      values
      <foreach collection="list" item="u" separator=",">
          (##{u.userName}, #{u.birthday}, #{u.sex}, #{u.address})
      </foreach>
  </insert>

测试：

1
2
3
4
5
6
@Test
public void testGetByIds() {
    Integer[] array = {2, 4, 6};
    List<Users> list = usersMapper.getByIds(array);
    list.forEach(System.out::println);
}

批量更新

允许多行操作：在 jdbc.properties 中的数据库 url 中添加 &allowMultiQueries=true

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<update id="updateBySet" parameterType="users">
      <foreach collection="list" item="u" separator=";">
      update users
      <set>
          <if test="u.userName!=null and u.userName!=''">
              username=#{u.userName},
          </if>
          <if test="u.birthday!=null">
              birthday=#{u.userName},
          </if>
          <if test="u.sex!=null and u.sex!=''">
              sex=#{u.sex},
          </if>
          <if test="u.address!=null and u.address!=''">
              address=#{u.address},
          </if>
      </set>
      where id = #{u.id}
      </foreach>
  </update>

Map

入参多个

入参多个，可以指定参数位置传参，是实体类包含不住的条件。

实体类只能封装成员变量的条件，如果某个成员变量有区间范围的判断，或有两个值处理，则实体类无法包含。

根据生日范围查询：

1
2
3
4
5
6
7
8
9
   <!--
    List<Users> getByBirthday(Date begin, Date end);
 -->
<select id="getByBirthday" resultType="users">
       select
       <include refid="allCols"/>
       from users
       where birthday between #{arg0} and #{arg1}
   </select>

也可以和动态代理里一样，用 @param 区分参数

入参 Map

入参超过 1 个以上，使用 map 封装查询条件，查询条件更明确。

map 的 key 和 xml 中的参数名对应

1
2
3
4
5
6
7
8
9
    <!--
      List<Users> getByMap(Map map);
 -->
<select id="getByMap" resultType="users">
       select
       <include refid="allCols"/>
       from users
       where birthday between #{birthdayBegin} and #{birthdayEnd}
   </select>

返回 Map

如果返回的数据实体类无法包含，可以使用 map 返回多张表的数据，返回数据没有任何关系，都是 Object 类型。

返回的 map 的 key 是列名或别名。

返回一行 map

1
2
3
4
5
6
7
8
9
   <!--
   Map getMap(Integer id);
-->
<select id="getMap" parameterType="int" resultType="map">
       select
       <include refid="allCols"/>
       from users
       where id=#{id}
   </select>
1
2
3
4
5
6
@Test
public void testGetResultMap(){
    Map map = usersMapper.getMap(1);
    System.out.println(map);
    System.out.println(map.get("username"));
}

返回多行 map

1
2
3
4
5
6
7
8
   <!--
   List<Map> getMulMap();
-->
<select id="getMulMap" resultType="map">
       select
       <include refid="allCols"/>
       from users
   </select>

resultMap

使用 resultMap 手动完成映射：

  • property：实体类成员变量名
  • column：数据库列名
1
2
3
4
5
6
7
8
9
10
11
12
13
   <resultMap id="myMap" type="users">
       <!-- 主键绑定 -->
       <id property="id" column="id"/>
       <!-- 非主键绑定 -->
       <result property="userName" column="username"/>
   </resultMap>
<!--
   List<Users> getAllMap();
-->
<select id="getAllMap" resultMap="myMap">
       select id, username
       from users
   </select>
1
2
3
4
5
6
7
8
    @Test
    public void testGetAllMap() {
        List<Users> list = usersMapper.getAllMap();
        list.forEach(System.out::println);
    }
/* 没绑定的为空值
Users{id=1, userName='王五', birthday=null, sex='null', address='null'}
*/

一对多关系

一个老师有多个学生，假定

  • 老师：id、name、studentList
  • 学生：id、name
1
2
3
4
5
6
7
8
9
10
11
12
13
   <!-- 绑定老师 -->
<resultMap id="teacherMap" type="teachers">
       <!-- 主键绑定 -->
       <id property="id" column="id"/>
       <!-- 非主键绑定 -->
       <result property="name" column="name"/>
       <!-- 外键关联 -->
       <collection property="studentList" ofType="students">
       <!-- 绑定学生 -->
           <id property="id" column="id"/>
           <result property="name" column="name"/>
       </collection>
   </resultMap>

多对一关系

学生对应绑定的老师，假定

  • 老师：id、name、studentList
  • 学生：id、name、teacher
1
2
3
4
5
6
7
8
9
10
11
12
13
   <!-- 绑定学生 -->
<resultMap id="studentMap" type="students">
       <!-- 主键绑定 -->
       <id property="id" column="id"/>
       <!-- 非主键绑定 -->
       <result property="name" column="name"/>
       <!-- 外键关联 -->
       <association property="teacher" javaType="teacher"> <!-- javaType是方法返回值类型 -->
       <!-- 绑定老师 -->
           <id property="id" column="id"/>
           <result property="name" column="name"/>
       </association>
   </resultMap>

studentList 不用绑定，否则循环绑死

一对一关系

一个班级对应一个班级，一个班级对应一个老师。

用 association

多对多关系

一个文章对应多个标签，一个标签对应多个文章，两个表就是多对多关系。

通过建立中间表处理多对多关联。

用 collection

无论什么关联关系：

  • 一方持有另一方的集合，使用 <collection>
  • 一方持有另一方的对象，使用 <association>

事务

简而言之，多个 CRUD 操作对应一个事务操作。

在 MyBatis 框架中设置事务：

  • <transactionManager type="JDBC"/>：程序员自己控制提交和回滚

可设置为自动提交：

  • sqlSession = factory.openSession(true);：默认是 false，手动提交之后不需要手动 commit

缓存

Mybatis 提供两级缓存：一级缓存和二级缓存，默认开启一级缓存。

查询流程

缓存查询流程：

  1. 查询先查缓存，如果没有则查询数据库，存在缓存中，再返回给客户端
  2. 下次访问相同查询时，直接从缓存返回
  3. 如果数据库发生 commit 操作，则清空缓存

作用域

  • 一级缓存：使用 sqlSession 的作用域，同一个 sqlSession 共享一级缓存的数据
  • 二级缓存：使用 mapper 的作用域，不同 sqlSession 只要访问同一个 mapper.xml 文件，则共享二级缓存的数据。

ORM（Object Relational Mapping）即对象关系映射：

Java 语言中以对象的方式操作数据，数据库中以表的方式存储，对象中的成员变量与表中的列之间的数据互换。

本文由 SukiEva 创作，如果您觉得本文不错，请随意赞赏

博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议

本文永久链接是：http://blog.sukiu.top/Framework/SSM/MyBatis/

您的喜欢是作者写作最大的动力！

FrameworkSSM

MyBatis

SSM

评论



Copyright 2022 SukiEva

Modify from Volantis theme Powered by Hexo