3.Mybatis框架学习笔记之表间关系

最新推荐文章于 2022-06-28 18:00:15 发布
最新推荐文章于 2022-06-28 18:00:15 发布
阅读量308 收藏
点赞数 1
分类专栏： Mybatis框架 文章标签： 数据库 java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42707971/article/details/105751578
版权

对应工程OneToMany，many-to-many

mybatis多表查询

表之间的关系有几种：

  • 一对一
  • 一对多
  • 多对一
  • 多对多

示例： 用户和账户。一个用户可以有多个账户，一个账户只能属于一个用户(多个账户也可以属于同一个用户)。
步骤:

  1. 建立两张表：用户表，账户表。让用户表和账户表之间具备一对多的关系:需要使用外键在账户表中添加。
  2. 建立两个实体类：用户实体类和账户实体类。让用户和账户的实体类能体现出一对多的关系。
  3. 建立两个配置文件：用户的配置文件和账户的配置文件。
  4. 实现配置：当我们查询用户时，可以同时得到用户下所包含的账户信息；当我们查询账户时，可以同时得到账户的所属用户信息。

数据库准备
用户表：
在这里插入图片描述
账户表：
在这里插入图片描述
其中账户表uid的外键是用户表中的id。

账户对用户的一对一查询操作

方式一：

首先新建一个account实体类

public class Account implements Serializable {
	private Integer id;
	private Integer uid;
	private Double money;
	// 自行插入set和get、toString方法
}

定义一个IAccountDao接口：

public interface IAccountDao {
    List<Account> findAll();
}

新建一个IAccountDao配置文件

    <!--    配置查询所有-->
    <select id="findAll" resultMap="accountUserMap">
        select * from account01
    </select>

测试类测试一下单表查询账户表
在这里插入图片描述
下面开始进行一对一步骤，首先定义 AccountUser 类：为了能够封装 SQL 语句的查询结果，定义 AccountCustomer 类中要包含账户信息同时还要包含用户信息，所以我们要在定义 AccountUser 类时可以继承 Account 类。

public class AccountUser extends Account implements Serializable {
	private String username;
	private String address;

	@Override
    public String toString() {
        return super.toString()+"AccountUser{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
	//省略set和get
}

在IAccountDao接口中添加一个方法

List<AccountUser> findAllAccount();

修改IAccountDao配置文件

    <select id="findAllAccount" resultType="accountuser">
        select a.*,u.username,u.address from account01 a,user u where u.id = a.uid;
    </select>

测试类代码

    @Test
    public void testFindAllAccountUser() {
        //5.使用代理对象执行方法
        List<AccountUser> ac = accountDao.findAllAccount() ;
        for (AccountUser a : ac) {
            System.out.println(a);
        }
    }

输出结果：
在这里插入图片描述

方法二

使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。在 Account 类中加入一个 User 类的对象来代表这个账户是哪个用户的。

在从表实体中定义一个主表实体的对象user，用来测试类中做引用。

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
//    从表实体应该包含一个主表实体的对象引用
    private User user;
//    省略set和get方法
}

IAccountDao配置文件：

    <!--    定义封装account和user的resultMap -->
    <resultMap id="accountUserMap" type="cn.smm.domain.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 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>

    <!--    配置查询所有-->
    <select id="findAll" resultMap="accountUserMap">
        select u.*,a.id as aid,a.uid,a.money from account01 a,user u where u.id = a.uid;
    </select>

其中resultMap中：association标签用于一对一关系，就是 将另一张表的字段 关联过来 然后一起映射到实体类user中。

  • property：说明从表引用了哪个表的属性，这里是user用户表，
  • column：以账户表的uid作为条件去查询。
  • javaType：把sql语句查询出的结果集，封装给实体类user的对象。

测试类：

    @Test
    public void testFindAll() {
        //5.使用代理对象执行方法
        List<Account> accounts = accountDao.findAll();
        for (Account a : accounts) {
            System.out.println("----------每个account的信息-----------");
            System.out.println(a);
            System.out.println(a.getUser());
        }
    }

输出结果：
在这里插入图片描述

用户对账户的一对多查询操作

通过查询一个用户，然后显示此用户下面有多少个账户。
在主表实体类user中配置从表实体的对象引用

//    主表实体配置一个从表实体的对象引用
    private List<Account> accounts;
//    省略get和set

sql语句使用左外连接，就会返回左表u的所有数据，加上条件u.id=a.uid

select u.*,a.id as aid ,a.uid,a.money from user u left outer join account01 a on u.id =a.uid

IUserDao配置文件：

  • collection部分定义了用户关联的账户信息。表示关联查询结果集
  • property=“accounts” ：关联查询的结果集存储在 User对象的上哪个属性。此处是user实体类中的accounts属性
    在这里插入图片描述
  • ofType：指定关联查询的结果集中的对象类型即List中的对象类型。也可以使用全限定名cn.smm.domain.account
    <!--    定义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 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 u.*,a.id as aid ,a.uid,a.money from user u left outer join account01 a on u.id =a.uid
    </select>

测试类：

    @Test
    public void testFindAll() {
        //5.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for (User a : users) {
            System.out.println("----------每个account的信息-----------");
            System.out.println(a);
            System.out.println(a.getAccounts());
        }
    }

输出结果：
在这里插入图片描述

多对多的两个案例

例如：一个用户有多个角色，比如父亲，孩子，兄弟角色。而一个角色可以赋予多个用户。
步骤:

  1. 建立两张表：用户表，角色表。让用户表和角色表之间具备多对多的关系。需要中间表，中间表包含各自的主键，在中间表中是外键。
  2. 建立两个实体类：用户实体类和角色实体类。让用户和角色的实体类能体现出多对多的关系。各自包含对方一个集合引用。
  3. 建立两个配置文件：用户的配置文件和角色的配置文件。
  4. 实现配置：当我们查询用户时，可以同时得到用户下所包含的角色信息；当我们查询角色时，可以同时得到角色的所赋予的用户信息。

前期准备

用户表不变，创建两个表，中间表user_role：
在这里插入图片描述
和角色表role：
在这里插入图片描述

查询角色得到用户信息

目的：通过查询角色，返回角色信息和对应的用户信息。
创建role实体类和接口：

//	实体类
public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc;
    //    多对多的关系映射，一个角色可以赋予多个用户
    private List<User> users;
    //	  省略get和set
}
//	接口
public interface IRoleDao {
    List<Role> findAll();
}

配置文件IRoleDao

    <!--    定义role的resultMap-->
    <resultMap id="roleMap" type="cn.smm.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="cn.smm.domain.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="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>
  • 补充知识开始

sql语句，注意很长的sql语句换行之前最好加个空格！！！

SELECT * FROM role r 
 LEFT OUTER JOIN user_role ur ON r.id = ur.rid 
 LEFT OUTER JOIN USER u ON u.id = ur.uid

查询结果：
在这里插入图片描述
但是不需要中间表的信息和用户表中id和前面的id一样，两者容易混淆，需要起别名。所以修改为如下：

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

查询结果：
在这里插入图片描述

  • 补充知识结束

测试类测试：

    @Test
    public void testFindAll() {
        //5.使用代理对象执行方法
        List<Role> roles = roleDao.findAll();
        for (Role r : roles) {
            System.out.println("----------每个account的信息-----------");
            System.out.println(r);
            System.out.println(r.getUsers());
        }
    }

输出结果：
在这里插入图片描述

查询用户得到角色信息

操作都是差不多，就是反过来
在user实体类中添加一个多对多的关系映射

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
//  多对多的关系映射：一个用户可以具备多个角色，省略set和get，toString
    private List<Role> roles;
}

IUserDao配置文件

    <!--    定义user的resultMap-->
    <resultMap id="userMap" 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>
        <!--    配置角色集合的映射    -->
        <collection property="roles" ofType="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="userMap">
        <!--    用户查角色的sql语句-->
        select u.*,r.id as rid,r.role_name,r.role_desc from user u
        left outer join user_role ur on u.id = ur.uid
        left outer join role r on r.id = ur.rid
    </select>

测试类

    @Test
    public void testFindAll() {
        //5.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for (User a : users) {
            System.out.println("----------每个account的信息-----------");
            System.out.println(a);
            System.out.println(a.getRoles());
        }
    }
EdmundDshi
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis学习日记（三）
kkkkkkws的博客
07-13 258
Mybatis学习日记（三） mybatis中的多表查询 实例：用户和账户 一个用户可以有多个账户 一个账户只能属于一个用户（多个账户也可以属于一个用户） 步骤： 1、创建两张表：用户表、账户表 让用户表和账户表之间具有一对多的关系：需要使用外键在账户表中添加 2、建立两个实体类：用户类和账户实体类 让用户和账户的实体类能体现出来一对多的关系 mybatis中的多表查询: 示例:用户和账户 一个用户可以有多个账户 一个账户只能属于一个用户(多个账户也可以属于同一个用户) 步骤: 1、建立两张表:用
Mybatis表关系操作（一对一、一对多、多对多）
c17315377559的博客
10-13 2270
一、resultMap关键字 Mybatis负责的是Dao层之间的交互，我们都知道表与表之间具有三种关系，一对一，一对多，多对多。我们要想让结果封装到bean中，就要通过resultMap关键字进行映射。 <resultMap type="" id=""></resultMap> type表示bean的类型。 id表示该resultMap的名称。 在resul...
Mybatis中表的关联关系
qq_42338744的博客
06-28 1096
一对多 多对一 关联关系
mybatis关联映射（表的三种关系，含具体代码）
我是老伯的博客
02-17 1110
mybatis关联映射（表的三种关系，含具体代码） 一对一：在任意一个表中设置一个外键 一对多： 在多的表中设置外键，标记少的表中id 多对多：（学生--选课） 建立关系表
mybatis Association标签 column属性应对多值的情况
热门推荐
jbgtwang的专栏
12-25 5万+
Association元素 Association元素处理“has-one”（一对一）这种类型关系。比如在我们的例子中，一个Blog有一个Author。联合映射与其它的结果集映射工作方式差不多，指定property、column、javaType（通常MyBatis会自动识别）、jdbcType（如果需要）、typeHandler。 不同的地方是您需要告诉MyBatis 如何加
Mybatis框架学习笔记.rar
最新发布
03-20
本笔记主要涵盖了Mybatis的基本概念、核心组件、配置、动态SQL以及最佳实践。 一、Mybatis概述 Mybatis是由Google Code托管，后迁移到GitHub的开源项目，由Clinton Begin创建。它是一个基于Java的持久层框架，通过...
mybatis框架-学习笔记Day01.rar
03-26
本人博客文章《mybatis框架-学习笔记Day01》的相关代码文件本人博客文章《mybatis框架-学习笔记Day01》的相关代码文件本人博客文章《mybatis框架-学习笔记Day01》的相关代码文件本人博客文章《mybatis框架-学习笔记...
MyBatis框架学习笔记
05-10
MyBatis是一个优秀的持久层框架，它支持SQL查询、存储过程和高级映射。与传统的JDBC相比，MyBatis消除了手动设置参数和检索结果集的繁琐工作，通过XML或注解方式将Java POJOs（Plain Old Java Objects）映射到数据库...
MyBatis学习笔记.zip
03-18
在"MyBatis学习笔记.zip"这个压缩包中，包含了四天的学习内容，分别以"MyBatis_day1"、"MyBatis_day2"、"MyBatis_day3"和"MyBatis_day4"命名，这些笔记可能详细阐述了MyBatis的核心概念和使用方法。让我们逐一解析...
MyBatis处理表与表之间的关系
Future_IT_Daniel的博客
07-02 856
列子： 比如要在帖子回复表里显示其它两张相关联表的信息 处理的第一种方式：  1）主要的数据实体类是ReplyInfo，相关联的实体表的数据是PostInfo，UserInfo。    那么首先创建的是ReplyInfoView的实体对象。 package com.gxa.bj.modle package com.gxa.bj.modle; public class Repl
用户表角色权限表的设计
10-20
因为做过的一些系统的权限管理的功能虽然在逐步完善，但总有些不尽人意的地方，总想抽个时间来更好的思考一下权限系统的设计。        权限系统一直以来是我们应用系统不可缺少的一个部分，若每个应用系统都重新对系统的权限进行设计，以满足不同系统用户的需求，将会浪费我们不少宝贵时间，所以花时间来设计一个相对通用的权限系统是很有意义的。 二．设计目标        设计一个灵活、通用、方便的权限管理系统。        在这个系统中，我们需要对系统的所有资源进行权限控制，那么系统中的资源包括哪些呢？我们可以把这些资源简单概括为静态资源（功能操作、数据列）和动态资源（数据），也分别称为对象资源和数据资源，后者是我们在系统设计与实现中的叫法。
myBatis里表与表之间的关系 多对一时候
java9426的博客
06-30 547
对       1.所实现的映射关系是：在帖子分类的实体对象里包含的是帖子的实体对象的集合。 1）首先建立实体关系的映射，那么就需要在分类的实体里加入帖子的集合。代码如下： package com.model; import java.util.List; //分类 public class Sort { private Integer sortId;//分类编号 priv
mybatis association 复杂类型联合操作
天际线；世界的尽头；天涯海角 !
06-29 5068
一：mybatis的XML文件                                                                                                                                          
Mybatis之表之间映射关系总结
sunpy
12-23 7903
1.什么是表之间映射关系
Mybats 多表联合查询之一对一操作
Zystem
06-13 1983
1、 项目简介 首先呢，我们创建两张表，一个是users表，一个是account表，两张表组成了用户和账户之间的关系，一个用户可以有多个账户，一个账户只能属于一个用户，这就是我们的背景。首先实现一对一表的联合查询，一个用户对应一张表。 2、数据库表 用户表users 账户表account 其中账户表的uid为外键，指向的是用户表的主键id 3、项目的目录 4、我们首先来看两个实体类，对应着两...
Mybatis进阶之表之间的关系
沙漠皇帝本拉登
04-26 248
Mybatis 输入映射 支持的类 八大基础数据类型 list map pojo 包装类型 可以通过对象导航的方式不断向下获取 例如:#{user.username} 输出映射 八大基础数据类型 list map pojo 输出包装类型时 需要自动映射字段 根据ID查找对象 User.java package ...
实际项目中外键，应该用"userid"(账号)还是用user表"ID"
weixin_34417814的博客
09-26 1832
2019独角兽企业重金招聘Python工程师标准>>> ...
MyBatis：一对多表关系详解(从案例中解析)
您已进入防沉迷系统...
11-11 2万+
1，案例一：产生问题 客户(Customer表)和订单(Order表)之间的关系是一对多的关系，即一个用户可以有多个订单。 （1）建立表，并建立一对多关联。 主表 create table Customer( id int primary key, name varchar(32) ); 从表，customer_id是指向Customer表的主键id的外键 creat
MyBatis学习笔记与实战指南
"这是一份关于MyBatis的学习笔记，包含笔记整理和示例代码，旨在帮助学习者全面理解并掌握MyBatis框架。" 在Java开发领域，MyBatis是一个广泛使用的开源免费数据访问层框架，原名为iBatis，自2010年起在Google Code...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值