初学Mybatis之多对一查询 association 和一对多查询 collection

于 2024-07-28 22:17:33 发布
阅读量548 收藏 3
点赞数 9
文章标签： mybatis sql 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58838332/article/details/140751693
版权

XML 映射器

多对一：关联（association）

一对多：集合（collection）

mysql 创建教师、学生表，插入数据

create table `teacher`(
	id int(10) primary key,
    `name` varchar(30) default null
) engine=InnoDB default charset=utf8;

insert into teacher (id,`name`) values (1,'教师');

create table `student`(
	id int(10) not null,
    `name` varchar(30) default null,
    tid int(10) default null,
    primary key (id),
    key fktid (tid),
    constraint fktid foreign key (tid) references `teacher` (id)
) engine=InnoDB default charset=utf8;

insert into student (id,`name`,tid) values (1,'学生1',1);
insert into student (id,`name`,tid) values (2,'学生2',1);
insert into student (id,`name`,tid) values (3,'学生3',1);

pom.xml 导入相应 jar 包

  <dependencies>
    <!-- mysql驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.33</version>
    </dependency>

    <!-- mybatis驱动 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.16</version>
    </dependency>

    <!-- junit驱动 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
    </dependency>

    <!-- lombok驱动 -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.34</version>
    </dependency>
  </dependencies>

  <!-- 在build中配置resources，防止资源导出失败 -->
  <build>
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
          <include>**/*.properties</include>
        </includes>
      </resource>

      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.xml</include>
          <include>**/*.properties</include>
        </includes>
      </resource>
    </resources>
  </build>

resources 目录下创建 db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8
username=root
password=root

resources 目录下创建 mybatis-config.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核心配置文件 -->
<configuration>

    <!-- 引入外部配置文件 -->
    <properties resource="db.properties"/>

    <settings>
        <!-- 日志工厂实现 -->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!-- 扫描实体类的包 -->
    <typeAliases>
        <package name="com.demo.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper class="com.demo.dao.TeacherMapper"/>
        <mapper class="com.demo.dao.StudentMapper"/>
    </mappers>

</configuration>

MybatisUtils 工具类：

package com.demo.utils;

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 java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

        /*
        有了SqlSessionFactory，就可以获得SqlSession的实例
        SqlSession提供了在数据库执行SQL命令所需的所有方法
        可以通过SqlSession实例来执行已映射的SQL语句
         */
        public static SqlSession getSqlSession(){
            return sqlSessionFactory.openSession(true);
        }
}

实体类与表字段一致

Teacher 类：

package com.demo.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    private int id;
    private String name;
}

 Student 类：

（因为 tid 设置了外键，直接写 int tid 则无法关联，所以通过组合的方式关联进来）

package com.demo.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    //多个学生关联一个老师
    private Teacher teacher;
}

TeacherMapper 接口：

import com.demo.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface TeacherMapper {
    @Select("select * from teacher where id = #{tid}")
    Teacher getTeacher(@Param("tid") int id);
}

 同理，写个 StudentMapper 接口

resources 目录创建同包名

TeacherMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.demo.dao.TeacherMapper">

</mapper>

同理，创建 StudentMapper.xml

在核心配置文件 mybatis-config.xml 绑定注册：

    <mappers>
        <mapper class="com.demo.dao.TeacherMapper"/>
        <mapper class="com.demo.dao.StudentMapper"/>
    </mappers>

测试类：

package com.demo.dao;

import com.demo.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        System.out.println(mapper.getTeacher(1));
        sqlSession.close();
    }
}

输出结果：

测试环境搭建步骤：

1.导入 Lombok 依赖

2.新建实体类 Teacher、Student

3.建立 Mapper 接口

4.建立 Mapper.xml 文件

5.在核心配置文件中绑定注册 Mapper 接口或者文件

6.测试查询是否成功

多对一处理：

StudentMapper 实体类：

package com.demo.dao;

import com.demo.pojo.Student;

import java.util.List;

public interface StudentMapper {
    //查询所有学生信息，以及对应教师信息
    List<Student> getStudent();
}

方法一：查找嵌套，根据查询出来的学生 tid，寻找对应的教师

StudentMapper.xml：

关联：association

集合：collection

javaType：对象类型

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.demo.dao.StudentMapper">
    <select id="getStudent" resultMap="tid">
        select * from student
    </select>
    <resultMap id="tid" type="student">
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <!-- 关联：association -->
        <!-- 集合：collection -->
        <!-- javaType：对象类型 -->
        <association property="teacher" column="tid" javaType="teacher" select="getTeacher"/>
    </resultMap>

    <select id="getTeacher" resultType="teacher">
        select * from teacher where id = #{tid}
    </select>
</mapper>

association 关联的 property 是 Student 类的组合

 测试类：遍历数组

package com.demo.dao;

import com.demo.pojo.Student;
import com.demo.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MyTest {
    @Test
    public void getStudent(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> studentList = mapper.getStudent();
        for(Student student : studentList){
            System.out.println(student);
        }
        sqlSession.close();
    }
}

 运行结果如下：

方法二：结果嵌套

StudentMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.demo.dao.StudentMapper">
    <select id="getStudent" resultMap="tid">
        select s.id sid,s.name sname,s.tid stid,t.name tname from student s,teacher t where s.tid = t.id;
    </select>
    <resultMap id="tid" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
            <result property="id" column="stid"/>
        </association>
    </resultMap>
</mapper>

 结果如下：

Mybatis 多对一查询方式：

1.子查询

2.联表查询 

一对多处理：

Student 类：

package com.demo.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    private int tid;
}

Teacher 类：

package com.demo.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    private int id;
    private String name;
    //一名教师教导多名学生
    private List<Student> students;
}

 TeacherMapper 接口：

package com.demo.dao;

import com.demo.pojo.Teacher;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface TeacherMapper {
    List<Teacher> getTeacher();

    //获取指定教师下所有学生及教师的信息
    Teacher getTeacherById(@Param("tid") int id);
}

TeacherMapper.xml：

方法一：结果嵌套查询

javaType 指定属性的类型，ofType 应用于集合中的泛型信息

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.demo.dao.TeacherMapper">

    <select id="getTeacher" resultType="teacher">
        select * from teacher
    </select>

    <!-- 结果嵌套查询 -->
    <!-- resultMap 结果集映射 -->
    <select id="getTeacherById" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.name tname,t.id tid
        from student s,teacher t
        where s.tid = t.id and t.id = #{tid};
    </select>
    <resultMap id="TeacherStudent" type="teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!-- 集合：collection -->
        <!-- javaType指定属性的类型，ofType应用于集合中的泛型信息 -->
        <collection property="students" ofType="student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
</mapper>

测试类：

package com.demo.dao;

import com.demo.pojo.Teacher;
import com.demo.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyTest {
    @Test
    public void getTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        for (Teacher teacher : mapper.getTeacher()) {
            System.out.println(teacher);
        }
        sqlSession.close();
    }

    @Test
    public void getTeacherById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        System.out.println(mapper.getTeacherById(1));
        sqlSession.close();
    }
}

运行结果：

方法二：查询嵌套

    <select id="getTeacherById" resultMap="TeacherStudent">
        select * from teacher where id = #{tid}
    </select>

    <resultMap id="TeacherStudent" type="teacher">
        <collection property="students" javaType="ArrayList" ofType="student" select="tid" column="id"/>
    </resultMap>

    <select id="tid" resultMap="student">
        select * from student where tid = #{tid}
    </select>

总结：

1.关联：association（多对一）

2.集合：collection（一对多） 

3. javaType 用来指定实体类中属性的类型

4. ofType 用来指定映射到 List 或集合中的 pojo 类型，泛型中的约束类型

注意点：

1.保证 SQL 可读性

2.注意一对多或多对一属性名和字段

3.使用 Log4j 日志排查错误

综上，还需了解 Mysql 引擎、InnoDB 底层原理、索引、索引优化等

m0_58838332
关注
  • 9
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Mybatis—一对一和一对多查询
qq_32015565的博客
04-13 193
文章目录Mybatis的查询一对一查询一对多查询 重新记录mybatis表查询 Mybatis的查询 一对一查询 连接词：association 数据表：作者表author 文章表article 描述：一个作者发表一篇文章 xml: <mapper namespace="com.liwang.mybatis02.mapper.AuthorMapper"> <resultMap id="AuthorMap" type="com.liwang.mybatis02.model.Auth
MyBatis 一对一、一对多的
wocao003的专栏
04-10 303
package com.baidu.model; import java.io.Serializable; import java.util.List; /** * * @author hongxiaolong * 20105-04-08 * 接口Serializable表示可以用流的方式传输 （stream） * */ public class Student implem
Mybatis实现高级映射一对一、一对多查询
weixin_30814329的博客
04-08 160
终于把论文写得差不多了，系统也不急着完成，可以抽出点时间来完成这个系列的博客了。在写本博客之前我是惶恐不安的，高级映射一贯是持久层框架里的重中之重，小到自己开发小系统，大到企业级开发，表的存在从来就不独立的。复杂交错的表之间的联系有时的确让后台开发人员头疼，而作为一个框架，要做的事就是把这种复杂程度降到最低。既然如此，我们就赶快进入正文吧。 先说一对一吧，前几篇博文里用到了User类，今天我们再...
Mybatis多对一的处理——按照结果嵌套处理
yooppa的博客
05-19 217
建立在之前多对一的按照查询结果嵌套的处理配置有相关的.xml文件及其其他的基础上，添加按照结果嵌套处理方法。 <select id="getStudents2" resultMap="getteacher"> select s.id sid ,s.name sname , t.name tname from student s,teacher t where s.tid=t.id </select> <result
MyBatis 多表查询之一对多、多对一、多对多以及数据库资料.rar
09-28
本资料包主要涵盖了MyBatis中的一对多、多对一、多对多这三种关系的查询方法，并结合了相关的数据库知识。 首先，我们来了解MyBatis中的“一对多”关系。在数据库设计中，一对多关系意味着一个父表记录可以与多个子...
Mybatis官方网址跟进学习视频的查询例题
01-28
6. **关联查询**：在Mybatis中，可以使用`<association>`和`<collection>`标签处理一对一和一对多的关系。 7. **缓存机制**：Mybatis支持本地缓存和二级缓存，可以提高数据读取速度。 在"查询需求例题.docx"文档中...
springboot创建集成的demo，pagehelper分页插件，mybatis集成mysql的一对多，多对多，Swagge
03-21
通过学习和实践，开发者可以深入理解Spring Boot的自动配置原理，掌握PageHelper的分页技巧，了解MyBatis中的一对多和多对多映射，以及熟练使用Swagger构建清晰的API文档。同时，对MySQL的使用也将进一步提升数据库...
mybatisDemo进阶入门有价值的案例，看过不会让你后悔，值得拥有.rar
07-15
2. **关联查询**：MyBatis 支持一对多、多对多等复杂关系的关联查询。在处理实体类之间的关联关系时，可以通过 `<association>` 和 `<collection>` 标签来定义。比如，一个用户可以有多个订单（一对多），而一个订单...
ibatis解决多对一n+1问题（更新上传例子(mybatis)代码）
03-27
1. **使用<association>标签**：在Mapper XML文件中，通过<association>标签可以指定多对一关联关系，MyBatis会自动处理连接查询，避免了多次数据库访问。例如： ```xml <!-- ... --> <association property=...
Sqli-labs-master的21—25通关教程
weixin_68416970的博客
07-25 823
Sqli-labs-master靶场的21、22、23、24、25关教程
SQL进阶：解锁高级特性，深化数据洞察
WayneYalejk的博客
07-24 423
掌握了SQL的基础知识后，进一步探索其高级特性将帮助您更高效地处理复杂数据，深化数据分析的广度和深度。本文将带您领略SQL的高级功能，包括窗口函数、存储过程、触发器以及高级查询技巧等，让您在数据处理的道路上更进一步。通过这两篇文章，读者可以从SQL的基础知识逐步深入到高级特性，全面掌握SQL在数据处理和分析中的强大能力。
SQL核心基础语法—快速入门MySQL
goldfish8848的博客
07-25 547
MySQL其实是DBMS软件系统，也就是说MySQL并不是一个数据库，这是很多人的误区。我们经常听到的Oracle，MySQL，微软SQL Server，都是DBMS软件系统，我们只是通过这些系统来管理和维护数据库而已，DBMS相当于用户和数据库之间的桥梁。目前有超过300种不同的DBMS系统，我们今天要学习的MySQL是关系型数据库，关系型数据库的数据存储模型很像Excel，用行和列组织数据。操作关系型的DBMS系统，大多数都是用SQL来管理数据，学会了SQL，就相当于学会了这些DBMS的核心。
spring —— 事务管理器
最新发布
firstgrass的博客
07-25 572
事务管理主要针对数据源进行操作：在数据库方面，通过 TransactionManager 事务管理器进行管理，表明一旦出现错误，该数据源的所有数据全部复原。那么数据库如何判断是否发生了错误呢？这就需要在代码方面，通过 @Transactional 注解管理相应的方法，表示一旦该方法出现错误，那么由该方法调用的数据就要执行回滚。
Dav_笔记10：Using SQL Plan Management之4
Dav_2099的博客
07-23 527
数据库清除超过53周未使用的计划，由该计划的SMB中存储的LAST_EXECUTED时间戳标识。您可以使用计划名称（plan_name）
数据库实验：SQL Server创建数据库及基本表
sherry__yuzu的博客
07-24 288
1、掌握使用SQL SERVER Management Studio工具连接数据库引擎；2、掌握使用CREATE TABLE 创建基本表的用法；3、掌握使用ALTER TABLE 修改基本表的用法；4、掌握使用DROP TABLE删除基本表的用法；
使用sqlalchemy查询mysql的JSON字段
ithongchou的博客
07-23 193
首先，你需要定义一个与表格对应的模型类。
会Excel就会sql？
svygh123的专栏
07-20 1137
以上就是通过具体的例子来说明Excel中对应的操作，以便更好地对比SQL，通过这些步骤，你可以直观地在Excel中实现类似数据库操作的功能，SQL就像是数据库世界的Excel，但它更加强大，适用于大规模数据处理和复杂的数据关系管理。虽然开始时可能会觉得SQL语法有些抽象，但一旦掌握了基础，你会发现它非常高效且强大，特别是在处理大量数据和执行复杂查询时。就像在Excel中一样，实践中学习SQL会更加有效，尝试编写一些简单的查询，逐渐增加难度，你会很快上手的！
力扣高频SQL 50题（基础版）第九题
m0_70882914的博客
07-24 601
197. 上升的温度
mybatis一对多查询实现association
06-13
Mybatis中可以通过association标签实现一对多查询。association标签用于处理一对一关系，而collection标签用于处理一对多关系。在一对多查询中，通常会在主表中包含一个外键，该外键指向从表中的主键。 下面是一个简单的示例，假设我们有两个表Order和OrderItem，Order表中包含一个外键指向OrderItem表的主键，代码如下： ``` <resultMap id="orderMap" type="Order"> <id property="orderId" column="order_id" /> <result property="orderName" column="order_name" /> <association property="orderItem" resultMap="orderItemMap" /> </resultMap> <resultMap id="orderItemMap" type="OrderItem"> <id property="orderItemId" column="order_item_id" /> <result property="orderItemName" column="order_item_name" /> </resultMap> <select id="selectOrder" resultMap="orderMap"> select * from order o left join order_item oi on o.order_id = oi.order_id where o.order_id = #{orderId} </select> ``` 在上面的示例中，我们定义了两个resultMap，一个用于映射Order表，另一个用于映射OrderItem表。在Order表的resultMap中，我们使用了association标签来处理一对多关系，将Order表中的orderItem属性映射到OrderItem表中，通过resultMap属性指定了OrderItem表的resultMap。 在select语句中，我们通过left join关键字将Order表和OrderItem表关联起来，通过where条件指定了查询的订单ID。最终返回的结果将会是一个Order对象，其中包含一个List<OrderItem>类型的orderItem属性，该属性中包含了该订单对应的所有订单项。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值