表之间的关系有几种：一对多多对一一对一多对多
举例：用户和订单就是一对多订单和用户就是多对一一个用户可以下多个订单多个订单属于同一个用户人和身份证号就是一对一一个人只能有一个身份证号一个身份证号只能属于一个人老师和学生之间就是多对多一个学生可以被多个老师教过一个老师可以交多个学生
特例：如果拿出每一个订单，他都只能属于一个用户。所以Mybatis就把多对一看成了一对一。

本次案例主要以最为简单的用户和账户的模型来分析Mybatis多表关系。用户为User 表，账户为Account
表。一个用户（User）可以有多个账户（Account）。具体关系如下：

	示例：用户和账户一个用户可以有多个账户一个账户只能属于一个用户（多个账户也可以属于同一个用户）需求: 查询所有账户信息，关联查询下单用户信息。注意：因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。步骤：1、建立两张表：用户表，账户表让用户表和账户表之间具备一对多的关系：需要使用外键在账户表中添加2、建立两个实体类：用户实体类和账户实体类让用户和账户的实体类能体现出来一对多的关系3、建立两个配置文件用户的配置文件账户的配置文件4、实现配置：当我们查询用户时，可以同时得到用户下所包含的账户信息当我们查询账户时，可以同时得到账户的所属用户信息

一对一查询( 多对一)

需求查询所有账户信息，关联查询下单用户信息。
注意：因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。

方式一:使用resultType处理【不推荐】

定义账户信息的 实体类

/*** <p>Title: Account</p>* <p>Description: 账户的实体类</p>*/
public class Account implements Serializable {private Integer id;private Integer uid;private Double money;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public Integer getUid() {return uid;}public void setUid(Integer uid) {this.uid = uid;}public Double getMoney() {return money;}public void setMoney(Double money) {this.money = money;}@Overridepublic String toString() {return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";}
}

编写 Sql 语句

实现查询账户信息时，也要查询账户所对应的用户信息。

SELECTaccount.*,user.username,user.address
FROMaccount,user
WHERE account.uid = user.id+----+------+-------+----------+-----------------+
| ID | UID  | MONEY | username | address         |
+----+------+-------+----------+-----------------+
|  1 |   46 |  1000 | 老王     | 北京            |
|  2 |   45 |  1000 | 张三     | 北京金燕龙      |
|  3 |   46 |  2000 | 老王     | 北京            |
+----+------+-------+----------+-----------------+

定义 AccountUser 类

为了能够封装上面 SQL 语句的查询结果，定义 AccountCustomer 类中要包含账户信息同时还要包含用户信
息，所以我们要在定义 AccountUser 类时可以继承 User 类。

/*** <p>Title: AccountUser</p>* <p>Description: 它是 account 的子类</p>*/
public class AccountUser extends Account {private String username;private String address;public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}@Overridepublic String toString() {return super.toString() + "        AccountUser{" +"username='" + username + '\'' +", address='" + address + '\'' +'}';}
}

定义层 账户的持久层 Dao 接口

/*** <p>Title: IAccountDao</p>* <p>Description: 账户的持久层接口</p>*/
public interface IAccountDao {/*** 查询所有账户，同时获取账户的所属用户名称以及它的地址信息** @return*/List<AccountUser> findAll();
}

定义 IAccountDao.xml 文件中的查询配置信息

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.IAccountDao"><!-- 配置查询所有操作--><select id="findAll" resultType="accountuser">select a.*,u.username,u.address from account a,user u where a.uid =u.id;</select>
</mapper>

注意：因为上面查询的结果中包含了账户信息同时还包含了用户信息，所以我们的返回值类型 returnType
的值设置为 AccountUser 类型，这样就可以接收账户信息和用户信息了。

创建 AccountTest 测试类

/*** <p>Description: 一对多账户的操作</p>*/
public class AccountTest {private InputStream in;private SqlSessionFactory factory;private SqlSession session;private IAccountDao accountDao;@Testpublic void testFindAll() {//6.执行操作List<AccountUser> accountusers = accountDao.findAll();for (AccountUser au : accountusers) {System.out.println(au);}}@Before//在测试方法执行之前执行public void init() throws Exception {//1.读取配置文件in = Resources.getResourceAsStream("SqlMapConfig.xml");//2.创建构建者对象SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();//3.创建 SqlSession 工厂对象factory = builder.build(in);//4.创建 SqlSession 对象session = factory.openSession();//5.创建 Dao 的代理对象accountDao = session.getMapper(IAccountDao.class);}@After//在测试方法执行完成之后执行public void destroy() throws Exception {session.commit();//7.释放资源session.close();in.close();}
}

小结：

定义专门的 po 类作为输出类型，其中定义了 sql 查询结果集所有的字段。此方法较为简单.

方式二:使用resultMap的结果嵌套处理

使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户是哪个用户的。

修改 Account 类

在 Account 类中加入 User 类的对象作为 Account 类的一个属性。

/*** <p>Title: Account</p>* <p>Description: 账户的实体类</p>*/
public class Account implements Serializable {private Integer id;private Integer uid;private Double money;// 代表当前账户从属于哪一个用户private User user;public User getUser() {return user;}public void setUser(User user) {this.user = user;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public Integer getUid() {return uid;}public void setUid(Integer uid) {this.uid = uid;}public Double getMoney() {return money;}public void setMoney(Double money) {this.money = money;}@Overridepublic String toString() {return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";}
}

修改 IAccountDao 接口中的方法

/*** <p>Title: IAccountDao</p>* <p>Description: 账户的持久层接口</p>*/
public interface IAccountDao {/*** 查询所有账户，同时获取账户的所属用户名称以及它的地址信息** @return*/List<Account> findAll();
}

注意：第二种方式，将返回值改 为了 Account 类型。
因为 Account 类中包含了一个 User 类的对象，它可以封装账户所对应的用户信息。

重新定义 IAccountDao.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.IAccountDao"><!-- 建立对应关系 --><resultMap type="account" id="accountMap"><!--手动指定字段与实体属性的映射关系column: 数据表的字段名称property：实体的属性名称--><id column="aid" property="id"/><result column="uid" property="uid"/><result column="money" property="money"/><!-- association:它是用于指定从表方的引用实体属性的property: 当前实体(account)中的属性名称(private User user)javaType: 当前实体(account)中的属性的类型(User)--><association property="user" javaType="user"><id column="id" property="id"/><result column="username" property="username"/><result column="sex" property="sex"/><result column="birthday" property="birthday"/><result column="address" property="address"/></association></resultMap><select id="findAll" resultMap="accountMap">select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid =u.id;</select>
</mapper>

其中 < resultMap > 还可以配置如下：

    <resultMap type="account" id="accountMap"><!--手动指定字段与实体属性的映射关系column: 数据表的字段名称property：实体的属性名称--><id column="aid" property="id"/><id column="id" property="user.id"/><result column="uid" property="uid"/><result column="money" property="money"/><result column="username" property="user.username"/><result column="sex" property="user.sex"/><result column="birthday" property="user.birthday"/><result column="address" property="user.address"/></resultMap>

注意:

在 resultMap 标签中
需要按照
id result association collection
顺序来排列

在 AccountTest 类中加入测试方法

    /*** 测试查询所有*/@Testpublic void testFindAll() {List<Account> accounts = accountDao.findAll();for (Account account : accounts) {System.out.println("--------每个account的信息------------");System.out.println(account);System.out.println(account.getUser());}}

测试结果

一对多查询

需求：
查询所有用户信息及用户关联的账户信息。
分析：
用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，我们想到了左外连接查询比较合适。

编写 SQL 语句

SELECTu.*, acc.id id,acc.uid,acc.money
FROMuser u
LEFT JOIN account acc ON u.id = acc.uid+----+--------------+---------------------+------+-----------------+------+------+-------+
| id | username     | birthday            | sex  | address         | id   | uid  | money |
+----+--------------+---------------------+------+-----------------+------+------+-------+
| 46 | 老王         | 2018-03-07 17:37:26 | 男   | 北京            |    1 |   46 |  1000 |
| 45 | 张三         | 2018-03-04 12:04:06 | 男   | 北京金燕龙      |    2 |   45 |  1000 |
| 46 | 老王         | 2018-03-07 17:37:26 | 男   | 北京            |    3 |   46 |  2000 |
| 41 | 老王         | 2018-02-27 17:47:08 | 男   | 北京            | NULL | NULL |  NULL |
| 42 | 小二王       | 2018-03-02 15:09:37 | 女   | 北京金燕龙      | NULL | NULL |  NULL |
| 43 | 小二王       | 2018-03-04 11:34:34 | 女   | 北京金燕龙      | NULL | NULL |  NULL |
| 48 | 小马宝莉     | 2018-03-08 11:44:00 | 女   | 北京修正        | NULL | NULL |  NULL |
+----+--------------+---------------------+------+-----------------+------+------+-------+

User 类加入 List< Account >

/*** <p>Title: User</p>* <p>Description: 用户的实体类</p>*/
public class User implements Serializable {private Integer id;private String username;private String address;private String sex;private Date birthday;//一对多关系映射：主表实体应该包含从表实体的集合引用// 代表当前用户具备哪些账户private List<Account> accounts;public List<Account> getAccounts() {return accounts;}public void setAccounts(List<Account> accounts) {this.accounts = accounts;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public Date getBirthday() {return birthday;}public void setBirthday(Date birthday) {this.birthday = birthday;}@Overridepublic String toString() {return "User{" +"id=" + id +", username='" + username + '\'' +", address='" + address + '\'' +", sex='" + sex + '\'' +", birthday=" + birthday +'}';}
}

用户持久层 Dao 接口 中加入查询方法

/**
* 查询所有用户，同时获取出每个用户下的所有账户信息
* @return
*/
List<User> findAll();

用户持久层 IUserDao 映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.IUserDao"><resultMap type="user" id="userMap"><id column="id" property="id"></id><result column="username" property="username"/><result column="address" property="address"/><result column="sex" property="sex"/><result column="birthday" property="birthday"/><!-- collection 是用于建立一对多中集合属性的对应关系ofType 用于指定集合元素的数据类型--><collection property="accounts" ofType="account"><id column="aid" property="id"/><result column="uid" property="uid"/><result column="money" property="money"/></collection></resultMap><!-- 配置查询所有操作 --><select id="findAll" resultMap="userMap">select u.*,a.id as aid ,a.uid,a.moneyfrom user uleft outer join account aon u.id =a.uid</select>
</mapper>

collection部分定义了用户关联的账户信息。表示关联查询结果集
property="accList" ：关联查询的结果集存储在 User 对象的上哪个属性。
ofType="account" ：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

测试方法

/*** <p>Title: UserTest</p>* <p>Description: 一对多的操作</p>*/
public class UserTest {private InputStream in;private SqlSessionFactory factory;private SqlSession session;private IUserDao userDao;@Testpublic void testFindAll() {//6.执行操作List<User> users = userDao.findAll();for (User user : users) {System.out.println("-------每个用户的内容---------");System.out.println(user);System.out.println(user.getAccounts());}}@Before//在测试方法执行之前执行public void init() throws Exception {//1.读取配置文件in = Resources.getResourceAsStream("SqlMapConfig.xml");//2.创建构建者对象SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();//3.创建 SqlSession 工厂对象factory = builder.build(in);//4.创建 SqlSession 对象session = factory.openSession();//5.创建 Dao 的代理对象userDao = session.getMapper(IUserDao.class);}@After//在测试方法执行完成之后执行public void destroy() throws Exception {session.commit();//7.释放资源session.close();in.close();}
}

测试结果