2.4.3MyBatis之复杂映射&配置深入

一、 Mybatis高级查询

1.1 ResutlMap属性

建立对象关系映射

* resultType 如果实体的属性名与表中字段名一致，将查询结果自动封装到实体类中 
* ResutlMap 如果实体的属性名与表中字段名不一致，可以使用ResutlMap实现手动封装到实体类中

1. 编写UserMapper接口

public interface UserMapper {
    
     public List<User> findAllResultMap(); }

2. 编写UserMapper.xml

<!--id : 标签的唯一标识
        type: 封装后实体类型-->
    <resultMap id="userResultMap" type="com.lagou.domain.User">
        <!--手动配置映射关系-->
        <!--id: 用来配置主键
            property 是实体类中的属性名
            column   是表中的字段名-->
        <id property="id" column="id"></id>
        <!-- result: 表中普通字段的封装-->
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
    </resultMap>
<!--查询所有用户-->
    <!--resultMap：手动配置实体属性与表中字段的映射关系，完成手动封装-->
    <select id="findAllResultMap" resultMap="userResultMap">
        select * from user
    </select>

3）代码测试

    @Test
    public void testFindAllResultMap() throws Exception {
    
    
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = userMapper.findAllResultMap();
        for (User user : list) {
    
    
            System.out.println(user);
        }
    }

1.2 多条件查询（三种）

需求
根据id和username查询user表 1）

1)方式一

使用 #{arg0}-#{argn} 或者 #{param1}-#{paramn} 获取参数
UserMapper接口

public interface UserMapper {
    
    
        public List<User> findByIdAndUsername1(Integer id, String username);
    }

UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByIdAndUsername1"
        resultType="user"> <!-- select * from user where id = #{arg0} and username = #{arg1} --> select * from user
    where id = #{param1} and username = #{param2}
</select>
</mapper>

测试

@Test
    public void testFindByIdAndUsername() throws Exception {
    
    
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = userMapper.findByIdAndUsername1(1, "子慕");
        System.out.println(list);
    }

2）方式二

使用注解，引入 @Param() 注解获取参数
UserMapper接口

public interface UserMapper {
    
    
        public List<User> findByIdAndUsername2(@Param("id") Integer id, @Param("username") String username);
    }

UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByIdAndUsername2"
        resultType="user"> select * from user where id = #{id} and username = #{username} </select>
</mapper>

测试

@Test
    public void testFindByIdAndUsername() throws Exception {
    
    
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = userMapper.findByIdAndUsername2(1, "子慕");
        System.out.println(list);
    }

3）方式三（推荐）

使用pojo对象传递参数
UserMapper接口

public interface UserMapper {
    
    
        public List<User> findByIdAndUsername3(User user);
    }

UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByIdAndUsername3" parameterType="com.lagou.domain.User"
        resultType="com.lagou.domain.User"> select * from user where id = #{id} and username = #{username} </select>
</mapper>

测试

@Test
    public void testFindByIdAndUsername() throws Exception {
    
    
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User param = new User();
        param.setId(1);
        param.setUsername("子慕");
        List<User> list = userMapper.findByIdAndUsername3(param);
        System.out.println(list);
    }

1.3 模糊查询

需求
根据username模糊查询user表

1)方式一

UserMapper接口

public interface UserMapper {
    
    
        public List<User> findByUsername1(String username);
    }

UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByUsername1" parameterType="string"
        resultType="user"> select * from user where username like #{username} </select>
</mapper>

测试

@Test
    public void testFindByUsername() throws Exception {
    
    
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = userMapper.findByUsername1("%王%");
        for (User user : list) {
    
    
            System.out.println(user);
        }
    }

方式二

UserMapper接口

public interface UserMapper {
    
    
        public List<User> findByUsername2(String username);
    }

UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper"> <!--不推荐使用，因为会出现sql注入问题-->
<select id="findByUsername2" parameterType="string"
        resultType="user"> select * from user where username like '${value}' </select>
</mapper>

测试

@Test
    public void testFindByUsername() throws Exception {
    
    
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = userMapper.findByUsername2("%王%");
        for (User user : list) {
    
    
            System.out.println(user);
        }
    }

3） ${} 与 #{} 区别【笔试题】

#{} :表示一个占位符号

• 通过 #{} 可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#
• {}可以有效防止sql注入。
• #{} 可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值， #{} 括号中名称随便写。

${} :表示拼接sql串

• 通过 ${} 可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换，会出现sql注入问题。
• ${} 可以接收简单类型值或pojo属性值。
• 如果parameterType传输单个简单类型值， ${} 括号中只能是value。
  补充：TextSqlNode.java 源码可以证明

二、 Mybatis映射文件深入

2.1 返回主键

应用场景
我们很多时候有这种需求，向数据库插入一条记录后，希望能立即拿到这条记录在数据库中的主键值

2.1.1 useGeneratedKeys

public interface UserMapper {
    
     
        // 返回主键 
        public void save(User user);
    }

<!-- useGeneratedKeys="true" 声明返回主键 keyProperty="id" 把返回主键的值，封装到实体的id属性中 
        注意：只适用于主键自增的数据库，mysql和sqlserver支持，oracle不支持 --> 
<insert
id="save" parameterType="user" useGeneratedKeys="true"
keyProperty="id"> INSERT INTO `user`(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address}) </insert>

注意：只适用于主键自增的数据库，mysql和sqlserver支持，oracle不行。

2.1.2 selectKey

public interface UserMapper {
    
     
	// 返回主键 
	public void save(User user);
}

<!-- selectKey 适用范围广，支持所有类型数据库 
keyColumn="id" 指定主键列名 keyProperty="id" 指定主键封装到实体的id属性中 
resultType="int" 指定主键类型 order="AFTER" 设置在sql语句执行前（后），执行此语句 --> 
<insert id="save" parameterType="user">
<selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">SELECT LAST_INSERT_ID();</selectKey> INSERT
INTO `user`(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>

11.3 测试代码

@Test
    public void testSave() throws Exception {
    
    
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUsername("子慕");
        user.setAddress("北京");
        user.setBirthday(new Date());
        user.setSex("男");
        userMapper.save(user);
        System.out.println("返回主键:" + user.getId());
    }

2.2 动态SQL

应用场景
当我们要根据不同的条件，来执行不同的sql语句的时候，需要用到动态sql

2.2.1 动态 SQL 之if

需求
根据id和username查询，但是不确定两个都有值。
a）UserMapper接口

public List<User> findByIdAndUsernameIf(User user);

b）UserMapper.xml映射

<!-- where标签相当于 where 1=1，但是如果没有条件，就不会拼接where关键字 --> 
<select id="findByIdAndUsernameIf" parameterType="user" resultType="user">SELECT * FROM `user`
<where>
    <if test="id != null">AND id = #{id}</if>
    <if test="username != null">AND username = #{username}</if>
</where>
</select>

c）测试代码

// if标签 where标签 
    @Test
    public void testFindByIdAndUsernameIf() throws Exception {
    
    
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User param = new User(); 
        param.setId(42);
        param.setUsername("王小二");
        List<User> list = userMapper.findByIdAndUsernameIf(param);
        System.out.println(list);
    }

2.2.2 动态 SQL 之set

需求
动态更新user表数据，如果该属性有值就更新，没有值不做处理。
a）UserMapper接口

/**
     * 动态SQL之set标签
     * */
    public void updateIf(User user);

b）UserMapper.xml映射

<!-- set标签在更新的时候，自动加上set关键字，然后去掉最后一个条件的逗号 -->
    <update id="updateIf" parameterType="user">
        update user
        <set>
            <if test="username !=null">
                username = #{username},
            </if>
            <if test="birthday !=null">
                birthday = #{birthday},
            </if>
            <if test="sex !=null">
                sex = #{sex},
            </if>
            <if test="address !=null">
                address = #{address},
            </if>
        </set>
        where id = #{id}
    </update>

c）测试代码

// set标签
    @Test
    public void testUpdateIf() throws Exception {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setId(5);
        user.setUsername("小二王");
        user.setSex("女");
        userMapper.updateIf(user);
        sqlSession.commit();
        sqlSession.close();
    }

2.2.3 动态 SQL 之foreach

foreach主要是用来做数据的循环遍历
例如： select * from user where id in (1,2,3) 在这样的语句中，传入的参数部分必须依靠foreach遍历才能实现。
< foreach>标签用于遍历集合，它的属性：

• collection：代表要遍历的集合元素
• open：代表语句的开始部分
• close：代表结束部分
• item：代表遍历集合的每个元素，生成的变量名
• sperator：代表分隔符
  a）集合
  UserMapper接口

/**
     * 动态SQL之foreach 集合
     * */
public List<User> findByList(List<Integer> ids);

UserMaper.xml映射

<!--动态sql的foreach标签：多值查询：根据多个id值查询用户-->
    <select id="findByList" parameterType="list" resultType="user">
        SELECT * FROM `user`
        <where>
            <!--
                collection : 代表要遍历的集合元素，通常写collection或者list
                open : 代表语句的开始部分
                close : 代表语句的结束部分
                item : 代表遍历结合中的每个元素，生成的变量名
                separator: 分隔符
             -->
            <foreach collection="collection" open="id in (" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </where>

    </select>

测试代码

/***
     * 动态SQL之foreach 多值查询
     * @throws Exception
     */
    @Test
    public void testFindByList() throws Exception {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<Integer> ids = new ArrayList<Integer>();
        ids.add(1);
        ids.add(2);
        ids.add(5);
        List<User> list = userMapper.findByList(ids);
        System.out.println(list);
    }

b）数组
UserMapper接口

/**
     * 动态SQL之foreach 数组
     * */
    public List<User> findByArray(Integer[] ids);

UserMaper.xml映射

<!--动态sql的foreach标签：多值查询：根据多个id值查询用户-->
    <select id="findByArray" parameterType="int" resultType="user">
        <include refid="selectUser"/>
        <where>
            <!--
                collection : 代表要遍历的集合元素，通常写collection或者list
                open : 代表语句的开始部分
                close : 代表语句的结束部分
                item : 代表遍历结合中的每个元素，生成的变量名
                separator: 分隔符
             -->
            <foreach collection="array" open="id in (" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </where>

    </select>

测试代码

/***
     * foreach标签 array
     * @throws Exception
     */
    @Test
    public void testFindByArray() throws Exception {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        Integer[] ids = {
    
    1, 2, 18};
        List<User> list = userMapper.findByArray(ids);
        System.out.println(list);
    }

2.3 SQL片段

应用场景
映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

<sql id="selectUser">
        select * from user
</sql>

    <!--动态sql的foreach标签：多值查询：根据多个id值查询用户-->
    <select id="findByList" parameterType="list" resultType="user">
        <include refid="selectUser"/>
        <where>
            ...
        </where>

    </select>

2.4 知识小结

MyBatis映射文件配置

<select>：查询 
<insert>：插入 
<update>：修改 
<delete>：删除 
<selectKey>：返回主键 
<where>：where条件 
<if>：if判断 
<foreach>：
for循环 
<set>：set设置 
<sql>：sql片段抽取

三、 Mybatis核心配置文件深入

3.1 plugins标签

MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封
装，使用简单的方式即可获得分页的相关数据
开发步骤：
①导入通用PageHelper的坐标
②在mybatis核心配置文件中配置PageHelper插件
③测试分页数据获取

①导入通用PageHelper的坐标
pom.xml中添加

 <!-- 分页助手 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>3.7.5</version>
        </dependency>

        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>0.9.1</version>
        </dependency>

②在mybatis核心配置文件中配置PageHelper插件
sqlMapConfig.xml中配置

<!-- 分页助手的插件 注意要放在<typeAliases>这些标签后面，<environments>标签前面-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <!-- 指定方言 --> <property name="dialect" value="mysql"/>
        </plugin>
    </plugins>

③测试分页代码实现

/*
        核心配置文件深入分页：plugin标签：pageHelper
     */
    @Test
    public void testPageHelper() throws IOException {
    
    

        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        // 设置分页参数
        // 参数1： 当前页
        // 参数2： 每页显示的条数
        PageHelper.startPage(1,2);

        List<User> users = userMapper.findAllResultMap();
        for (User user : users) {
    
    
            System.out.println(user);
        }

        // 获取分页相关的其他参数
        PageInfo<User> pageInfo = new PageInfo<User>(users);
        System.out.println("总条数"+ pageInfo.getTotal());
        System.out.println("总页数"+ pageInfo.getPages());
        System.out.println("是否是第一页"+ pageInfo.isIsFirstPage());
        sqlSession.close();
    }

获得分页相关的其他参数

//其他分页的数据 
PageInfo<User> pageInfo = new PageInfo<User>(select); 
System.out.println("总条数："+pageInfo.getTotal()); 
System.out.println("总页数："+pageInfo.getPages()); 
System.out.println("当前页："+pageInfo.getPageNum());
System.out.println("每页显示长度："+pageInfo.getPageSize()); 
System.out.println("是否第一页："+pageInfo.isIsFirstPage()); 
System.out.println("是否最后一页："+pageInfo.isIsLastPage());

3.2 知识小结

MyBatis核心配置文件常用标签：
1、properties标签：该标签可以加载外部的properties文件
2、typeAliases标签：设置类型别名
3、environments标签：数据源环境配置标签
4、plugins标签：配置MyBatis的插件

四 Mybatis多表查询

4.1 数据库表关系介绍

关系型数据库表关系分为

• 一对一
• 一对多
• 多对多
  案例环境准备

DROP TABLE
IF
	EXISTS `orders`;
CREATE TABLE `orders` (
`id` INT ( 11 ) NOT NULL AUTO_INCREMENT,
`ordertime` VARCHAR ( 255 ) DEFAULT NULL,
`total` DOUBLE DEFAULT NULL,
`uid` INT ( 11 ) DEFAULT NULL,
PRIMARY KEY ( `id` ),
KEY `uid` ( `uid` ),
CONSTRAINT `orders_ibfk_1` FOREIGN KEY ( `uid` ) REFERENCES `user` ( `id` ) 
) ENGINE = INNODB AUTO_INCREMENT = 4 DEFAULT CHARSET = utf8;
-- ---------------------------- -- Records of orders -- ----------------------------
INSERT INTO `orders`
VALUES
	( '1', '2020-12-12', '3000', '1' );
INSERT INTO `orders`
VALUES
	( '2', '2020-12-12', '4000', '1' );
INSERT INTO `orders`
VALUES
	( '3', '2020-12-12', '5000', '2' );
-- ---------------------------- -- Table structure for sys_role -- ----------------------------
DROP TABLE
IF
	EXISTS `sys_role`;
CREATE TABLE `sys_role` (
`id` INT ( 11 ) NOT NULL AUTO_INCREMENT,
`rolename` VARCHAR ( 255 ) DEFAULT NULL,
`roleDesc` VARCHAR ( 255 ) DEFAULT NULL,
PRIMARY KEY ( `id` ) 
) ENGINE = INNODB AUTO_INCREMENT = 3 DEFAULT CHARSET = utf8;
-- ---------------------------- -- Records of sys_role -- ----------------------------
INSERT INTO `sys_role`
VALUES
	( '1', 'CTO', 'CTO' );
INSERT INTO `sys_role`
VALUES
	( '2', 'CEO', 'CEO' );
-- ------------------------------ Table structure for sys_user_role -- ----------------------------
DROP TABLE
IF
	EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
`userid` INT ( 11 ) NOT NULL,
`roleid` INT ( 11 ) NOT NULL,
PRIMARY KEY ( `userid`, `roleid` ),
KEY `roleid` ( `roleid` ),
CONSTRAINT `sys_user_role_ibfk_1` FOREIGN KEY ( `userid` ) REFERENCES `sys_role` ( `id` ),
CONSTRAINT `sys_user_role_ibfk_2` FOREIGN KEY ( `roleid` ) REFERENCES `user` ( `id` ) 
) ENGINE = INNODB DEFAULT CHARSET = utf8;
-- ---------------------------- -- Records of sys_user_role -- ----------------------------
INSERT INTO `sys_user_role`
VALUES
	( '1', '1' );
INSERT INTO `sys_user_role`
VALUES
	( '2', '1' );
INSERT INTO `sys_user_role`
VALUES
	( '1', '2' );
INSERT INTO `sys_user_role`
VALUES
	( '2', '2' );

4.2 一对一（多对一）

4.2.1 介绍

一对一查询模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户一对一查询的需求：查询所有订单，与此同时查询出每个订单所属的用户

一对一查询语句

SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`;

4.2.2 代码实现

1 ）User实体,Order实体

public class User {
    
    
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
	
	//get、set方法...
}
public class Orders {
    
    
    private Integer id;
    private String ordertime;
    private Double total;
    private Integer uid;

    //表示当前订单属于哪个用户
    private User user;
    //get、set方法...
}

2 ）OrderMapper接口

public interface OrderMapper {
    
    
    /***
     * 一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属信息
     */
    public List<Orders> findAllWithUser();
}

3 ）OrderMapper.xml映射

<mapper namespace="com.lagou.mapper.OrderMapper">

    <!--一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息-->
    <resultMap id="orderMap" type="com.lagou.domain.Orders">
        <id property="id" column="id"/>
        <id property="ordertime" column="ordertime"/>
        <id property="total" column="total"/>
        <id property="uid" column="uid"/>

        <!--
            association : 在进行一对一关联查询配置时，使用association标签进行关联
                property="user" ：要封装实体的属性名
                javaType="com.lagou.domain.User" 要封装的实体的属性类型
        -->
        <association property="user" javaType="User">
            <id property="id" column="uid"></id>
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="sex" column="sex"></result>
            <result property="address" column="address"></result>
        </association>
    </resultMap>
    
    <select id="findAllWithUser" resultMap="orderMap">
        SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`
    </select>

</mapper>

4 ）测试代码

/***
     * 一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息
     * @throws IOException
     */
    @Test
    public void testOrderWithUser() throws IOException {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
        List<Orders> orders = mapper.findAllWithUser();
        for (Orders order : orders) {
    
    
            System.out.println(order);
        }

    }

4.3 一对多

4.3.1 介绍

一对多查询模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对多查询的需求：查询所有用户，与此同时查询出该用户具有的订单

一对多查询语句

SELECT *,o.id oid FROM USER u LEFT JOIN orders o ON u.`id` = o.`uid`;

4.3.2 代码实现

1 ）User实体

//增加以下表示多方关系：集合   代表当前用户所具有的订单列表
    private List<Orders> ordersList;
    //get、set、tostring

2 ）UserMapper接口

/***
     * 一对多关联查询：查询说有用户，同时查询每个用户关联信息
     */
    public List<User> findAllWithOrder();

3 ）UserMapper.xml映射

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lagou.mapper.UserMapper">
    <!--一对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的订单信息-->
    <resultMap id="userMap" type="User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>

        <!--
            collection : 一对多使用collection标签进行关联
        -->
        <collection property="ordersList" ofType="Orders">
            <id property="id" column="oid"></id>
            <result property="ordertime" column="ordertime"/>
            <result property="total" column="total"/>
            <result property="uid" column="uid"/>
        </collection>
    </resultMap>

    <select id="findAllWithOrder"  resultMap="userMap">
       SELECT u.*,o.id oid,o.ordertime,o.total,o.uid FROM orders o RIGHT JOIN USER u ON o.uid = u.id
    </select>
</mapper>

4 ）测试代码

/***
     * 一对多关联查询：查询说有用户，同时查询每个用户关联订单信息
     * @throws Exception
     */
    @Test
    public void testUserWithOrder() throws Exception {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = userMapper.findAllWithOrder();
        for (User user : list) {
    
    
            System.out.println(user);
        }
    }

4.4 多对多

4.4.1 介绍

多对多查询的模型
用户表和角色表的关系为，一个用户有多个角色，一个角色被多个用户使用
多对多查询的需求：查询所有用户同时查询出该用户的所有角色

多对多查询语句

SELECT * FROM `user` u
LEFT JOIN user_role ur ON u.id=ur.userid
LEFT JOIN role r ON ur.roleid=r.id;

4.4.2 代码实现

1 ）User和Role 实体

//user类添加
 // 代表当前用户关联的角色列表
 private List<Role> roleList;//get、set
 public class Role {
    
    
    private Integer id;
    private String roleName;
    private String roleDesc;
    //get、set...
}

2 ）UserMapper接口

/***
     * 多对多关联查询，查询所有用户同时查询用户所有角色
     * @return
     */
    public List<User> findAllWithRole();

3 ）UserMapper.xml映射

<!--多对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的角色信息-->
    <resultMap id="userRoleMap" type="user">
        <id property="id" column="id"/>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>

        <collection property="roleList" ofType="role">
            <id property="id" column="rid"/>
            <result property="roleName" column="roleName"/>
            <result property="roleDesc" column="roleDesc"/>
        </collection>
    </resultMap>
    <select id="findAllWithRole" resultMap="userRoleMap">
        SELECT * FROM `user` u LEFT JOIN user_role ur ON u.id=ur.userid LEFT JOIN role r ON ur.roleid=r.id
    </select>

4 ）测试代码

/***
     * 多对多关联，查询所有用户及关联角色信息
     * @throws IOException
     */
    @Test
    public void testUserWithRole() throws IOException {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = mapper.findAllWithRole();
        for (User user : list) {
    
    
            System.out.println(user);
        }
        sqlSession.close();
    }

4.5 小结

MyBatis多表配置方式

• 多对一（一对一）配置：使用+做配置
• 一对多配置：使用+做配置
• 多对多配置：使用+做配置
• 多对多的配置跟一对多很相似，难度在于SQL语句的编写。

五 MyBatis嵌套查询

5.1 什么是嵌套查询

嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用mybatis的语法嵌套在一
起。
举个栗子

* 需求：查询一个订单，与此同时查询出该订单所属的用户 
* 1. 联合查询
* SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`; 
* 2. 嵌套查询 
* 2.1 先查询订单 SELECT * FROM orders 
* 2.2 再根据订单uid外键，查询用户 SELECT * FROM `user` WHERE id = #{根据订单查询的uid} 
* 2.3 最后使用mybatis，将以上二步嵌套起来 ...

5.2 一对一嵌套查询

5.2.1 介绍

需求：查询一个订单，与此同时查询出该订单所属的用户

一对一查询语句

-- 先查询订单 
SELECT * FROM orders; 
-- 再根据订单uid外键，查询用户 
SELECT * FROM `user` WHERE id = #{订单的uid};

5.2.2 代码实现

1）OrderMapper接口

/***
     * 一对一嵌套：查询所有订单，与此同时还要查询出每个订单所属信息
     */
    public List<Orders> findAllWithUser2();

2）OrderMapper.xml映射

<!--一对一嵌套查询-->
    <resultMap id="orderMap2" type="Orders">
        <id property="id" column="id"></id>
        <id property="ordertime" column="ordertime"/>
        <id property="total" column="total"/>
        <id property="uid" column="uid"/>

        <!--问题：1.怎么去执行第二条sql , 2.如何执行第二条sql的时候，把uid作为参数进行传递-->
        <association property="user" javaType="User" select="com.lagou.mapper.UserMapper.findById" column="uid">

        </association>
    </resultMap>
    <select id="findAllWithUser2" resultMap="orderMap2">
        SELECT * FROM orders
    </select>

3）UserMapper接口

public User findById(Integer id);

4）UserMapper.xml映射

<!--根据id查询用户
      useCache="true" 代表当前这个statement是使用二级缓存
  -->
    <select id="findById" resultType="com.lagou.domain.User" parameterType="int" useCache="true">
        SELECT * FROM user WHERE id = #{id}
    </select>

5）测试代码

@Test
    public void testOrderWithUser2() throws IOException {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
        List<Orders> orders = mapper.findAllWithUser2();
        for (Orders order : orders) {
    
    
            System.out.println(order);
        }
        sqlSession.close();
    }

5.3 一对多嵌套查询

5.3.1 介绍

需求：查询所有用户，与此同时查询出该用户具有的订单
一对多查询语句

-- 先查询用户 
SELECT * FROM `user`; 
-- 再根据用户id主键，查询订单列表 
SELECT * FROM orders where uid = #{用户id};

5.3.2 代码实现

a）UserMapper接口

/***
     * 一对多嵌套查询
     * @return
     */
    public List<User> findAllWithOrder2();

b）UserMapper.xml映射

<!--一对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的订单信息-->
    <resultMap id="userOrderMap" type="com.lagou.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
        <!--fetchType="lazy" : 延迟加载策略
            fetchType="eager": 立即加载策略
        -->
        <collection property="ordersList" ofType="com.lagou.domain.Orders" column="id"
                    select="com.lagou.mapper.OrderMapper.findByUid" ></collection>
    </resultMap>

    <select id="findAllWithOrder2" resultMap="userOrderMap">
        SELECT * FROM USER
    </select>

c）OrderMapper接口

//根据uid查询对应订单
    public List<Orders> findByUid(Integer uid);

d）OrderMapper.xml映射

    <select id="findByUid" parameterType="int" resultType="orders">
        SELECT * FROM orders where uid = #{uid};
    </select>

e）测试代码

/***
     * 一对多嵌套查询
     * @throws IOException
     */
    @Test
    public void testAllWithOrder2() throws IOException {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.findAllWithOrder2();
        for (User user : users) {
    
    
            System.out.println(user);
        }
        sqlSession.close();
    }

5.4 多对多嵌套查询

5.4.1 介绍

需求：查询用户 同时查询出该用户的所有角色
多对多查询语句

-- 先查询用户 
SELECT * FROM `user`; 
-- 再根据用户id主键，查询角色列表 
SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid` WHERE ur.`uid` = #{用户id};

5.4.2 代码实现

a）UserMapper接口

public List<User> findAllWithRole2();

b）UserMapper.xml映射

<!--多对多嵌套查询-->
    <resultMap id="userRoleMap2" type="com.lagou.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>

        <collection property="roleList" ofType="com.lagou.domain.Role" column="id" select="com.lagou.mapper.RoleMapper.findByUid"></collection>
    </resultMap>

    <!--多对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的角色信息-->
    <select id="findAllWithRole2" resultMap="userRoleMap2">
        SELECT * FROM USER
    </select>

c）RoleMapper接口

public List<Role> findByUid(Integer uid);

d）RoleMapper.xml映射

<mapper namespace="com.lagou.mapper.RoleMapper">
    <select id="findByUid" resultType="Role" parameterType="int">
        SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`roleid` WHERE ur.`userid` = #{uid};
    </select>
</mapper>

e）测试代码

/***
     * 多对多嵌套查询
     * @throws IOException
     */
    @Test
    public void testUserWithRole2() throws IOException {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.findAllWithRole2();
        for (User user : users) {
    
    
            System.out.println(user);
        }
        sqlSession.close();
    }

5.5 小结

• 一对一配置：使用+做配置，通过column条件，执行select查询
• 一对多配置：使用+做配置，通过column条件，执行select查询
• 多对多配置：使用+做配置，通过column条件，执行select查询
• 优点：简化多表查询操作
• 缺点：执行多次sql语句，浪费数据库性能