快速了解MyBatis---映射关系多对一

最新推荐文章于 2024-07-22 17:40:26 发布
最新推荐文章于 2024-07-22 17:40:26 发布
阅读量1.5k 收藏
点赞数 2
分类专栏： MyBatis 文章标签： tomcat mybatis sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73557631/article/details/132023144
版权

文章目录

映射关系多对一

映射关系-官方文档

文档地址: https://mybatis.org/mybatis-3/zh/sqlmap-xml.html

映射关系多对1-基本介绍

基本介绍

  1. 项目中多对1 的关系是一个基本的映射关系, 多对1, 也可以理解成是1 对多.
  2. User — Pet： 一个用户可以养多只宠物
  3. Dep —Emp : 一个部门可以有多个员工

注意细节

  1. 我们直接讲双向的多对一的关系，单向的多对一比双向的多对一简单。
  2. 在实际的项目开发中, 要求会使用双向的多对一的映射关系
  3. 什么是双向的多对一的关系: 比如通过User 可以查询到对应的Pet, 反过来，通过Pet 也可以级联查询到对应的User 信息.
  4. 多对多的关系，是在多对1 的基础上扩展.

映射关系多对1-映射方式

映射方式

方式1：通过配置XxxMapper.xml 实现多对1

方式2：通过注解的方式实现多对1

配置Mapper.xml 方式-应用实例

需求说明: 实现级联查询,通过user 的id 可以查询到用户信息，并可以查询到关联的pet信息，

​ 反过来，通过Pet 的id 可以查询到Pet 的信息，并且可以级联查询到它的主人User对象信息。

  1. 创建mybatis_user 和mybatis_pet 表
CREATE TABLE mybatis_user
(
        id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(32) NOT NULL DEFAULT ''
)CHARSET=utf8 ;

CREATE TABLE mybatis_pet
(
        id INT PRIMARY KEY AUTO_INCREMENT,
        nickname VARCHAR(32) NOT NULL DEFAULT '',
        user_id INT ,
        FOREIGN KEY (user_id) REFERENCES mybatis_user(id)
)CHARSET=utf8 ;

INSERT INTO mybatis_user
VALUES(NULL,'宋江'),(NULL,'张飞');
INSERT INTO mybatis_pet
VALUES(1,'黑背',1),(2,'小哈',1);
INSERT INTO mybatis_pet
VALUES(3,'波斯猫',2),(4,'贵妃猫',2);

SELECT * FROM mybatis_user;
SELECT * FROM mybatis_pet;

image-20230731145051413

  1. 创建src\main\java\com\nlc\entity\Pet.java
public class Pet {
    private Integer id;
    private String nickname;
    //一个pet对应一个主人 User对象
    private User user;

    public Integer getId() {
        return id;
    }

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

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

}

创建src\main\java\com\nlc\entity\User.java

public class User {
    private Integer id;
    private String name;
    //因为一个user可以养多个宠物,mybatis 使用集合List<Pet>体现这个关系
    private List<Pet> pets;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public List<Pet> getPets() {
        return pets;
    }

    public void setPets(List<Pet> pets) {
        this.pets = pets;
    }

    //这toString会带来麻烦=>会造成StackOverFlow
    //@Override
    //public String toString() {
    //    return "User{" +
    //            "id=" + id +
    //            ", name='" + name + '\'' +
    //            ", pets=" + pets +
    //            '}';
    //}
}

  1. 创建PetMapper.java

    public interface PetMapper {
    //通过User的id来获取pet对象，可能有多个，因此使用List接收
    public List<Pet> getPetByUserId(Integer userId);
    
    //通过pet的id获取Pet对象, 同时会查询到pet对象关联的user对象
    public Pet getPetById(Integer id);
}

    创建UserMapper.java

public interface UserMapper {

    //通过id获取User对象
    public User getUserById(Integer id);

}

  1. 创建UserMapper.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 nameNlcace="com.nlc.mapper.UserMapper">

    <!--解读
    1、一定要想一想我们前面1-1是如何实现
    2、配置/实现 public User getUserById(Integer id);
    3、思路(1) 先通过user-id 查询得到user信息 (2) 再根据user-id查询对应的pet信息
      并映射到User-List<Pet> pets
    -->
    <resultMap id="UserResultMap" type="User">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <!--解读：因为pets属性是集合，因此这里需要是collection标签来处理
        1. ofType="Pet" 指定返回的集合中存放的数据类型Pet
        2. collection 表示 pets 是一个集合
        3. property="pets" 是返回的user对象的属性 pets
        4. column="id" SELECT * FROM `mybatis_user` WHERE `id` = #{id} 返回的id字段对应的值
        -->
        <collection property="pets" column="id" ofType="Pet"
                    select="com.nlc.mapper.PetMapper.getPetByUserId"/>
    </resultMap>
    <select id="getUserById" parameterType="Integer" resultMap="UserResultMap">
        SELECT * FROM `mybatis_user` WHERE `id` = #{id}
    </select>

</mapper>

  2. 创建PetMapper.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 nameNlcace="com.nlc.mapper.PetMapper">

    <!--
        1、通过User的id来获取pet对象，可能有多个，因此使用List接收
        2、public List<Pet> getPetByUserId(Integer userId);
        3. 完成的思路和前面大体相同.
    -->
    <resultMap id="PetResultMap" type="Pet">
        <id property="id" column="id"/>
        <result property="nickname" column="nickname"/>
        <association property="user" column="user_id"
                     select="com.nlc.mapper.UserMapper.getUserById" />
    </resultMap>
    <select id="getPetByUserId" parameterType="Integer" resultMap="PetResultMap">
        SELECT * FROM `mybatis_pet` WHERE `user_id` = #{userId}
    </select>

    <!--说明
        1. 注意体会resultMap带来好处， 直接复用
        2. 实现/配置public Pet getPetById(Integer id);
        3. 通过pet的id获取Pet对象
    -->
    <select id="getPetById"  parameterType="Integer"  resultMap="PetResultMap">
        SELECT * FROM `mybatis_pet` WHERE `id` = #{id}
    </select>
</mapper>

  1. 创建PetMapperTest.java 完成测试

    public class PetMapperTest {
    //属性
    private SqlSession sqlSession;
    private PetMapper petMapper;

    //初始化
    @Before
    public void init() {
        //获取到sqlSession
        sqlSession = MyBatisUtils.getSqlSession();
        petMapper = sqlSession.getMapper(PetMapper.class);
    }

    @Test
    public void getPetByUserId() {
        List<Pet> pets = petMapper.getPetByUserId(2);
        for (Pet pet : pets) {
            System.out.println("pet信息-" + pet.getId() + "-" + pet.getNickname());
            User user = pet.getUser();
            System.out.println("user信息 name-" + user.getName());
        }
        if(sqlSession != null) {
            sqlSession.close();
        }
    }
    
    @Test
    public void getPetById() {
        Pet pet = petMapper.getPetById(2);
        System.out.println("pet信息-" + pet.getId() + "-" + pet.getNickname());
        User user = pet.getUser();
        System.out.println("user信息-" + user.getId() + "-" + user.getName());
        if(sqlSession != null) {
            sqlSession.close();
        }
    }
}

  2. 创建UserMapperTest.java 完成测试

    public class UserMapperTest {

    //属性
    private SqlSession sqlSession;
    private UserMapper userMapper;

    //初始化
    @Before
    public void init() {
        //获取到sqlSession
        sqlSession = MyBatisUtils.getSqlSession();
        userMapper = sqlSession.getMapper(UserMapper.class);
    }

    @Test
    public void getUserById() {
        User user = userMapper.getUserById(2);

        System.out.println("user信息-" + user.getId() + "-" + user.getName());

        List<Pet> pets = user.getPets();
        for (Pet pet : pets) {
            System.out.println("养的宠物信息-" + pet.getId() + "-" + pet.getNickname());
        }
        if(sqlSession != null) {
            sqlSession.close();
        }
    }
}

注解实现多对1 映射-应用实例

需求说明: 通过注解的方式来实现下面的多对1 的映射关系，实现级联查询,

完成前面完成的任务，通过User–>Pet 也可Pet->User ， 在实际开发中推荐使用配置方式来做

  1. 创建UserMapperAnnotation.java
// UserMapperAnnotation：以注解的方式来配置多对一
public interface UserMapperAnnotation {
    //通过id获取User对象
    /**
     * 1. 注解的配置就是对应的Mapper.xml文件配置的，改写
     * 2.
     *     1、一定要想一想我们前面1-1是如何实现
     *     2、配置/实现 public User getUserById(Integer id);
     *     3、思路(1) 先通过user-id 查询得到user信息 (2) 再根据user-id查询对应的pet信息
     *       并映射到User-List<Pet> pets
     *     <resultMap id="UserResultMap" type="User">
     *         <id property="id" column="id"/>
     *         <result property="name" column="name"/>
     *         1. ofType="Pet" 指定返回的集合中存放的数据类型Pet
     *         2. collection 表示 pets 是一个集合
     *         3. property="pets" 是返回的user对象的属性 pets
     *         4. column="id" SELECT * FROM `mybatis_user` WHERE `id` = #{id} 返回的id字段对应的值
     *         <collection property="pets" column="id" ofType="Pet"
     *                     select="com.nlc.mapper.PetMapper.getPetByUserId"/>
     *     </resultMap>
     *     <select id="getUserById" parameterType="Integer" resultMap="UserResultMap">
     *         SELECT * FROM `mybatis_user` WHERE `id` = #{id}
     *     </select>
     */

    @Select("SELECT * FROM `mybatis_user` WHERE `id` = #{id}")
    @Results({
          @Result(id = true, property = "id", column = "id"),
          @Result(property = "name", column = "name"),
          //这里注意，pets属性对应的是集合
          @Result(property = "pets",
                        column = "id",
                        many = @Many(select = "com.nlc.mapper.PetMapperAnnotation.getPetByUserId"))
    })
    public User getUserById(Integer id);
}
  1. 创建PetMapperAnnotation.java
public interface PetMapperAnnotation {
    //通过User的id来获取pet对象，可能有多个，因此使用List接收
    /**
     * 1、通过User的id来获取pet对象，可能有多个，因此使用List接收
     * 2、public List<Pet> getPetByUserId(Integer userId);
     * 3. 完成的思路和前面大体相同.
     * <resultMap id="PetResultMap" type="Pet">
     * <id property="id" column="id"/>
     * <result property="nickname" column="nickname"/>
     * <association property="user" column="user_id"
     * select="com.nlc.mapper.UserMapper.getUserById" />
     * </resultMap>
     * <select id="getPetByUserId" parameterType="Integer" resultMap="PetResultMap">
     * SELECT * FROM `mybatis_pet` WHERE `user_id` = #{userId}
     * </select>
     */

    //id = "PetResultMap" 就是给我们的Results[Result Map] 指定一个名字
    //目的是为了后面复用
    @Select("SELECT * FROM `mybatis_pet` WHERE `user_id` = #{userId}")
    @Results(id = "PetResultMap", value = {
            @Result(id = true, property = "id", column = "id"),
            @Result(property = "nickname", column = "nickname"),
            @Result(property = "user",
                    column = "user_id",
                    one = @One(select = "com.nlc.mapper.UserMapperAnnotation.getUserById"))

    })
    public List<Pet> getPetByUserId(Integer userId);
    //通过pet的id获取Pet对象, 同时会查询到pet对象关联的user对象
    /**
     * <select id="getPetById"  parameterType="Integer"  resultMap="PetResultMap">
     * SELECT * FROM `mybatis_pet` WHERE `id` = #{id}
     * </select>
     * @ResultMap("PetResultMap") 使用/引用我们上面定义的 Results[ResultMap]
     */
    @Select("SELECT * FROM `mybatis_pet` WHERE `id` = #{id}")
    @ResultMap("PetResultMap")
    public Pet getPetById(Integer id);
}
  1. 创建UserMapperAnnotationTest.java 完成测试
public class UserMapperAnnotationTest {
    //属性
    private SqlSession sqlSession;
    private UserMapperAnnotation userMapperAnnotation;

    //初始化
    @Before
    public void init() {
        //获取到sqlSession
        sqlSession = MyBatisUtils.getSqlSession();
        userMapperAnnotation = sqlSession.getMapper(UserMapperAnnotation.class);
    }

    @Test
    public void getUserById() {

        User user = userMapperAnnotation.getUserById(2);
        System.out.println("user信息-" + user.getId() + "-" + user.getName());

        List<Pet> pets = user.getPets();
        for (Pet pet : pets) {
            System.out.println("宠物信息-" + pet.getId() + "-" + pet.getNickname());
        }

        if(sqlSession != null) {
            sqlSession.close();
        }
    }
}
  1. 创建PetMapperAnnotationTest.java 完成测试
public class PetMapperAnnotationTest {
    //属性
    private SqlSession sqlSession;
    private PetMapperAnnotation petMapperAnnotation;

    //初始化
    @Before
    public void init() {
        //获取到sqlSession
        sqlSession = MyBatisUtils.getSqlSession();
        petMapperAnnotation = sqlSession.getMapper(PetMapperAnnotation.class);
    }

    @Test
    public void getPetByUserId() {

        List<Pet> pets = petMapperAnnotation.getPetByUserId(1);
        for (Pet pet : pets) {
            System.out.println("宠物信息-" + pet.getId() + "-" + pet.getNickname());
        }

        if(sqlSession != null) {
            sqlSession.close();
        }
    }

    @Test
    public void getPetById() {

        Pet pet = petMapperAnnotation.getPetById(1);
        System.out.println("pet信息-" + pet.getId() + "-" +pet.getNickname());
        User user = pet.getUser();
        System.out.println("user信息-" + user.getId() + "-" + user.getName());
        if(sqlSession != null) {
            sqlSession.close();
        }
    }
}
晨犀
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis 多对一处理
qq_41359998的博客
01-22 1783
多对一处理 多对一的理解 多个学生，对应一个老师 对于学生这边而言，关联…，多个学生，关联一个老师 对于老师而言，集合，一个老师有很多学生 利用association关联和collection集合来代替结果映射resultmap，解决一对多，多对一的问题 编写一个多对一的Demo 首先建立数据库 SQL CREATE TABLE `teacher` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, PRIMARY KEY (`id`)
MyBatis的关联映射----多对多查询
m0_69530989的博客
05-15 129
INSERT INTO tb_product VALUES ('2', 'Java Web程序开发入门', '38.5');INSERT INTO tb_product VALUES ('1', 'Java基础入门', '44.5');INSERT INTO tb_product VALUES ('3', 'SSM框架整合实战', '50');ProductMapper.java 添加。OrdersMapper.java 添加。OrderTest.java 添加。OrderTest.java添加。
mybatis多对一
qq_43110032的博客
06-02 1921
1、什么是多对一 顾名思义，多对一即多个对象对应一个对象，这里我们用多个学生对应一个老师来举例 2、实际操作 2.1、创建学生表 student，和老师表 teacher 学生表 CREATE TABLE `student` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, `tid` INT(10) DEFAULT NULL, PRIMARY KEY (`id`), KEY `fktid` (`tid`), CONS
Mybatis——多对一的处理
Cooper的博客
03-08 148
Mybatis——多对一的处理的两种方式一、用到的数据库表二、多对一的处理的两种方式1.按照查询进行嵌套处理2.按照结果进行嵌套处理源码 一、用到的数据库表 student表 tid为外键关联teacher表的主键id teacher表 二、多对一的处理的两种方式 其中student实体类需要声明teacher对象 1.按照查询进行嵌套处理 <!--思路：1。查询所有的学生信息 2.根据学生的tid寻找对应的老师--> <select id
Mybatis之多对一的处理方式
peihj的博客
04-29 1204
Mybatis之多对一的处理方式 多对一的理解 多对一简而言之就是一个班级有多个学生，如果对于学生这边，就是一个多对一的现象，即从学生这边关联一个老师！ 数据库的设计 设计代码 搭建测试环境 引入Lombok配置插件 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId>
mybatis高级映射之多对一
TCDHanyongpeng的博客
06-18 256
ClazzMapper 因为步骤二是根据步骤一查出来的cid来获取clazz信息，所以本质是查询clazz信息的，所以要在clazzMapper中定义方法。**注意：**如果在项目中遇到某一条sql，业务需求，不让他使用延迟加载，那就使用。主表，副标怎么区分，谁在前谁就是主表，多对一，多的这个表就是主表。显而易见，开启延迟加载后，用到的时候才进行加载，不用的时候不加载。我们在上面的分布查询代码的基础上，我们只需要获取学生的姓名，例如：多个学生对应一个班级，学生表就是主表，班级表就是副表。
MyBatis映射关系一对多
Distance_NBA的博客
07-25 526
映射关系一对多
Mybatis-Plus实战
06-03
Mybatis-Plus（简称MP）是一个轻量级的ORM（对象关系映射）框架，它基于Mybatis并进行了增强，旨在简化常见的数据库操作，如CRUD（创建、读取、更新、删除）以及批量操作。MP提供了自动填充字段、条件构造器、分页...
mybatis-3.5.4.rar
04-01
通过阅读源码，我们可以了解MyBatis的内部工作原理，比如动态SQL的生成机制、SqlSession的管理、Mapper接口的实现方式等。此外，对于想要对MyBatis进行扩展或者调试的开发者，源码包更是必不可少。 其次，`mybatis-...
mybatis-3.4.3官方文档
12-19
* Mapper XML 文件是 MyBatis 中的一种配置文件，用于定义数据库操作的映射关系。 * Mapper 文件可以使用 XML 或注解来配置，Mapper 文件可以将 Java 对象映射到数据库表中。 5. 动态 SQL * MyBatis 提供了动态 ...
spring_mybatis_spring-mybatis_
10-02
通过这个Spring MyBatis模板，新手可以快速了解并掌握这两个框架的集成，为后续的Web应用开发打下坚实的基础。实践中，不断学习和优化，将使你更好地驾驭Spring和MyBatis，构建高效稳定的业务系统。
MyBatis-3.2.2
12-27
在学习过程中，了解这些核心概念和使用流程，结合提供的PDF文档深入学习，将有助于你快速掌握MyBatis框架，并能够熟练应用于实际项目中。同时，随着技术的发展，建议适时关注MyBatis的新版本和最佳实践，以便保持...
MyBatis处理多对一映射关系的三种方法
qq_47637405的博客
08-30 620
1.级联方式处理2.association标签3.分步查询 这里是基于t_emp,t_dept员工信息表与部门信息表对应的mapper接口实现方法，在员工信息表中有部门信息id这一字段，而在部门信息表中id字段与部门名称字段是一 一对应的。所以员工信息与部门信息是多对一的关系(多个员工可能在一个部门)...
Mybatis中多对一的处理
zzw3354353337的博客
01-20 1140
Mybatis框架中，如果bean对象中成员变量名称和数据库中的字段一一对应则可以完成自动注入，如果Java Bean对象中有复杂的数据类型（自定义对象类型），则需要在xml文件中配置相关的resultMap进行映射。例如一位老师会对应多名学生（先只考虑多对一的关系）数据库中的student表和teacher表写入简单的数据如下： 这两个表之间通过tid进行关联，两个bean对象的定义如下： public class Student { private int id; privat
如何使用mybatis处理数据库关系中的多对一关系呢？
m0_64365419的博客
01-13 630
既然要进行结果集映射，那么首先需要把resultType改为resultMap,根据我们之前的方法，使用result标签对字段和属性进行对应，但这里稍有不同，teacher是一个对象，并不是普通的字段。因此，你无法将其直接使用result标签，而应该association标签，property和column属性和普通的字段都是相同的写法，唯一的区别为后面的部分， 对于学生这边而言，**关联**.... 多个学生关联一个老师[多对一] 对于老师而言，**集合**.....，一个老师，有很多学生[一对多]
Mybatis多表查询之一对多、多对一
静水流深，沧笙踏歌
03-26 9645
前言 上次整理了单表的一些基本操作，现实工作可能会涉及复杂的多表查询，本文主要对Mybatis多表查询之一对多、多对一进行讲述。无论是一对多还是多对一，无非是涉及两个标签：collection和association，至于怎么去用和理解，后文会说明。每种查询都可以用两种方式去实现：按照查询嵌套处理（子查询）和按照结果嵌套处理（联表查询）。在进行操作前，需要把相关配置搞定，可以参考博主以往的博客。看之前需要对几个标签有所理解： property：对象、成员变量属性的名称 column：数据库字段名..
Mybatis学习之多对一映射处理
qq_39746820的博客
04-07 1068
Mybatis学习之多对一映射处理
一、Mybatis处理多对一映射关系的三种方式
m0_73414822的博客
08-29 494
Mybatis处理多对一映射关系的三种方式 ---IT筱&筱的博客
Tomcat 部署及优化
最新发布
YYL0019的博客
07-22 970
Engine匹配到名为localhost的Host (即使匹配不到也把请求交给该Host 处理，因为该Host被定义为该Engine的默认主机),名为localhost的 Host 获得请求 /testindexjsp,匹配它所拥有的所有Context。connectionUploadTimeout :上传超时时间，毕竟文件上传可能需要消耗更多的时间，该参数需要根据自己的业务需要自行调整，以使Servlet有较长的时间来完成它的执行，需要与上一个参数一起配合使用才会生效。通常默认20000 毫秒就可以。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

晨犀

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

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

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

打赏作者

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

抵扣说明：

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

余额充值