• Mybatis 快速入门之 关联关系映射

    目录

    一：基本概念

    二：关联关系的分类

    一对一，一对多，多对一，多对多

    关系的撰述：

    一对多：一本书对应多种书本类型，例如：西游记 -> 神话、古典、名著

    多对一：多本书指向一种书本类型，例如：西游记、山海经、聊斋志异 -> 神话  

    多对多：永远视为两个一对多

    一个人负责多个项目开发，例如：张三负责 A B C

    一个项目由多个人来开发，例如：A项目由张三、李四、王五来开发

    三：实现关联关系的操作步骤

    案例一：实现一对多关系

           一对多：一个A类类型对应多个B类类型的情况，需要在A类中以集合的方式引入B类类型的对象，在B类中定义A类类型的属性a， 在多的一方，添加一的一方的主键作为外键

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

    2.通过mybatis-generator插件生成dao、mapper、model层

    重点：

    客户实体类----Customer：

    CustomerMapper:

    3..配置mybatis关联映射文件------CustomerMapper.xml

    属性解析：

    servicej接口类与实现类:

    4.junit4单元测试

    案例二：实现多对一关系

    建立实体层面的关联关系： 多对一:多个订单对应一个客户（一个订单对应唯一一个客户）

    订单实体类----order

    1.orderMapper层

    2.配置mybatis关联映射文件------OrderMapper.xml

     在元素中，包含了一个子元素，MyBatis通过该元素来处理一对多关联关系。

    在元素中，包含了一个子元素，MyBatis就是通过该元素来处理一对一关联关系。

    3.servicej接口类与实现类:

    4.junit4单元测试

    案例三：实现多对多关系

    2.通过mybatis-generator插件生成dao、mapper、model层

    NewsCategoryMapper：

    3.配置mybatis关联映射文件

    4.servicej接口类与实现类:

    5.junit4单元测试

    一：基本概念

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

    以下例子可以表现类之间的引用关系：

      Adress类：

    1. public class Address{
    2.    private String name;
    3. }

    B类：

    1. public class B{
    2.    private String sid;
    3.    private Float score;
    4.    private Address address;   
    5. }

           adress这个类被定义成类B的属性，可以通过B类来调用adress类的相关属性，它们之间存在着引用关系

    二：关联关系的分类

    • 一对一，一对多，多对一，多对多

    关系的撰述：

    • 一对多：一本书对应多种书本类型，例如：西游记 -> 神话、古典、名著

    • 多对一：多本书指向一种书本类型，例如：西游记、山海经、聊斋志异 -> 神话  

    • 多对多：永远视为两个一对多

    • 一个人负责多个项目开发，例如：张三负责 A B C

    • 一个项目由多个人来开发，例如：A项目由张三、李四、王五来开发

    三：实现关联关系的操作步骤

    • 案例一：实现一对多关系

           一对多：一个A类类型对应多个B类类型的情况，需要在A类中以集合的方式引入B类类型的对象，在B类中定义A类类型的属性a， 在多的一方，添加一的一方的主键作为外键

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

    1. -- 一对多
    2. -- 客户表(主表)
    3. create table t_customer
    4. (
    5.   customer_id int primary key not null auto_increment,
    6.   customer_name varchar(50) not null
    7. );
    8.  
    9. -- 多对一
    10. -- 订单表(从表)
    11. create table t_order
    12. (
    13.   order_id int primary key not null auto_increment,
    14.   order_no varchar(50) not null unique,
    15.   cid int not null,
    16.   foreign key(cid) references t_customer(customer_id)
    17. );
    18.  
    19.  
    20. -- 初始化代码
    21. delete from t_order;
    22. delete from t_customer;
    23.  
    24. -- 与mssql不一样，自动增长是可以赋值，也可以不赋值
    25. insert into t_customer(customer_id,customer_name) values(1, 'zs');
    26. insert into t_customer(customer_id,customer_name) values(2, 'ls');
    27. insert into t_customer(customer_id,customer_name) values(3, 'ww');
    28. insert into t_customer(customer_id,customer_name) values(4, 'xm');
    29.  
    30. insert into t_order(order_no,cid) values('P01',1);
    31. insert into t_order(order_no,cid) values('P02',1);
    32. insert into t_order(order_no,cid) values('P03',1);
    33. insert into t_order(order_no,cid) values('P04',1);
    34. insert into t_order(order_no,cid) values('P05',1);
    35. insert into t_order(order_no,cid) values('P06',2);
    36. insert into t_order(order_no,cid) values('P07',2);
    37. insert into t_order(order_no,cid) values('P08',2);
    38. insert into t_order(order_no,cid) values('P09',3);
    39. insert into t_order(order_no,cid) values('P10',3);
    40.  
    41.  
    42.  
    43. SELECT * FROM t_customer;
    44. SELECT * FROM t_order;

    2.通过mybatis-generator插件生成dao、mapper、model层

    如果有兴趣了解插件的配置，可以参考之前的博客：

    nullMVC全名是ModelViewCotroller,是模型(model)——视图(view)——控制器（controller）的缩写,是一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码自定义MVCSSMaction(中转站-----servlet类)controller(控制层)biz(业务逻辑处理层)servicedao(数据访问层)mapperIXxxDAO.java(接口)XxxMapper.java(接口)XxxDAOImpl.java(实现类)......https://blog.csdn.net/qq_61313896/article/details/125969558

    重点：

    • 建立实体层面的关联关系：

            一对多:一个客户(customer)对应多个订单(order)

    如果要建立一对多的关系，则要在客户实体类建立关系：
      private List orders=new ArrayList<>();

    客户实体类----Customer：

    1. package com.tangyuan.model;
    2.  
    3. import lombok.ToString;
    4.  
    5. import java.util.ArrayList;
    6. import java.util.List;
    7.  
    8. /**
    9.  * 建立实体层面的关联关系：
    10.  * 一对多:一个客户(customer)对应多个订单(order)
    11.  */
    12.  
    13. public class Customer {
    14.     private Integer customerId;
    15.  
    16.     private String customerName;
    17.  
    18.     //A:订单(Order) B:客户(Customer)
    19.     //一对多
    20.     private List orders=new ArrayList<>();
    21.  
    22.  
    23.     public Customer(Integer customerId, String customerName) {
    24.         this.customerId = customerId;
    25.         this.customerName = customerName;
    26.     }
    27.  
    28.     public List getOrders() {
    29.         return orders;
    30.     }
    31.  
    32.     public void setOrders(List orders) {
    33.         this.orders = orders;
    34.     }
    35.  
    36.     public Customer() {
    37.         super();
    38.     }
    39.  
    40.     public Integer getCustomerId() {
    41.         return customerId;
    42.     }
    43.  
    44.     public void setCustomerId(Integer customerId) {
    45.         this.customerId = customerId;
    46.     }
    47.  
    48.     public String getCustomerName() {
    49.         return customerName;
    50.     }
    51.  
    52.     public void setCustomerName(String customerName) {
    53.         this.customerName = customerName;
    54.     }
    55.  
    56.     @Override
    57.     public String toString() {
    58.         return "Customer{" +
    59.                 "customerId=" + customerId +
    60.                 ", customerName='" + customerName + '\'' +
    61.                 ", orders=" + orders +
    62.                 '}';
    63.     }
    64. }

    CustomerMapper:

    1. package com.tangyuan.mapper;
    2.  
    3. import com.tangyuan.model.Customer;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. import java.util.List;
    7.  
    8. @Repository
    9. public interface CustomerMapper {
    10.  
    11.     /**
    12.      * 查询所有
    13.      * @return
    14.      */
    15.     List queryCustomer();
    16.  
    17.  
    18. }

    3..配置mybatis关联映射文件------CustomerMapper.xml

    1.  <resultMap id="one2many" type="Customer">
    2.         <id column="customer_id" property="customerId"/>
    3.         <result column="customer_name" property="customerName"/>
    4.         
    5.         
    6.         <collection property="orders" ofType="Order">
    7.             <id column="order_id" property="orderId"/>
    8.             <result column="order_no" property="orderNo"/>
    9.         collection>
    10.     resultMap>

    属性解析：

                元素表示的是结果映射集，是 MyBatis 中最重要也是最强大的元素，主要是用来定义映射规则、级联的更新以及定义类型转化器等。

                 在元素中，包含了一个子元素，MyBatis通过该元素来处理一对多关联关系

         包含一个特殊属性ofType，它用于指定实体对象中集合类属性所包含的元素类型

          Property：指定映射到的实体类对象属性，与表字段一一对应

          Column：指定表中对应的字段

          javaType：指定映射到实体对象属性的类型

          Select：指定引入嵌套查询的子SQL语句，该属性用于关联映射中的嵌套查询

     完整代码如下：

    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    3. <mapper namespace="com.tangyuan.mapper.CustomerMapper" >
    4.   <resultMap id="BaseResultMap" type="com.tangyuan.model.Customer" >
    5.     <constructor >
    6.       <idArg column="customer_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
    7.       <arg column="customer_name" jdbcType="VARCHAR" javaType="java.lang.String" />
    8.     constructor>
    9.   resultMap>
    10.   <resultMap id="oneToMany" type="com.tangyuan.model.Customer">
    11.     
    12.     <id property="customerId" javaType="java.lang.Integer" column="order_id"/>
    13.      <result property="customerName" javaType="java.lang.String" column="customer_name"/>
    14.     
    15.     <collection property="orders" ofType="com.tangyuan.model.Order" column="cid">
    16.       <id property="cid" javaType="java.lang.Integer" column="cid"/>
    17.       <id  property="orderId" javaType="java.lang.Integer" column="order_id"/>
    18.       <result property="orderNo" javaType="java.lang.String" column="order_no"/>
    19.     collection>
    20.   resultMap>
    21.   <sql id="Base_Column_List" >
    22.     customer_id, customer_name
    23.   sql>
    24.   <select id="queryCustomer" resultMap="oneToMany">
    25.      SELECT * FROM t_customer c left join
    26.       t_order o on c.customer_id=o.cid;
    27.   select>
    28.  
    29. mapper>

          注意事项，使用左外连接而非内连接，为了防止因为内连接的特性而让有一些客户因为没有订单而消失不见

    servicej接口类与实现类:

    1. package com.tangyuan.service;
    2.  
    3. import com.tangyuan.model.Customer;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. import java.util.List;
    7.  
    8.  
    9. public interface ICustomerService {
    10.  
    11.     /**
    12.      * 查询所有
    13.      * @return
    14.      */
    15.     List queryCustomer();
    16.  
    17.  
    18. }
    1. package com.tangyuan.service.impl;
    2.  
    3. import com.tangyuan.mapper.CustomerMapper;
    4. import com.tangyuan.model.Customer;
    5. import com.tangyuan.service.ICustomerService;
    6. import com.tangyuan.service.IOrderService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.stereotype.Service;
    9.  
    10. import java.util.List;
    11.  
    12. /**
    13.  * @author 唐渊
    14.  * @create  2022-07-27 11:29
    15.  */
    16. @Service
    17. public class CustomerServiceImpl implements ICustomerService {
    18.    @Autowired
    19.    private CustomerMapper customerMapper;
    20.  
    21.  
    22.     @Override
    23.     public List queryCustomer() {
    24.         return customerMapper.queryCustomer();
    25.     }
    26. }

    4.junit4单元测试

    1. package com.tangyuan.service.impl;
    2.  
    3. import com.tangyuan.model.Customer;
    4. import com.tangyuan.model.Order;
    5. import com.tangyuan.service.ICustomerService;
    6. import com.tangyuan.service.IOrderService;
    7.  
    8. import org.junit.Test;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10.  
    11.  
    12. import java.util.List;
    13.  
    14. import static org.junit.Assert.*;
    15.  
    16. /**
    17.  * @author 唐渊
    18.  * @create  2022-07-27 11:32
    19.  */
    20. public class CustomerServiceImplTest extends BaseTest{
    21.  
    22.     @Autowired
    23.     //用接口接收代理对象
    24.     private ICustomerService customerService;
    25.  
    26.  
    27.     @Test
    28.     public void queryCustomer() {
    29.         List customers = customerService.queryCustomer();
    30.         customers.forEach(System.out::println);
    31.  
    32.     }
    33.  
    34.  
    35. }

    测试结果： 

    • 案例二：实现多对一关系

    重点：

    • 建立实体层面的关联关系：
      多对一:多个订单对应一个客户（一个订单对应唯一一个客户）

      private Customer customer;

    订单实体类----order

    1. package com.tangyuan.model;
    2. /**
    3.  * 建立实体层面的关联关系：
    4.  * 多对一:多个订单对应一个客户（一个订单对应唯一一个客户）
    5.  */
    6. public class Order {
    7.     private Integer orderId;
    8.  
    9.     private String orderNo;
    10.  
    11.     private Integer cid;
    12.  
    13.     //B:订单(Order) A:客户(Customer)
    14.      //多对一
    15.     private Customer customer;
    16.  
    17.  
    18.  
    19.     public Order(Integer orderId, String orderNo, Integer cid) {
    20.         this.orderId = orderId;
    21.         this.orderNo = orderNo;
    22.         this.cid = cid;
    23.     }
    24.  
    25.     public Order() {
    26.         super();
    27.     }
    28.  
    29.     public Customer getCustomer() {
    30.         return customer;
    31.     }
    32.  
    33.     public void setCustomer(Customer customer) {
    34.         this.customer = customer;
    35.     }
    36.  
    37.     public Integer getOrderId() {
    38.         return orderId;
    39.     }
    40.  
    41.     public void setOrderId(Integer orderId) {
    42.         this.orderId = orderId;
    43.     }
    44.  
    45.     public String getOrderNo() {
    46.         return orderNo;
    47.     }
    48.  
    49.     public void setOrderNo(String orderNo) {
    50.         this.orderNo = orderNo;
    51.     }
    52.  
    53.     public Integer getCid() {
    54.         return cid;
    55.     }
    56.  
    57.     public void setCid(Integer cid) {
    58.         this.cid = cid;
    59.     }
    60.  
    61.     @Override
    62.     public String toString() {
    63.         return "Order{" +
    64.                 "orderId=" + orderId +
    65.                 ", orderNo='" + orderNo + '\'' +
    66.                 ", cid=" + cid +
    67.                 ", customer=" + customer +
    68.                 '}';
    69.     }
    70. }

    1.orderMapper层

    1. package com.tangyuan.mapper;
    2.  
    3.  
    4. import com.tangyuan.model.Order;
    5. import org.springframework.stereotype.Repository;
    6.  
    7. @Repository
    8. public interface OrderMapper {
    9.  
    10.    Order queryOrderById(Integer OrderId);
    11.  
    12. }

    2.配置mybatis关联映射文件------OrderMapper.xml

    1. <resultMap id="many2one" type="Order">
    2.         <id column="order_id" property="orderId"/>
    3.         <result column="order_no" property="orderNo"/>
    4.         <result column="cid" property="cid"/>
    5.  
    6.         
    7.         
    8.         <association property="customer" javaType="Customer">
    9.             <id column="customer_id" property="customerId"/>
    10.             <result column="customer_name" property="customerName"/>
    11.         association>
    12.    resultMap>

    完整版代码如下：

    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    3. <mapper namespace="com.tangyuan.mapper.OrderMapper" >
    4.   <resultMap id="BaseResultMap" type="com.tangyuan.model.Order" >
    5.     <constructor >
    6.       <idArg column="order_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
    7.       <arg column="order_no" jdbcType="VARCHAR" javaType="java.lang.String" />
    8.       <arg column="cid" jdbcType="INTEGER" javaType="java.lang.Integer" />
    9.     constructor>
    10.   resultMap>
    11.   <resultMap id="ManytoOne" type="com.tangyuan.model.Order">
    12.     <id  property="orderId"  javaType="java.lang.Integer"  column="order_id"/>
    13.     <result property="orderNo"  javaType="java.lang.String"    column="order_no"/>
    14.     <result property="cid"  javaType="java.lang.Integer"  column="cid" />
    15.     
    16.     
    17.     <association property="customer" javaType="com.tangyuan.model.Customer">
    18.       <id property="customerId"  javaType="java.lang.Integer"   column="customer_id" />
    19.       <result property="customerName" javaType="java.lang.String"      column="customer_name" />
    20.     association>
    21.   resultMap>
    22.  
    23.   <sql id="Base_Column_List" >
    24.     order_id, order_no, cid
    25.   sql>
    26.   <select id="queryOrderById" resultMap="ManytoOne">
    27.     SELECT * FROM t_customer c INNER join
    28.      t_order o on c.customer_id=o.cid
    29.      where o.order_id=#{orderId}
    30.  
    31.   select>
    32.  
    33. mapper>

             

    •  在元素中，包含了一个子元素，MyBatis通过该元素来处理一对多关联关系。

    • 在元素中，包含了一个子元素，MyBatis就是通过该元素来处理一对一关联关系。

    3.servicej接口类与实现类:

    1. package com.tangyuan.service;
    2.  
    3.  
    4. import com.tangyuan.model.Order;
    5. import org.springframework.stereotype.Repository;
    6.  
    7. @Repository
    8. public interface IOrderService {
    9.  
    10.    Order queryOrderById(Integer OrderId);
    11.  
    12. }
    1. package com.tangyuan.service.impl;
    2.  
    3. import com.tangyuan.mapper.OrderMapper;
    4. import com.tangyuan.model.Order;
    5. import com.tangyuan.service.IOrderService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8.  
    9. /**
    10.  * @author 唐渊
    11.  * @create  2022-07-27 11:56
    12.  */
    13. //org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'com.tangyuan.service.impl.CustomerServiceImplTest': Unsatisfied dependency expressed through field 'orderService'; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.tangyuan.service.IOrderService' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations:
    14. // {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    15. @Service
    16. public class OrderServiceImpl implements IOrderService {
    17.      @Autowired
    18.     private OrderMapper orderMapper;
    19.  
    20.     @Override
    21.     public Order queryOrderById(Integer OrderId) {
    22.         return orderMapper.queryOrderById(OrderId);
    23.     }
    24. }

    4.junit4单元测试

    1. package com.tangyuan.service.impl;
    2.  
    3. import com.tangyuan.model.Order;
    4. import com.tangyuan.service.IOrderService;
    5.  
    6. import org.junit.Test;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8.  
    9.  
    10. import java.util.List;
    11.  
    12. import static org.junit.Assert.*;
    13.  
    14. /**
    15.  * @author 唐渊
    16.  * @create  2022-07-27 11:32
    17.  */
    18. public class CustomerServiceImplTest extends BaseTest{
    19.  
    20.     @Autowired
    21.     private IOrderService orderService;
    22.  
    23.  
    24.     @Test
    25.     public  void  queryOrderById(){
    26.         Order orders = orderService.queryOrderById(1);
    27.         System.out.println(orders);
    28.     }
    29.  
    30. }

    测试结果： 

     

    • 案例三：实现多对多关系

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

    1. -- 多对多
    2. -- 主表
    3. create table t_news
    4. (
    5.   news_id int primary key auto_increment,          -- 新闻ID：主鍵
    6.   title varchar(50) not null                       -- 标题
    7. );
    8.  
    9. -- 主表
    10. create table t_category
    11. (
    12.   category_id int primary key auto_increment,      -- 类别编号：主鍵
    13.   category_name varchar(50) not null               -- 类别名称
    14. );
    15.  
    16. -- 桥接表,在关系型数据库中:多对多关系是无法直接映射的,
    17. -- 必须将一个多对多关系转换成二个一对多关系才能进行映射
    18. create table t_news_category
    19. (
    20.   id int primary key not null auto_increment,
    21.   nid int not null,
    22.   cid int not null,
    23.   foreign key(nid) references t_news(news_id),
    24.   foreign key(cid) references t_category(category_id)
    25. );
    26.  
    27.  
    28. insert into t_news(news_id,title) values(1,'110');
    29. insert into t_news(news_id,title) values(2,'111');
    30. insert into t_news(news_id,title) values(3,'112');
    31. insert into t_news(news_id,title) values(4,'113');
    32. insert into t_news(news_id,title) values(5,'114');
    33. insert into t_news(news_id,title) values(6,'115');
    34. insert into t_news(news_id,title) values(7,'116');
    35. insert into t_news(news_id,title) values(8,'117');
    36. insert into t_news(news_id,title) values(9,'118');
    37.  
    38.  
    39. insert into t_category(category_id,category_name) values(1,'焦点');
    40. insert into t_category(category_id,category_name) values(2,'国际');
    41. insert into t_category(category_id,category_name) values(3,'社会');
    42. insert into t_category(category_id,category_name) values(4,'房产');
    43. insert into t_category(category_id,category_name) values(5,'财经');
    44. insert into t_category(category_id,category_name) values(6,'娱乐');
    45.  
    46.  
    47. insert into t_news_category(nid,cid) values(1,1);
    48. insert into t_news_category(nid,cid) values(1,2);
    49.  
    50. insert into t_news_category(nid,cid) values(2,1);
    51. insert into t_news_category(nid,cid) values(2,2);
    52.  
    53. insert into t_news_category(nid,cid) values(3,1);
    54. insert into t_news_category(nid,cid) values(3,2);
    55. insert into t_news_category(nid,cid) values(3,3);
    56.  
    57. insert into t_news_category(nid,cid) values(4,1);
    58. insert into t_news_category(nid,cid) values(4,2);
    59. insert into t_news_category(nid,cid) values(4,3);
    60. insert into t_news_category(nid,cid) values(4,4);
    61.  
    62.  
    63. SELECT * FROM t_news;
    64. SELECT * FROM t_category;
    65. SELECT * FROM t_news_category;
    66.  
    67.

          多对多：产生中间关系表，引入两张表的主键作为外键，两个主键成为联合主键或使用新的字段作为主键。

                在A类中定义B类类型的集合，在B类中定义A类类型的集合

    2.通过mybatis-generator插件生成dao、mapper、model层

          为了简单便捷，只在中间表的Mapper类实现效果：


    NewsCategoryMapper：

    1. package com.tangyuan.mapper;
    2.  
    3. import com.tangyuan.model.NewsCategory;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. import java.util.List;
    7.  
    8. @Repository
    9. public interface NewsCategoryMapper {
    10.  
    11.     //根据新闻id查询
    12.     List queryNewsToMany(Integer newsId);
    13.     //根据类型id查询
    14.     List queryCategoryToMany(Integer categoryId);
    15.  
    16.  
    17.  
    18. }

    3.配置mybatis关联映射文件

    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    3. <mapper namespace="com.tangyuan.mapper.NewsCategoryMapper" >
    4.   <resultMap id="BaseResultMap" type="com.tangyuan.model.NewsCategory" >
    5.     <constructor >
    6.       <idArg column="id" jdbcType="INTEGER" javaType="java.lang.Integer" />
    7.       <arg column="nid" jdbcType="INTEGER" javaType="java.lang.Integer" />
    8.       <arg column="cid" jdbcType="INTEGER" javaType="java.lang.Integer" />
    9.     constructor>
    10.   resultMap>
    11.   <resultMap id="ManyToMany" type="com.tangyuan.model.NewsCategory">
    12.     <id property="id" javaType="java.lang.Integer" column="id"/>
    13.     <result property="nid" javaType="java.lang.Integer" column="nid"/>
    14.     <result property="cid"  javaType="java.lang.Integer" column="cid"/>
    15.     <association property="news" javaType="com.tangyuan.model.News">
    16.       <id property="newsId" javaType="java.lang.Integer"  column="category_Id"/>
    17.       <result property="title" javaType="java.lang.String" column="title"/>
    18.     association>
    19.  
    20.     <association property="category" javaType="com.tangyuan.model.Category">
    21.       <id property="categoryId" javaType="java.lang.Integer"  column="category_Id"/>
    22.       <result property="categoryName" javaType="java.lang.String" column="category_Name"/>
    23.     association>
    24.  
    25.   resultMap>
    26.     
    27.   <sql id="Base_Column_List" >
    28.     id, nid, cid
    29.   sql>
    30.   <select id="queryNewsToMany" resultMap="ManyToMany">
    31.         select
    32.         *
    33.         from
    34.         t_news_category nc left join t_news n on nc.nid=n.news_id
    35.         left join t_category c on nc.cid =c.category_id where n.news_id=#{value}
    36.   select>
    37.  
    38.   <select id="queryCategoryToMany" resultMap="ManyToMany">
    39.       select
    40.       *
    41.       from
    42.       t_news_category nc left join t_news n on nc.nid=n.news_id
    43.       left join t_category c on nc.cid =c.category_id where c.category_id=#{value}
    44.   select>
    45.  
    46. mapper>

    4.servicej接口类与实现类:

    1. package com.tangyuan.service;
    2.  
    3. import com.tangyuan.model.NewsCategory;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. import java.util.List;
    7.  
    8. @Repository
    9. public interface INewsCategoryService {
    10.  
    11.     //根据新闻id查询
    12.     List queryNewsToMany(Integer newsId);
    13.     //根据类型id查询
    14.     List queryCategoryToMany(Integer categoryId);
    15.  
    16.  
    17.  
    18. }
    1. package com.tangyuan.service.impl;
    2.  
    3. import com.tangyuan.mapper.NewsCategoryMapper;
    4. import com.tangyuan.model.NewsCategory;
    5. import com.tangyuan.service.INewsCategoryService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8.  
    9. import java.util.List;
    10.  
    11. /**
    12.  * @author 唐渊
    13.  * @create  2022-07-27 13:54
    14.  */
    15. @Service
    16. public class NewsCategoryServiceImpl implements INewsCategoryService {
    17.  
    18.     @Autowired
    19.     private NewsCategoryMapper newsCategoryMapper;
    20.  
    21.     @Override
    22.     public List queryNewsToMany(Integer newsId) {
    23.         return newsCategoryMapper.queryNewsToMany(newsId);
    24.     }
    25.  
    26.     @Override
    27.     public List queryCategoryToMany(Integer categoryId) {
    28.  
    29.         return newsCategoryMapper.queryCategoryToMany(categoryId);
    30.     }
    31. }

    5.junit4单元测试

    1. package com.tangyuan.service.impl;
    2.  
    3. import com.tangyuan.model.NewsCategory;
    4. import com.tangyuan.service.INewsCategoryService;
    5. import com.tangyuan.service.impl.BaseTest;
    6. import org.junit.Test;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8.  
    9. import java.util.List;
    10.  
    11. import static org.junit.Assert.*;
    12.  
    13. /**
    14.  * @author 唐渊
    15.  * @create  2022-07-27 13:53
    16.  */
    17. public class NewsCategoryMapperTest extends BaseTest {
    18.     @Autowired
    19.     private INewsCategoryService newsCategoryService;
    20.  
    21.     @Test
    22.     public void queryNewsToMany() {
    23.         List news = newsCategoryService.queryNewsToMany(1);
    24.         news.forEach(System.out::println);
    25.  
    26.  
    27.     }
    28.  
    29.     @Test
    30.     public void queryCategoryToMany() {
    31.         List categorys = newsCategoryService.queryCategoryToMany(1);
    32.         categorys.forEach(System.out::println);
    33.     }
    34. }

    测试结果： 

  • 相关阅读:
    rabbitmq 使用SAC队列实现顺序消息
    【NAS】整机备份还原Windows/Linux系统，群晖最强套件ABB教程
    开源任务调度框架
    【分布式】BASE理论详解
    从零开始手写一个Transformer
    SQL获取正数第N个或倒数第N个数据
    MySQL 日志管理
    XTTS系列之五：警惕大文件表空间
    郑州市管城回族区政协副主席张惠云一行莅临中创算力调研指导工作
    保姆级安装 Linux 虚拟机教程 （CentOS 7）
  • 原文地址：https://blog.csdn.net/qq_61313896/article/details/126090116