MyBatis 多表操作

文章源码

一对一查询

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

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

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

  • 定义账户信息的数据表

    1. DROP TABLE IF EXISTS `account`;
    3. CREATE TABLE `account` (
    4.                         `ID` int(11) NOT NULL COMMENT '编号',
    5.                         `UID` int(11) default NULL COMMENT '用户编号',
    6.                         `MONEY` double default NULL COMMENT '金额',
    7.                         PRIMARY KEY  (`ID`),
    8.                         KEY `FK_Reference_8` (`UID`),
    9.                         CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
    10. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    12. insert  into `account`(`ID`,`UID`,`MONEY`) values (1,41,1000),(2,45,1000),(3,41,2000);

  • 定义账户信息的实体类

    1. package cn.parzulpan.domain;
    3. import java.io.Serializable;
    5. /**
    6. * @Author : parzulpan
    7. * @Time : 2020-12
    8. * @Desc :
    9. */
    11. public class Account implements Serializable {
    12.     private Integer id;
    13.     private Integer uid;
    14.     private Double money;
    15.     private User user;
    17.     public Integer getId() {
    18.         return id;
    19.     }
    21.     public void setId(Integer id) {
    22.         this.id = id;
    23.     }
    25.     public Integer getUid() {
    26.         return uid;
    27.     }
    29.     public void setUid(Integer uid) {
    30.         this.uid = uid;
    31.     }
    33.     public Double getMoney() {
    34.         return money;
    35.     }
    37.     public void setMoney(Double money) {
    38.         this.money = money;
    39.     }
    41.     public User getUser() {
    42.         return user;
    43.     }
    45.     public void setUser(User user) {
    46.         this.user = user;
    47.     }
    49.     @Override
    50.     public String toString() {
    51.         return "Account{" +
    52.                 "id=" + id +
    53.                 ", uid=" + uid +
    54.                 ", money=" + money +
    55.                 ", user=" + user +
    56.                 '}';
    57.     }
    58. }

  • 编写 SQL

    1. select u.*, a.id as aid, a.uid, a.money
    2. from account a, user u
    3. where a.uid = u.id;

  • 定义账户的持久层 DAO 接口

    1. package cn.parzulpan.dao;
    3. import cn.parzulpan.domain.Account;
    5. import java.util.List;
    7. /**
    8. * @Author : parzulpan
    9. * @Time : 2020-12
    10. * @Desc :
    11. */
    13. public interface AccountDAO {
    15.     /**
    16.     * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
    17.     * @return
    18.     */
    19.     List<Account> findAll();
    20. }

  • 配置 AccountDAO.xml 文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    6. <mapper namespace="cn.parzulpan.dao.AccountDAO">
    8.     <!-- 建立对应关系 -->
    9.     <resultMap id="accountMap" type="account">
    10.         <id column="aid" property="id"/>
    11.         <result column="uid" property="uid"/>
    12.         <result column="money" property="money"/>
    14.         <!-- 用于指定从数据表方的引用实体属性 -->
    15.         <association property="user" javaType="user">
    16.             <id column="id" property="id"/>
    17.             <result column="username" property="username"/>
    18.             <result column="sex" property="sex"/>
    19.             <result column="birthday" property="birthday"/>
    20.             <result column="address" property="address"/>
    21.         </association>
    22.     </resultMap>
    24.     <select id="findAll" resultMap="accountMap">
    25.         select u.*, a.id as aid, a.uid, a.money
    26.         from account a, user u
    27.         where a.uid = u.id;
    28.     </select>
    29. </mapper>

  • 测试

    1. package cn.parzulpan.test;
    3. import cn.parzulpan.dao.AccountDAO;
    4. import cn.parzulpan.domain.Account;
    5. import org.apache.ibatis.io.Resources;
    6. import org.apache.ibatis.session.SqlSession;
    7. import org.apache.ibatis.session.SqlSessionFactory;
    8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    9. import org.junit.After;
    10. import org.junit.Before;
    11. import org.junit.Test;
    13. import java.io.IOException;
    14. import java.io.InputStream;
    15. import java.util.List;
    17. /**
    18. * @Author : parzulpan
    19. * @Time : 2020-12
    20. * @Desc : 多表查询
    21. */
    23. public class MyBatisQueryTest {
    24.     private InputStream is;
    25.     SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    26.     private SqlSessionFactory factory;
    27.     private SqlSession session;
    28.     private AccountDAO accountDAO;
    30.     @Before
    31.     public void init() throws IOException {
    32.         is = Resources.getResourceAsStream("SqlMapConfig.xml");
    33.         factory = builder.build(is);
    34.         session = factory.openSession();
    35.         accountDAO = session.getMapper(AccountDAO.class);
    36.     }
    38.     @After
    39.     public void destroy() throws IOException {
    40.         session.commit();   // 事务提交
    41.         session.close();
    42.         is.close();
    43.     }
    45.     @Test
    46.     public void findAllTest() {
    47.         List<Account> accounts = accountDAO.findAll();
    48.         for (Account account : accounts) {
    49.             System.out.println(account);
    50.             System.out.println(account.getUser());
    51.         }
    52.     }
    53. }

一对多查询

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

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

  • 编写 SQL

    1. select u.*, a.id as id, a.uid, a.money
    2. from user u left join account a on u.id = a. uid;

  • User 类加入 List<Account>

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

    1. /**
    2. * 查询所有用户，同时获取出每个用户下的所有账户信息
    3. * @return
    4. */
    5. List<User> findAllAndAccount();

  • 配置 UserDAO.xml 文件

    1.     <resultMap id="userMap" type="user">
    2.         <id column="id" property="id"/>
    3.         <result column="username" property="username"/>
    4.         <result column="address" property="address"/>
    5.         <result column="sex" property="sex"/>
    6.         <result column="birthday" property="birthday"/>
    8.         <!-- collection 是用于建立一对多中集合属性的对应关系 ofType 用于指定集合元素的数据类型 -->
    9.         <collection property="accounts" ofType="account">
    10.             <id column="aid" property="id"/>
    11.             <result column="uid" property="uid"/>
    12.             <result column="money" property="money"/>
    13.         </collection>
    14.     </resultMap>
    16.     <select id="findAllAndAccount" resultMap="userMap">
    17.         select u.*, a.id as aid, a.uid, a.money
    18.         from user u left join account a on u.id = a. uid;
    19.     </select>

  • 测试

    1. @Test
    2. public void findAllAndAccountTest() {
    3.     List<User> users = userDAO.findAllAndAccount();
    4.     for (User user : users) {
    5.         System.out.println();
    6.         System.out.println("----- " + user.getUsername() + " -----");
    7.         System.out.println(user);
    8.         System.out.println(user.getAccounts());
    9.     }
    10. }

多对多查询

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

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

  • 定义相关的数据表

    1. # -----
    3. DROP TABLE IF EXISTS `role`;
    5. CREATE TABLE `role` (
    6.                         `ID` int(11) NOT NULL COMMENT '编号',
    7.                         `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
    8.                         `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
    9.                         PRIMARY KEY  (`ID`)
    10. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    12. insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');
    14. # -----
    16. DROP TABLE IF EXISTS `user_role`;
    18. CREATE TABLE `user_role` (
    19.                             `UID` int(11) NOT NULL COMMENT '用户编号',
    20.                             `RID` int(11) NOT NULL COMMENT '角色编号',
    21.                             PRIMARY KEY  (`UID`,`RID`),
    22.                             KEY `FK_Reference_10` (`RID`),
    23.                             CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
    24.                             CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
    25. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    27. insert  into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);

  • 定义角色信息的实体类

    1. package cn.parzulpan.domain;
    3. import java.io.Serializable;
    4. import java.util.List;
    6. /**
    7. * @Author : parzulpan
    8. * @Time : 2020-12
    9. * @Desc : 角色实体类
    10. */
    12. public class Role implements Serializable {
    13.     private Integer roleId;
    14.     private String roleName;
    15.     private String roleDesc;
    17.     private List<User> users;   //多对多的关系映射：一个角色可以赋予多个用户
    19.     public Integer getRoleId() {
    20.         return roleId;
    21.     }
    23.     public void setRoleId(Integer roleId) {
    24.         this.roleId = roleId;
    25.     }
    27.     public String getRoleName() {
    28.         return roleName;
    29.     }
    31.     public void setRoleName(String roleName) {
    32.         this.roleName = roleName;
    33.     }
    35.     public String getRoleDesc() {
    36.         return roleDesc;
    37.     }
    39.     public void setRoleDesc(String roleDesc) {
    40.         this.roleDesc = roleDesc;
    41.     }
    43.     public List<User> getUsers() {
    44.         return users;
    45.     }
    47.     public void setUsers(List<User> users) {
    48.         this.users = users;
    49.     }
    51.     @Override
    52.     public String toString() {
    53.         return "Role{" +
    54.                 "roleId=" + roleId +
    55.                 ", roleName='" + roleName + '\'' +
    56.                 ", roleDesc='" + roleDesc + '\'' +
    57.                 ", users=" + users +
    58.                 '}';
    59.     }
    60. }

  • 编写 RoleDAO 持久层接口

    1. package cn.parzulpan.dao;
    3. import cn.parzulpan.domain.Role;
    5. import java.util.List;
    7. /**
    8. * @Author : parzulpan
    9. * @Time : 2020-12
    10. * @Desc :
    11. */
    13. public interface RoleDAO {
    15.     /**
    16.     * 查询所有角色
    17.     * @return
    18.     */
    19.     List<Role> findAll();
    20. }

  • 编写映射文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    6. <mapper namespace="cn.parzulpan.dao.RoleDAO">
    8.     <!-- 建立对应关系 -->
    9.     <resultMap id="roleMap" type="role">
    10.         <id property="roleId" column="rid"/>
    11.         <result property="roleName" column="role_name"/>
    12.         <result property="roleDesc" column="role_desc"/>
    13.         <collection property="users" ofType="user">
    14.             <id column="id" property="id"/>
    15.             <result column="username" property="username"/>
    16.             <result column="address" property="address"/>
    17.             <result column="sex" property="sex"/>
    18.             <result column="birthday" property="birthday"/>
    19.         </collection>
    20.     </resultMap>
    22.     <select id="findAll" resultMap="roleMap">
    23.         select r.id as rid, r.role_name, r.role_desc, u.*
    24.         from role r left outer join user_role ur on r.id = ur.rid left outer join user u on u.id = ur.uid
    25.     </select>
    26. </mapper>

  • 测试

    1. package cn.parzulpan.test;
    3. import cn.parzulpan.dao.AccountDAO;
    4. import cn.parzulpan.dao.RoleDAO;
    5. import cn.parzulpan.domain.Account;
    6. import cn.parzulpan.domain.Role;
    7. import cn.parzulpan.domain.User;
    8. import org.apache.ibatis.io.Resources;
    9. import org.apache.ibatis.session.SqlSession;
    10. import org.apache.ibatis.session.SqlSessionFactory;
    11. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    12. import org.junit.After;
    13. import org.junit.Before;
    14. import org.junit.Test;
    16. import java.io.IOException;
    17. import java.io.InputStream;
    18. import java.util.List;
    20. /**
    21. * @Author : parzulpan
    22. * @Time : 2020-12
    23. * @Desc : 多表查询
    24. */
    26. public class MyBatisManyQueryTest {
    27.     private InputStream is;
    28.     SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    29.     private SqlSessionFactory factory;
    30.     private SqlSession session;
    31.     private RoleDAO roleDAO;
    33.     @Before
    34.     public void init() throws IOException {
    35.         is = Resources.getResourceAsStream("SqlMapConfig.xml");
    36.         factory = builder.build(is);
    37.         session = factory.openSession();
    38.         roleDAO = session.getMapper(RoleDAO.class);
    39.     }
    41.     @After
    42.     public void destroy() throws IOException {
    43.         session.commit();   // 事务提交
    44.         session.close();
    45.         is.close();
    46.     }
    48.     @Test
    49.     public void findAllTest() {
    50.         List<Role> roles = roleDAO.findAll();
    51.         for (Role role : roles) {
    52.             System.out.println();
    53.             System.out.println("----- " +  " -----");
    54.             System.out.println(role);
    55.             if (role != null) {
    56.                 System.out.println(role.getUsers());
    57.             }
    58.         }
    59.     }
    60. }

练习和总结

【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. ip 子网掩码、网络地址、广播地址计算

    例:已知ip  16.158.165.91/22子网掩码 根据22 得知子网掩码占22位 即:11111111.11111111.11111100.00000000   == 255.255.252. ...

  2. redis学习之——主从复制（replication）

    准备:拥有linux环境,并安装redis mater:主机,进行写操作 slave:从机,进行读操作 一.配置 继续前边的学习.我们是拷贝redis.conf,文件到了/root /redis 下. ...

  3. Array的简单使用（Boost和STL通用）

    目录 目录 介绍 使用 Boost和STL的区别 介绍 本来这一次是想简单介绍一下Boost里面的协程库的使用的,但是Boost.Coroutine已经被废弃了,而Boost.Coroutine2目前 ...

  4. python魔术方法总结

    获取属性 __ getattr __(self, name) 定义当用户试图获取一个不存在的属性时的行为 __ getattribute __(self, name) 定义当该类的属性被访问时的行为 ...

  5. 横向无文件移动--SCshell使用

    1.简介 SCShell是无文件横向移动工具,它依赖ChangeServiceConfigA来运行命令.该工具的优点在于它不会针对SMB执行身份验证.一切都通过DCERPC执行.无需创建服务,而只需通 ...

  6. schema与数据类型优化-高性能mysql

    总结作为开发人员重点注意的内容!这是一篇有关高性能MYSQL第四章schema相关的笔记. 0.前言 在项目中,数据库表列有两个text字段,用来存储大文本,在数据规模达到40万后,如果查询没命中索引 ...

  7. gitbook 安装和使用

    gitbook 安装和使用 安装nodejs  wget https://nodejs.org/dist/v10.22.0/node-v10.22.0-linux-arm64.tar.xz tar - ...

  8. [日常摸鱼][POI2000]病毒-Tire图（AC自动机）+dfs

    https://www.luogu.org/problemnew/show/P2444 (没有bzoj权限号T_T) 字符串题对我这种傻逼来说真是太难了x 题意:输入$n$个01组成的模式串串,判断是 ...

  9. 第一天——编程语言与python

    ------------恢复内容开始------------ what's the python? python是一门编程语言,编程语言就是人用来和计算机沟通的语言,语言就是人与人,人与事物进行沟通的 ...

  10. tkinter + 爬虫 实现影视在线资源系统

    应吾爱朋友现公布代码如下: import tkinter as tk import requests,re,sys,asyncio from tkinter import scrolledtext,E ...