526互联

Mybatis

发布时间 2023-04-01 01:12:09作者: pengrq

Mybais

1.简介

  • MyBatis是一款基于Java语言的持久层框架，它可以将数据库操作封装成简单的配置文件和SQL语句，并且提供了多种映射方式，使得开发者可以使用面向对象的方式来操作数据库。MyBatis不同于其他ORM框架（如Hibernate），它更加灵活，可以自由地编写SQL语句，不必在对象和表之间进行强制映射。此外，MyBatis还支持动态SQL、缓存机制、插件扩展等功能，为Java开发者提供了方便快捷的数据访问解决方案。

2.为什么要使用Mybatis

  1. 灵活性高：MyBatis不会对开发者的编程风格和对象模型做出强制限制，可以自由地编写SQL语句和配置文件，符合多种数据库的使用需求。
  2. 映射方式多样化：MyBatis支持多种映射方式（如基于注解、XML配置文件、API等），可以根据具体情况选择最适合的方式。
  3. 高效性能：MyBatis通过预处理和缓存机制等功能来提高数据库操作的性能，同时还支持延迟加载和批量操作等优化方式。
  4. 易于调试：MyBatis可以将运行时生成的SQL语句输出到日志中，方便开发者调试和优化代码。
  5. 易于整合：MyBatis可以与其他框架（如Spring、Spring Boot等）无缝整合，可以更方便地集成到现有系统中。

总之，MyBatis是一个灵活、高效、易于调试和整合的持久层框架，可以帮助开发者快速构建可靠的数据访问层。

3.Mybatis和jdbc的优缺点

3.1、Mybatis的优缺点

3.1.1、MyBatis的优点：

  • SQL语句与Java代码分离，易于维护和升级。
  • 大量使用XML配置和注解，简化了开发人员的编码难度。
  • 支持多种数据库操作，比如CRUD、存储过程、批量操作等。
  • 提供了一级缓存和二级缓存来提高性能。
  • 易于整合到Spring等框架中。

3.1.2、MyBatis的缺点：

  • 配置文件相对复杂，需要学习一定的MyBatis知识。
  • 对于简单的数据库操作，可能会显得繁琐，不如JDBC方便。

3.2、JDBC的优缺点

3.2.1、JDBC的优点：

  • 是Java标准API，无需额外导入jar包，并且跨平台能力强。
  • 直接操作底层数据库，可以更好地掌握SQL相关知识。
  • 对于简单的数据库操作，使用JDBC会更加方便快捷。

3.2.2、JDBC的缺点：

  • 代码冗长，需要大量重复代码进行连接、关闭、异常处理等操作。
  • 需要手写SQL语句，容易出现错误。
  • 不支持对象关系映射（ORM）。

总的来说，MyBatis相对于JDBC而言，更加灵活、易用、可维护性和扩展性更强，同时能有效提高数据库操作的性能。但是对于简单的数据库操作而言，使用JDBC可能会更加方便快捷。在实际应用中，开发者需要根据具体情况做出选择，或者二者结合起来使用。

4.怎么使用Mybatis

4.1、导入相关依赖

  • maven仓库
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.13</version>
</dependency>

4.2、快速入门

  • 创建mybatis的配置文件

    <!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <environments default="development">
    <environment id="development">
      <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>
  <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

  • 创建mapper配置文件

    <?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=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="">

</mapper>

  • 工具类

    import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

//SqlSessionFactory-->sqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {
       try {
            //使用mybatis获取SqlSessionFactory对象
            String resource = "mybatis-config.xml";
           InputStream resourceAsStream = Resources.getResourceAsStream(resource);
           sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //既然有了SqlSessionFactory顾名思义我们就可以从中获得SqlSession的实例了。
    //SqlSession完全包含了面向数据库执行SQL命令所需的所有方法

    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();
    }
}

5.作用域和生命周期

5.1、MyBatis中有三个主要的作用域：SqlSessionFactory、SqlSession和Mapper。

  1. SqlSessionFactory作用域：表示整个MyBatis应用程序的作用域，由SqlSessionFactoryBuilder创建。它是线程安全的，一个应用通常只需要创建一个SqlSessionFactory实例即可。
  2. SqlSession作用域：表示一次数据库会话的作用域。它提供了对数据库的操作方法，包括插入、更新、删除和查询等。SqlSession使用完成后必须关闭，否则可能导致连接池泄漏。
  3. Mapper作用域：表示每个Mapper接口的作用域。它为进行数据库操作提供了不同的操作方法，并将配置文件中的SQL语句与Java方法进行映射。Mapper可以通过注解或XML文件来配置SQL语句。

5.2、MyBatis的生命周期指的是SqlSessionFactory、SqlSession和Mapper在整个应用程序运行过程中的状态变化：

  1. SqlSessionFactory生命周期：当应用程序启动时，SqlSessionFactory被创建并初始化，当应用程序关闭时，SqlSessionFactory被销毁。
  2. SqlSession生命周期：SqlSession在每次数据库访问时创建，并在操作结束后关闭。此外，SqlSession还可以被托管到Spring容器中，交由Spring容器管理其生命周期。
  3. Mapper生命周期：Mapper在应用程序中根据需要进行加载和卸载，当需要进行数据库操作时，Mapper被创建并执行相应的方法，然后再被卸载。

需要注意的是，SqlSession和Mapper在使用完之后必须进行关闭或销毁操作，以释放资源。否则，可能会导致连接泄漏、缓存溢出等问题。

5.3、Mybatis执行过程

img

5.4、SqlSession流程图

img

6.配置解析

6.1、核心配置文件

  • Mybatis-config.xml

  • MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

    configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

6.2、环境配置（environment）

6.2.1、简介

Mybatis中 environments配置用于配置数据源和事务管理器。它可以支持不同的环境（如开发、测试、生产等），每个环境有独立的数据源和事务管理器

不过要记住：尽管可以配置多个环境，但每个SqlSessionFactory实例只能选择一种环境

6.2.2、environments配置包含以下几个元素：

  1. environment元素：表示一个环境，其id属性指定环境名，transactionManager属性指定事务管理器，dataSource属性指定数据源。
  2. transactionManager元素：表示事务管理器，其type属性指定事务管理器类型，通常使用JDBC或者Spring提供的事务管理器。
  3. dataSource元素：表示数据源，其type属性指定数据源类型，通常使用JDBC或者连接池数据源。

6.2.3、environments配置示例：

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC"/>
    <dataSource type="POOLED">
      <property name="driver" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/test"/>
      <property name="username" value="root"/>
      <property name="password" value="test123"/>
    </dataSource>
  </environment>
</environments>

在上述示例中，定义了一个名为“development”的环境，使用JDBC事务管理器和连接池数据源，其中连接池数据源的相关参数通过property元素进行配置。默认的环境是“development”，可以通过default属性进行设置。

需要注意的是，environments配置只需要在MyBatis配置文件中声明一次即可。如果需要配置多个不同的环境，可以通过mybatis-config.xml中的profiles元素来实现。

6.2.3.1事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：

  • JDBC – 这个配置直接使用了 JDBC 的提交和回滚功能，它依赖从数据源获得的连接来管理事务作用域。默认情况下，为了与某些驱动程序兼容，它在关闭连接时启用自动提交。然而，对于某些驱动程序来说，启用自动提交不仅是不必要的，而且是一个代价高昂的操作。因此，从 3.5.10 版本开始，你可以通过将 "skipSetAutoCommitOnClose" 属性设置为 "true" 来跳过这个步骤。例如：
<transactionManager type="JDBC">
  <property name="skipSetAutoCommitOnClose" value="true"/>
</transactionManager>

  • MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。例如:

    <transactionManager type="MANAGED">
  <property name="closeConnection" value="false"/>
</transactionManager>

    提示: 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

6.2.3.2数据源（dataSource）

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

  • 大多数 MyBatis 应用程序会按示例中的例子来配置数据源。虽然数据源配置是可选的，但如果要启用延迟加载特性，就必须配置数据源。

有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）：

UNPOOLED– 这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。 性能表现则依赖于使用的数据库，对某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。

POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求。

JNDI – 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用。

6.3属性（properties）

我们可以通过properties属性来实现引用配置文件

这些属性都是可以在外部进行配置且可以动态替换的。既可以在典型的 Java 属性文件中配置，也可以在 properties 元素的子元素中设置。例如：

<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
</properties>

如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

  • 首先读取在 properties 元素体内指定的属性。
  • 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
  • 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的则是 properties 元素中指定的属性。

6.4类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。例如：

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

  • 每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名

  • TypeAliases 是一种将 Java 类型映射到 MyBatis 中的别名的机制。它可以简化在映射文件中使用 Java 类型的繁琐过程，让映射文件更加简洁易读。

  • TypeAliases 可以在 MyBatis 的配置文件中定义，也可以在实体类上中定义。

  • 在配置文件中定义的 TypeAliases 是全局的，而在实体类中定义的 @Alias 只在该映射文件中生效。

  • 在定义 TypeAliases 时，可以指定别名和对应的 Java 类型，也可以只指定别名，此时 MyBatis 会自动根据别名推断对应的 Java 类型。

  • TypeAliases 可以让更方便地使用 Java 类型，减少代码量，提高代码可读性。

6.5映射器（mappers）

MapperRegistry:注册绑定我们的Mapper文件

方式一:

<!-- 每一个mapper.xml都需要在Mybatis核心配置文件中注册！ -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

方式二:使用class文件绑定注册

<!-- 每一个mapper.xml都需要在Mybatis核心配置文件中注册！ -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

注意点：

  • 接口和他的Mapper配置文件必须同名
  • 接口和他的Mapper配置文件必须在同一个包下

方式三：通过扫包注册

<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

Mapper文件

<?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.kuang.mapper.UserMapper">
   
</mapper>

  • namespace中文意思：命名空间，作用如下：

    • namespace的命名必须跟某个接口同名
    • 接口中的方法与映射文件中sql语句id应该一一对应
    1. namespace和子元素的id联合保证唯一 , 区别不同的mapper
    2. 绑定DAO接口
    3. namespace命名规则 : 包名+类名

MyBatis 的真正强大在于它的映射语句，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 为聚焦于 SQL 而构建，以尽可能地为你减少麻烦。

7.映射器配置和分页

  • 为了解决属性名和字段名不一致

    解决方案

方案一：为列名指定别名 , 别名和java实体类的属性名一致 .

<select id="selectUserById" resultType="User">
  select id , name , pwd as password from user where id = #{id}
</select>

方案二：使用结果集映射->ResultMap 【推荐】

<resultMap id="UserMap" type="User">
   <!-- id为主键 -->
   <id column="id" property="id"/>
   <!-- column是数据库表的列名 , property是对应实体类的属性名 -->
   <result column="name" property="name"/>
   <result column="pwd" property="password"/>
</resultMap>

<select id="selectUserById" resultMap="UserMap">
  select id , name , pwd from user where id = #{id}
</select>
  • ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。

分页

在学习mybatis等持久层框架的时候，会经常对数据进行增删改查操作，使用最多的是对数据库进行查询操作，如果查询大量数据的时候，我们往往使用分页进行查询，也就是每次处理小部分数据，这样对数据库压力就在可控范围内。

7.2分页

使用Limit实现分页

#语法
SELECT * FROM table LIMIT stratIndex，pageSize

SELECT * FROM table LIMIT 5,10; // 检索记录行 6-15  

#为了检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为 -1：   
SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last.  

#如果只给定一个参数，它表示返回最大的记录行数目：   
SELECT * FROM table LIMIT 5; //检索前 5 个记录行  

#换句话说，LIMIT n 等价于 LIMIT 0,n。

RowBounds分页

RowBounds在Java代码层面实现分页，当然此种方式作为了解即可

1、mapper接口

//选择全部用户RowBounds实现分页
List<User> getUserByRowBounds();

2、mapper文件

<select id="getUserByRowBounds" resultType="user">
select * from user
</select>

3、测试类

在这里，我们需要使用RowBounds类

@Test
public void testUserByRowBounds() {
   SqlSession session = MybatisUtils.getSession();

   int currentPage = 2;  //第几页
   int pageSize = 2;  //每页显示几个
   RowBounds rowBounds = new RowBounds((currentPage-1)*pageSize,pageSize);

   //通过session.**方法进行传递rowBounds，[此种方式现在已经不推荐使用了]
   List<User> users = session.selectList("com.kuang.mapper.UserMapper.getUserByRowBounds", null, rowBounds);

   for (User user: users){
       System.out.println(user);
  }
   session.close();
}

8.注解开发

8.1面向接口编程

  • 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程
  • 根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好
  • 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了；
  • 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

  • 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。

  • 接口的本身反映了系统设计人员对系统的抽象理解。

  • 接口应有两类：

    • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；
    • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；

  • 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

  • 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法 .
  • 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现 .
  • 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题.更多的体现就是对系统整体的架构

8.2使用注解开发

  • mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。不幸的是，Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建

  • sql 类型主要分成 :

    • @select ()
    • @update ()
    • @Insert ()
    • @delete ()

注意：利用注解开发就不需要mapper.xml映射文件了 .

1、我们在我们的接口中添加注解

//查询全部用户
@Select("select id,name,pwd password from user")
public List<User> getAllUser();

2、在mybatis的核心配置文件中注入

<!--使用class绑定接口-->
<mappers>
   <mapper class="com.kuang.mapper.UserMapper"/>
</mappers>

本质上利用了jvm的动态代理机制

image-20230331231056611

Mybatis详细的执行流程

image-20230331231240671

8.4@Param注解

@Param注解用于给方法参数起一个名字。以下是总结的使用原则：

  • 在方法只接受一个参数的情况下，可以不使用@Param。

  • 在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。

  • 如果参数是 JavaBean ， 则不能使用@Param。

  • 不使用@Param注解时，参数只能有一个，并且是Javabean。

    #与$的区别

  • #{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用】

    INSERT INTO user (name) VALUES (#{name});
INSERT INTO user (name) VALUES (?);

  • ${} 的作用是直接进行字符串替换

    INSERT INTO user (name) VALUES ('${name}');
INSERT INTO user (name) VALUES ('kuangshen');

使用注解和配置文件协同开发，才是MyBatis的最佳实践！

9.一对多和多对一处理

Mybatis支持一对多和多对一的关联查询，其中一对多指的是一个实体类中包含多个子实体类的情况，多对一则相反。

一对多的处理可以通过在主实体类中添加一个List属性，然后在映射文件或注解中使用嵌套查询语句来实现。例如，在XML中，可以使用标签进行配置，指定子实体类对应的结果集。在Java代码中，Mybatis会自动将结果集转换为List对象，并设置到主实体类的对应属性中。

多对一的处理则需要在子实体类中添加一个主实体类类型的属性，并在映射文件或注解中使用外键关联语句进行处理。例如，在XML中，可以使用标签进行配置，指定主实体类对应的结果集。在Java代码中，Mybatis会自动将结果集转换为主实体类对象，并设置到子实体类的对应属性中。

需要注意的是，一对多和多对一的处理都涉及到数据库表之间的关联查询，因此在设计数据表时需要考虑好关联关系，并使用外键等机制进行维护。同时，在使用Mybatis进行关联查询时，也需要注意查询性能和结果集的正确性，避免出现慢查询或数据冗余等问题。

9.1多对一例如：

多对一的理解：

  • 多个学生对应一个老师
  • 如果对于学生这边，就是一个多对一的现象，即从学生这边关联一个老师！
@Data //GET,SET,ToString，有参，无参构造
public class Teacher {
   private int id;
   private String name;
}
@Data
public class Student {
   private int id;
   private String name;
   //多个学生可以是同一个老师，即多对一
   private Teacher teacher;
}

编写实体类对应的Mapper接口 【两个】

  • 无论有没有需求，都应该写上，以备后来之需！
public interface StudentMapper {
}

public interface TeacherMapper {
}

编写Mapper接口对应的 mapper.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.kuang.mapper.StudentMapper">

</mapper>


<?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.kuang.mapper.TeacherMapper">

</mapper>

按查询嵌套处理

1、给StudentMapper接口增加方法

//获取所有学生及对应老师的信息
public List<Student> getStudents();

2、编写对应的Mapper文件

<?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.kuang.mapper.StudentMapper">

   <!--
   需求：获取所有学生及对应老师的信息
   思路：
       1. 获取所有学生的信息
       2. 根据获取的学生信息的老师ID->获取该老师的信息
       3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般使用关联查询？
           1. 做一个结果集映射：StudentTeacher
           2. StudentTeacher结果集的类型为 Student
           3. 学生中老师的属性为teacher，对应数据库中为tid。
              多个 [1,...）学生关联一个老师=> 一对一，一对多
           4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查询
   -->
   <select id="getStudents" resultMap="StudentTeacher">
    select * from student
   </select>
   <resultMap id="StudentTeacher" type="Student">
       <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名-->
       <association property="teacher"  column="tid" javaType="Teacher" select="getTeacher"/>
   </resultMap>
   <!--
   这里传递过来的id，只有一个属性的时候，下面可以写任何值
   association中column多参数配置：
       column="{key=value,key=value}"
       其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
   -->
   <select id="getTeacher" resultType="teacher">
      select * from teacher where id = #{id}
   </select>

</mapper>

3、编写完毕去Mybatis配置文件中，注册Mapper！

4、注意点说明：

<resultMap id="StudentTeacher" type="Student">
   <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名-->
   <association property="teacher"  column="{id=tid,name=tid}" javaType="Teacher" select="getTeacher"/>
</resultMap>
<!--
这里传递过来的id，只有一个属性的时候，下面可以写任何值
association中column多参数配置：
   column="{key=value,key=value}"
   其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
-->
<select id="getTeacher" resultType="teacher">
  select * from teacher where id = #{id} and name = #{name}
</select>

5、测试

@Test
public void testGetStudents(){
   SqlSession session = MybatisUtils.getSession();
   StudentMapper mapper = session.getMapper(StudentMapper.class);

   List<Student> students = mapper.getStudents();

   for (Student student : students){
       System.out.println(
               "学生名:"+ student.getName()
                       +"\t老师:"+student.getTeacher().getName());
  }
}

按结果嵌套处理

除了上面这种方式，还有其他思路吗？

我们还可以按照结果进行嵌套处理；

1、接口方法编写

public List<Student> getStudents2();

2、编写对应的mapper文件

<!--
按查询结果嵌套处理
思路：
   1. 直接查询出结果，进行结果集的映射
-->
<select id="getStudents2" resultMap="StudentTeacher2" >
  select s.id sid, s.name sname , t.name tname
  from student s,teacher t
  where s.tid = t.id
</select>

<resultMap id="StudentTeacher2" type="Student">
   <id property="id" column="sid"/>
   <result property="name" column="sname"/>
   <!--关联对象property 关联对象在Student实体类中的属性-->
   <association property="teacher" javaType="Teacher">
       <result property="name" column="tname"/>
   </association>
</resultMap>

3、去mybatis-config文件中注入【此处应该处理过了】

4、测试

@Test
public void testGetStudents2(){
   SqlSession session = MybatisUtils.getSession();
   StudentMapper mapper = session.getMapper(StudentMapper.class);

   List<Student> students = mapper.getStudents2();

   for (Student student : students){
       System.out.println(
               "学生名:"+ student.getName()
                       +"\t老师:"+student.getTeacher().getName());
  }
}

小结

按照查询进行嵌套处理就像SQL中的子查询

按照结果进行嵌套处理就像SQL中的联表查询

9.2一对多的处理：

对多的理解：

  • 一个老师拥有多个学生
  • 如果对于老师这边，就是一个一对多的现象，即从一个老师下面拥有一群学生（集合）！

实体类编写

@Data
public class Student {
   private int id;
   private String name;
   private int tid;
}
@Data
public class Teacher {
   private int id;
   private String name;
   //一个老师多个学生
   private List<Student> students;
}

按结果嵌套处理

1、TeacherMapper接口编写方法

//获取指定老师，及老师下的所有学生
public Teacher getTeacher(int id);

2、编写接口对应的Mapper配置文件

<mapper namespace="com.kuang.mapper.TeacherMapper">

   <!--
   思路:
       1. 从学生表和老师表中查出学生id，学生姓名，老师姓名
       2. 对查询出来的操作做结果集映射
           1. 集合的话，使用collection！
               JavaType和ofType都是用来指定对象类型的
               JavaType是用来指定pojo中属性的类型
               ofType指定的是映射到list集合属性中pojo的类型。
   -->
   <select id="getTeacher" resultMap="TeacherStudent">
      select s.id sid, s.name sname , t.name tname, t.id tid
      from student s,teacher t
      where s.tid = t.id and t.id=#{id}
   </select>

   <resultMap id="TeacherStudent" type="Teacher">
       <result  property="name" column="tname"/>
       <collection property="students" ofType="Student">
           <result property="id" column="sid" />
           <result property="name" column="sname" />
           <result property="tid" column="tid" />
       </collection>
   </resultMap>
</mapper>

3、将Mapper文件注册到MyBatis-config文件中

<mappers>
   <mapper resource="mapper/TeacherMapper.xml"/>
</mappers>

4、测试

@Test
public void testGetTeacher(){
   SqlSession session = MybatisUtils.getSession();
   TeacherMapper mapper = session.getMapper(TeacherMapper.class);
   Teacher teacher = mapper.getTeacher(1);
   System.out.println(teacher.getName());
   System.out.println(teacher.getStudents());
}

按查询嵌套处理

1、TeacherMapper接口编写方法

public Teacher getTeacher2(int id);

2、编写接口对应的Mapper配置文件

<select id="getTeacher2" resultMap="TeacherStudent2">
select * from teacher where id = #{id}
</select>
<resultMap id="TeacherStudent2" type="Teacher">
   <!--column是一对多的外键 , 写的是一的主键的列名-->
   <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="getStudentByTeacherId"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
  select * from student where tid = #{id}
</select>

3、将Mapper文件注册到MyBatis-config文件中

4、测试

@Test
public void testGetTeacher2(){
   SqlSession session = MybatisUtils.getSession();
   TeacherMapper mapper = session.getMapper(TeacherMapper.class);
   Teacher teacher = mapper.getTeacher2(1);
   System.out.println(teacher.getName());
   System.out.println(teacher.getStudents());
}

小结

1、关联-association

2、集合-collection

3、所以association是用于一对一和多对一，而collection是用于一对多的关系

4、JavaType和ofType都是用来指定对象类型的

  • JavaType是用来指定pojo中属性的类型
  • ofType指定的是映射到list集合属性中pojo的类型。

注意说明：

1、保证SQL的可读性，尽量通俗易懂

2、根据实际要求，尽量编写性能更高的SQL语句

3、注意属性名和字段不一致的问题

4、注意一对多和多对一 中：字段和属性对应的问题

5、尽量使用Log4j，通过日志来查看自己的错误

10.动态SQL

什么是动态SQL：动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句.

常用的动态SQL标签包括：

  1. if标签：用于条件判断，可以根据不同情况生成不同的SQL片段。
  2. choose、when、otherwise标签：用于多条件选择，类似于Java中的switch-case语句。
  3. trim标签：用于去除生成SQL时产生的多余的空格和逗号等符号。
  4. where标签：可以自动根据条件添加WHERE关键字，并处理多个条件之间的AND/OR关系。
  5. set标签：用于更新操作，可以自动生成UPDATE语句中SET子句部分。
  6. foreach标签：用于循环迭代，可以根据集合大小生成对应数量的SQL片段。

通过使用动态SQL标签，可以避免手动构建复杂的SQL语句，同时还可以提高代码的可读性和可维护性。需要注意的是，在使用动态SQL时，要尽量避免过于复杂的嵌套结构，以免影响查询性能。

10.1动态SQL的使用

if 语句

需求：根据作者名字和博客名字来查询博客！如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询

1、编写接口类

//需求1
List<Blog> queryBlogIf(Map map);

2、编写SQL语句

<!--需求1：
根据作者名字和博客名字来查询博客！
如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询
select * from blog where title = #{title} and author = #{author}
-->
<select id="queryBlogIf" parameterType="map" resultType="blog">
  select * from blog where
   <if test="title != null">
      title = #{title}
   </if>
   <if test="author != null">
      and author = #{author}
   </if>
</select>

3、测试

@Test
public void testQueryBlogIf(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap<String, String> map = new HashMap<String, String>();
   map.put("title","Mybatis如此简单");
   map.put("author","狂神说");
   List<Blog> blogs = mapper.queryBlogIf(map);

   System.out.println(blogs);

   session.close();
}

这样写我们可以看到，如果 author 等于 null，那么查询语句为 select * from user where title=#{title},但是如果title为空呢？那么查询语句为 select * from user where and author=#{author}，这是错误的 SQL 语句，如何解决呢？请看下面的 where 语句！

Where

修改上面的SQL语句；

<select id="queryBlogIf" parameterType="map" resultType="blog">
  select * from blog
   <where>
       <if test="title != null">
          title = #{title}
       </if>
       <if test="author != null">
          and author = #{author}
       </if>
   </where>
</select>

这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。

Set

同理，上面的对于查询 SQL 语句包含 where 关键字，如果在进行更新操作的时候，含有 set 关键词，我们怎么处理呢？

1、编写接口方法

int updateBlog(Map map);

2、sql配置文件

<!--注意set是用的逗号隔开-->
<update id="updateBlog" parameterType="map">
  update blog
     <set>
         <if test="title != null">
            title = #{title},
         </if>
         <if test="author != null">
            author = #{author}
         </if>
     </set>
  where id = #{id};
</update>

3、测试

@Test
public void testUpdateBlog(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap<String, String> map = new HashMap<String, String>();
   map.put("title","动态SQL");
   map.put("author","秦疆");
   map.put("id","9d6a763f5e1347cebda43e2a32687a77");

   mapper.updateBlog(map);


   session.close();
}

choose语句

有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句

1、编写接口方法

List<Blog> queryBlogChoose(Map map);

2、sql配置文件

<select id="queryBlogChoose" parameterType="map" resultType="blog">
  select * from blog
   <where>
       <choose>
           <when test="title != null">
                title = #{title}
           </when>
           <when test="author != null">
              and author = #{author}
           </when>
           <otherwise>
              and views = #{views}
           </otherwise>
       </choose>
   </where>
</select>

3、测试类

@Test
public void testQueryBlogChoose(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap<String, Object> map = new HashMap<String, Object>();
   map.put("title","Java如此简单");
   map.put("author","狂神说");
   map.put("views",9999);
   List<Blog> blogs = mapper.queryBlogChoose(map);

   System.out.println(blogs);

   session.close();
}

SQL片段

有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。

提取SQL片段：

<sql id="if-title-author">
   <if test="title != null">
      title = #{title}
   </if>
   <if test="author != null">
      and author = #{author}
   </if>
</sql>

引用SQL片段：

<select id="queryBlogIf" parameterType="map" resultType="blog">
  select * from blog
   <where>
       <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
       <include refid="if-title-author"></include>
       <!-- 在这里还可以引用其他的 sql 片段 -->
   </where>
</select>

注意：

①、最好基于 单表来定义 sql 片段，提高片段的可重用性

②、在 sql 片段中不要包括 where

Foreach

将数据库中前三个数据的id修改为1,2,3；

需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息

1、编写接口

List<Blog> queryBlogForeach(Map map);

2、编写SQL语句

<select id="queryBlogForeach" parameterType="map" resultType="blog">
  select * from blog
   <where>
       <!--
       collection:指定输入对象中的集合属性
       item:每次遍历生成的对象
       open:开始遍历时的拼接字符串
       close:结束时拼接的字符串
       separator:遍历对象之间需要拼接的字符串
       select * from blog where 1=1 and (id=1 or id=2 or id=3)
     -->
       <foreach collection="ids"  item="id" open="and (" close=")" separator="or">
          id=#{id}
       </foreach>
   </where>
</select>

3、测试

@Test
public void testQueryBlogForeach(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap map = new HashMap();
   List<Integer> ids = new ArrayList<Integer>();
   ids.add(1);
   ids.add(2);
   ids.add(3);
   map.put("ids",ids);

   List<Blog> blogs = mapper.queryBlogForeach(map);

   System.out.println(blogs);

   session.close();
}

小结：其实动态 sql 语句的编写往往就是一个拼接的问题，为了保证拼接准确，我们最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错。多在实践中使用才是熟练掌握它的技巧。

11缓存

1、什么是缓存 [ Cache ]？

  • 存在内存中的临时数据。
  • 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2、为什么使用缓存？

  • 减少和数据库的交互次数，减少系统开销，提高系统效率。

3、什么样的数据能使用缓存？

  • 经常查询并且不经常改变的数据。

11.1Mybatis缓存

MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。

Mybatis提供了一级缓存和二级缓存两种缓存机制。

  • 一级缓存是在SqlSession生命周期内的缓存，多次查询相同的语句第一次会存储到缓存中后面再缓存中取，默认情况下，Mybatis开启了一级缓存，可以通过清除缓存或关闭SqlSession来刷新缓存。

  • 二级缓存是在Mapper映射文件级别的缓存，可跨SqlSession共享，在不同SqlSession中都可以访问到。需要手动开启和配置，并且只缓存Serializable类型的对象。同时要注意缓存对象的更新和失效问题，避免出现脏数据和并发问题。

尽管Mybatis提供了缓存机制，但并不是所有场景都适合使用缓存。例如，当数据量较大，查询频繁且更新频率较高时，缓存可能成为性能瓶颈，反而影响系统性能。因此，在使用缓存时需要谨慎考虑缓存策略和缓存失效机制，以达到最优化的系统性能。

11.1.1一级缓存

一级缓存失效的四种情况

一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它；

一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请求！

1、sqlSession不同

  • 每个sqlSession中的缓存相互独立

2、sqlSession相同，查询条件不同

  • 当前缓存中，不存在这个数据

3、sqlSession相同，两次查询之间执行了增删改操作！

  • 因为增删改操作可能会对当前数据产生影响

4、sqlSession相同，手动清除一级缓存

11.1.2二级缓存

  • 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存

  • 基于namespace级别的缓存，一个名称空间，对应一个二级缓存；

  • 工作机制

    • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
    • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
    • 新的会话查询信息，就可以从二级缓存中获取内容；
    • 不同的mapper查出的数据会放在自己对应的缓存（map）中；

使用步骤

1、开启全局缓存 【mybatis-config.xml】

<setting name="cacheEnabled" value="true"/>

2、去每个mapper.xml中配置使用二级缓存，这个配置非常简单；【xxxMapper.xml】

<cache/>

官方示例=====>查看官方文档
<cache
 eviction="FIFO"
 flushInterval="60000"
 size="512"
 readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

结论

  • 只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
  • 查出的数据都会被默认先放在一级缓存中
  • 只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中

11.2缓存原理图

image-20230401010208552