精华内容
下载资源
问答
  • 高级映射

    2017-02-25 22:32:51
    resultMap可以实现高级映射(使用association和collection实现一对一和一对多的映射),association和collection具有延迟加载的功能。 延迟加载:先从单表查询,需要时再从关联表去关联查询,大大提高数据库的...

    数据模型分析思路

    1.每张表记录的数据内容

    分模块对每张表就的内容进行熟悉,相当于你学习系统需求(功能)的过程。

    2.每张表的数据库字段的设置

    非空字段、外键字段

    3.数据库级别表与表之间的关系

    外键关系

    4.表与表的业务关系

    在分析表与表之间的业务关系时一定要建立。

     

    数据分析:

    用户表(users):记录了购买商品的用户信息。

    订单表(orders):记录了用户所创建的订单(购买商品的订单)。

    订单明细表(orderdetails):记录了订单的详细信息,即购买商品的信息。

    商品表(itmes):记录了商品信息。

     

     

    一对一映射查询:

     

    需求:需要订单信息,关联查询订单的用户信息。

    ResultType:

    SQL语句:selectorders.* ,users.username,users.sex,users.address from orders,useres whereorders.user_id=users.id;

    创建vo实体类,包装类,通过此类映射订单和用户查询的结果,让此类继承较多的vo实体类

    在自己的xml里面:

    <mappernamespace=”com.neusoft.vo.OrderCustom”>

    <select id=”findOrderCustom” ResultType =” OrderCustom”>

    select orders.*,users.username,users.sex,users.address from orders,useres whereorders.user_id=users.id;

    </select >

    </mapper>

    在dao接口中:publicList<OrderCustom> findOrderCustom();

    resultMap:

    SQL语句:selectorders.* ,users.username,users.sex,users.address from orders,useres where orders.user_id=users.id;

    使用resultMap将查询结果的订单信息映射到Orders对象中,在Orders里面添加用户对象users,并将查询出来的结果中的用户信息映射到users对象中。

    定义一个resultMap:

    <resultMaptype=”com.neusoft.vo.Orders” id=”ordersUsersResultMap”>

    <!—id:指定查询列中的唯一标识,如果有多个列组成唯一标识,那么就需要配置多个id

    column :订单信息的唯一标识

    property:订单信息的唯一标识列所映射字段名-->

    <idcolumn=”id” property=”id” />

    <resultcolumn=”userid” property=” userid”/>

    <resultcolumn=”number” property=” number”/>

    <resultcolumn=”createtime” property=” createtime”/>

    <resultcolumn=”note” property=” note”/>

    <!---配置映射的关联的用户信息,Property:将关联查询到的用户信息映射到Orders中的每个属性->

    <associationproperty=”users” javaType=”com.neusoft.vo.Users”>

    <idcolumn=”userid” property=”id” />

    <resultcolumn=”username” property=” username”/>

    <resultcolumn=”sex” property=” sex”/>

    <resultcolumn=”birthday” property=” birthday”/>

    <resultcolumn=”address” property=” address”/>

    </association>

    </resultMap>

    resultType和resultMap的对比小结:

    resultType:使用resultType实现较为简单,如果vo实体类中没有包括查询出来的列名,需要增加列名对象的属性,即可完成映射。

    如果没有查询结果的特殊要求建议使用resultType。

    ResultMap:需要单独定义resultMap,实现有点麻烦,如果对查询结果有特殊的要求,使用resultMap可以完成将关联查询映射到vo实体类的字段中。

    ResultMap可以实现延迟加载,resultType无法实现延迟加载。

     

     

     

    一对多映射:

    需求:查询订单及订单明细的信息。

    SQL语句:select orders.*,orderdetail.id ordertail_id  from orders,orderdetails whereorders.id=orderdatils.orderid;

    在订单实体类中添加订单明细变量,private List<Orderdetails> orderdetails;

    定义resultMap:

    <resultMaptype=”com.neusoft.vo.Orders” id=”ordersUsersResultMap”>

    <!—id:指定查询列中的唯一标识,如果有多个列组成唯一标识,那么就需要配置多个id

    column :订单信息的唯一标识

    property:订单信息的唯一标识列所映射字段名-->

    <idcolumn=”id” property=”id” />

    <resultcolumn=”userid” property=” userid”/>

    <resultcolumn=”number” property=” number”/>

    <resultcolumn=”createtime” property=” createtime”/>

    <resultcolumn=”note” property=” note”/>

    <!—订单明细信息

    一个订单关联查询出了多条明细,要使用collection进行映射

    Collection:把查询到的多条就映射到集合对象中

    Property:将查询的多条记录映射到orderdetails中-->

    <collectionproperty=”orderdetails” ofType=”com.neusoft.vo.Orderdetails”>

    <idcolumn=” ordertail_id”  property=”id”/>

    <resultcolumn=”items_id” property =”itemsid” />

    <resultcolumn=”items_num” property =”itemsnum” />

    <resultcolumn=”orders_id” property =”ordersid” />

    </collection>

    </resultMap>

    Mybatis采用collection对关联查询的多条记录映射到一个list集合中。

     

     

     

    ResultMap总结:将association和collection实现一对一和一对多的高级映射。

     

     

     

    什么是延迟加载?
    resultMap可以实现高级映射(使用association和collection实现一对一和一对多的映射),association和collection具有延迟加载的功能。

    延迟加载:先从单表查询,需要时再从关联表去关联查询,大大提高数据库的性能,因为查询单表要比关联查询多张表速度要快。

    展开全文
  • mybatis高级映射

    2017-11-08 23:08:13
    mybatis高级映射

    转载自   http://blog.csdn.net/zd836614437/article/details/51814108

    一、介绍 
    resultType : 
    作用:将查询结果按照sql列名pojo属性名一致性映射到pojo中。 
    场合:

    常见一些明细记录的展示,比如用户购买商品明细,将关联查询信息全部展示在页面时,此时可直接使用 resultType 将每一条记录映射到 pojo 中,在前端页面遍历 list ( list 中是 pojo )即可。

    resultMap :

    使用 association 和 collection 完成一对一和一对多高级映射(对结果有特殊的映射要求)。

    association :

    作用:将关联查询信息映射到一个pojo对象中。

    场合:

    为了方便查询关联信息可以使用 association 将关联订单信息映射为用户对象的 pojo 属性中,比如:查询订单及关联用户信息。

    使用 resultType 无法将查询结果映射到 pojo 对象的 pojo 属性中,根据对结果集查询遍历的需要选择使用 resultType 还是 resultMap 。

    collection :

    作用:将关联查询信息映射到一个list集合中。

    场合:

    为了方便查询遍历关联信息可以使用 collection 将关联信息映射到 list 集合中,比如:查询用户权限范围模块及模块下的菜单,可使用 collection 将模块映射到模块 list 中,将菜单列表映射到模块对象的菜单 list 属性中,这样的作的目的也是方便对查询结果集进行遍历查询。

    如果使用 resultType 无法将查询结果映射到 list 集合中。

    二、一对一查询

    resultType 和 resultMap 实现一对一查询小结:

    a.resultType :使用 resultType 实现较为简单,如果 pojo 中没有包括查询出来的列名,需要增加列名对应的属性,即可完成映射。

    b.如果没有查询结果的特殊要求建议使用 resultType 。

    c.resultMap :需要单独定义 resultMap ,实现有点麻烦,如果对查询结果有特殊的要求,使用 resultMap 可以完成将关联查询映射 pojo 的属性中。

    d.resultMap 可以实现延迟加载, resultType 无法实现延迟加载。

    2.1.需求:查询订单信息,关联查询用户信息;

    2.2 resultType实现

    public class Orders {
      /** 主键订单Id */
      private Integer id;
      /** 下单用户id */
      private Integer userid;
      /** 订单号 */
      private String number;
      /** 创建订单时间 */
      private Date createTime;
      /** 备注 */
      private String note;
      // 用户信息
      private User user;
      // 订单明细
      private List<OrderDetail> orderdetails;
         //  getter and setter ......
    }
    
    public class OrdersCustom extends Orders {
      // 添加用户的属性
      private String username;
      private String sex;
      private String address;
        // getter and setter......
    }
    
    
    public interface OrdersCustomMapper {
        /** 查询订单,关联查询用户信息 */
        public List<OrdersCustom> findOrdersUser();
    }
    <mapper namespace="com.mybatis.mapper.OrdersCustomMapper">
        <!-- 查询订单,关联查询用户信息 -->
      <select id="findOrdersUser" resultType="com.mybatis.entity.OrdersCustom">
      SELECT t1.*,
        t2.username,
        t2.sex,
        t2.address
      FROM
        orders t1,
        t_user t2
      WHERE t1.user_id=t2.id
      </select>
    </mapper>
    2.3 resultMap实现
    <resultMap type="com.mybatis.entity.Orders" id="OrdersUserResultMap">
              <!-- 配置映射的订单信息 -->
    
              <!-- id:查询列中的唯一标识,订单信息中的唯一标识,如果多列组成唯一标识(如:一般数据库设计中的字典表 使用联合主键),就需要配置多个id 
                  column:订单信息的唯一标识 列
                  property:订单信息的唯一标识列所映射到orders中的那个属性(假如:数据库中orders表中的主键为orders_id,而实体属性名称为ordersId,
                      则这个配置应为<id column="orders_id" property="ordersId"/>,类似hibernate实体映射文件配置)。
              -->
             <id column="id" property="id"/>
             <result column="user_id" property="userid"/>
             <result column="number" property="number"/>
             <result column="createtime" property="createTime"/>
             <result column="note" property="note"/>
    
             <!-- 配置映射的关联用户信息 -->
    
             <!--association:用于映射关联查询单个对象的信息
                 property:要将关联查询的用户信息映射到Orders中那个属性
               -->
             <association property="user" javaType="com.mybatis.entity.User">
                 <!-- id:关联查询用户的唯一标识 
                     column:指定唯一标识用户信息的列
                     property:映射到user的那个属性
                 -->
                 <id column="user_id" property="id"/>
                 <result column="username" property="username"/>
                 <result column="sex" property="sex"/>
                 <result column="address" property="address"/>
             </association>
    
         </resultMap>
    <!-- 查询订单,关联查询用户信息,使用resultMap实现 -->
          <select id="findOrdersUserResultMap" resultMap="OrdersUserResultMap">
                  SELECT t1.*,
                      t2.username,
                      t2.sex,
                      t2.address
                  FROM
                      orders t1,
                      t_user t2
                 WHERE t1.user_id=t2.id
         </select>

    三、一对多查询

    mybatis 使用 resultMap 的 collection 对关联查询的多条记录映射到一个 list 集合属性中。

    使用 resultType 实现:将订单明细映射到orders中的orderdetails中,需要自己处理,使用双重循环遍历,去掉重复记录,将订单明细放在orderdetails中。

    3.1 需求:查询订单(关联用户)及订单明细; 
    3.2 映射思路 
    3.2. 在 orders.java 类中添加 List orderDetails 属性(上面实体已添加) 。

    最终会将订单信息映射到 orders 中,订单所对应的订单明细映射到 orders 中的 orderDetails 属性中.

    3.3 核心代码

    <!-- 查询订单关联查询用户及订单明细 -->
    <select id="findOrdersAndOrderDetailResultMap" resultMap="ordersAndOrderDetailResultMap">
        SELECT 
          t1.*,
          t2.username,
          t2.sex,
          t2.address,
          t3.id orderdetail_id,
          t3.items_id,
          t3.items_num,
          t3.orders_id
        FROM
          orders t1,
          t_user t2,
          orderdetail t3
        WHERE t1.user_id = t2.id AND t3.orders_id=t1.id
    </select>
    <!-- 查询订单(关联用户)及订单明细的resultMap -->
    <resultMap type="com.mybatis.entity.Orders" id="ordersAndOrderDetailResultMap" extends="OrdersUserResultMap">
      <!-- 订单信息 -->
      <!-- 关联用户信息 -->
      <!-- 使用extends继承,不用在中配置订单信息和用户信息的映射-->
      <!-- 关联订单明细信息 
        一个订单关联查询出了多条订单明细,要使用collection映射
        collection:对关联查询到的多条记录映射到集合中
        property:将关联查询到的多条记录映射到orders类的那个属性
        ofType:指定映射的集合属性中pojo的类型
      -->
      <collection property="orderdetails" ofType="com.mybatis.entity.OrderDetail">
        <!-- id:唯一标识
           property:要将订单明细的唯一标识映射到com.mybatis.entity.OrderDetail的那个属性
         -->
        <id column="orderdetail_id" property="id"/>
        <result column="items_id" property="itemsId"/>
        <result column="items_num" property="itemsNum"/>
        <result column="orders_id" property="ordersId"/>
      </collection>
    </resultMap>

    四、多对多查询

    4.1.需求:查询用户以及用户购买的商品信息

    4.2.映射思路

    将用户信息映射到 user 中。

    在 user 类中添加订单列表属性 List orderslist ,将用户创建的订单映射到 orderslist;

    在 Orders 中添加订单明细列表属性 Listorderdetials ,将订单的明细映射到 orderdetials;

    在 OrderDetail 中添加 Items 属性,将订单明细所对应的商品映射到 Item;

    4.3 核心代码

    <!-- 查询用户即购买的商品信息的ResultMap -->
      <resultMap type="com.mybatis.entity.User" id="userAndItemsResultMap">
        <!-- 用户信息 -->
        <id column="user_id" property="id"/>
        <result column="username" property="username"/>
        <result column="sex" property="sex"/>
        <result column="address" property="address"/>
      <!-- 订单信息
        一个用户对应多个订单,使用collection映射 -->
        <collection property="ordersList" ofType="com.mybatis.entity.Orders">
           <id column="id" property="id"/>
           <result column="user_id" property="userid"/>
          <result column="number" property="number"/>
          <result column="createtime" property="createTime"/>
          <result column="note" property="note"/>
         <!-- 订单明细
             一个订单包括 多个明细
            -->
            <collection property="orderdetails" ofType="com.mybatis.entity.OrderDetail">
                <id column="orderdetail_id" property="id"/>
               <result column="items_id"   property="itemsId"/>
               <result column="items_num"  property="itemsNum"/>
               <result column="orders_id"  property="ordersId"/>
               <!-- 商品信息
                  一个订单明细对应一个商品
                 -->
               <association property="items" javaType="com.mybatis.entity.Items">
                 <id column="items_id" property="id"/>
                 <result column="items_name" property="itemsName"/>
                 <result column="items_detail" property="detail"/>
                 <result column="items_price" property="price"/>
               </association>
            </collection>
          </collection>
      </resultMap>
    <!-- 查询用户及用户购买的商品信息,使用resulaMap-->
    <select id="findUserAndItemsResultMap" resultMap="userAndItemsResultMap">
        SELECT 
             t1.*,
             t2.username,
             t2.sex,
             t2.address,
             t3.id orderdetail_id,
             t3.items_id,
             t3.items_num,
             t3.orders_id,
             t4.itemsname items_name,
             t4.detail items_detail,
             t4.price items_price
        FROM
            orders t1,
            t_user t2,
            orderdetail t3,
            items t4
        WHERE t1.user_id =  t2.id AND  t3.orders_id=t1.id AND t3.items_id = t4.id
    </select>
    展开全文
  • mybatis 高级映射和spring整合(4)————————————————学习结构———————————————————— 0.0对订单商品数据模型进行分析 1.0高级映射 1.1一对一查询 1.2一对多查询 1.3多...

    mybatis 高级映射和spring整合之高级映射

    ————————————————学习结构————————————————————
        0.0 对订单商品数据模型进行分析
        1.0 高级映射
            1.1 一对一查询
            1.2 一对多查询
            1.3 多对多查询
            1.4  resultMap总结
            1.5 延迟加载
        2.0 查询缓存
            2.1 一级缓存
            2.2 二级缓存(了解mybatis二级缓存使用场景)
        3.0 mybatis和spring整合(掌握)
        4.0 逆向工程(会用)
    ————————————————学习笔记详细————————————————
    0.0对订单商品数据模型进行分析
        0.1.1每张表记录的数据内容
            分模块对每张表记录的内容进行熟悉,相当于学习系统需求(功能)的过程。
        0.1.2分析每张表重要字段即非空字段、外键
        0.1.3数据库级别表于表之间的关系
            外键关系
        0.1.4表于表之间的业务关系
            在分析表于表之间的业务关系时,一定要建立在某个意义基础上去分析。
    
        0.2数据模型的分析( 可用工具PowerDesigner)
            用户表:user
                记录了购买商品的用户信息
                id:自增主键
    
            订单表:order
                记录了用户所创建的订单(购买商品的订单)
                number:订单号
                user_id(外键,用户id)
            订单的明细表:orderdetall
                记录了订单的详细信息即订单购买商品的信息
                id:自增主键
                orders_id(外键,订单id)
                items_di(外键,商品id)
            商品表:items
                记录了商品信息
                id:自增主键
    
            表于表之间的业务关系
                在分析表于表之间的业务关系时需要建立在某个业务意义基础上去分析
            分析数据库级别之间有关系的表之间的业务关系:
                user和oders:
                user--->orders:一个用户可以创建多个订单,一对多
                orders--->user:一个订单只由一个用户创建,一对一
    
                orders和orderdetall:
                orders--->orderdetall:一个订单可以包含多个订单明细,因为一个订单可以购买多个商品,而每个商品的购买信息,在orderdetall记录,一对多关系。
                orderdetall--->orders:一个订单明细只能包含在一个订单中,一对一。
    
                orderdetall和items:
                orderdetall--->items:一个商品明细只对于一个商品信息,一对一。
                items--->orderdetall:一个商品信息可以包含在多个订单明细中,一对多。
    
            在分析数据库级别没有关系的表之间是否有业务关系:
            orders和items:
            orders和items之间可以根据订单明细表orderdetall,所以是orders和items多对多。
            user和items 多对多关系
    1.0 高级映射
        1.1 一对一查询
            1.1.1需求
            查询订单信息,关联查询创建订单的用户信息。
            1.1.2 用resultType实现
                1.1.2.1 sql语句
                SELECT orders.*,USER.username,USER.sex,USER.address FROM orders,USER WHERE orders.user_id=user.id
                确定查询的主表:订单表
                确定查询的关联表:用户表
                    关联查询使用内链接?还是外链接?
                    由于 orders表有外键(user_id),通过外键关联查询用户表只能查询出一条记录,可以使用内链接。
                1.1.2.2创建pojo
                    将上边sql查询的结果集映射到pojo中,pojo中必须包含所有查询列名。
                    原始的Orders.java不能映射全部字段,需要新创建一个pojo。
                        创建一个pojo继承包括查询字段较多的po类。
    
                        //通过映射订单和用户查询的结果,让此类结果包括字段较多的pojo类
                        public class OrdersCustom extends Orders{
                            //添加用户属性
                            /**USER.username,
                            USER.sex,
                            USER.address*/
    
                            private String username;
                            private String sex;
                            private String address;
                            }
                1.1.2.3mapper.xml
    
                    <!--查询订单关联查询用户信息-->
                    <select id="findOrdersUser" resultType="com.demo.po.OrdersCustom">
                                    SELECT orders.*,
                                    USER.username,
                                    USER.sex,
                                    USER.address
                                    FROM
                                    orders,
                                    USER 
                                    WHERE orders.user_id=user.id
                    </select>
    
    
    
                1.1.2.4mapper.java
    
                    public interface OrdersMapperCustom{
    
                        //查询订单关联查询用户信息
                        public List<OrdersCustom> findOrdersUser()throws Exception;
                    }
                1.1.2.5测试
                    public void testFindOrdersUser() throws Exception{
                        SqlSession sqlSession = sqlSessionFactory.openSession();
                        //创建代理对象
                        OrdersMapperCustom orderMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);
                        //调用mapper的方法
                        List<OrdersCustom> list = ordersMapperCustom.findOrdersUser();
                        system.out.println(list);
                        sqlSession.close();
    
                    }
    
            1.1.3 用resultMap实现
    
                1.1.3.1 sql语句
                    同1.2.1 resultType实现的sql
    
                1.1.3.2 使用resultMap映射的思路
                    使用resultMap将查询结果中的订单信息映射到orders对象中,在orders类中添加User属性
                    ,将关联查询出来的用户信息映射到orders对象中的user属性中。
                    需要Orders类中添加User属性
    
                1.1.3.3需要Orders类中添加user属性
    
                    public class Orders{
    
                        private Integer userId;
                        private String number;
                        private Date createtime;
                        private String note;
                        //用户信息
                        private User user;
                    }
                1.1.3.4 mapper.xml
    
                1.1.3.4.1 定义resultMap:
    
                    <!--  订单查询关联用户的resultMap
                    将整个查询的结果映射到com.demo.po.Orders中
                    -->
                    <resultMap type="com.demo.po.Orders" id="OrdersUserResultMap">
                        <!-- 配置映射的订单信息 -->
                        <!-- id:指定查询列中的唯一标识,订单信息中的唯一标识,如果有多个列组成唯一标识,配置多个id
                            column:订单信息的唯一标识列
                            property:订单信息的唯一标识列所映射到Orders中哪个属性
                        -->
                        <id column="id" property="id"/>
                        <result column="user_id" property="userId"/>
                        <result column="number" property="number"/>
                        <result column="createtime" property="createtime"/>
                        <result column="note" property="note"/>
    
                        <!-- 配置映射的关联的用户信息 -->
                        <!--  association :用于映射关联查询单个对象的信息
                              property:要将关联查询的用户信息映射到Orders中哪个属性
                        -->
                        <association property="user" javaType="com.demo.po.User">
                            <!--  id:关联查询用户的唯一标识
                            column:指定唯一标识用户信息的列
                            JavaType:映射到user的哪个属性
                            -->
                            <id column="user_id" javaType="id"/>
                            <result column="username" property="username"/>
                            <result column="sex" property="sex"/>
                            <result column="address" property="address"/> 
                        </association>
                    </resultMap>
    
                1.1.3.4.2 statement 的定义
                    <!--  查询订单关联查询用户信息,使用resultmap -- >
                    <select id="findOrdersUserResultMap" resultMap="OrdersUserResultMap">
                                        SELECT 
                                        orders.*,
                                        USER.username,
                                        USER.sex,
                                        USER.address
                                        FROM
                                        orders,
                                        USER 
                                        WHERE orders.user_id=user.id
                    </select>
    
                1.1.1.3.5 mapper.java
    
                    //查询订单关联查询用户信息使用resultMap
                    public List<Orders> findOrdersUserResultMap() throws Exception;
                1.1.3.6测试
                @test
                public void testFindOrdersUserResultMap() throws Exception{
                    SqlSession sqlSession = sqlSessionFactory.openSession();
                    //创建代理对象
                    OrdersMapperCustom orderMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class)
    
                    //调用mapper的方法
                    List.out.println(list);
                    sqlSession.close;
    
                }
    
    
    
    
    
            1.1.4 resultType和resultMap实现一对一查询小结
    
                resultType:使用resulType实现比较简单,如果pojo中没有查询出来的列名,需要增加列名对应的属性,即可完成映射。
                如果没有查询结果的特殊要求建议使用resultType.
    
                resultMap:需要独立定义resultMap,实现有点麻烦,如果对查询结果有特殊的要求,使用resultMap可以完成将关联查询映射pojo的属性中。
    
                resultMap可以实现延迟加载,resultType无法实现延迟加载。
        1.2 一对多查询
            1.2.1需求
            查询订单及订单明细的信息。
            1.2.2 sql语句
            确定主查询表:订单表
            确定关联查询表:订单明细表
            在一对一查询基础上添加明细表的关联即可。
    
            SELECT
                order.*,
                USER.username,
                USER.sex,
                USER.address,
                orderdetall.id orderdetall_id,
                orderdetall.items_di,
                orderdetall.items_num,
                orderdetall.order_id
            FROM
                orders,
                USER,orderdetall
            WHERE order.user_id = user.id AND orderdetall.order_id = order.id
    
            1.2.3分析
            使用resultType将上边的查询结果映射到pojo中,那么订单的信息就重复。
            要求:
            对orders映射不能出现映射记录。
            在orders.java 类中添加List<orderDetall>orderDetalls属性。
            最终会将订单信息映射到orders中,订单所对应的订单明细映射到orders中的orderDetails属性中。
            映射成的orders的记录数为两条(orders信息不重复)
            每个orders中的orderDetalls属性存储了该订单所对应的订单明细。
            1.2.4 在orders中添加list订单明细属性
    
            public class Orders{
                private Integer id;
                private Integer userId;
                private String number;
                private Date createtime;
                private String note;
                //用户信息
                private User user;
                //订单明细
                private List<Orderdetail> orderdetails;
            }
            1.2.5 mapper.xml
    
            <!-- 查询订单关联查询用户及订单明细,使用resultmap -->
            <select id = "findOrdersAndOrderDetailResultMap" resultMap="OrdersAndOrderDetailResultMap">
            SELECT
                order.*,
                USER.username,
                USER.sex,
                USER.address,
                orderdetall.id orderdetall_id,
                orderdetall.items_di,
                orderdetall.items_num,
                orderdetall.order_id
            FROM
                orders,
                USER,orderdetall
            WHERE order.user_id = user.id AND orderdetall.order_id = order.id
            </select>
    
            1.2.6 resultMap 的定义
    
            <!--  订单及订单明细的resultMap 
            使用extends继承,不用在配置订单信息和用户信息的映射
            -->
            <resultMap type="com.demo.po.Orders" id="OrdersAndOrderDetailResultMap" extends="OrdersUserResultMap">
                <!-- 订单信息 -->
                <!-- 用户信息 --><!-- 使用extends继承,不用在配置订单信息和用户信息的映射(省去了158到176行代码) -->
    
    
                <!-- 订单明细信息
                一个订单关联查询多条明细,要使用collection进行映射
                collection:对关联查询到多条记录映射到集合对象中
                property:将关联查询到多条记录映射到com.demo.po.Orders哪个属性
                ofType:指定映射到lsit集合属性中pojo中的类型
                -->
                <collection property = "orderdetalls" ofType="com.demo.po.Orderdetail">
                    <!-- id:订单明细的唯一标识
                    property:要将订单明细的唯一标识映射到com.demo.po.Orderdetail的哪个属性
                    -->
                    <id colum="orderdetail_id" property="id"/>
                    <result colum="items_id" property="itemsId"/>
                    <result colum="items_num" property="itemsNum"/>
                    <result colum="orders_id" property="ordersId"/>
    
                </collection>
                </resultMap>
    
            1.2.7 mapper.java
            //查询订单(关联用户)及订单明细
            public List<Orders> findOrdersAndOrderDetailResultMap()throws Exception;
            1.2.8 测试
            @Test 
            public void testfindOrdersAndOrderDetailResultMap()throws Exception{
                SqlSession sqlSession = sqlSessionFactory.openSession();
                //创建代理对象
                OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class)
                //调用mapper的方法
                List<orders> list = ordersMapperCustom.findOrdersAndOrderDetailResultMap();
                system.out.println(list);
                sqlSession.close;
            }
    
            1.2.9 一对多小结
            mybatis 使用resultMap的 collection 对关联查询的多条记录映射到一个list集合属性中。
            如果使用resultType实现:
                将订单明细映射到orders中的orderdetails中,需要自己处理,使用双重循环遍历,去掉重复记录,将订单明细放在orderdetails中。
    
        1.3 多对多查询
            1.3.1需求
                查询用户及用户所购买的商品信息。
            1.3.2 sql 语句
                查询的主表:用户表
                关联表:由于用户和商品没有直接关联,通过订单和订单明细进行关联。所以关联表:orders、orderdetail、items
    
            SELECT
                order.*,
                USER.username,
                USER.sex,
                USER.address,
                orderdetall.id orderdetall_id,
                orderdetall.items_di,
                orderdetall.items_num,
                orderdetall.order_id,
                items.name items_name,
                items.detail items_detail,
                items.price items_price
            FROM
                orders,
                USER,
                orderdetall,
                items
            WHERE order.user_id = user.id AND orderdetall.order_id = order.id AND orderdetail.items_id = items.id
    
            1.3.3 映射思路
    
            将用户信息映射到user中。
            在user中添加订单列表的属性 List<Orders>orderslist,将用户创建的订单映射到orderlist
            在orders中添加订单明细列表属性List<OrderDetail>orderdetails,将订单的明细映射到orderdetails
            在OrderDetail中添加items属性,将订单明细所对应的商品映射到items
    
    
    
            1.3.4 mapper.xml
    
            <!-- 查询用户及购买的商品信息,使用resultmap -->
            <select id="findUserAndItemsResultMap" resultMap="UserAndItemsResultMap">
                SELECT
                    order.*,
                    USER.username,
                    USER.sex,
                    USER.address,
                    orderdetall.id orderdetall_id,
                    orderdetall.items_di,
                    orderdetall.items_num,
                    orderdetall.order_id,
                    items.name items_name,
                    items.detail items_detail,
                    items.price items_price
                FROM
                    orders,
                    USER,
                    orderdetall,
                    items
                WHERE order.user_id = user.id AND orderdetall.order_id = order.id AND orderdetail.items_id = items.id
            </select>
    
    
            1.3.5 resultMap定义(重点)
                <!-- 查询用户及购买的商品 -->
                <resultMap type="com.demo.po.User" id="UserAndItemsResultMap">
                    <!-- 用户信息 -->
                    <id column="user_id" property="id"/>
                    <result column="username" property="username"/>
                    <result column="sex" property="sex"/>
                    <result column="address" property="address"/>
    
                    <!-- 订单信息
                    一个用户对应多个订单,使用collection映射
                    -->
                    <collection property="ordersList" ofType="com.demo.po.Orders">
                        <id column="id" property="id"/>
                        <result cloumn="user_id" property="user_id"/>
                        <result cloumn="number" property="number"/>
                        <result cloumn="createtime" property="createtime"/>
                        <result cloumn="note" property="note"/>
    
                        <!-- 订单明细
                        一个订单包括多个明细
                        -- >
                        <collection property="ordersList" ofType="com.demo.po.Orders">
                            <id colum="orderdetail_id" property="id"/>
                            <result colum="items_id" property="itemsId"/>
                            <result colum="items_num" property="itemsNum"/>
                            <result colum="orders_id" property="ordersId"/>
    
                            <!-- 商品信息
                            一个订单明细对应一个商品
                            -->
                            <association property="items" javaType="com.demo.po.Items">
                                <id column="items_id" property="id"/>
                                <result cloumn="items_id" property="id"/>
                                <result cloumn="items_name" property="name"/>
                                <result cloumn="items_detail" property="detail"/>
                                <result cloumn="items_price" property="price"/>
    
                            </association>
    
                        </collection>
    
                    </collection>
    
    
    
                </resultMap>
    
    
    
    
            1.3.6 mapper.java  (接口)
            //查询用户购买商品信息
            public List<User> findUserAndItemsResultMap()throws Exception;
    
            1.3.7 测试
            @Test
            public void testfindUserAndItemsResultMap()throws Exception{
                SqlSession sqlSession = sqlSessionFactory.openSession();
                //创建代理对象
                OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class)
                //调用mapper的方法
                List<User> list = ordersMapperCustom.findUserAndItemsResultMap();
                system.out.println(list);
                sqlSession.close;
            }
    
            1.3.8 多对多总结
    
            需求:将查询用户购买的商品信息明细清单(包含用户名、用户地址、购买商品名称、购买商品时间、购买商品数量)
    
            针对上边的需求就使用resultType将查询到的记录映射到一个扩展的pojo中,很简单实现明细清单的功能。
    
            一对多是多对多的特例,如下需求:
            查询用户购买的商品信息,用户和商品的关系是多对多关系。
            需求1:
                查询字段:用户账号、用户名称、用户性别、商品名称、商品价格(常见)
                企业开发中常见明细列表,用户购买商品明细列表
                使用resultType将上边查询列表映射到pojo输出。
            需求2:
                查询字段:用户账号、用户名称、购买商品数量、商品明细(鼠标移上去显示明细)
                使用resultMap将用户购买的商品明细映射到user对象中。
    
            总结:
            使用resultMap是针对那些查询结果有特殊要求的功能,比如特殊要求映射成list中包含多个list。
    
        1.4 resultMap 总结:
            resultType:
            作用:
                将查询按照结果sql列名pojo属性名一致性映射到pojo中。
            场合:
                常见一些明细记录的展示,比如用户购买商品明细,将关联信息全部展示在页面时,
                此时,可直接使用resultType将每一条记录映射到pojo中,在前端页面遍历list(list中是pojo)即可。
    
            resultMap:
                使用association和collection完成一对一和一对多高级映射(对查询结果有特殊的映射要求)。
    
                association:
                作用:
                    将关联查询信息映射到一个pojo对象中。
                场合:
                    为了方便关联信息可以使用association将关联订单信息映射为用户对象的pojo属性中,
                    比如:查询订单及关联用户信息。
                    使用resultType无法将查询结果映射到pojo对象的pojo属性中,根据对结果集查询遍历的需要选择使用
                    resultType还是resultMap。
                collection:
                作用:
                    将关联查询信息映射到一个list集合中。
                场合:
                    为了方便查询遍历关联信息可以使用collection将关联信息映射到list集合中,比如:
                    查询用户权限范围模块及模块下的菜单,可使用collection将模块映射到模块list中,
                    将菜单列表映射到模块对象的菜单list属性中,这样做的目的也是方便对查询结果进行
                    遍历查询。
                        如果使用resultType无法将查询结果映射到list集合中。
    
        1.5延迟加载
            1.5.1 什么是延迟加载
            resultMap可以实现高级映射(使用association、collection实现一对一、一对多映射),association、collection具备
            延迟加载功能。
            需求:
            如果查询订单并且关联查询用户信息。如果先查询订单信息即可满足要求,当我们需要查询用户信息时再查询用户信息。
            把对用户信息的按需去查询就是延迟加载。
    
            延迟加载:先从单表查询、需要时再从关联表去查询,大大提高数据库性能,因为查询单表要比关联查询多张表速度要快。
    
            1.5.2 使用association实现延迟加载
                1.5.2.1 需求
                查询订单并且关联用户信息。
    
                1.5.2.2 mapper.xml
                需要定义两个mapper的方法对应的statement。
                    1、只查询订单信息
                    SELECT * FROM orders
                    在查询订单的statement中使用association去延迟加载(执行)下边的statement(关联查询用户信息)
    
                    <!-- 查询订单关联查询用户,用户信息需要延迟加载 -->
                    <select id="findOrdersUserLazyLoading" resultMap="OrdersUserLazyLoading">
                        SELECT * FROM orders
                    </select>
    
                    2、查询用户信息
                        通过上边查询到的订单信息中user_id去关联查询用户信息。
                        使用UserMapper.xml中的findUserByid
                        <select id="findUserById" parameterType="int" resultType="user">
                            SELECT * FROM USER WHERE id = #{value}
                        </select>
                    流程:上边先去执行findOrdersUserLazyLoading,当需要去查询用户的时候再去执行findUserById,通过
                        resultMap的定义将延迟加载执行配置起来。
    
                1.5.2.3 延迟加载resultMap
    
                使用association中的select指定延迟加载去执行的statement的id。
    
                <!-- 延迟加载的resultMap -->
                <resultMap type="com.demo.po.Orders" id="findOrdersUserLazyLoading">
                    <!-- 对订单信息进行映射配置 -->
                    <id column="id" property="id"/>
                    <result cloumn="user_id" property="user_id"/>
                    <result cloumn="number" property="number"/>
                    <result cloumn="createtime" property="createtime"/>
                    <result cloumn="note" property="note"/>
                    <!-- 实现对用户信息进行延迟加载
                        select:指定延迟加载需要执行的statement的id(是根据user_id查询用户信息的statement)
                        要使用userMapper.xml中findUserById完成根据用户id(user_id)用户信息的查询,如
                        果 findUserById不在本mapper中需要前面加namespace
                        column:订单信息中关联用户信息查询的列,是user_id
                        关联查询的sql理解为:
                        SELECT orders.*,
                        (SELECT username FROM USER WHERE orders.user_id = user.id)username,
                        (SELECT sex FROM USER WHERE orders.user_id = user.id)sex
                        FROM orders
                    -->
                    <association property="user" javaType="com.demo.po.User" select="com.demo.mybatis.mapper.UserMapper.findUserById" cloumn="user.id">
                    <!-- 实现对用户信息进行延迟加载 -->
                    </association>
    
                </resultMap>
    
                <!-- 查询订单关联查询用户,用户信息需要延迟加载 -->
                <select id="findOrdersUserLazyLoading" resultMap="OrdersUserLazyLoading">
                    SELECT * FROM orders
                </select>
    
    
                1.5.2.4 mapper.java(接口)
                //查询订单关联查询用户,用户信息时延迟加载
                public List<Orders> findOrdersUserLazyLoading()throws Exception;
    
                1.5.2.5 测试
                测试思路:
                1、执行上边mapper方法(findOrdersUserLazyLoading),内部去调用com.demo.mybatis.mapper.OrdersMapperCustom中的findOrdersUserLazyLoading只查询orders信息(单表)。
    
                2、在程序中去遍历上一步骤查询出的List<Orders>,当我们调用Orders中的getUser方法时,开始进行延迟加载。
    
                3、延迟加载,去掉用UserMapper.xml中findUserById这个方法获取用户信息。
    
                1.5.2.6 延迟加载配置
    
                在mybatis核心配置文件中配置:
                lazyLoadingEnable、aggressiveLazyLoading
    
                设置项             描述                      允许值     默认值
    
                lazyLoadingEnable   全局性设置懒加载。如果设为   true        
                                    'false',则所有相关的都会被               false
                                    初始化加载                   false
    
                aggressiveLazyLoading当设置为’true‘的时候,懒加载true
                                    对象可能被任何懒属性全部加载。         true
                                    否则,每个属性都按需加载     false
    
                SqlMapConfig.xml
    
                <!-- 全局配置参数,需要时再设置 -->
                <settings>
                    <!-- 打开延迟加载的开关 -->
                    <setting name = "lazyLoadingEnable" value="true"/>
                    <!-- 将积极加载改为消极加载即按需加载 -->
                    <setting name = "aggressiveLazyLoading" value="false"/>
                </setting>
    
                1.5.2.7 测试代码
                OrdersMapperCustomTest.java
                //查询订单关联查询用户,用户信息使用延迟加载
                @test
                public void testFindOrdersUserLazyLoading() throws Exception{
    
                    SqlSession sqlSession = sqlSessionFactory.openSession();
                    //创建代理对象
                    OrdersMapperCustom orderMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class)
    
                    //查询订单信息(单表)
                    List<Orders> list = ordersMapperCustom.findOrdersUserLazyLoading();
    
                    //遍历上边的订单列表
                    for(Orders orders:list)
                        //执行getUser()去查询用户信息,这里实现按需加载
                        User user = orders.getUser();
                        System.out.println(user);
    
                }
                1.5.2.8 延迟加载思考
                不使用mybatis提供的association及collection中的延迟加载功能,如果实现延迟加载?
    
                实现方法如下:
                定义两个mapper方法:
                1、查询订单列表
                2、根据用户id查询用户信息
                实现思路:
                先去查询第一个mapper方法,获取订单信息列表
                在程序中(service),按需去调用第二个mapper方法去查询用户信息。
    
                总之:
                使用延迟加载的方法,先去查询简单的sql(最好单表,也可以是关联查询),再去按需加载关联查询的其他信息。
    —————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
    展开全文
  • MyBatis 高级映射

    2018-01-26 14:37:52
    什么是MyBatis高级映射? mybatis是一个持久层框架,不完全的ORM(对象关系映射)框架。有输入参数映射和输出结果映射,pojo通过映射数据库字段才能对数据进行增删改查。即mapper.xml(映射文件)。高级映射即是多...

    一.什么是MyBatis高级映射?

    mybatis是一个持久层框架,不完全的ORM(对象关系映射)框架。有输入参数映射输出结果映射pojo通过映射数据库字段才能对数据进行增删改查。即mapper.xml(映射文件)。高级映射即是多表关联映射,如下所示:

    • 将关联查询的列映射到一个pojo属性中。(一对一)
    • 将关联查询的列映射到一个List<pojo>中。(一对多)

    1、parameterType(输入映射)

    指定输入参数类型可以简单类型、pojo类、hashmap。

    2、输出映射

    (1)resultType

    查询到的列类型和resultType指定输出类型一致。

    (2)reusltMap

    可以通过resultMap 完成一些高级映射。如果查询到的列名和映射的pojo的属性名不一致时,通过resultMap设置列名和属性名之间的对应关系(映射关系),可以完成映射。resultMap元素中,允许有以下直接子元素:

    • constructor:类在实例化时,用来注入结果到构造方法中;作用与result相同,同时可以标识出用这个字段值可以区分其他对象实例。可以理解为数据表中的主键,可以定位数据表中唯一记录。
    • result:将数据表中的字段注入到Java对象属性中。
    • association:关联关系,如“用户”有一个“帐号”。其中select属性可以指定查询语句。
    • collection:集合,顾名思议,就是“有很多”关系,如“用户”有很多“订单”。

    result 标签的属性

    • property:对象属性的名称
    • jdbcType:对象属性的类型
    • column:所对应的字段名称

    二.为什么用MyBatis高级映射?

    在现实的项目中进行数据库建模时,我们要遵循数据库设计范式的要求,会对现实中的业务模型进行拆分,封装在不同的数据表中,表与表之间存在着一对多或是多对多的对应关系。进而,我们对数据库的增删改查操作的主体,也就从单表变成了多表。下面举例说明高级映射:

    1. 一个用户可以创建多个订单,一对多。
    2. 一个订单只由一个用户创建,一对一 。
    3. 一个订单可以包括多个订单明细,因为一个订单可以购买多个商品,每个商品的购买信息在orderdetail记录,一对多关系反过来多个订单明细对应一个订单,多对一关系。
    4. 多个用户创建多个订单,多对多关系。

    三.对应关系

    1、一对一关系

    <?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,namespace的值习惯上设置成包名+sql映射文件名,这样保证了namespace的值是唯一的-->
    <mapper namespace="com.yc.mybatis.test.classMapper">
        
            <!-- 
             方式一:嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集
                     封装联表查询的数据(去除重复的数据)
             select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=1
         -->
        
        <select id="getClass" parameterType="int" resultMap="getClassMap">
            select * from class c, teacher t  where c.teacher_id = t.t_id and c.teacher_id=#{id}
        </select>
        
        <!-- resultMap:映射实体类和字段之间的一一对应的关系 -->
        <resultMap type="Classes" id="getClassMap">
            <id property="id" column="c_id"/>   
            <result property="name" column="c_name"/>
            <association property="teacher" javaType="Teacher">   
                <id property="id" column="t_id"/>
                <result property="name" column="t_name"/>
            </association>
        </resultMap>
        
         <!-- 
             方式二:嵌套查询:通过执行另外一个SQL映射语句来返回预期的复杂类型
             SELECT * FROM class WHERE c_id=1;
             SELECT * FROM teacher WHERE t_id=1   //1 是上一个查询得到的teacher_id的值
             property:别名(属性名)    column:列名 -->
              <!-- 把teacher的字段设置进去 -->
        <select id="getClass1" parameterType="int" resultMap="getClassMap1">
            select * from class where c_id=#{id}
        </select>
        
        <resultMap type="Classes" id="getClassMap1">
            <id property="id" column="c_id"/>   
            <result property="name" column="c_name"/>
            <association property="teacher" column="teacher_id" select="getTeacher"/>   
        </resultMap>
        <select id="getTeacher" parameterType="int" resultType="Teacher">
            select t_id id,t_name name from teacher where t_id =#{id}
        </select>
    </mapper>

    这里bean层会发生变化 这个classes的被bean层会多一个Teacher的属性,并且增加的get,set方法。

    2、一对多关系

    <?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.yc.mapper.CustomerMapper"> 
     
      <resultMap type="com.yc.m.Customer" id="resultCustomerMap"> 
        <id column="id" jdbcType="INTEGER" property="id" />
        <result property="address" column="address"/> 
        <result property="postcode" column="postcode"/> 
        <result property="sex" column="sex"/> 
        <result property="cname" column="cname"/> 
        <collection property="orders" ofType="com.yc.m.Orders">
              <id property="id" column="id"/>
              <result property="code" column="code"/>
        </collection>
      </resultMap> 
        
      <select id="getCustomer" resultMap="resultCustomerMap" parameterType="int"> 
        SELECT * 
        FROM t_customer 
        WHERE id=#{id} 
      </select>      
    </mapper> 

    在这里可以明显的看出多出了一个属性ofType,这个ofType的含义就是你collection所对应的是那个bean,当然在bean层中也会发生变化 ,这里在Customer的bean中嵌套一条语句:

    private List<Orders> orders;   //一个Customer 对应N多个Orders

     

    展开全文
  • 一、什么是MyBatis高级映射  mybatis是一个持久层框架,不完全的ORM(对象关系映射)框架。sql语句需要程序员自己去写,都是mybatis也有映射(输入参数映射,输出结果映射)。pojo通过映射数据库字段才能对数据...
  • 当我们学习heribnate的时候,也就是SSH框架的网上商城的时候,我们就学习过它对应的高级映射,一对一映射,一对多映射,多对多映射。对于SSM的Mybatis来说,肯定也是差不多的。既然开了头了,我们就也来简单说一些...
  • MyBatis之使用resultMap实现高级映射 2017/09/30 对于数据库中对表的增删改查操作,我们知道增删改都涉及的是单表,而只有查询操作既可以设计到单表操作又可以涉及到多表操作,所以对于输入映射parameterType而言...
  • 深入浅出Mybatis(八)高级映射

    千次阅读 2018-03-31 18:37:29
    前面的章节使用的都是对单张表的操作,但是在实际开发当中,很多时候需要关联多张表,这时就需要用到我们的高级映射,包括一对一,一对多和多对多。下面先来分析一个简单的业务场景。有四张表:用户表:user保存用户...
  • 在上一篇博客中,对mybatis的高级映射----一对一查询进行了讲解.这篇博客中,将在上一篇博客的基础上讲解mybatis的高级映射
  • 1.输入映射  通过parameterType指定输入参数的类型,类型可以是简单类型、 hashmap 、 pojo 的包装类型。  [1]简单类型   例如入门程序里的根据用户ID查询用户信息的映射文件,输入Int值。   [2]POJO类型...
  • Mybatis高级映射多对多查询

    千次阅读 2017-11-19 10:33:54
    紧接着上一篇文章:Mybatis高级映射一对多查询 写 一、开发准备 1、新建数据表(四张表)和添加测试数据 DROP TABLE IF EXISTS `items`;DROP TABLE IF EXISTS `orders`;DROP TABLE IF EXISTS ...
  • 【MyBatis框架】高级映射-延迟加载

    千次阅读 2015-06-30 15:18:43
    resultMap可以实现高级映射(使用association、collection实现一对一及一对多映射),association、collection具备延迟加载功能。 需求: 如果查询订单并且关联查询用户信息。如果先查询订单信息即可满足要求,当...
  • 学习Mybatis框架(五)—高级映射(多表关联查询)

    万次阅读 多人点赞 2018-06-15 11:13:20
    高级映射:(了解) 实现一对一查询、一对多、多对多查询。 延迟加载 查询缓存 一级缓存 二级缓存(了解mybatis二级缓存使用场景) 一、高级映射 订单商品数据模型 1.1 数据模型分析思路 1、每张表...
  • 【MyBatis学习08】高级映射之一对一查询

    万次阅读 多人点赞 2016-06-13 20:04:10
    从这一篇博文开始,将总结一下mybatis中的几个高级映射,即一对一、一对多、多对多查询,这篇先总结一下mybatis中的一对一查询。 为了模拟这些需求,事先要建立几个表,不同的表之间将对应上面提到的不同的映射,...
  • 上一篇文章我们讲解了《Mybatis—高级映射之一对一查询(七)》下面我们继续来讲解高级映射中的一对多和多对多查询。 【一对多查询】 1、需求 查询订单及订单明细的信息。 2、sql语句 确定主查询表:订单...
  • 问题:mybatis collection高级映射(不使用子查询,避免N+1),mapper配置如下: resultMap id="OmsSkuPoMap" type="com.trymore.pifa.domain.po.OmsSkuPo" >  id column="sku_id" property="skuId" ...
  • 其实一对一和一对多映射,在前面的配置中已经接触到,我没在日志里直接说明,是因为想要在之后写一篇总结日志(就是本篇),总结这些高级映射的配置。例如一对一查询在关联的嵌套结果集查询中就涉及到,一对多查询则...
  • 心得8-hibernate 高级映射

    千次阅读 2012-12-24 13:18:44
    在做持久化类的时候的规定:  1).有一个默认的构造方法;  2).所有的属性都有setter和getter方法  3).... 4)....不能定义成类类型HashSet、hashMap、ArrayList等 ...高级映射 元素:可以映射java.util.Set接口
  • MyBatis基础用法--使用resultMap自定义高级映射规则

    万次阅读 多人点赞 2017-10-03 18:10:57
    中最基本的映射内容,它们都可以将查询结果中一个单独列的值映射为返回结果对象中的简单数据类型(字符串,整型,双精度浮点数,日期等)的单独属性或字段。这两者之间的唯一不同是 id 表示的结果将是当比较对象实例时...
  • 高级映射之一对一、一对多、多对多
  • 2.高级映射 将关联映射的列查询映射到一个pojo属性中。(1对1) 将关联映射的列查询映射到List属性中。(1对多) 3.订单中的映射需求 数据模型分析思路: (1)每张表记录的数据内容 分模块对每张表记录的内
  • mybatis 高级映射和spring整合之逆向工程(7)4.0 逆向工程 4.1 mybatis需要程序员自己编写sql语句,mybatis官方提供逆向工程,可以针对单表自动生成mybatis执行所需的代码(mapper.java,mapper.xml,po..) 企业...
  • mybatis 高级映射和spring整合之mybatis与Spring整合3.0 mybatis和spring整合(掌握) 3.1 整合思路 需求spring通过单例方式管理SqlSessionFactory。 spring和mybatis整合生成代理对象,使用SqlSessionFactory...
  • 【Mybatis】---高级映射之一对一查询

    千次阅读 热门讨论 2017-02-28 11:52:05
    在上一篇mybatis的博客中... IDEA框架搭建+实例讲解,接下来要讲解的是mybatis的高级映射.mybatis的高级映射包括一对一查询,一对多,多对多查询.本篇文章将要介绍使用ResultType和ResultMap的一对一查询.将通过这两种方式
  • --高级映射需要配置resultMap,值为resultMap的id--> <!--根据用户查询所有订单条系--> SELECT c.cartItemId, c.quantity, b.bname, b.image_b, b.currPrice, u.loginname FROM t_cartitem c LEFT JOIN ...
  • mybatis的高级映射(包括 resultmap标签,column属性传多个参数,select子查询自身) 重点看代码里的注释的解释 resultmap子查询时,传多个参数时的格式:column="{自定义参数名=字段名,…}" 对方用#{参数名}接受参数值...
  • Hibernate高级映射 --- 集合映射 一 概念 1.集合类型的作用 在持久化类中,有时会使用到值类型的对象属性,所谓值类型的对象,是指它对应的类没有对象标识符属性,只能作为一个持久化类的属性使用。如果持久化...
  • Java EE数据持久化框架 • 【第3章 MyBatis高级映射

    万次阅读 多人点赞 2021-04-20 11:23:49
    3.1 一对一映射 3.1.1 自动化一对一映射 3.1.2 标签配置一对一映射 3.1.3 标签配置一对一映射 3.1.4 实践练习 3.2 一对一映射中的嵌套查询 3.2.1 标签嵌套查询属性 3.2.2 标签嵌套查询实现 3.2.3 实践练习 ...
  • MyBatis是一个支持普通SQL查询,存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。MyBatis可以使用简单的XML或注解用于配置和原始映射,将接口和Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 198,795
精华内容 79,518
关键字:

高级映射