2.4.3 Mybatis 高级查询, 复杂映射, 返回主键, 动态SQL if, set, foreach, 核心配置文件深入,plugins标签, 多表查询, 嵌套查询
2024-05-12 19:00:34
目录
Mybatis 复杂映射&配置文件深入
一 Mybatis高级查询
1.1 ResutlMap属性
1.2 多条件查询（三种）
1.3 模糊查询
二 Mybatis映射文件深入
2.1 返回主键
2.1.1 useGeneratedKeys
2.1.2 selectKey
2.2 动态SQL
2.2.1 动态 SQL 之 if (重点掌握)
2.2.2 动态 SQL 之 set
2.2.3 动态 SQL 之 foreach
2.3 SQL片段
2.4 知识小结
三 Mybatis核心配置文件深入
3.1 plugins标签
3.2 知识小结
四 Mybatis多表查询
4.1 数据库表关系介绍
4.2 一对一（多对一）
4.2.1 介绍
4.2.2 代码实现
4.3 一对多
4.3.1 介绍
4.3.2 代码实现
4.4 多对多
4.4.1 介绍
4.4.2 代码实现
4.5 小结
五 MyBatis嵌套查询
5.1 什么是嵌套查询
5.2 一对一嵌套查询
5.2.1 介绍
5.2.2 代码实现
5.3 一对多嵌套查询
5.3.1 介绍
5.3.2 代码实现
5.4 多对多嵌套查询
5.4.1 介绍
5.4.2 代码实现
5.5 小结
Mybatis 复杂映射&配置文件深入
一 Mybatis高级查询
1.1 ResutlMap属性
建立对象关系映射
1) 编写UserMapper接口
/*查询所有用户*/public List<User> findAllResultMap();
2) 编写UserMapper.xml
<!--查询所有用户--><!--resultMap：手动配置实体属性与表中字段的映射关系，完成手动封装--><select id="findAllResultMap" resultMap="userResultMap">select * from user</select><!--id : 标签的唯一标识type: 封装后实体类型--><resultMap id="userResultMap" type="com.lagou.domain.User"><!--手动配置映射关系--><!--id: 用来配置主键property 是实体类中的属性名column 是表中的字段名--><id property="id" column="id"></id><!-- result: 表中普通字段的封装--><result property="username" column="username"></result><result property="birthday" column="birthday"></result><result property="sex" column="sex"></result><result property="address" column="address"></result></resultMap>3）代码测试
@Testpublic void test2() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> allResultMap = mapper.findAllResultMap();for (User user : allResultMap) {System.out.println(user);}sqlSession.close();}
1.2 多条件查询（三种）
需求
根据id和username查询user表
1）方式一
使用 #{arg0} - #{argn} 或者 #{param1} - #{paramn} 获取参数
UserMapper接口
/*多条件查询方式一*/public List<User> findByIdAndUsername1(int id,String username);UserMapper.xml
<!--多条件查询：方式一--><select id="findByIdAndUsername1" resultMap="userResultMap" ><!-- 下面使用arg时从0开始, 使用param时从1开始 --><!-- select * from user where id = #{arg0} and username = #{arg1}-->select * from user where id = #{param1} and username = #{param2}</select>测试
/*多条件查询：方式一*/@Testpublic void test3() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> users = mapper.findByIdAndUsername1(1, "子慕");for (User user : users) {System.out.println(user);}sqlSession.close();}2）方式二(掌握)
使用注解，引入 @Param() 注解获取参数
UserMapper接口
/*多条件查询方式二*/public List<User> findByIdAndUsername2(@Param("id") int id, @Param("username") String username);UserMapper.xml
<!--多条件查询：方式二--><select id="findByIdAndUsername2" resultMap="userResultMap" >select * from user where id = #{id} and username = #{username}</select>测试
/*多条件查询：方式二*/@Testpublic void test4() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> users = mapper.findByIdAndUsername2(1, "子慕");for (User user : users) {System.out.println(user);}sqlSession.close();}3）方式三（推荐,掌握）
使用pojo对象传递参数
UserMapper接口
/*多条件查询方式三*/public List<User> findByIdAndUsername3(User user);UserMapper.xml
<!--多条件查询：方式三--><select id="findByIdAndUsername3" resultMap="userResultMap" parameterType="com.lagou.domain.User">select * from user where id = #{id} and username = #{usernameabc}</select>测试
/*多条件查询：方式三*/@Testpublic void test5() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);User user1 = new User();user1.setId(1);user1.setUsernameabc("子慕");List<User> users = mapper.findByIdAndUsername3(user1);for (User user : users) {System.out.println(user);}sqlSession.close();}1.3 模糊查询
需求
根据username模糊查询user表
1）方式一
UserMapper接口
/*模糊查询：方式一*/public List<User> findByUsername(String username);UserMapper.xml
<!--模糊查询：方式一--><select id="findByUsername" resultMap="userResultMap" parameterType="string"><!-- #{}在mybatis中是占位符，引用参数值的时候会自动添加单引号 如果只有单个值, 则{}中的内容可以随便写-->select * from user where username like #{username}</select>测试
/*模糊查询：方式一*/@Testpublic void test6() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> users = mapper.findByUsername("%子慕%");for (User user : users) {System.out.println(user);}sqlSession.commit();sqlSession.close();}2）方式二
UserMapper接口
/*模糊查询：方式二*/public List<User> findByUsername2(String username);UserMapper.xml
<!--模糊查询：方式二--><select id="findByUsername2" resultMap="userResultMap" parameterType="string"><!--parameterType是基本数据类型或者String的时候,${}里面的值只能写value这里不会自动加 单引号'' 所以 ↓${}: sql原样拼接-->select * from user where username like '${value}'</select>测试
/*模糊查询：方式二
*/@Testpublic void test7() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> users = mapper.findByUsername2("%子慕%");for (User user : users) {System.out.println(user);}sqlSession.close();}3）${ } 与 #{ } 区别【笔试题】
#{} :表示一个占位符号
- 通过 #{ } 可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。
- #{} 可以接收简单类型值或pojo属性值。
- 如果parameterType传输单个简单类型值， #{} 括号中名称随便写。
${} :表示拼接sql串
- 通过 ${} 可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换，会出现sql注入问题。
- ${} 可以接收简单类型值或pojo属性值。
- 如果parameterType传输单个简单类型值， ${} 括号中只能是value。
补充：TextSqlNode.java 源码可以证明
二 Mybatis映射文件深入
2.1 返回主键
应用场景
我们很多时候有这种需求，向数据库插入一条记录后，希望能立即拿到这条记录在数据库中的主键值。
2.1.1 useGeneratedKeys
/*添加用户：获取返回主键：方式一*/public void saveUser(User user); <!--添加用户：获取返回主键：方式一--><!--useGeneratedKeys: 声明返回主键keyProperty：把返回主键的值，封装到实体中对应属性上--><insert id="saveUser" parameterType="user" useGeneratedKeys="true" keyProperty="id">insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})</insert> /*添加用户：返回主键方式一*/@Testpublic void test8() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = new User();user.setUsername("某冰冰");user.setBirthday(new Date());user.setAddress("北京昌平");user.setSex("女");System.out.println(user);mapper.saveUser(user);System.out.println(user);sqlSession.commit();sqlSession.close();}注意：只适用于主键自增的数据库，mysql和sqlserver支持，oracle不行。
2.1.2 selectKey
/*添加用户：获取返回主键：方式二*/public void saveUser2(User user); <!--添加用户：获取返回主键：方式二--><insert id="saveUser2" parameterType="user" ><!--selectKey : 适用范围更广，支持所有类型的数据库order="AFTER" ： 设置在sql语句执行前（后），执行此语句, Oracle中用BRFOREkeyColumn="id" : 指定主键对应列名keyProperty="id"：把返回主键的值，封装到实体中的那个属性上resultType="int"：指定主键类型--><selectKey order="AFTER" keyColumn="id" keyProperty="id" resultType="int">SELECT LAST_INSERT_ID();</selectKey>insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})</insert> /*添加用户：返回主键方式二*/@Testpublic void test9() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = new User();user.setUsername("汤唯");user.setBirthday(new Date());user.setAddress("北京昌平");user.setSex("女");System.out.println(user);mapper.saveUser2(user);System.out.println(user);sqlSession.commit();sqlSession.close();}2.2 动态SQL
应用场景
当我们要根据不同的条件，来执行不同的sql语句的时候，需要用到动态sql。
2.2.1 动态 SQL 之 if (重点掌握)
需求
根据id和username查询，但是不确定两个都有值。
a）UserMapper接口
/*动态sql的if标签：多条件查询*/public List<User> findByIdAndUsernameIf(User user);b）UserMapper.xml映射
<!-- 动态sql之if : 多条件查询--><select id="findByIdAndUsernameIf" parameterType="user" resultType="com.lagou.domain.User">select * from user<!-- test里面写的就是表达式<where>: 相当于where 1= 1，但如果没有条件的话，不会拼接上where关键字--><where><if test="id != null">and id = #{id}</if><if test="username !=null">and username = #{username}</if></where></select>c）测试代码
/*动态sql之if： 多条件查询*/@Testpublic void test10() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = new User();user.setId(11);user.setUsername("汤唯");List<User> users = mapper.findByIdAndUsernameIf(user);for (User user1 : users) {System.out.println(user1);}sqlSession.close();}2.2.2 动态 SQL 之 set
需求
动态更新user表数据，如果该属性有值就更新，没有值不做处理。
a）UserMapper接口
/*动态sql的set标签：动态更新*/public void updateIf(User user);b）UserMapper.xml映射
<!--动态sql之set ： 动态更新--><update id="updateIf" parameterType="user">update user<!--<set>标签 : 在更新的时候，会自动添加set关键字，还会去掉最后一个条件的逗号 --><set><if test="username != null">username = #{username},</if><if test="birthday != null">birthday = #{birthday},</if><if test="sex != null">sex = #{sex},</if><if test="address != null">address = #{address},</if></set>where id = #{id}</update>c）测试代码
/*动态sql之set： 动态更新*/@Testpublic void test11() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = new User();user.setId(1);user.setUsername("子慕最帅");user.setAddress("北京海淀区拉勾网");mapper.updateIf(user);// 更新操作, 记得手动提交事务sqlSession.commit();sqlSession.close();}2.2.3 动态 SQL 之 foreach
foreach主要是用来做数据的循环遍历
例如： select * from user where id in (1,2,3) 在这样的语句中，传入的参数部分必须依靠foreach遍历才能实现。
a）集合
UserMapper接口
/*动态sql的foreach标签：多值查询:集合*/// 下面根据i多个id查询, 因此使用泛型规范一下public List<User> findByList(List<Integer> ids);UserMaper.xml映射
<!--动态sql的foreach标签：多值查询：根据多个id值查询用户传入的参数是List类型, 返回值是User类型--><select id="findByList" parameterType="list" resultType="user">select * from user<where><!--collection : 代表要遍历的集合，通常写collection或者listopen : 代表语句的开始部分close : 代表语句的结束部分item : 代表遍历结合中的每个元素，生成的变量名separator: 分隔符--><foreach collection="collection" open="id in (" close=")" item="id" separator=",">#{id}</foreach></where></select>测试代码
/*动态sql之foreach： 多值查询*/@Testpublic void test12() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);// 创建多个值存入集合中List<Integer> ids = new ArrayList<>();ids.add(1);ids.add(6);ids.add(2);List<User> users = mapper.findByList(ids);for (User user : users) {System.out.println(user);}sqlSession.close();}b）数组
UserMapper接口
/*动态sql的foreach标签：多值查询：数组*/public List<User> findByArray(Integer[] ids);UserMaper.xml映射
<!--动态sql的foreach标签：多值查询：根据多个id值查询用户--><select id="findByArray" parameterType="int" resultType="user"><include refid="selectUser"/><where><!--collection : 代表要遍历的集合元素，通常写collection或者list, 写成array是数组open : 代表语句的开始部分close : 代表语句的结束部分item : 代表遍历结合中的每个元素，生成的变量名separator: 分隔符--><foreach collection="array" open="id in (" close=")" item="id" separator=",">#{id}</foreach></where></select>测试代码
/*动态sql之foreach： 多值查询 ：数组
*/@Testpublic void test13() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);Integer[] ids = {2,6,9};List<User> byArray = mapper.findByArray(ids);for (User user : byArray) {System.out.println(user);}sqlSession.close();}2.3 SQL片段
应用场景
映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的
<sql id="selectUser">select * from user</sql> <!--动态sql的foreach标签：多值查询：根据多个id值查询用户--><select id="findByList" parameterType="list" resultType="user"><!-- 在下面使用include引入语句 --><include refid="selectUser"/><where>...</where></select> <!--动态sql的foreach标签：多值查询：根据多个id值查询用户--><select id="findByArray" parameterType="int" resultType="user"><!-- 下面使用include导入sql语句 --><include refid="selectUser"/><where>...</where></select>2.4 知识小结
MyBatis映射文件配置
三 Mybatis核心配置文件深入
3.1 plugins标签
MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据
开发步骤：
①导入通用PageHelper的坐标
②在mybatis核心配置文件中配置PageHelper插件
③测试分页数据获取
① 在pom中导入通用PageHelper坐标
<!-- 分页助手 --><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>3.7.5</version></dependency><dependency><groupId>com.github.jsqlparser</groupId><artifactId>jsqlparser</artifactId><version>0.9.1</version></dependency>②在mybatis核心配置文件sqlMapConfig中配置PageHelper插件
<!-- 要配置在environments标签的前面 --><plugins><plugin interceptor="com.github.pagehelper.PageHelper"><!--dialect: 指定方言 limit--><property name="dialect" value="mysql"/></plugin></plugins>③测试分页代码实现
/*核心配置文件深入：plugin标签：pageHelper*/@Testpublic void test15() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxyUserMapper mapper = sqlSession.getMapper(UserMapper.class);// 设置分页参数// 参数1： 当前页// 参数2： 每页显示的条数// 下面表示每页显示两条, 显示当前第1页PageHelper.startPage(1,2);// 上面的语句, 写在下面的语句前, 中间不要写别的语句List<User> users = mapper.findAllResultMap();for (User user : users) {System.out.println(user);}// 获取分页相关的其他参数// 下面传入的users 就是上面查询到的usersPageInfo<User> pageInfo = new PageInfo<User>(users);System.out.println("总条数"+ pageInfo.getTotal());System.out.println("总页数"+ pageInfo.getPages());System.out.println("是否是第一页"+ pageInfo.isIsFirstPage());sqlSession.close();}获得分页相关的其他参数
// 获取分页相关的其他参数
PageInfo<User> pageInfo = new PageInfo<User>(users);
System.out.println("总条数"+ pageInfo.getTotal());
System.out.println("总页数"+ pageInfo.getPages());
System.out.println("是否是第一页"+ pageInfo.isIsFirstPage());3.2 知识小结
MyBatis核心配置文件常用标签：
1、properties标签：该标签可以加载外部的properties文件
2、typeAliases标签：设置类型别名
3、environments标签：数据源环境配置标签
4、plugins标签：配置MyBatis的插件
四 Mybatis多表查询
4.1 数据库表关系介绍
关系型数据库表关系分为
举例
案例环境准备
DROP TABLE IF EXISTS `orders`;
CREATE TABLE `orders` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`ordertime` VARCHAR(255) DEFAULT NULL,
`total` DOUBLE DEFAULT NULL,
`uid` INT(11) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `uid` (`uid`),
CONSTRAINT `orders_ibfk_1` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
) ENGINE=INNODB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of orders
-- ----------------------------
INSERT INTO `orders` VALUES ('1', '2020-12-12', '3000', '1');
INSERT INTO `orders` VALUES ('2', '2020-12-12', '4000', '1');
INSERT INTO `orders` VALUES ('3', '2020-12-12', '5000', '2');
-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`rolename` VARCHAR(255) DEFAULT NULL,
`roleDesc` VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of sys_role
-- ----------------------------
INSERT INTO `sys_role` VALUES ('1', 'CTO', 'CTO');
INSERT INTO `sys_role` VALUES ('2', 'CEO', 'CEO');
-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
`userid` INT(11) NOT NULL,
`roleid` INT(11) NOT NULL,
PRIMARY KEY (`userid`,`roleid`),
KEY `roleid` (`roleid`),
CONSTRAINT `sys_user_role_ibfk_1` FOREIGN KEY (`userid`) REFERENCES `sys_role`
(`id`),
CONSTRAINT `sys_user_role_ibfk_2` FOREIGN KEY (`roleid`) REFERENCES `user`
(`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of sys_user_role
-- ----------------------------
INSERT INTO `sys_user_role` VALUES ('1', '1');
INSERT INTO `sys_user_role` VALUES ('2', '1');
INSERT INTO `sys_user_role` VALUES ('1', '2');
INSERT INTO `sys_user_role` VALUES ('2', '2');4.2 一对一（多对一）
4.2.1 介绍
一对一查询模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对一查询
需求：查询所有订单，与此同时查询出每个订单所属的用户
一对一查询语句, 使用左外连接
-- 左外连接, 不管左表中内容和右表有没有关联, 左表的内容都会全部显示
SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`;4.2.2 代码实现
1 ）Order实体
package com.lagou.domain;public class Orders {private Integer id;private String ordertime;private Double total;private Integer uid;// 表示当前订单属于哪个用户 associationprivate User user;@Overridepublic String toString() {return "Orders{" +"id=" + id +", ordertime='" + ordertime + '\'' +", total=" + total +", uid=" + uid +", user=" + user +'}';}// getter 和 setter省略
}
public class User {private Integer id;private String username;private Date birthday;private String sex;private String address;@Overridepublic String toString() {return "User{" +"id=" + id +", username='" + username + '\'' +", birthday=" + birthday +", sex='" + sex + '\'' +", address='" + address + '\'' +", ordersList=" + ordersList +", roleList=" + roleList +'}';}
}
2 ）OrderMapper接口
/*一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息*/// 返回值是多个, 并且要封装在Orders类中public List<Orders> findAllWithUser();3 ）OrderMapper.xml映射
<mapper namespace="com.lagou.mapper.OrderMapper"><!-- 一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息--><resultMap id="orderMap" type="com.lagou.domain.Orders"><id property="id" column="id"/><result property="ordertime" column="ordertime"/><result property="total" column="total"/><result property="uid" column="uid"/><!--association : 在进行一对一关联查询配置时，使用association标签进行关联property="user" ：要封装实体的属性名javaType="com.lagou.domain.User" 要封装的实体的属性类型-->
<!-- 下面的column中, 要写外键名, 和主键的id进行区分 --><association property="user" javaType="com.lagou.domain.User"><id property="id" column="uid"></id><result property="username" column="username"></result><result property="birthday" column="birthday"></result><result property="sex" column="sex"></result><result property="address" column="address"></result></association></resultMap>
<!-- 复杂的SQL语句, 可以先在数据库软件中编写好复制过来另外, 在多表查询时, 不能使用resultType的方式封装查询结果 --><select id="findAllWithUser" resultMap="orderMap">SELECT * FROM orders o LEFT JOIN USER u ON o.uid = u.id</select></mapper>4 ）测试代码
/*一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息*/@Testpublic void test1() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);List<Orders> orders = mapper.findAllWithUser();for (Orders order : orders) {System.out.println(order);}sqlSession.close();}4.3 一对多
4.3.1 介绍
一对多查询模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对多查询的
需求：查询所有用户，与此同时查询出该用户具有的订单
一对多查询语句
-- 右外连接, 不管右表和左表有没有关联, 右表信息都会全部显示
SELECT *,o.id oid FROM USER u LEFT JOIN orders o ON u.`id` = o.`uid`;4.3.2 代码实现
1 ）User实体
package com.lagou.domain;import java.io.Serializable;
import java.util.Date;
import java.util.List;public class User implements Serializable {private Integer id;private String username;private Date birthday;private String sex;private String address;// 表示多方关系:集合 : 代表了当前用户所具有的订单列表 collectionprivate List<Orders> ordersList;@Overridepublic String toString() {return "User{" +"id=" + id +", username='" + username + '\'' +", birthday=" + birthday +", sex='" + sex + '\'' +", address='" + address + '\'' +", ordersList=" + ordersList +", roleList=" + roleList +'}';}// getter setter 略
}
2 ）UserMapper接口
/*一对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的订单信息*/public List<User> findAllWithOrder();3 ）UserMapper.xml映射
<mapper namespace="com.lagou.mapper.UserMapper"><!--当前映射开启二级缓存--><cache></cache><!--一对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的订单信息--><!-- 因为查询结果中, uid有两个null值, 所以下面不能使用uid, 因此改造成oid, 下面就可以使用id了 --><resultMap id="userMap" type="com.lagou.domain.User"><id property="id" column="id"></id><result property="username" column="username"></result><result property="birthday" column="birthday"></result><result property="sex" column="sex"></result><result property="address" column="address"></result><!--collection : 一对多使用collection标签进行关联, 对方关系是对象, 用associationofType: 集合的泛型类型--><collection property="ordersList" ofType="com.lagou.domain.Orders"><id property="id" column="oid"></id><result property="ordertime" column="ordertime"/><result property="total" column="total"/><result property="uid" column="uid"/></collection></resultMap><!-- 因为查询结果中, uid有两个null值, 所以下面不能使用uid, 因此改造成oid --><select id="findAllWithOrder" resultMap="userMap">SELECT u.*,o.id oid,o.ordertime,o.total,o.uid FROM orders o RIGHT JOIN USER u ON o.uid = u.id</select>
</mapper>4 ）测试代码
/*一对多关联查询：查询所有用户及关联的订单信息*/@Testpublic void test2() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> allWithOrder = mapper.findAllWithOrder();for (User user : allWithOrder) {System.out.println(user);}sqlSession.close();}4.4 多对多
4.4.1 介绍
多对多查询的模型
用户表和角色表的关系为，一个用户有多个角色，一个角色被多个用户使用
多对多查询的
需求：查询所有用户同时查询出该用户的所有角色
多对多查询语句
SELECT
u.*, r.`id` rid, r.`roleDesc`, r.`rolename`
FROM
USER u -- 用户表
LEFT JOIN sys_user_role AS ur -- 左外连接中间表
ON u.`id` = ur.`userid`
LEFT JOIN sys_role r -- 左外连接中间表
ON ur.`roleid` = r.`id` ;
4.4.2 代码实现
1 ）User和Role 实体
package com.lagou.domain;import java.io.Serializable;public class Role implements Serializable {private Integer id;private String rolename;private String roleDesc;@Overridepublic String toString() {return "Role{" +"id=" + id +", rolename='" + rolename + '\'' +", roleDesc='" + roleDesc + '\'' +'}';}// getter setter 略
}
package com.lagou.domain;import java.io.Serializable;
import java.util.Date;
import java.util.List;public class User implements Serializable {private Integer id;private String username;private Date birthday;private String sex;private String address;// 表示多方关系:集合 : 代表了当前用户所具有的订单列表 collectionprivate List<Orders> ordersList;// 表示多方关系:集合 : 代表了当前用户所具有的角色列表 collectionprivate List<Role> roleList;@Overridepublic String toString() {return "User{" +"id=" + id +", username='" + username + '\'' +", birthday=" + birthday +", sex='" + sex + '\'' +", address='" + address + '\'' +", ordersList=" + ordersList +", roleList=" + roleList +'}';}// getter setter 省略
}
2 ）UserMapper接口
/*多对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的角色信息*/public List<User> findAllWithRole();3 ）UserMapper.xml映射
<!--多对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的角色信息--><resultMap id="userRoleMap" type="user"><id property="id" column="id"/><result property="username" column="username"></result><result property="birthday" column="birthday"></result><result property="sex" column="sex"></result><result property="address" column="address"></result><!-- ofType是这个集合的泛型类型 --><collection property="roleList" ofType="role"><id column="rid" property="id"></id><result column="rolename" property="rolename"></result><result column="roleDesc" property="roleDesc"></result></collection></resultMap><select id="findAllWithRole" resultMap="userRoleMap">SELECT u.*,r.id rid,r.rolename,r.roleDesc FROM USER u LEFT JOIN sys_user_role ur ON ur.userid = u.idLEFT JOIN sys_role r ON ur.roleid = r.id</select>4 ）测试代码
/*多对多关联查询：查询所有用户及关联的角色信息*/@Testpublic void test3() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> allWithRole = mapper.findAllWithRole();for (User user : allWithRole) {System.out.println(user);}sqlSession.close();}4.5 小结
MyBatis多表配置方式
五 MyBatis嵌套查询
5.1 什么是嵌套查询
嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用mybatis的语法嵌套在一起。
举个栗子
5.2 一对一嵌套查询
5.2.1 介绍
需求：查询一个订单，与此同时查询出该订单所属的用户
一对一查询语句
5.2.2 代码实现
1）OrderMapper接口
/*一对一嵌套查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息*/public List<Orders> findAllWithUser2();2）OrderMapper.xml映射
<resultMap id="orderMap2" type="com.lagou.domain.Orders"><id property="id" column="id"/><result property="ordertime" column="ordertime"/><result property="total" column="total"/><result property="uid" column="uid"/><!--问题：1.怎么去执行第二条sql , 2.如何执行第二条sql的时候，把uid作为参数进行传递下面的select用来调用第二条sqlcolumn 是要传递的参数, --><association property="user" javaType="com.lagou.domain.User"select="com.lagou.mapper.UserMapper.findById" column="uid"/></resultMap><!--一对一嵌套查询--><select id="findAllWithUser2" resultMap="orderMap2">SELECT * FROM orders</select>3）UserMapper接口
/*根据id查询用户*/public User findById(Integer id);4）UserMapper.xml映射
<!--根据id查询用户 --><select id="findById" resultType="com.lagou.domain.User" parameterType="int">SELECT * FROM user WHERE id = #{id}</select>5）测试代码
/*一对一嵌套查询：查询所有订单及关联的用户信息*/@Testpublic void test4() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);List<Orders> allWithUser2 = mapper.findAllWithUser2();for (Orders orders : allWithUser2) {System.out.println(orders);}sqlSession.close();}5.3 一对多嵌套查询
5.3.1 介绍
需求：查询所有用户，与此同时查询出该用户具有的订单
一对多查询语句
5.3.2 代码实现
a）UserMapper接口
/*一对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的订单信息*/public List<User> findAllWithOrder2();b）UserMapper.xml映射
<!--一对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的订单信息--><resultMap id="userOrderMap" type="com.lagou.domain.User"><id property="id" column="id"/><result property="username" column="username"></result><result property="birthday" column="birthday"></result><result property="sex" column="sex"></result><result property="address" column="address"></result><collection property="ordersList" ofType="com.lagou.domain.Orders" column="id"select="com.lagou.mapper.OrderMapper.findByUid" ></collection></resultMap><select id="findAllWithOrder2" resultMap="userOrderMap">SELECT * FROM USER</select>c）OrderMapper接口
/*根据uid查询对应订单*/public List<Orders> findByUid(Integer uid);d）OrderMapper.xml映射
<select id="findByUid" parameterType="int" resultType="com.lagou.domain.Orders">SELECT * FROM orders WHERE uid = #{uid}</select>e）测试代码
/*一对多嵌套查询：查询所有用户及关联的订单信息*/@Testpublic void test5() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> allWithOrder2 = mapper.findAllWithOrder2();for (User user : allWithOrder2) {System.out.println(user);// 要用到该用户的订单信息// System.out.println(user.getOrdersList());}sqlSession.close();}5.4 多对多嵌套查询
5.4.1 介绍
需求：查询用户 同时查询出该用户的所有角色
多对多查询语句
5.4.2 代码实现
a）UserMapper接口
/*多对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的角色信息*/public List<User> findAllWithRole2();b）UserMapper.xml映射
<resultMap id="userRoleMap2" type="com.lagou.domain.User"><id property="id" column="id"/><result property="username" column="username"></result><result property="birthday" column="birthday"></result><result property="sex" column="sex"></result><result property="address" column="address"></result><collection property="roleList" ofType="com.lagou.domain.Role" column="id" select="com.lagou.mapper.RoleMapper.findByUid"></collection></resultMap><!--多对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的角色信息--><select id="findAllWithRole2" resultMap="userRoleMap2">SELECT * FROM USER</select>c）RoleMapper接口
/*根据用户id查询对应角色*/public List<Role> findByUid(Integer uid);d）RoleMapper.xml映射
<mapper namespace="com.lagou.mapper.RoleMapper"><select id="findByUid" resultType="com.lagou.domain.Role" parameterType="int">SELECT * FROM sys_role r INNER JOIN sys_user_role ur ON ur.roleid = r.idWHERE ur.userid = #{uid}</select>
</mapper>e）测试代码
/*多对多嵌套查询：查询所有用户及关联的角色信息
*/@Testpublic void test6() throws IOException {InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);SqlSession sqlSession = sqlSessionFactory.openSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> allWithRole2 = mapper.findAllWithRole2();for (User user : allWithRole2) {System.out.println(user);}sqlSession.close();}5.5 小结
2.4.3 Mybatis 高级查询, 复杂映射, 返回主键, 动态SQL if, set, foreach, 核心配置文件深入,plugins标签, 多表查询, 嵌套查询相关推荐
- 使用mybatis插入数据(insert)时返回主键的问题
使用mybatis做插入操作时,想要获取新增记录的主键,我发现现在的方式和以前的方式有所区别,即以前是直接通过方法返回,现在是将主键设置在数据实体对象中. 下面对mybatis进行insert时返回主 ...
- MyBatis—insert语句返回主键和selectKey标签
本文已同步至个人博客liaosi's blog - MyBatis-insert语句返回主键和selectKey标签 往数据库中插入一条记录后,有时候我们需要这条记录的主键,用于后续的操作.如果在插入 ...
- MyBatis 插入数据库返回主键
最近在搞一个电商系统中由于业务需求,需要在插入一条产品信息后返回产品Id,刚开始遇到一些坑,这里做下笔记,以防今后忘记. 类似下面这段代码一样获取插入后的主键 User user = new User ...
- mybatis insert 返回主键_面试准备季——MyBatis 面试专题（含答案）
话不多说,直接上题-- 1.什么是 Mybatis? (1)Mybatis 是一个半 ORM(对象关系映射)框架,它内部封装了 JDBC,开发时只需要关注 SQL 语句本身,不需要花费精力去处理加载驱 ...
- mybatis添加记录时返回主键id
参考:mybatis添加记录时返回主键id 场景 有些时候我们在添加记录成功后希望能直接获取到该记录的主键id值,而不需要再执行一次查询操作. 在使用mybatis作为ORM组件时,可以很方便地达到这 ...
- MyBatis——insert并返回主键ID解决方案
问题描述 添加记录后获取主键ID,这是一个很常见的需求,特别是在一次前端调用中需要插入多个表的场景. 除了添加单条记录时获取主键值,有时候可能需要获取批量添加记录时各记录的主键值. 问题分析 暂无. ...
- MyBatis框架——mybatis插入数据返回主键（mysql、oracle）
向数据库中插入数据时,大多数情况都会使用自增列或者UUID做为主键.主键的值都是插入之前无法知道的,但很多情况下我们在插入数据后需要使用刚刚插入数据的主键,比如向两张关联表A.B中插入数据(A的主键是 ...
- MyBatis在Oracle中插入数据并返回主键的问题解决
前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家.点击跳转到教程. 前言:我早期用过这个方法,但是返回的依旧是影响行数,不是主键. 只是这种写法可以达到我要的效果: 用 ...
- bootstrap获取选中行的主键_深入分析Mybatis 使用useGeneratedKeys获取自增主键
摘要 我们经常使用useGenerateKeys来返回自增主键,避免多一次查询.也会经常使用on duplicate key update,来进行insertOrUpdate, 来避免先query 在 ...
最新文章
- Struts配置文件务必采用正确的DTD
- PPT怎么在剪映_剪映怎么剪辑音乐？添加、分割、导入音乐，图文详解！
- vue npm run serve/dev命令后台运行：nohup npm run serve ＞web.log 2＞1 exit
- boost::gil模块实现dynamic image的测试程序
- 「Python」ubuntu使用make命令安装python（带详细解释和防坑指南）
- 一次网站性能排查的经历
- pc-bsd安装教程_桌面用户的BSD：PC-BSD的回顾
- ApacheCN/iBooker 未来计划 2019.11
- mysql追溯历史性能问题_【踩坑記錄】記一次MySQL主從復制延遲的坑
- 14英寸电脑长宽多少_华为MateBook 14 2020款 14英寸轻薄笔记本王者升级
- Windows Server 2012 克隆修改SID
- paip.提高效率---微信 手机app快速开发平台—微网络撬动大市场
- ul阻燃标准有几个等级_最详细的UL阻燃等级介绍说明，快看过来
- ocr 神经网络,神经网络crop
- sqlserver中查询(升序、降序、top、百分比)
- html制作钢铁侠心脏,心脏术后我变成了“钢铁侠”
- numpy矩阵升维，拼接
- 图解电脑上Firefox浏览器无法打开的解决办法
- 002 反相器的动态特性
- 【管理篇 / 登录】❀ 03. USB线连接登录 ❀ FortiGate 防火墙