MyBatis 关联映射

最新推荐文章于 2024-03-05 01:27:47 发布
最新推荐文章于 2024-03-05 01:27:47 发布
阅读量2.7k 收藏 28
点赞数 7
分类专栏： Java EE 企业级应用开发 文章标签： mybatis 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52861684/article/details/127883347
版权

文章目录

一、关联映射概述

在此之前，我们已经学习了 MyBatis 的基本语法和动态 SQL 等重要知识，然而在实际开发中，对数据库的操作常常会涉及到多张表，针对多表之间的操作，MyBatis 提供了关联映射，通过关联映射可以很好地处理表与表、对象与对象之间的关联关系。
在关系型数据库中，表与表之间存在着三种关联映射关系，分别为一对一关系、一对多关系和多对多关系。
数据表之间的关系实质上描述的是数据之间的关系，除了数据表，在 Java 中，还可以通过对象来描述数据之间的关系，其实就是使对象的属性与另一个对象的属性相互关联。

在这里插入图片描述

二、一对一查询

1.association 元素

在 MyBatis 中，通过 association 元素来处理一对一关联关系，association 元素提供了一系列属性用于维护数据表之间的关系。

在这里插入图片描述

association 元素是 resultMap
元素的子元素，它有两种配置方式，嵌套查询方式和嵌套结果集方式，下面以个人与身份证之间一对一的关系为例，对这两种配置方式分别进行演示。

2.嵌套查询实例演示

① 准备数据库

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

② 编写实体类

//Person.java
package com.tyut.pojo;

public class Person {
    private int id;
    private String name;
    private int age;
    private String sex;
    //一对一的映射
    private IdCard card;

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", card=" + card +
                '}';
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public IdCard getCard() {
        return card;
    }
    public void setName(IdCard card) {
        this.card = card;
    }
}


//IdCard.java
package com.tyut.pojo;

public class IdCard {
    private int id;
    private String code;

    @Override
    public String toString() {
        return "IdCard{" +
                "id=" + id +
                ", code='" + code + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

}

③ 配置别名映射

在这里插入图片描述

④ 编写映射文件

<!-- IdCardMapper.xml -->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tyut.mapper.IdCardMapper">
    <select id="findCodeById" parameterType="Integer" resultType="IdCard">
        select * from tb_idcard where id=#{id}
    </select>
</mapper>    

<!-- PersonMapper.xml -->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tyut.mapper.PersonMapper">
    <select id="findPersonById" parameterType="Integer" resultMap="IdCardWithPersonResult">
        select * from tb_person where id=#{id};
    </select>
    <!--  自定义结果集映射  -->
    <resultMap id="IdCardWithPersonResult" type="person">
        <!--    主键列使用id标签来配置    -->
        <id property="id" column="id"></id>
        <!--    非主键列使用result标签    -->
        <result property="name" column="name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <!--    使用association来配置一对一映射    -->
        <association property="card" javaType="IdCard" column="card_id"
                     select="com.tyut.mapper.IdCardMapper.findCodeById">
        </association>
    </resultMap>
</mapper>

注意这里是自定义结果集映射，resultMap！

⑤ 引入映射文件
在这里插入图片描述

⑥ 编写工具类

//MyBatisUtils.java
package com.tyut.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.Reader;

public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;
    static {
        try {
            Reader reader = Resources.getResourceAsReader("MybatisConfig.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSession() {
        return sqlSessionFactory.openSession();
    }
}

为什么要编写工具类？
因为实际开发中有一些代码可能是会重复使用的，为了减少代码体积，我们不妨把这些重复的代码单独封装到一个类里面，用的时候直接调用就可以了，这个类就叫做工具类。

⑦ 编写测试类

package com.tyut.mapper;

import com.tyut.pojo.Person;
import com.tyut.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyTest {

    @Test
    public void findPersonByIdTest() {
        SqlSession session = MyBatisUtils.getSession();
        Person person = session.selectOne("com.tyut.mapper.PersonMapper.findPersonById",2);
        System.out.println(person);
        session.close();
    }
}

在这里插入图片描述

⑧ 延迟加载配置

嵌套查询方式支持懒加载，在使用 MyBatis 嵌套查询方式进行关联映射查询时，使用延迟加载在一定程度上可以降低运行消耗并提高查询效率，MyBatis 默认没有开启延迟加载，需要在 MybatisConfig.xml 中的 settings 元素内进行配置。

<settings>
  <!-- 打开延迟加载的开关 -->
  <setting name="lazyLoadingEnabled" value="true" />
  <!-- 将积极加载改为按需加载 -->
  <setting name="aggressiveLazyLoading" value="false" />
</settings>

具体效果在哪里呢？
就是在执行测试程序时，只有在用到关联表中的数据时才会去执行全部 SQL，用不着的时候就不会执行了，这样显然降低了运行消耗，而且提高了查询效率。

3.嵌套结果集实例演示

基础配置与上面的一样，所以这里我只提供部分代码。

<!-- PersonMapper.xml -->
    <select id="findPersonById2" parameterType="Integer" resultMap="IdCardWithPersonResult2">
        select *,
               p.id pid,
               c.id cid
               from tb_person p,
                    tb_idcard c
               where
                   p.card_id=c.id
               and  p.id=#{id}
    </select>
    <!--  嵌套结果集方式配置一对一映射  -->
    <resultMap id="IdCardWithPersonResult2" type="person">
        <id property="id" column="pid"></id>
        <result property="name" column="name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <!--    一对一映射    -->
        <association property="card" javaType="IdCard">
            <id property="id" column="cid"></id>
            <result property="code" column="code"></result>
        </association>
    </resultMap>

 @Test
    public void findPersonById2Test() {
        SqlSession session = MyBatisUtils.getSession();
        Person person = session.selectOne("com.tyut.mapper.PersonMapper.findPersonById2",2);
        System.out.println(person);
        session.close();
    }

在这里插入图片描述

多表查询有两种方式，嵌套查询方式意味着要分多条 SQL 语句去操作，显然这种方式的性能不好，而嵌套结果集方式只需一条 SQL 语句就可查出多表的数据，所以实际开发中，我们更倾向于使用嵌套结果集的方式进行配置。

三、一对多查询

1.collection 元素

在 MyBatis 中，通过 collection 元素来处理一对多关联关系，collection 元素的属性大部分与 association 元素相同，但其还包含一个特殊属性 —— ofType，ofType 属性与 javaType 属性对应，它用于指定实体类对象中集合类属性所包含的元素的类型。
collection 元素是 resultMap 元素的子元素，同样它也有两种配置方式，即嵌套查询和嵌套结果集查询。下面我们以用户与订单的关系为例，直接演示主流配置方式 —— 嵌套结果集查询。

2.嵌套结果集实例演示

① 准备数据库

在这里插入图片描述
在这里插入图片描述
② 编写工具类

package com.tyut.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.Reader;

public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;
    static {
        try {
            Reader reader = Resources.getResourceAsReader("MybatisConfig.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSession() {
        return sqlSessionFactory.openSession();
    }
}

③ 编写实体类

//Orders.java
package com.tyut.pojo;

public class Orders {
    private int id;
    private String number;
    private int userId;

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", number='" + number + '\'' +
                ", userId=" + userId +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }

}


//User.java
package com.tyut.pojo;

import java.util.List;

public class User {
    private int id;
    private String username;
    private String address;
    //一对多关联
    private List<Orders> ordersList;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", address='" + address + '\'' +
                ", ordersList=" + ordersList +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public List<Orders> getOrdersList() {
        return ordersList;
    }

    public void setOrdersList(List<Orders> ordersList) {
        this.ordersList = ordersList;
    }
}

④ 编写映射文件

//UsersMapper.xml
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tyut.mapper.UsersMapper">
    <select id="findUserWithOrdersById" parameterType="Integer" resultMap="userWithOrdersResult">
        select *,
              u.id uid,
              o.id oid
         from 
              tb_user u,
              tb_orders o 
         where
              u.id=o.user_id
         and 
              u.id=#{id}
    </select>
    <resultMap id="userWithOrdersResult" type="User">
        <id column="uid" property="id"></id>
        <result column="username" property="username"></result>
        <result column="address" property="address"></result>
        <!--    一对多映射    -->
        <collection property="ordersList" javaType="list" ofType="orders">
            <id property="id" column="oid"></id>
            <result property="number" column="number"></result>
        </collection>
    </resultMap>
</mapper>

⑤ 引入映射文件

在这里插入图片描述

⑥ 编写测试类

package com.tyut.mapper;

import com.tyut.pojo.User;
import com.tyut.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyTest {

    @Test
    public void findUserWithOrdersById() {
        SqlSession session = MyBatisUtils.getSession();
        User user = session.selectOne("com.tyut.mapper.UsersMapper.findUserWithOrdersById",1);
        System.out.println(user);
        session.close();
    }
}

在这里插入图片描述

字太难写了，勉强能看清吧~

四、多对多查询

对于多对多的查询，我们没有新的标签，从本质上讲，多对多的关系实质也是一对多的问题，所以我们借助中间表及 collection 标签来实现多对多的查询。
在数据库中，多对多的关联关系通常使用一个中间表来维护，中间表中添加订单 id 作为外键关联订单表的 id，中间表中添加商品 id 作为外键关联商品表的 id。下面以商品和订单为例进行讲解说明。

1.嵌套查询实例演示

① 准备数据库

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

根据订单的 id 查询订单的信息，以及订单购买的商品信息。需要准备三张表，订单表、商品表及中间表，由于上一个案例我们已经创建了一个订单表了，所以可以直接拿来用。

② 编写实体类

//Product.java
package com.tyut.pojo;

import java.util.List;

public class Product {
    private int id;
    private String name;
    private double price;
    private List<Orders> ordersList;

    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", ordersList=" + ordersList +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public List<Orders> getOrdersList() {
        return ordersList;
    }

    public void setOrdersList(List<Orders> ordersList) {
        this.ordersList = ordersList;
    }
}


//Orders.java
package com.tyut.pojo;

import java.util.List;

public class Orders {
    private int id;
    private String number;
    private int userId;
    private List<Product> productList;

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", number='" + number + '\'' +
                ", userId=" + userId +
                ", productList=" + productList +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }

    public List<Product> getProductList() {
        return productList;
    }

    public void setProductList(List<Product> productList) {
        this.productList = productList;
    }
}

③ 编写映射文件

<!-- ProductMapper.xml -->
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tyut.mapper.ProductMapper">
    <select id="findProductById" parameterType="Integer" resultType="Product">
        select * from tb_product
        where id in(select product_id from tb_ordersitem where orders_id=#{id})
    </select>
</mapper>    

<!-- OrdersMapper.xml -->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tyut.mapper.OrdersMapper">
    <select id="findOrdersById" parameterType="Integer" resultMap="orderWithProductResult">
        select * from tb_orders where id=#{id}
    </select>
    <resultMap id="orderWithProductResult" type="Orders">
        <id column="id" property="id"></id>
        <result column="number" property="number"></result>
        <!--    商品信息的映射    -->
        <collection property="productList" javaType="list" ofType="product" column="id"
        select="com.tyut.mapper.ProductMapper.findProductById">
        </collection>
    </resultMap>
</mapper>

④ 引入映射文件

在这里插入图片描述

⑤ 编写测试类

package com.tyut.mapper;

import com.tyut.pojo.Orders;
import com.tyut.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyTest {

    @Test
    public void findOrderWithProductById() {
        SqlSession session = MyBatisUtils.getSession();
        Orders order = session.selectOne("com.tyut.mapper.OrdersMapper.findOrdersById",1);
        System.out.println(order);
        session.close();
    }
}

以上是用嵌套查询的方式演示此案例，同样下面我们再以嵌套结果集方式做一个演示。

2.嵌套结果集实例演示

由于代码重复部分较多，这里仅展示核心代码。

<!-- OrdersMapper.xml -->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tyut.mapper.OrdersMapper">
    <select id="findOrdersById2" parameterType="Integer" resultMap="orderWithProductResult2">
        select o.*, p.*, o.id oid, p.id pid
        from tb_orders o, tb_product p, tb_ordersitem oi
        where
             o.id=oi.orders_id
        and  p.id=oi.product_id
        and  o.id=#{id}
    </select>
    <resultMap id="orderWithProductResult2" type="Orders">
        <id column="oid" property="id"></id>
        <result column="number" property="number"></result>
        <!--    商品信息的映射    -->
        <collection property="productList" javaType="list" ofType="product">
            <id property="id" column="pid"></id>
            <result property="name" column="name"></result>
            <result property="price" column="price"></result>
        </collection>
    </resultMap>
</mapper>

嵌套结果集方式只有一个OrdersMapper.xml 映射文件，而上面的嵌套查询方式是要写两个映射文件的！

五、自动补全 get、set 方法

这里有一个快捷方式可以直接补全实体类中的 get 和 set 方法，也就是说不用我们自己去手动编写了，这大大加快写代码速度。

① 定义好实体中的所有变量；
② 直接输入 pub 前三个字母就会出现 public String toString() 选项，回车键，直接补全@Override 下的代码；
在这里插入图片描述
③ 鼠标右键找到 Generate，然后点击 Getter and Setter，Ctrl+A 全选，最后点OK，直接自动补全后面所有的 get 和 set 方法。
在这里插入图片描述

怎么样，代码直接全部补全是不是感觉非常快乐！

栈老师不回家
关注
  • 7
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis关联映射
11-07
Mybatis关联映射 Mybatis关联映射 Mybatis关联映射 Mybatis关联映射 Mybatis关联映射
MyBatis —— 多种查询及映射关系
荔枝当大佬的博客
08-30 503
上一篇文章中荔枝梳理了有关MyBatis的相关环境配置和核心配置文件及其模板的设置和生成，而在这篇文章中荔枝会着重梳理MyBatis多种查询情况、特殊SQL执行以及两表联查时映射关系的处理。希望对需要的小伙伴有帮助~~~最近看了丙哥的文章，喜欢一句话分享给大家：你知道的越多，你不知道的越多。共勉共勉哈哈哈哈~~~
MyBatis基础应用（三）——使用MyBatis关联映射实现多表查询
路漫漫其修远兮，吾将上下而求索。小手点一波关注进阶的李仙桎，我们一起携手进步，
05-12 1781
Spring的核心容器是其他模块建立的基础，有Spring-core、Spring-beans、Spring-context、Spring-context-support和Spring-expression（String表达式语言）等模块组成。Spring 不排斥各种优秀的开源框架，相反 Spring 可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如 Struts,Hibernate、MyBatis）等的直接支持。它是一个容器管理对象，容器是装东西的，Spring 容器不装文本，数字。
Mybatis | Mybatis的“关联映射“
最新发布
m0_70720417的博客
03-05 764
Mybatis的 “关联映射” ： “关联关系” 概述 ： 1.一对一 “一对一” 关联关系 ( 嵌套查询 / 嵌套结果 (常用) ） “一对一” 关联关系 “实现方式” (例子) “嵌套查询” “嵌套结果” (常用) 2.一对多 “一对多” 关联关系 ( 嵌套查询 / 嵌套结果 (常用) ） “一对多” 关联关系 “实现方式” (例子) “嵌套结果” (常用) 3.多对多 “多对多” 关联关系 “多对多” 关联关系的 “例子” “嵌套查询” “嵌套结果” (常用) .....
认识Mybatis的关联关系映射，灵活关联表对象之间的关系
SAME_LOVE的博客
08-26 1433
关联关系映射是指通过配置映射文件，将数据库中的关联表进行关联查询，并将查询结果映射到实体类的关联属性上。通过扩展关联关系映射，可以方便地进行复杂的数据库查询操作，提高查询效率和简化数据操作的代码。
MyBatis关联关系映射详解
weixin_74268571的博客
09-04 2378
MyBatis关联关系映射详细说明一对一，一对多，多对多的关系，三种关系中嵌套查询和嵌套结果映射的处理
MyBatis关联映射
m0_62498006的博客
05-18 783
先来简单的了解一下关联映射吧，关联映射关系有一对一、一对多、多对多的关系，在开发中都会使用到，一对多其实比较多用。这些关联查询mybatis又可以使用两种方式来实现，分别为嵌套查询、嵌套结果。嵌套查询：嵌套查询其实是查询SQL语句后再进行一个(子查询)，会执行多条SQL语句,SQL语句编写比较简单，查询效率低，要多查一轮。嵌套结果：嵌套结果是一个多表查询的SQL语句，只有一条复杂的SQL语句(多表连接),SQL语句编写较为复杂，但是效率高。
mybatis关联映射
weixin_44603464的博客
06-27 289
表中多条记录对应关联表中一条记录（相当于一对多的反过来），将一对多关联中的主表与关联表交换位置后，描述此时的关系即为多对一。在嵌套结果查询中，即使实体类属性名与字段名一致，也不会进行自动映射。Oracle数据库不支持主键自增,需要采用序列(队列)生成主键值。主表中的一条记录在关联表中有多条记录(一对多)；主表中的记录在关联表中有且只有一条记录与之对应。在插入操作时,返回自动递增的主键值。例如：一个班级对应多个学生。
MyBatis的关联映射
yandao的博客
04-21 1017
结果映射（resultMap）–主要使用这两个标签association – 一个复杂类型的关联；许多结果将包装成这种类型嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用collection – 一个复杂类型的集合嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用。
Mybatis关联映射 多表查询（三种写法优缺点、主流性） 以及分步查询 延迟加载（按需加载、懒加载）
Scyth1的博客
11-04 1877
本文其实是我给自己写的保姆级教程，以防自己在新手期忘记了怎么写。。。。也方便自己时常拿出来看看
MyBatis的关联映射（多对一查询）
weixin_67286174的博客
05-10 139
2.1.2 OrdersMapper.java 添加。2.1.1 UsersMapper.java 添加。2.2.1 OrderMapper.java 添加。2.2.1 OrderMapper.xml添加。2.2.3 OrderTest.java 添加。2.1.6 测试结果。2.2.4 测试结果。
MyBatis关联映射代码
06-20
MyBatis关联映射代码
mybatis关联映射源码
12-08
MyBatis的关联映射的练习内容，可以现在博客中查看文章再选择是否需要下载。
Mybatis关联映射Demo
04-03
个人认为，这个东西，网上的资料很多都是坑人的，我这个完成了功能
MyBatis的关联映射实践报告
12-04
了解数据表之间以及对象之间的三种关联关系 2.熟悉关联关系中的嵌套查询和 嵌套结果 3.掌握一对一，一对多，和多对多关联映射作用
MyBatis关联映射：一对一、一对多-代码.zip
08-21
MyBatis关联映射：一对一、一对多-代码
企业级应用开发-MyBatis关联映射实践实验报告.docx
08-21
企业级应用开发-MyBatis关联映射实践实验报告
完整版 Java开发实训课程系列-MyBatis框架技术 03.MyBatis关联映射查询与缓存配置（共25页）.pptx
12-26
【完整课程列表】 ...完整版 Java开发实训课程系列-MyBatis框架技术 03.MyBatis关联映射查询与缓存配置（共25页）.pptx 完整版 Java开发实训课程系列-MyBatis框架技术 04.MyBatis与Spring整合开发（共21页）.pptx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

栈老师不回家

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

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

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

打赏作者

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

抵扣说明：

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

余额充值