admin管理员组文章数量:1794759
MyBatis从入门到精通
MyBatis
MyBatis 是一款优秀的半自动的ORM持久层框架，它支持自定义 SQL、存储过程以及高级映射。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
持久层：可以立即保存在磁盘上，在这里可以理解为与数据库相关操作。
什么是ORM
OBject Relation Mapping 对象关系映射
对象指的是面向面向对象，关系指的是数据库中的表，
例如Java语言中的POJO类与数据库模型之间的对应关系。
为什么MyBatis是半自动ORM框架
public class User(){ private long id; private String realname; } User user = user .getById(3); SELECT `id`,`realname` FROM `user` WHERE `id` = 3;以上用例为ORM框架部分执行代码，发现在ORM框架中不需要使用SQL语句，
大大减少了程序员学习成本和SQL语句维护成本，
另外当数据库产品更换的之后无需重新编写项目中的SQL语句
-- MySQL SELECT * FROM `user` LIMIT 10; -- SqlServer SELECT * FROM `user` TOP 10;用MyBatis进行开发的，需要手写SQL语句，而ORM框架例如Hibernate则不需要编写SQL语句。
为什么MyBais是半自动ORM框架我们还要去学习呢
因为MyBatis使用自定义SQL所以更加灵活尤其在多表操作
SqlSession对象，该对象包含了执行SQL语句的所有方法，例如JDBC里面Connection
| Executor接口 | 执行器.统一调度其他三个对象执行对应的SQL |
| StatementHandler | 使用的数据库中的Statement执行操作 相当于字符串拼接 |
| PrepareStatement | 使用SQL传参的方式处理 |
| ResultHandler | 对最后的结果进行封装 |
Executor接口，将传递过来的参数动态生成SQL语句，负责查询缓存。
MappedStatement对象，该对象负责对SQL封装，用于存储需要映射的SQL语句及参数等信
ResultHandler对象，用户返回结果集合，封装成最红想要的数据类型，可以自定义返回类型
点击下载数据库脚本文件
编写数据源文件src/main/resources/config.properties
driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql:///mybatis?useUnicode=true&characterEncoding=UTF8&useSSL=false&useServerPrepStmts=false&rewriteBatchedStatements=true&cachePrepStmts=true&allowMultiQueries=true&serverTimeZone=Aisa/Shanghai username=root password=123456 编写核心配置文件src/main/resources/mybatis/mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis//DTD Config 3.0//EN" "mybatis/dtd/mybatis-3-config.dtd"> <configuration> <!-- 这些属性可以在外部进行配置，并可以进行动态替换。 你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置 --> <properties resource="config.properties" /> <!-- MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。 例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。 --> <!--默认使用的环境 ID（比如：default="development"）。--> <environments default="development"> <!--每个 environment 元素定义的环境 ID（比如：id="development"）。--> <environment id="development"> <!--事务管理器的配置（比如：type="JDBC"）。--> <!-- 事务管理器（transactionManager） 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）： JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。 MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。 这两种事务管理器类型都不需要设置任何属性。它们其实是类型别名，换句话说，你可以用 TransactionFactory 接口实现类的全限定名或类型别名代替它们。 --> <transactionManager type="JDBC"/> <!--数据源的配置（比如：type="POOLED"）--> <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> </configuration> 测试数据库连通性 @Test public void testConetion() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession SqlSession sqlSession = sqlSessionFactory.openSession(); System.out.println(sqlSession.getConnection()); // 归还连接给数据源 sqlSession.close(); } 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public interface PersonMapper { /** * 查询用户列表 resultType * * @return */ List<Person> selectAll4t(); } 编写映射配置文件src/main/java/com/lihaozhe/mapper/PersonMapper.xml
或者
src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <!-- mapper 映射配置 namespace 命名空间 对应接口的名字 --> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!-- select 用于查询 id 与接口中方法的名字同名 即调用接口中方法的时候 该方法会找到该配置文件中对应的SQL resultType 返回值数据类型 或 泛型为该数据类型的集合 --> <!--查询用户列表 resultType--> <select id="selectAll4t" resultType="com.lihaozhe.pojo.Person"> SELECT * FROM `person` </select> </mapper> 核心配置文件加载映射配置文件 <!-- 既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。 --> <mappers> <!-- 使用相对于类路径的资源引用 --> <!--单独加载某个映射配置文件--> <!--<mapper resource="mybatis/mapper/PersonMapper.xml"/>--> <!-- 使用完全限定资源定位符（URL） --> <!--<mapper url="file:///home/lhz/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--<mapper url="file:///D:/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--加载某包下所有的映射配置文件--> <package name="com.lihaozhe.mapper"/> </mappers> 完整核心配置文件 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis//DTD Config 3.0//EN" "mybatis/dtd/mybatis-3-config.dtd"> <configuration> <!-- 这些属性可以在外部进行配置，并可以进行动态替换。 你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置 --> <properties resource="config.properties" /> <!-- MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。 例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。 --> <!--默认使用的环境 ID（比如：default="development"）。--> <environments default="development"> <!--每个 environment 元素定义的环境 ID（比如：id="development"）。--> <environment id="development"> <!--事务管理器的配置（比如：type="JDBC"）。--> <!-- 事务管理器（transactionManager） 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）： JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。 MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。 这两种事务管理器类型都不需要设置任何属性。它们其实是类型别名，换句话说，你可以用 TransactionFactory 接口实现类的全限定名或类型别名代替它们。 --> <transactionManager type="JDBC"/> <!--数据源的配置（比如：type="POOLED"）--> <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="mybatis/mapper/PersonMapper.xml"/>--> <!-- 使用完全限定资源定位符（URL） --> <!--<mapper url="file:///home/lhz/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--<mapper url="file:///D:/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--加载某包下所有的映射配置文件--> <package name="com.lihaozhe.mapper"/> </mappers> </configuration> 测试src/test/java/com/lihaozhe/mapper/PersonMapperTest.java
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void selectAll4t() { // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行接口中的方法 List<Person> people = mapper.selectAll4t(); // 释放SqlSession资源 sqlSession.close(); // 遍历集合 people.forEach(System.out::println); } }测试结果发现 idCard属性获取到的结果为null，
这是由于查询字段中没有idCard字段，
换言之 idCard属性 没有与 id_card字段形成映射关系
解决方法有两种：
映射配置文件中编写 resultMap
<!--描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。--> <!-- resultMap id 在命名空间中唯一的标识符 type 结果集映射的javabean 或者 泛型为该类型的集合 --> <resultMap id="PersonMap" type="com.lihaozhe.pojo.Person"> <!-- id 主键映射 result 非主键映射 property javabean 中的 filed column datatable 中的 filed --> <id property="id" column="id"/> <result property="id" column="id"/> <result property="uuid" column="uuid"/> <result property="mobile" column="mobile"/> <result property="nickname" column="nickname"/> <result property="idCard" column="id_card"/> </resultMap>修改select id=“selectAll4m” 的属性 resultType=“com.lihaozhe.pojo.Person” 为 resultMap=“PersonMap”
<select id="selectAll4m" resultMap="PersonMap"> SELECT * FROM `person` </select>在接口中增加对应的方法
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 查询用户列表 resultType * * @return */ List<Person> selectAll4t(); /** * 查询用户列表 resultMap * * @return */ List<Person> selectAll4m(); }测试 selectAll4m 方法
@Test public void selectAll4m(){ // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行接口中的方法 List<Person> people = mapper.selectAll4m(); // 释放SqlSession资源 sqlSession.close(); // 遍历集合 people.forEach(System.out::println); } 配置 mapUnderscoreToCamelCase 值为 true在核心配置文件中配置此参数如下
<settings> <!-- 驼峰命名与下划线自动转换 --> <setting name="mapUnderscoreToCamelCase" value="true"/> </settings>测试 selectAll4t 方法
@Test public void selectAll4t(){ // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行接口中的方法 List<Person> people = mapper.selectAll4t(); // 释放SqlSession资源 sqlSession.close(); // 遍历集合 people.forEach(System.out::println); } 在控制台显示log日志在核心配置文件中 设置logImpl 的值为 STDOUT_LOGGING
<settings> <!-- log日志 --> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> 完整的核心配置文件src/main/resources/mybatis/myatis-confog.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis//DTD Config 3.0//EN" "mybatis/dtd/mybatis-3-config.dtd"> <configuration> <!-- 这些属性可以在外部进行配置，并可以进行动态替换。 你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置 --> <properties resource="config.properties" /> <settings> <!-- 驼峰命名与下划线自动转换 --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- log日志 --> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> <!-- MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。 例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。 --> <!--默认使用的环境 ID（比如：default="development"）。--> <environments default="development"> <!--每个 environment 元素定义的环境 ID（比如：id="development"）。--> <environment id="development"> <!--事务管理器的配置（比如：type="JDBC"）。--> <!-- 事务管理器（transactionManager） 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）： JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。 MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。 这两种事务管理器类型都不需要设置任何属性。它们其实是类型别名，换句话说，你可以用 TransactionFactory 接口实现类的全限定名或类型别名代替它们。 --> <transactionManager type="JDBC"/> <!--数据源的配置（比如：type="POOLED"）--> <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="mybatis/mapper/PersonMapper.xml"/>--> <!-- 使用完全限定资源定位符（URL） --> <!--<mapper url="file:///home/lhz/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--<mapper url="file:///D:/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--加载某包下所有的映射配置文件--> <package name="com.lihaozhe.mapper"/> </mappers> </configuration> select 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public interface PersonMapper { /** * 根据手机号查询用户信 * @param mobile * @return */ Person selectByMobile(@Param("mobile") String mobile); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
默认情况下，使用 #{} 参数语法时，MyBatis 会创建 PreparedStatement 参数占位符，并通过占位符安全地设置参数（就像使用 ? 一样）。
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--根据手机号查询用户信--> <select id="selectByMobile" parameterType="java.lang.String" resultType="com.lihaozhe.pojo.Person"> SELECT * FROM `person` WHERE `mobile` = #{mobile}> </select> </mapper> 测试类com.lihaozhe.mapper.PersonMapperTest
注意：测试方法中获取SqlSession对象
@Test public void selectByMobile(){ // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行接口中的方法 Person person = mapper.selectByMobile("13925135946"); // 释放SqlSession资源 sqlSession.close(); // 输出查询结果 System.out.println(person); } #与$的区别默认情况下，使用 #{} 参数语法时，MyBatis 会创建 PreparedStatement 参数占位符，并通过占位符安全地设置参数（就像使用 ? 一样）。
这样做更安全，更迅速，通常也是首选做法，不过有时你就是想直接在 SQL 语句中直接插入一个不转义的字符串。
比如 ORDER BY 子句，MyBatis 就不会修改或转义该字符串了。
需求：查询的条件字段和该字段的值不确定
编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public interface PersonMapper { /** * 根据不确定的字段查询 * @param column * @param value * @return */ Person selectByFiled(@Param("column") String column,@Param("value")String value); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--根据不确定的字段查询--> <select id="selectByFiled" resultType="com.lihaozhe.pojo.Person"> SELECT * FROM `person` WHERE ${column} = #{value} </select> </mapper> 测试类com.lihaozhe.mapper.PersonMapperTest
注意：测试方法中获取SqlSession对象
@Test public void selectByFiled() { // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行接口中的方法 Person person = mapper.selectByFiled("mobile", "18400880850"); // 释放SqlSession资源 sqlSession.close(); // 输出查询结果 System.out.println(person); } 解析结果： ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE mobile = ? ==> Parameters: 18400880850(String) 别名映射起因：parameterType 和 resultType 的值 需要使用类的完全限定名 太麻烦 希望使用 简短的名字来替代 类的完全限定名
在核心配置文件中 配置如下内容：
<typeAliases> <!-- 别名 type 类的完全限定名 alias 别名 --> <!--为某个类指定别名--> <typeAlias alias="login" type="com.lihaozhe.pojo.Login"/> </typeAliases> 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Login; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 上午8:52 */ public interface PersonMapper { /** * 根据唯一身份标识符用户信 * * @param uuid * @return */ Person selectByUuid(@Param("uuid") String uuid);; } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--根据唯一身份标识符用户信--> <select id="selectByUuid" resultType="person"> SELECT * FROM `person` WHERE uuid = #{uuid} </select> </mapper> 测试类com.lihaozhe.mapper.PersonMapperTest
注意：测试方法中获取SqlSession对象
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Login; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public class LoginMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void selectByPid(){ LoginMapper mapper = sqlSession.getMapper(LoginMapper.class); Login login = mapper.selectByPid(3); sqlSession.close(); System.out.println(login); } } 某个包下所有类做别名映射起因：在核心配置文件中单独为某个类做别名映射 如果需要映射的类太多 则过于麻烦 可以指定某个包面所有的类指定别名映射
<typeAliases> <!-- 别名 type 类的完全限定名 alias 别名 --> <!--为某个类指定别名--> <!--<typeAlias alias="person" type="com.lihaozhe.pojo.Person"/>--> <!--为某个包下的所有类指定别名 别名默认为类的首字母小写之后的字符串--> <package name="com.lihaozhe.pojo"/> </typeAliases> 完整核心配置文件src/main/resources/mybatis/myatis-confog.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis//DTD Config 3.0//EN" "mybatis/dtd/mybatis-3-config.dtd"> <configuration> <!-- 这些属性可以在外部进行配置，并可以进行动态替换。 你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置 --> <properties resource="config.properties" /> <settings> <!-- 驼峰命名与下划线自动转换 --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- log日志 --> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> <typeAliases> <!-- 别名 type 类的完全限定名 alias 别名 --> <!--为某个类指定别名--> <!--<typeAlias alias="person" type="com.lihaozhe.pojo.Person"/>--> <!--为某个包下的所有类指定别名 别名默认为类的首字母小写之后的字符串--> <package name="com.lihaozhe.pojo"/> </typeAliases> <!-- MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。 例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。 --> <!--默认使用的环境 ID（比如：default="development"）。--> <environments default="development"> <!--每个 environment 元素定义的环境 ID（比如：id="development"）。--> <environment id="development"> <!--事务管理器的配置（比如：type="JDBC"）。--> <!-- 事务管理器（transactionManager） 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）： JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。 MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。 这两种事务管理器类型都不需要设置任何属性。它们其实是类型别名，换句话说，你可以用 TransactionFactory 接口实现类的全限定名或类型别名代替它们。 --> <transactionManager type="JDBC"/> <!--数据源的配置（比如：type="POOLED"）--> <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="mybatis/mapper/PersonMapper.xml"/>--> <!-- 使用完全限定资源定位符（URL） --> <!--<mapper url="file:///home/lhz/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--<mapper url="file:///D:/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--加载某包下所有的映射配置文件--> <package name="com.lihaozhe.mapper"/> </mappers> </configuration> insert 编写接口com.lihaozhe.mapper.DeptMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Dept; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public interface DeptMapper { /** * 新增部门 * * @param dept * @return */ int insert(@Param("dept") Dept dept); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/DeptMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.DeptMapper"> <!--新增部门--> <insert id="insert"> INSERT INTO `dept` (`dname`) VALUES (#{dept.dname}) </insert> </mapper> 测试类com.lihaozhe.mapper.DeptMapperTest
注意：测试方法中获取SqlSession对象
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Dept; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public class DeptMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void insert(){ // 获取代理对象 DeptMapper mapper = sqlSession.getMapper(DeptMapper.class); // 准备数据 Dept dept = new Dept("人事部"); // 插入之前 输出准备数据 System.out.println("插入之前 dept >>> " + dept); // 调用方法执行 insert 操作 mapper.insert(dept); // 手动提交事务 sqlSessionmit(); // 释放资源 sqlSession.close(); // 插入之后 输出准备数据 System.out.println("插入之后 dept >>> " + dept); } } 解析结果： 插入之前 dept >>> Dept(did=0, dname=人事部) Opening JDBC Connection Created connection 671596011. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2807bdeb] ==> Preparing: INSERT INTO `dept` (`dname`) VALUES (?) ==> Parameters: 人事部(String) <== Updates: 1 Committing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2807bdeb] Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2807bdeb] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2807bdeb] Returned connection 671596011 to pool. 插入之后 dept >>> Dept(did=0, dname=人事部) 新增数据后获取新增数据主键值 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.DeptMapper"> <!--新增部门--> <!-- useGeneratedKeys参数默认是false， 在进行insert操作后是获取不到自增的id的， 如果我们需要用到主键需要将参数值改为true keyProperty javabean 中主键 filed keyColumn datatable 中主键 filed --> <insert id="insert" parameterType="dept" useGeneratedKeys="true" keyProperty="did" keyColumn="did"> INSERT INTO `dept` (`dname`) VALUES (#{dept.dname}) </insert> </mapper> 解析结果： 插入之前 dept >>> Dept(did=0, dname=摸鱼部) Opening JDBC Connection Created connection 1643141512. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@61f05988] ==> Preparing: INSERT INTO `dept` (`dname`) VALUES (?) ==> Parameters: 摸鱼部(String) <== Updates: 1 Committing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@61f05988] Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@61f05988] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@61f05988] Returned connection 1643141512 to pool. 插入之后 dept >>> Dept(did=8, dname=摸鱼部) update 编写接口com.lihaozhe.mapper.DeptMappe
package com.lihaozhe.mapper; import cn.hutool.core.collection.LineIter; import com.lihaozhe.pojo.Dept; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public interface DeptMapper { /** * 修改部门信 * * @param dept * @return */ int update(@Param("dept") Dept dept); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/DeptMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.DeptMapper"> <!--修改部门信--> <update id="update"> UPDATE `dept` SET `dname` = #{dept.dname} WHERE `did` = #{dept.did} </update> </mapper> 测试类com.lihaozhe.mapper.DeptMappeTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Dept; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午8:52 */ public class DeptMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void getSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void update() { // 获取代理对象 DeptMapper mapper = sqlSession.getMapper(DeptMapper.class); // 准备数据 Dept dept = new Dept(8, "企宣部"); // 调用方法执行 update 操作 mapper.update(dept); // 手动提交事务 sqlSessionmit(); // 释放资源 sqlSession.close(); } } delete 编写接口com.lihaozhe.mapper.DeptMappe
package com.lihaozhe.mapper; import cn.hutool.core.collection.LineIter; import com.lihaozhe.pojo.Dept; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/6 上午11:13 */ public interface DeptMapper { /** * 根据部门id删除部门 * * @param did * @return */ int deleteByDid(@Param("did") long did); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/DeptMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.DeptMapper"> <!--根据部门id删除部门--> <delete id="deleteByDid"> DELETE FROM `dept` WHERE `did` = #{did} </delete> </mapper> 测试类com.lihaozhe.mapper.DeptMappeTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Dept; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:56 */ public class DeptMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void getSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void deleteByDid(){ // 获取代理对象 DeptMapper mapper = sqlSession.getMapper(DeptMapper.class); // 调用方法执行 delete 操作 mapper.deleteByDid(8); // 手动提交事务 sqlSessionmit(); // 释放资源 sqlSession.close(); } } 工具类com.lihaozhe.util.mybatis.MyBatisUtil
package com.lihaozhe.util.mybatis; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.ExecutorType; 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.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/13 上午11:39 */ public abstract class MyBatisUtil { private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<>(); private static SqlSessionFactory sqlSessionFactory; private static SqlSession sqlSession; static { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = null; try { reader = Resources.getResourceAsReader(resource); // 构建会话工厂 sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); } catch (IOException e) { throw new RuntimeException(e); } } /** * 获取 SqlSession 对象 * * @return SqlSession 对象 */ public static SqlSession openSqlSession() { if (threadLocal.get() == null) { // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); // 与线程绑定 threadLocal.set(sqlSession); // 返回 SqlSession 对象 return sqlSession; } else { return threadLocal.get(); } } /** * 获取 SqlSession 对象 * * @param executorType SIMPLE,REUSE,BATCH * @return SqlSession 对象 */ public static SqlSession openSqlSession(ExecutorType executorType) { if (threadLocal.get() == null) { // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(executorType); // 与线程绑定 threadLocal.set(sqlSession); // 返回 SqlSession 对象 return sqlSession; } else { return threadLocal.get(); } } /** * 释放资源 */ public static void close() { if (threadLocal.get() != null) { sqlSession = threadLocal.get(); threadLocal.remove(); sqlSession.close(); } } /** * 事务提交 释放资源 */ public static void commitAndClose() { if (threadLocal.get() != null) { sqlSession = threadLocal.get(); threadLocal.remove(); sqlSessionmit(); sqlSession.close(); } } /** * 事务回滚 释放资源 */ public static void rollbackAndClose() { if (threadLocal.get() != null) { sqlSession = threadLocal.get(); threadLocal.remove(); sqlSession.rollback(); sqlSession.close(); } } } 动态SQL @Test public void test() { // 需求：查询某部门的(did) 名字有某个字的(ename) 员工列表 // 分析： // 如果不给部门编号则在所有部门中查找 did 不能为 0 // 如果有部门编号则在某部门内查找 long did = 3; StringBuilder sql = new StringBuilder("select * from person where "); if (did != 0) { sql.append(" did = ?"); sql.append(" and ename like "); sql.append(" '%"); sql.append(" ? "); sql.append("%' "); }else { sql.append(" ename like "); sql.append(" '%"); sql.append(" ? "); sql.append("%' "); } System.out.println(sql.toString()); // select * from person where ename like % ? % // select * from person where did = ? and ename like % ? % }起因：根据不同的查询条件生成不同的SQL语句
sql片段将经常使用的SQL语句定义成SQL片段当使用的时候引导该片段即可 有点像 变量的赋值与引用
编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 根据用户ID查询该用户信 使用SQL片段 * * @return */ Person selectById(@Param("id") long id); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--定义SQL片段--> <sql id="select_person"> SELECT * FROM `person` </sql> <!--根据用户ID查询该用户信 使用SQL片段--> <select id="selectById" resultType="person"> <include refid="select_person"></include> WHERE `id` = #{id} </select> </mapper> 编写测试类com.lihaozhe.mapper.PersonMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void selectById() { // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行接口中的方法 Person person = mapper.selectByid(3); // 释放SqlSession资源 sqlSession.close(); // 输出查询结果 System.out.println(person); } }SQL解析结果：
==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5bc69d3c6aba4a61a81115ba916237f3, 13925135946, 邹庶, 313227198110042264 <== Total: 1 bind 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 模糊查找某姓名中包含某个字的用户 * * @param nickname * @return */ List<Person> selectByNickname(@Param("nickname") String nickname); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<!--定义SQL片段--> <sql id="select_person"> SELECT * FROM `person` </sql> <!--模糊查找某姓名中包含某个字的用户--> <select id="selectByNickname" resultType="person"> <!--模糊查找某姓名中包含某个字的用户--> <select id="selectByNickname" resultType="person"> <bind name="like_nickname" value="'%' + nickname + '%'"/> <include refid="select_person"></include> WHERE `nickname` like #{like_nickname} </select> </select>注意：在bind标签中value属性获取值的时候不需要使用#
编写测试类com.lihaozhe.mapper.PersonMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void getSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void selectByNickname() { // 获取接口代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 准备数据集 String nickname = "孙"; // %孙% StringBuilder param = new StringBuilder(); param.append("%"); if (!StringUtils.isEmpty(nickname)) { param.append(nickname); } param.append("%"); // 执行代理对象中的方法 List<Person> personList = mapper.selectByNickname(param.toString()); // 释放资源 sqlSession.close(); // 输出结果 personList.forEach(System.out::println); } } package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void getSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void selectByNickname() { // 获取接口代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行代理对象中的方法 List<Person> personList = mapper.selectByNickname("孙"); // 释放资源 sqlSession.close(); // 输出结果 personList.forEach(System.out::println); } }结果解析：
==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `nickname` LIKE ? ==> Parameters: %孙%(String) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 2, 82bbfb207b38447e93fffe3c53ba3e5b, 15051340785, 孙陈, 919948197901282822 <== Row: 31, 3db353f3b81b44c6bc6095487d8a5b05, 13628389232, 孙鹃祈, 314211197412052754 <== Row: 72, 2032a25e5245454894e192d8d5b17147, 13352587230, 孙茎, 453355198107241539 <== Total: 3 if 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 模糊查找某姓名中包含某个字的男性或女性用户 * * @param nickname * @return */ List<Person> selectByGenderAndNickname(@Param("gender") Integer gender, @Param("nickname") String nickname); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--定义SQL片段--> <sql id="select_person"> SELECT * FROM `person` </sql> <!--模糊查找某姓名中包含某个字的男性或女性用户--> <select id="selectByGenderAndNickname" resultType="person"> <include refid="select_person"></include> WHERE <if test="gender != null"> if(mod(substr(id_card, 17, 1), 2), 1, 0) = #{gender} </if> <if test="nickname != null and nickname.length > 0"> <bind name="like_nickname" value="'%' + nickname + '%'"/> AND `nickname` like #{like_nickname} </if> </select> </mapper>结果解析:
-- 当方法中参数nickname的值为null或者字符串长度为零 SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `gender` = ? -- 当方法中参数nickname的值不为null且字符串长度大于零 SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `gender` = ? AND `nickname` LIKE ? 编写测试类com.lihaozhe.mapper.PersonMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void oepnSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void selectByGenderAndNickname() { // 获取接口代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行代理对象中的方法 // List<Person> personList = mapper.selectByGenderAndNickname(0,null); List<Person> personList = mapper.selectByGenderAndNickname(1,"孙"); // 释放资源 sqlSession.close(); // 输出结果 personList.forEach(System.out::println); } } where使用上面if相同的方法selectByGenderAndNickname和配置文件
当两个参数同时为null的时候sql语句为 :
SELECT * FROM `perason` WHERE这条sql语句存在语法错误 当没有查询条件的时候做出如下配置
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--定义SQL片段--> <sql id="select_person"> SELECT * FROM `person` </sql> <!--模糊查找某姓名中包含某个字的男性或女性用户--> <select id="selectByGenderAndNickname" resultType="person"> <include refid="select_person"></include> WHERE <if test="gender != null"> if(mod(substr(id_card, 17, 1), 2), 1, 0) = #{gender} </if> <if test="nickname != null and nickname.length > 0"> <bind name="like_nickname" value="'%' + nickname + '%'"/> AND `nickname` like #{like_nickname} </if> </select> </mapper> choose (when, otherwise)有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。
需求：id, uuid, mobile 多个查询条件选择其中一个
编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * `id`, `uuid`, `mobile` 多个查询条件选择其中一个 * @param person * @return */ Person selectByIdOrUuidOrMobile(@Param("person") Person person); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<!--定义SQL片段--> <sql id="select_person"> SELECT * FROM `person` </sql> <!--`id`, `uuid`, `mobile` 多个查询条件选择其中一个--> <select id="selectByIdOrUuidOrMobile" resultType="person"> <include refid="select_person"></include> <where> <choose> <when test="person.id != null and person.id > 0"> `id` = #{person.id} </when> <when test="person.uuid != null and person.uuid.length > 0"> `uuid` = #{person.uuid} </when> <otherwise> `mobile` = #{person.mobile} </otherwise> </choose> </where> </select>解析结果：
-- 只传入mobile SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `mobile` = ? -- 传入uuid SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `uuid` = ? -- 传入id SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? 编写测试类com.lihaozhe.mapper.PersonMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void selectByIdOrUuidOrMobile() { // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 准备数据 Person person = new Person(); // SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `mobile` = ? person.setMobile("13352587230"); // SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `uuid` = ? person.setUuid("2032a25e5245454894e192d8d5b17147"); // SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? person.setId(33); // 执行接口中的方法 person = mapper.selectByIdOrUuidOrMobile(person); // SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `nickname` LIKE ? // 释放SqlSession资源 sqlSession.close(); // 输出查询结果 System.out.println(person); } } trim 编写接口com.lihaozhe.mapper.EmpMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Emp; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/8 上午10:32 */ public interface EmpMapper { /** * 动态SQL if 按照部门ID和姓名中部分关键字查找 * 如果没有传递部门ID则在所有部门中查找 * 如果传递部门ID但没有传递姓名中的关键字则查找该部门下所有员工列表 * 如果部门ID和姓名中的关键字都没有传递则查找所有员工列表 * * @param emp * @return */ List<Emp> selcetByDidAndEname(@Param("emp") Emp emp); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/EmpMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.EmpMapper"> <!-- 动态SQL if 按照部门ID和姓名中部分关键字查找 如果没有传递部门ID则在所有部门中查找 如果传递部门ID但没有传递姓名中的关键字则查找该部门下所有员工列表 如果部门ID和姓名中的关键字都没有传递则查找所有员工列表 --> <select id="selectByDidAndEname" resultType="emp"> SELECT * FROM `emp` <trim prefix="where" prefixOverrides="AND|OR"> <if test="emp.did != null and emp.did > 0"> `did` = #{emp.did} </if> <if test="emp.ename != null and emp.ename.length > 0"> <bind name="like_ename" value="'%' + emp.ename + '%'"/> AND `ename` like #{like_ename} </if> </trim> </select> </mapper>解析 结果：
-- ename 孙 SELECT `eid`, `ename`, `did` FROM `emp` WHERE `ename` Like ? -- ename "" SELECT `eid`, `ename`, `did` FROM `emp` -- did 3 SELECT `eid`, `ename`, `did` FROM `emp` WHERE `did` = ? -- did 3 并且 ename 孙 SELECT `eid`, `ename`, `did` FROM `emp` WHERE `did` = ? AND `ename` Like ? 编写测试类com.lihaozhe.mapper.EmpMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Emp; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/8 下午12:02 */ public class EmpMapperTest { @Test public void selcetByDidAndEname(){ // 使用工具类获取 SqlSession 对象 SqlSession sqlSession = MyBatisUtil.getSqlSession(); // 获取接口代理对象 EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); // 准备数据 Emp emp = new Emp(); // SELECT `eid`, `ename`, `did` FROM `emp` WHERE `ename` Like ? emp.setEname("孙"); // SELECT `eid`, `ename`, `did` FROM `emp` // emp.setEname(""); // SELECT `eid`, `ename`, `did` FROM `emp` WHERE `did` = ? emp.setDid(3); // SELECT `eid`, `ename`, `did` FROM `emp` WHERE `did` = ? AND `ename` Like ? // 执行 接口 中的方法 List<Emp> emps = mapper.selcetByDidAndEname(emp); // 使用工具类 释放资源 MyBatisUtil.close(); // 输出结果 emps.forEach(System.out::println); } } set用于动态更新语句的类似解决方案叫做 set, set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。
需求：更新 person表 中的个别字段
编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 修改员工表数据 * * @param person * @return */ int updateById(@Param("person") Person person); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--修改员工表数据--> <update id="updateById" parameterType="person"> UPDATE `person` <set> <if test="person.nickname != null and person.nickname.length > 0"> `nickname` = #{person.nickname}, </if> <if test="person.mobile != null and person.mobile.length == 11"> `mobile` = #{person.mobile}, </if> <if test="person.idCard != null and (person.idCard.length == 18 or person.idCard.length == 15)"> `id_card` = #{person.idCard} </if> </set> WHERE `id` = #{person.id} </update> </mapper>或者：
<!--修改员工信--> <update id="updateById"> UPDATE `person` <trim prefix="set" suffixOverrides=","> <if test="person.nickname != null and person.nickname.length > 0"> `nickname` = #{person.nickname}, </if> <if test="person.mobile != null and person.mobile.length == 11"> `mobile` = #{person.mobile}, </if> <if test="person.idCard != null and (person.idCard.length == 18 or person.idCard.length == 15)"> `id_card` = #{person.idCard} </if> </trim> WHERE `id` = #{person.id} </update> 编写测试类com.lihaozhe.mapper.PersonMapperTest
package com.lihaozhe.mapper; import cn.binarywang.tools.generator.ChineseIDCardNumberGenerator; import cn.binarywang.tools.generator.ChineseMobileNumberGenerator; import cn.binarywang.tools.generator.ChineseNameGenerator; import cn.hutool.core.util.IdUtil; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.ArrayList; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void updateById() { // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 准备数据 Person person = new Person(); String mobile = ChineseMobileNumberGenerator.getInstance().generate(); System.out.println(mobile); // UPDATE `person` SET `mobile` = ? WHERE `id` = ? person.setMobile(mobile); person.setId(3); // 执行接口中的方法 mapper.updateById(person); // 事务提交 sqlSessionmit(); // 释放SqlSession资源 sqlSession.close(); // 输出结果 if (status > 0) { System.out.println("☺"); } else { System.out.println("o(╯□╰)o"); } } } foreach select 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 查找多个id的用户列表 * * @param ids * @return */ List<Person> selectByIds(@Param("ids") Long... ids); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--定义SQL片段--> <sql id="select_person"> SELECT * FROM `person` </sql> <!--查找多个id的用户列表--> <select id="selectByIds" resultType="person"> <include refid="select_person"></include> <where> `id` IN <foreach collection="ids" index="index" item="id" open="(" separator="," close=")"> #{id} </foreach> </where> </select> </mapper> 编写测试类com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import cn.binarywang.tools.generator.ChineseIDCardNumberGenerator; import cn.binarywang.tools.generator.ChineseMobileNumberGenerator; import cn.binarywang.tools.generator.ChineseNameGenerator; import cn.hutool.core.util.IdUtil; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.ArrayList; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void selectByIds() { // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行接口中的方法 List<Person> personList = mapper.selectByIds(1L, 3L, 5L); // 释放SqlSession资源 sqlSession.close(); // 输出查询结果 personList.forEach(System.out::println); } } delete 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 根据传入的id删除用户 * * @param ids * @return */ int delByIds(@Param("ids") Long... ids); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--根据传入的id删除用户--> <delete id="delByIds"> DELETE FROM `person` <where> `id` IN <foreach collection="ids" index="index" item="id" open="(" separator="," close=")"> #{id} </foreach> </where> </delete> </mapper> 编写测试类com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import cn.binarywang.tools.generator.ChineseIDCardNumberGenerator; import cn.binarywang.tools.generator.ChineseMobileNumberGenerator; import cn.binarywang.tools.generator.ChineseNameGenerator; import cn.hutool.core.util.IdUtil; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.ArrayList; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void delByIds() { // 获取该接口的代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行接口中的方法 mapper.delByIds(1L, 3L, 5L); // 事务提交 sqlSessionmit(); // 释放SqlSession资源 sqlSession.close(); // 输出结果 if (status > 0) { System.out.println("☺"); System.out.println(status + " 条记录被删除"); } else { System.out.println("o(╯□╰)o"); } } } insert清空person表
truncate person; 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 新增用户列列表 * * @param personList * @return */ int insertAll(@Param("personList") List<Person> personList); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <!--新增用户列列表--> <insert id="insertAll"> INSERT INTO `person` (`uuid`,`mobile`,`nickname`,`id_card`) VALUES <foreach collection="personList" index="index" item="person" separator=","> (#{person.uuid},#{person.mobile},#{person.nickname},#{person.idCard}) </foreach> </insert> </mapper> 编写测试类com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import cn.binarywang.tools.generator.ChineseIDCardNumberGenerator; import cn.binarywang.tools.generator.ChineseMobileNumberGenerator; import cn.binarywang.tools.generator.ChineseNameGenerator; import cn.hutool.core.util.IdUtil; import com.lihaozhe.pojo.Person; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.ArrayList; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void insertAll() { // 准备数据 ArrayList<Person> personList = new ArrayList<>(); for (int i = 0; i < 200; i++) { Person person = new Person(); person.setUuid(IdUtil.fastSimpleUUID()); person.setMobile(ChineseMobileNumberGenerator.getInstance().generate()); person.setNickname(ChineseNameGenerator.getInstance().generate()); person.setIdCard(ChineseIDCardNumberGenerator.getInstance().generate()); System.out.println(person); personList.add(person); } // 获取接口代理对象 PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 执行代理对象中的方法 int status = mapper.insertAll(personList); // 事务提交 sqlSessionmit(); // 释放资源 sqlSession.close(); // 输出结果 if (status > 0) { System.out.println("☺"); System.out.println("新增了 " + status + " 条记录"); } else { System.out.println("o(╯□╰)o"); } } } 性能 @Test public void testConetion() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession 同时设置批处理 SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH); System.out.println(sqlSession.getConnection()); // 归还连接给数据源 sqlSession.close(); } 工具类修改 package com.lihaozhe.util.mybatis; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.ExecutorType; 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.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/13 上午11:39 */ public abstract class MyBatisUtil { private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<>(); private static SqlSessionFactory sqlSessionFactory; private static SqlSession sqlSession; static { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = null; try { reader = Resources.getResourceAsReader(resource); // 构建会话工厂 sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); } catch (IOException e) { throw new RuntimeException(e); } } /** * 获取 SqlSession 对象 * * @return SqlSession 对象 */ public static SqlSession openSqlSession() { if (threadLocal.get() == null) { // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); // 与线程绑定 threadLocal.set(sqlSession); // 返回 SqlSession 对象 return sqlSession; } else { return threadLocal.get(); } } /** * 获取 SqlSession 对象 * * @param executorType SIMPLE,REUSE,BATCH * @return SqlSession 对象 */ public static SqlSession openSqlSession(ExecutorType executorType) { if (threadLocal.get() == null) { // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(executorType); // 与线程绑定 threadLocal.set(sqlSession); // 返回 SqlSession 对象 return sqlSession; } else { return threadLocal.get(); } } /** * 释放资源 */ public static void close() { if (threadLocal.get() != null) { sqlSession = threadLocal.get(); threadLocal.remove(); sqlSession.close(); } } /** * 事务提交 释放资源 */ public static void commitAndClose() { if (threadLocal.get() != null) { sqlSession = threadLocal.get(); threadLocal.remove(); sqlSessionmit(); sqlSession.close(); } } /** * 事务回滚 释放资源 */ public static void rollbackAndClose() { if (threadLocal.get() != null) { sqlSession = threadLocal.get(); threadLocal.remove(); sqlSession.rollback(); sqlSession.close(); } } } select 一对一 resultType 编写接口com.lihaozhe.mapper.LoginMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Login; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:27 */ public interface LoginMapper { /** * 使用账号和密码登录 获取用户信 * * @param login 登录参数 account password * @return */ Person selectPersonByAccountAndPassword01(@Param("login") Login login); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/LoginMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.LoginMapper"> <!--使用账号和密码登录 获取用户信--> <select id="selectPersonByAccountAndPassword01" resultType="person"> SELECT p.id, nickname FROM login l INNER JOIN person p WHERE pid = p.id AND account = #{login.account} AND auth_text = #{login.authText} </select> </mapper> 编写测试类com.lihaozhe.mapper.LoginMapper.Test
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Login; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:29 */ public class LoginMapperTest { @Test public void selectPersonByAccountAndPassword01(){ Login login = new Login("13925135946", "123456"); SqlSession sqlSession = MyBatisUtil.openSqlSession(); LoginMapper mapper = sqlSession.getMapper(LoginMapper.class); Person person = mapper.selectPersonByAccountAndPassword01(login); MyBatisUtil.close(); System.out.println(person); } } resultMap 同一映射配置文件内 编写接口com.lihaozhe.mapper.LoginMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Login; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:27 */ public interface LoginMapper { /** * 用户登录 * * @param login 登录参数 account password * @return */ Person selectByAccountAndPassword02(@Param("login") Login login); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/LoginMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.LoginMapper"> <resultMap id="PersonMap" type="person"> <id property="id" column="id"/> <result property="uuid" column="uuid"/> <result property="mobile" column="mobile"/> <result property="nickname" column="nickname"/> <result property="idCard" column="id_card"/> </resultMap> <!--使用账号和密码登录 获取用户信--> <select id="selectPersonByAccountAndPassword02" resultMap="PersonMap"> SELECT p.id, nickname FROM login l INNER JOIN person p WHERE pid = p.id AND account = #{login.account} AND auth_text = #{login.authText} </select> </mapper> 编写测试类com.lihaozhe.mapper.LoginMapper.Test
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Login; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:29 */ public class LoginMapperTest { @Test public void selectPersonByAccountAndPassword02(){ Login login = new Login("13925135946", "123456"); SqlSession sqlSession = MyBatisUtil.openSqlSession(); LoginMapper mapper = sqlSession.getMapper(LoginMapper.class); Person person = mapper.selectPersonByAccountAndPassword02(login); MyBatisUtil.close(); System.out.println(person); } } resultMap 跨射配置文件内 编写接口com.lihaozhe.mapper.LoginMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Login; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:27 */ public interface LoginMapper { /** * 用户登录 * * @param login 登录参数 account password * @return */ Person selectByAccountAndPassword03(@Param("login") Login login); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/LoginMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.LoginMapper"> <!--使用账号和密码登录 获取用户信--> <select id="selectPersonByAccountAndPassword03" resultMap="com.lihaozhe.mapper.PersonMapper.PersonMap"> SELECT p.id, nickname FROM login l INNER JOIN person p WHERE pid = p.id AND account = #{login.account} AND auth_text = #{login.authText} </select> </mapper> 编写测试类com.lihaozhe.mapper.LoginMapper.Test
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Login; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:29 */ public class LoginMapperTest { @Test public void selectPersonByAccountAndPassword03(){ Login login = new Login("13925135946", "123456"); SqlSession sqlSession = MyBatisUtil.openSqlSession(); LoginMapper mapper = sqlSession.getMapper(LoginMapper.class); Person person = mapper.selectPersonByAccountAndPassword03(login); MyBatisUtil.close(); System.out.println(person); } } association 编写VO类com.lihaozhe.vo.PersonVo
package com.lihaozhe.vo; import com.lihaozhe.pojo.Login; import com.lihaozhe.pojo.Person; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 下午2:19 */ public class PersonVo implements Serializable { private static final long serialVersionUID = -2348274078216811958L; /** * 登录信 */ private Login login; /** * 员工信 */ private Person person; } 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.vo.PersonVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:27 */ public interface PersonMapper { /** * 根据id获取用户详细信包括登录信 * * @param id 用户ID * @return */ PersonVo selectPersonVoById(@Param("id") long id); } 在核心配置文件配置别名映射 <typeAliases> <package name="com.lihaozhe.pojo"/> <package name="com.lihaozhe.vo"/> </typeAliases> 编写映射配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <resultMap id="PersonVoMap" type="personVo"> <association property="login"> <id property="id" column="lid"/> <result property="account" column="account"/> <result property="authText" column="auth_text"/> <result property="pid" column="pid"/> </association> <association property="person"> <id property="id" column="pid"/> <result property="uuid" column="uuid"/> <result property="mobile" column="mobile"/> <result property="nickname" column="nickname"/> <result property="idCard" column="id_card"/> </association> </resultMap> <!--根据id获取用户详细信包括登录信--> <select id="selectPersonVoById" resultMap="PersonVoMap"> SELECT l.id AS lid, account, auth_text, pid, uuid, mobile, nickname, id_card FROM login l inner join person p WHERE pid = p.id and pid = #{id} </select> </mapper> 编写测试类com.lihaozhe.mapper.PersonMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.vo.PersonVo; import com.lihaozhe.util.mybatis.MyBatisUtil; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午3:29 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void openSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sessionFactory.openSession(); } @Test public void selectPersonVoById(){ PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); PersonVo personVo = mapper.selectPersonVoById(3L); sqlSession.close(); System.out.println(personVo); } } 多对一写法与一对一完全一致
下面的案例使用关联查询和子查询分别实现
编写VO类com.lihaozhe.vo.SonVo
package com.lihaozhe.vo; import com.lihaozhe.pojo.Father; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 上午9:46 */ @Data @NoArgsConstructor @AllArgsConstructor public class SonVo implements Serializable { private static final long serialVersionUID = -203988976020008362L; /** * 儿子ID */ private long sId; /** * 儿子姓名 */ private String sName; /** * 该儿子父亲ID */ private long fId; /** * 该儿子父亲信 */ private Father father; }com.lihaozhe.mapper.SonMapper
package com.lihaozhe.mapper; import com.lihaozhe.vo.SonVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 下午3:01 */ public interface SonMapper { /** * 根据儿子ID查询儿子和该儿子父亲的信 * * @param sid * @return */ SonVo selectSonVoBySid(@Param("sid") long sid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/SonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.SonMapper"> <!--根据儿子ID查询儿子和该儿子父亲的信--> <resultMap id="SonVoMap" type="sonVo"> <id property="sId" column="s_id"/> <result property="sName" column="s_name"/> <result property="fId" column="fid"/> <association property="father"> <id property="fId" column="fid"/> <result property="fName" column="f_name"/> </association> </resultMap> <select id="selectSonVoBySid" resultMap="SonVoMap"> SELECT s_id, s_name, s.f_id AS fid, f_name FROM son s INNER JOIN father f ON s.f_id = f.f_id AND s_id = #{sid} </select> </mapper> 编写测试类com.lihaozhe.mapper.SonMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.SonVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 下午3:13 */ public class SonMapperTest { @Test public void selectSonVoBySid() { SqlSession sqlSession = MyBatisUtil.openSqlSession(); SonMapper mapper = sqlSession.getMapper(SonMapper.class); SonVo sonVo = mapper.selectSonVoBySid(3L); MyBatisUtil.close(); System.out.println(sonVo); } }com.lihaozhe.mapper.FatherMapper
package com.lihaozhe.mapper; import com.lihaozhe.vo.FatherVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 上午11:15 */ public interface FatherMapper { /** * 根据父亲ID获取父亲信 * * @param fid * @return */ Father selectFatherById(@Param("fid") long fid); }com.lihaozhe.mapper.SonMapper
package com.lihaozhe.mapper; import com.lihaozhe.vo.SonVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 上午11:08 */ public interface SonMapper { /** * 根据儿子ID查询儿子和该儿子父亲的信 * * @param sid * @return */ SonVo selectSonVoById(@Param("sid") long sid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/FatherMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.FatherMapper"> <!--根据父亲ID获取父亲信--> <select id="selectFatherById" resultType="father"> SELECT * FROM `father` WHERE `f_id` = #{fid} </select> </mapper>src/main/resources/com/lihaozhe/mapper/SonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.SonMapper"> <!--根据儿子ID查询儿子和该儿子父亲的信--> <resultMap id="SonVoMapper" type="sonVo"> <id property="sId" column="s_id"/> <result property="sName" column="s_name"/> <result property="fId" column="f_id"/> <association property="father" column="f_id" select="com.lihaozhe.mapper.FatherMapper.selectFatherById"/> </resultMap> <select id="selectSonVoById" resultMap="SonVoMapper"> SELECT * FROM `son` WHERE `s_id` = #{sid} </select> </mapper> 编写测试类com.lihaozhe.mapper.FatherMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.FatherVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 上午11:22 */ public class FatherMapperTest { @Test public void selectFatherById(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); FatherMapper mapper = sqlSession.getMapper(FatherMapper.class); Father father = mapper.selectFatherById(1L); MyBatisUtil.close(); System.out.println(father); } }com.lihaozhe.mapper.SonMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.SonVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 上午11:33 */ public class SonMapperTest { @Test public void selectSonVoById() { SqlSession sqlSession = MyBatisUtil.openSqlSession(); SonMapper mapper = sqlSession.getMapper(SonMapper.class); SonVo sonVo = mapper.selectSonVoById(3L); MyBatisUtil.close(); System.out.println(sonVo); } }解析SQL
==> Preparing: SELECT s_id, s_name,f_id FROM son WHERE s_id = ? ==> Parameters: 1(Long) <== Columns: s_id, s_name, f_id <== Row: 1, 李金吒, 1 ====> Preparing: SELECT f_id, f_name FROM father WHERE f_id = ? ====> Parameters: 1(Integer) <==== Columns: f_id, f_name <==== Row: 1, 李靖 <==== Total: 1 <== Total: 1 一对多下面的案例使用子查询和联合查询分别实现
编写VO类com.lihaozhe.vo.FatherVo
package com.lihaozhe.vo; import com.lihaozhe.pojo.Son; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 上午10:27 */ @Data @NoArgsConstructor @AllArgsConstructor public class FatherVo implements Serializable { private static final long serialVersionUID = -1335512987974717220L; /** * 父亲ID */ private long fId; /** * 父亲姓名 */ private String fName; /** * 该父亲的儿子们 */ private List<Son> sons; }com.lihaozhe.mapper.SonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Son; import com.lihaozhe.vo.SonVo; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 上午11:08 */ public interface SonMapper { /** * 根据父亲ID获取该父亲的儿子列表 * @param fid * @return */ List<Son> selectAllByFId(@Param("fid") long fid); }com.lihaozhe.mapper.FatherMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Father; import com.lihaozhe.vo.FatherVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 上午11:15 */ public interface FatherMapper { /** * 根据父亲ID获取父亲及其儿子们的信 * * @param fid * @return */ FatherVo selectFatherVoById(@Param("fid") long fid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/SonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.SonMapper"> <!--根据父亲ID获取该父亲的儿子列表--> <select id="selectAllByFId" resultType="son"> select * from son where f_id = #{fid}; </select> </mapper>src/main/resources/com/lihaozhe/mapper/FatherMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.FatherMapper"> <!--根据父亲ID获取父亲及其儿子们的信--> <resultMap id="FatherVoMap" type="fatherVo"> <id property="fId" column="f_id"/> <result property="fName" column="f_name"/> <collection property="sons" ofType="son" column="f_id" select="com.lihaozhe.mapper.SonMapper.selectAllByFId"/> </resultMap> <select id="selectFatherVoById" resultMap="FatherVoMap"> select * from father where f_id = #{fid}; </select> </mapper> 编写测试类com.lihaozhe.mapper.SonMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Son; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.SonVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 上午11:33 */ public class SonMapperTest { @Test public void selectAllByFId(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); SonMapper mapper = sqlSession.getMapper(SonMapper.class); List<Son> sons = mapper.selectAllByFId(1L); MyBatisUtil.close(); sons.forEach(System.out::println); } }com.lihaozhe.mapper.FatherMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Father; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.FatherVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 上午11:22 */ public class FatherMapperTest { @Test public void selectFatherVoById(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); FatherMapper mapper = sqlSession.getMapper(FatherMapper.class); FatherVo fatherVo = mapper.selectFatherVoById(1L); MyBatisUtil.close(); System.out.println(fatherVo); } }解析SQL
==> Preparing: SELECT f_id, f_name FROM father WHERE f_id = ? ==> Parameters: 1(Long) <== Columns: f_id, f_name <== Row: 1, 李靖 ====> Preparing: SELECT s_id, s_name,f_id FROM son WHERE f_id = ? ====> Parameters: 1(Integer) <==== Columns: s_id, s_name, f_id <==== Row: 1, 李金吒, 1 <==== Row: 2, 李木吒, 1 <==== Row: 3, 李哪吒, 1 <==== Total: 3 <== Total: 1com.lihaozhe.mapper.FatherMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Father; import com.lihaozhe.vo.FatherVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 下午3:49 */ public interface FatherMapper { /** * 根据父亲ID获取父亲及其儿子们的信 * * @param fid * @return */ FatherVo selectFatherVoBySid(@Param("fid") long fid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/FatherMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.FatherMapper"> <!--根据父亲ID获取父亲及其儿子们的信--> <resultMap id="FatherVoMapper" type="fatherVo"> <id property="fId" column="fid"/> <result property="fName" column="f_name"/> <collection property="sons" ofType="son"> <id property="sId" column="s_id"/> <result property="sName" column="s_name"/> <result property="fId" column="fid"/> </collection> </resultMap> <select id="selectFatherVoBySid" resultMap="FatherVoMapper"> select f.f_id as fid, f_name, s_id, s_name from father f inner join son s on f.f_id = s.f_id and f.f_id = #{fid} </select> </mapper> 编写测试类com.lihaozhe.mapper.FatherMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Father; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.FatherVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/10 下午3:52 */ public class FatherMapperTest { @Test public void selectFatherVoBySid(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); FatherMapper mapper = sqlSession.getMapper(FatherMapper.class); FatherVo fatherVo = mapper.selectFatherVoBySid(1L); MyBatisUtil.close(); System.out.println(fatherVo); } } 多对多- 直接多对多
- 间接多对多 将多对多拆成两个一对多 或 两个多对一
需求：查找某图书类目下的所有图书信
编写VO类com.lihaozhe.vo.CategoryVo
package com.lihaozhe.vo; import com.lihaozhe.pojo.Book; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 上午11:27 */ @Data @NoArgsConstructor @AllArgsConstructor public class CategoryVo implements Serializable { private static final long serialVersionUID = 5565769402064534797L; /** * 分类ID */ private long cid; /** * 分类名称 */ private String cname; /** * 某分类的图书列表 */ private List<Book> books; } 编写接口com.lihaozhe.mapper.CategoryMapper
package com.lihaozhe.mapper; import com.lihaozhe.vo.CategoryVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 上午11:28 */ public interface CategoryMapper { /** * 根据分类ID获取分类及其分类下的图书列表 * * @param cid * @return */ CategoryVo selectCategoryVoByCid(@Param("cid") long cid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/CategoryMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.CategoryMapper"> <!--根据分类ID获取分类及其分类下的图书列表--> <resultMap id="CategoryVoMap" type="categoryVo"> <id property="cid" column="cid"/> <id property="cname" column="cname"/> <collection property="books" ofType="book"> <id property="bid" column="bid"/> <result property="bname" column="bname"/> </collection> </resultMap> <select id="selectCategoryVoByCid" resultMap="CategoryVoMap"> select cid, cname, bid, bname from category inner join book_category inner join book on cid = m_cid and bid = m_bid and cid = #{cid} </select> </mapper> 编写测试类com.lihaozhe.mapper.CategoryMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.CategoryVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 上午11:34 */ public class CategoryMapperTest { @Test public void selectCategoryVoByCid(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); CategoryMapper mapper = sqlSession.getMapper(CategoryMapper.class); CategoryVo categoryVo = mapper.selectCategoryVoByCid(3L); MyBatisUtil.close(); System.out.println(categoryVo); } }需求：查找某图书的分类信
编写VO类com.lihaozhe.vo.BookVo
package com.lihaozhe.vo; import com.lihaozhe.pojo.Category; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 上午11:36 */ @Data @NoArgsConstructor @AllArgsConstructor public class BookVo implements Serializable { private static final long serialVersionUID = 6785352134653400094L; /** * 书的ID */ private long bid; /** * 书名 */ private String bname; /** * 某图书的分类信列表 */ private List<Category> categories; } 编写接口com.lihaozhe.mapper.BookMapper
package com.lihaozhe.mapper; import com.lihaozhe.vo.BookVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 上午11:38 */ public interface BookMapper { /** * 根据图书ID查询图书信包括该图书的分类信 * * @param bid * @return */ BookVo selectBookVoByBid(@Param("bid") long bid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/BookMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.BookMapper"> <!--根据分类ID获取分类及其分类下的图书列表--> <resultMap id="BookVoMap" type="bookVo"> <id property="bid" column="bid"/> <result property="bname" column="bname"/> <collection property="categories" ofType="category"> <id property="cid" column="cid"/> <id property="cname" column="cname"/> </collection> </resultMap> <select id="selectBookVoByBid" resultMap="BookVoMap"> select bid, bname, cid, cname from book inner join book_category inner join category on bid = m_bid and cid = m_cid and bid = #{bid} </select> </mapper> 编写测试类 package com.lihaozhe.mapper; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.BookVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 上午11:34 */ public class BookMapperTest { @Test public void test(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); BookMapper mapper = sqlSession.getMapper(BookMapper.class); BookVo bookVo = mapper.selectBookVoByBid(3L); MyBatisUtil.close(); System.out.println(bookVo); } } 间接多对多 编写中间表映射类com.lihaozhe.pojo.StudentCourse
package com.lihaozhe.pojo; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; @Data @NoArgsConstructor @AllArgsConstructor public class StudentCourse implements Serializable { private static final long serialVersionUID = 7294808647412902387L; /** * 学生ID */ private long sId; /** * 课程ID */ private long cId; /** * 学生信 */ private Student student; /** * 课程信 */ private Course course; } 编写接口com.lihaozhe.mapper.CourseMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Course; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/11 下午3:04 */ public interface CourseMapper { /** * 根据课程ID查找课程 * * @param cid * @return */ Course selectCourseByCid(@Param("cid") long cid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/CourseMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.CourseMapper"> <!--根据课程ID查找课程--> <select id="selectCourseByCid" resultType="course"> SELECT * FROM `course` WHERE `c_id` = #{cid} </select> </mapper> 编写测试类com.lihaozhe.mapper.CourseMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Course; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/11 下午3:06 */ public class CourseMapperTest { @Test public void selectCourseByCid(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); CourseMapper mapper = sqlSession.getMapper(CourseMapper.class); Course course = mapper.selectCourseByCid(3L); MyBatisUtil.close(); System.out.println(course); } } 编写接口com.lihaozhe.mapper.StudentMapper
package com.lihaozhe.mapper; import com.lihaozhe.vo.StudentVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/11 下午3:08 */ public interface StudentMapper { /** * 根据学生ID 查询学生信 包含所需课程的ID列表 * * @param sid * @return */ StudentVo selectStudentVoBySid(@Param("sid") long sid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/StudentMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.StudentMapper"> <!--根据学生ID 查询学生信 包含所需课程的ID列表--> <resultMap id="StudentVoMap" type="studentVo"> <id property="sId" column="sid"/> <result property="sName" column="s_name"/> <collection property="studentCourses" ofType="studentCourse"> <result property="sId" column="sid"/> <result property="cId" column="c_id"/> <association property="course" column="c_id" select="com.lihaozhe.mapper.CourseMapper.selectCourseByCid"/> </collection> </resultMap> <select id="selectStudentVoBySid" resultMap="StudentVoMap"> select stu.s_id as sid, s_name, c_id from student as stu inner join student_course sc on stu.s_id = sc.s_id and stu.s_id = #{sid} </select> </mapper> 编写测试类com.lihaozhe.mapper.StudentMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.StudentVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/11 下午3:23 */ public class StudentMapperTest { @Test public void selectStudentVoBySid() { SqlSession sqlSession = MyBatisUtil.openSqlSession(); StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); StudentVo studentVo = mapper.selectStudentVoBySid(3L); System.out.println(studentVo); System.out.println(studentVo.getSName()); studentVo.getStudentCourses().forEach(studentCourse -> System.out.println(studentCourse.getCourse())); } } SQL解析 ==> Preparing: SELECT s.s_id, s_name, c_id FROM `student` s INNER JOIN `student_course` sc ON s.s_id = sc.s_id AND s.s_id = ? ==> Parameters: 1(Long) <== Columns: s_id, s_name, c_id <== Row: 1, stu01, 1 ====> Preparing: SELECT * FROM `course` WHERE `c_id` = ? ====> Parameters: 1(Integer) <==== Columns: c_id, c_name <==== Row: 1, java <==== Total: 1 <== Row: 1, stu01, 2 ====> Preparing: SELECT * FROM `course` WHERE `c_id` = ? ====> Parameters: 2(Integer) <==== Columns: c_id, c_name <==== Row: 2, scala <==== Total: 1 <== Total: 2 编写接口com.lihaozhe.mapper.StudentMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Student; import com.lihaozhe.vo.StudentVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/11 下午3:08 */ public interface StudentMapper { /** * 根据学生ID 查询学生信 包含所需课程的ID列表 * * @param sid * @return */ StudentVo selectStudentVoBySid(@Param("sid") long sid); /** * 根据学生ID 查询学生信 * * @param sid * @return */ Student selectStudentBySid(@Param("sid") long sid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/StudentMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.StudentMapper"> <!--根据学生ID 查询学生信 包含所需课程的ID列表--> <resultMap id="StudentVoMap" type="studentVo"> <id property="sId" column="sid"/> <result property="sName" column="s_name"/> <collection property="studentCourses" ofType="studentCourse"> <result property="sId" column="sid"/> <result property="cId" column="c_id"/> <association property="course" column="c_id" select="com.lihaozhe.mapper.CourseMapper.selectCourseByCid"/> </collection> </resultMap> <select id="selectStudentVoBySid" resultMap="StudentVoMap"> select stu.s_id as sid, s_name, c_id from student as stu inner join student_course sc on stu.s_id = sc.s_id and stu.s_id = #{sid} </select> <!--根据学生ID 查询学生信--> <select id="selectStudentBySid" resultType="student"> SELECT * FROM `student` WHERE `s_id` = #{sid} </select> </mapper> 编写测试类com.lihaozhe.mapper.StudentMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Student; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.StudentVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/11 下午3:23 */ public class StudentMapperTest { @Test public void selectStudentVoBySid() { SqlSession sqlSession = MyBatisUtil.openSqlSession(); StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); StudentVo studentVo = mapper.selectStudentVoBySid(3L); System.out.println(studentVo); System.out.println(studentVo.getSName()); studentVo.getStudentCourses().forEach(studentCourse -> System.out.println(studentCourse.getCourse())); } @Test public void selectStudentBySid() { SqlSession sqlSession = MyBatisUtil.openSqlSession(); StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); Student student = mapper.selectStudentBySid(3L); System.out.println(student); } } 编写VO类com.lihaozhe.vo.CourseVo
package com.lihaozhe.vo; import com.lihaozhe.pojo.StudentCourse; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/14 下午12:22 */ @Data @NoArgsConstructor @AllArgsConstructor public class CourseVo implements Serializable { private static final long serialVersionUID = -2649136027724661116L; /** * 课程ID */ private long cId; /** * 课程名称 */ private String cName; /** * 课程关联信 */ private List<StudentCourse> studentCourses; } 编写接口com.lihaozhe.mapper.CourseMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Course; import com.lihaozhe.vo.CourseVo; import org.apache.ibatis.annotations.Param; /** * @author 李昊哲 * @version 1.0.0 2022/7/11 下午3:04 */ public interface CourseMapper { /** * 根据课程ID查找课程 * * @param cid * @return */ Course selectCourseByCid(@Param("cid") long cid); /** * 根据课程ID查找课程 包含所需课程的ID列表 * * @param cid * @return */ CourseVo selectCourseVoByCid(@Param("cid") long cid); } 编写映射配置文件src/main/resources/com/lihaozhe/mapper/CourseMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.CourseMapper"> <!--根据课程ID查找课程--> <select id="selectCourseByCid" resultType="course"> SELECT * FROM `course` WHERE `c_id` = #{cid} </select> <!--根据课程ID查找课程 包含所需课程的ID列表--> <resultMap id="CourseVoMap" type="courseVo"> <id property="cId" column="cid"/> <result property="cName" column="c_name"/> <collection property="studentCourses" ofType="studentCourse"> <result property="sId" column="sid"/> <result property="cId" column="c_id"/> <association property="student" column="s_id" select="com.lihaozhe.mapper.StudentMapper.selectStudentBySid"/> </collection> </resultMap> <select id="selectCourseVoByCid" resultMap="CourseVoMap"> select c.c_id as cid, c_name, s_id from course as c inner join student_course sc on c.c_id = sc.c_id and c.c_id = #{cid} </select> </mapper> 编写测试类com.lihaozhe.mapper.CourseMapperTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Course; import com.lihaozhe.util.mybatis.MyBatisUtil; import com.lihaozhe.vo.CourseVo; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/11 下午3:06 */ public class CourseMapperTest { @Test public void selectCourseByCid(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); CourseMapper mapper = sqlSession.getMapper(CourseMapper.class); Course course = mapper.selectCourseByCid(3L); MyBatisUtil.close(); System.out.println(course); } @Test public void selectCourseVoByCid(){ SqlSession sqlSession = MyBatisUtil.openSqlSession(); CourseMapper mapper = sqlSession.getMapper(CourseMapper.class); CourseVo courseVo = mapper.selectCourseVoByCid(3L); System.out.println(courseVo); System.out.println(courseVo.getCName()); courseVo.getStudentCourses().forEach(studentCourse -> System.out.println(studentCourse.getStudent())); } } 延迟加载 @Test public void selectStudentVoBySid01() { SqlSession sqlSession = MyBatisUtil.getSqlSession(); StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); StudentVo studentVo = mapper.selectStudentVoBySid(1L); MyBatisUtil.close(); System.out.println(studentVo.getSName()); } Opening JDBC Connection Created connection 379121284. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] ==> Preparing: SELECT s.s_id, s_name, c_id FROM `student` s INNER JOIN `student_course` sc ON s.s_id = sc.s_id AND s.s_id = ? ==> Parameters: 1(Long) <== Columns: s_id, s_name, c_id <== Row: 1, stu01, 1 ====> Preparing: SELECT * FROM `course` WHERE `c_id` = ? ====> Parameters: 1(Integer) <==== Columns: c_id, c_name <==== Row: 1, java <==== Total: 1 <== Row: 1, stu01, 2 ====> Preparing: SELECT * FROM `course` WHERE `c_id` = ? ====> Parameters: 2(Integer) <==== Columns: c_id, c_name <==== Row: 2, scala <==== Total: 1 <== Total: 2 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] Returned connection 379121284 to pool. @Test public void selectStudentVoBySid02() { SqlSession sqlSession = MyBatisUtil.getSqlSession(); StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); StudentVo studentVo = mapper.selectStudentVoBySid(1L); MyBatisUtil.close(); studentVo.getStudentCourses().forEach(studentCourse -> System.out.println(studentCourse.getCourse())); } Opening JDBC Connection Created connection 379121284. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] ==> Preparing: SELECT s.s_id, s_name, c_id FROM `student` s INNER JOIN `student_course` sc ON s.s_id = sc.s_id AND s.s_id = ? ==> Parameters: 1(Long) <== Columns: s_id, s_name, c_id <== Row: 1, stu01, 1 ====> Preparing: SELECT * FROM `course` WHERE `c_id` = ? ====> Parameters: 1(Integer) <==== Columns: c_id, c_name <==== Row: 1, java <==== Total: 1 <== Row: 1, stu01, 2 ====> Preparing: SELECT * FROM `course` WHERE `c_id` = ? ====> Parameters: 2(Integer) <==== Columns: c_id, c_name <==== Row: 2, scala <==== Total: 1 <== Total: 2 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] Returned connection 379121284 to pool. Course(cId=1, cName=java) Course(cId=2, cName=scala) Process finished with exit code 0从上面第一个案例可以看出客户只想查看学生休并不想看学生所学专业信 但是 仍然执行了子查询，
我们希望 当想看该学生和该学生所学专业详细信的之后才走子查询而只看学生信的时候不走子查询
于是我们开启了延迟加载
核心配置文件 <!-- 延迟加载 --> <!-- lazyLoadingEnabled 延迟加载总开关 --> <setting name="lazyLoadingEnabled" value="true"/> <!-- true 侵入式延迟 访问主对象及主对象里面的属性时，不光会加载主对象（即从数据库中查询主对象的信），还会一同加载关联对象。 积极加载 false 深度延迟 访问主对象属性时，只加载主，只有当访问关联对象的属性时，才会去加载关联对象。 按需加载 默认值为false --> <!--<setting name="aggressiveLazyLoading" value="true"/>--> <!--<setting name="aggressiveLazyLoading" value="false"/>--> <!-- fetchType="lazy" lazy 支持懒加载 eager 不支持懒加载 --> <!--<collection property="emps" ofType="emp" column="did" select="com.lihaozhe.mapper.EmpMapper.selectByDid" fetchType="lazy"/>--> <!--<collection property="emps" ofType="emp" column="did" select="com.lihaozhe.mapper.EmpMapper.selectByDid" fetchType="eager"/>--> @Test public void selectStudentVoBySid01() { SqlSession sqlSession = MyBatisUtil.getSqlSession(); StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); StudentVo studentVo = mapper.selectStudentVoBySid(1L); MyBatisUtil.close(); System.out.println(studentVo.getSName()); } Opening JDBC Connection Created connection 379121284. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] ==> Preparing: SELECT s.s_id, s_name, c_id FROM `student` s INNER JOIN `student_course` sc ON s.s_id = sc.s_id AND s.s_id = ? ==> Parameters: 1(Long) <== Columns: s_id, s_name, c_id <== Row: 1, stu01, 1 <== Row: 1, stu01, 2 <== Total: 2 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1698ee84] Returned connection 379121284 to pool. @Test public void selectStudentVoBySid02() { SqlSession sqlSession = MyBatisUtil.getSqlSession(); StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); StudentVo studentVo = mapper.selectStudentVoBySid(1L); MyBatisUtil.close(); studentVo.getStudentCourses().forEach(studentCourse -> System.out.println(studentCourse.getCourse())); } Opening JDBC Connection Created connection 544966217. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] ==> Preparing: SELECT s.s_id, s_name, c_id FROM `student` s INNER JOIN `student_course` sc ON s.s_id = sc.s_id AND s.s_id = ? ==> Parameters: 1(Long) <== Columns: s_id, s_name, c_id <== Row: 1, stu01, 1 <== Row: 1, stu01, 2 <== Total: 2 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] Returned connection 544966217 to pool. Opening JDBC Connection Checked out connection 544966217 from pool. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] ==> Preparing: SELECT * FROM `course` WHERE `c_id` = ? ==> Parameters: 1(Integer) <== Columns: c_id, c_name <== Row: 1, java <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] Returned connection 544966217 to pool. Course(cId=1, cName=java) Opening JDBC Connection Checked out connection 544966217 from pool. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] ==> Preparing: SELECT * FROM `course` WHERE `c_id` = ? ==> Parameters: 2(Integer) <== Columns: c_id, c_name <== Row: 2, scala <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@207b8649] Returned connection 544966217 to pool. Course(cId=2, cName=scala) Process finished with exit code 0 侵入式延迟 积极加载侵入式延迟 访问主对象及主对象里面的属性时，不光会加载主对象（即从数据库中查询主对象的信），还会一同加载关联对象。 积极加载
深度延迟 访问主对象属性时，只加载主，只有当访问关联对象的属性时，才会去加载关联对象。 按需加载
<settings> <!-- 驼峰命名与下划线自动转换 --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- log日志 --> <setting name="logImpl" value="STDOUT_LOGGING"/> <!-- 延迟加载 --> <!-- lazyLoadingEnabled 延迟加载总开关 --> <setting name="lazyLoadingEnabled" value="true"/> <!-- true 侵入式延迟 访问主对象及主对象里面的属性时，不光会加载主对象（即从数据库中查询主对象的信），还会一同加载关联对象。 积极加载 false 深度延迟 访问主对象属性时，只加载主，只有当访问关联对象的属性时，才会去加载关联对象。 按需加载 默认值为false --> <!--<setting name="aggressiveLazyLoading" value="true"/>--> <!--<setting name="aggressiveLazyLoading" value="false"/>--> <!--开启缓存--> <!--<setting name="cacheEnabled" value="true" />--> </settings>映射配置文件中子查询设置fetchType
-
fetchType=“eager” 不支持懒加载
-
fetchType=“lzsy” 支持懒加载
com.lihaozhe.mapper.CacheTest
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/12 上午10:05 */ public class CacheTest { @Test public void testCache01(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(); PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); Person person01 = mapper.selectById(3L); Person person02 = mapper.selectById(3L); MyBatisUtil.close(); } } Opening JDBC Connection Created connection 1552870927. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5ee0074d47064285b8c5925534d70d84, 17674856547, 令狐荡, 649152199504171242 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Returned connection 1552870927 to pool. package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/12 上午10:05 */ public class CacheTest { @Test public void testCache02() { SqlSession sqlSession = MyBatisUtil.openSqlSession(); PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); Person person01 = mapper.selectById(6L); Person person02 = mapper.selectById(3L); MyBatisUtil.close(); }0 } Opening JDBC Connection Created connection 1552870927. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 6(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 6, aebe1bd701b24fb89347c78bb3aaf938, 13651227685, 欧阳脓, 644102199803081660 <== Total: 1 ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5ee0074d47064285b8c5925534d70d84, 17674856547, 令狐荡, 649152199504171242 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Returned connection 1552870927 to pool. package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/12 上午10:05 */ public class CacheTest { @Test public void testCache03() { SqlSession sqlSession = MyBatisUtil.openSqlSession(); PersonMapper mapper01 = sqlSession.getMapper(PersonMapper.class); PersonMapper mapper02 = sqlSession.getMapper(PersonMapper.class); Person person01 = mapper01.selectById(3L); Person person02 = mapper02.selectById(3L); MyBatisUtil.close(); } } Opening JDBC Connection Created connection 1552870927. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5ee0074d47064285b8c5925534d70d84, 17674856547, 令狐荡, 649152199504171242 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Returned connection 1552870927 to pool. package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/12 上午10:05 */ public class CacheTest { @Test public void testCache04() { SqlSession sqlSession01 = MyBatisUtil.getSqlSession(); PersonMapper mapper01 = sqlSession01.getMapper(PersonMapper.class); Person person01 = mapper01.selectById(3L); SqlSession sqlSession02 = MyBatisUtil.getSqlSession(); PersonMapper mapper02 = sqlSession02.getMapper(PersonMapper.class); Person person02 = mapper02.selectById(3L); MyBatisUtil.close(); } } Opening JDBC Connection Created connection 1552870927. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5ee0074d47064285b8c5925534d70d84, 17674856547, 令狐荡, 649152199504171242 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Returned connection 1552870927 to pool. package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/12 上午10:05 */ public class CacheTest { @Test public void testCache05() { SqlSession sqlSession01 = MyBatisUtil.getSqlSession(); PersonMapper mapper01 = sqlSession01.getMapper(PersonMapper.class); Person person01 = mapper01.selectById(3L); MyBatisUtil.close(); SqlSession sqlSession02 = MyBatisUtil.getSqlSession(); PersonMapper mapper02 = sqlSession02.getMapper(PersonMapper.class); Person person02 = mapper02.selectById(3L); MyBatisUtil.close(); } } Opening JDBC Connection Created connection 1552870927. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5ee0074d47064285b8c5925534d70d84, 17674856547, 令狐荡, 649152199504171242 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Returned connection 1552870927 to pool. Opening JDBC Connection Checked out connection 1552870927 from pool. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5ee0074d47064285b8c5925534d70d84, 17674856547, 令狐荡, 649152199504171242 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5c8eee0f] Returned connection 1552870927 to pool. 结论：mybatis一级缓存默认开启，同一个SqlSession中查询条件一致则走一级缓存,一级缓存不能跨SqlSession 二级缓存MyBatis如果想跨SqlSession缓存则可以采用将查询结果缓存至第三方，例如:
- ehcache
- memcached
- redis
maven项目提前在pom.xml文件中增加相关依赖
缓存遇到commit失效
ehcache二级缓存在映射配置文件中加入
src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
添加以下内容
<!-- flushInterval（刷新间隔）属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。 size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。 readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提 升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false。 --> <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true" />在需要缓存的查找标签增加设置useCache=true
<select id="selectById" resultType="person" useCache="true"> <include refid="select_person"></include> <where> `id` = #{id} </where> </select> 编写测试类 package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/12 上午10:05 */ public class CacheTest { @Test public void testCache05() { SqlSession sqlSession01 = MyBatisUtil.openSqlSession(); PersonMapper mapper01 = sqlSession01.getMapper(PersonMapper.class); Person person01 = mapper01.selectById(3L); MyBatisUtil.close(); SqlSession sqlSession02 = MyBatisUtil.openSqlSession(); PersonMapper mapper02 = sqlSession02.getMapper(PersonMapper.class); Person person02 = mapper02.selectById(3L); MyBatisUtil.close(); } } Cache Hit Ratio [com.lihaozhe.mapper.PersonMapper]: 0.0 Opening JDBC Connection Created connection 1045731788. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5ee0074d47064285b8c5925534d70d84, 17674856547, 令狐荡, 649152199504171242 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] Returned connection 1045731788 to pool. Cache Hit Ratio [com.lihaozhe.mapper.PersonMapper]: 0.5 package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.jupiter.api.Test; /** * @author 李昊哲 * @version 1.0.0 2022/7/12 上午10:05 */ public class CacheTest { @Test public void testCache05() { SqlSession sqlSession01 = MyBatisUtil.openSqlSession(); PersonMapper mapper01 = sqlSession01.getMapper(PersonMapper.class); Person person01 = mapper01.selectById(3L); MyBatisUtil.close(); SqlSession sqlSession02 = MyBatisUtil.openSqlSession(); PersonMapper mapper02 = sqlSession02.getMapper(PersonMapper.class); Person person02 = mapper02.selectById(3L); MyBatisUtil.close(); } } Cache Hit Ratio [com.lihaozhe.mapper.PersonMapper]: 0.0 Opening JDBC Connection Created connection 1045731788. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 6(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 6, aebe1bd701b24fb89347c78bb3aaf938, 13651227685, 欧阳脓, 644102199803081660 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] Returned connection 1045731788 to pool. Cache Hit Ratio [com.lihaozhe.mapper.PersonMapper]: 0.0 Opening JDBC Connection Checked out connection 1045731788 from pool. Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] ==> Preparing: SELECT `id`, `uuid`, `mobile`, `nickname`, `id_card` FROM `person` WHERE `id` = ? ==> Parameters: 3(Long) <== Columns: id, uuid, mobile, nickname, id_card <== Row: 3, 5ee0074d47064285b8c5925534d70d84, 17674856547, 令狐荡, 649152199504171242 <== Total: 1 Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3e5499cc] Returned connection 1045731788 to pool. 分页插件 pagehelper 引入maven依赖 <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>5.3.1</version> </dependency> 完整pom.xml文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="maven.apache/POM/4.0.0" xmlns:xsi="www.w3/2001/XMLSchema-instance" xsi:schemaLocation="maven.apache/POM/4.0.0 maven.apache/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.lihaozhe</groupId> <artifactId>mybatis</artifactId> <version>1.0-SNAPSHOT</version> <name>mybatis</name> <packaging>jar</packaging> <properties> <jdk.version>17</jdk.version> <mavenpiler.source>17</mavenpiler.source> <mavenpiler.target>17</mavenpiler.target> <mavenpilerpilerVersion>17</mavenpilerpilerVersion> <mavenpiler.encoding>utf-8</mavenpiler.encoding> <project.build.sourceEncoding>utf-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <maven.test.failure.ignore>true</maven.test.failure.ignore> <maven.test.skip>true</maven.test.skip> <junit.version>5.8.2</junit.version> <fastjson.version>2.0.6</fastjson.version> <gson.version>2.9.0</gson.version> <hutool.version>5.8.0.M3</hutool.version> <jackson.version>2.13.3</jackson.version> <lombok.version>1.18.24</lombok.version> <java-testdata.version>1.1.2</java-testdata.version> </properties> <dependencies> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> <dependency> <groupId>com.github.binarywang</groupId> <artifactId>java-testdata-generator</artifactId> <version>${java-testdata.version}</version> </dependency> <!--commons--> <!--commons-lang3--> <dependency> <groupId>org.apachemons</groupId> <artifactId>commons-lang3</artifactId> <version>3.8.1</version> </dependency> <!--commons-io--> <dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.11.0</version> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-engine</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>${hutool.version}</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>${lombok.version}</version> <scope>provided</scope> </dependency> <!--json--> <!--fastjson--> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>${fastjson.version}</version> </dependency> <!--gson--> <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>${gson.version}</version> </dependency> <!--jackson--> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>${jackson.version}</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-annotations</artifactId> <version>${jackson.version}</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>${jackson.version}</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.datatype</groupId> <artifactId>jackson-datatype-jsr310</artifactId> <version>${jackson.version}</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.29</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.10</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.8</version> </dependency> <dependency> <groupId>org.ehcache</groupId> <artifactId>ehcache</artifactId> <version>3.9.9</version> </dependency> <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-ehcache</artifactId> <version>1.2.2</version> </dependency> <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>5.3.1</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.20</version> </dependency> </dependencies> <build> <!--项目打包文件名--> <!--<finalName>news</finalName>--> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-war-plugin</artifactId> <version>3.3.2</version> </plugin> <!-- 编译级别 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <!-- 设置编译字符编码 --> <encoding>UTF-8</encoding> <!-- 设置编译jdk版本 --> <source>${jdk.version}</source> <target>${jdk.version}</target> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-clean-plugin</artifactId> <version>3.2.0</version> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-resources-plugin</artifactId> <version>3.2.0</version> </plugin> <!-- 打包的时候跳过测试junit begin --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>2.22.2</version> <configuration> <skip>true</skip> </configuration> </plugin> </plugins> </build> </project> 编写核心配置文件追加以下内容
<plugins> <!-- com.github.pagehelper为PageHelper类所在包名 --> <plugin interceptor="com.github.pagehelper.PageInterceptor"> <!-- 方言 --> <property name="helperDialect" value="mysql"/> <!-- 默认值为 false，当该参数设置为 true 时， 如果 pageSize=0 或者 RowBounds.limit = 0 就会查询出全部的结果 (相当于没有执行分页查询，但是返回结果仍然是 Page 类型)。 --> <property name="pageSizeZero" value="true"/> <!-- 分页合理化参数，默认值为false。当该参数设置为 true 时， pageNum<=0 时会查询第一页， pageNum>pages（超过总数时），会查询最后一页。 默认false 时，直接根据参数进行查询 --> <property name="reasonable" value="true" /> </plugin> </plugins> page参数详解 1. helperDialect ：分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。 你可以配置 helperDialect 属性来指定分页插件使用哪种方言。配置时，可以使用下面的缩写值：oracle , mysql , mariadb , sqlite , hsqldb , postgresql , db2 , sqlserver , informix , h2 , sqlserver2012 , derby 特别注意：使用 SqlServer2012 数据库时，需要手动指定为 sqlserver2012 ，否则会使用 SqlServer2005 的方式进行分页。 你也可以实现 AbstractHelperDialect ，然后配置该属性为实现类的全限定名称即可使用自定义的实现方法。 2. offsetAsPageNum ：默认值为 false ，该参数对使用 RowBounds 作为分页参数时有效。 当该参数设置为 true 时，会将 RowBounds 中的 offset 参数当成 pageNum 使用，可以用页码和页面大小两个参数进行分页。 3. rowBoundsWithCount ：默认值为 false ，该参数对使用 RowBounds 作为分页参数时有效。当该参数设置为 true 时，使用 RowBounds 分页会进行 count 查询。 4. pageSizeZero ：默认值为 false ，当该参数设置为 true 时，如果 pageSize=0 或者 RowBounds.limit = 0 就会查询出全部的结果（相当于没有执行分页查询，但是返回结果仍然是 Page 类型）。 5. reasonable ：分页合理化参数，默认值为 false 。当该参数设置为 true 时， pageNum<=0 时会查询第一页， pageNum>pages （超过总数时），会查询最后一页。默认 false 时，直接根据参数进行查询。 6. params ：为了支持 startPage(Object params) 方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值， 可以配置 pageNum,pageSize,count,pageSizeZero,reasonable ，不配置映射的用默认值， 默认值为 pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero= pageSizeZero 。 7. supportMethodsArguments ：支持通过 Mapper 接口参数来传递分页参数，默认值 false ，分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页。 使用方法可以参考测试代码中的 com.github.pagehelper.test.basic 包下的 ArgumentsMapTest 和 ArgumentsObjTest 。 8. autoRuntimeDialect ：默认值为 false 。设置为 true 时，允许在运行时根据多数据源自动识别对应方言的分页 （不支持自动选择 sqlserver2012 ，只能使用 sqlserver ），用法和注意事项参考下面的场景五。 9. closeConn ：默认值为 true 。当使用运行时动态数据源或没有设置 helperDialect 属性自动获取数据库类型时，会自动获取一个数据库连接， 通过该属性来设置是否关闭获取的这个连接，默认 true 关闭，设置为 false 后，不会关闭获取的连接，这个参数的设置要根据自己选择的数据源来决定。 完整核心配置文件 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis//DTD Config 3.0//EN" "mybatis/dtd/mybatis-3-config.dtd"> <configuration> <!-- 这些属性可以在外部进行配置，并可以进行动态替换。 你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置 --> <properties resource="config.properties"/> <settings> <!-- 驼峰命名与下划线自动转换 --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- log日志 --> <setting name="logImpl" value="STDOUT_LOGGING"/> <!-- 延迟加载 --> <!-- lazyLoadingEnabled 延迟加载总开关 --> <setting name="lazyLoadingEnabled" value="true"/> <!-- true 侵入式延迟 访问主对象及主对象里面的属性时，不光会加载主对象（即从数据库中查询主对象的信），还会一同加载关联对象。 积极加载 false 深度延迟 访问主对象属性时，只加载主对象，只有当访问关联对象的属性时，才会去加载关联对象。 按需加载 默认值为false --> <!--<setting name="aggressiveLazyLoading" value="true"/>--> <setting name="aggressiveLazyLoading" value="false"/> <!--开启二级缓存--> <setting name="cacheEnabled" value="true"/> </settings> <typeAliases> <!-- 别名 type 类的完全限定名 alias 别名 --> <!--为某个类指定别名--> <!--<typeAlias alias="person" type="com.lihaozhe.pojo.Person"/>--> <!--为某个包下的所有类指定别名 别名默认为类的首字母小写之后的字符串--> <package name="com.lihaozhe.pojo"/> <package name="com.lihaozhe.vo"/> </typeAliases> <plugins> <!-- com.github.pagehelper为PageHelper类所在包名 --> <plugin interceptor="com.github.pagehelper.PageInterceptor"> <!-- 方言 --> <property name="helperDialect" value="mysql"/> <!-- 默认值为 false，当该参数设置为 true 时， 如果 pageSize=0 或者 RowBounds.limit = 0 就会查询出全部的结果 (相当于没有执行分页查询，但是返回结果仍然是 Page 类型)。 --> <property name="pageSizeZero" value="true"/> <!-- 分页合理化参数，默认值为false。当该参数设置为 true 时， pageNum<=0 时会查询第一页， pageNum>pages（超过总数时），会查询最后一页。 默认false 时，直接根据参数进行查询 --> <property name="reasonable" value="true"/> </plugin> </plugins> <!-- MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。 例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。 --> <!--默认使用的环境 ID（比如：default="development"）。--> <environments default="development"> <!--每个 environment 元素定义的环境 ID（比如：id="development"）。--> <environment id="development"> <!--事务管理器的配置（比如：type="JDBC"）。--> <!-- 事务管理器（transactionManager） 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）： JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。 MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。 这两种事务管理器类型都不需要设置任何属性。它们其实是类型别名，换句话说，你可以用 TransactionFactory 接口实现类的全限定名或类型别名代替它们。 --> <transactionManager type="JDBC"/> <!--数据源的配置（比如：type="POOLED"）--> <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="mybatis/mapper/PersonMapper.xml"/>--> <!-- 使用完全限定资源定位符（URL） --> <!--<mapper url="file:///home/lhz/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--<mapper url="file:///D:/mybatis/src/main/resources/com/lihaozhe/mapper/PersonMapper.xml"/>--> <!--加载某包下所有的映射配置文件--> <package name="com.lihaozhe.mapper"/> </mappers> </configuration> 编写接口com.lihaozhe.mapper.PersonMapper
package com.lihaozhe.mapper; import com.lihaozhe.pojo.Person; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:47 */ public interface PersonMapper { /** * 分页查询 * @param person * @return */ List<Person> select4page(@Param("person") Person person); } 编写映射的配置文件src/main/resources/com/lihaozhe/mapper/PersonMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis//DTD Mapper 3.0//EN" "mybatis/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lihaozhe.mapper.PersonMapper"> <select id="select4page" resultType="person"> SELECT * FROM `person` <trim prefix="where" prefixOverrides="AND|OR"> <if test="person.mobile != null and person.mobile.length > 0 and person.mobile.length < 12"> <bind name="like_mobile" value="'%'+ person.mobile +'%'"/> AND `mobile` LIKE #{like_mobile} </if> <if test="person.mobile != null and person.mobile.length > 0 and person.mobile.length < 12"> <bind name="like_nickname" value="'%'+ person.nickname +'%'"/> AND `nickname` LIKE #{like_nickname} </if> </trim> </select> </mapper> 编写测试类com.lihaozhe.mapper.PersonMapperTest
package com.lihaozhe.mapper; import cn.binarywang.tools.generator.ChineseIDCardNumberGenerator; import cn.binarywang.tools.generator.ChineseMobileNumberGenerator; import cn.binarywang.tools.generator.ChineseNameGenerator; import cn.hutool.core.util.IdUtil; import com.alibaba.fastjson.JSONObject; import com.github.pagehelper.PageHelper; import com.github.pagehelper.PageInfo; import com.lihaozhe.pojo.Person; import com.lihaozhe.util.mybatis.MyBatisUtil; 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 org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.Reader; import java.util.ArrayList; import java.util.List; /** * @author 李昊哲 * @version 1.0.0 2022/7/7 下午1:51 */ public class PersonMapperTest { private SqlSession sqlSession; // JUnit5 @BeforeAll和@BeforeEach注解替换了 JUnit4 中的@Before注解。 // 它⽤于表⽰应在当前类中的每个@Test⽅法之前执⾏注解⽅法。 // 注意：@BeforeAll注解的⽅法必须为静态⽅法，否则它将引发运⾏时错误。 // 注意：@BeforeEach注解的⽅法不得为静态⽅法，否则它将引发运⾏时错误。 @BeforeEach public void getSqlSession() throws IOException { // 核心配置文件classpath路径 String resource = "mybatis/mybatis-config.xml"; // 加载配置文件 Reader reader = Resources.getResourceAsReader(resource); // 构建会话工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 从SqlSessionFactory对象中获取SqlSession sqlSession = sqlSessionFactory.openSession(); } @Test public void select4page(){ PersonMapper mapper = sqlSession.getMapper(PersonMapper.class); // 在执行代理对象中查询方法之前 开启分页 PageHelper.startPage(10,5); // 准备查询条件 Person person = new Person(); // 开启分页后 执行代理对象中的查询方法 List<Person> personList = mapper.select4page(person); sqlSession.close(); PageInfo<Person> pageInfo = new PageInfo<>(personList); System.out.println(pageInfo); System.out.println(JSONObject.toJSONString(pageInfo)); System.out.println(JSONObject.toJSONString(pageInfo.getList())); } }PageInfo类属性介绍
| pageNum | 当前页 |
| pageSize | 每页的数量 |
| size | 当前页的数量 |
| startRow | 由于startRow和endRow不常用，这里说个具体的用法 可以在页面中"显示startRow到endRow 共size条数据" 当前页面第一个元素在数据库中的行号 |
| endRow | |
| pages | 总页数 |
| prePage | 前一页 |
| nextPage | 下一页 |
| isFirstPage | 是否为第一页 |
| isLastPage | 是否为最后一页 |
| hasPreviousPage | 是否有前一页 |
| hasNextPage | 是否有下一页 |
| navigatePages | 导航页码数 |
| navigatepageNums | 所有导航页号 |
| nnavigateFirstPage | 导航条上的第一页 |
| navigateLastPage | 导航条上的最后一页 |
| list | 数据集合 |
| total | 总数量 |
版权声明：本文标题：MyBatis从入门到精通 内容由林淑君副主任自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：http://www.xiehuijuan.com/baike/1686987617a125815.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论