[Java]Mybatis学习笔记(动力节点老杜)（七）

/**
 * 查询所有的汽车信息
 * 
 * @return 所有的汽车信息
 */
List<Car> selectAll();

<select id="selectAll" resultType="car">
  select id,
         car_num      as carNum,
         brand,
         guide_price  as guidePrice,
         produce_time as produceTime,
         car_type     as carType
  from t_car;
</select>

@org.junit.Test
public void testSelectAll() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    List<Car> cars = mapper.selectAll();
    cars.forEach(System.out::println);
    SqlSessionUtil.close();
}

/**
 * 根据id查询汽车信息
 *
 * @param id 汽车信息的id
 * @return 汽车信息封装成的Map
 */
Map<String, Object> selectByIdReturnMap(Long id);

<!-- MyBatis 中 map 为 java.util.Map 的别名 -->
<select id="selectByIdReturnMap" resultType="map">
  select id,
         car_num      as carNum,
         brand,
         guide_price  as guidePrice,
         produce_time as produceTime,
         car_type     as carType
  from t_car
  where id = #{id};
</select>

@org.junit.Test
public void testSelectByIdReturnMap() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    Map<String, Object> map = mapper.selectByIdReturnMap(5L);
    System.out.println(map);
    SqlSessionUtil.close();
}

/**
 * 查询所有的汽车信息
 *
 * @return 由汽车信息封装在Map中组成的List集合
 */
List<Map<String, Object>> selectAllReturnListMap();

<!-- MyBatis 中 map 为 java.util.Map 的别名 -->
<!-- 返回的还是 map，只有最后数据多个map封装在list中 -->
<select id="selectAllReturnListMap" resultType="map">
  select id,
         car_num      as carNum,
         brand,
         guide_price  as guidePrice,
         produce_time as produceTime,
         car_type     as carType
  from t_car;
</select>

@org.junit.Test
public void testSelectAllReturnListMap() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    List<Map<String, Object>> maps = mapper.selectAllReturnListMap();
    maps.forEach(System.out::println);
    SqlSessionUtil.close();
}

/**
 * 查询所有的汽车信息
 *
 * @return 由汽车信息封装在Map中组成的Map集合
 */
@MapKey("id") // @MapKey 注解的属性 value 指定使用数据哪个字段作为Map 的 key
// 作为大Map key 的数据类型要与@MapKey 注解指定的字段的数据类型一致
Map<Long, Map<String, Object>> selectAllReturnMapMap();

<!-- MyBatis 中 map 为 java.util.Map 的别名 -->
<!-- 返回的还是 map，只有最后数据多个map封装在Map中 -->
<select id="selectAllReturnMapMap" resultType="map">
  select id,
         car_num      as carNum,
         brand,
         guide_price  as guidePrice,
         produce_time as produceTime,
         car_type     as carType
  from t_car;
</select>

@org.junit.Test
public void testSelectAllReturnMapMap() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    Map<Long, Map<String, Object>> map = mapper.selectAllReturnMapMap();
    System.out.println(map.get(5L));
    System.out.println(map.get(7L));
    SqlSessionUtil.close();
}

/**
 * 查询所有的汽车信息
 * 使用 ResultMap 标签进行结果映射
 * 
 * @return 汽车信息组成的集合
 */
List<Car> selectAllByResultMap();

<!-- 
  定义一个结果映射
  在这个结果映射中指定数据库表字段和Java类的属性名之间的对应关系 
  type=""：用于指定Java类的类名
  id=""：指定 resultMap 的唯一标识，这个id要在select标签中进行使用
-->
<!-- 在Mybatis核心配置文件中指定了别名，所以可以直接使用car -->
<resultMap id="carResultMap" type="car">
  <!-- 如果数据库表中有主键，建议配一个id标签，提高Mybatis的执行效率 -->
  <!-- 当然 id 也可以使用 result 标签，就是效率较低 -->
  <id property="id" column="id"/>
  <!-- 
    property=""：填写Java类的属性名
    column=""：填写数据库表的字段名
    javaType：指定Java类属性的类型，不用Mybatis自动类型推断，提高效率(可以使用别名)
    jdbcType：指定数据库表字段的类型，不用Mybatis自动类型推断，提高效率
  -->
  <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="carType"
          javaType="string"
          jdbcType="VARCHAR"
  />
</resultMap>
<!-- 
  使用结果映射，在select标签中不使用resultType
  而是使用 resultMap，其属性值为 resultMap 的 id
  使用 resultMap 指定结果映射
-->
<select id="selectAllByResultMap" resultMap="carResultMap">
  select * from t_car;
</select>

@org.junit.Test
public void testSelectAllByResultMap() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    List<Car> cars = mapper.selectAllByResultMap();
    cars.forEach(System.out::println);
    SqlSessionUtil.close();
}

<settings>
  <!-- 开启驼峰命名自动映射 -->
  <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

/**
 * 查询所有汽车信息
 * 使用驼峰命名自动映射
 * 
 * @return 汽车信息组成的集合
 */
List<Car> selectAllByMapUnderscoreToCamelCase();

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

@org.junit.Test
public void testSelectAllByMapUnderscoreToCamelCase() {
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    List<Car> cars = mapper.selectAllByMapUnderscoreToCamelCase();
    cars.forEach(System.out::println);
    SqlSessionUtil.close();
}

/**
 * 查询汽车信息的总记录条数
 * 
 * @return 汽车信息的总记录条数
 */
Long selectTotal();

<!-- long 是 java.util.Long 的别名 -->
<select id="selectTotal" resultType="long">
  select count(*) from t_car;
</select>

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

/**
 * 多条件查询
 * 可能的条件包括：品牌（brand）、指导价格（guide_price）、汽车类型（car_type）
 *
 * @param brand 品牌
 * @param guidePrice 指导价格
 * @param carType 汽车类型
 * @return 汽车信息组成的集合
 */
List<Car> selectByMultiCondition(
        @Param("brand") String brand, 
        @Param("guidePrice") Double guidePrice, 
        @Param("carType") String carType
);

<select id="selectByMultiCondition" resultType="Car">
    <!-- where 1 = 1 保证条件都为空时sql语法可以通过 -->
    <!-- 
      如果条件都为空，并且没有1 = 1，则SQL语句会变为select * from t_car where，
      会报语法错误
    -->
    select * from t_car where 1 = 1
    <!--
        1. if标签中test属性是必须的。
        2. if标签中test属性的值是false或者true。
              if标签的test属性中可以写表达式，值为false或者true
        3. 如果test是true，则if标签中的sql语句就会拼接。反之，则不会拼接。
        4. 在test属性中使用接口方法中参数的方式：（与#{}中使用接口方法中参数一样）
            1)当使用了@Param注解，那么test中要出现的是@Param注解指定的参数名。
                @Param("brand")，那么这里只能使用brand
            2)当没有使用@Param注解，那么test中要出现的是：
                param1 param2 param3 arg0 arg1 arg2....
            3)当使用了POJO，那么test中出现的是POJO类的属性名。
        5. 在mybatis的动态SQL当中，不能使用&&，只能使用and。
    -->
    <!-- 第一个条件添加and防止“where 1 = 1 brand like "%"#{brand}"%"”语法错误 -->
    <if test="brand != null and brand != ''">
        and 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>

@Test
    public void testSelectByMultiCondition(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        // 假设三个条件都不是空
        //List<Car> cars = mapper.selectByMultiCondition("比亚迪", 2.0, "新能源");
        // 假设三个条件都是空
        //List<Car> cars = mapper.selectByMultiCondition("", null, "");
        // 假设后两个条件不为空，第一个条件为空
        //List<Car> cars = mapper.selectByMultiCondition("", 2.0, "新能源");
        // 假设第一个条件不是空，后两个条件是空
        List<Car> cars = mapper.selectByMultiCondition("比亚迪", null, "");
        cars.forEach(car -> System.out.println(car));
        sqlSession.close();
    }

/**
 * 使用where标签，让where子句更加的智能。
 * @param brand
 * @param guidePrice
 * @param carType
 * @return
 */
List<Car> selectByMultiConditionWithWhere(@Param("brand") String brand, @Param("guidePrice") Double guidePrice, @Param("carType") String carType);

<select id="selectByMultiConditionWithWhere" resultType="Car">
    select * from t_car
    <!--
      where标签是专门负责where子句动态生成的。
      如果where标签中的条件都不成立，则SQL语句中不会有where子句
    -->
    <where>
        <!-- 可以自动去除条件前面多余的and或or -->
        <if test="brand != null and brand != ''">
            and 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>
</select>

@Test
public void testSelectByMultiConditionWithWhere(){
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    // 三个条件都不是空
    //List<Car> cars = mapper.selectByMultiConditionWithWhere("比亚迪", 2.0, "新能源");
    // 三个条件都是空
    //List<Car> cars = mapper.selectByMultiConditionWithWhere("", null, "");
    // 如果第一个条件是空
    //List<Car> cars = mapper.selectByMultiConditionWithWhere("", 2.0, "新能源");
    // 后面两个条件是空
    List<Car> cars = mapper.selectByMultiConditionWithWhere("比亚迪", null, "");
    cars.forEach(car -> System.out.println(car));
    sqlSession.close();
}

<select id="selectByMultiConditionWithTrim" resultType="Car">
    select * from t_car
    <!--
        prefix：加前缀
        suffix：加后缀
        prefixOverrides：删除前缀
        suffixOverrides：删除后缀
    -->
    <!--
      prefix="where" 是在trim标签内容的前面添加 where，
      这个添加是动态的
      如果有条件，会动态添加where，没有则不添加
    -->
    <!--
      suffixOverrides="and|or" 
      把trim标签中动态判断完后的内容多余的后缀and或or去掉
    -->
    <trim prefix="where" suffixOverrides="and|or">
        <if test="brand != null and brand != ''">
            brand like "%"#{brand}"%" or
        </if>
        <if test="guidePrice != null and guidePrice != ''">
            guide_price > #{guidePrice} and
        </if>
        <if test="carType != null and carType != ''">
            car_type = #{carType}
        </if>
    </trim>
</select>

/**
* 更新信息，使用set标签
* @param car
* @return
*/
int updateWithSet(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>
    where
        id = #{id}
</update>

<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 produceTime
* @return
*/
List<Car> selectWithChoose(@Param("brand") String brand, @Param("guidePrice") Double guidePrice, @Param("carType") String carType);

<select id="selectByChoose" resultType="Car">
        select * from t_car
        <where>
            <!--
              先根据品牌查询，没有传品牌，在根据价格查询，
              都没有最后根据汽车类型查询
            -->
            <choose>
                <!--只有一个分支会执行，所以不需要and or关键字-->
                <when test="brand != null and brand != ''">
                    brand like "%"#{brand}"%"
                </when>
                <when test="guidePrice != null and guidePrice != ''">
                    guide_price > #{guidePrice}
                </when>
                <!--都为null，还是执行这个分支，car_type = null，只是查不到数据-->
                <otherwise>
                    car_type = #{carType}
                </otherwise>
            </choose>
        </where>
    </select>

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','新能源')

/**
 * 批量删除。foreach标签
 * @param ids
 * @return
 */
int deleteByIds(@Param("ids") Long[] ids);

<!--
    foreach标签的属性：
        collection：指定数组或者集合
        item：代表数组或集合中的元素
        separator：循环之间的分隔符，自动添加分隔符，会自动在分隔符的两边添加空格
        open: foreach循环拼接的所有sql语句的最前面以什么开始。
        close: foreach循环拼接的所有sql语句的最后面以什么结束。
-->
<delete id="deleteByIds">
    <!--
      delete from t_car where id in(
      <foreach collection="ids" item="aaaaaaa" separator=",">
          #{aaaaaaa}
      </foreach>
      )
      没有使用@Param注解，上面的SQL报错了，错误信息是：[array, arg0]
      因为没有使用@Param注解时，参数在map集合中存储，默认使用array, arg0作为key
          map.put("array", 数组);
          map.put("arg0", 数组);
    -->
    delete from t_car where id in
    <foreach collection="ids" item="id" separator="," open="(" close=")">
        #{id}
    </foreach>
</delete>

/**
 * 根据id批量删除 使用or关键字。
 * @param ids
 * @return
 */
int deleteByIds2(@Param("ids") Long[] ids);

<delete id="deleteByIds2">
        delete from t_car where
        <!-- 会自动在分隔符的两边添加空格 -->
        <foreach collection="ids" item="id" separator="or">
            id=#{id}
        </foreach>
    </delete>

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

<insert id="insertBatch">
    insert into t_car values
    <!-- cars 汽车信息组成的list集合，car一个汽车类的对象，取属性，对象.属性 -->
    <foreach collection="cars" item="car" separator=",">
        (null,#{car.carNum},#{car.brand},#{car.guidePrice},#{car.produceTime},#{car.carType})
    </foreach>
</insert>

<!-- 
  声明sql片段
  将重复的SQL片段提取出来
-->
<sql id="carCols">
  id,
  car_num carNum,
  brand,
  guide_price guidePrice,
  produce_time produceTime,
  car_type carType
</sql>
<select id="selectAllRetMap" resultType="map">
  <!-- 将声明的sql片段包含进来 -->
  select 
    <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>

use mybatis_study;
drop table t_clazz;
create table t_clazz(
    cid int primary key,
    cname varchar(255)
);
drop table t_student;
create table t_student(
    sid int primary key,
    sname varchar(255),
    cid int
);
insert into t_clazz
values (1000, '高三一班'),
       (1001, '高三二班');
insert into t_student
values (1, '张三', 1000),
       (2, '李四', 1000),
       (3, '王五', 1000),
       (4, '赵六', 1001),
       (5, '钱七', 1001);

<dependencies>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.10</version>
  </dependency>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.30</version>
  </dependency>
  <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.5</version>
  </dependency>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
  </dependency>
</dependencies>

package cw.study.mybatis.pojo;
/**
 * ClassName: Clazz
 * Package: cw.study.mybatis.pojo
 * Description:
 * 班级信息
 *
 * @Author tcw
 * @Create 2023-06-04 11:38
 * @Version 1.0
 */
public class Clazz {
    private Integer cid;
    private String cname;
    public Clazz() {
    }
    public Clazz(Integer cid, String cname) {
        this.cid = cid;
        this.cname = cname;
    }
    @Override
    public String toString() {
        return "Clazz{" + "cid=" + cid + ", cname='" + cname + '\'' + '}';
    }
    public Integer getCid() {
        return cid;
    }
    public void setCid(Integer cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
}

package cw.study.mybatis.pojo;
/**
 * ClassName: Student
 * Package: cw.study.mybatis.pojo
 * Description:
 * 学生信息
 *
 * @Author tcw
 * @Create 2023-06-04 11:38
 * @Version 1.0
 */
public class Student {
    private Integer sid;
    private String sname;
    public Student() {
    }
    public Student(Integer sid, String sname) {
        this.sid = sid;
        this.sname = sname;
    }
    @Override
    public String toString() {
        return "Student{" + "sid=" + sid + ", sname='" + sname + '\'' + ", " + '}';
    }
    public Integer getSid() {
        return sid;
    }
    public void setSid(Integer sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
}

/**
 * 学生信息
 */
public class Student { // Student是多的一方
    private Integer sid;
    private String sname;
    private Clazz clazz; // Clazz是一的一方。
    ......
}

/**
 * 班级信息
 */
public class Clazz {
    private Integer cid;
    private String cname;
  ......
}