mybatis 一對一，一對多，多對多關系映射查詢操作

 定義兩個類（對應數據庫內兩張表） User ,Account，每個Account屬於一個User

User類 及其 對應的IUserDao

package com.itheima.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.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;
    }

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

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

package com.itheima.dao;

import com.itheima.domain.QueryVo;
import com.itheima.domain.User;

import java.util.List;

public interface IUserDao {
    /*
    * 查詢所有操作
    * */
    List<User> findAll();

    /*
    * 保存一條記錄並返回id（直接將id賦給對應的屬性）
    * */
    void saveUser(User user);

    /*
    * 更新用戶
    * */
    void updateUser(User user);

    /*
    * 刪除用戶
    * */
    void deleteUser(Integer userId);

    /*
    * 根據Id查詢User
    * */
    User findById(Integer userId);

    /*
    * 模糊查詢
    * */
    List<User> findByName(String username);

    /*
    * 查詢User總數
    * */
    int findTotal();

    /*
    *  根據queryVo查詢中的條件查詢用戶
    * */
    List<User> findByVo(QueryVo vo);

    /*
    * 根據傳入參數條件查詢
    * @param user 查詢的條件：有可能有用戶名，有可能有性別，也有可能有地址，可能啥都沒有
    * */
    List<User> findUserByCondition(User user);

    /*
    * 根據queryVo中提供的id集合查詢用戶信息
    * */
    List<User> findUserInIds(QueryVo vo);
}

Account類 及其對應的 IAccountDao

package com.itheima.domain;

import java.io.Serializable;

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

package com.itheima.dao;

import com.itheima.domain.Account;
import com.itheima.domain.AccountUser;

import java.util.List;

public interface IAccountDao {

    /*
    * 查詢所有Account
    * */
    List<Account> findAll();

    /*
    * 查詢所有賬戶，並且帶有用戶名和地址
    * */
    List<AccountUser> findAllAccountUser();

}

 

一對一(多對一)的關系查詢：查詢Account時也要查詢出所屬User的信息

顯然每個Account對應了一個User

//從表實體應該包含一個主表實體的對像引用
    private User user;

下面是IAccountDao.xml 對於 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.IAccountDao">

    <!--定義封裝account和user的resultMap-->
    <resultMap id="accountUserMap" type="com.itheima.domain.Account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--一對一關系映射，配置封裝user的內容，column：外鍵，javaType:聯系對象的全限定類名-->
        <association property="user" column="uid" javaType="com.itheima.domain.User">
            <id property="id" column="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>
        </association>
    </resultMap>

    <!--查詢所有Account並獲得對應User信息(多對一標准寫法)-->
    <select id="findAll" resultMap="accountUserMap">
        select u.*, a.id as aid, a.uid, a.money
        from account as a, user as u
        where u.id = a.uid
    </select>

    <!--查詢所有Account，同時包含用戶名和地址信息-->
    <select id="findAllAccountUser" resultType="com.itheima.domain.AccountUser">
        select a.*,u.username,u.address from account as a, user as u
        where a.uid = u.id;
    </select>
    
</mapper>

測試代碼

/*
    * 查詢所有Account並獲得對應User信息(多對一標准寫法)
    * */
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for(Account account:accounts)
            System.out.println(account+account.getUser().toString());
    }

 

一對多的關系查詢：查詢User時查詢所有和其相關的Account集合

類似Account類內聲明一個User的引用，User內也聲明了一個Account類的集合

//一對多關系映射，主表實體應該包含從表實體的集合引用
    private List<Account> accounts;

IUserDao.xml 關於 findAll方法的配置

<resultMap id="userAccountMap" type="com.itheima.domain.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集合的映射,ofTpe:集合中元素的全限定類名-->
        <collection property="accounts" ofType="com.itheima.domain.Account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
        </collection>

    </resultMap>

    <!--配置查詢所有-->
    <select id="findAll" resultMap="userAccountMap">
        select * from user as u left outer join account as a
        on u.id = a.uid
    </select>

測試方法

@Test
    public void testFindAll()throws Exception{
        //5.使用代理對象執行方法
        List<User>users = userDao.findAll();
        for(User user:users) {
            System.out.println("---------每個用戶的信息----------");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }

 

多對多關系的查詢：User和Role之間多對多

首先定義Role實體類(數據庫里還要一張user_role的對應關系表)

Role類及其Dao接口IRoleDao

package com.itheima.domain;

import java.io.Serializable;
import java.util.List;

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

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

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

package com.itheima.dao;

import com.itheima.domain.Role;

import java.util.List;

public interface IRoleDao {

    /*
    * 查詢所有角色
    * */
    List<Role> findAll();
}

 

查詢User以及和其相關的所有roles

首先User類中要有Role的一個集合

//多對多的關系映射：一個用戶可以具備多個角色
    private List<Role> roles;

IUserDao.xml里的配置實現

<!--定義User多對多查詢roles的resultMap-->
    <resultMap id="userRolesMap" type="com.itheima.domain.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 property="roles" ofType="com.itheima.domain.Role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
        </collection>
    </resultMap>

    <!--配置查詢所有-->
    <select id="findAll" resultMap="userRolesMap">
        select u.*,r.id as rid,r.role_name,r.role_desc from user as u
        left outer join user_role as ur on u.id = ur.uid
        left outer join role as r on r.id = ur.rid
    </select>

測試代碼

@Test
    public void testFindAll()throws Exception{
        //5.使用代理對象執行方法
        List<User>users = userDao.findAll();
        for(User user:users) {
            System.out.println("---------每個用戶的信息----------");
            System.out.println(user);
            System.out.println(user.getRoles());
        }
    }

 

查詢Role以及和其相關的所有User類

首先Role里要有一個User類的集合

//多對多的關系映射：一個角色可以賦予多個用戶
    private List<User> users;

IRoleDao.xml 配置實現

<!--定義role表的resultMap-->
    <resultMap id="roleMap" type="com.itheima.domain.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="com.itheima.domain.User">
            <id column="id" property="id"></id>
            <result column="birthday" property="birthday"></result>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
        </collection>
    </resultMap>

    
    <!--查詢所有-->
    <select id="findAll" resultMap="roleMap">
        select u.*, r.id as rid, r.role_name, r.role_desc from role as r
        left outer join user_role as ur on r.id = ur.rid
        left outer join user u on u.id = ur.uid 
    </select>

測試代碼

@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());
        }
    }