输入映射和输出映射

parameterType(输入类型)

1 传递简单类型

使用#{}占位符，或者${}进行sql拼接。

2 传递pojo对象

Mybatis使用ognl表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称。

3 传递pojo包装对象

开发中通过可以使用pojo传递查询条件。
查询条件可能是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如查询用户信息的时候，将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。
包装对象：Pojo类中的一个属性是另外一个pojo。
需求：根据用户名模糊查询用户信息，查询条件放到QueryVo的user属性中。

  1. 编写QueryVo

public class QueryVo {
// 包含其他的pojo
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}

  1. Sql语句

SELECT * FROM user WHERE username LIKE ‘%张%’

  1. Mapper.xml文件

在UserMapper.xml中配置sql，如下图。
02 输入输出映射 动态Sql - 图1

  1. Mapper接口

在UserMapper接口中添加方法，如下图：
02 输入输出映射 动态Sql - 图2

  1. 测试方法

在UserMapeprTest增加测试方法，如下：
_@_Test
public void testQueryUserByQueryVo() {
// mybatis和spring整合，整合之后，交给spring管理
SqlSession sqlSession = this.sqlSessionFactory.openSession();
// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 使用userMapper执行查询，使用包装对象
QueryVo queryVo = new QueryVo();
// 设置user条件
User user = new User();
user.setUsername(“张”);
// 设置到包装对象中
queryVo.setUser(user);
// 执行查询
List list = userMapper.queryUserByQueryVo(queryVo);
for (User u : list) {
System.out.println(u);
}
// mybatis和spring整合，整合之后，交给spring管理
sqlSession.close();
}

  1. 效果

测试结果如下图：
02 输入输出映射 动态Sql - 图3

resultType(输出类型)

1 输出简单类型

需求:查询用户表数据条数
sql：SELECT count(*) FROM user

  1. Mapper.xml文件

在UserMapper.xml中配置sql，如下图：
02 输入输出映射 动态Sql - 图4

  1. Mapper接口

在UserMapper添加方法，如下图：
02 输入输出映射 动态Sql - 图5

  1. 测试方法

在UserMapeprTest增加测试方法，如下：

  1. @Test
  2. public void testQueryUserCount() {
  3.     // mybatis和spring整合，整合之后，交给spring管理
  4.     SqlSession sqlSession = this.sqlSessionFactory.openSession();
  5.     // 创建Mapper接口的动态代理对象，整合之后，交给spring管理
  6.     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  8.     // 使用userMapper执行查询用户数据条数
  9.     int count = userMapper.queryUserCount();
  10.     System.out.println(count);
  12.     // mybatis和spring整合，整合之后，交给spring管理
  13.     sqlSession.close();
  14. }
  1. 效果

测试结果如下图：
02 输入输出映射 动态Sql - 图6
注意：输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型。

2 输出pojo对象

参考第一天内容

3 输出pojo列表

参考第一天内容

resultMap

resultType可以指定将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。
如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系 ，resultMap实质上还需要将查询结果映射到pojo对象中。
resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。
需求：查询订单表order的所有数据-
sql：SELECT id, user_id, number, createtime, note FROM order

动态SQL

1 If

演示基于完成用户列表查询功能，由多查询条件拼装引出if标签。

  1. <!-- 演示动态sql-if标签的使用情景 -->
  2. <select id="getUserByWhere" parameterType="user" resultType="com.carven.mybatis.pojo.User">
  3.    <!-- SELECT * FROM USER WHERE username LIKE '%${username}%' and id = #{id} -->
  5.    SELECT * FROM USER where 1 = 1
  6.    <!-- if标签的使用 -->
  7.    <if test="id != null">
  8.        and id = #{id}
  9.    </if>
  10.    <if test="username != null and username != ''">
  11.        and username LIKE '%${username}%'
  12.    </if>
  13. </select>

2 where

  1. <!-- 演示动态sql-where标签的使用情景 -->
  2. <select id="getUserByWhere2" parameterType="user"
  3.    resultType="com.carven.mybatis.pojo.User">
  4.    SELECT * FROM USER
  5.    <!-- where会自动加上where同处理多余的and -->
  6.    <where>
  7.        <!-- if标签的使用 -->
  8.        <if test="id != null">
  9.           and id = #{id}
  10.        </if>
  11.        <if test="username != null and username != ''">
  12.           and username LIKE '%${username}%'
  13.        </if>
  14.    </where>
  15. </select>

3 Foreach

  1. <!-- 演示动态sql-foreach标签的使用情景 -->
  2. <select id="getUserByIds" parameterType="queryvo"
  3.    resultType="com.carven.mybatis.pojo.User">
  4.    SELECT * FROM USER
  5.    <!-- where会自动加上where同处理多余的and -->
  6.    <where>
  7.        <!-- id IN(1,10,25,30,34) -->
  8.        <!-- foreach循环标签
  9.            collection:要遍历的集合，来源入参
  10.            open:循环开始前的sql
  11.            separator:分隔符
  12.            close:循环结束拼接的sql
  13.        -->
  14.        <foreach item="uid" collection="ids" open="id IN(" separator=","
  15.           close=")">
  16.           #{uid}
  17.        </foreach>    
  18.    </where>
  19.   </select>

4 SQL片段

  1. <sql id="user_column">
  2.    `id`,
  3.    `username`,
  4.    `birthday`,
  5.    `sex`,
  6.    `address`,
  7.    `uuid2`
  8. </sql>
  9. 使用方式:
  10. SELECT
  11. <!-- sql片段的使用：include:引入sql片段,refid引入片段id -->
  12. <include refid="user_column" />
  13. FROM USER

关联查询

一对一

方式一: resultType

1.新建OrderUser的pojo，继承自Order。

  1. public class OrderUser extends Order {
  2.     private String username;
  3.     private String address;
  4.     ……get,set
  5. }

2.修改order的映射文件，新增查询方法getOrderUser。

  1. <!-- 一对一关联查询，使用resultType -->
  2. <select id="getOrderUser" resultType="orderuser">
  3.    SELECT
  4.      o.`id`,
  5.      o.`user_id` userId,
  6.      o.`number`,
  7.      o.`createtime`,
  8.      o.`note`,
  9.      u.`username`,
  10.      u.`address`
  11.    FROM `order` o
  12.    LEFT JOIN `user` u
  13.    ON u.id = o.`user_id`
  14. </select>

方式二: resultMap

1.改造order的pojo
02 输入输出映射 动态Sql - 图7

  1. 修改order的映射文件
  1. <!-- 一对一关联查询-resultMap -->
  2. <resultMap type="order" id="order_user_map">
  3.    <!-- id标签用于绑定主键 -->
  4.    <id property="id" column="id"/>
  5.    <!-- 使用result绑定普通字段 -->
  6.    <result property="userId" column="user_id"/>
  7.    <result property="number" column="number"/>
  8.    <result property="createtime" column="createtime"/>
  9.    <result property="note" column="note"/>
  11.    <!-- association:配置一对一关联
  12.         property:绑定的用户属性
  13.         javaType:属性数据类型，支持别名
  14.    -->
  15.    <association property="user" javaType="com.carven.mybatis.pojo.User">
  16.        <id property="id" column="user_id"/>
  18.        <result property="username" column="username"/>
  19.        <result property="address" column="address"/>
  20.        <result property="sex" column="sex"/>
  21.    </association>
  22. </resultMap>
  23. <!-- 一对一关联查询-使用resultMap -->
  24. <select id="getOrderUser2" resultMap="order_user_map">
  25.    SELECT
  26.      o.`id`,
  27.      o.`user_id`,
  28.      o.`number`,
  29.      o.`createtime`,
  30.      o.`note`,
  31.      u.`username`,
  32.      u.`address`,
  33.      u.`sex`
  34.    FROM `order` o
  35.    LEFT JOIN `user` u
  36.    ON u.id = o.`user_id`
  37. </select>

一对多

  1. 改造user的pojo

02 输入输出映射 动态Sql - 图8

  1. 修改user的映射文件
  1. <!-- 一对多关联查询 -->
  2. <resultMap type="user" id="user_order_map">
  3.    <id property="id" column="id" />
  4.    <result property="username" column="username" />
  5.    <result property="birthday" column="birthday" />
  6.    <result property="address" column="address" />
  7.    <result property="sex" column="sex" />
  8.    <result property="uuid2" column="uuid2" />
  10.    <!-- collection:配置一对多关系
  11.         property:用户下的order属性
  12.         ofType:property的数据类型，支持别名
  13.    -->
  14.    <collection property="orders" ofType="order">
  15.        <!-- id标签用于绑定主键 -->
  16.        <id property="id" column="oid"/>
  17.        <!-- 使用result绑定普通字段 -->
  18.        <result property="userId" column="id"/>
  19.        <result property="number" column="number"/>
  20.        <result property="createtime" column="createtime"/>
  21.    </collection>
  22. </resultMap>
  23. <!-- 一对多关联查询 -->
  24. <select id="getUserOrder" resultMap="user_order_map">
  25.    SELECT
  26.    u.`id`,
  27.    u.`username`,
  28.    u.`birthday`,
  29.    u.`sex`,
  30.    u.`address`,
  31.    u.`uuid2`,
  32.    o.`id` oid,
  33.    o.`number`,
  34.    o.`createtime`
  35.    FROM `user` u
  36.    LEFT JOIN `order` o
  37.    ON o.`user_id` = u.`id`
  38. </select>