Mybatis高级映射一对一查询

avatar 2017年08月13日09:49:20 1 1943 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此
从这一篇博文开始，将总结一下mybatis中的几个高级映射，即一对一、一对多、多对多查询，这篇先总结一下mybatis中的一对一查询。
为了模拟这些需求，事先要建立几个表，不同的表之间将对应上面提到的不同的映射，为此，我建立4个表，如下：
  1. DROP TABLE IF EXISTS `items`;
  2. DROP TABLE IF EXISTS `orders`;
  3. DROP TABLE IF EXISTS `user`;
  4. DROP TABLE IF EXISTS `orderdetail`;
  6. /*items是商品表*/
  7. CREATE TABLE `items` (
  8.   `id` INT(11) NOT NULL AUTO_INCREMENT,
  9.   `name` VARCHAR(32) NOT NULL COMMENT '商品名称',
  10.   `price` FLOAT(10,1) NOT NULL COMMENT '商品定价',
  11.   `detail` TEXT COMMENT '商品描述',
  12.   `pic` VARCHAR(64) DEFAULT NULL COMMENT '商品图片',
  13.   `createtime` DATETIME NOT NULL COMMENT '生产日期',
  14.   PRIMARY KEY (`id`)
  15. ) ENGINE=INNODB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
  17. /*user是用户表*/
  18. CREATE TABLE `user` (
  19.   `id` INT(11) NOT NULL AUTO_INCREMENT,
  20.   `username` VARCHAR(32) NOT NULL COMMENT '用户名称',
  21.   `birthday` DATE DEFAULT NULL COMMENT '生日',
  22.   `sex` CHAR(1) DEFAULT NULL COMMENT '性别',
  23.   `address` VARCHAR(256) DEFAULT NULL COMMENT '地址',
  24.   PRIMARY KEY (`id`)
  25. ) ENGINE=INNODB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;
  27. /*orders是订单表*/
  28. CREATE TABLE `orders` (
  29.   `id` INT(11) NOT NULL AUTO_INCREMENT,
  30.   `user_id` INT(11) NOT NULL COMMENT '下单用户id',
  31.   `number` VARCHAR(32) NOT NULL COMMENT '订单号',
  32.   `createtime` DATETIME NOT NULL COMMENT '创建订单时间',
  33.   `note` VARCHAR(100) DEFAULT NULL COMMENT '备注',
  34.   PRIMARY KEY (`id`),
  35.   KEY `FK_orders_1` (`user_id`),
  36.   CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
  37. ) ENGINE=INNODB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
  39. /*orderdetail是订单明细表*/
  40. DROP TABLE IF EXISTS orderdetail;
  41. CREATE TABLE `orderdetail` (
  42.   `id` INT(11) NOT NULL AUTO_INCREMENT,
  43.   `orders_id` INT(11) NOT NULL COMMENT '订单id',
  44.   `items_id` INT(11) NOT NULL COMMENT '商品id',
  45.   `items_num` INT(11) DEFAULT NULL COMMENT '商品购买数量',
  46.   PRIMARY KEY (`id`),
  47.   KEY `FK_orderdetail_1` (`orders_id`),
  48.   KEY `FK_orderdetail_2` (`items_id`),
  49.   CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  50.   CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
  51. ) ENGINE=INNODB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

每个表对应的po就不写了。从上面的表中，可以分析出下面的一些关系：

这一节主要总结mybatis中一对一的映射，所以我选择左边orders和user之间的一对一关系来总结，主要是查询订单信息，关联查询创建订单的用户信息。
我们知道，查询结果可以使用resultType，也可以使用resultMap，在这里我两种方法都使用一下，然后对比一下各个方法的特点。


一、resultType方法



1、 sql查询语句


写查询语句的时候首先得确定查询的主表，这里是订单表，然后关联表是用户表。由于orders表中有一个外键（user_id），通过此外键关联查询用户表只能查询出一条记录，所以使用内连接。查询的sql如下：
  1. SELECT
  2.   orders.*,
  3.   USER.username,
  4.   USER.sex,
  5.   USER.address
  6. FROM
  7.   orders,
  8.   USER
  9. WHERE orders.user_id = user.id

有了sql，接下来就是创建pojo了

2、 创建pojo

使用resultType的话，有个前提就是查询结果要想映射到pojo中去，pojo中必须包括所有查询出的列名才行。这里不仅查询出order表中的所有字段，而且还查询出了用户表中的部分字段，所以我们要自己新建一个pojo来包含所有的这些查询出来的字段才行。
创建pojo的原则是继承包括查询字段较多的po类。
  1. //通过此类映射订单和用户查询的结果，让此类继承包括字段较多的po类
  2. public class OrdersCustom extends Orders {
  4.     //继承了Orders，已经有了Orders的所有属性了
  5.     //下面添加用户属性
  6.     private String username;
  7.     private String sex;
  8.     private String address;
  10.     //省略get和set方法
  11. }

接下来就可以写mapper.xml映射文件了。

3、 UserMapperOrders.xml配置文件

  1. <mapper namespace="mybatis.mapper.UserMapperOrders">
  3.     <select id="findOrdersUser" resultType="mybatis.po.OrdersCustom">
  4.         SELECT
  5.           orders.*,
  6.           user.`username`,
  7.           user.`sex`,
  8.           user.`address`
  9.         FROM
  10.           orders,
  11.           USER
  12.         WHERE orders.`user_id` = user.`id`
  13.     </select>
  14. </mapper>

4、 UserMapperOrders.java接口
  1. public interface UserMapperOrders {
  3.     //查询订单，关联查询用户信息
  4.     public List<OrdersCustom> findOrdersUser() throws Exception;
  5. }



注意接口和映射文件要放在同一个目录下，因为SqlMapConfig.xml文件中配置的是批量加载mapper，这里可以参考我的这篇博文：传送门。
到这里就完成了使用resultType方法来实现一对一查询了，下面测试一下：
  1. @Test
  2.     public void testUserMapperOrders() throws Exception {
  3.         //获取sqlSessionFactory的代码省略了
  4.         SqlSession sqlSession = sqlSessionFactory.openSession();
  5.         UserMapperOrders userMapperOrders = sqlSession.getMapper(UserMapperOrders.class);
  6.         List<OrdersCustom> list = userMapperOrders.findOrdersUser();
  7.         System.out.println(list);
  8.     }

从上面可以看出，使用resultType的流程很简单，还是和之前的一样，关键还是在sql语句上，这也是mybatis的强大之处，自己写sql语句，想怎么查就怎么查。下面再总结一下使用resultMap方法来实现一对一查询。




二、 resultMap方法


还是上面那个sql，使用resultMap方法的思路如下：使用resultMap将查询结果中的订单信息映射到Orders对象中，在Orders类中添加User属性，将关联查询出来的用户信息映射到Orders对象中的User属性中。所以现在Orders类中添加一项User属性，我就不写具体的代码了。
学过hibernate就会感觉这里和Hibernate有点像，如果用Hibernate，这里也是在Orders类中添加一个User属性，将查询Orders关联出的User放到User属性中。

1、定义resultMap
  1. <resultMap type="mybatis.po.Orders" id="OrdersUserResultMap">
  2.     <!-- 配置映射订单信息 -->
  3.     <id column="id" property="id"/>
  4.     <result column="user_id" property="userId"/>
  5.     <result column="number" property="number"/>
  6.     <result column="createtime" property="createtime"/>
  7.     <result column="note" property="note"/>
  9.     <!-- 配置映射的关联的用户信息 -->
  10.     <!-- association用于映射关联查询单个对象的信息
  11.         property：要将关联查询的用户信息映射到Orders中的哪个属性
  12.         javaType：该属性的类型
  13.      -->
  14.     <association property="user" javaType="mybatis.po.User">
  15.         <id column="user_id" property="id"/>
  16.         <result column="username" property="username"/>
  17.         <result column="sex" property="sex"/>
  18.         <result column="address" property="address"/>
  19.     </association>
  20. </resultMap>

这里主要用到了<association>标签，值用来映射关联查询单个对象的信息，关于resultMap的一些标签属性我在前面的博客中已经解释过了，这里不再赘述。

2、UserMapperOrders.xml配置文件
  1. <select id="findOrdersUserResultMap" resultMap="OrdersUserResultMap">
  2.     SELECT
  3.       orders.*,
  4.       user.`username`,
  5.       user.`sex`,
  6.       user.`address`
  7.     FROM
  8.       orders,
  9.       USER
  10.     WHERE orders.`user_id` = user.`id`
  11. </select>

配置和上面resultType一样的，唯一区别在于id和resultMap，注意一下就行了。

3、UserMapperOrders.java接口
  1. public interface UserMapperOrders {
  3.     //查询订单，关联查询用户信息,使用resultMap
  4.     public List<OrdersCustom> findOrdersUserResultMap() throws Exception;
  6. }

也很简单，不再多说了。下面测试一下：
  1. @Test
  2.     public void testUserMapperOrdersResultMap() throws Exception {
  3.         SqlSession sqlSession = sqlSessionFactory.openSession();
  4.         UserMapperOrders userMapperOrders = sqlSession.getMapper(UserMapperOrders.class);
  5.         List<OrdersCustom> list = userMapperOrders.findOrdersUserResultMap();
  6.         System.out.println(list);
  7.     }

到这里，resultMap方法完成的一对一查询映射就总结完了，从这里可以看出，resultMap方法和hibernate中其实是有点像的。下面再总结一下resultType和resultMap的区别：


三、resultType和resultMap区别


实现一对一查询：
  1. resultType：使用resultType实现较为简单，如果pojo中没有包括查询出来的列名，需要增加列名对应的属性，即可完成映射。如果没有查询结果的特殊要求建议使用resultType。
  2. resultMap：需要单独定义resultMap，实现有点麻烦，如果对查询结果有特殊的要求，使用resultMap可以完成将关联查询映射pojo的属性中。
  3. resultMap可以实现延迟加载，resultType无法实现延迟加载。






参考：

传智播客视频

http://blog.csdn.net/eson_15/article/details/51648140



本文链接：https://liuyanzhao.com/5838.html

历史上的今天
八月
13日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0