目录
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）代码测试
@Test
public void test2() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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>测试
/*
多条件查询：方式一
*/
@Test
public void test3() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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>测试
/*
多条件查询：方式二
*/
@Test
public void test4() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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>
测试
/*
多条件查询：方式三
*/
@Test
public void test5() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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>
测试
/*
模糊查询：方式一
*/
@Test
public void test6() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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>测试
/*
模糊查询：方式二
*/
@Test
public void test7() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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> /*
添加用户：返回主键方式一
*/
@Test
public void test8() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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中用BRFORE
keyColumn="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> /*
添加用户：返回主键方式二
*/
@Test
public void test9() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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： 多条件查询
*/
@Test
public void test10() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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： 动态更新
*/
@Test
public void test11() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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或者list
open : 代表语句的开始部分
close : 代表语句的结束部分
item : 代表遍历结合中的每个元素，生成的变量名
separator: 分隔符
-->
<foreach collection="collection" open="id in (" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
</select>测试代码
/*
动态sql之foreach： 多值查询
*/
@Test
public void test12() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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： 多值查询 ：数组
*/
@Test
public void test13() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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
*/
@Test
public void test15() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 当前返回的 其实是基于UserMapper所产生的代理对象：底层：JDK动态代理 实际类型：proxy
UserMapper 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 就是上面查询到的users
PageInfo<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;
// 表示当前订单属于哪个用户 association
private User user;
@Override
public 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;
@Override
public 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 ）测试代码
/*
一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息
*/
@Test
public 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;
// 表示多方关系:集合 : 代表了当前用户所具有的订单列表 collection
private List<Orders> ordersList;
@Override
public 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标签进行关联, 对方关系是对象, 用association
ofType: 集合的泛型类型
-->
<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 ）测试代码
/*
一对多关联查询：查询所有用户及关联的订单信息
*/
@Test
public 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;
@Override
public 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;
// 表示多方关系:集合 : 代表了当前用户所具有的订单列表 collection
private List<Orders> ordersList;
// 表示多方关系:集合 : 代表了当前用户所具有的角色列表 collection
private List<Role> roleList;
@Override
public 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.id
LEFT JOIN sys_role r ON ur.roleid = r.id
</select>4 ）测试代码
/*
多对多关联查询：查询所有用户及关联的角色信息
*/
@Test
public 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用来调用第二条sql
column 是要传递的参数, -->
<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）测试代码
/*
一对一嵌套查询：查询所有订单及关联的用户信息
*/
@Test
public 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）测试代码
/*
一对多嵌套查询：查询所有用户及关联的订单信息
*/
@Test
public 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.id
WHERE ur.userid = #{uid}
</select>
</mapper>e）测试代码
/*
多对多嵌套查询：查询所有用户及关联的角色信息
*/
@Test
public 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 小结
