【MyBatis学习及总结06】联合查询：ResultMap封装数据库中查询出的数据

1. resultMap解决属性名和字段名不同

JavaBean是指对数据库封装的类。。。。不是普通类
首先看下应用场景：
下面是数据库中的一个表：

下面是根据上面的数据库数据封装的JavaBean对象：并且对象的属性和数据库的字段名不一致

public class Cat {
    private Integer id;
    private String name;
    private Integer gender;
    private Integer age;
}

下面看一下，当数据库的字段名和JavaBean的属性名不一致时会出现什么情况：

public interface CatDao {
    public Cat getCatById(Integer id);
}

<mapper namespace="com.hh.dao.CatDao">
    <select id="getCatById" resultType="com.hh.bean.Cat">
        select * from t_cat where id=#{id}
    </select>
</mapper>

@Test
public void testSelect(){
    SqlSession sqlSession = sqlsessionFactory.openSession();
    CatDao mapper = sqlSession.getMapper(CatDao.class);
    Cat cat = mapper.getCatById(1);
    System.out.println(cat);
    sqlSession.close();
}

我们数据库中的数据并没有查询出来，也就是没有封装上去。

默认情况下：
MyBatis自动封装结果集，条件是数据库的字段名和JavaBean的属性名要对应。
如果不是对应的：
1.可以给数据库中要查询的字段名起别名，但是每次都起别名，麻烦
2.驼峰命名设置（要求数据库字段名满足aa_b,JavaBean对象的属性满足aaB）

下面介绍一种解决方法：

<mapper namespace="com.hh.dao.CatDao">
    <!--
    id:唯一标识
    type：指定为哪个JavaBean自定义封装规则:全类名
    -->
    <resultMap id="mycat" type="com.hh.bean.Cat">
        <!--
        用来指定主键列的对应规则:
        column="id":指定哪一列是主键列
        property="id"：指定Cat类的哪个属性封装id这一列数据
        -->
        <id property="id" column="id" />

        <!--指定普通列的对应规则-->
        <result property="name" column="cName"/>
        <result property="age" column="cAge"/>
        <result property="gender" column="cgender"/>
    </resultMap>

    <select id="getCatById" resultMap="mycat">
        select * from t_cat where id=#{id}
    </select>
</mapper>

2.ResultMap封装数据（JavaBean中有JavaBean）

场景：，站在钥匙的角度，一个钥匙开一把锁（一对一）


现在想要查询出钥匙的信息以及这把钥匙能开的锁的信息：

//因为有两个id,所以对id起别名
 SELECT k.id kid, k.`keyname`,k.`lockid`,l.`id` lid,l.`lockname`
 FROM t_key k 
 LEFT JOIN t_lock l
 ON k.lockid=l.id
 WHERE k.id=1;

2.1 级联属性的方式封装查出的数据

public class Key {
    private int id;
    private String keyName;
    //JavaBean对象
    private Lock lock;
}

public class Lock {
    private int id;
    private String lockName;
}

public interface KeyDao {
    //当前钥匙能开哪把锁
    public Key getKeyById(int id);
}

使用级联属性的方式封装查询出来的数据：

<mapper namespace="com.hh.dao.KeyDao">
    <select id="getKeyById" resultMap="mykey">
         <!--由于t_key和t_lock中都有id,所以需要起别名-->
         SELECT k.id kid, k.`keyname`,k.`lockid`,l.`id` lid,l.`lockname`
         FROM t_key k
         LEFT JOIN t_lock l
         ON k.lockid=l.id
         WHERE k.id=#{id};
    </select>

    <resultMap id="mykey" type="com.hh.bean.Key">
        <id property="id" column="kid"/>
        <result property="keyName" column="keyname"/>
        <result property="lock.id" column="lid"/>
        <result property="lock.lockName" column="lockname"/>
    </resultMap>
</mapper>

测试类：

@Test
public void testSelect(){
	 SqlSession sqlSession = sqlsessionFactory.openSession();
	 KeyDao mapper = sqlSession.getMapper(KeyDao.class);
	 Key keyById = mapper.getKeyById(2);
	 System.out.println(keyById);
	 sqlSession.close();
}

2.2 使用association标签

如果JavaBean中有一个JavaBean对象：就用association
如果JavaBean中有一个集合，就用collection

<mapper namespace="com.hh.dao.KeyDao">
    <select id="getKeyById" resultMap="mykey">
         <!--由于t_key和t_lock中都有id,所以需要起别名-->
         SELECT k.id kid, k.`keyname`,k.`lockid`,l.`id` lid,l.`lockname`
         FROM t_key k
         LEFT JOIN t_lock l
         ON k.lockid=l.id
         WHERE k.id=#{id};
    </select>

    <!--MyBatis推荐的方式封装数据-->
    <resultMap id="mykey" type="com.hh.bean.Key">
        <id property="id" column="kid"/>
        <result property="keyName" column="keyname"/>
        <!--
        接下来的属性是一个对象，
        自定义这个对象的封装规则，使用association表示联合了一个对象
        javaType:指定这个属性的类型
        -->
        <association property="lock" javaType="com.hh.bean.Lock">
            <!--定义lock属性对应的这个Lock对象如何封装-->
            <id property="id" column="lid"/>
            <result property="lockName" column="lockname"/>
        </association>
    </resultMap>
</mapper>

3.ResultMap封装数据（JavaBean中有集合）

场景：站在锁的角度，一个锁有多把钥匙，一对多


现在想查出某把锁以及能开这把锁的钥匙：

多个钥匙是一个集合，所以在Lock类中有一个集合，这个集合里面装Key对象

public class Lock {
    private int id;
    private String lockName;

    //查询锁的时候把所有的钥匙也查出来
    private List<Key> keys;
}

public class Key {
    private int id;
    private String keyName;
    //JavaBean对象
    private Lock lock;
}

查出锁信息并将能开这把锁的所有钥匙查询出来:

public interface LockDao {
    //查出锁信息并将能开这把锁的所有钥匙查询出来
    public Lock getLockById(int id);
}

JavaBean对象中集合使用Collection标签封装数据

<mapper namespace="com.hh.dao.LockDao">
    <select id="getLockById" resultMap="mylock">
        SELECT l.id lid,l.`lockname`,k.`id` kid,k.`keyname`,k.`lockid` FROM t_lock l
        LEFT JOIN t_key k
        ON l.`id`=k.`lockid`
        WHERE l.`id`=3;
    </select>

    <resultMap id="mylock" type="com.hh.bean.Lock">
        <id property="id" column="lid"/>
        <result property="lockName" column="lockname"/>
        <!--
        定义集合元素的封装：
        property:指定哪个属性是集合属性
        ofType:指定集合里面元素的类型
        -->
        <collection property="keys" ofType="com.hh.bean.Key">
            <id property="id" column="kid"/>
            <id property="keyName" column="keyname"/>
        </collection>
    </resultMap>
</mapper>

测试类：

@Test
public void testSelect(){
   SqlSession sqlSession = sqlsessionFactory.openSession();
   LockDao mapper = sqlSession.getMapper(LockDao.class);
   Lock lock = mapper.getLockById(3);
   System.out.println(lock);
   System.out.println("所有的锁如下：");
   List<Key> keys = lock.getKeys();
   for(Key key:keys){
       System.out.println(key);
   }
   sqlSession.close();
}