本文详细介绍了Mybatis框架，包括其简介、与JDBC的优缺点比较、使用方法、作用域和生命周期、配置解析、映射器配置、分页处理、注解开发、一对多和多对一处理、动态SQL以及缓存机制。Mybatis提供了灵活的SQL操作，支持多种映射方式，可提高开发效率，但配置相对复杂，需要根据具体需求选择使用。通过了解Mybatis的各个方面，开发者可以更好地利用该框架优化数据库操作。
Mybais
1.简介
- MyBatis是一款基于Java语言的持久层框架，它可以将数据库操作封装成简单的配置文件和SQL语句，并且提供了多种映射方式，使得开发者可以使用面向对象的方式来操作数据库。MyBatis不同于其他ORM框架（如Hibernate），它更加灵活，可以自由地编写SQL语句，不必在对象和表之间进行强制映射。此外，MyBatis还支持动态SQL、缓存机制、插件扩展等功能，为Java开发者提供了方便快捷的数据访问解决方案。
2.为什么要使用Mybatis
- 灵活性高：MyBatis不会对开发者的编程风格和对象模型做出强制限制，可以自由地编写SQL语句和配置文件，符合多种数据库的使用需求。
- 映射方式多样化：MyBatis支持多种映射方式（如基于注解、XML配置文件、API等），可以根据具体情况选择最适合的方式。
- 高效性能：MyBatis通过预处理和缓存机制等功能来提高数据库操作的性能，同时还支持延迟加载和批量操作等优化方式。
- 易于调试：MyBatis可以将运行时生成的SQL语句输出到日志中，方便开发者调试和优化代码。
- 易于整合：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。
- SqlSessionFactory作用域：表示整个MyBatis应用程序的作用域，由SqlSessionFactoryBuilder创建。它是线程安全的，一个应用通常只需要创建一个SqlSessionFactory实例即可。
- SqlSession作用域：表示一次数据库会话的作用域。它提供了对数据库的操作方法，包括插入、更新、删除和查询等。SqlSession使用完成后必须关闭，否则可能导致连接池泄漏。
- Mapper作用域：表示每个Mapper接口的作用域。它为进行数据库操作提供了不同的操作方法，并将配置文件中的SQL语句与Java方法进行映射。Mapper可以通过注解或XML文件来配置SQL语句。
5.2、MyBatis的生命周期指的是SqlSessionFactory、SqlSession和Mapper在整个应用程序运行过程中的状态变化：
- SqlSessionFactory生命周期：当应用程序启动时，SqlSessionFactory被创建并初始化，当应用程序关闭时，SqlSessionFactory被销毁。
- SqlSession生命周期：SqlSession在每次数据库访问时创建，并在操作结束后关闭。此外，SqlSession还可以被托管到Spring容器中，交由Spring容器管理其生命周期。
- Mapper生命周期：Mapper在应用程序中根据需要进行加载和卸载，当需要进行数据库操作时，Mapper被创建并执行相应的方法，然后再被卸载。
需要注意的是，SqlSession和Mapper在使用完之后必须进行关闭或销毁操作，以释放资源。否则，可能会导致连接泄漏、缓存溢出等问题。
5.3、Mybatis执行过程
5.4、SqlSession流程图
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配置包含以下几个元素：
- environment元素：表示一个环境，其id属性指定环境名，transactionManager属性指定事务管理器，dataSource属性指定数据源。
- transactionManager元素：表示事务管理器，其type属性指定事务管理器类型，通常使用JDBC或者Spring提供的事务管理器。
- 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应该一一对应
-
- namespace和子元素的id联合保证唯一 , 区别不同的mapper
- 绑定DAO接口
- 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的动态代理机制
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WGMTb1me-1680325373740)(C:\Users\彭润启\AppData\Roaming\Typora\typora-user-images\image-20230331231056611.png)]
Mybatis详细的执行流程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jSpn3oln-1680325373741)(C:\Users\彭润启\AppData\Roaming\Typora\typora-user-images\image-20230331231240671.png)]
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标签包括：
- if标签：用于条件判断，可以根据不同情况生成不同的SQL片段。
- choose、when、otherwise标签：用于多条件选择，类似于Java中的switch-case语句。
- trim标签：用于去除生成SQL时产生的多余的空格和逗号等符号。
- where标签：可以自动根据条件添加WHERE关键字，并处理多个条件之间的AND/OR关系。
- set标签：用于更新操作，可以自动生成UPDATE语句中SET子句部分。
- 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缓存原理图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h0c0hjUA-1680325373742)(C:\Users\彭润启\AppData\Roaming\Typora\typora-user-images\image-20230401010208552.png)]
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
