Mybatis06_多表查询（一对一、一对多、多对多）

本次案例使用简单的用户和账户表来分析mybatis的多表关系。用户为User表，账户为Account表。其中一个用户可以拥有多个账户

一对一（多对一）：

　　场景：查询所有账户信息，关联查询结果中对应的用户信息

　　分析：

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

　　1）方式一：定义Account和User的所需信息封装类

　　　　账户实体类　　

public class Account implements Serializable {
　　private Integer id;
　　private Integer uid;
　　private Double money;
　　 get/set
 　　toString        
}

　　SQL语句编写

SELECT 
 account.*,
 user.username,
 user.address
FROM
 account,
 user
WHERE account.uid = user.id

　　定义封装类AccountUser

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

public class AccountUser extends Account implements Serializable {
　　private String username;
　　private String address;
　　set/get
　　toString
}

　　定义持久层DAO

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

　　定义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.itheima.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>

　　测试类测试

public class AccountTest {
　　private InputStream in ;
　　private SqlSessionFactory factory;
　　private SqlSession session;
　　private IAccountDao accountDao;
　　@Test
　　public 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();
　　}
}

　　2）方式二：使用resultMap，定义专门的User或Account，然后进行一对一映射

　　　　使用：通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户是哪个用户的。

　　　　修改Account类

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;
　　}
　　get/set
　　toString
}

　　　　持久层修改

因为 Account 类中包含了一个 User 类的对象，它可以封装账户所对应的用户信息。
public interface IAccountDao {
    List<Account> findAll();
}

　　　　重新配置AccountDao.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.itheima.dao.IAccountDao">
　　<!-- 建立对应关系 -->
　　<resultMap type="account" id="accountMap">
　　　　<id column="aid" property="id"/>
　　　　<result column="uid" property="uid"/>
　　　　<result column="money" property="money"/>
　　　　<!-- 它是用于指定从表方的引用实体属性的 -->
　　　　<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>

一对多：

　　场景：查询所有用户信息，以及关联的账户信息

　　分析：

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

　　编写SQL

SELECT
　　u.*, acc.id id,
　　acc.uid,
 　　acc.money
FROM
　　user u
LEFT JOIN account acc ON u.id = acc.uid

　　编写User类

public class User implements Serializable {
　　private Integer id;
　　private String username;
　　private Date birthday;
　　private String sex;
　　private String address;
　　private List<Account> accounts;
　　public List<Account> getAccounts() {
　　　　return accounts;
　　}
　　public void setAccounts(List<Account> accounts) {
　　　　this.accounts = accounts;
　　}
　　get/set
　　toString
}

　　持久层

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

　　mapperDao.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.itheima.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.money from user u left outer join account a on u.id =a.uid
　　　　</select>
　　</mapper>
collection
部分定义了用户关联的账户信息。表示关联查询结果集
property="accList"：
关联查询的结果集存储在 User 对象的上哪个属性。
ofType="account"：
指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

　　　　测试

多对多：

　　多对多其实可以看出双向的一对多关系

　　本次案例的关系模型如下

　　场景：查询所有对象，并且加载他的角色信息

　　分析：

　　　　查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中间表(USER_ROLE 表)才能关联到用户信息。

　　SQL的编写

SELECT
 r.*,u.id uid,
 u.username username,
 u.birthday birthday,
 u.sex sex,
 u.address address
FROM 
 ROLE r
INNER JOIN 
 USER_ROLE ur
ON ( r.id = ur.rid)
INNER JOIN
 USER u
ON (ur.uid = u.id);

　　角色实体类

public class Role implements Serializable {
 　　private Integer roleId;
 　　private String roleName;
　　 private String roleDesc;
 　　//多对多的关系映射：一个角色可以赋予多个用户
 　　private List<User> users;
　　 public List<User> getUsers() {
 　　　　return users;
 　　}
 　　public void setUsers(List<User> users) {
 　　　　this.users = users;
　　 }
　　get/set
　　toString
}

　　角色持久层

public interface IRoleDao {
 /**
 * 查询所有角色
 * @return
 */
 List<Role> findAll();
}

　　mapper文件配置

<?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.itheima.dao.IRoleDao">
 <!--定义 role 表的 ResultMap-->
 <resultMap id="roleMap" type="role">
 　　<id property="roleId" column="rid"></id>
 　　<result property="roleName" column="role_name"></result>
 　　<result property="roleDesc" column="role_desc"></result>
 　　<collection property="users" ofType="user">
　　　　 <id column="id" property="id"></id>
 　　　　<result column="username" property="username"></result>
 　　　　<result column="address" property="address"></result>
 　　　　<result column="sex" property="sex"></result>
 　　　　<result column="birthday" property="birthday"></result>
 　　</collection>
 </resultMap>
<!--查询所有-->
 <select id="findAll" resultMap="roleMap">
 　　select u.*,r.id as rid,r.role_name,r.role_desc from role r 
　　 left outer join user_role ur on r.id = ur.rid
 　　left outer join user u on u.id = ur.uid
 </select>
</mapper>