Mybatis多表查询

最新推荐文章于 2024-06-25 09:59:40 发布
最新推荐文章于 2024-06-25 09:59:40 发布
阅读量1.5k 收藏 9
点赞数
分类专栏： Mybatis学习日志 文章标签： mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40857365/article/details/112696313
版权

步骤

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

建立用户表和账户表

  1. 建立用户表
create table mybatisuser(
	id int(11) not null auto_increment,
	username varchar(32) not null comment '用户名称',
	birthday datetime default null comment '生日',
	sex char(1) default null comment '性别',
	address varchar(256) default null comment '地址',
	primary key (id)
)engine=innoDB default charset=utf8;
  1. 建立账户表
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 mybatisuser (id)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
  1. 查询所有账户同时包含用户名和地址
    1. 创建实体类
    public class AccountUser extends Account {
   private String username;
   private String 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;
   }

   @Override
   public String toString() {
      return super.toString() + "AccountUser{" +
               "username='" + username + '\'' +
               ", address='" + address + '\'' +
               '}';
   }
}
    1. sql语句
       <select id="findAllAccount" resultType="domain.AccountUser">
      SELECT a.*,u.username,u.address FROM ACCOUNT a, mybatisuser u WHERE a.uid=u.id;
   </select>

一对一查询

  1. 从表实体类应该包含一个主表实体类的对象引用
public class Account implements Serializable {
   private int id;
   private int uid;
   private double money;

   //从表实体类应该包含一个主表实体类的对象引用
   private MybatisUser mybatisUser;

   public MybatisUser getMybatisUser() {
      return mybatisUser;
   }

   public void setMybatisUser(MybatisUser mybatisUser) {
      this.mybatisUser = mybatisUser;
   }

   public int getId() {
      return id;
   }

   public void setId(int id) {
      this.id = id;
   }

   public int getUid() {
      return uid;
   }

   public void setUid(int uid) {
      this.uid = uid;
   }

   public double getMoney() {
      return money;
   }

   public void setMoney(double money) {
      this.money = money;
   }

   @Override
   public String toString() {
      return "Account{" +
               "id=" + id +
               ", uid=" + uid +
               ", money=" + money +
               '}';
   }
}
  1. 定义封装account和user的resultMap
<resultMap id="accountUserMap" type="domain.Account">
   <id property="id" column="aid"></id>
   <result property="uid" column="uid"></result>
   <result property="money" column="money"></result>
   <!--一对一的关系映射，配置封装user的内容-->
   <association property="mybatisUser" column="uid">
      <id property="id" column="id"></id>
      <result property="username" column="username"></result>
      <result property="birthday" column="birthday"></result>
      <result property="sex" column="sex"></result>
      <result property="address" column="address"></result>
   </association>
</resultMap>
  1. sql语句
<select id="findAll" resultMap="accountUserMap">
   SELECT u.*,a.id as aid,a.uid,a.money FROM ACCOUNT a, mybatisuser u WHERE a.uid=u.id;
</select>
  1. 编写方法
public void testFindAll(){
   //5. 使用代理对象执行方法
   List<Account> accounts = accountDao.findAll();

   for (Account account : accounts){
      System.out.println("账户"+account.getId()+"----------------------------");
      System.out.println(account);
      System.out.println(account.getMybatisUser());
   }
}
  1. 查询结果
    在这里插入图片描述

一对多查询

  1. 一对多映射，主表实体类应包含从表实体类的集合引用
public class UserAccount implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

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

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


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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return username;
    }

    public void setName(String name) {
        this.username = name;
    }

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

    @Override
    public String toString() {
        return "MybatisUser{" +
                "id=" + id +
                ", name='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}
  1. 定义UserAccount的resultMap
<!-- 定义UserAccount的resultMap-->
<resultMap id="userAccountMap" type="domain.UserAccount">
   <id property="id" column="id"></id>
   <result property="username" column="username"></result>
   <result property="birthday" column="birthday"></result>
   <result property="sex" column="sex"></result>
   <result property="address" column="address"></result>
   <!--一对多的关系映射，配置UserAccount对象中accounts集合的内容-->
   <collection property="accounts" ofType="domain.Account">
      <id property="id" column="aid"></id>
      <result property="uid" column="uid"></result>
      <result property="money" column="money"></result>
   </collection>
</resultMap>
  1. sql语句
<select id="findAll" resultMap="userAccountMap">
   SELECT u.*,a.id as aid,a.uid,a.money FROM mybatisuser u left outer join account a on u.id=a.uid;
</select>
  1. 编写查询方法
public void testFindAll(){
   //5. 使用代理对象执行方法
   List<UserAccount> users = userDao.findAll();

   for (UserAccount user : users){
      System.out.println("用户"+user.getId()+"--------------------");
      System.out.println(user);
      System.out.println(user.getAccounts());
   }
}
  1. 查询结果
    在这里插入图片描述

多对多查询

  1. 步骤

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

  2. 建表

    1. 建立角色表
    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,'校长','管理整个学校');
    1. 建立中间表
    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 `mybatisuser` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT  INTO `user_role`(`UID`,`RID`) VALUES (2,1),(4,1),(2,2),(5,3),(6,1),(1,2),(4,2);

  3. 查询角色，同时得到该角色下的所有用户

    1. 创建角色实体类，同时包含用户的集合
    public class RoleUser implements Serializable {
   private Integer roleId;
   private String roleName;
   private String roleDesc;

   //生成多对多关系
   private List<UserRole> userRoles;

   public List<UserRole> getUserRoles() {
      return userRoles;
   }

   public void setUserRoles(List<UserRole> userRoles) {
      this.userRoles = userRoles;
   }

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

   @Override
   public String toString() {
      return "RoleUser{" +
               "roleId=" + roleId +
               ", roleName='" + roleName + '\'' +
               ", roleDesc='" + roleDesc + '\'' +
               '}';
   }
}
    1. 创建RoleUserDao接口
    public interface RoleUserDao {

   List<RoleUser> findAll();

}
    1. 定义resultMap
    <resultMap id="roleUserMap" type="domain.RoleUser">
   <id property="roleId" column="rid"></id>
   <result property="roleName" column="role_name"></result>
   <result property="roleDesc" column="role_desc"></result>
   <!--多对多的关系映射，配置封装user的内容-->
   <collection property="userRoles" ofType="domain.UserRole">
      <id property="id" column="id"></id>
      <result property="username" column="username"></result>
      <result property="birthday" column="birthday"></result>
      <result property="sex" column="sex"></result>
      <result property="address" column="address"></result>
   </collection>
</resultMap>
    1. sql语句
    <select id="findAll" resultMap="roleUserMap">
   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 mybatisuser u on u.id=ur.uid;
</select>
    1. 编写方法
    public class RoleUserTest {
   public static void main(String[] args) throws IOException {

   }
   private InputStream in;
   private SqlSession sqlSession;
   private RoleUserDao roleUserDao;
   @Before
   public void init() throws IOException {
      //1. 读取配置文件
      in = Resources.getResourceAsStream("SqlMapConfig.xml");
      //2. 使用ServletContext对象的getRealPath()
      //2. 创建SqlSessionFactory工厂
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory factory = sqlSessionFactoryBuilder.build(in);
      //3. 使用工厂生产SqlSession对象
      sqlSession = factory.openSession();
      //4. 使用SqlSession创建Dao接口的代理对象
      roleUserDao = sqlSession.getMapper(RoleUserDao.class);
   }
   @After
   public void destory() throws IOException {
      //6.事务的提交
      sqlSession.commit();
      //7. 释放资源
      sqlSession.close();
      in.close();
   }

   @Test
   public void testFindAll(){
      //5. 使用代理对象执行方法
      List<RoleUser> roleUsers = roleUserDao.findAll();
      for (RoleUser roleUser : roleUsers){
            System.out.println("角色"+roleUser.getRoleId()+"--------------------");
            System.out.println(roleUser);
            System.out.println(roleUser.getUserRoles());
      }
   }
}
    1. 输出结果
      在这里插入图片描述

  4. 查询所有用户，同时得到该用户的所有角色信息

    1. 创建user实体类，同时包含角色集合
    public class UserRole implements Serializable {
   private Integer id;
   private String username;
   private Date birthday;
   private String sex;
   private String address;

   //生成多对多映射关系
   private List<RoleUser> roleUsers;

   public List<RoleUser> getRoleUsers() {
      return roleUsers;
   }

   public void setRoleUsers(List<RoleUser> roleUsers) {
      this.roleUsers = roleUsers;
   }

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

   @Override
   public String toString() {
      return "UserRole{" +
               "id=" + id +
               ", username='" + username + '\'' +
               ", birthday=" + birthday +
               ", sex='" + sex + '\'' +
               ", address='" + address + '\'' +
               '}';
   }
}
    1. 创建UserRoleDao接口
    public interface UserRoleDao {

   List<UserRole> findAll();

}
    1. 定义resultMap
    <resultMap id="userRoleMap" type="domain.UserRole">
   <id property="id" column="id"></id>
   <result property="username" column="username"></result>
   <result property="birthday" column="birthday"></result>
   <result property="sex" column="sex"></result>
   <result property="address" column="address"></result>
   <!--一对一的关系映射，配置封装user的内容-->
   <collection property="roleUsers" ofType="domain.RoleUser">
      <id property="roleId" column="rid"></id>
      <result property="roleName" column="role_name"></result>
      <result property="roleDesc" column="role_desc"></result>
   </collection>
</resultMap>
    1. 定义sql语句
    <select id="findAll" resultMap="userRoleMap">
   SELECT r.id as rid,r.role_name,r.role_desc,u.* FROM mybatisuser u
   left outer join user_role ur on u.id=ur.uid
   left outer join role r on r.id=ur.rid;
</select>
    1. 编写测试方法
    public class UserRoleTest {
   public static void main(String[] args) throws IOException {

   }
   private InputStream in;
   private SqlSession sqlSession;
   private UserRoleDao userRoleDao;
   @Before
   public void init() throws IOException {
      //1. 读取配置文件
      in = Resources.getResourceAsStream("SqlMapConfig.xml");
      //2. 使用ServletContext对象的getRealPath()
      //2. 创建SqlSessionFactory工厂
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory factory = sqlSessionFactoryBuilder.build(in);
      //3. 使用工厂生产SqlSession对象
      sqlSession = factory.openSession();
      //4. 使用SqlSession创建Dao接口的代理对象
      userRoleDao = sqlSession.getMapper(UserRoleDao.class);
   }
   @After
   public void destory() throws IOException {
      //6.事务的提交
      sqlSession.commit();
      //7. 释放资源
      sqlSession.close();
      in.close();
   }

   @Test
   public void testFindAll(){
      //5. 使用代理对象执行方法
      List<UserRole> userRoles = userRoleDao.findAll();
      for (UserRole userRole : userRoles){
            System.out.println("用户"+userRole.getId()+"--------------------");
            System.out.println(userRole);
            System.out.println(userRole.getRoleUsers());
      }
   }
}
    1. 输出结果
      在这里插入图片描述

JNDI

  1. 基本概念
    1. JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口
    2. JNDI仿windows的注册表，通过key：value实现
      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TBAg2OHA-1610768096586)(JNDI.png)]
  2. 新建MAVEN-webapp工程，配置目录
  3. 导入依赖
<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.5</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.21</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
    </dependency>
  1. 配置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">
<configuration>
    <typeAliases>
        <package name="domain"/>
    </typeAliases>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"/>
            <dataSource type="JNDI">
                <property name="data_source" value="java:comp/env/jdbc/my_jndi_test"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="dao/MybatisUserDao.xml"/>
    </mappers>
</configuration>
  1. 在webapp目录下新建目录MATE-INF，在MATE-INF下创建context.xml
<?xml version="1.0" encoding="UTF-8"?>
<Context>
<!-- 
<Resource 
name="jdbc/my_jndi_test"                                    数据源的名称
type="javax.sql.DataSource"                                 数据源类型
auth="Container"                                            数据源提供者
maxActive="20"                                              最大活动数
maxWait="10000"                                             最大等待时间
maxIdle="5"                                                 最大空闲数
username="root"                                             用户名
password="fy123"                                            密码
driverClassName="com.mysql.cj.jdbc.Driver"                  驱动类
url="jdbc:mysql://localhost:3306/my_db?serverTimezone=UTC"  连接url字符串
/>
 -->
<Resource 
name="jdbc/my_jndi_test"
type="javax.sql.DataSource"
auth="Container"
maxActive="20"
maxWait="10000"
maxIdle="5"
username="root"
password="fy123"
driverClassName="com.mysql.cj.jdbc.Driver"
url="jdbc:mysql://localhost:3306/my_db?serverTimezone=UTC"
/>
</Context>
  1. 编写index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<%@ page import="org.apache.ibatis.io.Resources" %>
<%@ page import="org.apache.ibatis.session.SqlSessionFactoryBuilder" %>
<%@ page import="org.apache.ibatis.session.SqlSessionFactory" %>
<%@ page import="dao.MybatisUserDao" %>
<%@ page import="domain.MybatisUser" %>
<%@ page import="java.util.List" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="org.apache.ibatis.session.SqlSession" %>
<html>
<body>
<h2>Hello World!</h2>
<%
    InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory = sqlSessionFactoryBuilder.build(in);
    SqlSession sqlSession = factory.openSession();
    MybatisUserDao userDao = sqlSession.getMapper(MybatisUserDao.class);
    List<MybatisUser> users = userDao.findAll();
    for (MybatisUser user : users){
        System.out.println(user);
    }
    sqlSession.close();
    in.close();
%>
</body>
</html>
一大岐
关注
专栏目录
mybatis多表查询.zip
08-06
本资料“mybatis多表查询.zip”着重讲解了如何在MyBatis中实现多表查询，这对于构建复杂业务逻辑的系统来说是至关重要的。以下是对这个主题的详细阐述： 1. **MyBatis简介** MyBatis是由Apache基金会维护的一个...
MyBatis（跨表查询）
Fred's Note
01-19 807
1、建立数据库表如下： DROP TABLE IF EXISTS t_demo_user; CREATE TABLE IF NOT EXISTS t_demo_user( userid varchar(255), username varchar(100), password varchar(100), PRIMARY KEY(userid) )ENGINE=I...
mybatis实现跨库多表查询
热门推荐
Less Is More
09-04 2万+
需求：查询用户名具体负责的项目的名称 已有数据库表如下所示，二者通过项目ID关联   test数据库的user表   test1数据库的project表   需要实现的SQL查询 select user.id,user.name,projectName from test.user left join test1.project on user.`projectId`=pr...
MyBatis—多表查询
最新发布
rxdasd123456的博客
06-25 804
本次主要写了关于mybatis的多表查询相关问题，延迟加载，动态sql，缓存，分页，逆向工程等功能的介绍和实现
MyBatisPlus分页插件查跨表的分页(SpringBoot环境)
qq_58291481的博客
06-03 852
我们知道MyBatisPlus的分页插件是操作对应的表来查询的,如果要展示的数据跨表,该如何查询展示?
[MyBatis系列⑤]多表查询 | 一篇万字长文带你上手三种多表查询方式及其对象封装过程
逐梦苍穹的博客
08-27 2254
本文介绍mybatis的三种多表查询方式及其对象封装过程
Mybatis实现多表查询的方式
记录点点滴滴的成长。
06-25 5022
Mybatis实现多表查询的方式（一对多、一对一、多对多）
MyBatis多表查询
01-07
MyBatis多表查询
Mybatis基于注解实现多表查询功能
08-25
Mybatis基于注解实现多表查询功能 Mybatis基于注解实现多表查询功能是指使用Mybatis框架中的注解来实现多表查询的功能。这种方法可以简化配置，提高开发效率。下面我们将详细介绍如何使用Mybatis基于注解实现多表...
MyBatis多表连接
10-17
本文将深入探讨MyBatis如何处理多表连接查询，结合具体的实例，包括学生表、课程表和关系表，来阐述这个主题。 首先，我们需要了解在SQL中，多表连接是用于从多个相关的表中获取数据的关键方法。MyBatis通过动态SQL...
MyBatis 中如何使用多表查询
stormjun的博客
07-11 1591
本文介绍了 MyBatis 中如何使用多表查询，包括使用嵌套查询、使用关联查询和使用动态 SQL 等方式。在实际开发中，我们可以根据具体的业务需求和数据结构，选择合适的方式进行多表查询。使用嵌套查询和关联查询的方式比较简单直观，适合查询较少的表，而使用动态 SQL 的方式则可以根据条件动态生成 SQL 语句，具有更高的灵活性，适合查询较多的表和复杂的数据结构。在使用 MyBatis 进行多表查询时，需要注意以下几点：确定查询的表和关系。
用MyBatis实现表的一对多关联查询
12-05
使用MyBatis写的一对多关联映射查询的web，在eclipse上写的，使用的Mysql进行数据连接，内含数据库脚本，直接导入数据库即可建数据库和建表，不用再编写，非常方便
Mybatis 一对多关联查询（两种方法）
04-26
NULL 博文链接：https://qihaibo1989.iteye.com/blog/2354597
Mybatis之多表查询
weixin_73509711的博客
01-04 2551
MyBatis 是一个优秀的持久层框架，它提供了强大的支持来执行数据库操作，包括多表查询。多表查询是指从多个数据库表中检索数据的过程，这在实际的应用中非常常见。
Mybatis多表联查的几种办法
weixin_51667449的博客
05-20 2万+
开发过程中，对数据库多表连接查询是常规操作。Mybatis（plus）在多表连接查询上提供了很好的支持。通常，表与表之间存在四种映射关系：一对一映射、多对一映射、一对多映射、多对多映射。在处理的过程中，多对一和一对一映射一般采用同一种操作方式，一对多和多对多映射一般采用同一种操作方式。而且，对于Mybatis的运用，我们通常使用xml的方式。因此，本文主要介绍xml方式下一对一多表联查和一对多多表联查。
MyBatis——MyBatis实现多表查询
m0_68519425的博客
05-31 3093
resultMap中的常见属性级联查询和多表查询的比较及其选择ResultType和ResultMap使用场景1) 如果你做的是单表的查询并且封装的实体和数据库的字段一一对应 resultType2) 如果实体封装的属性和数据库的字段不一致 resultMap3) 使用N+1级联查询的时候 resultMap4) 使用的是多表的连接查询 resultMap一对一关联映射的实现1) 实例：学生和学生证、雇员和工牌2) 数据库层次：主键关联或者外键关联（参看之前内容）
mybatis多表查询
随便写写
05-15 2104
对之前的mybatis多表查询做xml方式的补充
mybatis03-多表查询、延迟加载、逆向工程
weixin_53903929的博客
04-18 710
mybatis多表查询（一对一、一对多(多对一）、多对多）、mybatis延迟加载、mybatis逆向工程
mybatis中的多表查询
m0_62969222的博客
07-26 6202
级联查询，分步查询，collection，association
mybatis 多表查询
08-08
MyBatis是一个开源的持久层框架，可以用于与关系型数据库进行交互。...需要注意的是，多表查询可能会导致性能问题，因此在设计和执行多表查询时，应考虑到数据库索引、查询条件和数据量等因素，以优化查询性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一大岐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值