MyBatis 的多表操作：一对一、一对多、多对多

一对一：一个订单只能属于一个人

一对多：一个人可以有多个订单

多对多：一个人可以有多个角色，但这些角色也可以被其他人拥有

---

文章有点长，认真看，慢慢理解就可以看懂

---

这篇文章介绍 配置文件 方式 和 注解 方式

---

=== 使用 配置文件 方式 ===

一对一：一个订单只能属于一个人

order 表结构：

user 表结构：

 

1、首先根据数据库中的 order 表创建 order 的实体类，并在order的实体类中添加一个 user 字段

package cn.henu.domain;

import java.util.Date;

public class Order {
    private int id;
    private Date ordertime;
    private double total;

    //当前订单属于哪一个用户
    private User user;

    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", ordertime=" + ordertime +
                ", total=" + total +
                ", user=" + user +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Date getOrdertime() {
        return ordertime;
    }

    public void setOrdertime(Date ordertime) {
        this.ordertime = ordertime;
    }

    public double getTotal() {
        return total;
    }

    public void setTotal(double total) {
        this.total = total;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

2、在持久层添加一个查询全部的方法 findAll()

package cn.henu.mapper;

import cn.henu.domain.Order;

import java.util.List;

public interface OrderMapper {
    //查询全部的方法
    public List<Order> findAll();
}

3、编写映射文件

<?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="cn.henu.mapper.OrderMapper">

    <resultMap id="orderMap" type="order">
        <!--手动指定字段与实体属性的映射关系
            colum：数据表的字段名称
            property：实体的属性名称 -->
        <id column="oid" property="id"></id>
        <result column="ordertime" property="ordertime"></result>
        <result column="total" property="total"></result>

        <result column="uid" property="user.id"></result>
        <result column="username" property="user.username"></result>
        <result column="password" property="user.password"></result>
        <result column="birthday" property="user.birthday"></result>

    </resultMap>

    <select id="findAll" resultMap="orderMap">
        select *,o.id oid from orders o,user u where o.uid = u.id
    </select>
</mapper>

4、映射文件中各个部分的对应关系（有点乱，但是认真看一定能看懂）

 3-1、第二种映射文件的编写 

<?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="cn.henu.mapper.OrderMapper">

    <resultMap id="orderMap" type="order">
        <!--手动指定字段与实体属性的映射关系
            colum：数据表的字段名称
            property：实体的属性名称 -->
        <id column="oid" property="id"></id>
        <result column="ordertime" property="ordertime"></result>
        <result column="total" property="total"></result>
        <!--<result column="uid" property="user.id"></result>
        <result column="username" property="user.username"></result>
        <result column="password" property="user.password"></result>
        <result column="birthday" property="user.birthday"></result>-->

        <!--property:当前实体（order）中的属性名称（private User user）
            javaType:当前实体（order）中的属性（private User user）的类型-->
        <association property="user" javaType="user">
            <id column="uid" property="id"></id>
            <result column="username" property="username"></result>
            <result column="password" property="password"></result>
            <result column="birthday" property="birthday"></result>
        </association>
    </resultMap>

    <select id="findAll" resultMap="orderMap">
        select *,o.id oid from orders o,user u where o.uid = u.id
    </select>
</mapper>

4-1、映射文件中各个部分的对应关系

5、编写测试类

package cn.henu.test;

import cn.henu.domain.Order;
import cn.henu.domain.User;
import cn.henu.mapper.OrderMapper;
import cn.henu.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    //测试一对一（order表中的一条数据对应于user表中的一条数据，即一个订单只能属于一个人的）
    @Test
    public void test() 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<Order> orderList = mapper.findAll();
        for (Order order : orderList) {
            System.out.println(order);
        }

        sqlSession.commit();
        sqlSession.close();
    }
}

运行结果：
Order{id=1, ordertime=Fri Feb 15 14:59:37 CST 2019, total=3000.0, user=User{id=1, username='zhangsan', password='123', birthday=null, roleList=null}}
Order{id=2, ordertime=Wed Oct 10 15:00:00 CST 2018, total=5800.0, user=User{id=1, username='zhangsan', password='123', birthday=null, roleList=null}}
Order{id=3, ordertime=Thu Feb 28 15:00:14 CST 2019, total=323.0, user=User{id=2, username='lisi', password='123', birthday=null, roleList=null}}
Order{id=4, ordertime=Thu Feb 21 15:00:25 CST 2019, total=2345.0, user=User{id=1, username='zhangsan', password='123', birthday=null, roleList=null}}
Order{id=5, ordertime=Mon Feb 04 15:00:37 CST 2019, total=100.0, user=User{id=2, username='lisi', password='123', birthday=null, roleList=null}}
Order{id=6, ordertime=Thu Jun 07 15:00:52 CST 2018, total=2009.0, user=User{id=3, username='wangwu', password='123', birthday=null, roleList=null}}

 一对多：一个人可以有多个订单

order 表结构：

user 表结构：

 

1、首先根据数据库中的 user 表创建 user 的实体类，并在 user 的实体类中添加一个 order 字段

package cn.henu.domain;

import java.util.Date;
import java.util.List;

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday;

    //描述的是当前用户存在哪些订单
    private List<Order> orderList;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", birthday=" + birthday +
                ", orderList=" + orderList +
                '}';
    }

    public List<Order> getOrderList() {
        return orderList;
    }

    public void setOrderList(List<Order> orderList) {
        this.orderList = orderList;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

2、在持久层添加一个查询全部的方法 findAll()

package cn.henu.mapper;

import cn.henu.domain.User;

import java.util.List;

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

3、编写映射文件

<?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="cn.henu.mapper.UserMapper">

    <resultMap id="userMap" type="user">
        <id column="uid" property="id"></id>
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="birthday" property="birthday"></result>
        <!--配置集合信息
        property:集合名称
        ofType:当前集合中的数据类型-->
        <collection property="orderList" ofType="order">
            <!--封装order的数据-->
            <id column="oid" property="id"></id>
            <result column="ordertime" property="ordertime"></result>
            <result column="total" property="total"></result>
        </collection>
    </resultMap>

    <select id="findAll" resultMap="userMap">
        select *,o.id oid from user u,orders o where u.id = o.uid
    </select>
</mapper>

4、映射文件中各个部分的对应关系

5、编写测试类

package cn.henu.test;

import cn.henu.domain.Order;
import cn.henu.domain.User;
import cn.henu.mapper.OrderMapper;
import cn.henu.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    //测试一对多（user表中的一个数据对应order表中的多条数据，即一个人可以有多条对应的订单）
    @Test
    public void test() 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> userList = mapper.findAll();
        for (User user : userList) {
            System.out.println(user);
        }

        sqlSession.commit();
        sqlSession.close();
    }
}

运行结果：
User{id=1, username='zhangsan', password='123', birthday=null, orderList=[Order{id=1, ordertime=Fri Feb 15 14:59:37 CST 2019, total=3000.0, user=null}, Order{id=2, ordertime=Wed Oct 10 15:00:00 CST 2018, total=5800.0, user=null}, Order{id=4, ordertime=Thu Feb 21 15:00:25 CST 2019, total=2345.0, user=null}]}
User{id=2, username='lisi', password='123', birthday=null, orderList=[Order{id=3, ordertime=Thu Feb 28 15:00:14 CST 2019, total=323.0, user=null}, Order{id=5, ordertime=Mon Feb 04 15:00:37 CST 2019, total=100.0, user=null}]}
User{id=3, username='wangwu', password='123', birthday=null, orderList=[Order{id=6, ordertime=Thu Jun 07 15:00:52 CST 2018, total=2009.0, user=null}]}

多对多：一个人可以有多个角色，但这些角色也可以被其他人拥有

sys_role 表结构：

sys_user_role 表结构（中间表）： 

user 表结构：

 

1、首先根据数据库中的 user 表创建 user 的实体类，并在 user 的实体类中添加一个 role 字段

package cn.henu.domain;

import java.util.Date;
import java.util.List;

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday;

    //描述的是当前用户具备哪些角色
    private List<Role> roleList;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", birthday=" + birthday +
                ", roleList=" + roleList +
                '}';
    }

    public List<Role> getRoleList() {
        return roleList;
    }

    public void setRoleList(List<Role> roleList) {
        this.roleList = roleList;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

2、在持久层添加一个查询全部的方法 findAll()

package cn.henu.mapper;

import cn.henu.domain.User;

import java.util.List;

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

3、编写映射文件

<?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="cn.henu.mapper.UserMapper">
    <resultMap id="userRoleMap" type="user">
        <!--封装user的信息-->
        <id column="userId" property="id"></id>
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="birthday" property="birthday"></result>
        <!--封装user内部的roleList的信息-->
        <collection property="roleList" ofType="role">
            <id column="roleId" property="id"></id>
            <result column="roleName" property="roleName"></result>
            <result column="roleDesc" property="roleDesc"></result>
        </collection>
    </resultMap>
    <select id="findUserAndRoleAll" resultMap="userRoleMap">
        SELECT * FROM user u,sys_user_role ur,sys_role r where u.id = ur.userId and ur.roleId = r.id
    </select>
</mapper>

4、编写测试类

package cn.henu.test;

import cn.henu.domain.Order;
import cn.henu.domain.User;
import cn.henu.mapper.OrderMapper;
import cn.henu.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    //测试多对多（user表中的一个数据对应role表中的多条数据，即一个人可以有多个职位，这些职位也可以被其他人所拥有）
    @Test
    public void test() 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> userAndRoleAll = mapper.findUserAndRoleAll();
        for (User user : userAndRoleAll) {
            System.out.println(user);
        }

        sqlSession.commit();
        sqlSession.close();
    }
}

运行结果：
User{id=1, username='zhangsan', password='123', birthday=null, roleList=[Role{id=1, roleName='院长', roleDesc='负责全面工作'}, Role{id=2, roleName='研究员', roleDesc='课程研发工作'}]}
User{id=2, username='lisi', password='123', birthday=null, roleList=[Role{id=2, roleName='研究员', roleDesc='课程研发工作'}, Role{id=3, roleName='讲师', roleDesc='授课工作'}]}

总结：

MyBatis 多表配置方式：

一对一配置：使用<resultMap>做配置

一对多配置：使用<resultMap>+<collection>做配置

多对多配置：使用<resultMap>+<collection>做配置

---

虽然注解开发方式在以后的应用中占大多数，但是先学会上面的配置文件开发方式之后再来学习注解开发方式会容易得多。所以一定要认真看完上面使用配置文件的方式！！！

---

=== 使用 注解 方式 === 

### 认真看完上面的，这部分一看就懂 ###

一对一：一个订单只能属于一个人

1、使用注解的方式将SQL语句写持久层的方法上 findAll()

package cn.henu.mapper;

import cn.henu.domain.Order;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface OrderMapper {
    @Select("select *,o.id oid from orders o,user u where o.uid = u.id")
    @Results({
            @Result(column = "oid",property = "id"),
            @Result(column = "ordertime",property = "ordertime"),
            @Result(column = "total",property = "total"),

            @Result(column = "uid",property = "user.id"),
            @Result(column = "username",property = "user.username"),
            @Result(column = "password",property = "user.password"),
            @Result(column = "birthday",property = "user.birthday")
    })
    //查询全部的方法
    public List<Order> findAll();
}

1-1、第二种编写方式

1-1-1、先在 UserMapper.java 中编写一个 findById() 方法

package cn.henu.mapper;

import cn.henu.domain.User;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface UserMapper {
    //根据id查询
    @Select("select * from user where id = #{id}")
    public User findById(int id);
}

1-1-2、 使用注解的方式将SQL语句写持久层的方法上 findAll()（引用 UserMapper.java 中的 findById() 方法）

package cn.henu.mapper;

import cn.henu.domain.Order;
import cn.henu.domain.User;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface OrderMapper {
    @Select("select * from orders")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "ordertime",property = "ordertime"),
            @Result(column = "total",property = "total"),

            @Result(
                    property = "user",//要封装的属性名称
                    column = "uid",//根据order表的哪个字段去查询user表的数据
                    javaType = User.class,//要封装的实体类型
                    //one = @One 表示一对一查询
                    //select属性 表示查询哪个接口的方法获得数据
                    one = @One(select = "cn.henu.mapper.UserMapper.findById")
            )
    })
    //查询全部的方法
    public List<Order> findAll();
}

2、删除映射文件 OrderMapper.xml 文件（映射文件 OrderMapper.xml 已经没用了）

3、修改 Spring 核心配置文件（不用加载映射文件了，只需要加载映射关系）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--通过properties标签加载外部的properties文件-->
    <properties resource="jdbc.properties"></properties>
    <!--自定义别名-->
    <typeAliases>
        <typeAlias type="cn.henu.domain.User" alias="user"></typeAlias>
    </typeAliases>

    <!--配置数据源环境-->
    <environments default="developement">
        <environment id="developement">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--使用注解，加载下面的映射关系-->
    <mappers>
        <!--指定接口所在的包-->
        <package name="cn.henu.mapper"></package>
    </mappers>

</configuration>

4、编写一个测试类

package cn.henu.test;

import cn.henu.domain.Order;
import cn.henu.mapper.OrderMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest2 {
    private OrderMapper mapper;
    @Before
    public void before() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        mapper = sqlSession.getMapper(OrderMapper.class);
    }

    @Test
    public void testSave(){
        List<Order> all = mapper.findAll();
        for (Order order : all) {
            System.out.println(order);
        }
    }
}
运行结果：
Order{id=1, ordertime=Fri Feb 15 14:59:37 CST 2019, total=3000.0, user=User{id=1, username='zhangsan', password='123', birthday=null}}
Order{id=2, ordertime=Wed Oct 10 15:00:00 CST 2018, total=5800.0, user=User{id=1, username='zhangsan', password='123', birthday=null}}
Order{id=3, ordertime=Thu Feb 28 15:00:14 CST 2019, total=323.0, user=User{id=2, username='lisi', password='123', birthday=null}}
Order{id=4, ordertime=Thu Feb 21 15:00:25 CST 2019, total=2345.0, user=User{id=1, username='zhangsan', password='123', birthday=null}}
Order{id=5, ordertime=Mon Feb 04 15:00:37 CST 2019, total=100.0, user=User{id=2, username='lisi', password='123', birthday=null}}
Order{id=6, ordertime=Thu Jun 07 15:00:52 CST 2018, total=2009.0, user=User{id=3, username='wangwu', password='123', birthday=null}}

一对多：一个人可以有多个订单

1、在 OrderMapper.java 中编写一个 findByUid(int uid) 方法

2、为了和上面使用配置文件时查询一对多的 findAll() 方法相区分，在 UserMapper.java 中另外定义一个方法 findUserAndOrderAll() 

package cn.henu.mapper;

import cn.henu.domain.User;
import org.apache.ibatis.annotations.*;
import java.util.List;

public interface UserMapper {
    @Select("select * from user")
    @Results({
            //id = true 代表这个@Result注解就是@Id注解（也可以省略不写）
            @Result(id = true,column = "id",property = "id"),
            @Result(column = "username",property = "username"),
            @Result(column = "password",property = "password"),
            @Result(
                    property = "orderList",//要封装的属性名称
                    column = "id",//根据user表的哪个字段去查询order表的数据
                    javaType = List.class,//要封装的实体类型
                    //many = @Many 表示一对多查询
                    //select属性 表示查询哪个接口的方法获得数据
                    many = @Many(select = "cn.henu.mapper.OrderMapper.findByUid")
            )
    })
    public List<User> findUserAndOrderAll();
}

3、也要删除映射文件 UserMapper.xml 文件（映射文件 UserMapper.xml 已经没用了）

4、修改 Spring 核心配置文件（不用加载映射文件了，只需要加载映射关系。上面修改过就不用修改了）

5、编写一个测试类

package cn.henu.test;

import cn.henu.domain.Order;
import cn.henu.domain.User;
import cn.henu.mapper.OrderMapper;
import cn.henu.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest3 {
    private UserMapper mapper;
    @Before
    public void before() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        mapper = sqlSession.getMapper(UserMapper.class);
    }

    @Test
    public void testSave(){
        List<User> all = mapper.findUserAndOrderAll();
        for (User user : all) {
            System.out.println(user);
        }
    }
}

运行结果：
User{id=1, username='zhangsan', password='123', birthday=null, orderList=[Order{id=1, ordertime=Fri Feb 15 14:59:37 CST 2019, total=3000.0, user=null}, Order{id=2, ordertime=Wed Oct 10 15:00:00 CST 2018, total=5800.0, user=null}, Order{id=4, ordertime=Thu Feb 21 15:00:25 CST 2019, total=2345.0, user=null}]}
User{id=2, username='lisi', password='123', birthday=null, orderList=[Order{id=3, ordertime=Thu Feb 28 15:00:14 CST 2019, total=323.0, user=null}, Order{id=5, ordertime=Mon Feb 04 15:00:37 CST 2019, total=100.0, user=null}]}
User{id=3, username='wangwu', password='123', birthday=null, orderList=[Order{id=6, ordertime=Thu Jun 07 15:00:52 CST 2018, total=2009.0, user=null}]}
User{id=4, username='zhaoliu', password='123', birthday=null, orderList=[]}
User{id=5, username='tianqi', password='123', birthday=null, orderList=[]}
User{id=6, username='xiaoming', password='123', birthday=null, orderList=[]}
User{id=7, username='wangba', password='123', birthday=null, orderList=[]}

多对多：一个人可以有多个角色，但这些角色也可以被其他人拥有

1、首先创建一个名为 RoleMapper.java 的持久层文件，里面写 findByUid(int uid) 方法

package cn.henu.mapper;

import cn.henu.domain.Role;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface RoleMapper {
    @Select("select * from sys_user_role ur,sys_role r where ur.roleId = r.id and ur.userId = #{uid}")
    public List<Role> findByUid(int uid);
}

2、在 UserMapper.java 中的方法 findUserAndOrderAll() 上直接使用注解的方式写SQL语句

package cn.henu.mapper;

import cn.henu.domain.User;
import org.apache.ibatis.annotations.*;
import java.util.List;

public interface UserMapper {
    @Select("select * from user")
    @Results({
            @Result(id = true,column = "id",property = "id"),
            @Result(column = "username",property = "username"),
            @Result(column = "password",property = "password"),
            @Result(column = "birthday",property = "birthday"),
            @Result(
                    property = "roleList",//要封装的属性名称
                    column = "id",//根据user表的哪个字段去查询role表的数据
                    javaType = List.class,//要封装的实体类型
                    //many = @Many 表示多对多查询
                    //select属性 表示查询哪个接口的方法获得数据
                    many = @Many(select = "cn.henu.mapper.RoleMapper.findByUid")
            )
    })
    public List<User> findUserAndRoleAll();
}

3、编写一个测试类

package cn.henu.test;

import cn.henu.domain.User;
import cn.henu.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest4 {
    private UserMapper mapper;
    @Before
    public void before() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        mapper = sqlSession.getMapper(UserMapper.class);
    }

    @Test
    public void testSave(){
        List<User> all = mapper.findUserAndRoleAll();
        for (User user : all) {
            System.out.println(user);
        }
    }
}
运行结果：
User{id=1, username='zhangsan', password='123', birthday=null, roleList=[Role{id=1, roleName='院长', roleDesc='负责全面工作'}, Role{id=2, roleName='研究员', roleDesc='课程研发工作'}]}
User{id=2, username='lisi', password='123', birthday=null, roleList=[Role{id=2, roleName='研究员', roleDesc='课程研发工作'}, Role{id=3, roleName='讲师', roleDesc='授课工作'}]}
User{id=3, username='wangwu', password='123', birthday=null, roleList=[]}
User{id=4, username='zhaoliu', password='123', birthday=null, roleList=[]}
User{id=5, username='tianqi', password='123', birthday=null, roleList=[]}
User{id=6, username='xiaoming', password='123', birthday=null, roleList=[]}
User{id=7, username='wangba', password='123', birthday=null, roleList=[]}