当前位置：首页 > news >正文

小黑子—MyBatis：第四章

news 2025/7/16 0:25:56

MyBatis入门4.0

十小黑子进行MyBatis参数处理
- 10.1 单个简单类型参数
- - 10.1.1 单个参数Long类型
  - 10.1.2 单个参数Date类型
- 10.2 Map参数
- 10.3 实体类参数（POJO参数）
- 10.4 多参数
- 10.5 @Param注解（命名参数）
- 10.6 @Param注解源码分析
十一小黑子的MyBatis查询专题
- 11.1 返回Car
- 11.2 返回List< Car >
- 11.3 返回Map
- - 11.3.1 返回List< Map >
- 11.4 返回Map<String.Map>
- 11.5 resultMap结果映射
- - 11.5.1 开启驼峰命名自动映射
- 11.6返回总记录条数
十二小黑子的动态SQL
- 12.1 if标签
- 12.2 where标签
- 12.3 trim标签
- 12.4 set标签
- 12.5 chose when otherwise标签
- 12.6 foreach标签
- - 12.6.1 批量删除
  - 12.6.2 批量插入
- 12.7 sql标签和include标签

十小黑子进行MyBatis参数处理

10.1 单个简单类型参数

简单类型包括：

byte short int long float double char
Byte Short Integer Long Float Double Character
String
java.util.Date
java.sql.Date

简单类型对于mybatis来说都是可以自动类型识别的：

也就是说对于mybatis来说，它是可以自动推断出ps.setXxxx()方法的。ps.setString()还是ps.setInt()。它可以自动推断。

其实SQL映射文件中的配置比较完整的写法是：

<select id="selectByName" resultType="student" parameterType="java.lang.String">select * from t_student where name = #{name, javaType=String, jdbcType=VARCHAR}
</select>

其中sql语句中的javaType，jdbcType，以及select标签中的parameterType属性，都是用来帮助mybatis进行类型确定的。不过这些配置多数是可以省略的。因为mybatis它有强大的自动类型推断机制。

javaType：可以省略
jdbcType：可以省略
parameterType：可以省略

准备数据库：
在这里插入图片描述
目录展示：

10.1.1 单个参数Long类型

StudentMapper

package com.powernode.mybatis.mapper;import com.powernode.mybatis.pojo.Student;import java.util.Date;
import java.util.List;public interface StudentMapper {/*** 当接口中的方法的参数只有一个（单给参数），并且参数的数据类型都是简单类型* 根据id查询、name查询、birth查询、sex查询* @version 1.0*/List<Student> selectById(Long id);List<Student> selectByName(String name);List<Student> selectByBirth(Date birth);List<Student> selectBySex(Character sex);
}

StudentMappper.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.powernode.mybatis.mapper.StudentMapper">
<!--List<Student> selectById(int id);List<Student> selectByName(String name);List<Student> selectByBirth(String birth);List<Student> selectBySex(String sex);parameterType属性的作用：告诉mybatis框架，我这个方法的参数类型是什么类型mybatis框架自身带有类型自动推断机制，所以大部分情况下parameterType属性都是可以省略不写的SQL语句最终是这样的：select * from t_student where id = ?JDBC代码是一定要给?传值的，怎么传值？ps.setXxx(第几个问好，传什么值);ps.setLong(1,1L)ps.setString(1,"zhangsan")ps.setDate(1,new Date())ps.setInt(1,100)...mybatis底层到底调用setXxx的哪个方法，取决于parameterType属性的值
--><select id="selectById" resultType="Student" parameterType="java.lang.Long">select * from t_student where id = #{id}</select></mapper>

测试

package com.powernode.mybatis.test;import com.powernode.mybatis.mapper.StudentMapper;
import com.powernode.mybatis.pojo.Student;
import com.powernode.mybatis.utils.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;import java.util.List;public class StudentMapperTest {@Testpublic void SelectById(){SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);List<Student> students = mapper.selectById(1L);students.forEach(student -> System.out.println(student));sqlSession.commit();sqlSession.close();}
}

在这里插入图片描述

10.1.2 单个参数Date类型

<?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.powernode.mybatis.mapper.StudentMapper">
<!--List<Student> selectById(int id);List<Student> selectByName(String name);List<Student> selectByBirth(String birth);List<Student> selectBySex(String sex);parameterType属性的作用：告诉mybatis框架，我这个方法的参数类型是什么类型mybatis框架自身带有类型自动推断机制，所以大部分情况下parameterType属性都是可以省略不写的SQL语句最终是这样的：select * from t_student where id = ?JDBC代码是一定要给?传值的，怎么传值？ps.setXxx(第几个问好，传什么值);ps.setLong(1,1L)ps.setString(1,"zhangsan")ps.setDate(1,new Date())ps.setInt(1,100)...mybatis底层到底调用setXxx的哪个方法，取决于parameterType属性的值
--><select id="selectById" resultType="Student" parameterType="java.lang.Long">select * from t_student where id = #{id}</select><select id="selectByName" resultType="Student">select * from t_student where name = #{name,javaType=String,jdbcType=VARCHAR}</select><select id="selectByBirth" resultType="Student">select * from t_student where birth = #{birth}</select><select id="selectBySex" resultType="Student">select * from t_student where sex = #{sex}</select></mapper>

测试

package com.powernode.mybatis.test;import com.powernode.mybatis.mapper.StudentMapper;
import com.powernode.mybatis.pojo.Student;
import com.powernode.mybatis.utils.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;public class StudentMapperTest {@Testpublic void SelectBySex(){SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);Character sex = Character.valueOf('男');List<Student> students = mapper.selectBySex(sex);students.forEach(student -> System.out.println(student));sqlSession.commit();sqlSession.close();}@Testpublic void SelectByBirth() throws ParseException {SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date birth = sdf.parse("1980-10-11");List<Student> students = mapper.selectByBirth(birth);students.forEach(student -> System.out.println(student));sqlSession.commit();sqlSession.close();}@Testpublic void SelectByName(){SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);List<Student> students = mapper.selectByName("李四");students.forEach(student -> System.out.println(student));sqlSession.commit();sqlSession.close();}@Testpublic void SelectById(){SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);List<Student> students = mapper.selectById(1L);students.forEach(student -> System.out.println(student));sqlSession.commit();sqlSession.close();}
}

10.2 Map参数

这种方式是手动封装Map集合，将每个条件以key和value的形式存放到集合中。然后在使用的时候通过#{map集合的key}来取值

需求：根据map集合保存学生信息

StudentMapper接口：

    int insertStudentByMap(Map<String,Object> map);

StudentMapper.xml

    <insert id="insertStudentByMap" parameterType="map">insert into t_student(id,name,age,sex,birth,height) value (null,#{姓名},#{年龄},#{性别},#{生日},#{身高})</insert>

测试

@Testpublic void InsertStudentByMap(){SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);Map<String,Object> map = new HashMap<>();map.put("姓名","麻瓜");map.put("年龄",25);map.put("身高",1.82);map.put("性别",'男');map.put("生日",new Date());mapper.insertStudentByMap(map);sqlSession.commit();sqlSession.close();}

在这里插入图片描述

10.3 实体类参数（POJO参数）

使用实体类参数这里需要注意的是：#{} 里面写的是属性名字。这个属性名其本质上是：set/get方法名去掉set/get之后的名字

StudentMapper.xml

    <insert id="insertStudentByPOJO">insert into t_student(id,name,age,sex,birth,height) value (null,#{name},#{age},#{sex},#{birth},#{height})</insert>

StudentMapper接口

/** @description: 保存学生信息，通过实体类参数* @param student* @version 1.0*/int insertStudentByPOJO(Student student);

测试

 @Testpublic void InsertStudentByPOJO(){SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);Student student = new Student();student.setName("小老板");student.setAge(24);student.setSex('男');student.setBirth(new Date());student.setHeight(1.78);mapper.insertStudentByPOJO(student);sqlSession.commit();sqlSession.close();}

在这里插入图片描述

10.4 多参数

需求：通过name和sex查询

StudentMapper.xml

    <select id="selectByNameAndSex" resultType="Student">select * from t_student where name = #{name} and sex = #{sex}</select>

StudentMapper接口

/** 这是多参数* 根据name和sex查询Student信息* 如果是多个参数的话，mybatis框架底层是怎么做到的呢？*      mybatis框架会自动创建一个Map集合，并且Map集合是以这种方式储存参数的：*          map.put("arg0",name);*          map.put("arg1",sex);*          map.put("arg1",sex);*          map.put("param1",name);*          map.put("param2",sex);*/List<Student> selectByNameAndSex(String name,Character sex);

测试

  @Testpublic void selectByNameAndSex(){SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);List<Student> students = mapper.selectByNameAndSex("张三", '男');students.forEach(student -> System.out.println(student));sqlSession.commit();sqlSession.close();}

在这里插入图片描述

异常信息描述了：name参数找不到，可用的参数包括[arg1, arg0, param1, param2]
修改StudentMapper.xml配置文件：尝试使用[arg1, arg0, param1, param2]去参数

修改StudentMapper.xml文件

    <select id="selectByNameAndSex" resultType="Student"><!--  select * from t_student where name = #{name} and sex = #{sex}  -->select * from t_student where name = #{arg0} and sex = #{param2}</select>

再次尝试修改StudentMapper.xml文件

<select id="selectByNameAndSex" resultType="Student"><!--select * from t_student where name = #{name} and sex = #{sex}--><!--select * from t_student where name = #{arg0} and sex = #{arg1}--><!--select * from t_student where name = #{param1} and sex = #{param2}-->select * from t_student where name = #{arg0} and sex = #{param2}
</select>

在这里插入图片描述
通过测试可以看到：

arg0 是第一个参数
param1是第一个参数
arg1 是第二个参数
param2是第二个参数

实现原理：实际上在mybatis底层会创建一个map集合，以arg0/param1为key，以方法上的参数为value，例如以下代码：

Map<String,Object> map = new HashMap<>();
map.put("arg0", name);
map.put("arg1", sex);
map.put("param1", name);
map.put("param2", sex);// 所以可以这样取值：#{arg0} #{arg1} #{param1} #{param2}
// 其本质就是#{map集合的key}

注意：使用mybatis3.4.2之前的版本时：要用#{0}和#{1}这种形式。

10.5 @Param注解（命名参数）

可以不用arg0 arg1 param1 param2吗？这个map集合的key我们自定义可以吗？当然可以。使用@Param(" 注解的名称 ")注解即可。这样可以增强可读性。

需求：根据name和age查询

StudentMapper接口

    /** Param注解** mybatis框架底层的实现原理：*    map.put("name",name);*    map.put("sex",sex);* @param name* @param sex**/List<Student> selectByNameAndSex2(@Param("name")String name,@Param("sex") Character sex);

StudentMapper.xml

    <select id="selectByNameAndSex2" resultType="Student"><!-- 使用了@Param注解之后，arg0和arg1失效了，但是param1和param2还可以用  -->select * from t_student where name = #{name} and sex and #{sex}</select>

测试

@Testpublic void SelectByNameAndSex2(){SqlSession sqlSession = SqlSessionUtil.openSession();StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);List<Student> students = mapper.selectByNameAndSex2("张三", '男');students.forEach(student -> System.out.println(student));sqlSession.commit();sqlSession.close();}

在这里插入图片描述

核心：@Param(“这里填写的其实就是map集合的key”)

10.6 @Param注解源码分析

做个了解
在这里插入图片描述

十一小黑子的MyBatis查询专题

模块名：mybatis-007-select
打包方式：jar
引入依赖：mysql驱动依赖、mybatis依赖、logback依赖、junit依赖。
引入配置文件：jdbc.properties、mybatis-config.xml、logback.xml
创建pojo类：Car
创建Mapper接口：CarMapper
创建Mapper接口对应的映射文件：com/powernode/mybatis/mapper/CarMapper.xml
创建单元测试：CarMapperTest
拷贝工具类：SqlSessionUtil

11.1 返回Car

当查询的结果，有对应的实体类，并且查询结果只有一条时：

CarMapper.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.powernode.mybatis.mapper.CarMapper"><select id="selectById" resultType="Car">selectid,car_num as carNum,brand,guide_price as guidePrice,produce_time as produceTime,car_type as carTypefrom t_carwhereid = #{id}</select></mapper>

CarMapper接口

package com.powernode.mybatis.mapper;import com.powernode.mybatis.pojo.Car;public interface CarMapper {/*** 根据id主键查询：结果最多只有一条* @param id* @return*/Car selectById(Long id);}

测试

package com.powernode.mybatis.test;import com.powernode.mybatis.mapper.CarMapper;
import com.powernode.mybatis.pojo.Car;
import com.powernode.mybatis.utils.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;public class CarMapperTest {@Testpublic void testSelectById(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);Car car = mapper.selectById(1L);System.out.println(car);sqlSession.commit();sqlSession.close();}}

在这里插入图片描述

当返回记录结果有多条，却用单个实体类接收时：

CarMapper接口

/** @description: 根据品牌进行模糊查询* 查询的结果可能有多个，但是采用一个POJO对象来接收的问题* @param brand* @version 1.0*/Car selectByBrandLike(String brand);

CarMapper.xml

<select id="selectByBrandLike" resultType="Car">selectid,car_num as carNum,brand,guide_price as guidePrice,produce_time as produceTime,car_type as carTypefrom t_carwherebrand like "%"#{brand}"%"</select>

测试

 @Testpublic void testSelectByBrandLike(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);//出现异常TooManyResultsException//什么意思？你期望的结果是返回一条记录，但是实际的SQL语句在执行的时候，返回的记录条数不是一条，是多条Car car = mapper.selectByBrandLike("byd");System.out.println(car);sqlSession.commit();sqlSession.close();}

在这里插入图片描述

11.2 返回List< Car >

一、采用List集合接收多条数据，模糊查询

CarMappper接口

List<Car> selectByBrandLike2(String brand);

CarMapper.xml

  <select id="selectByBrandLike2" resultType="Car">selectid,car_num as carNum,brand,guide_price as guidePrice,produce_time as produceTime,car_type as carTypefrom t_carwherebrand like "%"#{brand}"%"</select>

测试

@Testpublic void testSelectByBrandLike2(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);List<Car> cars = mapper.selectByBrandLike2("byd");cars.forEach(car -> System.out.println(car));sqlSession.commit();sqlSession.close();}

在这里插入图片描述

二、
根据id查询Car，id是主键。这个结果一定是一条，不可能有多条数据。所以返回可以用List< Car >集合进行接收。

CarMapper.xml

    <select id="selectById2" resultType="Car">selectid,car_num as carNum,brand,guide_price as guidePrice,produce_time as produceTime,car_type as carTypefrom t_carwhereid = #{id}</select>

CarMapper接口

    /** @description: 根据id查询Car，id是主键。这个结果一定是一条，不可能有多条数据。* @param id* @version 1.0*/List<Car> selectById2(Long id);

测试

  @Testpublic void testSelectById2(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);List<Car> cars = mapper.selectById2(2L);System.out.println(cars);sqlSession.commit();sqlSession.close();}

在这里插入图片描述

11.3 返回Map

当返回的数据，没有合适的实体类对应的话，可以采用Map集合接收。字段名做key，字段值做value。
查询如果可以保证只有一条数据，则返回一个Map集合即可。
在这里插入图片描述

CarMappper.xml

    <!-- resultType="java.util.map"有别名 map --><select id="selectByIdRetMap" resultType="map">select * from t_car where id = #{id}</select>

CarMapper接口

    /** @description: 根据id获取汽车信息。将汽车信息放到Map集合中* @param id* @version 1.0*/Map<String,Object> selectByIdRetMap(Long id);

测试

    @Testpublic void testSelectByIdRetMap(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);Map<String, Object> car = mapper.selectByIdRetMap(34L);System.out.println(car);sqlSession.commit();sqlSession.close();}

在这里插入图片描述

11.3.1 返回List< Map >

查询结果条数大于等于1条数据，则可以返回一个存储Map集合的List集合
在这里插入图片描述

resultMap=“map”，这是因为mybatis内置了很多别名。【参见mybatis开发手册】

CarMapper.xml

    <!-- 这个resultType不是list，是map--><select id="selectAllRetListMap" resultType="map">select * from t_car</select>

CarMapper接口

 /** 查询所有的Car信息，返回一个存放Map集合的List集合* @version 1.0*/List<Map<String,Object>> selectAllRetListMap();

测试

    @Testpublic  void testSelectAllRetListMap(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);List<Map<String, Object>> maps = mapper.selectAllRetListMap();maps.forEach(map -> System.out.println(map));sqlSession.commit();sqlSession.close();}

在这里插入图片描述

当然，如果返回一个Map集合，可以将Map集合放到List集合中吗？当然可以，这里就不再测试了。
反过来，如果返回的不是一条记录，是多条记录的话，只采用单个Map集合接收，这样同样会出现之前的异常：TooManyResultsException

11.4 返回Map<String.Map>

拿Car的id做key，以后取出对应的Map集合时更加方便
在这里插入图片描述

CarMapper接口

    /** 查询所有的Car，返回一个大Map集合* Map集合的key是每条记录的主键值* map集合的value是每条记录*/@MapKey("id")//将查询结果的id值作为整个大Map集合的keyMap<Long,Map<String,Object>> selectAllRetMap();

测试

@Testpublic void testSelectAllRetMap(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);Map<Long, Map<String, Object>> maps = mapper.selectAllRetMap();System.out.println(maps);sqlSession.commit();sqlSession.close();}

CarMapper.xml

    <select id="selectAllRetMap" resultType="map">select * from t_car</select>

返回结果一个大Map集合：

{1={car_num=1001, id=1, guide_price=10, produce_time=2022-10-11, brand=宝马520, car_type=燃油车}, 
2={car_num=1111, id=2, guide_price=10, produce_time=2020-11-11, brand=byd, car_type=电车}, 
34={car_num=9991, id=34, guide_price=40, produce_time=2022-11-11, brand=凯迪, car_type=能源车}, 
3={car_num=1111, id=3, guide_price=10, produce_time=2020-11-11, brand=byd, car_type=电车}, 
4={car_num=9999, id=4, guide_price=30, produce_time=1999-11-10, brand=magua, car_type=旧能源}, 
6={car_num=8888, id=6, guide_price=30, produce_time=2000-11-66, brand=法克鱿, car_type=捞车}, 
7={car_num=8888, id=7, guide_price=30, produce_time=2000-11-66, brand=法克鱿, car_type=捞车}, 
8={car_num=8888, id=8, guide_price=30, produce_time=2000-11-66, brand=法克鱿, car_type=捞车}, 
9={car_num=8888, id=9, guide_price=30, produce_time=2000-11-66, brand=法克鱿, car_type=捞车}, 
10={car_num=8888, id=10, guide_price=30, produce_time=2000-11-66, brand=法克鱿, car_type=捞车}, 
15={car_num=22222, id=15, guide_price=3, produce_time=2022-10-1, brand=小老板, car_type=新能源}}

11.5 resultMap结果映射

查询结果的列名和java对象的属性名对应不上怎么办？

第一种方式：as 给列起别名
第二种方式：使用resultMap进行结果映射
第三种方式：是否开启驼峰命名自动映射（配置settings）

使用resultMap进行结果映射：

CarMapper接口

    /*** 查询所有Car，使用resultMap进行结果映射* @return*/List<Car> selectAllByResultMap();

CarMapper.xml

    <!--1.专门定义一个结果映射，在这个结果映射当中指定数据库的字段名和Java类的属性名的对应关系2.type属性：用来指定POJO类的类名3.id属性：指定resultMap的唯一标识。这个id将来要在select标签中使用--><resultMap id="carResultMap" type="Car"><!--如果数据库表中有主键，一般都是有主键，要不然不符合数据库设计的第一范式--><!--如果有主键，建议这里配置一个id标签，注意：这不是必须的。但是官方的解释是什么？这样配置可以让mybatis提供效率--><id property="id" column="id"></id><!--property后面接的是POJO类的属性名--><!--column后面接的是数据库的字段名--><result property="carNum" column="car_num" javaType="java.lang.String" jdbcType="VARCHAR"/><!--如果column和property是一样的，这个可以省略。--><!--        <result property="brand" column="brand"/>--><result property="guidePrice" column="guide_price"/><result property="produceTime" column="produce_time"/><result property="carType" column="car_type" javaType="string" jdbcType="VARCHAR"/></resultMap><!--select标签的resultMap属性，用来指定使用哪个结果映射。resultMap后面的值是resultMap的id--><select id="selectAllByResultMap" resultMap="carResultMap">select * from t_car</select>

测试

  @Testpublic void testSelectAllByResultMap(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);List<Car> cars = mapper.selectAllByResultMap();cars.forEach(car -> System.out.println(car));sqlSession.commit();sqlSession.close();}

在这里插入图片描述

11.5.1 开启驼峰命名自动映射

使用这种方式的前提是：属性名遵循Java的命名规范，数据库表的列名遵循SQL的命名规范。
Java命名规范：首字母小写，后面每个单词首字母大写，遵循驼峰命名方式。
SQL命名规范：全部小写，单词之间采用下划线分割。

比如以下的对应关系：

实体类中的属性名	数据库表的别名
carNum	car_num
carType	car_type
produceTime	produce_time

如何启用该功能，在mybatis-config.xml文件中进行配置：

<!--放在properties标签后面-->
<settings><setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

CarMapper接口

/**
* 查询所有Car，启用驼峰命名自动映射
* @return
*/
List<Car> selectAllByMapUnderscoreToCamelCase();

CarMapper.xml

    <select id="selectAllByMapUnderscoreToCamelCase" resultType="car">select * from t_car</select>

测试

@Testpublic void testSelectAllByMapUnderscoreToCamelCase (){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);List<Car> cars = mapper.selectAllByMapUnderscoreToCamelCase();cars.forEach(car -> System.out.println(car));sqlSession.commit();sqlSession.close();}

在这里插入图片描述

11.6返回总记录条数

需求：查询总记录条数

CarMapper.xml

 <select id="selectTotal" resultType="Long">select count(*) from t_car</select>

CarMapper接口

    /** @description: 获取Car的总记录条数* @version 1.0*/Long selectTotal();

测试

 @Testpublic void testSelectTotal(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);Long total = mapper.selectTotal();System.out.println(total);sqlSession.commit();sqlSession.close();}

十二小黑子的动态SQL

什么是动态SQL？

有的业务场景，也需要SQL语句进行动态拼接，例如：

批量删除

12.1 if标签

if标签中test属性是必须的。
if标签中test属性的值是false或者true。
如果test是true，则if标签中的sql语句就会拼接。反之，则不会拼接。
test属性中可以使用的是:
- 当使用了@Param注解，那么test中要出现的是@Param注解指定的参数名。@Param("brand")，那么这里只能使用brand
- 当没有使在这里插入代码片用@Param注解，那么test中要出现的是: param1 param2 param3 arg0 arg1 arg2. . . .
- 当使用了POJO，那么test中出现的是POJO类的属性名。
在mybatis的动态SQL当中，不能使用&&，只能使用and。

CarMapper.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.powernode.mybatis.mapper.CarMapper"><select id="selectByMultiCondition" resultType="Car">select * from t_carwhere<if test="brand != null and brand != ''">brand like "%"#{brand}"%"</if><if test="guidePrice != null and guidePrice != ''">and guide_price > #{guidePrice}</if><if test="carType != null and carType != ''">and car_type = #{carType}</if></select>
</mapper>

CarMapper接口

package com.powernode.mybatis.mapper;import com.powernode.mybatis.pojo.Car;
import org.apache.ibatis.annotations.Param;import java.util.List;public interface CarMapper {/** 多条件查询* @param brand* @param guidePrice* @param carType* @version 1.0*/List<Car> selectByMultiCondition(@Param("brand") String brand,@Param("guidePrice") Double guidePrice, @Param("carType") String carType);
}

测试

package com.powernode.mybatis.test;import com.powernode.mybatis.mapper.CarMapper;
import com.powernode.mybatis.pojo.Car;
import com.powernode.mybatis.utils.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;import java.util.List;public class CarMapperTest {@Testpublic void testSelectByMultiCondition(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);//假设三个条件都不是空List<Car> cars = mapper.selectByMultiCondition("byd", 2.0, "电车");cars.forEach(car -> System.out.println(car));sqlSession.commit();sqlSession.close();}
}

在这里插入图片描述

12.2 where标签

where标签的作用：让where子句更加动态智能。

所有条件都为空时，where标签保证不会生成where子句。
自动去除某些条件前面多余的and或or。后面的无法去除
继续使用if标签中的需求。

CarMapper接口

    /** @description: where标签，让where子句更加的智能* @version 1.0*/List<Car> selectByMultiConditionWithWhere(@Param("brand") String brand,@Param("guidePrice") Double guidePrice, @Param("carType") String carType);

CarMapper接口

  <select id="selectByMultiConditionWithWhere" resultType="Car">select * from t_car<!--where标签是专门负责where子句动态生成的--><where><if test="brand != null and brand != ''">brand like "%"#{brand}"%"</if><if test="guidePrice != null and guidePrice != ''">and guide_price > #{guidePrice}</if><if test="carType != null and carType != ''">and car_type = #{carType}</if></where>

测试

@Testpublic void selectByMultiConditionWithWhere(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);//假设三个条件都不是空
//        List<Car> cars = mapper.selectByMultiConditionWithWhere("byd", 2.0, "电车");//假设三个条件都是空，where标签可以自动判断是否符合条件
//        List<Car> cars = mapper.selectByMultiConditionWithWhere("", null, "");//假设一个条件为空，where标签也会自动判断消去andList<Car> cars = mapper.selectByMultiConditionWithWhere("", 2.0, "电车");cars.forEach(car -> System.out.println(car));//但是后面两个条件是空时，后面有and，where标签就无法去除sqlSession.commit();sqlSession.close();}

12.3 trim标签

trim标签的属性：

prefix：再trim标签中的语句前添加内容
suffix：再trim标签中的语句后添加内容
prefixOverrides：前缀覆盖掉（去掉）
suffixOverrides：后缀覆盖掉（去掉）

    /** @description: 使用trim标签* @version 1.0*/List<Car> selectByMultiConditionWithTrim(@Param("brand") String brand,@Param("guidePrice") Double guidePrice, @Param("carType") String carType);

 <select id="selectByMultiConditionWithTrim" resultType="Car"><!--prefix="where" 是在trim标签所有内容的前面添加where--><!--suffixOverrides="and|or" 把trim标签中内容的后缀and或or去掉，以至于后面有and或or的话程序也不会报错-->select * from t_car<trim prefix="where" suffixOverrides="and|or"><if test="brand != null and brand != ''">brand like "%"#{brand}"%" and</if><if test="guidePrice != null and guidePrice != ''">guide_price > #{guidePrice} and</if><if test="carType != null and carType != ''">car_type = #{carType}</if></trim></select>

   @Testpublic void testSelectByMultiConditionWithTrim(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);List<Car> cars = mapper.selectByMultiConditionWithTrim("", null, "");cars.forEach(car -> System.out.println(car));sqlSession.commit();sqlSession.close();}

12.4 set标签

主要使用在update语句当中，用来生成set关键字，同时去掉最后多余的“,”

比如我们只更新提交的不为空的字段，如果提交的数据是空或者""，那么这个字段我们将不更新。

    /** @description: 使用set标签* @version 1.0*/int updateBySet(Car car);

    <update id="updateBySet">update t_car<set><if test="carNum != null and carNum != '' ">car_num = #{carNum},</if><if test="brand != null and brand != '' ">brand = #{brand},</if><if test="guidePrice != null and guidePrice != '' ">guide_price = #{guidePrice},</if><if test="produceTime != null and produceTime != '' ">produce_time = #{produceTime},</if><if test="carType != null and carType != '' ">car_type = #{carType}</if></set>whereid = #{id}</update>

    @Testpublic void testUpdateBySet(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);Car car = new Car(34L, null, "麻瓜霸道", null, null, null);mapper.updateBySet(car);sqlSession.commit();sqlSession.close();}

在这里插入图片描述

12.5 chose when otherwise标签

这三个标签是在一起使用的：

语法格式：

<choose><when></when><when></when><when></when><otherwise></otherwise>
</choose>

等同于：

if(){}else if(){}else if(){}else if(){}else{}

只有一个分支会被选择！！！！

案例需求：先根据品牌查询，如果没有提供品牌，再根据指导价查询，如果没有提供指导架构，就根据生产日期查询

    /*** 使用choose when otherwise标签查询* @param brand* @param guidePrice* @param carType* @return*/List<Car> selectWithChoose(@Param("brand") String brand, @Param("guidePrice") Double guidePrice, @Param("carType") String carType);

 <select id="selectWithChoose" resultType="Car">select * from t_car<where><choose><when test="brand != null and brand != ''">brand like "%"#{brand}"%"</when><when test="guidePrice != null and guidePrice != ''">guide_price > #{guidePrice}</when><otherwise>car_type = #{carType}</otherwise></choose></where></select>

 @Testpublic void testSelectWithChoose(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);//三个条件都不为空
//        List<Car> cars = mapper.selectWithChoose("麻瓜霸道", 1.0, "新能源");//第一个条件是空// List<Car> cars = mapper.selectWithChoose(null, 1.0, "新能源");//前两个条件是空// List<Car> cars = mapper.selectWithChoose(null, null, "新能源");//全都是空List<Car> cars = mapper.selectWithChoose(null, null, null);cars.forEach(car -> System.out.println(car));sqlSession.commit();sqlSession.close();}

12.6 foreach标签

循环数组或集合，动态生成sql，比如这样的SQL：

批量删除

delete from t_car where id in(1,2,3);
delete from t_car where id = 1 or id = 2 or id = 3;

批量增加

insert into t_car values(null,'1001','凯美瑞',35.0,'2010-10-11','燃油车'),(null,'1002','比亚迪唐',31.0,'2020-11-11','新能源'),(null,'1003','比亚迪宋',32.0,'2020-10-11','新能源')

12.6.1 批量删除

用in来删除

foreach标签属性：

collection：集合或数组
item：集合或数组中的元素
separator：循环之间的分隔符
open：foreach标签中所有内容的开始
close：foreach标签中所有内容的结束

    /*** 通过foreach完成批量删除* @param ids* @return*/int deleteBatchByForeach(@Param("ids") Long[] ids);

    <delete id="deleteBatchByForeach">delete from t_car where id in<foreach collection="ids" item="id" separator="," open="(" close=")">#{id}</foreach></delete>

    @Testpublic void testDeleteBatchByForeach(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);Long[] ids = {8L,9L,10L};mapper.deleteBatchByForeach(ids);sqlSession.commit();sqlSession.close();}

在这里插入图片描述

用or来删除

    <delete id="deleteById2" >delete from t_car where<foreach collection="ids" item="id" separator="or">id = #{id}</foreach></delete>

    /*** 通过id批量删除，使用or关键字* @param ids* @return*/int deleteById2(@Param("ids") Long[] ids);

  @Testpublic void testDeleteById2(){SqlSession sqlSession = SqlSessionUtil.openSession();CarMapper mapper = sqlSession.getMapper(CarMapper.class);Long[] ids = {35L,36L,37L};int count = mapper.deleteById2(ids);System.out.println(count);sqlSession.commit();sqlSession.close();}

在这里插入图片描述

12.6.2 批量插入

    <insert id="insertBatch">insert into t_car values<foreach collection="cars" item="car" separator=",">(null,#{car.carNum},#{car.brand},#{car.guidePrice},#{car.produceTime},#{car.carType})</foreach></insert>

    /*** 通过foreach批量插入，一次插入多条car信息* @param cars* @return*/int insertBatch(@Param("cars") List<Car> cars);

@Testpublic void testInsertBatchByForeach(){CarMapper mapper = SqlSessionUtil.openSession().getMapper(CarMapper.class);Car car1 = new Car(null, "2001", "兰博基尼", 100.0, "1998-10-11", "燃油车");Car car2 = new Car(null, "2001", "兰博基尼", 100.0, "1998-10-11", "燃油车");Car car3 = new Car(null, "2001", "兰博基尼", 100.0, "1998-10-11", "燃油车");List<Car> cars = Arrays.asList(car1, car2, car3);int count = mapper.insertBatch(cars);System.out.println("插入了几条记录" + count);SqlSessionUtil.openSession().commit();}

在这里插入图片描述

12.7 sql标签和include标签

sql标签用来声明sql片段

include标签用来将声明的sql片段包含到某个sql语句当中

作用：代码复用。易维护。

<!--声明一个SQL片段-->
<sql id="carCols">id,car_num as carNum,brand,guide_price as guidePrice,produce_time as produceTime,car_type as carType
</sql><select id="selectAllRetMap" resultType="map">select <!--将声明的sql片段包含进来--><include refid="carCols"/> from t_car
</select><select id="selectAllRetListMap" resultType="map">select <include refid="carCols"/> carType from t_car
</select><select id="selectByIdRetMap" resultType="map">select <include refid="carCols"/> from t_car where id = #{id}
</select>