关联关系映射

最新推荐文章于 2023-11-17 15:26:00 发布
最新推荐文章于 2023-11-17 15:26:00 发布
阅读量52 收藏
点赞数
分类专栏： Maven 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hmjcxy/article/details/126433549
版权

目录

一，一对多关系关联 

二，多对多关系关联

一，一对多关系关联 

<?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="D:\\maven mulu\\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.hmj.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.hmj.mapper"
                         targetProject="src/main/java">
            <!-- 是否允许子包，即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.hmj.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_hibernate_Book" domainObjectName="Hbook"
               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_hibernate_category" domainObjectName="Category"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
        </table>
 
        <table schema="" tableName="t_hibernate_book_category" domainObjectName="HbookCategory"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
        </table>
 
    </context>
</generatorConfiguration>
<?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.hmj.mapper.OrderMapper" >
  <resultMap id="BaseResultMap" type="com.hmj.model.Order" >
    <constructor >
      <idArg column="order_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="order_no" jdbcType="VARCHAR" javaType="java.lang.String" />
    </constructor>
  </resultMap>
 
  <resultMap id="OrderVoMap" type="com.hmj.model.vo.OrderVo" >
    <result column="order_id" property="orderId"></result>
    <result column="order_no" property="orderNo"></result>
    <collection property="orderItems" ofType="com.hmj.model.OrderItem">
      <result column="order_item_id" property="orderItemId"></result>
      <result column="oid" property="oid"></result>
      <result column="product_id" property="productId"></result>
      <result column="quantity" property="quantity"></result>
 
    </collection>
 
  </resultMap>
 
 
  <sql id="Base_Column_List" >
    order_id, order_no
  </sql>
 
  <select id="selectByPrimaryKey" resultMap="OrderVoMap" parameterType="java.lang.Integer" >
   select * from t_hibernate_order o,t_hibernate_order_item oi
   where o.order_id = oi.oid and o.order_id=#{orderId}
  </select>
 
 
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_hibernate_order
    where order_id = #{orderId,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.hmj.model.Order" >
    insert into t_hibernate_order (order_id, order_no)
    values (#{orderId,jdbcType=INTEGER}, #{orderNo,jdbcType=VARCHAR})
  </insert>
  <insert id="insertSelective" parameterType="com.hmj.model.Order" >
    insert into t_hibernate_order
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="orderId != null" >
        order_id,
      </if>
      <if test="orderNo != null" >
        order_no,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="orderId != null" >
        #{orderId,jdbcType=INTEGER},
      </if>
      <if test="orderNo != null" >
        #{orderNo,jdbcType=VARCHAR},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.hmj.model.Order" >
    update t_hibernate_order
    <set >
      <if test="orderNo != null" >
        order_no = #{orderNo,jdbcType=VARCHAR},
      </if>
    </set>
    where order_id = #{orderId,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.hmj.model.Order" >
    update t_hibernate_order
    set order_no = #{orderNo,jdbcType=VARCHAR}
    where order_id = #{orderId,jdbcType=INTEGER}
  </update>
</mapper>
<?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.hmj.mapper.OrderItemMapper" >
  <resultMap id="BaseResultMap" type="com.hmj.model.OrderItem" >
    <constructor >
      <idArg column="order_item_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="product_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="quantity" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="oid" jdbcType="INTEGER" javaType="java.lang.Integer" />
    </constructor>
  </resultMap>
 
 
  <resultMap id="OrderVoMap" type="com.hmj.model.vo.OrderItemVo" >
    <result column="order_item_id" property="orderItemId"></result>
    <result column="oid" property="oid"></result>
    <result column="product_id" property="productId"></result>
    <result column="quantity" property="quantity"></result>
    <collection property="order" javaType="com.hmj.model.Order">
      <result column="order_id" property="orderId"></result>
      <result column="order_no" property="orderNo"></result>
    </collection>
  </resultMap>
 
 
 
 
  <sql id="Base_Column_List" >
    order_item_id, product_id, quantity, oid
  </sql>
 
  <select id="selectByPrimaryKeys" resultMap="OrderVoMap" parameterType="java.lang.Integer" >
   select * from t_hibernate_order o,t_hibernate_order_item oi
   where o.order_id = oi.oid and oi.order_item_id=#{orderItemId}
  </select>
 
 
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from t_hibernate_order_item
    where order_item_id = #{orderItemId,jdbcType=INTEGER}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_hibernate_order_item
    where order_item_id = #{orderItemId,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.hmj.model.OrderItem" >
    insert into t_hibernate_order_item (order_item_id, product_id, quantity, 
      oid)
    values (#{orderItemId,jdbcType=INTEGER}, #{productId,jdbcType=INTEGER}, #{quantity,jdbcType=INTEGER}, 
      #{oid,jdbcType=INTEGER})
  </insert>
  <insert id="insertSelective" parameterType="com.hmj.model.OrderItem" >
    insert into t_hibernate_order_item
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="orderItemId != null" >
        order_item_id,
      </if>
      <if test="productId != null" >
        product_id,
      </if>
      <if test="quantity != null" >
        quantity,
      </if>
      <if test="oid != null" >
        oid,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="orderItemId != null" >
        #{orderItemId,jdbcType=INTEGER},
      </if>
      <if test="productId != null" >
        #{productId,jdbcType=INTEGER},
      </if>
      <if test="quantity != null" >
        #{quantity,jdbcType=INTEGER},
      </if>
      <if test="oid != null" >
        #{oid,jdbcType=INTEGER},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.hmj.model.OrderItem" >
    update t_hibernate_order_item
    <set >
      <if test="productId != null" >
        product_id = #{productId,jdbcType=INTEGER},
      </if>
      <if test="quantity != null" >
        quantity = #{quantity,jdbcType=INTEGER},
      </if>
      <if test="oid != null" >
        oid = #{oid,jdbcType=INTEGER},
      </if>
    </set>
    where order_item_id = #{orderItemId,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.hmj.model.OrderItem" >
    update t_hibernate_order_item
    set product_id = #{productId,jdbcType=INTEGER},
      quantity = #{quantity,jdbcType=INTEGER},
      oid = #{oid,jdbcType=INTEGER}
    where order_item_id = #{orderItemId,jdbcType=INTEGER}
  </update>
</mapper>
package com.hmj.mapper;
 
import com.hmj.model.OrderItem;
import com.hmj.model.vo.OrderItemVo;
import org.apache.ibatis.annotations.Param;
 
public interface OrderItemMapper {
    int deleteByPrimaryKey(Integer orderItemId);
 
    int insert(OrderItem record);
 
    int insertSelective(OrderItem record);
 
    OrderItem selectByPrimaryKey(Integer orderItemId);
 
    OrderItemVo selectByPrimaryKeys(@Param("orderItemId") Integer orderItemId);
 
 
    int updateByPrimaryKeySelective(OrderItem record);
 
    int updateByPrimaryKey(OrderItem record);
}
package com.hmj.mapper;
 
import com.hmj.model.vo.OrderVo;
import com.hmj.model.Order;
import org.apache.ibatis.annotations.Param;
 
public interface OrderMapper {
    int deleteByPrimaryKey(Integer orderId);
 
    int insert(Order record);
 
    int insertSelective(Order record);
 
    OrderVo selectByPrimaryKey(@Param("orderId") Integer orderId);
 
    int updateByPrimaryKeySelective(Order record);
 
    int updateByPrimaryKey(Order record);
}
package com.hmj.biz;
 
import com.hmj.model.Order;
import org.apache.ibatis.annotations.Param;
 
/**
 * @author 
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 18:41
 */
public interface OrderBiz{
    int deleteByPrimaryKey(Integer orderId);
 
    int insert(Order record);
 
    int insertSelective(Order record);
 
    Order selectByPrimaryKey(Integer orderId);
 
    int updateByPrimaryKeySelective(Order record);
 
    int updateByPrimaryKey(Order record);
 
}
package com.hmj.biz;
 
import com.hmj.model.OrderItem;
import com.hmj.model.vo.OrderItemVo;
import org.apache.ibatis.annotations.Param;
 
/**
 * @author 
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 19:14
 */
public interface OrderItemBiz {
    int deleteByPrimaryKey(Integer orderItemId);
 
    int insert(OrderItem record);
 
    int insertSelective(OrderItem record);
 
    OrderItem selectByPrimaryKey(Integer orderItemId);
 
    OrderItemVo selectByPrimaryKeys( Integer orderItemId);
 
 
    int updateByPrimaryKeySelective(OrderItem record);
 
    int updateByPrimaryKey(OrderItem record);
 
}
package com.hmj.biz.impl;
 
import com.hmj.biz.OrderBiz;
import com.hmj.mapper.OrderMapper;
import com.hmj.model.Order;
import com.sun.tracing.dtrace.Attributes;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
/**
 * @author 
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 18:42
 */
 
@Service
public class OrderBizImpl implements OrderBiz {
    @Autowired
    private OrderMapper orderMapper;
    @Override
    public int deleteByPrimaryKey(Integer orderId) {
        return 0;
    }
 
    @Override
    public int insert(Order record) {
        return 0;
    }
 
    @Override
    public int insertSelective(Order record) {
        return 0;
    }
 
    @Override
    public Order selectByPrimaryKey(Integer orderId) {
        return orderMapper.selectByPrimaryKey(orderId);
    }
 
    @Override
    public int updateByPrimaryKeySelective(Order record) {
        return 0;
    }
 
    @Override
    public int updateByPrimaryKey(Order record) {
        return 0;
    }
}
package com.hmj.biz.impl;
 
import com.hmj.biz.OrderItemBiz;
import com.hmj.mapper.OrderItemMapper;
import com.hmj.mapper.OrderMapper;
import com.hmj.model.OrderItem;
import com.hmj.model.vo.OrderItemVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
/**
 * @author 若娟
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 19:36
 */
@Service
public class OrderItemBizImpl implements OrderItemBiz {
 
    @Autowired
    private OrderItemMapper orderItemMapper;
 
    @Override
    public int deleteByPrimaryKey(Integer orderItemId) {
        return 0;
    }
 
    @Override
    public int insert(OrderItem record) {
        return 0;
    }
 
    @Override
    public int insertSelective(OrderItem record) {
        return 0;
    }
 
    @Override
    public OrderItem selectByPrimaryKey(Integer orderItemId) {
        return null;
    }
 
    @Override
    public OrderItemVo selectByPrimaryKeys(Integer orderItemId) {
        return orderItemMapper.selectByPrimaryKeys(orderItemId);
    }
 
    @Override
    public int updateByPrimaryKeySelective(OrderItem record) {
        return 0;
    }
 
    @Override
    public int updateByPrimaryKey(OrderItem record) {
        return 0;
    }
}
package com.hmj.biz.impl;
 
import com.hmj.biz.OrderItemBiz;
import com.hmj.model.vo.OrderItemVo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import static org.junit.Assert.*;
 
/**
 * @author 
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 19:38
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext-mybatis.xml"})
 
public class OrderItemBizImplTest {
    @Autowired
    private OrderItemBiz orderItemBiz;
 
    @Test
    public void selectByPrimaryKeys() {
       OrderItemVo orderitemVo = orderItemBiz.selectByPrimaryKeys(43);
        System.out.println(orderitemVo);
    }
}
package com.hmj.biz.impl;
 
import com.hmj.biz.OrderBiz;
import com.hmj.model.Order;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import static org.junit.Assert.*;
 
/**
 * @author 
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 18:45
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext-mybatis.xml"})
 
public class OrderBizImplTest {
    @Autowired
    private OrderBiz orderBiz;
 
    @Test
    public void selectByPrimaryKey() {
        Order order = orderBiz.selectByPrimaryKey(9);
        System.out.println(order);
    }
}

二，多对多关系关联

<?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.hmj.mapper.HbookMapper" >
  <resultMap id="BaseResultMap" type="com.hmj.model.Hbook" >
    <constructor >
      <idArg column="book_id" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="book_name" jdbcType="VARCHAR" javaType="java.lang.String" />
      <arg column="price" jdbcType="REAL" javaType="java.lang.Float" />
    </constructor>
  </resultMap>
  <sql id="Base_Column_List" >
    book_id, book_name, price
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from t_hibernate_book
    where book_id = #{bookId,jdbcType=INTEGER}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_hibernate_book
    where book_id = #{bookId,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.hmj.model.Hbook" >
    insert into t_hibernate_book (book_id, book_name, price
      )
    values (#{bookId,jdbcType=INTEGER}, #{bookName,jdbcType=VARCHAR}, #{price,jdbcType=REAL}
      )
  </insert>
  <insert id="insertSelective" parameterType="com.hmj.model.Hbook" >
    insert into t_hibernate_book
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="bookId != null" >
        book_id,
      </if>
      <if test="bookName != null" >
        book_name,
      </if>
      <if test="price != null" >
        price,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="bookId != null" >
        #{bookId,jdbcType=INTEGER},
      </if>
      <if test="bookName != null" >
        #{bookName,jdbcType=VARCHAR},
      </if>
      <if test="price != null" >
        #{price,jdbcType=REAL},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.hmj.model.Hbook" >
    update t_hibernate_book
    <set >
      <if test="bookName != null" >
        book_name = #{bookName,jdbcType=VARCHAR},
      </if>
      <if test="price != null" >
        price = #{price,jdbcType=REAL},
      </if>
    </set>
    where book_id = #{bookId,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.hmj.model.Hbook" >
    update t_hibernate_book
    set book_name = #{bookName,jdbcType=VARCHAR},
      price = #{price,jdbcType=REAL}
    where book_id = #{bookId,jdbcType=INTEGER}
  </update>
</mapper>
package com.hmj.mapper;
 
import com.hmj.model.Hbook;
 
public interface HbookMapper {
    int deleteByPrimaryKey(Integer bookId);
 
    int insert(Hbook record);
 
    int insertSelective(Hbook record);
 
    Hbook selectByPrimaryKey(Integer bookId);
 
    int updateByPrimaryKeySelective(Hbook record);
 
    int updateByPrimaryKey(Hbook record);
}package com.hmj.mapper;
 
import com.hmj.model.Hbook;
 
public interface HbookMapper {
    int deleteByPrimaryKey(Integer bookId);
 
    int insert(Hbook record);
 
    int insertSelective(Hbook record);
 
    Hbook selectByPrimaryKey(Integer bookId);
 
    int updateByPrimaryKeySelective(Hbook record);
 
    int updateByPrimaryKey(Hbook record);
}package com.hmj.mapper;
 
import com.hmj.model.Hbook;
 
public interface HbookMapper {
    int deleteByPrimaryKey(Integer bookId);
 
    int insert(Hbook record);
 
    int insertSelective(Hbook record);
 
    Hbook selectByPrimaryKey(Integer bookId);
 
    int updateByPrimaryKeySelective(Hbook record);
 
    int updateByPrimaryKey(Hbook record);
}
package com.hmj.biz;
 
import com.hmj.model.HbookCategory;
import com.hmj.model.vo.CategoryVo;
import com.hmj.model.vo.HbookVo;
 
/**
 * @author 
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 20:16
 */
public interface HbookCategoryBiz {
 
    int deleteByPrimaryKey(Integer bcid);
 
    int insert(HbookCategory record);
 
    int insertSelective(HbookCategory record);
 
    HbookCategory selectByPrimaryKey(Integer bcid);
 
    int updateByPrimaryKeySelective(HbookCategory record);
 
    int updateByPrimaryKey(HbookCategory record);
 
    HbookVo queryByBookId( Integer bookId);
 
    CategoryVo queryByCid( Integer cid);
 
}
package com.hmj.biz.impl;
 
import com.hmj.biz.HbookCategoryBiz;
import com.hmj.mapper.HbookCategoryMapper;
import com.hmj.model.HbookCategory;
import com.hmj.model.vo.CategoryVo;
import com.hmj.model.vo.HbookVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
/**
 * @author 
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 20:16
 */
@Service
public class HbookCategoryBizImpl implements HbookCategoryBiz {
    @Autowired
    private HbookCategoryMapper hbookCategoryMapper;
    @Override
    public int deleteByPrimaryKey(Integer bcid) {
        return 0;
    }
 
    @Override
    public int insert(HbookCategory record) {
        return 0;
    }
 
    @Override
    public int insertSelective(HbookCategory record) {
        return 0;
    }
 
    @Override
    public HbookCategory selectByPrimaryKey(Integer bcid) {
        return null;
    }
 
    @Override
    public int updateByPrimaryKeySelective(HbookCategory record) {
        return 0;
    }
 
    @Override
    public int updateByPrimaryKey(HbookCategory record) {
        return 0;
    }
 
    @Override
    public HbookVo queryByBookId(Integer bookId) {
        return hbookCategoryMapper.queryByBookId(bookId);
    }
 
    @Override
    public CategoryVo queryByCid(Integer cid) {
        return hbookCategoryMapper.queryByCid(cid);
    }
}
package com.hmj.biz.impl;
 
import com.hmj.biz.HbookCategoryBiz;
import com.hmj.model.vo.CategoryVo;
import com.hmj.model.vo.HbookVo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import static org.junit.Assert.*;
 
/**
 * @author 
 * @site 123456999
 * @company 玉渊工作室
 * @create 2022-08-15 20:18
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext-mybatis.xml"})
 
public class HbookCategoryBizImplTest {
    @Autowired
    private HbookCategoryBiz hbookCategoryBiz;
 
    @Test
    public void queryByBookId() {
        HbookVo hbookVo =  hbookCategoryBiz.queryByBookId(8);
        System.out.println(hbookVo);
        hbookVo.getCategories().forEach(System.out::println);
    }
 
    @Test
    public void queryByCid() {
        CategoryVo categoryVo = hbookCategoryBiz.queryByCid(8);
        System.out.println(categoryVo);
        categoryVo.getHbooks().forEach(System.out::println);
 
    }
}

糖心何包蛋·
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一对多与多对多
weixin_45180770的博客
10-23 750
Mybatis关系映射之一对多 一对多 （订单对应多个订单项） 多对一 （订单项对应一个订单） 其是映射关系的基层思维是一样的，只是用法不一样，今天所记录的mybatis关系映射比Hibernate要简单 之前我记录一篇hibernate映射关系，可以移步（https://www.cnblogs.com/huangting/p/11203498.html） 今天就用订单表和订单项表来演示myba...
关于数据结构中的一对多，多对多的学习与理解
weixin_42069780的博客
03-20 8175
前言 今天开始一个新项目，设计数据表，由于之前这方面经验不是很足，所以一直在纠结，特别是一对一，多对多这种关系的设计。 问题 一个项目有0-3个固定的主编单位，一个主编单位对应一个项目联系人，这种关系应该是一对多还是多对多呢。 一对一、一对多、多对多 1、一对一很简单，就比如一个人拥有一张身份证，一张身份证也只能对应一个人 2、一对多，可以用班级和学生举例，一个学生只能有一个班级，但是一个班级对...
详解Mybatis一对多、多对一、多对多
热门推荐
菜鸟逆袭之路
05-07 2万+
Mybatis一对一、一对多、多对多
一对一，一对多，多对多三种关系简单理解
最新发布
weixin_44793582的博客
11-17 1933
一对一，一对多，多对多 这三种关系该怎么理解。
Mybatis一对多关联关系映射实现过程解析
08-25
Mybatis的一对多关联关系映射实现过程解析 Mybatis是一款基于Java的持久层框架，它提供了对数据库的操作接口，包括数据的增删改查等操作。在实际开发中，我们经常会遇到一对多关联关系映射的问题，例如用户和订单...
Hibernate的关联关系映射图解
03-30
Hibernate4中映射关系图解。
Hibernate注解 关联关系映射注解.docx
06-19
在Java的持久化框架Hibernate中，注解是用于简化对象关系映射（ORM）的一种方式。本篇文章将详细探讨在Hibernate中如何使用注解来处理各种关联关系，特别是`mappedBy`属性的用法。 首先，`@OneToMany`注解用于表示...
Hibernate之关联关系映射(一对多和多对一映射，多对多映射).docx
06-19
在Java的持久化框架Hibernate中，关联关系映射是实现对象关系映射（ORM）的重要概念，它允许我们在Java对象和数据库表之间建立链接。本文将深入探讨Hibernate中的一对多、多对一以及多对多映射。 1. 一对多与多对一...
ssh全注解项目（一对一，一对多，多对多）
01-24
ssh全注解项目（一对一，一对多，多对多），hibernate的注解配置及映射关系
对象的一对多和多对多关系
java编程学习_java基础教程_booyzhang的博客
05-13 2960
对象与对象的关系可以分为： 一对一，一对多和多对多。 一对一关系： 分别在两个对象将对方对象设置为属性进行关联 一对多关系： 在 “一” 关系设置对多关系的集合表示，在 “ 多” 关系将以关系设置为属性 多对多关系： 分别在两个对象将对方对象作为集合的方式进行关联。 实际开发中一对多的关系用得最多，不建议直接使用多对多关系,这样逻辑过于复杂，不好处理，通常多对多的关系，设置一个中间对象，拆分为两个一对多的关系进行处理。 一对多关系关联代码示例： 主类 package com.booy; public cl
自我理解一对多，多对多关系
fly_and_fish的博客
01-26 1434
自我陶醉理解杂记
一对多和多对多
weixin_38168696的博客
08-20 98
一个组织拥有多个用户，一个组织有多个角色，一个角色有多个组织 package com.eshore.ismp.permission.model; import java.io.Serializable; import java.util.ArrayList; import java.util.Date; import java.util.HashSet; import...
【转】数据库一对一、一对多、多对多关系
beidaol的专栏
11-01 1万+
转自：https://blog.csdn.net/u013144287/article/details/79024130  本来数据库一对一、一对多、多对多关系并不复杂，但是最近在理解的时候感觉又感觉多了写新意，所以现在在来总结一下吧 一、首先给出三种关系的实例 1、一对一关系实例    * 一个人对应一张身份证，一张身份证对应一个人 2、一对多关系实例    * 一个班级拥有多个学生，一个学生...
【MyBatis】mybatis多对一、一对多、多对多
Duson
05-31 1322
1. 表结构与关系分析1. 数据表创建1.2 表关联关系2. 多对一2.1 实体间建立关系2.2 方式一：先查从表再根据外键id查主表2.3 方式二：直接左外连接连表一次性查询2.4 测试3. 一对多3.1 实体间建立关系3.2 方式一：先查主表再查从表3.3 方式二：直接左外连接连表一次性查询3.4 测试多对多 1. 表结构与关系分析 1. 数据表创建 DROP TABLE IF EXISTS `account`; CREATE TABLE `account` ( `id` int(11) NOT .
一对多和多对多的区别
hubert3的专栏
01-18 833
以前还真没细想过怎么区别一对多和多对多，最近使用hibernate才猛然发现，这个东西不是凭借感觉吓写是不可以的。 一对多：从一端看多，多只属于一 多对多： 有两个方法看 1，从一段看多，多不止属于一个一 2，从多端看一，一不止属于一个多 转载自http://www.jiancool.com/article/37783071566/
多对多单向，多对多双向
hurahura的博客
07-28 1886
多对多单向 Teacher类中 @ManyToMany @JoinTable(name="student_teacher",//中间表名 joinColumns=@JoinColumn(name="teacher_id"),//这个类在表中的id inverseJoinColumns=@JoinColumn(name="student_id")//反转的类在联合表中的id ) p
Hibernate实体关联关系映射总结与实例
"Hibernate实体关联关系映射的学习总结与实例速查" 在软件开发中，特别是Java企业级应用中，Hibernate作为一个流行的ORM（对象关系映射）框架，它极大地简化了数据库操作。实体关联关系映射是Hibernate的核心特性，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值