7、一对一关联、多对多关联、设置延迟加载的全局开关、指定MyBatis所用日志的具体实现

最新推荐文章于 2023-05-25 11:39:54 发布
最新推荐文章于 2023-05-25 11:39:54 发布
阅读量172 收藏 1
点赞数
分类专栏： SSM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShawnYue_08/article/details/108487295
版权

文章目录

一对一关联

环境

USE mybatis;

CREATE TABLE IF NOT EXISTS boy (
	bid INT NOT NULL AUTO_INCREMENT,
	bname VARCHAR(50) NOT NULL,
	PRIMARY KEY (bid)
);

CREATE TABLE IF NOT EXISTS girl (
	gid INT NOT NULL AUTO_INCREMENT,
	gname VARCHAR(50) NOT NULL,
	bbid INT UNIQUE,
	PRIMARY KEY (gid),
	CONSTRAINT fk_girl_boy FOREIGN KEY (bbid) REFERENCES boy(bid)
);

INSERT INTO boy VALUES(NULL, '周杰伦'), (NULL, '张杰');

INSERT INTO girl VALUES(NULL, '昆凌', 1), (NULL, '谢娜', 2);

实体类

public class Boy implements Serializable {
    private static final long serialVersionUID = 1589521560109475017L;
    private Integer bid;
    private String bname;
    private Girl girl;
}

public class Girl implements Serializable {
    private static final long serialVersionUID = 1611265720249960439L;
    private Integer gid;
    private String gname;
    private Integer bbid;
    private Boy boy;
}

BoyMapper

public interface BoyMapper {
    Boy selectByBid(Integer bid);
}

非延迟加载（复杂sql）

第一种配置：没有使用automapping和延迟加载的association标签

<mapper namespace="org.westos.mapper.BoyMapper">
    <resultMap id="resultMapBoy" type="Boy">
        <id property="bid" column="bid"/>
        <result property="bname" column="bname"/>
        <result property="girl.gid" column="gid"/>
        <result property="girl.gname" column="gname"/>
        <result property="girl.bbid" column="bbid"/>
    </resultMap>

    <select id="selectByBid" resultMap="resultMapBoy">
        SELECT b.*, g.*
        FROM boy b
        INNER JOIN girl g
        ON b.`bid` = g.`bbid`
        WHERE b.`bid` = #{bid};
    </select>
</mapper>

测试：数据封装完好

{
	"bid":1,
	"bname":"周杰伦",
	"girl":{
		"bbid":1,
		"gid":1,
		"gname":"昆凌"
	}
}

第二种配置：使用automapping自动映射

<mapper namespace="org.westos.mapper.BoyMapper">
    <resultMap id="resultMapBoy" type="Boy" autoMapping="true">
        <result property="girl.gid" column="gid"/>
        <result property="girl.gname" column="gname"/>
        <result property="girl.bbid" column="bbid"/>
    </resultMap>

    <select id="selectByBid" resultMap="resultMapBoy">
        SELECT b.*, g.*
        FROM boy b
        INNER JOIN girl g
        ON b.`bid` = g.`bbid`
        WHERE b.`bid` = #{bid};
    </select>
</mapper>

测试：数据封装完整

{
	"bid":1,
	"bname":"周杰伦",
	"girl":{
		"bbid":1,
		"gid":1,
		"gname":"昆凌"
	}
}

第三种配置：使用automapping + association关联对象

<mapper namespace="org.westos.mapper.BoyMapper">
    <resultMap id="resultMapBoy" type="Boy" autoMapping="true">
        <!--association关联对象-->
        <association property="girl" javaType="Girl" autoMapping="true"/>
    </resultMap>

    <select id="selectByBid" resultMap="resultMapBoy">
        SELECT b.*, g.*
        FROM boy b
        INNER JOIN girl g
        ON b.`bid` = g.`bbid`
        WHERE b.`bid` = #{bid};
    </select>
</mapper>

测试：数据封装完整

{
	"bid":1,
	"bname":"周杰伦",
	"girl":{
		"bbid":1,
		"gid":1,
		"gname":"昆凌"
	}
}

延迟加载

Boy selectByPrimaryBid(Integer bid);

<resultMap id="resultMapBoy2" type="Boy" autoMapping="true">
    <id property="bid" column="bid"/>
    <association property="girl" column="bid"
                 select="selectByBBid"
                 fetchType="lazy"/>
</resultMap>

<select id="selectByBBid" resultType="Girl">
    select * from girl where bbid = #{bbid}
</select>

<!--延迟加载-->
<select id="selectByPrimaryBid" resultMap="resultMapBoy2">
    select * from boy where bid = #{bid}
</select>

测试：

{
	"bid":1,
	"bname":"周杰伦",
	"girl":{
		"bbid":1,
		"gid":1,
		"gname":"昆凌"
	}
}

GirlMapper

public interface GirlMapper {
    Girl selectByGid(Integer gid);
}

非延迟加载（复杂sql）

第一种方式：

<mapper namespace="org.westos.mapper.GirlMapper">
    <resultMap id="resultMapGirl" type="Girl">
        <id column="gid" property="gid"/>
        <result column="gname" property="gname"/>
        <result property="bbid" column="bbid"/>
        <result property="boy.bid" column="bid"/>
        <result property="boy.bname" column="bname"/>
    </resultMap>

    <select id="selectByGid" resultMap="resultMapGirl">
        SELECT g.*, b.*
        FROM girl g
        INNER JOIN boy b
        ON g.`bbid` = b.`bid`
        WHERE g.`gid` = #{gid}
    </select>
</mapper>

测试：封装数据完整

{
	"bbid":2,
	"boy":{
		"bid":2,
		"bname":"张杰"
	},
	"gid":2,
	"gname":"谢娜"
}

第二种方式：

<mapper namespace="org.westos.mapper.GirlMapper">
    <resultMap id="resultMapGirl" type="Girl" autoMapping="true">
        <result property="boy.bid" column="bid"/>
        <result property="boy.bname" column="bname"/>
    </resultMap>

    <select id="selectByGid" resultMap="resultMapGirl">
        SELECT g.*, b.*
        FROM girl g
        INNER JOIN boy b
        ON g.`bbid` = b.`bid`
        WHERE g.`gid` = #{gid}
    </select>
</mapper>

测试：封装数据完整。

第三种方式：

<mapper namespace="org.westos.mapper.GirlMapper">
    <resultMap id="resultMapGirl" type="Girl" autoMapping="true">
        <association property="boy" autoMapping="true" javaType="Boy"/>
    </resultMap>

    <select id="selectByGid" resultMap="resultMapGirl">
        SELECT g.*, b.*
        FROM girl g
        INNER JOIN boy b
        ON g.`bbid` = b.`bid`
        WHERE g.`gid` = #{gid}
    </select>
</mapper>

延迟加载

Girl selectByPrimaryGid(Integer gid);

<resultMap id="resultMapGirl2" type="Girl" autoMapping="true">
    <id property="gid" column="gid"/>
    <result property="bbid" column="bbid"/>
    <association property="boy" column="bbid"
                 select="selectBoyById"
                 fetchType="lazy"/>
</resultMap>
<select id="selectBoyById" resultType="Boy">
    select * from boy where bid = #{bid}
</select>
<select id="selectByPrimaryGid" resultMap="resultMapGirl2">
    select * from girl where gid = #{gid}
</select>

当配置了autoMapping为true，有些字段仍然无法封装到对象时，可以使用id，result标签手动封装。

全局设置setting

1、设置全局懒加载

即，所有关联对象都为懒加载。

2、因为log4j的日志信息过多，如果我们只想查看mybatis中sql的生成过程时，我们可以在mybatis-config.xml全局配置中配置。

设置名描述有效值默认值
lazyLoadingEnabled延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。true|falsefalse
logImpl指定 MyBatis 所用日志的具体实现，未指定时将自动查找。STDOUT_LOGGING未设置

多对多关联

环境

-- student表和course表为多对多的关系
USE mybatis;
CREATE TABLE IF NOT EXISTS student(
	sid INT NOT NULL AUTO_INCREMENT,
	sname VARCHAR(50) NOT NULL,
	sgender VARCHAR(50) NOT NULL,
	PRIMARY KEY (sid)
);

CREATE TABLE IF NOT EXISTS course (
	cid INT NOT NULL AUTO_INCREMENT,
	cname VARCHAR(50) NOT NULL,
	PRIMARY KEY (cid)
);


-- 创建关联表
CREATE TABLE IF NOT EXISTS stu_cour (
	id INT NOT NULL AUTO_INCREMENT,
	ssid INT NOT NULL,
	ccid INT NOT NULL,
	CONSTRAINT fk_stu_cour_student FOREIGN KEY (ssid) REFERENCES student(sid),
	CONSTRAINT fk_stu_cout_course FOREIGN KEY (ccid) REFERENCES course(cid)
);

INSERT INTO student VALUES (NULL, '张三', '男'), (NULL, '李梅', '女');
INSERT INTO course VALUES (NULL, 'Java从入门到精通'), (NULL, 'Linux从入门到精通');
INSERT INTO stu_cour VALUES (NULL, 1, 1), (NULL, 1, 2), (NULL, 2, 1), (NULL, 2, 2);

实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Serializable {
    private Integer sid;
    private String sname;
    private String sgender;
    private List<Course> courses;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Course implements Serializable {
    private static final long serialVersionUID = -7418471653366978677L;
    private Integer cid;
    private String cname;
    private List<Student> students;
}

StudentMapper

延迟加载

1、查询单个Student对象

public interface StudentMapper {
    Student selectBySid(Integer sid);
}

<mapper namespace="org.westos.mapper.StudentMapper">
    <resultMap id="resultMapStudent" type="Student">
        <id property="sid" column="sid"/>
        <result property="sname" column="sname"/>
        <result property="sgender" column="sgender"/>
        <!--关联集合-->
        <collection property="courses" column="sid"
                    select="selectCourseBySid"/>
    </resultMap>

    <select id="selectCourseBySid" resultType="Course">
        SELECT c.*
        FROM course c
        INNER JOIN stu_cour s
        ON c.`cid` = s.`ccid`
        WHERE s.`ssid` = #{sid};
    </select>

    <!--全局开启懒加载-->
    <select id="selectBySid" resultMap="resultMapStudent">
        select *
        from student
        where sid = #{sid}
    </select>
</mapper>

@Test
public void testStudentMapper() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Student student = mapper.selectBySid(1);
        System.out.println(JSON.toJSONString(student, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select * from student where sid = ? 
==> Parameters: 1(Integer)
<==    Columns: sid, sname, sgender
<==        Row: 1, 张三, 男
<==      Total: 1
==>  Preparing: SELECT c.* FROM course c INNER JOIN stu_cour s ON c.`cid` = s.`ccid` WHERE s.`ssid` = ?; 
==> Parameters: 1(Integer)
<==    Columns: cid, cname
<==        Row: 1, Java从入门到精通
<==        Row: 2, Linux从入门到精通
<==      Total: 2
{
	"courses":[
		{
			"cid":1,
			"cname":"Java从入门到精通"
		},
		{
			"cid":2,
			"cname":"Linux从入门到精通"
		}
	],
	"sgender":"男",
	"sid":1,
	"sname":"张三"
}

2、查询所有Student对象

List<Student> selectAll();

<resultMap id="resultMapStudent2" type="Student">
    <id property="sid" column="sid"/>
    <result property="sname" column="sname"/>
    <result property="sgender" column="sgender"/>
    <collection property="courses" column="sid"
                select="selectCourseBySid"/>
</resultMap>

<select id="selectCourseBySid" resultType="Course">
    SELECT c.*
    FROM course c
    INNER JOIN stu_cour s
    ON c.`cid` = s.`ccid`
    WHERE s.`ssid` = #{sid};
</select>

<select id="selectAll" resultMap="resultMapStudent2">
    select * from student
</select>

@Test
public void testStudentMapper() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> students = mapper.selectAll();
        System.out.println(JSON.toJSONString(students, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select * from student 
==> Parameters: 
<==    Columns: sid, sname, sgender
<==        Row: 1, 张三, 男
<==        Row: 2, 李梅, 女
<==      Total: 2
==>  Preparing: SELECT c.* FROM course c INNER JOIN stu_cour s ON c.`cid` = s.`ccid` WHERE s.`ssid` = ?; 
==> Parameters: 1(Integer)
<==    Columns: cid, cname
<==        Row: 1, Java从入门到精通
<==        Row: 2, Linux从入门到精通
<==      Total: 2
==>  Preparing: SELECT c.* FROM course c INNER JOIN stu_cour s ON c.`cid` = s.`ccid` WHERE s.`ssid` = ?; 
==> Parameters: 2(Integer)
<==    Columns: cid, cname
<==        Row: 1, Java从入门到精通
<==        Row: 2, Linux从入门到精通
<==      Total: 2
[
	{
		"courses":[
			{
				"cid":1,
				"cname":"Java从入门到精通"
			},
			{
				"cid":2,
				"cname":"Linux从入门到精通"
			}
		],
		"sgender":"男",
		"sid":1,
		"sname":"张三"
	},
	{
		"courses":[
			{
				"cid":1,
				"cname":"Java从入门到精通"
			},
			{
				"cid":2,
				"cname":"Linux从入门到精通"
			}
		],
		"sgender":"女",
		"sid":2,
		"sname":"李梅"
	}
]

CourseMapper

延迟加载

1、查询单个Course对象

public interface CourseMapper {
    Course selectByCid(Integer cid);
}

<mapper namespace="org.westos.mapper.CourseMapper">
    <resultMap id="resultMapCourse" type="Course">
        <id property="cid" column="cid"/>
        <result property="cname" column="cname"/>
        <collection property="students" column="cid"
                    select="selectStudentByCid"/>
    </resultMap>

    <select id="selectStudentByCid" resultType="Student">
        SELECT s.*
        FROM student s
                 INNER JOIN stu_cour st
                            ON s.`sid` = st.`ssid`
        WHERE st.`ccid` = #{cid};
    </select>

    <select id="selectByCid" resultMap="resultMapCourse">
        select * from course where cid = #{cid}
    </select>
</mapper>

@Test
public void testCourseMapper() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        CourseMapper mapper = sqlSession.getMapper(CourseMapper.class);
        Course course = mapper.selectByCid(1);
        System.out.println(JSON.toJSONString(course, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select * from course where cid = ? 
==> Parameters: 1(Integer)
<==    Columns: cid, cname
<==        Row: 1, Java从入门到精通
<==      Total: 1
==>  Preparing: SELECT s.* FROM student s INNER JOIN stu_cour st ON s.`sid` = st.`ssid` WHERE st.`ccid` = ?; 
==> Parameters: 1(Integer)
<==    Columns: sid, sname, sgender
<==        Row: 1, 张三, 男
<==        Row: 2, 李梅, 女
<==      Total: 2
{
	"cid":1,
	"cname":"Java从入门到精通",
	"students":[
		{
			"sgender":"男",
			"sid":1,
			"sname":"张三"
		},
		{
			"sgender":"女",
			"sid":2,
			"sname":"李梅"
		}
	]
}

2、查询所有Course对象

List<Course> selectAll();

<select id="selectStudentByCid" resultType="Student">
    SELECT s.*
    FROM student s
    INNER JOIN stu_cour st
    ON s.`sid` = st.`ssid`
    WHERE st.`ccid` = #{cid};
</select>
<resultMap id="resultMapCourse2" type="Course">
    <id property="cid" column="cid"/>
    <result property="cname" column="cname"/>
    <collection property="students" column="cid"
                select="selectStudentByCid"/>
</resultMap>

<select id="selectAll" resultMap="resultMapCourse2">
    select * from course
</select>

@Test
public void testCourseMapper() {
    try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
        CourseMapper mapper = sqlSession.getMapper(CourseMapper.class);
        /*Course course = mapper.selectByCid(1);
            System.out.println(JSON.toJSONString(course, true));*/
        List<Course> courses = mapper.selectAll();
        System.out.println(JSON.toJSONString(courses, true));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

==>  Preparing: select * from course 
==> Parameters: 
<==    Columns: cid, cname
<==        Row: 1, Java从入门到精通
<==        Row: 2, Linux从入门到精通
<==      Total: 2
==>  Preparing: SELECT s.* FROM student s INNER JOIN stu_cour st ON s.`sid` = st.`ssid` WHERE st.`ccid` = ?; 
==> Parameters: 1(Integer)
<==    Columns: sid, sname, sgender
<==        Row: 1, 张三, 男
<==        Row: 2, 李梅, 女
<==      Total: 2
==>  Preparing: SELECT s.* FROM student s INNER JOIN stu_cour st ON s.`sid` = st.`ssid` WHERE st.`ccid` = ?; 
==> Parameters: 2(Integer)
<==    Columns: sid, sname, sgender
<==        Row: 1, 张三, 男
<==        Row: 2, 李梅, 女
<==      Total: 2
[
	{
		"cid":1,
		"cname":"Java从入门到精通",
		"students":[
			{
				"sgender":"男",
				"sid":1,
				"sname":"张三"
			},
			{
				"sgender":"女",
				"sid":2,
				"sname":"李梅"
			}
		]
	},
	{
		"cid":2,
		"cname":"Linux从入门到精通",
		"students":[
			{
				"sgender":"男",
				"sid":1,
				"sname":"张三"
			},
			{
				"sgender":"女",
				"sid":2,
				"sname":"李梅"
			}
		]
	}
]
ShawnYue_08
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis系列第8篇：自动映射，使用需谨慎！
hanxh7的博客
03-11 1482
什么是自动映射？ 介绍自动映射之前先看一下手动映射，如下： <resultMapid="orderModelMap1"type="com.javacode2018.chat05.demo7.model.OrderModel"> <idcolumn="id"property="id"/> <resultcolumn="userId"pr...
mybatis的AutoMapping自动注入和ResultMap自定义注入
虎啊兄弟的博客
09-11 3829
文章目录AutoMapping自动注入和ResultMap自定义注入 AutoMapping自动注入和ResultMap自定义注入 解释： 在单表查询中，mybatis会根据实体类的属性名和字段名 相同的方式将查询结果自定的注入到实体类的对象中。就不 需要我们像以前一样书写while循环遍历赋值了。 注意： Mybatis默认按照字段名和属性名一致的规则将查询的数据注入 到实体...
mybatis ＜association＞ 标签的使用
果酱 の 博客
05-25 7174
mybatis 标签的使用
【 SQL映射】映射元素、一对一(association)、一对多(collection)
m0_70083523的博客
10-24 2978
association：映射到JavaBean的某个“复杂类型”属性，比如JavaBean类。resultMap自动映射匹配前提：字段名column与属性名property一致。resultMap自动映射匹配前提：字段名column与属性名property一致。collection：映射到JavaBean的某个“复杂类型”属性，比如集合。resultMap：数据库字段信息与对象属性不一致；result：映射到JavaBean的某个“简单类型”属性。property：映射数据库列的实体对象的属性。
MyBatis从入门到入土——自动映射的使用
qfchenjunbo的博客
12-17 775
天我们介绍一下我们一直在使用的但是没有来得及做过多介绍的自动映射。 什么是自动映射？ 介绍自动映射之前先看一下手动映射，如下： <resultMap id="orderModelMap1" type="com.zhonghu.chat08.demo7.model.OrderModel"> <id column="id" property="id"/> <result column="userId" property="userId" />
Mybatis 一对多和多对一关联查询问题
08-30
Mybatis 一对多和多对一关联查询问题 Mybatis 是一个基于 Java 的持久层框架，它提供了强大的数据库交互功能。在实际开发中，我们经常会遇到一对多和多对一关联查询的问题。本文将详细介绍 Mybatis 中的一对多和多...
Mybatis一对多关联关系映射实现过程解析
08-25
Mybatis的一对多关联关系映射实现过程解析 Mybatis是一款基于Java的持久层框架，它提供了对数据库的操作接口，包括数据的增删改查等操作。在实际开发中，我们经常会遇到一对多关联关系映射的问题，例如用户和订单...
mybatis实现一对一关联映射实例代码
08-28
MyBatis 实现一对一关联映射实例代码 MyBatis 是一个基于 Java 的持久层框架，它提供了对数据库的访问和操作。在实际项目开发中，经常存在一对一的关系，如一个人对应一张身份证信息，这就是一对一的关系。下面我们...
用MyBatis实现表的一对多关联查询
12-05
本文主要围绕"用MyBatis实现表的一对多关联查询"这一主题，详细阐述如何在实际项目中实现这种关联关系。 一、MyBatis一对多映射基础 MyBatis的一对多映射是指一个表（父表）中的多条记录可以与另一个表（子表）中...
Spring boot整合Mybatis实现级联一对多CRUD操作的完整步骤
08-25
主要给大家介绍了关于Spring boot整合Mybatis实现级联一对多CRUD操作的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
mybatis延迟加载开关
知也无涯
10-12 465
PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">     注意，设置运行参数会影响 mybatis的运行，一定要注意！ --> --> type:类路径 alias：
autoMapping和autoMappingBehavior的区别
Androidcaobo
06-05 1万+
autoMappingBehaviormybatis核心配置文件中settings中配置,指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）。默认是partial，这是一种全局设置autoMapping在resultMap或者association,co...
association和collection存在时，对映射结果的影响。
我若成佛，天下无魔；我若入魔，佛奈我何！
08-11 1709
图一 图二 出现以上问题的原因： 当没有 association或者collection时,autoMappingBehavior在默认情况下（PARTIAL），若是普通数据类型的属性，会自动匹配所有，但是若是有内部嵌套（association或者collection），那么输出结果就是null,也就是说它不会自动匹配，除非手动设置autoMappingBehavior的value为...
MyBatis中映射器之结果映射详解
小小默：进无止境
07-14 2923
关联博文：MyBatis中XML映射器使用详解 【1】结果映射 resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的操作。实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的数千行代码。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。 之前你已经见过简单映
【MyBatis学习11】MyBatis中的延迟加载
热门推荐
武哥聊编程
06-15 3万+
1. 什么是延迟加载 　　举个例子：如果查询订单并且关联查询用户信息。如果先查询订单信息即可满足要求，当我们需要查询用户信息时再查询用户信息。把对用户信息的按需去查询就是延迟加载。 所以延迟加载即先从单表查询、需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 　　我们来对比一下： 关联查询：SELECT orders.*, user.use
详解Mybatis 「resultMap」中的autoMapping属性
weixin_40486955的博客
07-05 1万+
<?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.tfjy.sda.mapper.CourseMapper"> <resultMap id="TopicList" typ
MyBatis的关联映射彩色PPT版本.pptx
最新发布
05-29
章节目标聚焦于理解并掌握MyBatis如何处理对象间的一对一、一对多和多对多关联关系，这对于实际项目开发中的数据操作至关重要。 首先，关联关系概述是核心内容，介绍了在数据库中常见的三种关系模式：一对一、一对...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值