Mybatis 入门及实践

前言

⭐️ 代码地址：https://gitee.com/zhp1221/java/tree/master/lab_04_mybatis

---

⭐️ 这里sql准备了2个文件，为什么分2个库来练习?

因为笔者来练习实现不同数据库之间的使用。原理是切换environment配置。所以大家请自行创建2个数据库,sql文件名为数据库的名称，分别是deep_practice，test

ConnectOptionalEnvironmentUtil ：通过这个工具类的编写，传入environment指定的id（environment在mybatis-config.xml文件里配置），就可实现另一个数据库的使用

ResultMapSqlDemo ：对ConnectOptionalEnvironmentUtil的使用

⭐️ 如果本文章对你们有帮助，记得给笔者点个赞，编写不易！

一. 简介

Mybatis - 官方文档

​ MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

二. 入手案例

2.1 前置准备

2.1.1 Maven依赖

	<dependencies><!-- mysql数据库链接 --><!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.30</version></dependency><!-- mybatis orm层依赖 --><!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.11</version></dependency><!-- junit 测试依赖 --><!-- https://mvnrepository.com/artifact/junit/junit --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency><!-- 简化java臃肿代码依赖包 --><!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.24</version><scope>provided</scope></dependency><!--hutool 工具集合引入--><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.4.7</version><scope>compile</scope></dependency></dependencies>

2.1.2 sql准备

-- 建表
CREATE TABLE `demo` (`id` int NOT NULL AUTO_INCREMENT COMMENT '主键id',`name` varchar(10) DEFAULT NULL COMMENT '姓名',`age` int DEFAULT NULL COMMENT '年龄',PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='mybatis - demo表';-- 测试数据
INSERT INTO `demo` (`id`, `name`, `age`) VALUES (1, '张三', 18);
INSERT INTO `demo` (`id`, `name`, `age`) VALUES (2, '李四', 20);

2.1.3 Log4j2 配置

用于打印sql，方便查看自己所构建的sql语句运行过程

1. Maven引入

		<dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.12.1</version></dependency>

2. log4j2.xml

在resources包下创建

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN"><loggers><Logger name="com.zhanghp" level="debug"></Logger></loggers>
</Configuration>

2.2 代码流程构建步骤

2.2.1 Mybatis前置知识

Mybatis的核心类是SqlSessionFactory，我们需要通过此类来建立数据库连接，并实现增删改查的代码编写。

而SqlSessionFactory实例需通过SqlSessionFactoryBuilder获得。SqlSessionFactoryBuilder则通过XML/Configuration的实例来构建。这里笔者采用的是XML构建SqlSessionFactoryBuilder。

另一种Configuration实例化，读者可通过访问官网链接，进行详细的了解。

2.2.2 步骤流程

1. SqlSessionFactory实例代码编写：数据库与java代码相连的桥梁
2. mybatis-config.xml配置：进行SqlSessionFacotryBuilder实例创建
3. 数据库对应的实体类Demo编写：接收及传递对象
4. DemoMapper.xml编写：进行数据库的增删改查
5. 通过Junit来测试编写的代码

2.2.3 代码实现

目录结构

1. SqlSessionFactory实例代码编写

   /*** XML 中构建 SqlSessionFactory** @author zhanghp* @date 2023/6/25 14:24*/
   public class ConnectionDBWithXml {/*** xml配置路径*/private static final String RESOURCE = "mybatis-config.xml";/*** 连接数据库的工厂类*/private static final SqlSessionFactory SQL_SESSION_FACTORY;static {InputStream resourceAsStream = null;try {// MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。resourceAsStream = Resources.getResourceAsStream(RESOURCE);} catch (IOException e) {e.printStackTrace();}// 初始化SqlSessionFactorySQL_SESSION_FACTORY = new SqlSessionFactoryBuilder().build(resourceAsStream);}public void connect() {// SqlSession 提供了在数据库执行 SQL 命令所需的所有方法try (SqlSession session = SQL_SESSION_FACTORY.openSession()) {// DemoMapper.xml中的select的id：selectOneRecordDemo record = session.selectOne("selectOneRecord");System.out.println(record);System.out.println("---------------------------------");List<Demo> recordList = session.selectList("selectDemo");if (ObjectUtil.isNotEmpty(record)) {recordList.forEach(System.out::println);}}}
   }
   

2. mybatis-config.xml 配置

   我这里创建了一个jdbc.properties文件，目的是为了方便统一管理数据库。

   在mybatis-config.xml文件中，可通过properties属性，来引用该文件，并在环境配置中，通过**${}**来引用jdbc.properties里的属性。

   jdbc.properties

   jdbc_driver=com.mysql.cj.jdbc.Driver
   jdbc_url=jdbc:mysql://127.0.0.1:3306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&allowPublicKeyRetrieval=true
   jdbc_username=root
   jdbc_password=zhp.1221
   

   mybatis-config.xml

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
   <configuration><!-- 引入外部文件配置 --><properties resource="jdbc.properties"/><!-- 类型别名 --><typeAliases><package name="com.zhanghp.dao.pojo"/></typeAliases><!-- 环境配置 --><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="${jdbc_driver}"/><property name="url" value="${jdbc_url}"/><property name="username" value="${jdbc_username}"/><property name="password" value="${jdbc_password}"/></dataSource></environment></environments><mappers><!-- 扫描xml路径 --><mapper resource="mappers/DemoMapper.xml"/></mappers>
   </configuration>
   

3. 实体类Demo

   /*** demo表 - 实体类** @author zhanghp* @date 2023/6/25 14:50*/
   @Data
   @NoArgsConstructor
   @AllArgsConstructor
   public class Demo implements Serializable {private Integer id;private String name;private Integer age;
   }
   

4. DemoMapper.xml

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.zhanghp.dao.pojo.Demo"><!-- 查询全部 --><select id="selectDemo" resultType="demo">select * from demo</select><!-- 查询单个 --><select id="selectOneRecord" resultType="demo">select * from demo where id = 1</select>
   </mapper>
   

5. UT测试用例

   DemoTest.java

   /*** @author zhanghp* @date 2023/6/25 15:00*/
   public class DemoTest {@Testpublic void testConnectAndSelectOneRecord(){final ConnectionDBWithXml connectionDBWithXml = new ConnectionDBWithXml();connectionDBWithXml.connect();}
   }
   

6. 结果打印

   Demo(id=1, name=张三, age=18)
   ---------------------------------
   Demo(id=1, name=张三, age=18)
   Demo(id=2, name=李四, age=20)
   

三. XML映射器

前置代码

ConnectUtil.java

抽离SqlSession实例化，及释放，方便外部类调用

/*** 连接数据库工具类** @author zhanghp* @date 2023/6/25 23:53*/
public class ConnectUtil {/*** xml配置路径*/private static final String RESOURCE = "mybatis-config.xml";public ConnectUtil() {}/*** 获取SqlSession** @return {@link org.apache.ibatis.session.SqlSession}*/public static SqlSession getSqlSession() {InputStream resourceAsStream = null;try {// MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。resourceAsStream = Resources.getResourceAsStream(RESOURCE);} catch (IOException e) {e.printStackTrace();}// 初始化SqlSessionFactory：连接数据库的工厂类SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);// 增删改需要手动提交事务// openSession(true)；设置是否自动提交事务，true为自动提交，false为不自动提交（例子：修改方法）// Spring整合后，就不在需要手动处理事务return sqlSessionFactory.openSession(true);}/*** 释放资源** @param session {@link org.apache.ibatis.session.SqlSession}*/public static void release(SqlSession session) {session.close();}
}

3.1 select

3.1.1 元素属性

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句。
parameterType	将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。
resultType	期望从这条语句中返回结果的类全限定名或别名。 注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。 resultType 和 resultMap 之间只能同时使用一个。
resultMap	对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。 resultType 和 resultMap 之间只能同时使用一个。
flushCache	将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：false。
useCache	将其设置为 true 后，将会导致本条语句的结果被二级缓存缓存起来，默认值：对 select 元素为 true。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。
fetchSize	这是一个给驱动的建议值，尝试让驱动程序每次批量返回的结果行数等于这个设置值。 默认值为未设置（unset）（依赖驱动）。
statementType	可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
resultSetType	FORWARD_ONLY，SCROLL_SENSITIVE, SCROLL_INSENSITIVE 或 DEFAULT（等价于 unset） 中的一个，默认值为 unset （依赖数据库驱动）。
databaseId	如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有不带 databaseId 或匹配当前 databaseId 的语句；如果带和不带的语句都有，则不带的会被忽略。
resultOrdered	这个设置仅针对嵌套结果 select 语句：如果为 true，将会假设包含了嵌套结果集或是分组，当返回一个主结果行时，就不会产生对前面结果集的引用。 这就使得在获取嵌套结果集的时候不至于内存不够用。默认值：false。
resultSets	这个设置仅适用于多结果集的情况。它将列出语句执行后返回的结果集并赋予每个结果集一个名称，多个名称之间以逗号分隔。
parameterType	用于引用外部 parameterMap 的属性，目前已被废弃。请使用行内参数映射和 parameterType 属性。

3.1.2 无参查询

1. 查询全部记录，通过List形式回参

DemoMapper.xml

  	<!-- 查询全部 --><select id="selectDemo" resultType="demo">select *from demo</select>

SelectDemo.java

    /*** 获取全部记录，通过List返回*/public void queryAll() {try {List<Demo> demoList = SQLSESSION.selectList("selectDemo");if (IterUtil.isNotEmpty(demoList)) {demoList.forEach(System.out::println);}} finally {// 释放资源ConnectUtil.release(SQLSESSION);}}

UT测试用例 - SelectTest.java

  	@Testpublic void queryAll() {// select * from demoSELECT_DEMO.queryAll();}

2. 查询全部记录，通过Map形式回参

DemoMapper.xml

    <!-- 查询全部 返回Map集合 --><select id="queryReturnMap" resultType="map">select *from demo</select>

SelectDemo.java

	/*** 获取全部记录，通过Map返回*/public void queryReturnMap() {try {// 第二参数为mapKey：需指定主键名称Map<Integer, Demo> demoMap = SQLSESSION.selectMap("queryReturnMap", "id");if (MapUtil.isNotEmpty(demoMap)) {demoMap.entrySet().forEach(it -> {System.out.println(it.getKey() + "：" + it.getValue());});}} finally {// 释放资源ConnectUtil.release(SQLSESSION);}}

UT测试用例 - SelectTest.java

	@Testpublic void queryReturnMap() {// sql: select * from demoSELECT_DEMO.queryReturnMap();}

3.1.3 传参查询

1.单个参数类型传参

DemoMapper.xml

	<!-- 通过主键id查询单个记录 --><select id="queryById" parameterType="int" resultType="demo">select * from demo where id = #{id}</select>

SelectDemo.java

/*** select demo* * @author zhanghp* @date 2023/6/25 23:30*/
public class SelectDemo {/*** 获取SqlSession*/private final SqlSession SQLSESSION = ConnectUtil.getSqlSession();/*** 通过主键id传参获取对应的一条记录** @param id 主键id*/public void queryById(Integer id) {try {// selectDemo demo = SQLSESSION.selectOne("queryById", 1);System.out.println(demo);} finally {// 释放资源ConnectUtil.release(SQLSESSION);}}
}

UT测试用例 - SelectTest.java

/*** @author zhanghp* @date 2023/6/26 0:04*/
public class SelectTest {private final SelectDemo SELECT_DEMO = new SelectDemo();@Testpublic void queryById() {SELECT_DEMO.queryById(1);}
}

2.多个基础数据类型map集合传参

DemoMapper.xml

	<!-- 通过map查询匹配记录集合 --><select id="queryByMap" parameterType="map" resultType="demo">select * from demo where name = #{name} and age= #{age}</select>

SelectDemo.java

  	/*** 通过map传参获取记录集合** @param map {@link java.util.Map}*/public void queryByMap(Map<String, Object> map) {try {// selectList<Demo> demoList = SQLSESSION.selectList("queryByMap", map);if (IterUtil.isNotEmpty(demoList)) {demoList.forEach(System.out::println);}} finally {// 释放资源ConnectUtil.release(SQLSESSION);}}

UT测试用例 - SelectTest.java

    @Testpublic void queryByMap(){Map<String, Object> map = new HashMap<>();map.put("name", "张三");map.put("age", 18);SELECT_DEMO.queryByMap(map);}

3.引用类型传参

DemoMapper.xml

    <!-- 通过对象demo查询匹配记录集合 --><select id="queryByDemo" parameterType="demo" resultType="demo">select * from demo where age= #{age}</select>

SelectDemo.java

	/*** 通过对象传参获取集合** @param demo {@link com.zhanghp.dao.pojo.Demo}*/public void queryByDemo(Demo demo) {try {List<Demo> demoList = SQLSESSION.selectList("queryByDemo", demo);if (IterUtil.isNotEmpty(demoList)) {demoList.forEach(System.out::println);}} finally {// 释放资源ConnectUtil.release(SQLSESSION);}}

UT测试用例 - SelectTest.java

	@Testpublic void queryByDemo(){final Demo demo = new Demo();demo.setAge(20);SELECT_DEMO.queryByDemo(demo);}

3.2 insert, update&delete

前置

insert update&delete需要手动提交事务，来进行对数据库记录的操作，设置如下

ConnectUtil.java

// 增删改需要手动提交事务
// openSession(true)；设置是否自动提交事务，true为自动提交，false为不自动提交（例子：修改方法）
// Spring整合后，就不在需要手动处理事务
// 或者不设置true，当执行完增删改，可使用sqlSession.commit(),手动提交事务
sqlSessionFactory.openSession(true);

3.2.1 元素属性

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句。
parameterType	将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。
flushCache	将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：（对 insert、update 和 delete 语句）true。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。
statementType	可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
useGeneratedKeys	（仅适用于 insert 和 update）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系型数据库管理系统的自动递增字段），默认值：false。
keyProperty	（仅适用于 insert 和 update）指定能够唯一识别对象的属性，MyBatis 会使用 getGeneratedKeys 的返回值或 insert 语句的 selectKey 子元素设置它的值，默认值：未设置（unset）。如果生成列不止一个，可以用逗号分隔多个属性名称。
keyColumn	（仅适用于 insert 和 update）设置生成键值在表中的列名，在某些数据库（像 PostgreSQL）中，当主键列不是表中的第一列的时候，是必须设置的。如果生成列不止一个，可以用逗号分隔多个属性名称。
databaseId	如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有不带 databaseId 或匹配当前 databaseId 的语句；如果带和不带的语句都有，则不带的会被忽略。
parameterMap	用于引用外部 parameterMap 的属性，目前已被废弃。请使用行内参数映射和 parameterType 属性。

3.2.2 insert

DemoMapper.xml

	 <!-- 插入一条记录 --><insert id="addOne">insert into demovalues (100, '测试', 30)</insert><!-- 通过对象传参，插入一条记录 --><insert id="addOneByDemo" parameterType="demo">insert into demovalues (#{id}, #{name}, #{age})</insert><!-- 通过对象传参，使用主键自增，插入一条记录 --><insert id="addOneByDemoUseGenerateKey" parameterType="demo" useGeneratedKeys="true" keyProperty="id">insert into demovalues (#{id}, #{name}, #{age})</insert>

InsertDemo.java

/*** 插入** @author zhanghp* @date 2023/6/26 8:31*/
public class InsertDemo {/*** 获取SqlSession*/private final SqlSession SQLSESSION = ConnectUtil.getSqlSession();/*** 插入固定数据*/public void addOne() {try{final int rows = SQLSESSION.insert("addOne");System.out.println("插入成功的行数：" + rows);}finally {ConnectUtil.release(SQLSESSION);}}/*** 通过对象作为参数传递，新增一条记录*/public void addOneByDemo(Demo demo) {try{final int rows = SQLSESSION.insert("addOneByDemo", demo);System.out.println("插入成功的行数：" + rows);}finally {ConnectUtil.release(SQLSESSION);}}/*** 通过对象作为参数传递，使用数据库主键自增策略，实现新增一条记录*/public void addOneByDemoUseGenerateKey(Demo demo) {try{final int rows = SQLSESSION.insert("addOneByDemo", demo);System.out.println("插入成功的行数：" + rows);}finally {ConnectUtil.release(SQLSESSION);}}
}

UT测试用例 - InsertTest.java

/*** @author zhanghp* @date 2023/6/26 8:34*/
public class InsertTest {private final InsertDemo insertDemo = new InsertDemo();@Testpublic void addOne(){// sql: insert into demo values (100, '测试', 30)insertDemo.addOne();}@Testpublic void addOneByDemo(){// sql: insert into demo values (4, '小胡', 30)insertDemo.addOneByDemo( new Demo(4, "小胡", 30));}@Testpublic void addOneByDemoUseGenerateKey(){// sql: insert into demo values (null, '小李', 30)insertDemo.addOneByDemoUseGenerateKey( new Demo(null, "小李", 40));}
}

3.2.3 update

DemoMapper.xml

 	 <!-- 更新一条记录 --><update id="updateOne" parameterType="demo">update demoset name = '小陈',age  = 18where id = 1</update><!-- 通过对象传参，更新记录 --><update id="updateByDemo" parameterType="demo">update demoset name =#{name},age  = #{age}where id = #{id}</update>

UpdateDemo.java

/*** 更新** @author zhanghp* @date 2023/6/26 8:31*/
public class UpdateDemo {/*** 获取SqlSession*/private final SqlSession SQLSESSION = ConnectUtil.getSqlSession();/*** 固定更新一条数据*/public void updateOne() {try {final int rows = SQLSESSION.insert("updateOne");System.out.println("更新成功的行数：" + rows);} finally {ConnectUtil.release(SQLSESSION);}}/*** 通过传入的对象，通过主键，更新其余的属性*/public void updateByDemo(Demo demo) {try {final int rows = SQLSESSION.update("updateByDemo", demo);System.out.println("更新成功的行数：" + rows);} finally {ConnectUtil.release(SQLSESSION);}}
}

UT测试用例 - UpdateTest.java

/*** @author zhanghp* @date 2023/6/26 8:34*/
public class UpdateTest {private final UpdateDemo updateDemo = new UpdateDemo();@Testpublic void updateOne() {// sql: update demo set name = '小陈', age = 18 where id = 1updateDemo.updateOne();}@Testpublic void updateByDemo(){// sql: update demo set name = '小胡', age = 50 where id = 4updateDemo.updateByDemo(new Demo(4, "小胡", 50));}
}

3.2.4 delete

DemoMapper.xml

	<!-- 删除一条记录 --><delete id="deleteOne">delete from demo where id = 101</delete><!-- 通过主键id删除一条记录 --><delete id="deleteOneById" parameterType="int">delete from demo where id = #{id}</delete>

DeleteDemo.java

/*** 删除** @author zhanghp* @date 2023/6/26 8:31*/
public class DeleteDemo {/*** 获取SqlSession*/private final SqlSession SQLSESSION = ConnectUtil.getSqlSession();/*** 删除固定一条记录*/public void deleteOne() {try{final int rows = SQLSESSION.delete("deleteOne");System.out.println("删除成功的行数：" + rows);}finally {ConnectUtil.release(SQLSESSION);}}/*** 通过主键id删除固定一条记录*/public void deleteOneById(Integer id) {try{final int rows = SQLSESSION.delete("deleteOneById", id);System.out.println("删除成功的行数：" + rows);}finally {ConnectUtil.release(SQLSESSION);}}
}

UT测试用例 - DeleteTest.java

/*** @author zhanghp* @date 2023/6/26 8:34*/
public class DeleteTest {private final DeleteDemo deleteDemo = new DeleteDemo();@Testpublic void deleteOne(){// sql:  delete from demo where id = 101deleteDemo.deleteOne();}@Testpublic void deleteOneById(){// sql:  delete from demo where id = 100deleteDemo.deleteOneById(100);}
}

3.3 ResultMap - 关联查询

ResultMap里的标签

属性	功能
constructor	用于在实例化类时，注入结果到构造方法中
association	一个复杂类型的关联（一对一）
collection	一个复杂类型的集合（一对多）
discriminator	使用结果值来决定使用哪个 resultMap

resultmap简单使用

resultMapSqlDemo.java

/*** @author zhanghp* @date 2023/6/27 8:45*/
public class ResultMapSqlDemo {private final String ENVIRONMENT = "deep_practice";private final SqlSession SQLSESSION = ConnectOptionalEnvironmentUtil.getSqlSession(ENVIRONMENT);/*** resultMap基本使用*/public void queryResultMap() {try {// test1 : MyBatis 会在幕后自动创建一个 ResultMap，若属性名和列名不匹配，会返回nullfinal List<Emp> results1 = SQLSESSION.selectList("queryResultType");CommonUtil.printList(results1);// test2 : resultMap 映射后，会重新自动转换名称不一致问题final List<Emp> results2 = SQLSESSION.selectList("queryResultMap");CommonUtil.printList(results2);} finally {ConnectUtil.release(SQLSESSION);}}
}

mapper/EmpMapper.xml

<resultMap id="deptResultMap" type="dept"><id property="deptno" column="DEPTNO"></id><result property="dname" column="DNAME"></result><result property="loc" column="LOC"></result></resultMap><resultMap id="empResultMap" type="emp"><id property="empno" column="EMPNO"/><result property="name" column="ENAME"/><result property="job" column="JOB"/><result property="mgr" column="MGR"/><result property="hiredate" column="HIREDATE"/><result property="sal" column="SAL"/><result property="comm" column="COMM"/><result property="deptno" column="DEPTNO"/></resultMap><!-- 查询全部 resultType --><select id="queryResultType" resultType="emp">select *from emp</select><!-- 查询全部 resultMap--><select id="queryResultMap" resultMap="empResultMap">select *from emp</select>

UT用例 - ResultMapSqlTest.java

/*** @author zhanghp* @date 2023/7/2 21:47*/
public class ResultMapSqlTest {private final ResultMapSqlDemo DEMO = new ResultMapSqlDemo();@Testpublic void queryResultMap(){DEMO.queryResultMap();}
}

1. constructor

用于在实例化类时，注入结果到构造方法中

可以这么理解，通过类里写的有参构造器，来进行参数的传递

ps：

要注意构造器入参的顺序，顺序和constructor指定的属性名顺序不同会导致数据为空

属性	功能
idArg	ID 参数；标记出作为 ID 的结果可以帮助提高整体性能
arg	将被注入到构造方法的一个普通结果

ResultMapSqlDemo.java

 	/*** 通过<constructor/>元素查询*/public void queryConstructor() {try {// test1 : MyBatis 会在幕后自动创建一个 ResultMap，若属性名和列名不匹配，会返回nullfinal List<Dept> results = SQLSESSION.selectList("queryConstructor");CommonUtil.printList(results);} finally {ConnectUtil.release(SQLSESSION);}}

Dept.java

/*** @author zhanghp* @date 2023/6/28 9:25*/
@Data
@ToString
@NoArgsConstructor
public class Dept implements Serializable {private Integer deptno;private String dname;private String loc;// 组合一个Emp的List集合作为属性private List<Emp> empList;public Dept(Integer deptno, String dname, List<Emp> empList) {this.deptno = deptno;this.dname = dname;this.empList = empList;}public Dept(Integer deptno, String dname, String loc) {this.deptno = deptno;this.loc = loc;this.dname = dname;}}

mappers/DeptMapp.xml

  <resultMap id="deptResultMap" type="dept"><!-- 按照有参构造器，依次注入，若参数顺序不一致，可通过构造器调整参数位置，来达到效果--><constructor><idArg column="deptno" javaType="Integer"/><arg column="dname" javaType="String"/><!-- 通过deptno传参，传入constructorQuery方法，来进行参数--><arg select="com.zhanghp.dao.mapper.EmpMapper.constructorQuery" javaType="List" column="deptno" /></constructor><result property="loc" column="LOC"/></resultMap><!-- 查询全部 通过resultMap constructor标签 --><select id="queryConstructor" resultMap="deptResultMap">select *from dept</select>

UT用例 - ResultMapSql.java

	@Testpublic void queryConstructor(){DEMO.queryConstructor();}

---

2. association（一对一）

关联（association）元素处理“有一个”类型的关系。 比如，在我们的示例中，一个博客有一个用户。关联结果映射和其它类型的映射工作方式差不多。 你需要指定目标属性名以及属性的javaType（很多时候 MyBatis 可以自己推断出来），在必要的情况下你还可以设置 JDBC 类型，如果你想覆盖获取结果值的过程，还可以设置类型处理器。

关联的不同之处是，你需要告诉 MyBatis 如何加载关联。MyBatis 有两种不同的方式加载关联：

• 嵌套 Select 查询：通过执行另外一个 SQL 映射语句来加载期望的复杂类型。
• 嵌套结果映射：使用嵌套的结果映射来处理连接结果的重复子集。

resultMapSqlDemo.java

	/*** 一对一*/public void queryAssociation() {try {final List<Emp> results1 = SQLSESSION.selectList("queryAssociation");CommonUtil.printList(results1);} finally {ConnectUtil.release(SQLSESSION);}}/*** 一对一* 引用select，引用外部的id*/public void queryAssociation2() {try {// association对应的select属性查询dept表，是一个一个sql查询，比较消耗时间final List<Emp> results1 = SQLSESSION.selectList("queryAssociation2");CommonUtil.printList(results1);} finally {ConnectUtil.release(SQLSESSION);}}/*** 一对一* 引用select，引用内部的id*/public void queryAssociation3() {try {// association对应的select属性查询dept表，是一个一个sql查询，比较消耗时间final List<Emp> results1 = SQLSESSION.selectList("queryAssociation3");CommonUtil.printList(results1);} finally {ConnectUtil.release(SQLSESSION);}}

mapper/EmpMapper.xml

  <!-- 一对一查询 --><resultMap id="oneToOne" type="emp"><id property="empno" column="EMPNO"/><result property="name" column="ENAME"/><result property="job" column="JOB"/><result property="mgr" column="MGR"/><result property="hiredate" column="HIREDATE"/><result property="sal" column="SAL"/><result property="comm" column="COMM"/><result property="deptno" column="DEPTNO"/><association property="deptObject" javaType="dept" resultMap="deptResultMap"/></resultMap><resultMap id="oneToOne2" type="emp"><id property="empno" column="EMPNO"/><result property="name" column="ENAME"/><result property="job" column="JOB"/><result property="mgr" column="MGR"/><result property="hiredate" column="HIREDATE"/><result property="sal" column="SAL"/><result property="comm" column="COMM"/><result property="deptno" column="DEPTNO"/><association property="deptObject" javaType="dept" column="DEPTNO"select="com.zhanghp.dao.mapper.DeptMapper.queryByDeptno"/></resultMap><resultMap id="oneToOne3" type="emp"><id property="empno" column="EMPNO"/><result property="name" column="ENAME"/><result property="job" column="JOB"/><result property="mgr" column="MGR"/><result property="hiredate" column="HIREDATE"/><result property="sal" column="SAL"/><result property="comm" column="COMM"/><result property="deptno" column="DEPTNO"/><association property="deptObject" javaType="dept" column="DEPTNO" select="queryDeptByDeptno"/></resultMap><select id="queryDeptByDeptno" resultMap="deptResultMap">select *from deptwhere DEPTNO = #{deptno}</select><select id="queryAssociation" resultMap="oneToOne">select *from emp eleft join dept d on (e.DEPTNO = d.DEPTNO)</select><select id="queryAssociation2" resultMap="oneToOne2">select *from emp</select><select id="queryAssociation3" resultMap="oneToOne3">select *from emp</select>

UT用例 - ResultMapSqlTest.java

@Testpublic void oneToOne(){DEMO.queryAssociation();DEMO.queryAssociation2();DEMO.queryAssociation3();}

---

3.collection（一对多）

resultMapSqlDemo.java

 	/*** 一对多查询*/public void queryOneToMulti() {try {final List<Dept> results1 = SQLSESSION.selectList("queryOneToMulti");CommonUtil.printList(results1);} finally {ConnectUtil.release(SQLSESSION);}}

mapper/DeptMapper.xml

	<!-- 一对多查询 --><resultMap id="oneToMulti" type="dept"><id property="deptno" column="DEPTNO"></id><result property="dname" column="DNAME"></result><result property="loc" column="LOC"></result><collection property="empList" ofType="emp"><id property="empno" column="EMPNO"/><result property="name" column="ENAME"/><result property="job" column="JOB"/><result property="mgr" column="MGR"/><result property="hiredate" column="HIREDATE"/><result property="sal" column="SAL"/><result property="comm" column="COMM"/><result property="deptno" column="DEPTNO"/></collection></resultMap><select id="queryOneToMulti" resultMap="oneToMulti">select * from dept d left join emp e on (d.DEPTNO = e.DEPTNO)</select>

UT用例 - ResultMapSqlTest.java

	@Testpublic void oneToMulti(){DEMO.queryOneToMulti();}

---

4. discriminator

有时候，一个数据库查询可能会返回多个不同的结果集（但总体上还是有一定的联系的）。 鉴别器（discriminator）元素就是被设计来应对这种情况的，另外也能处理其它情况，例如类的继承层次结构。 鉴别器的概念很好理解——它很像 Java 语言中的 switch 语句。

用的场景较少，没写相关示例，我这里查了相关文章示例，有需要的请自行观看

官网例子

https://blog.csdn.net/weixin_45799972/article/details/121657855

https://www.jianshu.com/p/e808b1cfb265

---

5. 多对多查询

Sql表准备

CREATE TABLE `project` (`pid` int NOT NULL AUTO_INCREMENT,`pname` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,`money` int DEFAULT NULL,PRIMARY KEY (`pid`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci ROW_FORMAT=DYNAMIC;CREATE TABLE `project_record` (`empno` int NOT NULL,`pid` int NOT NULL,PRIMARY KEY (`empno`,`pid`) USING BTREE,KEY `fk_project_pro` (`pid`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci ROW_FORMAT=DYNAMIC;

实例查询原理：

一个project对应多个project_record，而每个project_record记录都对应一个emp表

resultMapSqlDemo.java

	/*** 多对多查询*/public void queryMultiToMulti() {try {final List<Project> results1 = SQLSESSION.selectList("queryMultiToMulti");CommonUtil.printList(results1);} finally {ConnectUtil.release(SQLSESSION);}}

mapper/ProjectMapper.xml

   <!-- 多对多查询 --><resultMap id="empResultMap" type="emp"><id property="empno" column="EMPNO"/><result property="name" column="ENAME"/><result property="job" column="JOB"/><result property="mgr" column="MGR"/><result property="hiredate" column="HIREDATE"/><result property="sal" column="SAL"/><result property="comm" column="COMM"/><result property="deptno" column="DEPTNO"/></resultMap><resultMap id="multiToMulti" type="project"><id property="pid" column="pid"/><result property="pname" column="pname"/><result property="money" column="money"/><collection property="projectRecords" ofType="projectRecord"><!-- 多主键必须都写id属性，否则查询的结果会是一对一--><id property="pid" column="pid"/><id property="empno" column="empno"/><association property="empObject" javaType="emp" resultMap="empResultMap"/></collection></resultMap><select id="queryMultiToMulti" resultMap="multiToMulti">select *from project pleft join project_record pr on (p.pid = pr.pid)left join emp e on (pr.empno = e.empno)</select>

UT用例 - ResultMapSqlTest.java

	@Testpublic void multiToMulti(){DEMO.queryMultiToMulti();}

3.4 存储过程调用

sql准备

CREATE DEFINER=`root`@`localhost` PROCEDURE `getEmpAndDept`(IN deptno int(11))
BEGIN
select * from emp e left join dept d on (e.deptno = d.deptno) where e.deptno = deptno;
END

resultMapSqlDemo.java

	/*** 调用存储过程*/public void callProcedure(Integer deptno) {try {// association对应的select属性查询dept表，是一个一个sql查询，比较消耗时间final List<Emp> results1 = SQLSESSION.selectList("callProcedure", deptno);CommonUtil.printList(results1);} finally {ConnectUtil.release(SQLSESSION);}}

mapper/EmpMapper.xml

jdbcType：指定数据库该字段类型，mybatis包含的jdbcType请自行上官网查看（在XML配置-结果映射章节）

mode：IN，OUT 或 INOUT 参数。如果参数的 mode 为 OUT 或 INOUT，将会修改参数对象的属性值，以便作为输出参数返回。 如果 mode 为 OUT（或 INOUT），而且 jdbcType 为 CURSOR（也就是 Oracle 的 REFCURSOR），你必须指定一个 resultMap 引用来将结果集 ResultMap 映射到参数的类型上。要注意这里的 javaType 属性是可选的，如果留空并且 jdbcType 是 CURSOR，它会被自动地被设为 ResultMap。

	<!--  调用存储过程  --><select id="callProcedure" resultMap="oneToOne" statementType="CALLABLE">{call getEmpAndDept(#{dept,jdbcType=INTEGER,mode=IN})}</select>

UT用例 - ResultMapSqlTest.java

 	@Testpublic void callProcedure(){DEMO.callProcedure(20);}

四. Mybatis 代理模式开发

4.1 简介

传统的XML配置映射器的方式，实现对数据库的增删改查，是基于SqlSession实例中的Api进行完成，虽说基需都能满足，但还是有很多劣势

1. selectOne()，selectAll()，seletMap()，update()，insert()，delete()等，都是基于SqlSession完成，规定的传参格式很单一，若传参多个参数，需要集成到map，对象等。
2. 由xml配置，需要额外实例化SqlSession，而没直接提供数据库操作接口，不利于后期维护

Mybatis的代理模式开发，通过Mapper代理(或称接口绑定)的操作方式，相对传统的XML映射器，具有以下优点

1. 接口规范统一，方便模块间的调用，利于维护
2. 传参多样化，不拘束于传统单一的传参方式

4.2 代理接口编写

4.2.1 步骤流程

1. 创建DemoMapper.java：用于Mapper接口代理开发，统一访问该类，调用api实现对数据库的增删改查
2. 创建DemoMapper.xml（和DemoMapper.java同路径包下）：用于sql的编写
3. mybatis-config.xml增加对com.zhanghp.dao.mapper包路径下文件的扫描配置

这里需要注意几个点

• Mapper接口绑定类的名称，需和映射文件名称保持一致（不包含拓展名）

• Mapper映射文件的namespace为Mapper接口的全路径包名

• sql语句对应的id，需和Mapper接口的方法名保持一致

• Mapper接口和Mapper映射文件编译后会在target的同一目录下

---

ps1:

拥有两个DemoMapper.xml文件，并不冲突，这里说明一下：

1. 包路径不同
2. namespace的作用域对象不同，一个是作用的是Demo类，另一个作用的是DemoMapper接口类

ps2:

创建映射文件包路径com.zhanghp.dao.mapper时，需一个一个名称的文件夹创建，若直接文件夹名写成com.zhanghp.dao.mapper，并回车后，会出现找不到该包的异常，这里需要注意一下。

4.2.2 代码实现

目录结构

这里读者会发现，笔者创建的DemoMapper.java和DemoMapper.xml前有2个小图标，这里读者若也想实现该效果

请自行去"settings" -> “plugins”，搜索MyBatisX插件，下载并重启idea即可复现图标效果

1. 创建一个接口类DemoMapper.java

   /*** @author zhanghp* @date 2023/6/26 10:45*/
   public interface DemoMapper {
   }
   

2. 创建DemoMapper.xml

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <!-- namespace 写Mapper接口的全路径包名 -->
   <mapper namespace="com.zhanghp.dao.mapper.DemoMapper"></mapper>
   

3. mybatis-config.xml添加配置

   	<mappers><!-- 扫描xml路径 --><mapper resource="mappers/DemoMapper.xml"/><!-- 扫描代理接口模式类包路径 --><package name="com.zhanghp.dao.mapper"></package></mappers>
   

4.2 crud代码实现

所用到的CommonUtil.java代码

上面xml映射器的代码，一个一个手动写代码，打印集合数据，很费时间，这里笔者写了一个公共类，来进行统一编写实现List，Map的集合打印

/*** @author zhanghp* @date 2023/6/26 13:31*/
public class CommonUtil {/*** List打印** @param list 集合*/public static void printList(List<?> list) {if (IterUtil.isNotEmpty(list)) {list.forEach(System.out::println);}}/*** Map打印** @param map 集合*/public static void printMap(Map<?, ?> map) {if (MapUtil.isNotEmpty(map)) {map.entrySet().forEach(it -> {System.out.println(it.getKey() + ":" + it.getValue());});}}
}

DemoMapper.java

/*** @author zhanghp* @date 2023/6/26 10:45*/
public interface DemoMapper {/*** 查询全部记录** @return {@link com.zhanghp.dao.pojo.Demo}*/List<Demo> queryAll();/*** 通过Demo对象传参，新增一条记录** @param demo 所需插入的对象信息* @return 插入成功的行数*/int insertOneByDemo(@Param("demo") Demo demo);/*** 通过Demo对象的传参及指定的id，来进行更新记录** @param demo 所需修改的对象信息* @return 修改成功的行数*/int updateOneByDemo(@Param("demo") Demo demo);/*** 根据主键id删除指定的记录** @param id 主键id* @return 删除成功的行数*/int deleteOneById(@Param("id") Integer id);
}

DemoMapper.xml(com.zhanghp.dao.mapper路径下)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace 写Mapper接口的全路径包名 -->
<mapper namespace="com.zhanghp.dao.mapper.DemoMapper"><!-- 查询全部数据记录 --><select id="queryAll" resultType="demo">select * from demo</select><!-- 通过对象传参，新增记录 --><insert id="insertOneByDemo" parameterType="demo" useGeneratedKeys="true" keyProperty="id">insert into demo values (#{demo.id}, #{demo.name}, #{demo.age})</insert><!-- 通过对象传参，更新记录 --><update id="updateOneByDemo" parameterType="demo">update demoset name =#{demo.name},age  = #{demo.age}where id = #{demo.id}</update><!-- 通过主键id删除一条记录 --><delete id="deleteOneById" parameterType="int">deletefrom demowhere id = #{id}</delete></mapper>

SelectMapperDemo.java

/*** @author zhanghp* @date 2023/6/26 13:30*/
public class SelectMapperDemo {private final SqlSession SQLSESSION = ConnectUtil.getSqlSession();private final DemoMapper MAPPER = SQLSESSION.getMapper(DemoMapper.class);public void queryAll() {CommonUtil.printList(MAPPER.queryAll());}public void insertOneByDemo(Demo demo) {System.out.println(MAPPER.insertOneByDemo(demo));}public void updateOneByDemo(Demo demo) {System.out.println(MAPPER.updateOneByDemo(demo));}public void deleteOneById(Integer id) {System.out.println(MAPPER.deleteOneById(id));}
}

UT测试用例 - SelectMapperTest.java

/*** @author zhanghp* @date 2023/6/26 13:35*/
public class SelectMapperTest {private final SelectMapperDemo DEMO = new SelectMapperDemo();@Testpublic void queryAll(){// select * from demoDEMO.queryAll();}@Testpublic void insertOneByDemo(){// insert into demo values (null, '小刘', 22)DEMO.insertOneByDemo(new Demo(null, "小刘", 22));}@Testpublic void updateOneByDemo(){// update demo set name = '小贺', age = '11' where id = 1DEMO.updateOneByDemo(new Demo(1, "小贺", 11));}@Testpublic void deleteOneById() {// delete from demo where id = 1DEMO.deleteOneById(1);}
}

4.3 深入查询

4.3.1 传参

1. 通过单个基本数据类型查询

SelectByParamDemo.java

/*** 参数传递的几种查询方式** @author zhanghp* @date 2023/6/26 21:09*/
public class SelectByParamMapperDemo {private final SqlSession SQLSESSION = ConnectUtil.getSqlSession();private final DemoMapper MAPPER = SQLSESSION.getMapper(DemoMapper.class);/*** 通过单个基本数据类型查询** @param name 姓名*/public void selectBySingleType(String name) {final List<Demo> demos = MAPPER.selectBySingleType(name);CommonUtil.printList(demos);}
}

DemoMapper.xml

 	<select id="selectBySingleType" parameterType="string" resultType="demo">select * from demo where name = #{name}</select>

UT测试用例 - SelectByParamMapperTest.java

/*** @author zhanghp* @date 2023/6/26 23:22*/
public class SelectByParamMapperTest {private final SelectByParamMapperDemo DEMO= new SelectByParamMapperDemo();@Testpublic void selectBySingleType(){DEMO.selectBySingleType("小白");}
}

2. 通过多个基本数据类型查询

SelectByParamDemo.java

 	/*** 通过多个基本数据类型查询** @param name 姓名* @param age  年龄*/public void selectByMultiType(String name, Integer age) {final List<Demo> demos = MAPPER.selectByMultiType(name, age);CommonUtil.printList(demos);}

DemoMapper.xml

   	<select id="selectByMultiType" resultType="demo">select * from demo where name = #{name} and age = #{age}</select>

UT测试用例 - SelectByParamMapperTest.java

    @Testpublic void selectByMultiType(){DEMO.selectByMultiType("小白", 10);}

3. 通过实体类查询

SelectByParamDemo.java

 	/*** 通过实体类查询** @param demo 实体类*/public void selectByBean(Demo demo) {final List<Demo> demos = MAPPER.selectByBean(demo);CommonUtil.printList(demos);}

DemoMapper.xml

 	<select id="selectByBean" parameterType="demo" resultType="demo">select * from demo where name = #{demo.name} and age = #{demo.age}</select>

UT测试用例 - SelectByParamMapperTest.java

	@Testpublic void selectByBean(){DEMO.selectByBean(new Demo(null, "小白", 10));}

4. 通过多个实体类查询

SelectByParamDemo.java

 	/*** 通过多个实体类查询** @param demo01 实体类1* @param demo02 实体类2*/public void selectByMultiBean(Demo demo01, Demo demo02) {final List<Demo> demos = MAPPER.selectByMultiBean(demo01, demo02);CommonUtil.printList(demos);}

DemoMapper.xml

  	<select id="selectByMultiBean"  resultType="demo">select * from demo where name = #{demo01.name} and age = #{demo02.age}</select>

UT测试用例 - SelectByParamMapperTest.java

	@Testpublic void selectByMultiBean(){DEMO.selectByMultiBean(new Demo(null, "小白", null),new Demo(null, null, 10));}

5. 通过map集合查询

SelectByParamDemo.java

	/*** 通过map集合查询** @param map map集合*/public void selectByMap(Map<String, Object> map) {final List<Demo> demos = MAPPER.selectByMap(map);CommonUtil.printList(demos);}

DemoMapper.xml

	<select id="selectByMap"  parameterType="map" resultType="demo">select * from demo where name = #{map.name} and age = #{map.age}</select>

UT测试用例 - SelectByParamMapperTest.java

 	@Testpublic void selectByMap(){Map<String, Object> map = new HashMap<String, Object>(){{put("name", "小白");put("age", 10);}};DEMO.selectByMap(map);}

4.3.2 模糊查询

通过concat函数，进行实现模糊查询

FuzzySelectMapperDemo

/*** 模糊查询** @author zhanghp* @date 2023/6/26 21:45*/
public class FuzzySelectMapperDemo {private final SqlSession SQLSESSION = ConnectUtil.getSqlSession();private final DemoMapper MAPPER = SQLSESSION.getMapper(DemoMapper.class);public void fuzzyQuery(String fuzzyName){final List<Demo> demos = MAPPER.fuzzyQuery(fuzzyName);CommonUtil.printList(demos);}
}

DemoMapper.xml

 	<select id="fuzzyQuery" parameterType="string" resultType="demo">select * from demo where name like concat('%', #{name}, '%')</select>

UT测试用例 - FuzzySelectMapperTest

/*** @author zhanghp* @date 2023/6/26 23:09*/
public class FuzzySelectMapperTest {private final FuzzySelectMapperDemo DEMO = new FuzzySelectMapperDemo();@Testpublic void fuzzyQuery(){DEMO.fuzzyQuery("小");}
}

4.4 动态sql

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用

4.4.1 if

判断字符串：1. 不为null 2. 不为空字符串

判断对象里的String类型属性：1. 对象不为空 2. 对象里的属性不为null 且 不是空字符串

DynamicSqlDemo.java

/*** @author zhanghp* @date 2023/6/27 18:54*/
public class DynamicSqlDemo {private final SqlSession SQLSESSION = ConnectUtil.getSqlSession();private final DemoMapper MAPPER = SQLSESSION.getMapper(DemoMapper.class);public void dynamicIf() {try {// test1 select * from demo where 1=1 and name = ?CommonUtil.printList(MAPPER.dynamicIf("小胡"));// test2 select * from demo where 1=1CommonUtil.printList(MAPPER.dynamicIf(null));// test3 <if test = "name != null and name != ''">// select * from demo where 1=1CommonUtil.printList(MAPPER.dynamicIf(""));} finally {ConnectUtil.release(SQLSESSION);}}public void dynamicIfByDemo() {try {// select * from demo where 1=1 and name = ?CommonUtil.printList(MAPPER.dynamicIfByDemo(new Demo(null, "小胡", null)));} finally {ConnectUtil.release(SQLSESSION);}}public void dynamicIfFuzzy() {try {// select * from demo where 1=1 and name like concat('%','小','%')CommonUtil.printList(MAPPER.dynamicIfFuzzy("小"));} finally {ConnectUtil.release(SQLSESSION);}}}

DemoMapper.xml

  <select id="dynamicIf" parameterType="string" resultType="demo">select * from demowhere 1=1<if test="name != null and name != ''">and name = #{name}</if></select><select id="dynamicIfByDemo" parameterType="demo" resultType="demo">select * from demowhere 1=1<if test="demo != null and demo.name != null and demo.name != ''">and name = #{demo.name}</if></select><select id="dynamicIfFuzzy" parameterType="string" resultType="demo">select * from demowhere 1=1<if test="name != null">and name like concat('%', #{name}, '%')</if></select>

UT测试用例 - DynamicSqlTest.java

/*** @author zhanghp* @date 2023/6/27 19:07*/
public class DynamicSqlTest {private final DynamicSqlDemo DEMO = new DynamicSqlDemo();@Testpublic void dynamicIf(){DEMO.dynamicIf();}@Testpublic void dynamicIfByDemo(){DEMO.dynamicIfByDemo();}@Testpublic void dynamicIfFuzzy(){DEMO.dynamicIfFuzzy();}
}

4.4.2 choose, when&otherwise

choose：前面的when条件成立 后面的 when就不再判断了

DynamicSqlDemo.java

 public void dynamicChooseWhenAndOtherwise() {try {// test1 select * from demo where 1=1 and age = ?CommonUtil.printList(MAPPER.dynamicChooseWhenAndOtherwise(new Demo(null, null, 10), ""));// test2 select * from demo where 1=1 and name = ?CommonUtil.printList(MAPPER.dynamicChooseWhenAndOtherwise(new Demo(null, null, null), "小胡"));// test3 select * from demo where 1=1 and name like concat('%','小','%')CommonUtil.printList(MAPPER.dynamicChooseWhenAndOtherwise(new Demo(null, null, null), ""));} finally {ConnectUtil.release(SQLSESSION);}}

DemoMapper.xml

    <select id="dynamicChooseWhenAndOtherwise" resultType="demo">select * from demo where 1=1<choose><when test="demo != null and demo.age != null">and age = #{demo.age}</when><when test="name != null and name != ''">and name = #{name}</when><otherwise>and name like concat('%','小','%')</otherwise></choose></select>

UT测试用例 - DynamicSqlTest.java

 	@Testpublic void dynamicChooseWhenAndOtherwise(){DEMO.dynamicChooseWhenAndOtherwise();}

4.4.3 trim, where&set

where：where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

---

trim

<trim prefix="WHERE" prefixOverrides="AND |OR ">...
</trim>

属性	功能
prefix	增加的前缀
prefixOverrides	去除的前缀
suffix	增加的后缀
suffixOverrides	去除的后缀

DynamicSqlDemo.java

	  public void dynamicWhere() {try {// select * from demoCommonUtil.printList(MAPPER.dynamicWhere(""));} finally {ConnectUtil.release(SQLSESSION);}}public void dynamicTrim() {try {// select * from demo where 1=1CommonUtil.printList(MAPPER.dynamicTrim());} finally {ConnectUtil.release(SQLSESSION);}}public void dynamicSet() {try {// test1 update demo SET age = ? where id = ?System.out.println(MAPPER.dynamicSet(11, 2));//test2 报错：age=null 所以无法更新  update demo where id = 2System.out.println(MAPPER.dynamicSet(null, 2));} finally {ConnectUtil.release(SQLSESSION);}}

DemoMapper.xml

  <select id="dynamicWhere"  parameterType="string" resultType="demo">select * from demo<where><if test="name != null and name != ''">name = #{name}</if></where></select><select id="dynamicTrim"  resultType="demo">select * from demo<trim prefix="where">1=1</trim></select><update id="dynamicSet">update demo<set><if test="age != null">age = #{age}</if></set>where id = #{id}</update>

UT测试用例 - DynamicSqlTest.java

	@Testpublic void dynamicWhere(){DEMO.dynamicWhere();}@Testpublic void dynamicTrim(){DEMO.dynamicTrim();}@Testpublic void dynamicSet(){DEMO.dynamicSet();}

4.4.4 foreach

属性	功能
collection	遍历的集合或者是数组，参数是数组。collection中名字指定为array，参数是List集合。collection中名字指定为list
separator	遍历时，采用的分隔符
open	以什么开头
close	以什么结尾
item	中间变量名

DynamicSqlDemo.java

   public void dynamicForeach() {try {// select * from demo where id in ( ? , ? , ? )CommonUtil.printList(MAPPER.dynamicForeach(Arrays.asList(1, 2, 3)));} finally {ConnectUtil.release(SQLSESSION);}}

DemoMapper.xml

  <select id="dynamicForeach" parameterType="list" resultType="demo">select * from demowhere id in<foreach collection="list" item="it" separator="," open="(" close=")">#{it}</foreach></select>

UT测试用例 - DynamicSqlTest.java

	@Testpublic void dynamicForeach(){DEMO.dynamicForeach();}

4.4.5 sql&bind

sql：如果引用sql标签的话用的refid

bind

属性	功能
name	名称
value	要使用绑定的值，通过#{name}来使用

DynamicSqlDemo.java

 	public void dynamicSql() {try {// select name, age from demoCommonUtil.printList(MAPPER.dynamicSql());} finally {ConnectUtil.release(SQLSESSION);}}public void dynamicBind() {try {// select * from demo where name like ?CommonUtil.printList(MAPPER.dynamicBind(new Demo(null, "小", null)));} finally {ConnectUtil.release(SQLSESSION);}}

DemoMapper.xml

    <sql id="sql_property">name, age</sql><sql id="sql_select">select <include refid="sql_property"/> from demo</sql><select id="dynamicSql" resultType="demo"><include refid="sql_select"></include></select><select id="dynamicBind" parameterType="demo" resultType="demo"><!-- 2种绑定方式都可获取到name值--><bind name="pattern" value="'%' + demo.name + '%'"/><bind name="pattern2" value="'%' + demo.getName() + '%'"/>select * from demowhere name like #{pattern3}</select>

UT测试用例 - DynamicSqlTest.java

    @Testpublic void dynamicBind(){DEMO.dynamicBind();}

4.5 注解 - 增删改查

在Mapper接口绑定类上，通过@Select，@Insert，@Update，@Delete等注解进行完成增删改查，更详细的注解使用，访问官网。笔者这里编写的是基本的增删改查操作。

4.5.1 步骤流程

1. 创建一个DemoAnnotationMapper.java
2. 在该接口类里编写crud，并添加注释
3. 测试用例

4.5.2 代码实现

DemoAnnotationMapper.java

/*** @author zhanghp* @date 2023/6/26 22:32*/
public interface DemoAnnotationMapper {/*** 查询全部** @return {@link com.zhanghp.dao.pojo.Demo}*/@Select("select * from demo")List<Demo> queryAll();/*** 通过主键查询单条记录** @return {@link com.zhanghp.dao.pojo.Demo}*/@Select("select * from demo where id = #{id}")Demo queryById(@Param(value = "id") Integer id);/*** 通过map匹配对应的对象集合** @return {@link com.zhanghp.dao.pojo.Demo}*/@Select("select * from demo where name = #{map.name} and age = #{map.age}")List<Demo> queryByMap(@Param(value = "map") Map<String, Object> map);/*** 通过对象指定的信息查询所匹配的集合** @return {@link com.zhanghp.dao.pojo.Demo}*/@Select("select * from demo where name = #{demo.name} and age = #{demo.age}")List<Demo> queryByDemo(@Param(value = "demo") Demo demo);/*** 通过map插入** @param map 信息* @return 插入成功的行数*/@Insert("insert into demo values (#{map.id}, #{map.name}, #{map.age})")int insertByMap(@Param(value = "map") Map<String, Object> map);/*** 通过对象插入** @param demo 实体类* @return 插入成功行数*/@Insert("insert into demo values (#{demo.id}, #{demo.name}, #{demo.age})")int insertByDemo(@Param(value = "demo") Demo demo);/*** 通过指定的几个参数修改** @param name 姓名* @param age  年龄* @param id   主键* @return 修改成功的行数*/@Update("update demo set name = #{name}, age = #{age} where id = #{id}")int updateByParams(@Param(value = "name") String name,@Param(value = "age") Integer age,@Param(value = "id") Integer id);/*** 通过主键删除对应的记录** @param id 主键* @return 删除成功行数*/@Delete("delete from demo where id = #{id}")int deleteById(@Param(value = "id") Integer id);
}

UT测试用例 - DemoAnnotationTest.java

/*** @author zhanghp* @date 2023/6/26 11:21*/
public class DemoTest {final SqlSession SQLSESSION = ConnectUtil.getSqlSession();final DemoAnnotationMapper mapper = SQLSESSION.getMapper(DemoAnnotationMapper.class);@Testpublic void queryAll() {CommonUtil.printList(mapper.queryAll());}@Testpublic void queryById() {System.out.println(mapper.queryById(1));}@Testpublic void queryByMap() {Map<String, Object> map = new HashMap<>();map.put("name", "小陈");map.put("age", 18);CommonUtil.printList(mapper.queryByMap(map));}@Testpublic void queryByDemo() {CommonUtil.printList(mapper.queryByDemo(new Demo(null, "小陈", 18)));}@Testpublic void insertByMap(){Map<String, Object> map = new HashMap<String, Object>(){{put("id", 200);put("name", "小白");put("age", 10);}};System.out.println(mapper.insertByMap(map));}@Testpublic void insertByDemo(){System.out.println(mapper.insertByDemo(new Demo(300, "小黑", 10)));}@Testpublic void updateByParams(){System.out.println(mapper.updateByParams("小红", 20, 300));}@Testpublic void deleteById(){System.out.println(mapper.deleteById(300));}}

五. 遇见的异常

5.1 异常一：Type interface com.zhanghp.dao.mapper.DemoMapper is already known to the MapperRegistry.

问题原因：

这个问题就是接口无法Mapper注册,导致这个原因可能是在,我们MaBatis核心配置文件只的中的mapper和package扫包冲突导致的

解决方式：

mybatis-config.xml配置里，配置的

当指定使用的是接口绑定的方式，就不需要单独扫描xml了，改成扫描包路径

 	<mappers><!--Exception:Type interface com.zhanghp.dao.mapper.DemoMapper is already known to the MapperRegistry.
<!--        <mapper resource="com/zhanghp/dao/mapper/DemoMapper2.xml"/>--><!-- 扫描代理接口模式类包路径 --><package name="com.zhanghp.dao.mapper"></package></mappers>

5.2 异常二：Cannot define both nestedQueryId and nestedResultMapId in property dept

问题原因：

在标签里使用了seletct，指定调用DeptMapper.xml里的queryByDeptno方而在queryByDeptno也指定了resultMap，导致嵌套异常（即使queryByDeptno方法用的是resulttype也一样）

解决方式：

把association里的resultMap属性删除

下面2个文件为抛异常相关的文件，其中EmpMapper.xml是出错的文件

mappers/EmpMapper.xml

 <resultMap id="oneToOne2" type="emp"><id property="empno" column="EMPNO"/><result property="name" column="ENAME"/><result property="job" column="JOB"/><result property="mgr" column="MGR"/><result property="hiredate" column="HIREDATE"/><result property="sal" column="SAL"/><result property="comm" column="COMM"/><result property="deptno" column="DEPTNO"/><association property="dept" javaType="dept" column="DEPTNO" select="com.zhanghp.dao.mapper.DeptMapper.queryByDeptno" resultMap="deptResultMap"/></resultMap>

mappers/DeptMapper.xml

    <select id="queryConstructor" resultMap="deptResultMap">select *from dept</select>

5.3 异常三：Mapped Statements collection does not contain value for queryMultiToMulti

问题原因：

映射语句集合不包含指定的queryMultiToMulti

通过这句话，可以看出，使用的是xml配置的扫描。

说明没有扫描到这个方法id，换句话说，mybatis-config.xml没有配置扫描该方法所在类的路径

解决方式：

在mybatis-config.xml中添加扫描该方法的类

 	<mappers><!-- 扫描xml路径 --><mapper resource="mappers/DemoMapper.xml"/><mapper resource="mappers/EmpMapper.xml"/><mapper resource="mappers/DeptMapper.xml"/><mapper resource="mappers/ProjectMapper.xml"/></mappers>

---

⭐️ 源码地址：https://gitee.com/zhp1221/java/tree/master/lab_04_mybatis