Mybatis框架（9） —— 实现多表查询操作

其他 2020-02-16 11:25:52 阅读次数: 0

简介

多表之间的关系

  • 一对多
    • 用户 ——> 订单、订单、订单、订单
  • 多对一（一对一）
    • 订单、订单、订单、订单 ——> 用户
    • 单个订单 ——> 用户
  • 一对一
    • 中国公民——>身份证
  • 多对多
    • 语文老师、数学老师、英语老师——>小明、小红、小黑、小绿

MyBatis中多表之间的关系

  • 本次案例主要以最为简单的用户（User）、账户（Account）、角色（Role）的模型来分析Mybatis多表关系。
    • 用户为User 表，账户为Account表。
      • 一对多关系
        • 一个用户（User）可以开设多个账户（Account）
          • **从查询 用户信息（User） 出发，关联查询 账户信息（Account）**属于一对多查询
      • 一对一关系（多对一）
        • 多个账户（Account）可以对应一个用户（User）
        • 单个账户（Account）只能属于一个用户（User）
          • **从查询 账户信息（Account） 出发，关联查询 用户信息（User）**属于一对一查询
      • 多对多关系
        • 一个用户（User）可以拥有多个角色（Role）
        • 一个角色（Role）可以赋予多个用户（User）
          • 多对多关系其实我们看成是双向的一对多关系。

目录结构

  • src
    • main
      • java
        • cn.water.dao
          • M2MDao.java（多对多 持久层接口）
          • O2MDao.java（一对多 持久层接口）
          • O2ODao.java（一对一 持久层接口）
        • cn.water.domain
          • M2M_Role.java（多对多 实体类）
          • M2M_User.java（多对多 实体类）
          • O2M_Account.java（一对多 实体类）
          • O2M_User.java（一对多 实体类）
          • O2O_Account.java（一对一 实体类）
          • O2O_AccountUser.java（一对一 实体类）
          • O2O_User.java（一对一 实体类）
      • resources
        • cn.water.dao
          • M2MDao.xml（多对多 映射配置文件）
          • O2MDao.xml（一对多 映射配置文件）
          • O2ODao.xml（一对一 映射配置文件）
        • SqlMapConfig.xml（MyBatis主配置文件）
        • jdbcConfig.properties（数据库连接信息文件）
    • test
      • java.cn.water
        • MybatisTest.java（测试类）

MyBatis主配置文件

SqlMapConfig.xml

<?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">


        <!-- mybatis的主配置文件 -->
        <configuration>

            <!-- 外部配置 -->
            <properties resource="jdbcConfig.properties"></properties>

            <!-- 指定包：实体类-->
            <typeAliases>
                <package name="cn.water.domain"/>
            </typeAliases>

            <!-- 配置环境 -->
            <environments default="mysql">
                <environment id="mysql">
                    <transactionManager type="JDBC"></transactionManager>
                    <dataSource type="POOLED">
                        <!-- 配置连接数据库的4个基本信息 -->
                        <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.water.dao"/>
            </mappers>

        </configuration>

数据库连接信息文件

jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=root

实体类

M2M_Role.java

package cn.water.domain;

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

/**
 * @author Water
 * @date 2019/10/10 - 19:11
 * @description ManyToMany 多对多查询
 */
public class M2M_Role implements Serializable {

    private Integer roleId;
    private String roleName;
    private String roleDesc;
    private List<M2M_User> users;

    @Override
    public String toString() {
        return "M2M_Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                ", 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;
    }

    public List<M2M_User> getUsers() {
        return users;
    }

    public void setUsers(List<M2M_User> users) {
        this.users = users;
    }
}

M2M_User.java

package cn.water.domain;

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

/**
 * @author Water
 * @date 2019/10/10 - 19:11
 * @description ManyToMany 多对多查询
 */
public class M2M_User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<M2M_Role> roles;

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

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

    public List<M2M_Role> getRoles() {
        return roles;
    }

    public void setRoles(List<M2M_Role> roles) {
        this.roles = roles;
    }
}

O2M_Account.java

package cn.water.domain;

import java.io.Serializable;

/**
 * @author Water
 * @date 2019/10/10 - 19:12
 * @description OneToMany 一对多查询
 */
public class O2M_Account implements Serializable {

    private Integer id;
    private Integer uid;
    private Double money;


    @Override
    public String toString() {
        return "O2M_Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + 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;
    }
}

O2M_User.java

package cn.water.domain;

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

/**
 * @author Water
 * @date 2019/10/10 - 19:10
 * @description OneToMany 一对多查询
 */
public class O2M_User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<O2M_Account> accounts;

    @Override
    public String toString() {
        return "O2M_User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                ", 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;
    }

    public List<O2M_Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<O2M_Account> accounts) {
        this.accounts = accounts;
    }
}

O2O_Account.java

package cn.water.domain;

import java.io.Serializable;

/**
 * @author Water
 * @date 2019/10/10 - 19:12
 * @description OneToOne 一对一查询
 */
public class O2O_Account implements Serializable {

    private Integer id;
    private Integer uid;
    private Double money;
    private O2O_User user;

    @Override
    public String toString() {
        return "O2O_Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                ", 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;
    }

    public O2O_User getUser() {
        return user;
    }

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

O2O_AccountUser.java

package cn.water.domain;

import java.io.Serializable;

/**
 * @author Water
 * @date 2019/10/10 - 19:12
 * @description OneToOne 一对一查询
 */
public class O2O_AccountUser extends O2O_Account implements Serializable {

    private String username;
    private String address;

    @Override
    public String toString() {
        /* 调用父类的toString方法 */
        return super.toString()+"  O2O_AccountUser{" +
                "username='" + username + '\'' +
                ", address='" + 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;
    }
}

O2O_User.java

package cn.water.domain;

import java.io.Serializable;
import java.util.Date;

/**
 * @author Water
 * @date 2019/10/10 - 19:10
 * @description OneToOne 一对一查询
 */
public class O2O_User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    @Override
    public String toString() {
        return "O2O_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;
    }
}

持久层

M2MDao.java

package cn.water.dao;

import cn.water.domain.M2M_Role;
import cn.water.domain.M2M_User;

import java.util.List;

/**
 * @author Water
 * @date 2019/10/10 - 19:24
 * @description ManyToMany 多对多查询
 */
public interface M2MDao {

    /* 多表查询，封装类：Role类 User类 */
    List<M2M_Role> findAll01();

    /* 多表查询，封装类：Role类 User类 */
    List<M2M_User> findAll02();

}

O2MDao.java

package cn.water.dao;

import cn.water.domain.O2M_User;
import cn.water.domain.O2O_Account;
import cn.water.domain.O2O_User;

import java.util.List;

/**
 * @author Water
 * @date 2019/10/10 - 19:24
 * @description OneToMany 一对多查询
 */
public interface O2MDao {

    /* 多表查询，封装类：Account类 User类 */
    List<O2M_User> findAll ();

}

O2ODao.java

package cn.water.dao;

import cn.water.domain.O2O_Account;
import cn.water.domain.O2O_AccountUser;

import java.util.List;

/**
 * @author Water
 * @date 2019/10/10 - 19:24
 * @description OneToOne 一对一查询
 */
public interface O2ODao {

    /* 多表查询，封装类：Account类 User类*/
    List<O2O_Account> findAll01 ();

    /* 多表查询，封装类：父类Account 子类AccountUser */
    List<O2O_AccountUser> findAll02 ();

}

映射配置文件

M2MDao.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="cn.water.dao.M2MDao">
    <!-- 【Role表】 -->
    <resultMap id="role" type="m2m_role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <!-- 【User表】 -->
        <collection property="users" ofType="m2m_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="findAll01" resultMap="role">
        SELECT
            u.*,
            r.id 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>

O2MDao.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="cn.water.dao.O2MDao">
    <!-- 【主表：User】 -->
    <resultMap id="o2m" type="o2m_user">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="birthday" property="birthday"/>
        <result column="sex" property="sex"/>
        <result column="address" property="address"/>
        <!-- 【次表：Account】 -->
        <collection property="accounts" ofType="o2m_account">
            <id column="id" property="id"/>
            <result column="uid" property="uid"/>
            <result column="money" property="money"/>
        </collection>
    </resultMap>
    <!-- 多表查询 -->
    <select id="findAll" resultMap="o2m">
        SELECT *
        FROM user u
        LEFT OUTER JOIN account a
        ON u.id = a.uid;
    </select>
</mapper>

O2ODao.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="cn.water.dao.O2ODao">
    <!-- 【次表：Account】 -->
    <resultMap id="o2o" type="o2o_account">
        <id column="id" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <!-- 【主表：User】 -->
        <association property="user" javaType="o2o_user">
            <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="birthday" property="birthday"/>
            <result column="sex" property="sex"/>
            <result column="address" property="address"/>
        </association>
    </resultMap>
    <!-- 多表查询 -->
    <select id="findAll01" resultMap="o2o">
        SELECT
        u.*,
        a.*
        FROM
        user u,
        account a
        WHERE
        u.id = a.uid;
    </select>
    <!-- 多表查询 -->
    <select id="findAll02" resultType="o2o_accountUser">
        SELECT
        a.*,
        u.username,
        u.address
        FROM
        user u,
        account a
        WHERE
        u.id = a.uid;
    </select>
</mapper>

测试类

MyBatisTest.java

package cn.water;

import cn.water.dao.M2MDao;
import cn.water.dao.O2MDao;
import cn.water.dao.O2ODao;
import cn.water.domain.*;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

/**
 * @author Water
 * @date 2019/10/10 - 19:44
 * @description
 */
public class MybatisTest {

    /* 成员变量 */
    private InputStream inputStream;
    private SqlSession session;

    /* 初始化操作 */
    @Before
    public void init() throws IOException {
        /* 加载 MyBatis配置文件 */
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        /* 获取 工厂类 */
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        /* 获取 产品类 */
        session = factory.openSession(true);/* 设置自动提交 */
    }

    /* 销毁操作 */
    @After
    public void destroy() throws IOException {
        session.close();
        inputStream.close();
    }

    /* OneToOne */
    @Test
    public void test01(){
        O2ODao dao = session.getMapper(O2ODao.class);
        for (O2O_Account account : dao.findAll01()) {
            System.out.println(account);
        }
    }

    /* OneToOne */
    @Test
    public void test02(){
        O2ODao dao = session.getMapper(O2ODao.class);
        for (O2O_AccountUser accountUser : dao.findAll02()) {
            System.out.println(accountUser);
        }
    }

    /* OneToMany */
    @Test
    public void test03(){
        O2MDao dao = session.getMapper(O2MDao.class);
        for (O2M_User user : dao.findAll()) {
            System.out.println(user);
        }
    }

    /* ManyToMany */
    @Test
    public void test04(){
        M2MDao dao = session.getMapper(M2MDao.class);
        for (M2M_Role role : dao.findAll01()) {
            System.out.println(role);
        }
    }

    /* ManyToMany */
    @Test
    public void test05(){
        M2MDao dao = session.getMapper(M2MDao.class);
        for (M2M_User user : dao.findAll02()) {
            System.out.println(user);
        }
    }


}

一对一查询

  • 从查询 账户信息（Account） 出发，关联查询 用户信息（User）

结果集

  • 当我们查询多个表的时候，我们就需要考虑考虑结果集封装类的问题了。
  • 例如，我们需要查询用户（User）的 username字段 和 address字段 以及账户（Account）的 所有字段。
    • 方法一：根据查询方式，将实体类设置为变量。
    • 方法二：根据查询结果，创建新的实体类。

方法一：将实体类设置为变量

  • 在账户类（Account）直接将 用户类（User）设置为变量，于是账户类即封装了账户信息，又封装了用户信息。
    • 以持久层接口的方法 find01 为案例，查询 Account.uid 与 User.id 相等的所有 Account信息和 User信息。

用户类

public class O2O_User implements Serializable {
    
    /* 成员变量 */
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;
    
    /* toString方法 省略 */
    /* Setter Getter 省略 */
}

账户类（结果集封装类）

  • 将 用户类（User）设置为变量
public class O2O_Account implements Serializable {
    
    /* 成员变量 */
    private Integer id;
    private Integer uid;
    private Double money;
    private User user; /* 用户类 */
    
    /* toString方法 省略 */
    /* Setter Getter 省略 */
    
}

持久层接口

List<O2O_Account> findAll01 ();

映射配置文件

  • 使用resultMap，定义专门的resultMap用于映射一对一查询结果。
<!-- 【次表：Account】 -->
<resultMap id="o2o" type="o2o_account">
    <id column="id" property="id"/>
    <result column="uid" property="uid"/>
    <result column="money" property="money"/>
    <!-- 【主表：User】 -->
    <association property="user" javaType="o2o_user">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="birthday" property="birthday"/>
        <result column="sex" property="sex"/>
        <result column="address" property="address"/>
    </association>
</resultMap>
<!-- 多表查询 -->
<select id="findAll01" resultMap="o2o">
    SELECT
        u.*,
        a.*
    FROM
    	user u,
    	account a
    WHERE
    	u.id = a.uid;
</select>

测试类

@Test
public void test01(){
    O2ODao dao = session.getMapper(O2ODao.class);
    for (O2O_Account account : dao.findAll01()) {
        System.out.println(account);
    }
}

运行结果

O2O_Account{
    id=46, 
    uid=46, 
    money=1000.0, 
    user=O2O_User{id=46, username='老王', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='北京'}}
    
O2O_Account{
    id=45, 
    uid=45, 
    money=1000.0, 
    user=O2O_User{id=45, username='传智播客', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='北京金燕龙'}}

方法二：创建新的实体类

  • 创建 账户子类（AccountUser），由于继承关系我们可以封装账户信息，于是我们只用再设置 usernam变量 和 address变量就可以封装用户信息了。

    • 以持久层接口的方法 find02 为案例，查询 Account.uid 与 User.id 相等的所有 Account信息和 User的usename 和 address信息。

用户类

public class O2O_User implements Serializable {
    
    /* 成员变量 */
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;
    
    /* toString方法 省略 */
    /* Setter Getter 省略 */
}

账户类

public class O2O_Account implements Serializable {
    
    /* 成员变量 */
    private Integer id;
    private Integer uid;
    private Double money;
    
    /* toString方法 省略 */
    /* Setter Getter 省略 */
    
}

账户子类（结果集封装类）

  • 调用父类的toString方法
public class O2O_AccountUser extends O2O_Account implements Serializable {
    
    /* 成员变量 */
    private String username;
    private String address;
    
    /* toString方法 省略 */
    @Override
    public String toString() {
        /* 调用父类的toString方法 */
        return super.toString()+
                "  AccountUser{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
    
    /* Setter Getter 省略 */
    
}

持久层接口

List<O2O_AccountUser> findAll02 ();

映射配置文件

 <!-- 多表查询 -->
<select id="findAll02" resultType="o2o_accountUser">
    SELECT
        a.*,
        u.username,
        u.address
    FROM
        user u,
        account a
    WHERE
        u.id = a.uid;
</select>

测试类

@Test
public void test02(){
    O2ODao dao = session.getMapper(O2ODao.class);
    for (O2O_AccountUser accountUser : dao.findAll02()) {
        System.out.println(accountUser);
    }
}

运行结果

O2O_Account{id=1, uid=46, money=1000.0, user=null}  O2O_AccountUser{username='老王', address='北京'}
O2O_Account{id=2, uid=45, money=1000.0, user=null}  O2O_AccountUser{username='传智播客', address='北京金燕龙'}
O2O_Account{id=3, uid=46, money=2000.0, user=null}  O2O_AccountUser{username='老王', address='北京'}

一对多查询

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

用户类

  • 一对多关系映射：主表实体类 应该包含 从表实体类的集合引用
public class O2M_User implements Serializable {
    
    /* 成员变量 */
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<O2M_Account> accounts;
    
    /* toString方法 省略 */
    /* Setter Getter 省略 */
}

账户类

public class O2M_Account implements Serializable {
    
    /* 成员变量 */
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<O2M_Account> accounts;
    
    /* toString方法 省略 */
    /* Setter Getter 省略 */
}

持久层接口

List<O2M_User> findAll ();

映射文件

 <!-- 【主表：User】 -->
<resultMap id="o2m" type="o2m_user">
    <id column="id" property="id"/>
    <result column="username" property="username"/>
    <result column="birthday" property="birthday"/>
    <result column="sex" property="sex"/>
    <result column="address" property="address"/>
    <!-- 【次表：Account】 -->
    <collection property="accounts" ofType="o2m_account">
        <id column="id" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
    </collection>
</resultMap>
<!-- 多表查询 -->
<select id="findAll" resultMap="o2m">
    SELECT *
    FROM 
    	user u
    LEFT OUTER JOIN 
    	account a
    ON 
    	u.id = a.uid;
</select>

测试类

@Test
public void test03(){
    O2MDao dao = session.getMapper(O2MDao.class);
    for (O2M_User user : dao.findAll()) {
        System.out.println(user);
    }
}

测试结果

O2M_User{id=41, username='老王', birthday=Tue Feb 27 17:47:08 CST 2018, sex='男', address='北京', accounts=[O2M_Account{id=41, uid=null, money=null}]}
O2M_User{id=42, username='小二王', birthday=Fri Mar 02 15:09:37 CST 2018, sex='女', address='北京金燕龙', accounts=[O2M_Account{id=42, uid=null, money=null}]}
O2M_User{id=43, username='小二王', birthday=Sun Mar 04 11:34:34 CST 2018, sex='女', address='北京金燕龙', accounts=[O2M_Account{id=43, uid=null, money=null}]}
O2M_User{id=45, username='传智播客', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='北京金燕龙', accounts=[O2M_Account{id=45, uid=45, money=1000.0}]}
O2M_User{id=46, username='老王', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='北京', accounts=[O2M_Account{id=46, uid=46, money=1000.0}]}
O2M_User{id=48, username='小马宝莉', birthday=Thu Mar 08 11:44:00 CST 2018, sex='女', address='北京修正', accounts=[O2M_Account{id=48, uid=null, money=null}]}

多对多查询

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

用户类

  • 多对多关系映射：两个实体类应该包含彼此的集合引用
public class M2M_User implements Serializable {
    
    /* 成员变量 */
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<M2M_Role> roles;
    
    /* toString方法 省略 */
    /* Setter Getter 省略 */
}

角色类

  • 多对多关系映射：两个实体类应该包含彼此的集合引用
public class M2M_Role implements Serializable {
    
    /* 成员变量 */
    private Integer roleId;
    private String roleName;
    private String roleDesc;
    private List<M2M_User> users;
    
    /* toString方法 省略 */
    /* Setter Getter 省略 */
}

持久层接口

	List<M2M_Role> findAll();

映射文件

 <!-- 【Role表】 -->
<resultMap id="role" type="m2m_role">
    <id property="roleId" column="rid"></id>
    <result property="roleName" column="role_name"></result>
    <result property="roleDesc" column="role_desc"></result>
    <!-- 【User表】 -->
    <collection property="users" ofType="m2m_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="role">
    SELECT
        u.*,
        r.id 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>

测试类

@Test
public void test04(){
    M2MDao dao = session.getMapper(M2MDao.class);
    for (M2M_Role role : dao.findAll()) {
        System.out.println(role);
    }
}

测试结果

M2M_Role{roleId=1, roleName='院长', roleDesc='管理整个学院', users=[M2M_User{id=41, username='老王', birthday=Tue Feb 27 17:47:08 CST 2018, sex='男', address='北京', roles=null}, M2M_User{id=45, username='传智播客', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='北京金燕龙', roles=null}]}
M2M_Role{roleId=2, roleName='总裁', roleDesc='管理整个公司', users=[M2M_User{id=41, username='老王', birthday=Tue Feb 27 17:47:08 CST 2018, sex='男', address='北京', roles=null}]}
M2M_Role{roleId=3, roleName='校长', roleDesc='管理整个学校', users=[]}

比较：O2O O2M

一对一

实体类

  • 用户类

    • id
    • username
    • birthday
    • sex
    • address

  • 账户类

    • id
    • uid
    • money
    • user

映射配置文件

  • association标签
    • javaType属性
<!-- 【次表：Account】 -->
<resultMap id="accountUserMap" type="account">
    <id property="id" column="id"></id>
    <result property="uid" column="uid"></result>
    <result property="money" column="money"></result>
    <!-- 【主表：User】 -->
    <association property="user" javaType="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>

一对多

实体类

  • 用户类

    • id
    • username
    • birthday
    • sex
    • address
    • LIst<Account>

  • 账户类

    • id
    • uid
    • money

映射配置文件

  • collection标签
    • ofType属性
<!-- 【主表：User】 -->
<resultMap id="userAccountMap" type="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>
    <!-- 【次表：Account】 -->
    <collection property="accounts" ofType="account">
        <id property="id" column="id"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
    </collection>
</resultMap>
water1127
发布了68 篇原创文章 · 获赞 2 · 访问量 1915
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_40981851/article/details/104191909
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022