MyBatis多对一，一对多，多对多查询

最新推荐文章于 2024-03-30 18:48:19 发布
最新推荐文章于 2024-03-30 18:48:19 发布
阅读量496 收藏 1
点赞数 1
文章标签： mybatis mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68092999/article/details/125791902
版权

目录

多对一：

一对多：（同样使用联合查询与子查询实现）

 多对多：

多对一：

编写VO类 （因为一个儿子对应一个父亲，所以儿子的VO类中有父亲的信息）

@Data
@NoArgsConstructor
@AllArgsConstructor
public class SonVo implements Serializable {
    private static final long serialVersionUID = -203988976020008362L;
    /**
     * 儿子ID
     */
    private long sId;
    /**
     * 儿子姓名
     */
    private String sName;
    /**
     * 该儿子父亲ID
     */
    private long fId;
    /**
     * 该儿子父亲信息
     */
    private Father father;
}

1.使用关联查询实现

编写接口（返回一个SonVo对象）

public interface SonMapper {
    /**
     * 根据儿子ID查询儿子和该儿子父亲的信息
     *
     * @param sid
     * @return
     */
    SonVo selectSonVoBySid(@Param("sid") long sid);
}

编写映射配置文件

<?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.lihaozhe.mapper.SonMapper">
    <!--根据儿子ID查询儿子和该儿子父亲的信息-->
    <resultMap id="SonVoMap" type="sonVo">
        <id property="sId" column="s_id"/>
        <result property="sName" column="s_name"/>
        <result property="fId" column="fid"/>
        <association property="father">
            <id property="fId" column="fid"/>
            <result property="fName" column="f_name"/>
        </association>
    </resultMap>
    <select id="selectSonVoBySid" resultMap="SonVoMap">
        SELECT s_id, s_name, s.f_id AS fid, f_name
        FROM son s
                 INNER JOIN father f ON s.f_id = f.f_id AND s_id = #{sid}
    </select>
</mapper>

编写测试类

2.使用子查询实现

编写接口（这时需要先查询父亲的信息，以便后期的使用）

public interface FatherMapper {
    /**
     * 根据父亲ID获取父亲信息
     *
     * @param fid
     * @return
     */
    Father selectFatherById(@Param("fid") long fid);
}
public interface SonMapper {
    /**
     * 根据儿子ID查询儿子和该儿子父亲的信息
     *
     * @param sid
     * @return
     */
    SonVo selectSonVoById(@Param("sid") long sid);
}

编写映射配置文件（第一份映射父亲信息，第二份映射儿子信息）

<?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.lihaozhe.mapper.FatherMapper">
    <!--根据父亲ID获取父亲信息-->
    <select id="selectFatherById" resultType="father">
        SELECT *
        FROM `father`
        WHERE `f_id` = #{fid}
    </select>
</mapper>

注意：<association>标签中会走一遍查询父亲信息的子查询 

<?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.lihaozhe.mapper.SonMapper">
    <!--根据儿子ID查询儿子和该儿子父亲的信息-->
    <resultMap id="SonVoMapper" type="sonVo">
        <id property="sId" column="s_id"/>
        <result property="sName" column="s_name"/>
        <result property="fId" column="f_id"/>
        <association property="father" column="f_id" select="com.lihaozhe.mapper.FatherMapper.selectFatherById"/>
    </resultMap>
    <select id="selectSonVoById" resultMap="SonVoMapper">
        SELECT *
        FROM `son`
        WHERE `s_id` = #{sid}
    </select>
</mapper>

编写测试类

（第一份测试是查询父亲信息的）

public class FatherMapperTest {
    @Test
    public void selectFatherById(){
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        FatherMapper mapper = sqlSession.getMapper(FatherMapper.class);
        Father father = mapper.selectFatherById(1L);
        MyBatisUtil.close();
        System.out.println(father);
    }
}

（第二份才是总的测试类）

public class SonMapperTest {
    @Test
    public void selectSonVoById() {
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        SonMapper mapper = sqlSession.getMapper(SonMapper.class);
        SonVo sonVo = mapper.selectSonVoById(3L);
        MyBatisUtil.close();
        System.out.println(sonVo);
    }
}

SQL解析：

==>  Preparing: SELECT s_id, s_name,f_id FROM son WHERE s_id = ?
==> Parameters: 1(Long)
<==    Columns: s_id, s_name, f_id
<==        Row: 1, 李金吒, 1
====>  Preparing: SELECT f_id, f_name FROM father WHERE f_id = ?
====> Parameters: 1(Integer)
<====    Columns: f_id, f_name
<====        Row: 1, 李靖
<====      Total: 1
<==      Total: 1

一对多：（同样使用联合查询与子查询实现）

        编写VO类（因为一个父亲可以对应多个儿子，所以父亲信息中要有儿子的集合）

@Data
@NoArgsConstructor
@AllArgsConstructor
public class FatherVo implements Serializable {
    private static final long serialVersionUID = -1335512987974717220L;
    /**
     * 父亲ID
     */
    private long fId;
    /**
     * 父亲姓名
     */
    private String fName;
    /**
     * 该父亲的儿子们
     */
    private List<Son> sons;
}

1.使用子查询实现

 编写接口（这时需要先查询儿子们的信息，以便后期的使用）

public interface SonMapper {
    /**
     * 根据父亲ID获取该父亲的儿子列表
     * @param fid
     * @return
     */
    List<Son> selectAllByFId(@Param("fid") long fid);
}
public interface FatherMapper {
    /**
     * 根据父亲ID获取父亲及其儿子们的信息
     *
     * @param fid
     * @return
     */
    FatherVo selectFatherVoById(@Param("fid") long fid);
}

编写映射配置文件（第一份映射儿子信息，第二份映射父亲信息）

<?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.lihaozhe.mapper.SonMapper">
    <!--根据父亲ID获取该父亲的儿子列表-->
    <select id="selectAllByFId" resultType="son">
        select *
        from son
        where f_id = #{fid};
    </select>
</mapper>

 注意：<collection>标签中会走一遍查询儿子们信息的子查询 

<?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.lihaozhe.mapper.FatherMapper">
    <!--根据父亲ID获取父亲及其儿子们的信息-->
    <resultMap id="FatherVoMap" type="fatherVo">
        <id property="fId" column="f_id"/>
        <result property="fName" column="f_name"/>
        <collection property="sons" ofType="son" column="f_id" select="com.lihaozhe.mapper.SonMapper.selectAllByFId"/>
    </resultMap>
    <select id="selectFatherVoById" resultMap="FatherVoMap">
        select *
        from father
        where f_id = #{fid};
    </select>
</mapper>

编写测试类

（第一份测试是查询儿子们信息的）

public class SonMapperTest {
    @Test
    public void selectAllByFId(){
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        SonMapper mapper = sqlSession.getMapper(SonMapper.class);
        List<Son> sons = mapper.selectAllByFId(1L);
        MyBatisUtil.close();
        sons.forEach(System.out::println);
    }
}

（第二份才是总的测试类）

public class FatherMapperTest {
    @Test
    public void selectFatherVoById(){
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        FatherMapper mapper = sqlSession.getMapper(FatherMapper.class);
        FatherVo fatherVo = mapper.selectFatherVoById(1L);
        MyBatisUtil.close();
        System.out.println(fatherVo);
    }
}

SQL解析：

==>  Preparing: SELECT f_id, f_name FROM father WHERE f_id = ?
==> Parameters: 1(Long)
<==    Columns: f_id, f_name
<==        Row: 1, 李靖
====>  Preparing: SELECT s_id, s_name,f_id FROM son WHERE f_id = ?
====> Parameters: 1(Integer)
<====    Columns: s_id, s_name, f_id
<====        Row: 1, 李金吒, 1
<====        Row: 2, 李木吒, 1
<====        Row: 3, 李哪吒, 1
<====      Total: 3
<==      Total: 1

2.使用联合查询实现

编写接口（返回一个FatherVo对象）

public interface FatherMapper {
    /**
     * 根据父亲ID获取父亲及其儿子们的信息
     *
     * @param fid
     * @return
     */
    FatherVo selectFatherVoBySid(@Param("fid") long fid);
}

编写映射配置文件

<?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.lihaozhe.mapper.FatherMapper">
    <!--根据父亲ID获取父亲及其儿子们的信息-->
    <resultMap id="FatherVoMapper" type="fatherVo">
        <id property="fId" column="fid"/>
        <result property="fName" column="f_name"/>
        <collection property="sons" ofType="son">
            <id property="sId" column="s_id"/>
            <result property="sName" column="s_name"/>
            <result property="fId" column="fid"/>
        </collection>
    </resultMap>
    <select id="selectFatherVoBySid" resultMap="FatherVoMapper">
        select f.f_id as fid, f_name, s_id, s_name
        from father f
                 inner join son s on f.f_id = s.f_id and f.f_id = #{fid}
    </select>
</mapper>

编写测试类

public class FatherMapperTest {
    @Test
    public void selectFatherVoBySid(){
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        FatherMapper mapper = sqlSession.getMapper(FatherMapper.class);
        FatherVo fatherVo = mapper.selectFatherVoBySid(1L);
        MyBatisUtil.close();
        System.out.println(fatherVo);
    }

}

 多对多：

1.直接多对多（需求：查找某图书类目下的所有图书）

编写VO类（包含图书这个集合）

@Data
@NoArgsConstructor
@AllArgsConstructor
public class CategoryVo implements Serializable {
    private static final long serialVersionUID = 5565769402064534797L;
    /**
     * 分类ID
     */
    private long cid;
    /**
     * 分类名称
     */
    private String cname;
    /**
     * 某分类的图书列表
     */
    private List<Book> books;
}

编写接口（返回图书类目对象）

public interface CategoryMapper {
    /**
     * 根据分类ID获取分类及其分类下的图书列表
     *
     * @param cid
     * @return
     */
    CategoryVo selectCategoryVoByCid(@Param("cid") long cid);
}

编写映射配置文件

<?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.lihaozhe.mapper.CategoryMapper">
    <!--根据分类ID获取分类及其分类下的图书列表-->
    <resultMap id="CategoryVoMap" type="categoryVo">
        <id property="cid" column="cid"/>
        <id property="cname" column="cname"/>
        <collection property="books" ofType="book">
            <id property="bid" column="bid"/>
            <result property="bname" column="bname"/>
        </collection>
    </resultMap>
    <select id="selectCategoryVoByCid" resultMap="CategoryVoMap">
        select cid, cname, bid, bname
        from category
                 inner join book_category
                 inner join book
                            on cid = m_cid and bid = m_bid and cid = #{cid}
    </select>
</mapper>

编写测试类

public class CategoryMapperTest {

    @Test
    public void selectCategoryVoByCid(){
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        CategoryMapper mapper = sqlSession.getMapper(CategoryMapper.class);
        CategoryVo categoryVo = mapper.selectCategoryVoByCid(3L);
        MyBatisUtil.close();
        System.out.println(categoryVo);
    }
}

2.直接多对多（需求：查找某图书对应的所有图书类目）

编写VO类（包含图书类目这个集合）

@Data
@NoArgsConstructor
@AllArgsConstructor
public class BookVo implements Serializable {
    private static final long serialVersionUID = 6785352134653400094L;
    /**
     * 书的ID
     */
    private long bid;
    /**
     * 书名
     */
    private String bname;
    /**
     * 某图书的分类信息列表
     */
    private List<Category> categories;
}

编写接口（返回图书对象）

public interface BookMapper {
    /**
     * 根据图书ID查询图书信息包括该图书的分类信息
     *
     * @param bid
     * @return
     */
    BookVo selectBookVoByBid(@Param("bid") long bid);
}

编写映射配置文件

<?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.lihaozhe.mapper.BookMapper">
    <!--根据分类ID获取分类及其分类下的图书列表-->
    <resultMap id="BookVoMap" type="bookVo">
        <id property="bid" column="bid"/>
        <result property="bname" column="bname"/>
        <collection property="categories" ofType="category">
            <id property="cid" column="cid"/>
            <id property="cname" column="cname"/>
        </collection>
    </resultMap>
    <select id="selectBookVoByBid" resultMap="BookVoMap">
        select bid, bname, cid, cname
        from book
                 inner join book_category
                 inner join category
                            on bid = m_bid and cid = m_cid and bid = #{bid}
    </select>
</mapper>

编写测试类

public class BookMapperTest {

    @Test
    public void test(){
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
        BookVo bookVo = mapper.selectBookVoByBid(3L);
        MyBatisUtil.close();
        System.out.println(bookVo);
    }
}

3.间接多对多（将多对多拆成两个一对多 或 两个多对一）

（需求：查找某课程下的所有学生信息）

编写中间表映射类（包括学生信息 和 课程信息）

@Data
@NoArgsConstructor
@AllArgsConstructor
public class StudentCourse implements Serializable {
    private static final long serialVersionUID = 7294808647412902387L;
    /**
     * 学生ID
     */
    private long sId;
    /**
     * 课程ID
     */
    private long cId;
    /**
     * 学生信息
     */
    private Student student;
    /**
     * 课程信息
     */
    private Course course;

}

编写接口

public interface CourseMapper {
    /**
     * 根据课程ID查找课程
     *
     * @param cid
     * @return
     */
    Course selectCourseByCid(@Param("cid") long cid);

}

编写映射配置文件

<mapper namespace="com.lihaozhe.mapper.CourseMapper">

    <!--根据课程ID查找课程-->
    <select id="selectCourseByCid" resultType="course">
        SELECT *
        FROM `course`
        WHERE `c_id` = #{cid}
    </select>
</mapper>

编写测试类

public class CourseMapperTest {
    @Test
    public void selectCourseByCid(){
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        CourseMapper mapper = sqlSession.getMapper(CourseMapper.class);
        Course course = mapper.selectCourseByCid(3L);
        MyBatisUtil.close();
        System.out.println(course);
    }
}

编写接口

public interface StudentMapper {
    /**
     * 根据学生ID 查询学生信息 包含所需课程的ID列表
     *
     * @param sid
     * @return
     */
    StudentVo selectStudentVoBySid(@Param("sid") long sid);
}

编写映射配置文件

<?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.lihaozhe.mapper.StudentMapper">
    <!--根据学生ID 查询学生信息 包含所需课程的ID列表-->
    <resultMap id="StudentVoMap" type="studentVo">
        <id property="sId" column="sid"/>
        <result property="sName" column="s_name"/>
        <collection property="studentCourses" ofType="studentCourse">
            <result property="sId" column="sid"/>
            <result property="cId" column="c_id"/>
            <association property="course" column="c_id" select="com.lihaozhe.mapper.CourseMapper.selectCourseByCid"/>
        </collection>
    </resultMap>
    <select id="selectStudentVoBySid" resultMap="StudentVoMap">
        select stu.s_id as sid, s_name, c_id
        from student as stu
                 inner join student_course sc on stu.s_id = sc.s_id and stu.s_id = #{sid}

    </select>
</mapper>

编写测试类

public class StudentMapperTest {
    @Test
    public void selectStudentVoBySid() {
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        StudentVo studentVo = mapper.selectStudentVoBySid(3L);
        System.out.println(studentVo);
        System.out.println(studentVo.getSName());
        studentVo.getStudentCourses().forEach(studentCourse -> System.out.println(studentCourse.getCourse()));
    }
}

SQL解析

==>  Preparing: SELECT s.s_id, s_name, c_id FROM `student` s INNER JOIN `student_course` sc ON s.s_id = sc.s_id AND s.s_id = ?
==> Parameters: 1(Long)
<==    Columns: s_id, s_name, c_id
<==        Row: 1, stu01, 1
====>  Preparing: SELECT * FROM `course` WHERE `c_id` = ?
====> Parameters: 1(Integer)
<====    Columns: c_id, c_name
<====        Row: 1, java
<====      Total: 1
<==        Row: 1, stu01, 2
====>  Preparing: SELECT * FROM `course` WHERE `c_id` = ?
====> Parameters: 2(Integer)
<====    Columns: c_id, c_name
<====        Row: 2, scala
<====      Total: 1
<==      Total: 2

4.间接多对多（将多对多拆成两个一对多 或 两个多对一）

（需求：查找某学生对应的所有课程信息）

编写接口

public interface StudentMapper {
    /**
     * 根据学生ID 查询学生信息
     *
     * @param sid
     * @return
     */
    Student selectStudentBySid(@Param("sid") long sid);
}

编写映射配置文件

<?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.lihaozhe.mapper.StudentMapper">

    <!--根据学生ID 查询学生信息-->
    <select id="selectStudentBySid" resultType="student">
        SELECT * FROM `student` WHERE `s_id` = #{sid}
    </select>
</mapper>

编写测试类

public class StudentMapperTest {

    @Test
    public void selectStudentBySid() {
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Student student = mapper.selectStudentBySid(3L);
        System.out.println(student);
    }
}

编写VO类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class CourseVo implements Serializable {
    private static final long serialVersionUID = -2649136027724661116L;
    /**
     * 课程ID
     */
    private long cId;
    /**
     * 课程名称
     */
    private String cName;
    /**
     * 课程关联信息
     */
    private List<StudentCourse> studentCourses;
}

编写接口

public interface CourseMapper {
   

    /**
     * 根据课程ID查找课程 包含所需课程的ID列表
     *
     * @param cid
     * @return
     */
    CourseVo selectCourseVoByCid(@Param("cid") long cid);
}
<?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.lihaozhe.mapper.CourseMapper">
 

    <!--根据课程ID查找课程 包含所需课程的ID列表-->
    <resultMap id="CourseVoMap" type="courseVo">
        <id property="cId" column="cid"/>
        <result property="cName" column="c_name"/>
        <collection property="studentCourses" ofType="studentCourse">
            <result property="sId" column="sid"/>
            <result property="cId" column="c_id"/>
            <association property="student" column="s_id" select="com.lihaozhe.mapper.StudentMapper.selectStudentBySid"/>
        </collection>
    </resultMap>
    <select id="selectCourseVoByCid" resultMap="CourseVoMap">
        select c.c_id as cid, c_name, s_id
        from course as c
                 inner join student_course sc on c.c_id = sc.c_id and c.c_id = #{cid}
    </select>
</mapper>

编写测试类

public class CourseMapperTest {

    @Test
    public void selectCourseVoByCid(){
        SqlSession sqlSession = MyBatisUtil.openSqlSession();
        CourseMapper mapper = sqlSession.getMapper(CourseMapper.class);
        CourseVo courseVo = mapper.selectCourseVoByCid(3L);
        System.out.println(courseVo);
        System.out.println(courseVo.getCName());
        courseVo.getStudentCourses().forEach(studentCourse -> System.out.println(studentCourse.getStudent()));
    }
}

星星不喝药
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Mybatis查询多对一，一对多Mapper语句（返回集合，返回对象）
qq_35034711的博客
04-19 2843
Mybatis查询多对一，一对多Mapper语句（返回集合，返回对象） 1.多对一 多个学生对应一个老师 学生类： Student{ private int id; private String name; private Teacher teacher; } 学生数据表： id name tid 1 小明 1 2 小刚 1 方法一：按照查询嵌套处理： <select id = getStudent resultMap="StudentTeacher"> se
关于Mybatis一对多查询以及返回一条记录的经验总结
昊月光华的博客
03-22 2995
我的配置:mysql数据库中user表主键为iduser_orders表以userid（user表中的id）做为外键假设一个用户有多个订单user类(一对多查询，所以user类持有对order集合的引用。return uid;resultmap 结果关联映射 在.xml中(通过 user 表left join 左连接 order表selectuser.*,关注于以下两个框。
Mybatis的多表连接操作，一对一、一对多、多对多
最新发布
2401_83915450的博客
03-30 618
既已说到spring cloud alibaba，那对于整个微服务架构，如果想要进一步地向上提升自己，到底应该掌握哪些核心技能呢？就个人而言，对于整个微服务架构，像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识，架构师必经之路！下图，是自绘的微服务架构路线体系大纲，如果有还不知道自己该掌握些啥技术的朋友，可根据小编手绘的大纲进行一个参考。
Mybati返回数据一对多
19：30的博客
01-19 1098
记录一下，mybatis的返回类型一对多。 通常情况下使用mybatis的select标签，使用其resultType属性来绑定java数据类型，但是这种方式只适应一对一的关系，即一条数据库记录，对应一个java对象。比如，在工作中，有时会出现复杂的情况（即一对多）。 正文： 我想要mybatis给我返回如下图所示的java类型：一个java对象中有一个是集合的成员变量（一对多） 可以看到...
mybatis-plus 实现一对多查询，返回VO对象某个字段为List
wwyy2018的博客
02-22 6185
类关系 Animal类下包含一个List<Dog》，两表可用id和animalId字段关联。 @Data @TableName("animal") public class Animal { @TableId private String id; private Integer foot; private List<Dog> dogList; } @Data @TableName("dog") public class Dog { @TableId
mybatis多对一和一对多查询数据处理解读
一个菜鸡的博客
07-22 1133
针对的mybatis中的多对一和一对多的高级映射进行分析解读，带你从0到1把握理解并运用到实际开发中去，居家旅行必备。
mybatis一对多查询功能
08-31
主要介绍了mybatis一对多查询功能,非常不错，具有参考借鉴价值，需要的朋友可以参考下
Mybatis一对多关联关系映射实现过程解析
08-25
主要介绍了Mybatis一对多关联关系映射实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
mybatis递归 一对多的实现方法示例
08-27
mybatis递归 一对多的实现方法示例
mybatis高级映射一对多查询实现代码
08-30
本篇文章主要介绍了mybatis高级映射一对多查询实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
Mybatis 一对多和多对一关联查询问题
08-30
主要介绍了Mybatis 一对多和多对一关联查询问题,需要的朋友可以参考下
MyBatis：一对多、多对一处理
adsdaas的博客
03-17 396
多对一的处理     多对一的理解： 多个学生对应一个老师 如果对于学生这边，就是一个多对一的现象，即从学生这边关联一个老师！ 数据库设计 CREATE TABLE `teacher` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, PRIMARY KEY (`id`) )...
mybatisplus多表查询返回vo对象，如何在java代码中实现
weixin_42759398的博客
04-11 3124
在使用MyBatis-Plus进行多表查询时，可以使用`@TableName`注解来指定表名，使用`@TableField`注解来指定表字段，使用`@JoinQuery`注解来指定关联查询条件。在Mapper接口中，使用`@JoinQuery`注解指定关联查询条件，`value`属性指定关联表名，`condition`属性指定关联条件，`type`属性指定关联方式（此处使用左连接查询）。// 省略getter/setter方法。
mybatis plus多表联查返回vo对象（纯java代码无需xml和注解）
weixin_42759398的博客
04-11 1934
在这个示例中，我们使用`QueryWrapper`类构建了一个多表联查的查询条件。首先使用`select()`方法指定要查询的字段，然后使用`leftJoin()`方法指定关联查询的表和条件，最后使用`groupBy()`方法指定分组条件。最后，使用`selectList()`方法查询数据，并将查询结果转换成`List`对象。MyBatis-Plus提供了`QueryWrapper`类，可以用它来构建多表联查的查询条件。下面是一个示例代码：```java。
mybatis一对多--多对多（查出的数据-返回参数）
qq_43470725的博客
05-31 394
xml文件为： <!--1对多，指的是在那个多的里面都是不同的（collection），而在resultMap上的result都是一样的--> <resultMap id="resultAllDTO" type="cn.org.emcs.materialapi.social.dto.DonationMeterialAllDTO"> <!-- <id property="ids" column="ids"/>--> <
mybatis 父子级树形结构查询
纯洁的小魔鬼
09-13 2130
针对父子级数据目录查询, 以前都是逐级的去根据父级id查询子集目录, 查出后最后再在代码中拼成树形结构, 相当复杂,我们可以利用 mybatis 提供的 collection 标签自动组织树形结构, 接下来我们一步一步看该如何建立。
使用mybatis进行数据库中同一张表中的父子类别查询
weixin_41358807的博客
03-10 1762
同一张表中的父子查询 表中parent_id与id对应 Category.java package com.meutech.entity; import java.util.List; public class Category { private Integer id; private Integer parent_id; private String name; private List<Category> childcategory; pub
MyBatis——@Result注解column参数传递——父查询函数的参数传递到子查询
无限迭代中......
05-30 4330
问题描述 假设a方法中传入一个带查询参数x 但是a方法的查询结果中不包含参数x 而子查询里也需要参数x 如何在子查询b中带入参数x /** * 按User表中platform查询User */ @Select("select * from user where pid = #{id}") List<User> findUsers(int id); /** * 一对多查询 */ @Select("sele
Mybatis——父子查询(collection)
qq_39980539的博客
11-22 5199
Mybatis之父子查询(collection)，最详细！！！
mybatis一对多对多查询
10-12
一对多查询可以通过在主表中定义一个集合属性，然后在映射文件中使用collection标签来映射子表数据。例如： ``` select u.id, u.name, o.id as order_id, o.name as order_name from user u left...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

星星不喝药

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

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

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

打赏作者

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

抵扣说明：

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

余额充值