Mybatis处理复杂查询环境

最新推荐文章于 2024-07-27 21:01:43 发布
最新推荐文章于 2024-07-27 21:01:43 发布
阅读量303 收藏
点赞数
分类专栏： mybatis 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xry12354/article/details/131543173
版权
本文介绍了在Mybatis中处理多对一和一对多关系映射的方法，通过创建数据表、配置文件、Mapper接口和XML文件，展示了如何使用association和collection进行复杂查询。示例包括从协调人角度获取多个工作者和从工作者角度获取一个协调人的例子，以及两种不同的处理方式。
摘要由CSDN通过智能技术生成

复杂查询环境

多对一和一对多

多个工作者对应一个协调人

对于工作者(worker)而言，多个工作者关联一个协调人(coordinator)（多对一，关联）
对于协调人而言，一个协调人有很多工作者（一对多，集合）
在程序开发中，也会遇到类似的情况，这时就会涉及到Mybatis中结果映射的association 和 collection

实例

创建数据表

coordinator表

CREATE TABLE `coordinator`(
	`id` INT(10) NOT NULL,
    `name` VARCHAR(30) DEFAULT NULL,
    PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO coordinator(`id`, `name`) VALUES(1, "Alex");

worker表

CREATE TABLE `worker`(
	`id` INT(10) NOT NULL,
    `name` VARCHAR(30) DEFAULT NULL,
    `cid` INT(10) DEFAULT NULL,
    PRIMARY KEY (`id`),
    FOREIGN KEY (`cid`) REFERENCES `coordinator` (`id`) 
)ENGINE = INNODB DEFAULT CHARSET=utf8mb4;

INSERT INTO `worker` (`id`, `name`, `cid`) VALUES (1, '小明', '1');
INSERT INTO `worker` (`id`, `name`, `cid`) VALUES (2, '小红', '1');
INSERT INTO `worker` (`id`, `name`, `cid`) VALUES (3, '小方', '1');
INSERT INTO `worker` (`id`, `name`, `cid`) VALUES (4, '小芳', '1');
INSERT INTO `worker` (`id`, `name`, `cid`) VALUES (5, '小王', '1');
环境搭建

创建核心配置文件(mybatis-config.xml)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="db.properties"/>
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>
    <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>
</configuration>

创建配置文件(db.properties)

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

创建工具类(MybatisUtil)

public class MybatisUtil {
    private  static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}
文件准备

①导入相关依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.13</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.16</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.28</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

②新建实体类

Coordinator类

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

Worker类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Worker {
    private int id;
    private String name;
    //工作者需要关联协调人
    private Coordinator coordinator;
}

③创建Mapper接口

CoordinatorMapper

public interface CoordinatorMapper {
    @Select("select * from coordinator where id = #{cid}")
    Coordinator select(@Param("cid") int id);
}

WorkerMapper

public interface WokerMapper {
}

④创建Mapper.xml

CoordinatorMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.louis.dao.CoordinatorMapper">

</mapper>

WorkerMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.louis.dao.WokerMapper">

</mapper>

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

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="db.properties"/>
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>
    <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.louis.dao.CoordinatorMapper"/>
        <mapper class="com.louis.dao.WokerMapper"/>
    </mappers>
</configuration>

⑥测试是否成功

public class MyTest {
    static Logger logger = Logger.getLogger(MyTest.class);
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        CoordinatorMapper mapper = sqlSession.getMapper(CoordinatorMapper.class);
        Coordinator select = mapper.select(1);
        logger.info(select);
        sqlSession.close();
    }
}
//注意导入Logger为：import org.apache.log4j.Logger;

在这里插入图片描述

特别提醒：以上只是为了测试配置文件是否正确。

多对一处理

WorkerMapper接口

public interface WorkerMapper {
    //查询所有的工作人员和它们对应的协调人的信息
    List<Worker> getWorker2();
    List<Worker> getWorker();
}
方式一(按照查询嵌套处理)

WorkerMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.louis.dao.WorkerMapper">
        <!--<select id="getWorker" resultType="com.louis.pojo.Worker">-->
                <!--
                思路：
                1、查询所有的工作人员信息
                2、根据查询出来的工作人员的cid,寻找对应的协调人
                -->
                <!--select w.id, w.name, 
					c.name from worker as w, 
					coordinator as c 
					where w.tid = c.id;-->
                <!--select * from worker;-->
        <!--</select>-->
        <select id="getWorker" resultMap="WorkerCoordinator">
                select * from worker;
        </select>
        <resultMap id="WorkerCoordinator" type="com.louis.pojo.Worker">
            	<!--column 数据库中的字段， property实体类中的属性-->
                <result property="id" column="id"/>
                <result property="name" column="name"/>
                <!--复杂的属性我们需要单独做处理 对象使用association 集合使用collection-->
                <association property="coordinator" column="cid" javaType="com.louis.pojo.Coordinator" select="getCoordinator"/>
        </resultMap>
        <select id="getCoordinator" resultType="com.louis.pojo.Coordinator">
                select * from coordinator where id = #{id};
        </select>
</mapper>

测试

@Test
public void getWorker(){
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    WorkerMapper mapper = sqlSession.getMapper(WorkerMapper.class);
    List<Worker> worker = mapper.getWorker();
    System.out.println("worker = " + worker);
    sqlSession.close();
}

//结果
worker = [Worker(id=1, name=小明, coordinator=Coordinator(id=1, name=Alex)), 
Worker(id=2, name=小红, coordinator=Coordinator(id=1, name=Alex)), 
Worker(id=3, name=小方, coordinator=Coordinator(id=1, name=Alex)), 
Worker(id=4, name=小芳, coordinator=Coordinator(id=1, name=Alex)), 
Worker(id=5, name=小王, coordinator=Coordinator(id=1, name=Alex))]
方式二(按照结果嵌套处理)

WorkerMapper.xml

<!--
方式二：按照结果嵌套处理
思路：
   1、查询所有的工作人员信息
   2、根据查询出来的工作人员的cid,寻找对应的协调人
-->
<select id="getWorker2" resultMap="WorkerCoordinator02">
        <!--使用我们常用的查询语句,并且相应的给一些别名-->
        select w.id as wid, w.name as wname, c.name as cname
        from worker as w, coordinator as c
        where w.cid = c.id;
</select>
<resultMap id="WorkerCoordinator02" type="com.louis.pojo.Worker">
        <result property="id" column="wid"/>
        <result property="name" column="wname"/>
        <association property="coordinator" javaType="com.louis.pojo.Coordinator">
                <result property="name" column="cname"/>
        </association>
</resultMap>

测试

@Test
public void getWorker2(){
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    WorkerMapper mapper = sqlSession.getMapper(WorkerMapper.class);
    List<Worker> worker = mapper.getWorker2();
    System.out.println("worker = " + worker);
    sqlSession.close();
}

//结果 
worker = [Worker(id=1, name=小明, coordinator=Coordinator(id=1, name=Alex)), 
Worker(id=2, name=小红, coordinator=Coordinator(id=1, name=Alex)), 
Worker(id=3, name=小方, coordinator=Coordinator(id=1, name=Alex)), 
Worker(id=4, name=小芳, coordinator=Coordinator(id=1, name=Alex)), 
Worker(id=5, name=小王, coordinator=Coordinator(id=1, name=Alex))]

一对多处理

比如一个协调人对应多个工作人员，对于协调人而言，就是一对多的关系，除了实体类外和多对一的环境相同。

实体类

Worker

public class Worker {
    private int id;
    private String name;
    private int cid;
}

Coordinator

public class Coordinator {
    private int id;
    private String name;
    //一个协调人协调多个工作人员
    private List<Worker> worker;
}

CoordinatorMapper接口

public interface CoordinatorMapper {
    //获取指定协调人下的所有工作人员和协调人的信息
    Coordinator getCoordinatorTarget(@Param("cid") int cid);
    Coordinator getCoordinatorTarget01(@Param("id") int id);
}
方式一(按照查询嵌套处理)

CoordinatorMapper.xml

<!--按查询嵌套处理-->
<select id="getCoordinatorTarget01" resultMap="CoordinatorWorker01">
    select * from mybatis.coordinator where id = #{id}
</select>
<resultMap id="CoordinatorWorker01" type="com.louis.entity.Coordinator">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <collection property="worker" javaType="ArrayList" ofType="com.louis.entity.Worker" select="getWorkerById" column="id"/>
</resultMap>
<select id="getWorkerById" resultType="com.louis.entity.Worker">
    select * from worker where cid = #{id}
</select>

测试

@Test
public void myTest01(){
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    CoordinatorMapper mapper = sqlSession.getMapper(CoordinatorMapper.class);
    Coordinator coordinatorTarget = mapper.getCoordinatorTarget(1);
    System.out.println("coordinatorTarget = " + coordinatorTarget);
    sqlSession.close();

coordinatorTarget = Coordinator(id=1, name=Alex, 
	worker=[Worker(id=1, name=小明, cid=0),
			Worker(id=2, name=小红, cid=0),
			Worker(id=3, name=小方, cid=0),
			Worker(id=4, name=小芳, cid=0),
			Worker(id=5, name=小王, cid=0)])
方式二(按照结果嵌套处理)

CoordinatorMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.louis.dao.CoordinatorMapper">
<!--按结果嵌套查询-->
    <select id="getCoordinatorTarget" resultMap="CoordinatorWorker">
        select c.id, c.`name`, w.id as wid, w.`name`as wname
        from coordinator as c, worker as w
        where c.id = w.cid and c.id = #{cid}
    </select>
    <resultMap id="CoordinatorWorker" type="com.louis.entity.Coordinator">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--复杂的属性我们需要单独做处理 对象使用association 集合使用collection
        javaType=""指定属性的类型，集合中泛型信息我们需要使用的是ofType
        -->
        <collection property="worker" ofType="com.louis.entity.Worker">
            <result property="id" column="wid"/>
            <result property="name" column="wname"/>
        </collection>
    </resultMap>
</mapper>

测试

@Test
public void myTest02(){
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    CoordinatorMapper mapper = sqlSession.getMapper(CoordinatorMapper.class);
    Coordinator coordinator = mapper.getCoordinatorTarget01(1);
    System.out.println("coordinator = " + coordinator);
    sqlSession.close();

//结果
coordinatorTarget = Coordinator(id=1, name=Alex, 
	worker=[Worker(id=1, name=小明, cid=0),
 			Worker(id=2, name=小红, cid=0),
			Worker(id=3, name=小方, cid=0),
 			Worker(id=4, name=小芳, cid=0),
 			Worker(id=5, name=小王, cid=0)])

注意：使用association用于(多对一) 和collection用于(一对多)，此外

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

ofType用来指定映射到List或集合中的pojo类型，泛型中的约束类型。如：List<worker>

LouieA
关注
专栏目录
MyBatis性能调优——优化SQL查询和分页查询速度
程序员光剑
07-28 2629
MyBatis 是 MyBatis SQL Mapper Framework 的简称，是一个 Java 框架，用于存取数据库中的数据。MyBatis 将 sql 映射到 java 对象上，并将对象映射成 sql，最终实现对关系数据库进行持久化操作。MyBatis 使用 xml 或注解的方式来配置映射关系，并通过 xml 文件或注解来生成mybatis核心配置文件 mybatis-config.xml，然后再根据具体的业务需要编写 mapper 文件。
Mybatis 复杂查询 多对一 和一对多
0629的博客
05-26 312
Student(id=1, name=小明, teacher=Teacher(id=1, name=秦老师))Student(id=2, name=小红, teacher=Teacher(id=1, name=秦老师))Student(id=3, name=小张, teacher=Teacher(id=1, name=秦老师))Student(id=5, name=小王, teacher=Teacher(id=1, name=秦老师))Student(id=2, name=小红, tid=1),
使用Mybatis框架完成复杂查询
m0_49692893的博客
04-09 1916
前言 前面的所演示的只是在单表上实现CRUD，而在真实的项目中存在更复杂的查询通常涉及到多表之间的复杂查询。所以本章记录使用Mybatis框架完成复杂查询操作。 一、环境搭建 前置要求：建表 CREATE TABLE `teacher` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 INSERT INTO teac
Mybatis复杂查询
最新发布
o0way0o的博客
07-27 447
【代码】Mybatis复杂查询。
MyBatis-一对多、多对一
Adelagirl的博客
02-24 286
一对多和多对一，是一个相对的概念。 以老师和学生为例，最常见的情况就是：一个老师教授很多学生。站在学生的角度，是很多学生被一个老师教，即很多学生关联一个老师（多对一）；站在老师的角度，是一个老师教授很多学生，即一个老师有多个学生（一对多）。 在MyBatis中，处理多对一的问题使用 association标签（关联）；处理一对多的问题使用 collection标签（集合）。 多对一 按照查询嵌套...
MyBatis的复杂查询
程序员光剑
01-18 897
1.背景介绍 MyBatis是一款流行的Java持久化框架，它可以简化数据库操作，提高开发效率。MyBatis的核心功能是将SQL查询语句与Java代码分离，使得开发人员可以更加方便地编写和维护数据库操作。 在实际开发中，我们经常需要处理复杂的查询，例如包含多个表的查询、分组、排序、聚合等操作。这些查询可能会涉及到复杂的SQL语句和多个参数。为了更好地处理这些复杂查询，MyBatis提供了一系...
mybatis复杂查询
vcoy的博客
10-26 452
mybatis
MyBatis分页查询与特殊字符处理
liaozhixiangjava的博客
08-24 1349
MyBatis是一种基于Java的持久层框架，它实现了对数据库的操作，并使用Java对象映射关系表中的记录，即将关系数据库中的数据映射到Java对象中，提供了一种优雅的方式来访问关系数据库。MyBatis最重要的特点是它的SQL映射，使得开发人员可以使用XML或注解的方式将SQL语句与Java代码进行解耦，从而提高了代码的可维护性和可读性，并降低了整个应用程序的复杂度。MyBatis还支持动态SQL，这意味着你可以在不同的场景下根据不同的条件来生成SQL查询语句。
InfluxDB查询 导出数据 mybatis SpringBoot
07-22
InfluxDB具有高写入和查询性能，支持复杂的查询语言（InfluxQL），允许用户执行实时分析。在描述中提到的"InfluxDB查询 导出数据"，意味着我们需要了解如何通过InfluxDB的API或者InfluxQL来检索并导出数据，这对于...
SpringBoot-Mybatis处理事务
08-15
总的来说，SpringBoot结合Mybatis处理事务主要是通过Spring的声明式事务管理机制，配合`@Transactional`注解来实现事务的自动回滚和提交。在实际项目中，还需要注意事务的隔离级别、超时设置以及回滚规则的配置，以...
mybatis 复杂查询
xcc_2269861428的博客
07-22 549
1、定义sql语句，减少我们经常手写的字段 例子： select id,name,age from user 可以写成 <sql id="col"> id,name,age</sql>,select<include refid="col" /> fromuser 这样以后如果用到上面的字段或者修改col中某个字段，我们只需要修改col就好，不...
mybatis的复杂sql查询
weixin_45063957的博客
03-21 2557
在利用mybatis做查询的时候，一般返回结果用resulttype，这种情况必须是查询的结果在对应 的pojo类中有对应的，一般都是单表查询，但是对于一些复杂的情况，比如需要用到多表查询的时候，resultType不再适用，此时一般用resultMap来表示返回的结果。 resultMap类似于一个hashmap，里面的数据库中的字段与pojo类中的字段的映射， associate的使用--- 一对一关联查询 对象里面包含一个其他对象： 如video是一个pojo类，但是其属性里面..
MyBatis复杂查询【MyBatis笔记四】
yuyu的博客
02-01 556
目录 1.in 查询 2.like 模糊查询 3.between and 区间查询 4.分⻚ 方式一：RowBounds 逻辑分页 方式二：pageHelper分页插件 物理分页 优缺点 5.resultMap 处理列名不一致问题(多表查询) 1.in 查询 (StudentMapper2.xml) 中添加 foreach 标签 <select id="finda" resultType="student"> select * from student where .
Mybatis-复杂查询实现
weixin_49512993的博客
09-02 140
Mybatis-复杂查询实现 十、复杂查询实现 1、环境搭建 搭建数据库 use mybatis CREATE TABLE `teacher` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 INSERT INTO teacher(`id`, `name`) VALUES (1, "秦老师"); CREATE
MyBatis 实现复杂 Sql 查询
一个双子座的Java攻城狮
12-27 1230
但是在某些业务场景下，可能只需要学生的信息或者教室的信息，而不需要两者的联表数据，这种时候就可以使用懒加载。resultMap 元素是 MyBatis 中最重要最强大的元素，之前所写的 sql 语句，返回值都是简单的基本数据类型或者某一个实体类，比如下面这段 sql 返回的就是最简单的 User 类型。依旧是通过结果嵌套查询的方式，通过 sql 语句查询出结果，再通过 resultMap 进行组装，一对多查询用的是 collection。接着编写 Mapper 接口和对应的 Mapper.xml。
MyBatis 实现复杂查询
weixin_60257917的博客
03-11 806
SQL注入就是指服务器对用户输入的数据过滤不严谨, 使得攻击者在输入数据之后添加了SQL语句, 从而获得了非法的权限.例如, 我们登录操作需要用户输入 账号 和 密码此时黑客就可通过SQL注入的方式,不需要知道账号密码 也能获取数据。
Mybatis-复杂查询
weixin_45445291的博客
04-09 734
Mybatis-复杂查询 1. 测试环境搭建 导入lombok 新建实体类Teacher， Student 建立Mapper接口 建立Mapper.xml文件 在核心配置中绑定注册Mapper接口或者文件 测试查询是否能够成功 2. 复杂查询 实体类： // 学生 package com.kangzhu.pojo; import lombok.Data; @Data public class Student { private int id; private String name;
MyBatis框架详解：环境搭建与核心接口
MyBatis是一个强大的持久层框架，它专注于SQL查询、存储过程和高级映射，极大地简化了Java开发者与数据库交互的过程。通过消除手动设置JDBC代码和处理结果集的需求，MyBatis使得开发者能够更专注于业务逻辑。 **一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值