07.【Mybatis中的多表查询】

最新推荐文章于 2023-07-11 10:15:23 发布
最新推荐文章于 2023-07-11 10:15:23 发布
阅读量192 收藏
点赞数
分类专栏： MyBatis
原文链接：http://www.itheima.com/
版权

表之间的关系

  • 一对多
  • 多对一
  • 一对一
  • 多对多
举例
  1. 用户和订单就是一对多
  2. 订单和用户就是多对一
  3. 一个用户可以下多个订单
  4. 多个订单属于同一个用户
特例
  • 如果拿出每一个订单，他都只能属于一个用户。
  • 所以Mybatis就把多对一看成了一对一。

mybatis中的多表查询

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

1. 一对一

当我们查询账户时，可以同时得到账户的所属用户信息

第一种写法 【不推荐】
  • 子类继承实体类，并重写 toString 方法

实体类：Account.java

package com.itheima.domain;

import java.io.Serializable;

public class Account implements Serializable {

    private Integer id;
    private Integer uid;
    private Double money;
    
	// 省略...
    }
}

子类：AccountUser.java

package com.itheima.domain;

public class AccountUser extends Account {

    private String username;
    private String address;

	// 省略...

    @Override
    public String toString() {
        return super.toString()+"        AccountUser{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

接口：IAccountDao.java

package com.itheima.dao;

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

import java.util.List;

public interface IAccountDao {

      /**
     * 查询所有账户
     * @return
     */
    List<Account> findAll();

    /**
     * 查询所有账户，并且带有用户名称和地址信息
     * @return
     */
    List<AccountUser> findAllAccount();
}

映射配置文件：IAccountDao.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="com.itheima.dao.IAccountDao">

    <!-- 查询所有account账户信息 -->
    <select id="findAll" resultType="account">
        select * from account
    </select>

    <!--查询所有账户同时包含用户名和地址信息-->
    <select id="findAllAccount" resultType="accountuser">
        select a.*,u.username,u.address from account a , user u where u.id = a.uid;
    </select>

</mapper>

Mybatis的主配置文件：SqlMapConifg.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">
<configuration>
    <!-- 配置properties-->
    <properties resource="jdbcConfig.properties"></properties>

    <!--使用typeAliases配置别名，它只能配置domain中类的别名 -->
    <typeAliases>
        <package name="com.itheima.domain"></package>
    </typeAliases>

    <!--配置环境-->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务 -->
            <transactionManager type="JDBC"></transactionManager>

            <!--配置连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"></property>
                <property name="url" value="${jdbc.url}"></property>
                <property name="username" value="${jdbc.username}"></property>
                <property name="password" value="${jdbc.password}"></property>
            </dataSource>
        </environment>
    </environments>
    <!-- 配置映射文件的位置 -->
    <mappers>
        <package name="com.itheima.dao"></package>
    </mappers>
</configuration>

配置连接数据库文件：jdbcConfig.properties

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

AccountTest.java

package com.itheima.test;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.domain.AccountUser;
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.InputStream;
import java.util.List;

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 */
public class AccountTest {

    private InputStream in;
    private SqlSession sqlSession;
    private IAccountDao accountDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        //4.获取dao的代理对象
        accountDao = sqlSession.getMapper(IAccountDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        //提交事务
        // sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询account单表数据
     */
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for(Account account : accounts){          
            System.out.println(account);
        }
    }

    /**
     * 测试查询所有账户，同时包含用户名称和地址
     * 第一种一对一查询方式
     * 【创建实体类子类】
     */
    @Test
    public void testFindAllAccountUser(){
        List<AccountUser> aus = accountDao.findAllAccount();
        for(AccountUser au : aus){
            System.out.println(au);
        }
    }
}

结果：

测试查询所有account账户

Account{id=1, uid=41, money=1000.0}
Account{id=2, uid=45, money=1000.0}
Account{id=3, uid=41, money=2000.0}

测试查询所有账户，同时包含用户名称和地址

Account{id=1, uid=41, money=1000.0}        AccountUser{username='老王', address='北京'}
Account{id=2, uid=45, money=1000.0}        AccountUser{username='mybatis updateuser', address='沈阳'}
Account{id=3, uid=41, money=2000.0}        AccountUser{username='老王', address='北京'}
第二种写法 【推荐】
  • 增加一对一关系映射：从表实体应该包含一个主表实体的对象引用

实体类

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

实体类：User

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 String address;
    private String sex;
    private Date birthday;
 	
    // 省略...
}

接口：IAccount.java

 /**
     * 查询所有账户，同时还要获取到当前账户的所属用户信息
     * @return
     */
    List<Account> findAll();

配置映射文件：IAccount.xml

注意

<association property="user" column="uid" javaType="user">

javaType="user" : 封装到哪个对象，user是起别名了！！

<?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="account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一对一的关系映射：配置封装user的内容-->
        <!-- javaType="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 account a , user u where u.id = a.uid;
    </select>

</mapper>

Test

/**
     * 测试查询所有账户，同时包含用户名称和地址
     * 第二种一对一查询方式
     * 【从表实体应该包含一个主表实体的对象引用】
     */
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for(Account account : accounts){
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

结果：

Account{id=1, uid=41, money=1000.0}
User{id=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}
Account{id=2, uid=45, money=1000.0}
User{id=45, username='mybatis updateuser', address='沈阳', sex='女', birthday=Sun Mar 01 01:14:18 CST 2020}
Account{id=3, uid=41, money=2000.0}
User{id=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}

2. 一对多

当我们查询用户时，可以同时得到用户下所包含的账户信息

  • 增加一对多关系映射：主表实体应该包含从表实体的集合引用

实体类

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 String address;
    private String sex;
    private Date birthday;

    //一对多关系映射：主表实体应该包含从表实体的集合引用
    private List<Account> accounts;

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

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

	 // 省略
}

IUserDao.java

 /**
     * 查询所有用户，同时获取到用户下所有账户的信息
     * @return
     */
    List<User> findAll();

IUserDao.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="com.itheima.dao.IUserDao">

    <!-- 定义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集合的映射   ofType="account":集合中元素的类型  若未起别名，则要写全限定类名-->
        <collection property="accounts" ofType="account">
            <!--  column="aid" 数据库列名（起别名了，避免列明重复） property="id"：实体类中属性名称-->
            <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 u left outer join account a on u.id = a.uid
    </select>

</mapper>

Test

 /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println("-----每个用户的信息------");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }
注意
1. 配置user对象中accounts集合的映射
  • ofType="account": 集合中元素的类型 若未起别名，则要写全限定类名
  • property="id" 实体类中属性名称
  • column="aid" 数据库列名（起别名了，避免列明重复）
        <collection property="accounts" ofType="account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
		</collection>
2. mybatis可以识别重复数据，将对应的信息封装到一起
[Account{id=null, uid=41, money=1000.0}, Account{id=null, uid=41, money=2000.0}]

结果：

-----每个用户的信息------
User{id=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}
[Account{id=null, uid=41, money=1000.0}, Account{id=null, uid=41, money=2000.0}]
-----每个用户的信息------
User{id=45, username='mybatis updateuser', address='沈阳', sex='女', birthday=Sun Mar 01 01:14:18 CST 2020}
[Account{id=null, uid=45, money=1000.0}]
-----每个用户的信息------
User{id=42, username='小二王', address='北京金燕龙', sex='女', birthday=Fri Mar 02 15:09:37 CST 2018}
[]
...

3. 多对多

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

实体类

  • 多对多的关系映射：一个角色可以赋予多个用户
package com.itheima.domain;

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

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 */
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;
    }

	// 省略...
}

IRoleDao.java

package com.itheima.dao;
import com.itheima.domain.Role;
import java.util.List;

public interface IRoleDao {

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

IRoleDao.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">
<!--namespace用于绑定Dao接口的，即面向接口编程-->
<mapper namespace="com.itheima.dao.IRoleDao">

    <!--定义role表的ResultMap-->
    <resultMap id="roleMap" type="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="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>
</mapper>

Test

/**
     * 测试查询所有
     */
    @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());
        }
    }

结果：

---每个角色的信息----
Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}
[User{id=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}, User{id=45, username='mybatis updateuser', address='沈阳', sex='女', birthday=Sun Mar 01 01:14:18 CST 2020}]
---每个角色的信息----
Role{roleId=2, roleName='总裁', roleDesc='管理整个公司'}
[User{id=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}]
---每个角色的信息----
Role{roleId=3, roleName='校长', roleDesc='管理整个学校'}
[]
2. 当我们查询角色时，可以同时得到角色的所赋予的用户信息

实体类

  • 多对多的关系映射：一个用户可以具备多个角色
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 String address;
    private String sex;
    private Date birthday;

    //多对多的关系映射：一个用户可以具备多个角色
    private List<Role> roles;

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

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }
	// 省略...
}

IUserDao.java

package com.itheima.dao;

import com.itheima.domain.User;

import java.util.List;

/**
 * 用户的持久层接口
 */
public interface IUserDao {

    /**
     * 查询所有用户，同时获取到用户下所有账户的信息
     * @return
     */
    List<User> findAll();
}

IUserDao.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="com.itheima.dao.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">
        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>

    <!-- 根据id查询用户 -->
    <select id="findById" parameterType="INT" resultType="user">
        select * from user where id = #{uid}
    </select>
</mapper>

Test

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println("-----每个用户的信息------");
            System.out.println(user);
            System.out.println(user.getRoles());
        }
    }

结果：

-----每个用户的信息------
User{id=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}
[Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}, Role{roleId=2, roleName='总裁', roleDesc='管理整个公司'}]
-----每个用户的信息------
User{id=45, username='mybatis updateuser', address='沈阳', sex='女', birthday=Sun Mar 01 01:14:18 CST 2020}
[Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}]
-----每个用户的信息------
User{id=42, username='小二王', address='北京金燕龙', sex='女', birthday=Fri Mar 02 15:09:37 CST 2018}
[]
...
LiuszZZ
关注
专栏目录
mybatis之多表查询
m0_46570170的博客
04-16 1468
准备两张表 第一种 sql语句 <!-- 多表查询 设置一个resultMap 来映射 /--> 测试代码 第二种多表查询 使用association语句 接口 mapper 测试 第三种association 的高级用法 对多表查询进行分割 变成单表查询来提高效率 第一步写第一个表的查询根据id //多表查询association 分解成单标查询 先查询Employee的全部数据 然后再通过deptId...
MyBatis的多表查询
qq_49044908的博客
11-16 918
MyBatis的多表查询 数据之间有多种对应关系,如一对多(用户和订单),多对一,一对一(人和身份证号),多对多(老师和学生) 多表查询 例子:用户和账户 一个用户可以有多个账户 一个账户只能属于一个用户 现在我们想要的是在查询所有账户信息的同时可以展示用户的情况. 法一 创建实体类AccountUser,通过继承的方式让这个类中拥有所有需要的属性; public class AccountUser extends Account { private String username; pri
mybatis-day03笔记
weixin_45185764的博客
09-18 173
1.Mybatis多表查询 一对一 人-1-----1-身份证号 一对多 多对一 USER ==1============N==orders 多对多 用户 =1=====N==中间表==N====1== 角色 1.1 一对一查询 1.1.1 一对一查询的模型 用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户 一对一查询的需求：查询一个订单，与此同...
Mybatis多表查询
qq_47156956的博客
10-11 721
对于数据库中表之间的关系有一对一、一对多、多对多。 针对于多表查询，依据表的关系，可分为一对一查询、一对多查询、多对多查询
mybatis中的多表查询
技术积累，技术分享
01-06 571
表之间的关系有几种 一对多：一个用户可以有多个订单，用户和订单间的关系就是一对多的关系 多对一：多个订单属于同一个用户，订单和用户之间的关系就是一个多对一的关系 一对一：一个人只能由一个身份证号，一个身份证号只能属于一个人，人和身份证号之间的关系就属于一对一 多对多：一个学生可以被多个老师交过，一个老师可以交多个学生，老师和学生之间就是多对多 特例： 如果拿出每一个订单，他都只能属于一个用户。所以mybatis就把多对一看成了一对一 mybatis中的多表查询 示例：账户和用户 一个用户可以有多个账户
使用tk.mybatis查询，某些字段返回0的问题
weixin_38950807的博客
07-10 1140
title: 使用tk.mybatis查询，某些字段返回0的问题 date: 2019-07-10 16:21:27 categories: MyBatis 今天使用mapper4出现了个问题，记录一下。 查询代码： example = new Example(VesselTrackData.class); if (dateType != 0){ ...
Mybatis的多表查询实例
不思量
04-16 745
通过实例演示Mybatis的多表查询（一对一、一对多、多对多）
Mybatis-07.zip
01-06
在“Mybatis-07.zip”压缩包中，我们可以找到几个关键文件，它们对于理解Mybatis的工作原理至关重要。 首先，`pom.xml`是Maven项目对象模型（Project Object Model）的配置文件，它定义了项目的依赖、构建过程等...
mybatis-3-config.dtd mybatis-3-mapper.dtd
11-19
在提供的压缩包文件`a5a737bf07ad487ea7b6eae182394e1a`中，可能包含了具体的MyBatis配置文件和映射文件示例，进一步展示了如何利用`mybatis-3-config.dtd`和`mybatis-3-mapper.dtd`来构建一个完整的MyBatis应用。...
07.MyBatis学习--全局配置文件_databaseIdProvider_多数据库支持
Adela0916的博客
12-26 437
实现多数据库支持步骤 在MyBatis中，可以通过databaseIdProvider来实现多数据库支持。 databaseIdProvider:支持多数据库厂商 type="DB_VENDOR":VendorDatabaseIdProvider,作用就是得到数据库厂商的标识（驱动getDatabaseProductName()), mybatis就能根据数据库厂商标识来执行不同的sql. 厂商标识：MySQL,Oracle,SQL Server,xxx 在mybatis全局配置文件中使用database
8.mybatis中多表查询
西瓜咬人啦
07-17 166
8.1 一对一(多对一)查询 查询学生对象，学生对象中含有班级信息。 package com.itany.ms.dao; import com.itany.ms.entity.Stu; import java.util.List; public interface StuMapper { // 查询所有学生(含该学生所属班级信息) List<Stu> selectAll(); } 1.方式1 <?xml version="1.0" encoding="UTF-8" ?&g
Mybatis中多表查询之多对多查询
weixin_43157935的博客
04-17 265
该例有两个数据表：user和role以及一个用户角色中间表，用户与角色的多对多关系模型如下： 其中：user表： role表： 用户角色中间表user_role： 分析：role表和user表构成了多对多的关系：即一个用户user可能有多个角色role，而同一个角色也可以从属于多个用户。其实多对多关系，我们可以看成是双向的一对多关系。 需求：进行多对多查询：其实双向的一对多查询。 步骤： ...
Mybatis中实现多表查询
z7kirictol的博客
06-21 470
mybatis中实现多表查询方式 在业务层(service)中处理,对两张表分别编写单表查询语句，然后将结果合并。 使用mybatis中resultMap标签进行实现。 当多表查询时，类中包含另一个类的对象 这里主要使用第二种方法 一、resultMap属性 resultMap标签写在mapper.xml中，由程序员控制SQL查询结果与实体类的映射关系。 默认MyBatis使用Auto Mapping特性 使用resultMap 标签时，select标签不写resultType属性,而是使用resul
【Mybatis】MyBatis 实现多表查询
热门推荐
寒泉
09-04 2万+
准备：创建数据库 create table teacher( id int(10) primary key auto_increment, name varchar(20) ); insert into teacher values(default,'鱼老师'); insert into teacher values(default,'绿老师'); insert into teacher v...
Mybatis中多表查询之一对一查询
weixin_43157935的博客
04-16 216
首先，查看两张数据表：user和account。 user表： account表： 并且，account的外键UID所对应的是user表的主键id。 需求：查询所有账户信息，关联查询下单用户信息。 分析：因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。 方式一： 1.定义账户Account实体信息类： package com.itheima.domain;...
MyBatis--高级查询（二）
荒的博客
10-13 139
一对多映射 假设在RBAC权限系统中，一个用户只能拥有一个角色，把用户和角色之间的关系限制为一对一的关系，一对一映射不需要考虑是否存在重复
MyBatis 中如何使用多表查询
最新发布
stormjun的博客
07-11 1623
本文介绍了 MyBatis 中如何使用多表查询，包括使用嵌套查询、使用关联查询和使用动态 SQL 等方式。在实际开发中，我们可以根据具体的业务需求和数据结构，选择合适的方式进行多表查询。使用嵌套查询和关联查询的方式比较简单直观，适合查询较少的表，而使用动态 SQL 的方式则可以根据条件动态生成 SQL 语句，具有更高的灵活性，适合查询较多的表和复杂的数据结构。在使用 MyBatis 进行多表查询时，需要注意以下几点：确定查询的表和关系。
{ "timestamp": "2023-06-01T07:59:10.804+0000", "status": 500, "error": "Internal Server Error", "message": "nested exception is org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 130", "trace": "org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 130\r\n\tat org.mybatis.spring.MyBatisExceptionTranslator.translateExceptionIfPossible(MyBatisExceptionTranslator.java:92)\r\n\tat org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:440)\r\n\tat com.sun.proxy.$Proxy95.selectOne(Unknown Source)\r\n\tat org.mybatis.spring.SqlSessionTemplate.selectOne(SqlSessionTemplate.java:159)\r\n\tat com.baomidou.mybatisplus.core.override.MybatisMapperMethod.execute(MybatisMapperMethod.java:89)\r\n\tat com.baomidou.mybatisplus.core.override.MybatisMapperProxy.invoke(MybatisMapperProxy.java:61)\r\n\tat com.sun.proxy.$Proxy160.isSuccess(Unknown Source)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImp 这段代码有什么问题
06-02
这段代码中的问题可能与 MyBatis 的查询逻辑有关。根据这段代码中的错误消息，selectOne() 方法只期望返回一个结果或者 null，但实际上查询返回了 130 个结果，因此抛出了 TooManyResultsException 异常。您可以检查...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值