Mybatis多表查询

一对一查询( 多对一)

本文章参考于：https://www.bilibili.com/video/BV1tf4y1U7pi?p=1
用户为User 表，账户为Account表。一个用户（User）可以有多个账户（Account）

需求：查询所有账户信息，关联查询下单用户信息。

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

步骤：
使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
通过面向对象的(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;
	}

	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;
	}

	@Override
	public String toString() {
		return "Account{" +
				"id=" + id +
				", uid=" + uid +
				", money=" + money +
				'}';
	}
}

二、AccountDao 接口中的方法

public interface IAccountDao  {
	//方式二：使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
	List<Account> findAll();
	
	//方式一：定义专门的 po 类作为输出类型，其中定义了 sql 查询结果集所有的字段。
	//查询所有账户，并且带有用户名和地址信息
	List<AccountUser> findAllAccount();
}

三、重新定义 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">
    <!--配置查询所有-->
    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--一对一的关系映射：配置封装user的内容-->
        <!-- 它是用于指定从表方的引用实体属性的 -->
        <association property="user" column="uid" javaType="user">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
        </association>
    </resultMap>
    <!--方式二-->
    <select id="findAll" resultMap="accountUserMap">
       select u.*,a.id as aid, a.uid,a.money from account a,user u where u.id=a.uid;
    </select>

    <!--方式一-->
    <!--查询所有账户，并且带有用户名和地址信息-->
    <select id="findAllAccount" resultType="accountuser">
        select a.*, u.username, u.address from account a,user u where u.id=a.uid;
    </select>
</mapper>

四、在 在 AccountTest 类中加入测试方法

@Test
	public void testFindAll(){
		List<Account> accounts = accountDao.findAll();
		for(Account account:accounts){
			System.out.println("-------------每个account的信息-----------------");
			System.out.println(account);
			System.out.println(account.getUser());
		}
	}

一对多查询

需求：查询所有用户信息及用户关联的账户信息。

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

步骤：

一、User 类 类入 加入 List

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;
	}

	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 Date getBirthday() {
		return birthday;
	}

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

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

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

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

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

三、用户持久层 Dao 映射文件 配置

<?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">
    <!--配置查询所有-->
    <!--定义User的resultMap-->
    <resultMap id="userAccountMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="address" column="address"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
        <!--配置user对象中accounts集合的映射-->
        <!-- collection 是用于建立一对多中集合属性的对应关系
             ofType 用于指定集合元素的数据类型-->
        <!-- property="accounts" ：关联查询的结果集存储在 User 对象的上哪个属性。
             ofType="account" ：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名-->
        <collection property="accounts" ofType="account">
            <id column="aid" property="id"></id>
            <result column="uid" property="uid"></result>
            <result column="money" property="money"></result>
        </collection>
    </resultMap>
    <select id="findAll" resultMap="userAccountMap">
        select * from user u left outer join account a on u.id=a.uid
    </select>
</mapper>

四、测试方法

public class UserTest {

	private InputStream in;
	private SqlSession sqlSession;
	private IUserDao userDao;

	@Before
	public void init() throws IOException {
		//1、读取配置文件
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2、创建SqlSessionFaction工厂
		SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
		SqlSessionFactory factory = builder. build(in);
		//3、使用工厂生产SqlSession对象
		sqlSession = factory.openSession();
		//4、使用SqlSession创建Dao接口的代理对象
		userDao = sqlSession.getMapper(IUserDao.class);
	}
	@After
	public void destroy() throws Exception {
		sqlSession.commit();
		sqlSession.close();;
		in.close();
		//提交事务

	}
	@Test
	public void testFindAll(){
		List<User> users = userDao.findAll();
		for(User user : users){
			System.out.println("--------每个用户的信息-------");
			System.out.println(user);
			System.out.println(user.getAccounts());
		}
	}
}

多表查询之多对多

多对多关系其实我们看成是双向的一对多关系。

用户与角色的关系模型

实现 Role 到 User 多对多
需求：实现查询所有对象并且加载它所分配的用户信息。

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

**步骤：

一、 编写角色实体类**

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;
	}

	public Integer getRoleId() {
		return roleId;
	}

	public void setRoleId(Integer roleId) {
		this.roleId = roleId;
	}

	public String getRoleName() {
		return roleName;
	}

	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}

	public String getRoleDesc() {
		return roleDesc;
	}

	public void setRoleDesc(String roleDesc) {
		this.roleDesc = roleDesc;
	}

	@Override
	public String toString() {
		return "Role{" +
				"roleId=" + roleId +
				", roleName='" + roleName + '\'' +
				", roleDesc='" + roleDesc + '\'' +
				'}';
	}
}

二、编写 Role 持久层

public interface IRoleDao {

	List<Role> findAll();
}

三、 编写映射文件

<?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 property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="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>

四、编写测试类

public class RoleTest {

	private InputStream in;
	private SqlSession sqlSession;
	private IRoleDao roleDao;

	@Before
	public void init() throws IOException {
		//1、读取配置文件
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2、创建SqlSessionFaction工厂
		SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
		SqlSessionFactory factory = builder. build(in);
		//3、使用工厂生产SqlSession对象
		sqlSession = factory.openSession();
		//4、使用SqlSession创建Dao接口的代理对象
		roleDao = sqlSession.getMapper(IRoleDao.class);
	}
	@After
	public void destroy() throws Exception {
		sqlSession.commit();
		sqlSession.close();;
		in.close();
		//提交事务

	}
	@Test
	public void testFindAll(){
		List<Role> roles = roleDao.findAll();
		for(Role role : roles){
			System.out.println("--------每个角色的信息-------");
			System.out.println(role);
			System.out.println(role.getUsers());
		}
	}
}

多对多与一对多区别不大，主要在于多对多需要中间表把两个表联系起来，而一对多不需要。