Mybatis之关联关系映射

已于 2022-04-03 21:20:22 修改
阅读量509 收藏 1
点赞数
文章标签： spring maven
于 2022-04-03 21:15:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64987028/article/details/123942515
版权

目录

一、什么是关联关系？

二、关联关系示例

一、什么是关联关系？

关联关系是指类之间的引用关系，如果类A与类B关联，那么类A将被定义成类B的属性。

关联关系的分类：

关联关系的分类：一对一，一对多，多对一，多对多
一对多：一本书对应多种书本类型，例如：西游记 -> 神话、古典、名著
多对一：一种书本类型对应多本数，例如：神话 -> 西游记、山海经、聊斋志异
多对多：永远视为两个一对多
一个人负责多个项目开发，例如：张三负责 A B C
一个项目由多个人来开发，例如：A项目由张三、李四、王五来开发
 

二、关联关系示例

       实现步骤：

1.将数据表导入数据库中

2.通过mybatis-generator插件生成实体类、mapper、model

   1）配置mybatis-generator插件生成文件位置
   2）修改generatorConfig.xml配置文件的生成目录(mapper和model)及对应生成关系

3.修改Customer、Order实体类
   1）实现序列化接口
   2）建立实体映射关联关系（一对多、多对一）
   #一对多：一个客户对应多个订单
   private List<Order> orders=new ArrayList<Order>();

   #多对一：多个订单对应一个客户（一个订单对应一个客户）
   private Customer customer;
   

1、一对一

        例如：就像一个中国公民只对应一张身份证，一张身份证也只对应一个中国公民

2、一对多、多对一

        例如：一个客户可以对应多个商品订单，而多个商品订单也可以对应一个客户。

1、我们可以新建一张t_customer（客户表）和一张t_order（订单表）来进行举例。

t_customer（客户表）

 t_order（订单表）

 2、通过mybatis-generator插件生成实体类、mapper、model

实体类

Order

package com.zking.ssm.book.model;

/**
 * 建立实体层面的关联关系
 * 多对一：多个订单对一一个客户，（一个订单对应一个客户）
 */
public class Order {
    private Integer orderId;

    private String orderNo;

    private Integer cid;

    //关联关系是指类之间的引用关系，如果类A与类B关联，那么类A将被定义成类B的属性。
    //A:订单（order） B：客户（customer）
    //多对一
    private Customer customer;

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    public Order(Integer orderId, String orderNo, Integer cid) {
        this.orderId = orderId;
        this.orderNo = orderNo;
        this.cid = cid;
    }

    public Order() {
        super();
    }

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }

    public String getOrderNo() {
        return orderNo;
    }

    public void setOrderNo(String orderNo) {
        this.orderNo = orderNo;
    }

    public Integer getCid() {
        return cid;
    }

    public void setCid(Integer cid) {
        this.cid = cid;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderId=" + orderId +
                ", orderNo='" + orderNo + '\'' +
                ", cid=" + cid +
                ", customer=" + customer +
                '}';
    }
}

Customer 

package com.zking.ssm.book.model;

import java.util.ArrayList;
import java.util.List;

/**
 * 建立实体层面的关联关系
 * 一对多：一个客户（customer）对应多个订单（order）
 */
public class Customer {
    private Integer customerId;

    private String customerName;

    //关联关系是指类之间的引用关系，如果类A与类B关联，那么类A将被定义成类B的属性。
    //A:订单（order） B：客户（customer）
    //一对多
    private List<Order> oders=new ArrayList<>();

    public List<Order> getOders() {
        return oders;
    }

    public void setOders(List<Order> oders) {
        this.oders = oders;
    }

    public Customer(Integer customerId, String customerName) {
        this.customerId = customerId;
        this.customerName = customerName;
    }

    public Customer() {
        super();
    }

    public Integer getCustomerId() {
        return customerId;
    }

    public void setCustomerId(Integer customerId) {
        this.customerId = customerId;
    }

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "customerId=" + customerId +
                ", customerName='" + customerName + '\'' +
                ", oders=" + oders +
                '}';
    }
}

mapper接口

order的mapper接口

package com.zking.ssm.book.mapper;

import com.zking.ssm.book.model.Customer;
import com.zking.ssm.book.model.Order;
import org.springframework.stereotype.Repository;

@Repository
public interface OrderMapper {
    Order queryoderById(Integer orderId);
}

Customer的mapper接口 

package com.zking.ssm.book.mapper;

import com.zking.ssm.book.model.Customer;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface CustomerMapper {
   List<Customer> querycustomer();
}

对应的接口方法mapper.xml

orderMapper.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 namespace="com.zking.ssm.book.mapper.OrderMapper" >
  <resultMap id="BaseResultMap" type="com.zking.ssm.book.model.Order" >
    <constructor >
      <idArg column="order_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="order_no" jdbcType="VARCHAR" javaType="java.lang.String" />
      <arg column="cid" jdbcType="INTEGER" javaType="java.lang.Integer" />
    </constructor>
  </resultMap>
  <resultMap id="ManyToOne" type="com.zking.ssm.book.model.Order">
    <id property="orderId" javaType="java.lang.Integer" column="order_id"/>
    <result property="orderNo" javaType="java.lang.String" column="order_no"/>
    <result property="cid" javaType="java.lang.Integer" column="cid"/>
    <association property="customer" javaType="com.zking.ssm.book.model.Customer">
      <id property="customerId" javaType="java.lang.Integer" column="customer_id"/>
      <result property="customerName" javaType="java.lang.String" column="customer_name"/>
    </association>

  </resultMap>
  <sql id="Base_Column_List" >
    order_id, order_no, cid
  </sql>
  <select id="queryoderById" resultMap="ManyToOne">
    select
        *
    from t_customer c
    inner join t_order o
    on c.customer_id=o.cid
    where o.order_id=#{orderId}
  </select>

</mapper>

CustomerMapper.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 namespace="com.zking.ssm.book.mapper.CustomerMapper" >
  <resultMap id="BaseResultMap" type="com.zking.ssm.book.model.Customer" >
    <constructor >
      <idArg column="customer_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="customer_name" jdbcType="VARCHAR" javaType="java.lang.String" />
    </constructor>
  </resultMap>
  <resultMap id="oneToMany" type="com.zking.ssm.book.model.Customer">
    <id property="customerId" javaType="java.lang.Integer" column="customer_id"/>
    <result property="customerName" javaType="java.lang.String" column="customer_name" />
    <collection property="oders" ofType="com.zking.ssm.book.model.Order">
      <id property="orderId" javaType="java.lang.Integer" column="order_id"/>
      <result property="cid" javaType="java.lang.Integer" column="cid"/>
      <result property="orderNo" javaType="java.lang.String" column="order_no"/>
    </collection>
  </resultMap>
  <sql id="Base_Column_List" >
    customer_id, customer_name
  </sql>
  <select id="querycustomer" resultMap="oneToMany">
       select
             *
       from t_customer c left join t_order o
    on c.customer_id=o.cid
  </select>
</mapper>

测试类Test

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml"})
public class OrderServiceImplTest{
    @Autowired
    private IOrderService iOrderService;
 
 
    @Test
    public void queryOrderId() {
        Order order = iOrderService.queryOrderId(3);
        System.out.println(order);
    }
}

 运行结果

多对一的关系，多个订单对应一个客户

Order{orderId=3, orderNo='P03', cid=null, customer=Customer{customerId=1, customerName='zs', orders=null}}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml"})
public class CustomerServiceImplTest{
 
    @Autowired
    private ICustomerService iCustomerService;
 
    @Test
    public void queryOrders() {
        List<Customer> orders = iCustomerService.queryOrders();
        orders.forEach(System.out::println);
    }
}

一对多的关系，一个客户对应多个订单

Customer{customerId=1, customerName='zs', orders=[Order{orderId=1, orderNo='P01', cid=null, customer=null}, Order{orderId=2, orderNo='P02', cid=null, customer=null}, Order{orderId=3, orderNo='P03', cid=null, customer=null}, Order{orderId=4, orderNo='P04', cid=null, customer=null}, Order{orderId=5, orderNo='P05', cid=null, customer=null}]}
Customer{customerId=2, customerName='ls', orders=[Order{orderId=6, orderNo='P06', cid=null, customer=null}, Order{orderId=7, orderNo='P07', cid=null, customer=null}, Order{orderId=8, orderNo='P08', cid=null, customer=null}]}
Customer{customerId=3, customerName='ww', orders=[Order{orderId=9, orderNo='P09', cid=null, customer=null}, Order{orderId=10, orderNo='P10', cid=null, customer=null}]}
Customer{customerId=4, customerName='xm', orders=[]}

3、多对多

多对多关系是关系数据库中两个表之间的一种关系， 该关系中第一个表中的一个行可以与第二个表中的一个或多个行相关。第二个表中的一个行也可以与第一个表中的一个或多个行相。

举例：我们以以下三张表来示例

 t_news（新闻）

t_category（新闻类型）

 t_news_category（连接表）

t_news

 t_category

  t_news_category

创建相应的实体类对象、mapper层接口和mapper文件  

News

 
public class News {
    private Integer newsId;
 
    private String title;
 
    private List<Category> categoryList;
 
    public List<Category> getCategoryList() {
        return categoryList;
    }
 
    public void setCategoryList(List<Category> categoryList) {
        this.categoryList = categoryList;
    }
 
    public News(Integer newsId, String title) {
        this.newsId = newsId;
        this.title = title;
    }
 
    public News() {
        super();
    }
 
    public Integer getNewsId() {
        return newsId;
    }
 
    public void setNewsId(Integer newsId) {
        this.newsId = newsId;
    }
 
    public String getTitle() {
        return title;
    }
 
    public void setTitle(String title) {
        this.title = title;
    }
 
 
    @Override
    public String toString() {
        return "News{" +
                "newsId=" + newsId +
                ", title='" + title + '\'' +
                ", categoryList=" + categoryList +
                '}';
    }
}

 Category

public class Category {
    private Integer categoryId;
 
    private String categoryName;
 
    private List<News> newsList;
 
 
    public List<News> getNewsList() {
        return newsList;
    }
 
    public void setNewsList(List<News> newsList) {
        this.newsList = newsList;
    }
 
    public Category(Integer categoryId, String categoryName) {
        this.categoryId = categoryId;
        this.categoryName = categoryName;
    }
 
    public Category() {
        super();
    }
 
    public Integer getCategoryId() {
        return categoryId;
    }
 
    public void setCategoryId(Integer categoryId) {
        this.categoryId = categoryId;
    }
 
    public String getCategoryName() {
        return categoryName;
    }
 
    public void setCategoryName(String categoryName) {
        this.categoryName = categoryName;
    }
 
    @Override
    public String toString() {
        return "Category{" +
                "categoryId=" + categoryId +
                ", categoryName='" + categoryName + '\'' +
                ", newsList=" + newsList +
                '}';
    }
}

News_Category 

public class News_Category {
    private Integer id;
 
    private Integer nid;
 
    private Integer cid;
 
    private News news;
    private Category category;
 
    public News getNews() {
        return news;
    }
 
    public void setNews(News news) {
        this.news = news;
    }
 
    public Category getCategory() {
        return category;
    }
 
    public void setCategory(Category category) {
        this.category = category;
    }
 
    public News_Category(Integer id, Integer nid, Integer cid) {
        this.id = id;
        this.nid = nid;
        this.cid = cid;
    }
 
    public News_Category() {
        super();
    }
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public Integer getNid() {
        return nid;
    }
 
    public void setNid(Integer nid) {
        this.nid = nid;
    }
 
    public Integer getCid() {
        return cid;
    }
 
    public void setCid(Integer cid) {
        this.cid = cid;
    }
 
    @Override
    public String toString() {
        return "News_Category{" +
                "id=" + id +
                ", nid=" + nid +
                ", cid=" + cid +
                ", news=" + news +
                ", category=" + category +
                '}';
    }
}

mapper层接口   


News_CategoryMapper
 
@Repository
public interface News_CategoryMapper {
    //根据新闻id查询
    List<News_Category> queryNewsToMany(Integer newsId);
    //根据类型id查询
    List<News_Category> queryCategoryToMany(Integer categoryId);

mapper文件 

News_CategoryMapper.xml
 
<resultMap id="ManyToMany" type="com.zking.ssm.book.model.News_Category">
    <id property="id" javaType="java.lang.Integer" column="id"/>
    <result property="nid" javaType="java.lang.Integer" column="nid"/>
      <result property="cid"  javaType="java.lang.Integer" column="cid"/>
    <association property="news" javaType="com.zking.ssm.book.model.News">
      <id property="newsId" javaType="java.lang.Integer"  column="category_Id"/>
     <result property="title" javaType="java.lang.String" column="title"/>
    </association>
 
     <association property="category" javaType="com.zking.ssm.book.model.Category">
         <id property="categoryId" javaType="java.lang.Integer"  column="category_Id"/>
         <result property="categoryName" javaType="java.lang.String" column="category_Name"/>
     </association>
 
  </resultMap>
 
 
 
<select id="queryNewsToMany" resultMap="ManyToMany">
        select
        *
        from
        t_news_category nc left join t_news n on nc.nid=n.news_id
        left join t_category c on nc.cid =c.category_id where n.news_id=#{value}
  </select>
 
  <select id="queryCategoryToMany" resultMap="ManyToMany">
      select
      *
      from
      t_news_category nc left join t_news n on nc.nid=n.news_id
      left join t_category c on nc.cid =c.category_id where c.category_id=#{value}
  </select>

Test测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml"})
public class News_CategoryServiceImplTest{
    @Autowired
    private INews_CategoryService iNews_categoryService;
 
    @Test
    public void queryNewsToMany() {
        List<News_Category> news = iNews_categoryService.queryNewsToMany(1);
        news.forEach(System.out::println);
    }
 
    @Test
    public void queryCategoryToMany() {
        List<News_Category> categorys = iNews_categoryService.queryCategoryToMany(1);
        categorys.forEach(System.out::println);
    }
}

结果：

News_Category{id=1, nid=1, cid=1, news=News{newsId=1, title='110', categoryList=null}, category=Category{categoryId=1, categoryName='焦点', newsList=[News{newsId=1, title='110', categoryList=null}]}}
News_Category{id=2, nid=1, cid=2, news=News{newsId=2, title='110', categoryList=null}, category=Category{categoryId=2, categoryName='国际', newsList=[News{newsId=2, title='110', categoryList=null}]}}





News_Category{id=1, nid=1, cid=1, news=News{newsId=1, title='110', categoryList=null}, category=Category{categoryId=1, categoryName='焦点', newsList=null}}
News_Category{id=3, nid=2, cid=1, news=News{newsId=1, title='111', categoryList=null}, category=Category{categoryId=1, categoryName='焦点', newsList=null}}
News_Category{id=5, nid=3, cid=1, news=News{newsId=1, title='112', categoryList=null}, category=Category{categoryId=1, categoryName='焦点', newsList=null}}
News_Category{id=8, nid=4, cid=1, news=News{newsId=1, title='113', categoryList=null}, category=Category{categoryId=1, categoryName='焦点', newsList=null}}

以上仅供参考，若有意见，私信作者大大~ 

周大福ye
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Mybatis中映射文件和Mapper接口有什么对应关系吗？
泗水六年的博客
07-24 1084
映射文件中的mapper标签的namespace属性值必须要和对应的Mapper接口路径保持一致。映射文件中SQL语句的parameterType要和Mapper接口中方法的参数类型保持一致。映射文件中SQL语句的resultType要和Mapper接口中的方法的返回值类型保持一致。映射文件中SQL语句的ID要和Mapper接口中的方法名保持一致。...
MyBatis配置文件（二）：Mapper映射文件详解
pan_junbiao的博客
12-07 1万+
Mapper顾名思义就是“映射”的意思，Mapper文件就是MyBatis中SQL语句的配置文件，其会在运行时加载SQL语句并映射相应参数。在MyBatis的全局配置文件SqlMapConfig.xml（mybatis-config.xml），其中就有mapper文件的资源路径的配置，因为创建SqlSessionFactory时会加载全局配置文件SqlMapConfig.xml，这说明Mapper...
Mybatis（五）------Mybatis执行Mapper接口的方法流程
qq_35599414的博客
04-10 3648
在java中常用的动态代理一般有两种方式，jdk动态代理和cglib动态代理。上面我讲了先通过动态代理获取Mappper的代理对象，而代理方法invoke方法（代理方法调用时会调用，代理方法逻辑是通过Mapperproxy类，而代理对象的创建时通过MapperProxyFactory工厂实例化MapperProxy对象返回）中创建一个MapperMethod对象（用来描述Mappe接口中方法信息的对象），然后通过调用该对象的execute方法去执行sql语句。
Mapper 文件与接口的映射
CoderLi
05-12 1304
我们在使用 Mybatis 的时候、只需要定义一个 Mapper xml 文件和一个对应的 Mapper 接口、并需要实现该接口、即可在程序中使用该 Mapper 接口、调用里面的方法对其进行查询(当然 xml 中的 namespace 要关联接口)。 那么这个功能是怎么实现的呢 ？ MapperRegistry 我们知道在使用 Mybatis 的时候都会去创建一个 Configuration 类、而在这个类中、则会创建一个 MapperRegistry public class MapperRegist.
Mybatis中mapper是怎么和XMl关联起来的
daliucheng的博客
09-04 5398
Mybatis中mapper是怎么和XMl关联起来的 从源码来分析，通过Mybatis的都知道，必须指定nameSpace为Mapper的全限定类名。这样就能关联起来。Mapper的实现肯定是动态dialing，在InvocationHandler中做增强。这里就来分析分析具体是怎么做的？ 在下面分析的时候，源码看起来比较枯燥，并且涉及到的东西很多。分析的时候设计的东西多，容易走偏。我尽量回归主题。 1. XML文件解析 这里的xml解析比较繁琐，如果逐行来分析的话，很多很多，这里就挑主线来分析了。之后会分
Mybatis一对多关联关系映射实现过程解析
08-25
Mybatis的一对多关联关系映射实现过程解析 Mybatis是一款基于Java的持久层框架，它提供了对数据库的操作接口，包括数据的增删改查等操作。在实际开发中，我们经常会遇到一对多关联关系映射的问题，例如用户和订单...
MyBatis的关联映射实践报告
12-04
了解数据表之间以及对象之间的三种关联关系 2.熟悉关联关系中的嵌套查询和 嵌套结果 3.掌握一对一，一对多，和多对多关联映射作用
MyBatis关联映射代码
06-20
"关联映射"是MyBatis中的一个重要概念，用于处理数据库中表之间的关联关系，比如一对一、一对多、多对一和多对多的关系。下面将详细介绍MyBatis的关联映射以及如何在代码中实现。 关联映射是MyBatis通过XML配置文件...
SpringBoot中mybatis表关联映射关系(一对多嵌套：结果方式)
07-11
SpringBoot 中 MyBatis 表关联映射关系（一对多嵌套：结果方式） 在 SpringBoot 中，MyBatis 是一个非常流行的持久层框架，它提供了强大的持久化功能，能够将 Java 对象与数据库表进行映射。在实际开发中，我们经常...
MyBatis的关联映射-资料.rar
最新发布
03-21
在MyBatis中，关联映射是实现对象关系映射（ORM）的重要一环，用于处理复杂的数据库表之间的关联关系。关联映射允许我们在一个查询中获取多个相关联的对象，使得数据的检索更为便捷高效。 关联映射主要通过XML配置...
Mybatis-Mapper映射文件的映射方式以及映射关系
yz_blanks的博客
11-16 946
一、一对一映射关系 举例：Student和Address是一对一关系 建表语句: drop table students; drop table addresses; 如果需要可以使用 cascade constraints; create table addresses( addr_id number primary key, str...
深入理解MyBatis(二)--Mapper
striveb的博客
06-01 856
GitHub：https://github.com/JDawnF 一、Mapper接口的工作原理 Mapper 接口，对应的关系如下： 接口的全限名，就是映射文件中的 "namespace" 的值。 接口的方法名，就是映射文件中 MappedStatement 的 "id" 值。 接口方法内的参数，就是传递给 SQL 的参数。 Mapper 接口是没有实现类的，当...
MybatisPlus 实体类与数据库表映射关系&MybatisPlus：ORM思想
热门推荐
qq_43842093的博客
08-27 1万+
在开发中可能会遇到MyBatis-Plus使用实体类属性进行SQL操作，但是不用存到数据库中去查找，这时候我们的实体中有这个属性，但是数据库的表中没有这个字段(即：实体类属性非数据库表字段)，如果不做处理就会报错。例如MyUserTable 对应的数据库表为 my_user_table;TEMyUserTable 对应表名为t_e_my_user_table;在类名上方添加@TableName(“my_user_table”)在实体类的属性上面加上这个注解后，此字段就不会映射数据库了。......
Mybatis使用@Mapper和@MapperScan注解实现映射关系
pan_junbiao的博客
06-13 2935
MyBatis与Spring整合后需要实现实体和数据表的映射关系。 实现实体和数据表的映射关系可以在Mapper类上添加@Mapper注解，如下代码： /** * 用户信息Mapper动态代理接口 * @author pan_junbiao **/ @Mapper @Repository public interface UserMapper { /** * 新增用户，并获取自增主键 */ @Insert("INSERT INTO tb_user(user_a
一对多mysql mapper文件_【Mybatis】一对多、多对一关系映射
weixin_28900461的博客
01-30 306
Mybatis和hibernate比起来，笔者认为hibernate比较适合懒人用，mybatis比较灵活易学，要自己写sql语句，适合喜欢写sql的用。不过个人还是喜欢hibernate多一点，毕竟先入为主。。下午有空，写了一个关于用强大的ResultMap来进行一对多，多对一的关系映射。详细如下：1.数据库表(User、Menu)假设一个用户(User)对应多个菜单(Menu)。在设计数据库表...
Mybatis原理2 — mapper映射文件的解析
vanchine的博客
01-10 701
XMLMapperBuilder的parse()方法调用configurationElement()用于解析xml映射文件，和解析mybatis配置文件一样，仅仅只是将配置的数据和初始化数据准备好，都加载在全局配置configuration中 private void configurationElement(XNode context) { //root标签就是mapper：<mapper namespace="cn.mytest.mapper.StudentMapper"> Stri
MyBatis - mapper映射文件详解
宋同学shl
11-20 1439
0. 工程搭建 照例，我们还是先来搭建一个新的工程，前面的configuration工程中已经有点乱了。工程名我们就叫它mybatis-03-mapper吧，导入的依赖跟之前一样，然后精简一下之前的代码。 拷贝完成后的工程结构及文件应该是这样的： 里面大部分的代码都是不用变的，只需要把 MyBatis 全局配置文件精简一下： <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration ...
MyBatis建立Mapper接口与Mapper.xml文件之间的映射关系
小景的博客
06-28 3502
有Mapper接口文件UserInfoMapper.java，以及相应的XML文件UserInfo.xml，如何建立两者的映射关系？ 在UserInfo.xml的<mapper>标签中加上namespace属性，如下所示： <mapper namespace="com.mapper.UserInfoMapper"> ... </mapper> ...
Mapper接口和映射文件是何时关联的
weixin_44730681的博客
08-17 229
mybatis关系关联映射
09-13
MyBatis是一种持久化框架，它可以通过配置文件或注解来进行关系关联映射。在MyBatis中，关系关联映射主要通过以下几种方式实现： 1. 一对一关联映射：通过在对象之间定义关联关系，可以使用嵌套查询或嵌套结果映射...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值