别人已经整理好的笔记博客

MyBatis笔记_苍茗的博客-CSDN博客

一、Mybatis简介

1. 历史

  • MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github
  • iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

2. 特性

  1. MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
  2. MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
  3. MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录
  4. MyBatis 是一个 半自动的ORM（Object Relation Mapping）框架

3. 下载

GitHub - mybatis/mybatis-3: MyBatis SQL mapper framework for Java
下载最新版本
image.png

4. 和其他持久层技术横向比较

  • 原生JDBC
    • SQL夹杂在Java代码中，造成代码的耦合度较高。
    • 维护成本过高，且需要在代码中对SQL语句进行频繁的修改
    • 代码冗长，开发效率比较低
  • Hibernate和JPA
    • 操作比较简便，开发效率较高
    • 内部可以自动生成SQL，但是集成度太高，不容易做特殊的优化
    • 基于全映射的全自动框架，大量字段的POJO进行部分映射的时候比较困难
    • 反射操作太多，造成数据库的性能下降
  • Mybatis
    • 比较轻量，性能也很出色
    • SQL和Java代码分离开来。Java代码专注于业务需求，SQL语句专注于对数据的管理
    • 开发效率虽然比不上JPA，但是仍然可以接受

二、Mybatis环境的搭建

1. IDEA开发插件

  • MybatisHelperPro：1.1.0
  • MybatisX：1.5.2

image.png

2. 创建Maven工程

配置打包方式，并引入依赖

  1.   <packaging>jar</packaging>
  2.   <dependencies>
  3.       <dependency>
  4.           <groupId>org.mybatis</groupId>
  5.           <artifactId>mybatis</artifactId>
  6.           <version>3.5.7</version>
  7.       </dependency>
  8.       <dependency>
  9.           <groupId>junit</groupId>
  10.           <artifactId>junit</artifactId>
  11.           <version>4.13.2</version>
  12.           <scope>test</scope>
  13.       </dependency>
  14.       <dependency>
  15.           <groupId>mysql</groupId>
  16.           <artifactId>mysql-connector-java</artifactId>
  17.           <version>5.1.47</version>
  18.       </dependency>
  19.       <dependency>
  20.           <groupId>log4j</groupId>
  21.           <artifactId>log4j</artifactId>
  22.           <version>1.2.12</version>
  23.       </dependency>
  24.       <dependency>
  25.           <groupId>org.projectlombok</groupId>
  26.           <artifactId>lombok</artifactId>
  27.           <version>1.18.22</version>
  28.       </dependency>
  29.   </dependencies>

3. 创建Mybatis的核心配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。 核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息 核心配置文件存放的位置是src/main/resources目录下

  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE configuration  
  3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-config.dtd">  
  5. <configuration>  
  6.     <!--设置连接数据库的环境-->  
  7.     <environments default="development">  
  8.         <environment id="development">  
  9.             <transactionManager type="JDBC"/>  
  10.             <dataSource type="POOLED">  
  11.                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>  
  12.                 <property name="url" value="jdbc:mysql://localhost:3306/MyBatis"/>  
  13.                 <property name="username" value="root"/>  
  14.                 <property name="password" value="123456"/>  
  15.             </dataSource>  
  16.         </environment>  
  17.     </environments>  
  18.     <!--引入映射文件-->  
  19.     <mappers>  
  20.         <mapper resource="mappers/UserMapper.xml"/>  
  21.     </mappers>  
  22. </configuration>

4. 创建数据库表和实体类

在数据库中创建我们要存储数据所对应的表，然后在Java中编写对应的实体类。

相关概念：ORM（Object Relationship Mapping）对象关系映射 对象：Java的实体类对象 关系：关系型数据库 映射：二者之间的对应关系

Java概念 数据库概念
类 表
属性 字段/列
对象 记录/行

image.png

  1. package com.clevesheep.mybatis2.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  6. /**
  7. * Created By Intellij IDEA
  8. *
  9. * @author Xinrui Yu
  10. * @date 2022/3/24 16:21 星期四
  11. */
  12. @Data
  13. @AllArgsConstructor
  14. public class User {
  15.     private Integer id;
  16.     private String username;
  17.     private String password;
  18.     private Integer age;
  19.     private String gender;
  20.     private String email;
  21. }

5. 创建Mapper接口

MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类

  1. package com.atguigu.mybatis.mapper;  
  3. public interface UserMapper {  
  4.     /**  
  5.     * 添加用户信息  
  6.     */  
  7.     int insertUser();  
  8. }

6. 创建Mybatis的mapper映射文件

  • 映射文件的命名规则：
    • 表所对应的实体类名称+Mapper.xml
    • 一个映射文件对应一个实体类，对应一张表的操作
    • Mybatis的映射文件用来编写SQL语句，访问和操作数据库中的数据
    • Mybatis的映射文件存放的位置是 src/main/resources/mappers目录下

  • Mybatis可以面向接口操作数据，但是要保证一定的规范

    • mapper接口的全类名，要和映射文件的名称空间namespace保持一致
    • mapper接口中方法的方法名，要和映射文件中编写SQL的标签的id保持一致
      1. <?xml version="1.0" encoding="UTF-8" ?>  
      2. <!DOCTYPE mapper  
      3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
      4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
      5. <mapper namespace="com.atguigu.mybatis.mapper.UserMapper">  
      6. <!--int insertUser();--> 
      7. <insert id="insertUser">  
      8. insert into t_user values(null,'张三','123',23,'女')  
      9. </insert>  
      10. </mapper>

      7. 通过Junit测试方法

  • SqlSession：代表的是Java程序和数据库之间的会话

  • SqlSessionFactory：生成SqlSession的工厂类，使用的是工厂模式
  • 工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象
    1. public class UserMapperTest {
    2.   @Test
    3.   public void testInsertUser() throws IOException {
    4.       //读取MyBatis的核心配置文件
    5.       InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    6.       //获取SqlSessionFactoryBuilder对象
    7.       SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    8.       //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
    9.       SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    10.       //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
    11.       //SqlSession sqlSession = sqlSessionFactory.openSession();
    12.       //创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交  
    13.       SqlSession sqlSession = sqlSessionFactory.openSession(true);
    14.       //通过代理模式创建UserMapper接口的代理实现类对象
    15.       UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    16.       //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
    17.       int result = userMapper.insertUser();
    18.       //提交事务
    19.       //sqlSession.commit();
    20.       System.out.println("result:" + result);
    21.   }
    22. }

    由于配置Mybatis的时候，使用到的事务管理器是原生的JDBC，因此，我们需要手动的来使用sqlSession.commit()来提交我们的事务。或者，在创建sqlSession对象的时候，传入一个boolean值的参数，来表示我们希望使用自动提交的方式提交事务 SqlSession sqlSession = sqlSessionFactory.openSession(true);

8. 加入log4j的日志功能

  • 引入依赖
  • 加入配置文件
    • 文件名为：log4j.xml，存放位置为：src/main/resources 目录下
    • 日志的级别：FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试) 从左到右打印的内容越来越详细 ```xml <?xml version=”1.0” encoding=”UTF-8” ?> <!DOCTYPE log4j:configuration SYSTEM “log4j.dtd”> 
  2. <a name="itC7O"></a>
  3. # 三、核心配置文件详解
  4. ```xml
  5. <?xml version="1.0" encoding="UTF-8" ?>
  6. <!DOCTYPE configuration
  7.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  8.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  9. <configuration>
  11.     <!--
  12.     mybatis核心配置文件的标签具有一定的顺序，某些标签使用不到的时候可以不写
  13.     但是如果使用到了，就一定要按照对应的顺序编写
  14.     properties、settings、typeAliases、typeHandlers、
  15.     objectFactory、objectWrapperFactory、reflectorFactory、
  16.     plugins、environments、databaseIdProvider、mappers
  17.     -->
  19.     <!--
  20.         引入properties文件
  21.     -->
  22.     <properties resource="jdbc.properties"/>
  24.     <!--设置类型别名-->
  25.     <typeAliases>
  26.         <!--
  27.             typeAlias：设置类型别名
  28.             属性alias用来表示设置的别名，也可以不设置，那么默认的别名就是类的名称
  29.         -->
  30. <!--        <typeAlias type="com.clevesheep.mybatis2.pojo.User" />-->
  31.         <!--
  32.             package：以包为单位，将其下所有类的别名都设置为默认的别名（类名）
  33.         -->
  34.         <package name="com.clevesheep.mybatis2.pojo"/>
  35.     </typeAliases>
  37.     <!--
  38.         environments:配置多个连接数据库的环境
  39.         属性：
  40.             default:默认数据库连接环境的id
  41.     -->
  42.     <environments default="development">
  43.         <!--
  44.             environment:配置单个连接数据库的环境
  45.             属性：
  46.                 id: 数据库连接的唯一标识
  47.         -->
  48.         <environment id="development">
  49.             <!--
  50.                 transactionManager:配置数据库事务的管理方式
  51.                 属性：
  52.                     type：JDBC|MANGED
  53.                         JDBC：在当前环境下执行SQL的时候，使用的是原生JDBC进行事务管理，默认需要我们手动提交和回滚事务
  54.                         MANGED：事务管理交由别处进行管理，例如Spring
  55.             -->
  56.             <transactionManager type="JDBC"/>
  58.             <!--
  59.                 dataSource: 配置数据源信息
  60.                 属性：
  61.                     type: POOLED|UNPOOLED|JNDI
  62.                     POOLED: 表示使用数据库连接池缓存数据库连接
  63.                     UNPOOLED：表示不使用数据库连接池缓存
  64.                     JNDI：使用上下文的数据源
  65.             -->
  66.             <dataSource type="POOLED">
  67.                 <property name="driver" value="${datasource.driver}"/>
  68.                 <property name="url" value="${datasource.url}"/>
  69.                 <property name="username" value="${datasource.username}"/>
  70.                 <property name="password" value="${datasource.password}"/>
  71.             </dataSource>
  72.         </environment>
  73.     </environments>
  74.     <!--引入映射文件-->
  75.     <mappers>
  76.         <mapper resource="mappers/UserMapper.xml"/>
  77.         <!--
  78.             引入mapper的配置文件的时候，同样可以采用package的方式进行映射
  79.             这样可以不用再每次新建一个mapper的时候，都要重新修改核心配置文件
  80.             使用package引入配置文件的注意点：
  81.             1. mapper所在接口的包要和映射文件所在的包一致
  82.             2. mapper接口要和映射文件的名字一致
  83.             个人更喜欢使用一个个mapper标签引入
  84.         -->
  85. <!--        <package name=""/>-->
  86.     </mappers>
  87. </configuration>

四、默认的类型别名

image.png
image.png

五、Mybatis实现简单的增删改查

1. 增加

  1. <!--int insertUser();-->
  2. <insert id="insertUser">
  3.     insert into t_user values(null,'admin','123456',23,'男','12345@qq.com')
  4. </insert>

2. 删除

  1. <!--int deleteUser();-->
  2. <delete id="deleteUser">
  3.     delete from t_user where id = 6
  4. </delete>

3. 修改

  1. <!--int updateUser();-->
  2. <update id="updateUser">
  3.     update t_user set username = '张三' where id = 5
  4. </update>

4. 查询一个实体类对象

  1. <!--User getUserById();-->  
  2. <select id="getUserById" resultType="User">  
  3.     select * from t_user where id = 2  
  4. </select>

5. 查询集合

  1. <!--List<User> getUserList();-->
  2. <select id="getUserList" resultType="User">
  3.     select * from t_user
  4. </select>

查询的标签 select * from t_user where username = #{username} 

  1. ```xml
  2. <!--User getUserByUsername(String username);-->
  3. <select id="getUserByUsername" resultType="User">  
  4.     select * from t_user where username = '${username}'  
  5. </select>

2. 多个字面量类型的参数

  • 如果mapper接口中参数是多个的时候，此时Mybatis会自动将这些参数放在一个Map集合中
    • 以arg0,arg1…为键，参数为值
    • 以param1,param2…为键，参数为值
  • 因此只需要通过${}或#{}来获取对应的值
  • 注意使用${}的时候，要手动加上单引号 ```xml 
  1. ```xml
  2. <!--User checkLogin(String username,String password);-->
  3. <select id="checkLogin" resultType="User">
  4.     select * from t_user where username = '${param1}' and password = '${param2}'
  5. </select>

3. Map类型的参数

  • 若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号 ```xml 
  1. ```java
  2. @Test
  3. public void checkLoginByMap() {
  4.     SqlSession sqlSession = SqlSessionUtils.getSqlSession();
  5.     ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
  6.     Map<String,Object> map = new HashMap<>();
  7.     map.put("usermane","admin");
  8.     map.put("password","123456");
  9.     User user = mapper.checkLoginByMap(map);
  10.     System.out.println(user);
  11. }

4. 实体类型的参数

  • 若mapper接口中的方法参数为实体类对象时此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号

    1. <!--int insertUser(User user);-->
    2. <insert id="insertUser">
    3.   insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})
    4. </insert>
    1. @Test
    2. public void insertUser() {
    3.   SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    4.   ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    5.   User user = new User(null,"Tom","123456",12,"男","123@321.com");
    6.   mapper.insertUser(user);
    7. }

    5. 使用@Param注解标识参数

  • 可以通过@Param注解标识mapper接口中的方法参数，此时，会将这些参数放在map集合中

    1. 以@Param注解的value属性值为键，以参数为值；
    2. 以param1,param2…为键，以参数为值；
  • 只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号
    1. <!--User CheckLoginByParam(@Param("username") String username, @Param("password") String password);-->
    2.   <select id="CheckLoginByParam" resultType="User">
    3.       select * from t_user where username = #{username} and password = #{password}
    4.   </select>
    1. @Test
    2. public void checkLoginByParam() {
    3.   SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    4.   ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    5.   mapper.CheckLoginByParam("admin","123456");
    6. }

    6. 总结

    建议分成以下两种情况进行处理
  1. 实体类型的参数
  2. 使用@Param标识参数

七、Mybatis的各种查询功能

  1. 如果查询出的数据只有一条，可以通过
    1. 实体类对象接收
    2. List集合接收
    3. Map集合接收，结果{password=123456, sex=男, id=1, age=23, username=admin}
  2. 如果查询出的数据有多条，一定不能用实体类对象接收，会抛异常TooManyResultsException，可以通过
    1. 实体类类型的LIst集合接收
    2. Map类型的LIst集合接收
    3. 在mapper接口的方法上添加@MapKey注解

1. 查询一个实体类对象

  1. /**
  2.  * 根据用户id查询用户信息
  3.  * @param id
  4.  * @return
  5.  */
  6. User getUserById(@Param("id") int id);
  1. <!--User getUserById(@Param("id") int id);-->
  2. <select id="getUserById" resultType="User">
  3.     select * from t_user where id = #{id}
  4. </select>

2. 查询一个List集合

  1. /**
  2.  * 查询所有用户信息
  3.  * @return
  4.  */
  5. List<User> getUserList();
  1. <!--List<User> getUserList();-->
  2. <select id="getUserList" resultType="User">
  3.     select * from t_user
  4. </select>

3. 查询单个数据

  1. /**  
  2.  * 查询用户的总记录数  
  3.  * @return  
  4.  * 在MyBatis中，对于Java中常用的类型都设置了类型别名  
  5.  * 例如：java.lang.Integer-->int|integer  
  6.  * 例如：int-->_int|_integer  
  7.  * 例如：Map-->map,List-->list  
  8.  */  
  9. int getCount();
  1. <!--int getCount();-->
  2. <select id="getCount" resultType="_integer">
  3.     select count(id) from t_user
  4. </select>

4. 查询一条数据为Map集合

  1. /**  
  2.  * 根据用户id查询用户信息为map集合  
  3.  * @param id  
  4.  * @return  
  5.  */  
  6. Map<String, Object> getUserToMap(@Param("id") int id);
  1. <!--Map<String, Object> getUserToMap(@Param("id") int id);-->
  2. <select id="getUserToMap" resultType="map">
  3.     select * from t_user where id = #{id}
  4. </select>
  5. <!--结果：{password=123456, sex=男, id=1, age=23, username=admin}-->

5. 查询多条数据为Map集合

方法一：

  1. /**  
  2.  * 查询所有用户信息为map集合  
  3.  * @return  
  4.  * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取  
  5.  */  
  6. List<Map<String, Object>> getAllUserToMap();
  1. <!--Map<String, Object> getAllUserToMap();-->  
  2. <select id="getAllUserToMap" resultType="map">  
  3.     select * from t_user  
  4. </select>
  5. <!--
  6.     结果：
  7.     [{password=123456, sex=男, id=1, age=23, username=admin},
  8.     {password=123456, sex=男, id=2, age=23, username=张三},
  9.     {password=123456, sex=男, id=3, age=23, username=张三}]
  10. -->

方法二：

  1. /**
  2.  * 查询所有用户信息为map集合
  3.  * @return
  4.  * 将表中的数据以map集合的方式查询，一条数据对应一个map；
  5.  * 若有多条数据，就会产生多个map集合，并且最终要以一个map的方式返回数据，
  6.  * 此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合
  7.  */
  8. @MapKey("id")
  9. Map<String, Object> getAllUserToMap();
  1. <!--Map<String, Object> getAllUserToMap();-->
  2. <select id="getAllUserToMap" resultType="map">
  3.     select * from t_user
  4. </select>
  5. <!--
  6.     结果：
  7.     {
  8.     1={password=123456, sex=男, id=1, age=23, username=admin},
  9.     2={password=123456, sex=男, id=2, age=23, username=张三},
  10.     3={password=123456, sex=男, id=3, age=23, username=张三}
  11.     }
  12. -->

八、特殊SQL的执行

1. 模糊查询

  1. /**
  2.  * 根据用户名进行模糊查询
  3.  * @param username 
  4.  * @return java.util.List<com.atguigu.mybatis.pojo.User>
  5.  * @date 2022/2/26 21:56
  6.  */
  7. List<User> getUserByLike(@Param("username") String username);
  1. <!--List<User> getUserByLike(@Param("username") String username);-->
  2. <select id="getUserByLike" resultType="User">
  3.     <!--select * from t_user where username like '%${mohu}%'-->  
  4.     <!--select * from t_user where username like concat('%',#{mohu},'%')-->  
  5.     select * from t_user where username like "%"#{mohu}"%"
  6. </select>

  • 其中select * from t_user where username like "%"#{mohu}"%"是最常用的

    2. 批量删除

  • 只能使用${}，如果使用#{}，则解析后的sql语句为delete from t_user where id in ('1,2,3')，这样是将1,2,3看做是一个整体，只有id为1,2,3的数据会被删除。 正确的语句应该是delete from t_user where id in (1,2,3)，或者delete from t_user where id in ('1','2','3')

    1. /**
    2. * 根据id批量删除
    3. * @param ids 
    4. * @return int
    5. * @date 2022/2/26 22:06
    6. */
    7. int deleteMore(@Param("ids") String ids);
    1. <delete id="deleteMore">
    2.   delete from t_user where id in (${ids})
    3. </delete>
    1. //测试类
    2. @Test
    3. public void deleteMore() {
    4.   SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    5.   SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    6.   int result = mapper.deleteMore("1,2,3,8");
    7.   System.out.println(result);
    8. }

    3. 动态设置表名

  • 只能使用${}，因为表名不能加单引号

    1. /**
    2. * 查询指定表中的数据
    3. * @param tableName 
    4. * @return java.util.List<com.atguigu.mybatis.pojo.User>
    5. * @date 2022/2/27 14:41
    6. */
    7. List<User> getUserByTable(@Param("tableName") String tableName);
    1. <!--List<User> getUserByTable(@Param("tableName") String tableName);-->
    2. <select id="getUserByTable" resultType="User">
    3.   select * from ${tableName}
    4. </select>

    4. 添加功能获取自动递增的主键

  • 在mapper.xml中设置两个属性

    • useGeneratedKeys：设置使用自增的主键
    • keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中
      1. /**
      2. * 添加用户信息
      3. * @param user 
      4. * @date 2022/2/27 15:04
      5. */
      6. void insertUser(User user);
      1. <!--void insertUser(User user);-->
      2. <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
      3. insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})
      4. </insert>
      1. //测试类
      2. @Test
      3. public void insertUser() {
      4. SqlSession sqlSession = SqlSessionUtils.getSqlSession();
      5. SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
      6. User user = new User(null, "ton", "123", 23, "男", "123@321.com");
      7. mapper.insertUser(user);
      8. System.out.println(user);
      9. //输出：user{id=10, username='ton', password='123', age=23, sex='男', email='123@321.com'}，自增主键存放到了user的id属性中
      10. }

九、自定义映射resultMap

1. 通过resultMap来处理字段和属性之间的映射关系

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

  • 如果数据库表的字段名和类的属性名不一致，那么可以通过resultMap来设置自定义映射，那么此时，即使字段名和属性名一致也要映射，也就是全部的属性都要列出来

    1. <resultMap id="empResultMap" type="Emp">
    2.   <id property="eid" column="eid"></id>
    3.   <result property="empName" column="emp_name"></result>
    4.   <result property="age" column="age"></result>
    5.   <result property="sex" column="sex"></result>
    6.   <result property="email" column="email"></result>
    7. </resultMap>
    8. <!--List<Emp> getAllEmp();-->
    9. <select id="getAllEmp" resultMap="empResultMap">
    10.   select * from t_emp
    11. </select>

  • 若字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用_），实体类中的属性名符合Java的规则（使用驼峰）。此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系

    • 通过在SQL语句中，给字段起别名的方式，来保证实体类和数据表中的属性名保持一致

      1. <!--List<Emp> getAllEmp();-->
      2. <select id="getAllEmp" resultType="Emp">
      3. select eid,emp_name empName,age,sex,email from t_emp
      4. </select>

    • 在Mybatis的核心配置文件的setting中，进行配置

      1. <settings>
      2.  <setting name="mapUnderscoreToCamelCase" value="true"/>
      3. </settings>

      2. 多对一映射处理

      image.pngimage.png

      2.1 associationl来处理映射关系

  • association：处理多对一的映射关系

  • property：需要处理多对的映射关系的属性名

  • javaType：该属性的类型

    1. <resultMap id="empAndDeptResultMapTwo" type="Emp">
    2.   <id property="eid" column="eid"></id>
    3.   <result property="empName" column="emp_name"></result>
    4.   <result property="age" column="age"></result>
    5.   <result property="sex" column="sex"></result>
    6.   <result property="email" column="email"></result>
    7.   <association property="dept" javaType="Dept">
    8.       <id property="did" column="did"></id>
    9.       <result property="deptName" column="dept_name"></result>
    10.   </association>
    11. </resultMap>
    12. <!--Emp getEmpAndDept(@Param("eid")Integer eid);-->
    13. <select id="getEmpAndDept" resultMap="empAndDeptResultMapTwo">
    14.   select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid}
    15. </select>

    2.2 分步查询

    先查员工对应的部门id，然后通过部门id去部门表中查询部门的信息

  • select：对应SQL方法的唯一标识=>全类名.方法

  • column：被传入下一步查询的字段

    1. <resultMap id="empAndDeptByStepResultMap" type="Emp">
    2.   <id property="eid" column="eid"></id>
    3.   <result property="empName" column="emp_name"></result>
    4.   <result property="age" column="age"></result>
    5.   <result property="sex" column="sex"></result>
    6.   <result property="email" column="email"></result>
    7.   <association property="dept"
    8.                select="com.atguigu.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
    9.                column="did"></association>
    10. </resultMap>

    分步查询的优点：可以实现懒加载模式，但是必须在核心配置文件中设置全局的配置信息

    2.3 延迟加载（懒加载模式）

    需要在核心配置文件中进行配置

  • lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载

  • aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个属性会按需加载

  • 此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType=“lazy(延迟加载)|eager(立即加载)”

    1. <settings>
    2.   <setting name="lazyLoadingEnabled" value="true"/>
    3. </settings>
    1. @Test
    2. public void getEmpAndDeptByStepOne() {
    3.   SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    4.   EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    5.   Emp emp = mapper.getEmpAndDeptByStepOne(1);
    6.   System.out.println(emp.getEmpName());
    7. }

  • 关闭延迟查询，两条SQL会一起执行

  • 开启延迟加载，只执行获取Employee的SQL
  • 开启后，只有需要用到Employee中的Department时候才会调用相应查询的SQL语句
  • fetchType：当开启了全局的延迟加载之后，可以通过该属性手动控制延迟加载的效果

fetchType=lazy(延迟加载)|eager(立即加载)

  1. <resultMap id="empAndDeptByStepResultMap" type="Emp">
  2.     <id property="eid" column="eid"></id>
  3.     <result property="empName" column="emp_name"></result>
  4.     <result property="age" column="age"></result>
  5.     <result property="sex" column="sex"></result>
  6.     <result property="email" column="email"></result>
  7.     <association property="dept"
  8.                  select="com.atguigu.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
  9.                  column="did"
  10.                  fetchType="lazy"></association>
  11. </resultMap>

3. 一对多映射处理

image.png

3.1 collection

  • collection：用来处理一对多的映射关系

  • ofType：表示该属性对应集合中存储的数据类型（或类名）

    1. <resultMap id="getAllEmployeesByDeptIdResultMap" type="Department">
    2.   <id property="deptId" column="dept_id" />
    3.   <result property="deptName" column="dept_name" />
    4.   <result property="deptLocation" column="dept_location" />
    5.   <collection property="employees" ofType="Employee">
    6.       <id property="empId" column="emp_id" />
    7.       <result property="empName" column="emp_name"/>
    8.       <result property="empPhone" column="emp_phone" />
    9.       <result property="empGender" column="emp_gender" />
    10.   </collection>
    11. </resultMap>

    3.2 分步查询

    先通过部门id查询部门的信息，然后通过部门id去员工表中查询所有的员工信息

    1. <resultMap id="getAllEmployeesByDeptIdAndStepResultMap" type="Department">
    2.   <id property="deptId" column="dept_id" />
    3.   <result property="deptName" column="dept_name" />
    4.   <result property="deptLocation" column="dept_location" />
    5.   <!--同样可以设置为懒加载模式-->
    6.   <collection property="employees"
    7.               select="com.clevesheep.mybatis3.mapper.EmployeeMapper.getAllByDeptId"
    8.               column="dept_id"
    9.               fetchType="lazy"/>
    10. </resultMap>
    1. <select id="getAllByDeptId" resultType="Employee">
    2.     select * from t_emp where dept_id = #{dept_id}
    3. </select>

    十、动态SQL

    1. IF标签

  • if标签可通过test属性（即传递过来的数据）的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行

  • 在where后面添加一个恒成立条件1=1

    • 这个恒成立条件并不会影响查询的结果
    • 这个1=1可以用来拼接and语句，例如：当empName为null时
      • 如果不加上恒成立条件，则SQL语句为select * from t_emp where and age = ? and sex = ? and email = ?，此时where会与and连用，SQL语句会报错
      • 如果加上一个恒成立条件，则SQL语句为select * from t_emp where 1= 1 and age = ? and sex = ? and email = ?，此时不报错
        1. <!--List<Emp> getEmpByCondition(Emp emp);-->
        2. <select id="getEmpByCondition" resultType="Emp">
        3. select * from t_emp where 1=1
        4. <if test="empName != null and empName !=''">
        5. and emp_name = #{empName}
        6. </if>
        7. <if test="age != null and age !=''">
        8. and age = #{age}
        9. </if>
        10. <if test="sex != null and sex !=''">
        11. and sex = #{sex}
        12. </if>
        13. <if test="email != null and email !=''">
        14. and email = #{email}
        15. </if>
        16. </select>

        2. WHERE标签

  • where和if一般结合使用：

    • 若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
    • 若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and/or去掉
      1. <!--List<Emp> getEmpByCondition(Emp emp);-->
      2. <select id="getEmpByCondition" resultType="Emp">
      3. select * from t_emp
      4. <where>
      5.    <if test="empName != null and empName !=''">
      6.        emp_name = #{empName}
      7.    </if>
      8.    <if test="age != null and age !=''">
      9.        and age = #{age}
      10.    </if>
      11.    <if test="sex != null and sex !=''">
      12.        and sex = #{sex}
      13.    </if>
      14.    <if test="email != null and email !=''">
      15.        and email = #{email}
      16.    </if>
      17. </where>
      18. </select>

  • 注意：where标签不能去掉条件后多余的and/or

    1. <!--这种用法是错误的，只能去掉条件前面的and/or，条件后面的不行-->
    2. <if test="empName != null and empName !=''">
    3. emp_name = #{empName} and
    4. </if>
    5. <if test="age != null and age !=''">
    6.   age = #{age}
    7. </if>

    3. choose、when、otherwise

  • choose、when、otherwise相当于if...else if..else

  • when至少要有一个，otherwise至多只有一个

    1. <select id="getEmpByChoose" resultType="Emp">
    2.   select * from t_emp
    3.   <where>
    4.       <choose>
    5.           <when test="empName != null and empName != ''">
    6.               emp_name = #{empName}
    7.           </when>
    8.           <when test="age != null and age != ''">
    9.               age = #{age}
    10.           </when>
    11.           <when test="sex != null and sex != ''">
    12.               sex = #{sex}
    13.           </when>
    14.           <when test="email != null and email != ''">
    15.               email = #{email}
    16.           </when>
    17.           <otherwise>
    18.               did = 1
    19.           </otherwise>
    20.       </choose>
    21.   </where>
    22. </select>

    4. foreach标签

  • 属性：

    • collection：设置要循环的数组或集合
    • item：表示集合或数组中的每一个数据
    • separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如,
    • open：设置foreach标签中的内容的开始符
    • close：设置foreach标签中的内容的结束符

  • 举例

    • 批量删除

      1. <!--int deleteMoreByArray(Integer[] eids);-->
      2. <delete id="deleteMoreByArray">
      3. delete from t_emp where eid in
      4. <foreach collection="eids" item="eid" separator="," open="(" close=")">
      5.    #{eid}
      6. </foreach>
      7. </delete>
      1. @Test
      2. public void deleteMoreByArray() {
      3. SqlSession sqlSession = SqlSessionUtils.getSqlSession();
      4. DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
      5. int result = mapper.deleteMoreByArray(new Integer[]{6, 7, 8, 9});
      6. System.out.println(result);
      7. }

      image.png

    • 批量添加

      1. <!--int insertMoreByList(@Param("emps") List<Emp> emps);-->
      2. <insert id="insertMoreByList">
      3. insert into t_emp values
      4. <foreach collection="emps" item="emp" separator=",">
      5.    (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
      6. </foreach>
      7. </insert>
      1. @Test
      2. public void insertMoreByList() {
      3. SqlSession sqlSession = SqlSessionUtils.getSqlSession();
      4. DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
      5. Emp emp1 = new Emp(null,"a",1,"男","123@321.com",null);
      6. Emp emp2 = new Emp(null,"b",1,"男","123@321.com",null);
      7. Emp emp3 = new Emp(null,"c",1,"男","123@321.com",null);
      8. List<Emp> emps = Arrays.asList(emp1, emp2, emp3);
      9. int result = mapper.insertMoreByList(emps);
      10. System.out.println(result);
      11. }

      image.png

      5. SQL标签

      <sql />标签用来记录一段SQL片段，在使用的地方可以使用<include />标签进行引入
      声明SQL标签：<sql>
      使用SQL标签：<include>

      十一、Mybatis的缓存

      1. 一级缓存

  • 一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会进行缓存保留，下次查询相同数据的时候就会直接从缓存中获取，而不会从数据库中重新访问。

  • 一级缓存失效的四种情况
    1. 不同的SqlSession对应不同的一级缓存
    2. 同一个SqlSession但是查询条件不同
    3. 同一个SqlSession两次查询期间执行了任何一次增删改操作
    4. 同一个SqlSession两次查询期间手动清空了缓存

2. 二级缓存

  • 二级缓存是SqlSessionFactory级别的，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取
  • 二级缓存的开启方式
    • 核心配置文件中，设置全局配置属性cacheEnabled="true"，默认就是true，无需进行设置
    • 在映射文件中设置对应的标签<cache />
    • 二级缓存必须在SqlSession关闭或提交之后生效
    • 查询的数据对应的实体类必须实现序列化接口
  • 二级缓存失效的情况：两个查询之间进行了任意的增删改操作，会导致一级和二级缓存同时失效

3. Mybatis缓存查询的顺序

  1. 首先查询二级缓存，因为二级缓存中可能有已经查询出来的数据
  2. 如果二级缓存未命中，则再查询一级缓存
  3. 如果一级缓存也未命中，那么则查询数据库
  4. SqlSession关闭之后，对应的一级缓存会写入二级缓存，供其他程序调用