MyBatis学习笔记（二）

发布于：2023-01-21 ⋅ 阅读:(502) ⋅ 点赞:(0)
微信交流群：https://732903.hlcode.cn/?id=NK1fWUR

一、自定义映射 resultMap

1.1 resultMap 处理字段和属性的映射关系

若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射

<!--
        字段名和属性名不一致的情况，如何处理映射关系
        1、为查询的字段设置别名，和属性名保持一致
        2、当字段符合MySQL的要求使用_，而属性符合java的要求使用驼峰
        此时可以在MyBatis的核心配置文件中设置一个全局配置，可以自动将下划线映射为驼峰
        emp_id:empId,emp_name:empName
        3、使用resultMap自定义映射处理
        处理多对一的映射关系：
        1、级联方式处理
        2、association
        3、分步查询

        处理一对多的映射关系：
        1、collection
        2、分步查询
    -->
  <!--
      resultMap：设置自定义的映射关系
      id：唯一标识
      type：处理映射关系的实体类的类型
      常用的标签：
      id：处理主键和实体类中属性的映射关系
      result：处理普通字段和实体类中属性的映射关系
      association：处理多对一的映射关系（处理实体类类型的属性）
      collection：处理一对多的映射关系（处理集合类型的属性）
      column：设置映射关系中的字段名，必须是sql查询出的某个字段
      property：设置映射关系中的属性的属性名，必须是处理的实体类类型中的属性名
  -->
  <resultMap id="empResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="gender" property="gender"></result>
  </resultMap>

  <!--Emp getEmpByEmpId(@Param("empId") Integer empId);-->
  <select id="getEmpByEmpId" resultMap="empResultMap">
    select * from t_emp where emp_id = #{empId}
  </select>

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

  • 可以通过为字段起别名的方式，保证和实体类中的属性名保持一致

  • 可以在MyBatis的核心配置文件中设置一个全局配置信息mapUnderscoreToCamelCase，可以在查询表中数据时，自动将_类型的字段名转换为驼峰

例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为userName

1.2 多对一映射处理

场景模拟：

查询员工信息以及员工所对应的部门信息

  • 级联方式处理映射关系

    <resultMap id="empAndDeptResultMapOne" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="gender" property="gender"></result>
    <result column="dept_id" property="dept.deptId"></result>
    <result column="dept_name" property="dept.deptName"></result>
  </resultMap>
  <!--Emp getEmpAndDeptByEid(@Param("eid") int eid);--> 
  <select id="getEmpAndDeptByEid" resultMap="empDeptMap"> select emp.*,dept.* from t_emp emp left join t_dept dept on emp.did = dept.did where emp.eid = #{eid} 
  </select>

  • 使用association处理映射关系

    <resultMap id="empAndDeptResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="gender" property="gender"></result>
    <!--
        association：处理多对一的映射关系（处理实体类类型的属性）
        property：设置需要处理映射关系的属性的属性名
        javaType：设置要处理的属性的类型
    -->
    <association property="dept" javaType="Dept">
      <id column="dept_id" property="deptId"></id>
      <result column="dept_name" property="deptName"></result>
    </association>
  </resultMap>
  <!--Emp getEmpAndDeptByEid(@Param("eid") int eid);--> 
  <select id="getEmpAndDeptByEid" resultMap="empDeptMap"> 
  select emp.*,dept.* from t_emp emp left join t_dept dept on emp.did = dept.did where emp.eid = #{eid}			</select>

  • 分步查询

    • 查询员工信息
    /*** 通过分步查询查询员工信息 * @param eid * @return */
Emp getEmpByStep(@Param("eid") int eid);
<resultMap id="empAndDeptByStepResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="gender" property="gender"></result>
    <!--
            property：设置需要处理映射关系的属性的属性名
            select：设置分步查询的sql的唯一标识
            column：将查询出的某个字段作为分步查询的sql的条件
            fetchType：在开启了延迟加载的环境中，通过该属性设置当前的分步查询是否使用延迟加载
            fetchType="eager(立即加载)|lazy(延迟加载)"
        -->
    <association property="dept"
                 select="com.cgg.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                 column="dept_id">
    </association>
  </resultMap>
    • 根据员工所对应的部门id查询部门信息
    /*** 分步查询的第二步： 根据员工所对应的did查询部门信息 * @param did * @return */ 
Dept getEmpDeptByStep(@Param("did") int did);
<!--Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);-->
  <!--  Emp getEmpAndDeptByStepOne(@Param("empId") Integer empId);-->
  <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
    select * from t_emp where emp_id = #{empId}
  </select>

1.3 一对多映射处理

  • collection

    /*** 根据部门id查新部门以及部门中的员工信息 * @param did * @return */ 
Dept getDeptEmpByDid(@Param("did") int did);
<resultMap id="deptAndEmpResultMap" type="Dept">
    <id column="dept_id" property="deptId"></id>
    <result column="dept_name" property="deptName"></result>
    <!--
        ofType：设置集合类型的属性中存储的数据的类型
    -->
    <collection property="emps" ofType="Emp">
      <id column="emp_id" property="empId"></id>
      <result column="emp_name" property="empName"></result>
      <result column="age" property="age"></result>
      <result column="gender" property="gender"></result>
    </collection>
  </resultMap>
<!--  public Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId);-->
  <select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpResultMap">
    SELECT *
    FROM t_dept
           LEFT JOIN t_emp
                     ON t_dept.dept_id = t_emp.dept_id
    WHERE t_dept.dept_id = #{deptId}
  </select>

  • 分步查询

    • 查询部门信息

      /*** 分步查询部门和部门中的员工 * @param did * @return */ 
Dept getDeptByStep(@Param("did") int did);
<resultMap id="deptAndEmpResultMapByStep" type="Dept">
    <id column="dept_id" property="deptId"></id>
    <result column="dept_name" property="deptName"></result>
    <collection property="emps"
      select="com.cgg.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
      column="dept_id"></collection>
  </resultMap>

  <!--Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);-->
  <select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpResultMapByStep">
    select * from t_dept where dept_id = #{deptId}
  </select>

    • 根据部门id查询部门中的所有员工

      /*** 根据部门id查询员工信息 * @param did * @return */ 
List<Emp> getEmpListByDid(@Param("did") int did);
<!--List<Emp> getEmpListByDid(@Param("did") int did);--> 
<select id="getEmpListByDid" resultType="Emp"> 
select * from t_emp where did = #{did} 
</select>

    分步查询的优点：可以实现延迟加载

    但是必须在核心配置文件中设置全局配置信息：

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

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

    性会按需加载

    此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和

    collection中的fetchType属性设置当前的分步查询是否使用延迟加载， fetchType="lazy(延迟加

    载)|eager(立即加载)"

二、动态 SQL

Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决 拼接SQL语句字符串时的痛点问题。

2.1 if

if标签可通过test属性的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行

<!--List<Emp> getEmpByCondition(Emp emp);-->
  <select id="getEmpByCondition" resultType="Emp">
    select * from t_emp where 1=1
    <if test="empName != null and empName != ''">
        and emp_name = #{empName}
    </if>
    <if test="age != null and age != ''">
        and age = #{age}
    </if>
    <if test="gender != null and gender != ''">
        and gender = #{gender}
    </if>
  </select>

2.2 where

where和if一般结合使用：

  • 若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字

  • 若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and去掉

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

<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <where>
      <if test="empName != null and empName != ''">
        emp_name = #{empName}
      </if>
      <if test="age != null and age != ''">
        and age = #{age}
      </if>
      <if test="gender != null and gender != ''">
        and gender = #{gender}
      </if>
    </where>
  </select>

2.3 trim

trim用于去掉或添加标签中的内容

常用属性：

prefix：在trim标签中的内容的前面添加某些内容

prefixOverrides：在trim标签中的内容的前面去掉某些内容

suffix：在trim标签中的内容的后面添加某些内容

suffixOverrides：在trim标签中的内容的后面去掉某些内容

<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <trim prefix="where" prefixOverrides="and">
      <if test="empName != null and empName != ''">
        emp_name = #{empName} and
      </if>
      <if test="age != null and age != ''">
        age = #{age} and
      </if>
      <if test="gender != null and gender != ''">
        gender = #{gender}
      </if>
    </trim>
  </select>

2.4 choose、when、otherwise

choose、when、 otherwise相当于if…else if…else

<!--List<Emp> getEmpByChoose(Emp emp);-->
  <select id="getEmpByChoose" resultType="Emp">
    select * from t_emp
    <where>
      <choose>
        <when test="empName != null and empName != ''">
          emp_name = #{empName}
        </when>
        <when test="age != null and age != ''">
          age = #{age}
        </when>
        <when test="gender != null and gender != ''">
          gender = #{gender}
        </when>
      </choose>
    </where>
  </select>

2.5 foreach

<!--  public void insertMoreEmp(@Param("emps") List<Emp> emps);-->
  <insert id="insertMoreEmp">
    insert into t_emp values
    <foreach collection="emps" item="emp" separator=",">
      (null,#{emp.empName},#{emp.age},#{emp.gender},null)
    </foreach>
  </insert>
<!--void deleteMoreEmp(@Param("empIds") Integer[] empIds);-->
    <delete id="deleteMoreEmp">
        <!--delete from t_emp where emp_id in
        <foreach collection="empIds" item="empId" separator="," open="(" close=")">
            #{empId}
        </foreach>-->
        delete from t_emp where
        <foreach collection="empIds" item="empId" separator="or">
            emp_id = #{empId}
        </foreach>
    </delete>

2.6 SQL 片段

sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入

<sql id="empColumns"> 
	eid,ename,age,sex,did 
</sql> 
select <include refid="empColumns"> </include> from t_emp
<!--
        动态SQL：
        1、if，通过test属性中的表达式判断标签中的内容是否有效（是否会拼接到sql中）
        2、where
        a.若where标签中有条件成立，会自动生成where关键字
        b.会自动将where标签中内容前多余的and去掉，但是其中内容后多余的and无法去掉
        c.若where标签中没有任何一个条件成立，则where没有任何功能
        3、trim
        prefix、suffix：在标签中内容前面或后面添加指定内容
        prefixOverrides、suffixOverrides：在标签中内容前面或后面去掉指定内容
        4、choose、when、otherwise
        相当于java中的if...else if...else
        when至少设置一个，otherwise最多设置一个
        5、foreach
        collection：设置要循环的数组或集合
        item：用一个字符串表示数组或集合中的每一个数据
        separator：设置每次循环的数据之间的分隔符
        open：循环的所有内容以什么开始
        close：循环的所有内容以什么结束
        6、sql片段
        可以记录一段sql，在需要用的地方使用include标签进行引用
        <sql id="empColumns">
            emp_id,emp_name,age,gender,dept_id
        </sql>
        <include refid="empColumns"></include>
    -->

三、MyBatis 的缓存

3.1 MyBatis 的一级缓存

​ 一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问，使一级缓存失效的四种情况：

  • 不同的SqlSession对应不同的一级缓存
  • 同一个SqlSession但是查询条件不同
  • 同一个SqlSession两次查询期间执行了任何一次增删改操作
  • 同一个SqlSession两次查询期间手动清空了缓存

3.2 MyBatis 的二级缓存

二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取

二级缓存开启的条件：

  • 在核心配置文件中，设置全局配置属性cacheEnabled=“true”，默认为true，不需要设置
  • 在映射文件中设置标签
  • 二级缓存必须在SqlSession关闭或提交之后有效
  • 查询的数据所转换的实体类类型必须实现序列化的接口

使二级缓存失效的情况：

两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

3.3 二级缓存的相关配置

在mapper配置文件中添加的cache标签可以设置一些属性：

  1. eviction属性：缓存回收策略，默认的是 LRU。
    • LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。
    • FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。
    • SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
    • WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
  2. flushInterval属性：刷新间隔，单位毫秒
    • 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新
  3. size属性：引用数目，正整数
    • 代表缓存最多可以存储多少个对象，太大容易导致内存溢出
  4. readOnly属性：只读， true/false
    • true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了 很重要的性能优势。
    • false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false。

3.4 MyBatis 缓存查询的顺序

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。

如果二级缓存没有命中，再查询一级缓存

如果一级缓存也没有命中，则查询数据库

SqlSession关闭之后，一级缓存中的数据会写入二级缓存

3.5 整合第三方缓存 EHCache

<!-- Mybatis EHCache整合包 --> 
<dependency> 
    <groupId>org.mybatis.caches</groupId> 
    <artifactId>mybatis-ehcache</artifactId> 
    <version>1.2.1</version> 
</dependency> 
<!-- slf4j日志门面的一个具体实现 --> 
<dependency> 
    <groupId>ch.qos.logback</groupId> 
    <artifactId>logback-classic</artifactId> 
    <version>1.2.3</version> 
</dependency>

各jar包功能

在这里插入图片描述

存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日

志。 创建logback的配置文件logback.xml

四、MyBatis 的逆向工程

正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。 Hibernate是支持正向工程的。

逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：

  • Java实体类
  • Mapper接口
  • Mapper映射文件

4.1 创建逆向工程的步骤

  • 添加依赖和插件
<!-- 依赖MyBatis核心包 -->
  <dependencies>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.7</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <!-- log4j日志 -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.8</version>
    </dependency>
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.2.0</version>
    </dependency>
  </dependencies>

  <!-- 控制Maven在构建过程中相关配置 -->
  <build>

    <!-- 构建过程中用到的插件 -->
    <plugins>

      <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
      <plugin>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-maven-plugin</artifactId>
        <version>1.3.0</version>

        <!-- 插件的依赖 -->
        <dependencies>

          <!-- 逆向工程的核心依赖 -->
          <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.2</version>
          </dependency>

          <!-- MySQL驱动 -->
          <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.8</version>
          </dependency>
        </dependencies>
      </plugin>
    </plugins>
  </build>

  • 创建MyBatis的核心配置文件

  • 创建逆向工程的配置文件

    文件名必须是：generatorConfig.xml

    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
  <!--
          targetRuntime: 执行生成的逆向工程的版本
                  MyBatis3Simple: 生成基本的CRUD（清新简洁版）
                  MyBatis3: 生成带条件的CRUD（奢华尊享版）
   -->
  <context id="DB2Tables" targetRuntime="MyBatis3">
    <!-- 数据库的连接信息 -->
    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
      connectionURL="jdbc:mysql://localhost:3306/ssm"
      userId="root"
      password="123456">
    </jdbcConnection>
    <!-- javaBean的生成策略-->
    <javaModelGenerator targetPackage="com.cgg.mybatis.pojo" targetProject=".\src\main\java">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>
    <!-- SQL映射文件的生成策略 -->
    <sqlMapGenerator targetPackage="com.cgg.mybatis.mapper"  targetProject=".\src\main\resources">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>
    <!-- Mapper接口的生成策略 -->
    <javaClientGenerator type="XMLMAPPER" targetPackage="com.cgg.mybatis.mapper"  targetProject=".\src\main\java">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>
    <!-- 逆向分析的表 -->
    <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
    <!-- domainObjectName属性指定生成出来的实体类的类名 -->
    <table tableName="t_emp" domainObjectName="Emp"/>
    <table tableName="t_dept" domainObjectName="Dept"/>
  </context>
</generatorConfiguration>

  • 执行MBG插件的generate目标

    在这里插入图片描述

4.2 QBC 查询

@Test
    public void testMBG(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        //根据id查询数据
        /*Emp emp = mapper.selectByPrimaryKey(1);
        System.out.println(emp);*/
        //查询所有数据
        /*List<Emp> list = mapper.selectByExample(null);
        list.forEach(System.out::println);*/
        //根据条件查询数据
        /*EmpExample example = new EmpExample();
        example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(20);
        example.or().andGenderEqualTo("男");
        List<Emp> list = mapper.selectByExample(example);
        list.forEach(System.out::println);*/
        Emp emp = new Emp(1, "小黑", null, "女");
        //测试普通修改功能
        //mapper.updateByPrimaryKey(emp);
        //测试选择性修改
        mapper.updateByPrimaryKeySelective(emp);
    }

五、分页插件

5.1 分页插件的使用步骤

  • 添加依赖

  • 配置分页插件

    在MyBatis的核心配置文件中配置插件

    <plugins> 
<!--设置分页插件--> 
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin> 
</plugins>

5.2 分页插件的使用

  1. 在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能

    pageNum：当前页的页码

    pageSize：每页显示的条数

  2. 在查询获取list集合之后，使用PageInfo pageInfo = new PageInfo<>(List list, int navigatePages)获取分页相关数据

    list：分页之后的数据

    navigatePages：导航分页的页码数

  3. 分页相关数据

    PageInfo{

    pageNum=8, pageSize=4, size=2, startRow=29, endRow=30, total=30, pages=8,

    list=Page{count=true, pageNum=8, pageSize=4, startRow=28, endRow=32, total=30,

    pages=8, reasonable=false, pageSizeZero=false},

    prePage=7, nextPage=0, isFirstPage=false, isLastPage=true, hasPreviousPage=true,

    hasNextPage=false, navigatePages=5, navigateFirstPage4, navigateLastPage8,

    navigatepageNums=[4, 5, 6, 7, 8]

    }

    pageNum：当前页的页码

    pageSize：每页显示的条数

    size：当前页显示的真实条数

    total：总记录数

    pages：总页数

    prePage：上一页的页码

    nextPage：下一页的页码

    isFirstPage/isLastPage：是否为第一页/最后一页

    hasPreviousPage/hasNextPage：是否存在上一页/下一页

    navigatePages：导航分页的页码数

    navigatepageNums：导航分页的页码，[1,2,3,4,5]

本文含有隐藏内容，请 开通VIP 后查看

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布