MyBatis 多表操作

文章源码

一对一查询

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

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

可以使用 resultMap,定义专门的 resultMap 用于映射一对一查询结果。

  • 定义账户信息的数据表

    DROP TABLE IF EXISTS `account`;
    
    CREATE TABLE `account` (
    `ID` int(11) NOT NULL COMMENT '编号',
    `UID` int(11) default NULL COMMENT '用户编号',
    `MONEY` double default NULL COMMENT '金额',
    PRIMARY KEY (`ID`),
    KEY `FK_Reference_8` (`UID`),
    CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8; insert into `account`(`ID`,`UID`,`MONEY`) values (1,41,1000),(2,45,1000),(3,41,2000);
  • 定义账户信息的实体类

    package cn.parzulpan.domain;
    
    import java.io.Serializable;
    
    /**
    * @Author : parzulpan
    * @Time : 2020-12
    * @Desc :
    */ public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    private 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 User getUser() {
    return user;
    } public void setUser(User user) {
    this.user = user;
    } @Override
    public String toString() {
    return "Account{" +
    "id=" + id +
    ", uid=" + uid +
    ", money=" + money +
    ", user=" + user +
    '}';
    }
    }
  • 编写 SQL

    select u.*, a.id as aid, a.uid, a.money
    from account a, user u
    where a.uid = u.id;
  • 定义账户的持久层 DAO 接口

    package cn.parzulpan.dao;
    
    import cn.parzulpan.domain.Account;
    
    import java.util.List;
    
    /**
    * @Author : parzulpan
    * @Time : 2020-12
    * @Desc :
    */ public interface AccountDAO { /**
    * 查询所有账户,同时获取账户的所属用户名称以及它的地址信息
    * @return
    */
    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="cn.parzulpan.dao.AccountDAO"> <!-- 建立对应关系 -->
    <resultMap id="accountMap" type="account">
    <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>
  • 测试

    package cn.parzulpan.test;
    
    import cn.parzulpan.dao.AccountDAO;
    import cn.parzulpan.domain.Account;
    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;
    import java.util.List; /**
    * @Author : parzulpan
    * @Time : 2020-12
    * @Desc : 多表查询
    */ public class MyBatisQueryTest {
    private InputStream is;
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    private SqlSessionFactory factory;
    private SqlSession session;
    private AccountDAO accountDAO; @Before
    public void init() throws IOException {
    is = Resources.getResourceAsStream("SqlMapConfig.xml");
    factory = builder.build(is);
    session = factory.openSession();
    accountDAO = session.getMapper(AccountDAO.class);
    } @After
    public void destroy() throws IOException {
    session.commit(); // 事务提交
    session.close();
    is.close();
    } @Test
    public void findAllTest() {
    List<Account> accounts = accountDAO.findAll();
    for (Account account : accounts) {
    System.out.println(account);
    System.out.println(account.getUser());
    }
    }
    }

一对多查询

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

分析:用户信息和他的账户信息为一对多关系,并且查询过程中如果用户没有账户信息,此时也要将用户信息查询出来,所以左外连接查询比较合适。

  • 编写 SQL

    select u.*, a.id as id, a.uid, a.money
    from user u left join account a on u.id = a. uid;
  • User 类加入 List<Account>

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

    /**
    * 查询所有用户,同时获取出每个用户下的所有账户信息
    * @return
    */
    List<User> findAllAndAccount();
  • 配置 UserDAO.xml 文件

        <resultMap id="userMap" type="user">
    <id column="id" property="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="findAllAndAccount" resultMap="userMap">
    select u.*, a.id as aid, a.uid, a.money
    from user u left join account a on u.id = a. uid;
    </select>
  • 测试

    @Test
    public void findAllAndAccountTest() {
    List<User> users = userDAO.findAllAndAccount();
    for (User user : users) {
    System.out.println();
    System.out.println("----- " + user.getUsername() + " -----");
    System.out.println(user);
    System.out.println(user.getAccounts());
    }
    }

多对多查询

需求:实现查询所有对象并且加载它所分配的用户信息。

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

  • 定义相关的数据表

    # -----
    
    DROP TABLE IF EXISTS `role`;
    
    CREATE TABLE `role` (
    `ID` int(11) NOT NULL COMMENT '编号',
    `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
    `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
    PRIMARY KEY (`ID`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8; insert into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校'); # ----- DROP TABLE IF EXISTS `user_role`; CREATE TABLE `user_role` (
    `UID` int(11) NOT NULL COMMENT '用户编号',
    `RID` int(11) NOT NULL COMMENT '角色编号',
    PRIMARY KEY (`UID`,`RID`),
    KEY `FK_Reference_10` (`RID`),
    CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
    CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8; insert into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);
  • 定义角色信息的实体类

    package cn.parzulpan.domain;
    
    import java.io.Serializable;
    import java.util.List; /**
    * @Author : parzulpan
    * @Time : 2020-12
    * @Desc : 角色实体类
    */ public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc; private List<User> 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<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 + '\'' +
    ", users=" + users +
    '}';
    }
    }
  • 编写 RoleDAO 持久层接口

    package cn.parzulpan.dao;
    
    import cn.parzulpan.domain.Role;
    
    import java.util.List;
    
    /**
    * @Author : parzulpan
    * @Time : 2020-12
    * @Desc :
    */ public interface RoleDAO { /**
    * 查询所有角色
    * @return
    */
    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="cn.parzulpan.dao.RoleDAO"> <!-- 建立对应关系 -->
    <resultMap id="roleMap" type="role">
    <id property="roleId" column="rid"/>
    <result property="roleName" column="role_name"/>
    <result property="roleDesc" column="role_desc"/>
    <collection property="users" ofType="user">
    <id column="id" property="id"/>
    <result column="username" property="username"/>
    <result column="address" property="address"/>
    <result column="sex" property="sex"/>
    <result column="birthday" property="birthday"/>
    </collection>
    </resultMap> <select id="findAll" resultMap="roleMap">
    select r.id as rid, r.role_name, r.role_desc, u.*
    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>
  • 测试

    package cn.parzulpan.test;
    
    import cn.parzulpan.dao.AccountDAO;
    import cn.parzulpan.dao.RoleDAO;
    import cn.parzulpan.domain.Account;
    import cn.parzulpan.domain.Role;
    import cn.parzulpan.domain.User;
    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;
    import java.util.List; /**
    * @Author : parzulpan
    * @Time : 2020-12
    * @Desc : 多表查询
    */ public class MyBatisManyQueryTest {
    private InputStream is;
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    private SqlSessionFactory factory;
    private SqlSession session;
    private RoleDAO roleDAO; @Before
    public void init() throws IOException {
    is = Resources.getResourceAsStream("SqlMapConfig.xml");
    factory = builder.build(is);
    session = factory.openSession();
    roleDAO = session.getMapper(RoleDAO.class);
    } @After
    public void destroy() throws IOException {
    session.commit(); // 事务提交
    session.close();
    is.close();
    } @Test
    public void findAllTest() {
    List<Role> roles = roleDAO.findAll();
    for (Role role : roles) {
    System.out.println();
    System.out.println("----- " + " -----");
    System.out.println(role);
    if (role != null) {
    System.out.println(role.getUsers());
    }
    }
    }
    }

练习和总结

【MyBatis】MyBatis 多表操作的更多相关文章

  1. Mybatis的多表操作

    1.Mybatis多表查询 1.1 一对一查询 1.1.1 一对一查询的模型MapperScannerConfigurer 用户表和订单表的关系为,一个用户有多个订单,一个订单只从属于一个用户 一对一 ...

  2. 阶段3 1.Mybatis_09.Mybatis的多表操作_2 完成account表的建立及实现单表查询

    mybatis中的多表查询:         示例:用户和账户             一个用户可以有多个账户             一个账户只能属于一个用户(多个账户也可以属于同一个用户)    ...

  3. 阶段3 1.Mybatis_09.Mybatis的多表操作_1 mybatis表之间关系分析

    4.mybatis中的多表查询     表之间的关系有几种:         一对多         多对一         一对一         多对多     举例:         用户和订单 ...

  4. 阶段3 1.Mybatis_09.Mybatis的多表操作_8 mybatis多对多操作-查询角色获取角色下所属用户信息

    一个角色对应多个用户 生成getter和setter 查看两个表的数据 中间表定义了谁有角色,谁没有角色 根据中间表的关系,最终查询出来的列表的数据样子.这需要两个左外链接才能实现功能. 第一个左外链 ...

  5. 阶段3 1.Mybatis_09.Mybatis的多表操作_7 mybatis多对多准备角色表的实体类和映射配置

    创建Role表和user_role表 DROP TABLE IF EXISTS `role`; CREATE TABLE `role` ( `ID` int(11) NOT NULL COMMENT ...

  6. 阶段3 1.Mybatis_09.Mybatis的多表操作_6 分析mybatis多对多的步骤并搭建环境

    示例:用户和角色             一个用户可以有多个角色             一个角色可以赋予多个用户         步骤:             1.建立两张表:用户表,角色表    ...

  7. 阶段3 1.Mybatis_09.Mybatis的多表操作_3 完成account的一对一操作-通过写account的子类方式查询

    先把多表查询的sql语句写出来 想要显示的字段 创建一个AccountUser类 继承Account.这样它就会从父类上继承一些信息 这里只需要定义username和address就可以了 .然后生成 ...

  8. 阶段3 1.Mybatis_09.Mybatis的多表操作_9 mybatis多对多操作-查询用户获取用户所包含的角色信息

    sql语句以user作为主表 用户的全部信息,以为用户下的角色的.并不是所有的用户都有角色,有角色的就带角色.没角色的就为null 首先修改实体类 定义List<Role> 生成gette ...

  9. 阶段3 1.Mybatis_09.Mybatis的多表操作_5 完成user的一对多查询操作

    定义List<Account> accounts,生成getter和setter 复制AccountTest类改名UserTest类 修改测试类 还没封装所以Account的list都是n ...

  10. 阶段3 1.Mybatis_09.Mybatis的多表操作_4 完成account一对一操作-建立实体类关系的方式

    定义user的实体.然后生成getter和setter 定义一个可以封装Account和User的Map type这里虽然是account类型 这一段只能保证account的数据完成.并不能保证use ...

随机推荐

  1. css3(::before)伪元素的使用

    1 <!DOCTYPE html> 2 <html lang="en"> 3 4 <head> 5 <meta charset=" ...

  2. NOI Online #2 提高组 游戏

    没用二项式反演的菜比. 题目链接 Solution 非平局代表的树上祖先关系是比较好统计,(可以在处理一个点时,考虑用他去匹配他的子树中的东西)而平局的关系比较难统计.我们不妨求出至少 \(k\) 个 ...

  3. 海量数据架构下如何保证Mycat的高可用?

    写在前面 在<冰河,能讲讲Mycat如何实现MySQL的读写分离吗?>一文中,我们实现了使用Mycat实现MySQL的读写分离.然而,此时的Mycat只有一个节点,如果Mycat节点宕机了 ...

  4. git 常用命令--超实用

    git命令行常用操作 1.配置ssh key git config --global user.name 'git用户名' git config --global user.email '邮箱地址' ...

  5. STL—— 容器(vector)元素的删除

    1. clear() 将整个 vector 都删除 使用 vectorname.clear() 可以将整个vector 中的元素全部删除,但是内存不会释放,如下代码: 1 #include <i ...

  6. 一个实现浏览器网页与本地程序之间进行双向调用的轻量级、强兼容、可扩展的插件开发平台—PluginOK中间件

    通过PluginOK中间件插件平台(原名本网通WebRunLocal)可实现在网页中的JavaScript脚本无障碍访问本地电脑的硬件.调用本地系统的API及相关组件,同时可彻底解决ActiveX组件 ...

  7. spring boot 项目使用idea正常打包后执行总是出现异常,解决办法

    众所周知,spring boot 在构建项目时,确实为Java程序员们省了不少力气,打包项目非常容易. 上周在项目中遇到打包后的项目总是无法运行,困扰了我们团队将近两天才找到原因. 图和真相在这里.

  8. Flink读写Redis(一)-写入Redis

    项目pom文件 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w ...

  9. Missing Private key解决方案——IOS证书 .cer 以p12文件以及配置方案

    一个苹果证书怎么多次使用--导出p12文件 为什么要导出.p12文件 因为苹果规定 .cer证书只能存在于一台机器上,因此 如果另一台电脑想要用的话,需要导出为.p12 file ,安装到另一台没有安 ...

  10. node目录

    1 [了解nodejs] 1.1 [node简介] 1.2 [node的特点] 1.3 [如何安装] 1.4 [如何运行] 2 [es6--基本语法] 2.1 [变量的解构赋值] 2.2 [解构赋值] ...