一对一和一对多的关联查询（该实体类中存在实体类属性和实体类集合属性，将关联的实体类详细信息查询出来，但没有查询所有该实体类信息）

一.高级查询

高级查询主要是一对一查询,一对多查询,多对多查询

1.一对一查询

有用户和订单两个表,用户对订单是1对1查询.也就是订单中有一个外键是指向用户的. 
先创建实体类: 
User.java

public class User {
    private int id;
    private String username;
    private String password;
    private String nickname;
    private int status;
//省略get和set方法
}
 
 
1
2
3
4
5
6
7
8

Orders.java

public class Orders {
    private int id;
    private Date buy_date;
    private Date pay_date;
    private Date confirm_date;
    private int status;
    private int user_id;//外键,指向用户
//省略get和set方法
}
 
 
1
2
3
4
5
6
7
8
9

1.使用resultType

这种方式映射的话,我们需要一个pojo的包装类,在包装类里面增加我们要关联的属性,这里增加用户名和昵称,把要关联的属性聚集在一起.具体如下, 
OrdersCustorm.java

public class OrdersCustorm extends Orders {
    private String username;
    private String nickname;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

接下来SQL语句就可以使用内连接查询.不过返回的类型是写好的pojo包装类,这样的方法使用起来省事

<?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="orders">
    <select id="findOrderAndUser" parameterType="int" resultType="com.aust.model.OrdersCustorm">
      SELECT t_orders.*,user.username,user.nickname 
      FROM t_orders,user 
      WHERE user_id = user.id AND user_id=#{id}
    </select>

</mapper>
 
 
1
2
3
4
5
6
7
8
9
10
11

junit测试

    @Before
    public void init(){
        InputStream is = null;
        try {
            is = Resources.getResourceAsStream("SqlMapperConfig.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        factory = new SqlSessionFactoryBuilder().build(is);
    }

    //测试取出单个
    @Test
    public void findOrderAndUserTest(){
        //获取sqlsession
        SqlSession session = factory.openSession();
        OrdersCustorm custorm = session.selectOne("orders.findOrderAndUser",18);
        session.close();
        System.out.println(custorm.toString());
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

测试结果 

---

2.使用resultMap

使用resultMap的话,就需要在Orders里面定义一个User属性,用于关联查询,具体如下: 
Orders.java

public class Orders {
    private int id;
    private Date buy_date;
    private Date pay_date;
    private Date confirm_date;
    private int status;
    private int user_id;//外键,指向用户
    private User user;//用于关联查询
    }
 
 
1
2
3
4
5
6
7
8
9

然后定义resultMap

autoMapping=”true”这个是打开自动映射,不然只会映射你配置的那些属性 
association property=”user” javaType=”com.aust.model.User”这句话就是关联到属性user,也就是在Orders里面新增加的关联变量,映射类型为com.aust.model.User这个类.

    <resultMap id="OrderAndUserMap" type="com.aust.model.Orders" autoMapping="true">
        <id column="id" property="id"/>
        <association property="user" javaType="com.aust.model.User">
            <id column="user_id" property="id"/>
            <result column="username" property="username"/>
            <result column="nickname" property="nickname"/>
        </association>
    </resultMap>
 
 
1
2
3
4
5
6
7
8

junit测试

@Before
    public void init(){
        InputStream is = null;
        try {
            is = Resources.getResourceAsStream("SqlMapperConfig.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        factory = new SqlSessionFactoryBuilder().build(is);
    }

    //测试取出单个
    @Test
    public void findOrderAndUserTest(){
        //获取sqlsession
        SqlSession session = factory.openSession();
        Orders orders = session.selectOne("orders.findOrderAndUserMap",18);
        session.close();
        System.out.println(orders.toString());
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

---

2.一对多查询

现在的需求是查询用户和地址,一个用户对应多个地址.一对多查询只能使用resultMap了,不然会出现很多重复数据.使用前,需要修改User实体类,增加一个集合存储多条地址信息 
User.java

public class User {
    private int id;
    private String username;
    private String password;
    private String nickname;
    private int status;
    private List<Adress> adresses;//用于存储用户的多个地址信息
    }
 
 
1
2
3
4
5
6
7
8

然后定义resultMap 
collection property=”adresses” ofType=”com.aust.model.Adress”: 
collection标签用于映射到一个集合的信息,property要映射的属性,也就是user里面的List adresses,ofType要映射到集合里面的pojo类型,这里是com.aust.model.Adress

<resultMap id="userMap" type="com.aust.model.User" autoMapping="true">
        <id column="userid" property="id"/>
        <collection property="adresses" ofType="com.aust.model.Adress" autoMapping="true">
            <id column="id" property="id"/>
        </collection>
    </resultMap>
 
 
1
2
3
4
5
6

接着写sql语句,仍然使用内连接

    <select id="findUserAndAddress" parameterType="int" resultMap="userMap">
      SELECT user.id userid,user.username,user.nickname,t_address.* 
      from user,t_address 
      WHERE t_address.user_id = user.id AND user.id=#{id};
    </select>
 
 
1
2
3
4
5

junit测试

@Before
    public void init(){
        InputStream is = null;
        try {
            is = Resources.getResourceAsStream("SqlMapperConfig.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        factory = new SqlSessionFactoryBuilder().build(is);
    }


    @Test
    public void findAddressAndUserTest(){
        //获取sqlsession
        SqlSession session = factory.openSession();
        User user = session.selectOne("UserMapper.findUserAndAddress",18);
        session.close();
        System.out.println(user.toString());
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

测试结果,成功取出多条地址信息 

---

3.多对多查询

手头上没有很好的例子,所以也就直接说说思路.通过上面的1对1和1对n两个可以看出,n对n无非就是collection,association的嵌套使用,每一个collection,association实际上就相当于一个局部的resultMap,只要明白这一点的话,多对多实现是也就很简单了.

4.总结

resultType： 
作用： 
将查询结果按照sql列名pojo属性名一致性映射到pojo中。 
场合： 
常见一些明细记录的展示，比如用户购买商品明细，将关联查询信息全部展示在页面时，此时可直接使用resultType将每一条记录映射到pojo中，在前端页面遍历list（list中是pojo）即可。

resultMap： 
使用association和collection完成一对一和一对多高级映射（对结果有特殊的映射要求）。

association： 
作用： 
将关联查询信息映射到一个pojo对象中。 
场合： 
为了方便查询关联信息可以使用association将关联订单信息映射为用户对象的pojo属性中，比如：查询订单及关联用户信息。 
使用resultType无法将查询结果映射到pojo对象的pojo属性中，根据对结果集查询遍历的需要选择使用resultType还是resultMap。

collection： 
作用： 
将关联查询信息映射到一个list集合中。 
场合： 
为了方便查询遍历关联信息可以使用collection将关联信息映射到list集合中，比如：查询用户权限范围模块及模块下的菜单，可使用collection将模块映射到模块list中，将菜单列表映射到模块对象的菜单list属性中，这样的作的目的也是方便对查询结果集进行遍历查询。 
如果使用resultType无法将查询结果映射到list集合中。

---

5.补充例子(javaType和ofType)

最近做到一个联合查询,用户登录后要把其完成的题目一起查询出来,只需要查询题目的id,也就是映射出private List<Integer> pro_ac;这样的形式,

对应的映射就如下,利用javaType来映射,而不是ofType

<resultMap id="userMap" type="com.aust.model.CumUser" autoMapping="true">
        <id column="id" property="id"/>
        <collection property="pro_ac" javaType="java.util.List"  ofType="java.lang.Integer" autoMapping="true">
            <id column="pro_id" javaType="java.lang.Integer"/>
        </collection>
    </resultMap>
 
 
1
2
3
4
5
6

ofType 是对象的所属类型 javaType ：collection 的类型

如:

<collection property="questions" ofType="map" javaType="list">
 
 
1

对应的java 形态为 ：List<Map<String,Object>>