Mybatis关系映射

最新推荐文章于 2024-02-27 08:50:20 发布
最新推荐文章于 2024-02-27 08:50:20 发布
阅读量97 收藏
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l32273/article/details/124164231
版权

一、什么是关联关系？

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

二、关联关系的分类

1.一对一

这个就好像中国人的身份证一样，每个身份证对应一个人

2.一对多

每个淘宝订单用户都对应多个订单

1.一对一 

这里提供两个表t_customer（客户表）和 t_order（订单表）

-- 一对多
-- 客户表(主表)
create table t_customer
(
  customer_id int primary key not null auto_increment,
  customer_name varchar(50) not null
);
 
-- 多对一
-- 订单表(从表)
create table t_order
(
  order_id int primary key not null auto_increment,
  order_no varchar(50) not null unique,
  cid int not null,
  foreign key(cid) references t_customer(customer_id)
);
 
-- 初始化代码
delete from t_order;
delete from t_customer;
 
-- 与mssql不一样，自动增长是可以赋值，也可以不赋值
insert into t_customer(customer_id,customer_name) values(1, 'zs');
insert into t_customer(customer_id,customer_name) values(2, 'ls');
insert into t_customer(customer_id,customer_name) values(3, 'ww');
insert into t_customer(customer_id,customer_name) values(4, 'xm');
 
insert into t_order(order_no,cid) values('P01',1);
insert into t_order(order_no,cid) values('P02',1);
insert into t_order(order_no,cid) values('P03',1);
insert into t_order(order_no,cid) values('P04',1);
insert into t_order(order_no,cid) values('P05',1);
insert into t_order(order_no,cid) values('P06',2);
insert into t_order(order_no,cid) values('P07',2);
insert into t_order(order_no,cid) values('P08',2);
insert into t_order(order_no,cid) values('P09',3);
insert into t_order(order_no,cid) values('P10',3);
 
SELECT * FROM t_customer;
SELECT * FROM t_order;

利用 generatorConfig.xml，生成实体类和方法

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
<generatorConfiguration>
    <!-- 引入配置文件 -->
    <properties resource="jdbc.properties"/>
 
    <!--指定数据库jdbc驱动jar包的位置-->
    <classPathEntry location="E:\repository\mvn-repository\mysql\mysql-connector-java\5.1.44\mysql-connector-java-5.1.44.jar"/>
 
    <!-- 一个数据库一个context -->
    <context id="infoGuardian">
        <!-- 注释 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true"/><!-- 是否取消注释 -->
            <property name="suppressDate" value="true"/> <!-- 是否生成注释代时间戳 -->
        </commentGenerator>
 
        <!-- jdbc连接 -->
        <jdbcConnection driverClass="${jdbc.driver}"
                        connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}"/>
 
        <!-- 类型转换 -->
        <javaTypeResolver>
            <!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
 
        <!-- 01 指定javaBean生成的位置 -->
        <!-- targetPackage：指定生成的model生成所在的包名 -->
        <!-- targetProject：指定在该项目下所在的路径  -->
        <javaModelGenerator targetPackage="com.zking.ssm.book.model"
                            targetProject="src/main/java">
            <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
            <property name="enableSubPackages" value="false"/>
            <!-- 是否对model添加构造函数 -->
            <property name="constructorBased" value="true"/>
            <!-- 是否针对string类型的字段在set的时候进行trim调用 -->
            <property name="trimStrings" value="false"/>
            <!-- 建立的Model对象是否 不可改变  即生成的Model对象不会有 setter方法，只有构造方法 -->
            <property name="immutable" value="false"/>
        </javaModelGenerator>
 
        <!-- 02 指定sql映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="com.zking.ssm.book.mapper"
                         targetProject="src/main/resources">
            <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>
 
        <!-- 03 生成XxxMapper接口 -->
        <!-- type="ANNOTATEDMAPPER",生成Java Model 和基于注解的Mapper对象 -->
        <!-- type="MIXEDMAPPER",生成基于注解的Java Model 和相应的Mapper对象 -->
        <!-- type="XMLMAPPER",生成SQLMap XML文件和独立的Mapper接口 -->
        <javaClientGenerator targetPackage="com.zking.ssm.book.mapper"
                             targetProject="src/main/java" type="XMLMAPPER">
            <!-- 是否在当前路径下新加一层schema,false路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>
 
        <!-- 配置表信息 -->
        <!-- schema即为数据库名 -->
        <!-- tableName为对应的数据库表 -->
        <!-- domainObjectName是要生成的实体类 -->
        <!-- enable*ByExample是否生成 example类 -->
        <!--<table schema="" tableName="t_book" domainObjectName="Book"-->
               <!--enableCountByExample="false" enableDeleteByExample="false"-->
               <!--enableSelectByExample="false" enableUpdateByExample="false">-->
            <!--&lt;!&ndash; 忽略列，不生成bean 字段 &ndash;&gt;-->
            <!--&lt;!&ndash; <ignoreColumn column="FRED" /> &ndash;&gt;-->
            <!--&lt;!&ndash; 指定列的java数据类型 &ndash;&gt;-->
            <!--&lt;!&ndash; <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> &ndash;&gt;-->
        <!--</table>-->
 
        <table schema="" tableName="t_order" domainObjectName="Order"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
            <!-- 忽略列，不生成bean 字段 -->
            <!-- <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 -->
            <!-- <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> -->
        </table>
        <table schema="" tableName="t_customer" domainObjectName="Customer"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
            <!-- 忽略列，不生成bean 字段 -->
            <!-- <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 -->
            <!-- <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" /> -->
        </table>
 
    </context>
</generatorConfiguration>

Mapper层


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

OrderMapper.xml

<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="orderId" javaType="java.lang.Integer" column="order_Id"/>
    <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>
 
<select id="queryOrderId" resultMap="ManyToOne">
      select * from t_customer c inner join t_order o on c.customer_id=o.cid
      where o.order_id=#{value}
</select>

测试

 
@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);
    }
}

2.一对多

Mapper层

@Repository
public interface OrderMapper {
    Order queryOrderId(Integer OrderId);
}

CustomerMapper.xml:

<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="orders" ofType="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="orderId" javaType="java.lang.Integer" column="order_Id"/>
    </collection>
</resultMap>
 
<select id="queryOrders" resultMap="oneToMany">
    select * from t_customer c left join t_order o on c.customer_id=o.cid
</select>

测试

@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);
    }
}

4.多对多

提供三个表t_news（新闻表）t_category（新闻类型表）t_news_category（桥接表）

-- 多对多
-- 主表
create table t_news
(
  news_id int primary key auto_increment,          -- 新闻ID：主鍵
  title varchar(50) not null                       -- 标题
);
 
-- 主表
create table t_category
(
  category_id int primary key auto_increment,      -- 类别编号：主鍵
  category_name varchar(50) not null               -- 类别名称
);
 
-- 桥接表,在关系型数据库中:多对多关系是无法直接映射的,
-- 必须将一个多对多关系转换成二个一对多关系才能进行映射
create table t_news_category
(
  id int primary key not null auto_increment,
  nid int not null,
  cid int not null,
  foreign key(nid) references t_news(news_id),
  foreign key(cid) references t_category(category_id)
);
 
 
insert into t_news(news_id,title) values(1,'110');
insert into t_news(news_id,title) values(2,'111');
insert into t_news(news_id,title) values(3,'112');
insert into t_news(news_id,title) values(4,'113');
insert into t_news(news_id,title) values(5,'114');
insert into t_news(news_id,title) values(6,'115');
insert into t_news(news_id,title) values(7,'116');
insert into t_news(news_id,title) values(8,'117');
insert into t_news(news_id,title) values(9,'118');
 
 
insert into t_category(category_id,category_name) values(1,'焦点');
insert into t_category(category_id,category_name) values(2,'国际');
insert into t_category(category_id,category_name) values(3,'社会');
insert into t_category(category_id,category_name) values(4,'房产');
insert into t_category(category_id,category_name) values(5,'财经');
insert into t_category(category_id,category_name) values(6,'娱乐');
 
 
insert into t_news_category(nid,cid) values(1,1);
insert into t_news_category(nid,cid) values(1,2);
 
insert into t_news_category(nid,cid) values(2,1);
insert into t_news_category(nid,cid) values(2,2);
 
insert into t_news_category(nid,cid) values(3,1);
insert into t_news_category(nid,cid) values(3,2);
insert into t_news_category(nid,cid) values(3,3);
 
insert into t_news_category(nid,cid) values(4,1);
insert into t_news_category(nid,cid) values(4,2);
insert into t_news_category(nid,cid) values(4,3);
insert into t_news_category(nid,cid) values(4,4);
 
 
SELECT * FROM t_news;
SELECT * FROM t_category;
SELECT * FROM t_news_category;

Mapper层

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

Mapper文件

<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>

测试加结果

@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);
    }
}
//输出
/*
queryNewsToMany：
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}]}}
 
queryCategoryToMany：
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}}
*/

俺叫牛爱芳
关注
MyBatis是如何自动装配的
天然玩家的博客
04-03 3712
MyBatis自动装配的核心4步： （1）注册BeanDefinition：org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration.AutoConfiguredMapperScannerRegistrar （2）读取MyBatis配置：通过org.mybatis.spring.boot.autoconfigure.MybatisProperties映射yml配置； （3）配置Bean sqlSessionFactory：org.mybat
Mybatis关联映射；Mybatis注解
qq_65687461的博客
04-15 2323
Mybatis关联映射 Mybatis关联映射的用途： 在实际的开发过程中，对于数据库的操作除了单表外往往会涉及到多张表，这些操作在面向对象中就涉及到了对象与对象之间的关联关系。针对多表之间的操作，MyBatis提供了关联映射，通过关联映射就可以很好的处理对象与对象之间的关联关系。 关联关系的种类： 在关系型数据库中，多表之间存在着三种关联关系，分别为一对一（1:1）、一对多（1：N）和多对多（M：N）。 一对一（1:1）：在任意一方引入对方主键作为外键。 一对多（1：N）：在“多”的一方，
mybatis自动装配
w1939481704的博客
07-27 553
generatorConfig.xml文件 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" > <generato
后端-框架-Spring-MyBatis-自动装配
CaediosViolet的博客
11-11 294
后端-框架-Spring-MyBatis-自动装配 bean标签下autowire属性 autowire value no 手动装配 byName 类名装配 byType 类型装配 constructor 构造器装配 beans标签下default-autowire属性 autowire value no 手动装配 byName 类名装配 b...
MyBatis自动配置原理
Alexon Xu的博客
12-28 1491
在springboot中，mybatis引用的jar包 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.3</version> </dependency> mybatis的配置一般放在a
springboot自动装配的实现（mybatis）
automannn
04-15 5925
   根据大牛的思路，结合自身的理解，看看mybatis的自动装配实现。 @SpringbootApplication注解：  注解  @EnableAutoConfiguration的源码：（位于SpringBootApplication同级包下）       查看EnableAutoConfigurationImportSelector.class:       查看g...
mybatis关系映射之一对多和多对一
08-26
MyBatis关系映射之一对多和多对一 MyBatis是一款流行的Java持久化框架，提供了丰富的关系映射功能。关系映射是指在数据库中建立实体之间的关联关系，例如，一对多、多对一、多对多等。今天，我们将探讨MyBatis关系...
Java MyBatis 关系映射 一对一关系
10-06
本话题主要关注MyBatis中的一对一关系映射，这是一种常见的数据库关联关系，用于描述一个实体与另一个实体之间的对应关系。 一对一关系映射在数据库设计中意味着一个表中的记录唯一对应另一个表中的记录。例如，...
Mybatis关系映射：一對多与多對一详解示例
在本文档中，我们将深入探讨MyBatis框架中的关系映射，特别是关注一对多（One-to-Many）和多对一（Many-to-One）这两种常见的数据库关联模式。本文以用户和订单为例来说明，因为一个用户可以有多个订单，而每个订单...
Spring整合其他ORM框架
11-08
Spring整合其他ORM框架：Spring整合其他ORM框架整合的时候所需要的jar包spring-orm-3.2.0.RELEASE.jar
mybatis自动配置
胖胖的博客
02-24 397
一、SpringBoot整合MyBatis注解版 1.加入依赖 父工程依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.4.1</version>
MyBatis自动装配问题
明明如月的技术博客
12-13 3014
最近遇到同事在MyBatis的 mapper.xml文件里，定义了&lt;resultMap&gt;标签，但是里面并没有&lt;result&gt;将数据库的列映射为java对象的属性的标签，我认为这种写法是错误的，这样会导致映射不到实体的属性上。 之前以为mapper.xml文件如果select标签指定为resultMap="XXX",就是是通过resultMap的&lt;result&gt;...
Spring 加强版 ORM 框架 Spring Data 入门
大鹏的博客
05-23 1025
Spring 中有多种操作数据库的方式，通常来说我们优先选择的是 MyBatis，如果业务比较简单我们还会使用 JdbcTemplate，另外据说国外使用 spring-data-jpa 比较多？ 最近发现了 Spring 中另一款操作关系型数据库的框架，相对 JdbcTemplate 来说使用上又简化了一些。 由于 Spring Data 内容较多，分为上下两篇介绍，本篇我们先介绍一些 Spring Data 的基础知识，下篇再介绍 spring-data-jdbc。...
Spring之ORM框架
AnythingIs_possible的博客
03-15 1768
·~·ORM框架 Spring是一个容器，是用来装对象的，当然需要配置文件用来连接 ORM全称对象关系映射（Object/Relation Mapping），指将Java对象状态自动映射到关系数据库中的数据上，从而提供透明化的持久化支持，即把一种形式转化为另一种形式。 对象与关系数据库之间是不匹配，我们把这种不匹配称为阻抗失配，主要表现在： 关系数据库首先不支持面向对象技术如继...
SpringBoot源码解读与原理分析(三十五)SpringBoot整合MyBatis时的核心组件自动装配
最新发布
挑灯日记 记录自己
02-27 1289
在实际SpringBoot项目开发中，更多的场景是整合成熟的持久层框架来完成与数据库的交互。目前比较流行的持久层框架包括SpringData JPA（底层默认依赖Hibernate）和MyBatis。SpringData本身属于Spring生态的一部分，而MyBatis是第三方框架。本章以MyBatis整合SpringBoot的核心场景启动器为切入点，研究MyBatis如何完成与SpringBoot的场景整合。MyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。
spring集成ORM框架
hobson的专栏
06-23 457
Spring将数据访问过程中固定的和可变的部分明确划分为两个不同的类： ①模板（template）：管理过程中固定的部分（事务控制、管理资源、处理异常） ②回调（callback）：处理自定义的数据访问代码（创建语句、绑定参数、整理结果集） DBCP包含了多个提供连接池功能的数据源；其中BasicDataSource是最常用的；在org.apache.comm
spring整合ORM框架
逍遥壮士
08-25 462
注：本文篇幅有点长，总字数3万多，所以建议各位下载源码学习。（如需要请收藏！转载请声明来源，谢谢！）代码下载：https://gitee.com/hong99/spring/issues...
SpringBoot 构建ORM框架
myli92的博客
02-19 2426
目前常用的ORM框架有 Mybatis（batis）、MybatisPlus，Hibernate、Jpa等几个框架，今天就简单介绍一下搭建Mybatisplus框架的流程。 1.增加依赖 <dependencies> <!-- 第一步：选择ORM框架，使用springboot整合mybatis-plus依赖包--> <dependency> <groupId>com.baomidou
mybatis关系映射
09-04
在MyBatis中，关系映射是通过XML配置文件或注解来完成的。 关系映射的主要目的是将数据库表中的行数据映射到Java对象上，使开发者能够通过操作对象来实现对数据库的操作，而不需要直接编写SQL语句。在MyBatis中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值