目录
Mybatis 任务一：基本应用
一 框架简介
1.1 三层架构
软件开发常用的架构是三层架构，之所以流行是因为有着清晰的任务划分。一般包括以下三层：
- 持久层：主要完成与数据库相关的操作，即对数据库的增删改查。
- 因为数据库访问的对象一般称为Data Access Object（简称DAO），所以有人把持久层叫做DAO层。
- 业务层：主要根据功能需求完成业务逻辑的定义和实现。
- 因为它主要是为上层提供服务的，所以有人把业务层叫做Service层或Business层。
- 表现层：主要完成与最终软件使用用户的交互，需要有交互界面（UI）。
因此，有人把表现层称之为web层或View层。
三层架构之间调用关系为:表现层调用业务层，业务层调用持久层。
各层之间必然要进行数据交互，我们一般使用java实体对象来传递数据。
1.2 框架
1.2.1 什么是框架？
框架就是一套规范，既然是规范，你使用这个框架就要遵守这个框架所规定的约束。
框架可以理解为半成品软件，框架做好以后，接下来在它基础上进行开发。
1.2.2 为什么使用框架？
框架为我们封装好了一些冗余，且重用率低的代码。并且使用反射与动态代理机制，将代码实现了通用性，让 开发人员把精力专注在核心的业务代码实现上。
比如在使用servlet进行开发时，需要在servlet获取表单的参数，每次都要获取很麻烦，而框架底层就使用反射机制和拦截器机制帮助我们获取表单的值，使用jdbc每次做专一些简单的crud的时候都必须写sql，但使用框架就不需要这么麻烦了，直接调用方法就可以。当然，既然是使用框架，那么还是要遵循其一些规范进行配置
1.2.3 常见的框架
Java世界中的框架非常的多，每一个框架都是为了解决某一部分或某些问题而存在的。下面列出在目前企业中流行的几种框架（一定要注意他们是用来解决哪一层问题的）：
- 持久层框架：专注于解决数据持久化的框架。常用的有mybatis、hibernate、spring jdbc等等。
- 表现层框架：专注于解决与用户交互的框架。常见的有struts2、spring mvc等等。
- 全栈框架: 能在各层都给出解决方案的框架。比较著名的就是spring。
这么多框架，我们怎么选择呢?
我们以企业中最常用的组合为准来学习Spring + Spring MVC + mybatis（SSM）
二 Mybatis简介
2.1 原始jdbc操作（查询数据）
2.2 原始jdbc操作的分析
原始jdbc开发存在的问题如下：
① 数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能
② sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变java代码。
③ 查询操作时，需要手动将结果集中的数据手动封装到实体中。
应对上述问题给出的解决方案：
① 使用数据库连接池初始化连接资源
② 将sql语句抽取到xml配置文件中
③ 使用反射、内省等底层技术，自动将实体与表进行属性与字段的自动映射
2.3 Mybatis简介
MyBatis是一个优秀的基于ORM的半自动轻量级持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码
mybatis 历史
MyBatis 本是apache的一个开源项目iBatis, 2010年6月这个项目由apache software foundation 迁移到了google code，随着开发团队转投到Google Code旗下，iBatis正式改名为MyBatis ，代码于2013年11月迁移到Github
Github地址：https://github.com/mybatis/mybatis-3/
1.4 ORM思想
ORM（Object Relational Mapping）对象关系映射
O（对象模型）：
- 实体对象，即我们在程序中根据数据库表结构建立的一个个实体javaBean
R（关系型数据库的数据结构）：
- 关系数据库领域的Relational（建立的数据库表）
M（映射）：
- 从R（数据库）到O（对象模型）的映射，可通过XML文件映射
实现：
（1）让实体类和数据库表进行一一对应关系
- 先让实体类和数据库表对应
- 再让实体类属性和表里面字段对应
（2）不需要直接操作数据库表，直接操作表对应的实体类对象
ORM作为是一种思想
帮助我们跟踪实体的变化,并将实体的变化翻译成sql脚本,执行到数据库中去,也就是将实体的变化映射到了表的变化。
mybatis采用ORM思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与jdbc api 打交道，就可以完成对数据库的持久化操作
三 Mybatis快速入门
3.1 MyBatis开发步骤
MyBatis官网地址：http://www.mybatis.org/mybatis-3/
案例需求：通过mybatis查询数据库user表的所有记录，封装到User对象中，打印到控制台上
步骤分析：
- 1. 创建数据库及user表
- 2. 创建maven工程，导入依赖（MySQL驱动、mybatis、junit）
- 3. 编写User实体类
- 4. 编写UserMapper.xml映射配置文件（ORM思想）
- 5. 编写SqlMapConfig.xml核心配置文件
- 数据库环境配置
- 映射关系配置的引入(引入映射配置文件的路径)
- 6. 编写测试代码
- // 1.加载核心配置文件
- // 2.获取sqlSessionFactory工厂对象
- // 3.获取sqlSession会话对象
- // 4.执行sql
- // 5.打印结果
- // 6.释放资源
3.2 代码实现
- 1) 创建user数据表
CREATE DATABASE `mybatis_db`;
USE `mybatis_db`;
CREATE TABLE `user` (
`id` int(11) NOT NULL auto_increment,
`username` varchar(32) NOT NULL COMMENT '用户名称',
`birthday` datetime default NULL COMMENT '生日',
`sex` char(1) default NULL COMMENT '性别',
`address` varchar(256) default NULL COMMENT '地址',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- insert....
insert into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,'子
慕','2020-11-11 00:00:00','男','北京海淀'),(2,'应颠','2020-12-12 00:00:00','男','北
京海淀');- 2) 导入MyBatis的坐标和其他相关坐标pom.xml
<!--指定编码和版本-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>1.11</java.version>
<maven.compiler.source>1.11</maven.compiler.source>
<maven.compiler.target>1.11</maven.compiler.target>
</properties>
<!--mybatis坐标-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.4</version>
</dependency>
<!--mysql驱动坐标-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
<scope>runtime</scope>
</dependency>
<!--单元测试坐标-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>- 3) 编写User实体
public class User {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
// getter/setter 略
}- 4) 编写UserMapper映射文件(UserMapper.xml)
<?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="userMapper">
<!--namespace : 命名空间：与id属性共同构成唯一标识 namespace.id: user.findAll
resultType: 返回结果类型（自动映射封装）：要封装的实体的全路径
-->
<!-- 查询所有 -->
<select id="findAll" resultType="uSeR">
select * from user
</select>
<!--新增用户-->
<!--#{} : mybatis中的占位符，等同于JDBC中的
parameterType ：指定接收到的参数类型 -->
<insert id="saveUser" parameterType="user">
insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>
<!--更新用户-->
<update id="updateUser" parameterType="user">
update user set username = #{username},birthday = #{birthday},sex = #{sex},address = #{address} where id = #{id}
</update>
<!--删除用户 java.lang.Integer-->
<delete id="deleteUser" parameterType="int">
delete from user where id = #{abc}
</delete>
</mapper>- 5) 编写MyBatis核心文件(sqlMapConfig.xml)
- 编写 jdbc.properties文件
-
jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql:///mybatis_db jdbc.username=root jdbc.password=123
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--加载properties文件-->
<properties resource="jdbc.properties"></properties>
<!--设置别名-->
<typeAliases>
<!--方式一：给单个实体起别名-->
<!-- <typeAlias type="com.lagou.domain.User" alias="user"></typeAlias>-->
<!--方式二：批量起别名 别名就是类名，且不区分大小写-->
<package name="com.lagou.domain"/>
</typeAliases>
<!--environments: 运行环境-->
<environments default="development">
<environment id="development">
<!--当前的事务事务管理器是JDBC-->
<transactionManager type="JDBC"></transactionManager>
<!--数据源信息 POOLED：使用mybatis的连接池-->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<!--引入映射配置文件-->
<mappers>
<mapper resource="mapper/UserMapper.xml"></mapper>
</mappers>
</configuration>- 6) 编写测试类
import com.lagou.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
public class MybatisTest {
/*
快速入门测试方法
*/
@Test
public void mybatisQuickStart() throws IOException {
//1.加载核心配置文件
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
//2. 获取sqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
//3. 获取sqlSession会话对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//4. 执行sql 参数：statementid : namespace.id
List<User> users = sqlSession.selectList("userMapper.findAll");
//5. 遍历打印结果
for (User user : users) {
System.out.println(user);
}
//6. 关闭资源
sqlSession.close();
}
/*
测试新增用户
*/
@Test
public void testSave() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
User user = new User();
user.setUsername("自动提交事务");
user.setBirthday(new Date());
user.setSex("男");
user.setAddress("北京海淀");
sqlSession.insert("userMapper.saveUser",user);
// 手动提交事务
// sqlSession.commit();
sqlSession.close();
}
/*
测试更新用户
*/
@Test
public void testUpdate() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = new User();
user.setId(4);
user.setUsername("lucy");
user.setBirthday(new Date());
user.setSex("女");
user.setAddress("北京朝阳");
sqlSession.update("userMapper.updateUser",user);
// 手动提交事务
sqlSession.commit();
sqlSession.close();
}
/*
测试删除用户
*/
@Test
public void testDelete() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
sqlSession.delete("userMapper.deleteUser",4);
// 手动提交事务
sqlSession.commit();
sqlSession.close();
}
}
3.3 知识小结
- 1. 创建mybatis_db数据库和user表
- 2. 创建项目，导入依赖
- 3. 创建User实体类
- 4. 编写映射文件UserMapper.xml
- 5. 编写核心文件SqlMapConfig.xml
- 6. 编写测试类
四 Mybatis映射文件概述
五 Mybatis增删改查
5.1 新增
- 1）编写映射文件UserMapper.xml
<!--新增-->
<insert id="save" parameterType="com.lagou.domain.User">
insert into user(username,birthday,sex,address)
values(#{username},#{birthday},#{sex},#{address})
</insert>- 2）编写测试类
@Test
public void testSave() throws Exception {
// 加载核心配置文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
// 获取SqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new
SqlSessionFactoryBuilder().build(is);
// 获取SqlSession会话对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 执行sql
User user = new User();
user.setUsername("jack");
user.setBirthday(new Date());
user.setSex("男");
user.setAddress("北京海淀");
sqlSession.insert("UserMapper.save", user);
// DML语句，手动提交事务
sqlSession.commit();
// 释放资源
sqlSession.close();
}
- 3）新增注意事项
- - 插入语句使用insert标签
- - 在映射文件中使用parameterType属性指定要插入的数据类型
- - Sql语句中使用#{实体属性名}方式引用实体中的属性值
- - 插入操作使用的API是sqlSession.insert(“命名空间.id”,实体对象);
- - 插入操作涉及数据库数据变化，所以要使用sqlSession对象显示的提交事务，即sqlSession.commit()
5.2 修改
- 1）编写映射文件UserMapper.xml
<!--修改-->
<update id="update" parameterType="com.lagou.domain.User">
update user set username = #{username},birthday = #{birthday},
sex = #{sex},address = #{address} where id = #{id}
</update>
- 2）编写测试类
/*
测试更新用户
*/
@Test
public void testUpdate() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = new User();
user.setId(4);
user.setUsername("lucy");
user.setBirthday(new Date());
user.setSex("女");
user.setAddress("北京朝阳");
sqlSession.update("userMapper.updateUser",user);
// 手动提交事务
sqlSession.commit();
sqlSession.close();
}
- 3）修改注意事项
- - 修改语句使用update标签
- - 修改操作使用的API是sqlSession.update(“命名空间.id”,实体对象);
5.3 删除
- 1）编写映射文件UserMapper.xml
<!--删除-->
<delete id="delete" parameterType="java.lang.Integer">
delete from user where id = #{id}
</delete>
- 2）编写测试类
/*
测试删除用户
*/
@Test
public void testDelete() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
sqlSession.delete("userMapper.deleteUser",4);
// 手动提交事务
sqlSession.commit();
sqlSession.close();
}- 3）删除注意事项
- - 删除语句使用delete标签
- - Sql语句中使用#{任意字符串}方式引用传递的单个参数
- - 删除操作使用的API是sqlSession.delete(“命名空间.id”,Object);
5.4 知识小结
* 查询
代码：
List<User> list = sqlSession.selectList("UserMapper.findAll");
映射文件：
<select id="findAll" resultType="com.lagou.domain.User">
select * from user
</select>
* 新增
代码：
sqlSession.insert("UserMapper.save", user);
映射文件：
<insert id="save" parameterType="com.lagou.domain.User">
insert into user(username,birthday,sex,address)
values(#{username},#{birthday},#{sex},#{address})
</insert>
* 修改
代码：
sqlSession.update("UserMapper.update", user);
映射文件：
<update id="update" parameterType="com.lagou.domain.User">
update user set username = #{username},birthday = #{birthday},
sex = #{sex},address = #{address} where id = #{id}
</update>
* 删除
代码：
sqlSession.delete("UserMapper.delete", 4);
映射文件：
<delete id="delete" parameterType="java.lang.Integer">
delete from user where id = #{id}
</delete>
六 Mybatis核心文件概述
6.1 MyBatis核心配置文件层级关系
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
配置文档的顶层结构如下：
6.2 MyBatis常用配置解析
1) environments标签
数据库环境的配置，支持多环境配置
1. 其中，事务管理器（transactionManager）类型有两种：
- - JDBC：
- 这个配置就是直接使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
- - MANAGED：
- 这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期。
- 例如：mybatis与spring整合后，事务交给spring容器管理。
2. 其中，数据源（dataSource）常用类型有三种：
- - UNPOOLED：
- 这个数据源的实现只是每次被请求时打开和关闭连接。
- - POOLED：
- 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。
- - JNDI :
- 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用
2）properties标签
实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载额外配置的properties：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///mybatis_db
jdbc.username=root
jdbc.password=root
3）typeAliases标签
类型别名是为 Java 类型设置一个短的名字。
为了简化映射文件 Java 类型设置，mybatis框架为我们设置好的一些常用的类型的别名：
原来的类型名称配置如下：
配置typeAliases，为com.lagou.domain.User定义别名为user：
4）mappers标签
该标签的作用是加载映射的，加载方式有如下几种
- 1. 使用相对于类路径的资源引用，例如：
- <mapper resource="org/mybatis/builder/userMapper.xml"/>
- 2. 使用完全限定资源定位符（URL），例如：
- <mapper url="file:///var/mappers/userMapper.xml"/>
- 《下面两种mapper代理开发中使用:暂时了解》
- 3. 使用映射器接口实现类的完全限定类名，例如：
- <mapper class="org.mybatis.builder.userMapper"/>
- 4. 将包内的映射器接口实现全部注册为映射器，例如：
- <package name="org.mybatis.builder"/>
6.3 知识小结
核心配置文件常用配置：
properties标签：该标签可以加载外部的properties文件
<properties resource="jdbc.properties"></properties>
typeAliases标签：设置类型别名
<typeAlias type="com.lagou.domain.User" alias="user"></typeAlias>
mappers标签：加载映射配置
<mapper resource="com/lagou/mapper/UserMapping.xml"></mapper>
environments标签：数据源环境配置
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
七 Mybatis的API概述
7.1 API介绍
7.1.1 SqlSession工厂构建器SqlSessionFactoryBuilder
常用API：SqlSessionFactory build(InputStream inputStream)
通过加载mybatis的核心文件的输入流的形式构建一个SqlSessionFactory对象
String resource = "org/mybatis/builder/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(inputStream);其中， Resources 工具类，这个类在 org.apache.ibatis.io 包中。Resources 类帮助你从类路径下、文件系统或一个 web URL 中加载资源文件。
7.1.2 SqlSession工厂对象SqlSessionFactory
SqlSessionFactory 有多个个方法创建SqlSession 实例。常用的有如下两个：
7.1.3 SqlSession会话对象
SqlSession 实例在 MyBatis 中是非常强大的一个类。在这里你会看到所有执行语句、提交或回滚事务
和获取映射器实例的方法。
执行语句的方法主要有：
<T> T selectOne(String statement, Object parameter)
<E> List<E> selectList(String statement, Object parameter)
int insert(String statement, Object parameter)
int update(String statement, Object parameter)
int delete(String statement, Object parameter)
操作事务的方法主要有：
void commit()
void rollback()
7.2 Mybatis基本原理介绍
八 Mybatis的dao层开发使用
8.1 传统开发方式
1）编写UserMapper接口
import com.lagou.domain.User;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface UserMapper {
/*
根据id查询用户
*/
public User findUserById(int id);
/*
查询所有用户
*/
public List<User> findAllResultMap();
/*
多条件查询方式一
*/
public List<User> findByIdAndUsername1(int id,String username);
/*
多条件查询方式二
*/
public List<User> findByIdAndUsername2(@Param("id") int id, @Param("username") String username);
/*
多条件查询方式三
*/
public List<User> findByIdAndUsername3(User user);
/*
模糊查询：方式一
*/
public List<User> findByUsername(String username);
/*
模糊查询：方式二
*/
public List<User> findByUsername2(String username);
/*
添加用户：获取返回主键：方式一
*/
public void saveUser(User user);
/*
添加用户：获取返回主键：方式二
*/
public void saveUser2(User user);
/*
动态sql的if标签：多条件查询
*/
public List<User> findByIdAndUsernameIf(User user);
/*
动态sql的set标签：动态更新
*/
public void updateIf(User user);
/*
动态sql的foreach标签：多值查询:集合
*/
public List<User> findByList(List<Integer> ids);
/*
动态sql的foreach标签：多值查询：数组
*/
public List<User> findByArray(Integer[] ids);
}
2）编写UserMapper实现
public class UserMapperImpl implements UserMapper {
@Override
public List<User> findAll() throws Exception {
// 加载配置文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
// 获取SqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new
SqlSessionFactoryBuilder().build(is);
// 获取SqlSe会话对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 执行sql
List<User> list = sqlSession.selectList("UserMapper.findAll");
// 释放资源
sqlSession.close();
return list;
}
}3）编写UserMapper.xml
<?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="UserMapper">
<!--查询所有-->
<select id="findAll" resultType="user">
select * from user
</select>
</mapper>
4）测试
@Test
public void testFindAll() throws Exception {
// 创建UserMapper 实现类
UserMapper userMapper = new UserMapperImpl();
// 执行查询
List<User> list = userMapper.findAll();
for (User user : list) {
System.out.println(user);
}
}
5）知识小结
传统开发方式
- 1. 编写UserMapper接口
- 3. 编写UserMapper.xml
传统方式问题思考：
- 1.实现类中，存在mybatis模板代码重复
- 2.实现类调用方法时，xml中的sql statement 硬编码到java代码中
思考：能否只写接口，不写实现类。只编写接口和Mapper.xml即可？
因为在dao（mapper）的实现类中对sqlsession的使用方式很类似。因此mybatis提供了接口的动态代理
8.2 代理开发方式
1）介绍
采用 Mybatis 的基于接口代理方式实现 持久层 的开发，这种方式是我们后面进入企业的主流。基于接口代理方式的开发只需要程序员编写 Mapper 接口，Mybatis 框架会为我们动态生成实现类的对象。
这种开发方式要求我们遵循一定的规范：
- Mapper.xml映射文件中的namespace与mapper接口的全限定名相同
- Mapper接口方法名和Mapper.xml映射文件中定义的每个statement的id相同
- Mapper接口方法的输入参数类型和mapper.xml映射文件中定义的每个sql的parameterType的类型相同
- Mapper接口方法的输出参数类型和mapper.xml映射文件中定义的每个sql的resultType的类型相同
- Mapper 接口开发方法只需要程序员编写Mapper 接口（相当于Dao 接口），由Mybatis 框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。
2）编写UserMapper接口
public interface UserMapper {
public List<User> findAll() throws Exception;
}
3）编写UserMapper.xml
<?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.lagou.mapper.UserMapper">
<!--查询所有-->
<select id="findAll" resultType="user">
select * from user
</select>
</mapper>4）测试
@Test
public void testFindAll() throws Exception {
// 加载核心配置文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
// 获得SqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
// 获得SqlSession会话对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 获得Mapper代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 执行查询
List<User> list = userMapper.findAll();
for (User user : list) {
System.out.println(user);
}
// 释放资源
sqlSession.close();
}
5）Mybatis基于接口代理方式的内部执行原理
我们的持久层现在只有一个接口，而接口是不实际干活的，那么是谁在做查询的实际工作呢？
下面通过追踪源码看一下：
1、通过追踪源码我们会发现，我们使用的mapper实际上是一个代理对象,是由MapperProxy代理产生
的。
2、追踪MapperProxy的invoke方法会发现，其最终调用了mapperMethod.execute(sqlSession, args)\
3、进入execute方法会发现，最终工作的还是sqlSession
Mybatis 任务二：复杂映射&配置文件深入
一 Mybatis高级查询
1.1 ResutlMap属性
建立对象关系映射
* resultType
- 如果实体的属性名与表中字段名一致，将查询结果自动封装到实体类中
* ResutlMap
- 如果实体的属性名与表中字段名不一致，可以使用ResutlMap实现手动封装到实体类中
1) 编写UserMapper接口
public interface UserMapper {
public List<User> findAllResultMap();
}
2) 编写UserMapper.xml
<!--
实现手动映射封装
resultMap
id="userResultMap" 此标签唯一标识
type="user" 封装后的实体类型
<id column="uid" property="id"></id> 表中主键字段封装
column="uid" 表中的字段名
property="id" user实体的属性名
<result column="NAME" property="username"></result> 表中普通字段封装
column="NAME" 表中的字段名
property="username" user实体的属性名
补充：如果有查询结果有 字段与属性是对应的，可以省略手动封装 【了解】
-->
<resultMap id="userResultMap" type="user">
<id column="uid" property="id"></id>
<result column="NAME" property="username"></result>
<result column="PASSWORD" property="username"></result>
</resultMap>
<select id="findAllResultMap" resultMap="userResultMap">
SELECT id AS uid,username AS NAME,password AS PASSWORD FROM USER
</select>3）代码测试
@Test
public void testFindAllResultMap() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findAllResultMap();
for (User user : list) {
System.out.println(user); }
}
1.2 多条件查询（三种）
需求
根据id和username查询user表
1）方式一
使用 #{arg0}-#{argn} 或者 #{param1}-#{paramn} 获取参数
UserMapper接口
public interface UserMapper {
public List<User> findByIdAndUsername1(Integer id, String username);
}
UserMapper.xml
<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByIdAndUsername1" resultType="user">
<!-- select * from user where id = #{arg0} and username = #{arg1} -->
select * from user where id = #{param1} and username = #{param2}
</select>
</mapper>
测试
@Test
public void testFindByIdAndUsername() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findByIdAndUsername1(1 , "子慕");
System.out.println(list);
}
2）方式二
使用注解，引入@Param() 注解获取参数
UserMapper接口
public interface UserMapper {
public List<User> findByIdAndUsername2(@Param("id") Integer id,@Param("username") String username);
}
UserMapper.xml
<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByIdAndUsername2" resultType="user">
select * from user where id = #{id} and username = #{username}
</select>
</mapper>
测试
@Test
public void testFindByIdAndUsername() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findByIdAndUsername2(1, "子慕");
System.out.println(list);
}
3）方式三（推荐）
使用pojo对象传递参数
UserMapper接口
public interface UserMapper {
public List<User> findByIdAndUsername3(User user);
}
UserMapper.xml
<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByIdAndUsername3" parameterType="com.lagou.domain.User" resultType="com.lagou.domain.User">
select * from user where id = #{id} and username = #{username}
</select>
</mapper>
测试
@Test
public void testFindByIdAndUsername() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User param = new User();
param.setId(1);
param.setUsername("子慕");
List<User> list = userMapper.findByIdAndUsername3(param);
System.out.println(list);
}
1.3 模糊查询
需求
根据username模糊查询user表
1）方式一
UserMapper接口
public interface UserMapper {
public List<User> findByUsername1(String username);
}UserMapper.xml
<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByUsername1" parameterType="string" resultType="user">
select * from user where username like #{username}
</select>
</mapper>
测试
@Test
public void testFindByUsername() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findByUsername1("%王%");
for (User user : list) {
System.out.println(user);
}
}
2）方式二
UserMapper接口
public interface UserMapper {
public List<User> findByUsername2(String username);
}
UserMapper.xml
<mapper namespace="com.lagou.mapper.UserMapper">
<!--不推荐使用，因为会出现sql注入问题-->
<select id="findByUsername2" parameterType="string" resultType="user">
select * from user where username like '${value}'
</select>
</mapper>
测试
@Test
public void testFindByUsername() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findByUsername2("%王%");
for (User user : list) {
System.out.println(user);
}
}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 interface UserMapper {
// 返回主键
public void save(User user);
}<!--
useGeneratedKeys="true" 声明返回主键
keyProperty="id" 把返回主键的值，封装到实体的id属性中
注意：只适用于主键自增的数据库，mysql和sqlserver支持，oracle不支持
-->
<insert id="save" parameterType="user" useGeneratedKeys="true" keyProperty="id">
INSERT INTO `user`(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>注意：只适用于主键自增的数据库，mysql和sqlserver支持，oracle不行。
2.1.2 selectKey
public interface UserMapper {
// 返回主键
public void save(User user);
}<!--
selectKey 适用范围广，支持所有类型数据库
keyColumn="id" 指定主键列名
keyProperty="id" 指定主键封装到实体的id属性中
resultType="int" 指定主键类型
order="AFTER" 设置在sql语句执行前（后），执行此语句
-->
<insert id="save" parameterType="user">
<selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">
SELECT LAST_INSERT_ID();
</selectKey>
INSERT INTO `user`(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>
11.3 测试代码
@Test
public void testSave() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = new User();
user.setUsername("子慕");
user.setAddress("北京");
user.setBirthday(new Date());
user.setSex("男");
userMapper.save(user);
System.out.println("返回主键:" + user.getId());
}2.2 动态SQL
应用场景
当我们要根据不同的条件，来执行不同的sql语句的时候，需要用到动态sql。
2.2.1 动态 SQL 之<if>
需求
根据id和username查询，但是不确定两个都有值。
a）UserMapper接口
import com.lagou.domain.User;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface UserMapper {
/*
根据id查询用户
*/
public User findUserById(int id);
/*
查询所有用户
*/
public List<User> findAllResultMap();
/*
多条件查询方式一
*/
public List<User> findByIdAndUsername1(int id,String username);
/*
多条件查询方式二
*/
public List<User> findByIdAndUsername2(@Param("id") int id, @Param("username") String username);
/*
多条件查询方式三
*/
public List<User> findByIdAndUsername3(User user);
/*
模糊查询：方式一
*/
public List<User> findByUsername(String username);
/*
模糊查询：方式二
*/
public List<User> findByUsername2(String username);
/*
添加用户：获取返回主键：方式一
*/
public void saveUser(User user);
/*
添加用户：获取返回主键：方式二
*/
public void saveUser2(User user);
/*
动态sql的if标签：多条件查询
*/
public List<User> findByIdAndUsernameIf(User user);
/*
动态sql的set标签：动态更新
*/
public void updateIf(User user);
/*
动态sql的foreach标签：多值查询:集合
*/
public List<User> findByList(List<Integer> ids);
/*
动态sql的foreach标签：多值查询：数组
*/
public List<User> findByArray(Integer[] ids);
}
b）UserMapper.xml映射
<?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.lagou.mapper.UserMapper">
<!--根据id查询用户-->
<select id="findUserById" parameterType="int" resultMap="userResultMap">
select * from user where id = #{id}
</select>
<!--id : 标签的唯一标识
type: 封装后实体类型-->
<resultMap id="userResultMap" type="com.lagou.domain.User">
<!--手动配置映射关系-->
<!--id: 用来配置主键-->
<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>
<!--查询所有用户-->
<!--resultMap：手动配置实体属性与表中字段的映射关系，完成手动封装-->
<select id="findAllResultMap" resultMap="userResultMap">
select * from user
</select>
<!--多条件查询：方式一-->
<select id="findByIdAndUsername1" resultMap="userResultMap" >
<!-- select * from user where id = #{arg0} and username = #{arg1}-->
select * from user where id = #{param1} and username = #{param2}
</select>
<!--多条件查询：方式二-->
<select id="findByIdAndUsername2" resultMap="userResultMap" >
select * from user where id = #{id} and username = #{username}
</select>
<!--多条件查询：方式三-->
<select id="findByIdAndUsername3" resultMap="userResultMap" parameterType="com.lagou.domain.User">
select * from user where id = #{id} and username = #{usernameabc}
</select>
<!--模糊查询：方式一-->
<select id="findByUsername" resultMap="userResultMap" parameterType="string">
<!-- #{}在mybatis中是占位符，引用参数值的时候会自动添加单引号 -->
select * from user where username like #{username}
</select>
<!--模糊查询：方式二-->
<select id="findByUsername2" resultMap="userResultMap" parameterType="string">
<!--parameterType是基本数据类型或者String的时候,${}里面的值只能写value
${}: sql原样拼接
-->
select * from user where username like '${value}'
</select>
<!--添加用户：获取返回主键：方式一-->
<!--
useGeneratedKeys: 声明返回主键
keyProperty：把返回主键的值，封装到实体中的那个属性上
-->
<insert id="saveUser" parameterType="user" useGeneratedKeys="true" keyProperty="id">
insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>
<!--添加用户：获取返回主键：方式二-->
<insert id="saveUser2" parameterType="user" >
<!--
selectKey : 适用范围更广，支持所有类型的数据库
order="AFTER" ： 设置在sql语句执行前（后），执行此语句
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>
<!-- 动态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>
<!--动态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>
<sql id="selectUser">
select * from user
</sql>
<!--动态sql的foreach标签：多值查询：根据多个id值查询用户-->
<select id="findByList" parameterType="list" resultType="user">
<include refid="selectUser"/>
<where>
<!--
collection : 代表要遍历的集合元素，通常写collection或者list
open : 代表语句的开始部分
close : 代表语句的结束部分
item : 代表遍历结合中的每个元素，生成的变量名
separator: 分隔符
-->
<foreach collection="collection" open="id in (" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
</select>
<!--动态sql的foreach标签：多值查询：根据多个id值查询用户-->
<select id="findByArray" parameterType="int" resultType="user">
<include refid="selectUser"/>
<where>
<!--
collection : 代表要遍历的集合元素，通常写collection或者list
open : 代表语句的开始部分
close : 代表语句的结束部分
item : 代表遍历结合中的每个元素，生成的变量名
separator: 分隔符
-->
<foreach collection="array" open="id in (" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
</select>
</mapper>
c）测试代码
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.lagou.domain.User;
import com.lagou.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class MybatisTest {
/*
mybatis的Dao层mapper代理方式测试
*/
@Test
public void test1() 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 = mapper.findUserById(1);
System.out.println(user);
}
@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();
}
/*
多条件查询：方式一
*/
@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();
}
/*
多条件查询：方式二
*/
@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();
}
/*
多条件查询：方式三
*/
@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();
}
/*
模糊查询：方式一
*/
@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();
}
/*
模糊查询：方式二
*/
@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();
}
/*
添加用户：返回主键方式一
*/
@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();
}
/*
添加用户：返回主键方式一
*/
@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();
}
/*
动态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();
}
/*
动态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();
}
/*
动态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();
}
/*
动态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();
}
/*
核心配置文件深入：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： 每页显示的条数
PageHelper.startPage(1,2);
List<User> users = mapper.findAllResultMap();
for (User user : users) {
System.out.println(user);
}
// 获取分页相关的其他参数
PageInfo<User> pageInfo = new PageInfo<User>(users);
System.out.println("总条数"+ pageInfo.getTotal());
System.out.println("总页数"+ pageInfo.getPages());
System.out.println("是否是第一页"+ pageInfo.isIsFirstPage());
sqlSession.close();
}
}2.2.2 动态 SQL 之<set>
需求
动态更新user表数据，如果该属性有值就更新，没有值不做处理。
a）UserMapper接口
public void updateIf(User user);
b）UserMapper.xml映射
<!--
set标签在更新的时候，自动加上set关键字，然后去掉最后一个条件的逗号
-->
<update id="updateIf" parameterType="user">
UPDATE `user`
<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）测试代码
// set标签
@Test
public void testUpdateIf()throws Exception{
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = new User();
user.setId(1);
user.setUsername("小二王");
user.setSex("女");
userMapper.updateIf(user);
}2.2.3 动态 SQL 之<foreach>
foreach主要是用来做数据的循环遍历
例如： select * from user where id in (1,2,3) 在这样的语句中，传入的参数部分必须依靠foreach遍历才能实现。
* <foreach>标签用于遍历集合，它的属性：
- collection：代表要遍历的集合元素
- open：代表语句的开始部分
- close：代表结束部分
- item：代表遍历集合的每个元素，生成的变量名
- sperator：代表分隔符
a）集合
UserMapper接口
public List<User> findByList(List<Integer> ids);
UserMaper.xml映射
<!--
如果查询条件为普通类型 List集合，collection属性值为：collection 或者 list
-->
<select id="findByList" parameterType="list" resultType="user" >
SELECT * FROM `user`
<where>
<foreach collection="collection" open="id in(" close=")" item="id"
separator=",">
#{id}
</foreach>
</where>
</select>测试代码
// foreach标签 list
@Test
public void testFindByList() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<Integer> ids = new ArrayList<>();
ids.add(46);
ids.add(48);
ids.add(51);
List<User> list = userMapper.findByList(ids);
System.out.println(list);
}
b）数组
UserMapper接口
public List<User> findByArray(Integer[] ids);
UserMaper.xml映射
<!--
如果查询条件为普通类型 Array数组，collection属性值为：array
-->
<select id="findByArray" parameterType="int" resultType="user">
SELECT * FROM `user`
<where>
<foreach collection="array" open="id in(" close=")" item="id"
separator=",">
#{id}
</foreach>
</where>
</select>测试代码
// foreach标签 array
@Test
public void testFindByArray() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
Integer[] ids = {46, 48, 51};
List<User> list = userMapper.findByArray(ids);
System.out.println(list);
}
2.3 SQL片段
应用场景
映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的
<!--抽取的sql片段-->
<sql id="selectUser">
SELECT * FROM `user`
</sql>
<select id="findByList" parameterType="list" resultType="user" >
<!--引入sql片段-->
<include refid="selectUser"></include>
<where>
<foreach collection="collection" open="id in(" close=")" item="id"
separator=",">
#{id}
</foreach>
</where>
</select>
<select id="findByArray" parameterType="integer[]" resultType="user">
<!--引入sql片段-->
<include refid="selectUser"></include>
<where>
<foreach collection="array" open="id in(" close=")" item="id"
separator=",">
#{id}
</foreach>
</where>
</select>
2.4 知识小结
MyBatis映射文件配置
- <select>：查询
- <insert>：插入
- <update>：修改
- <delete>：删除
- <selectKey>：返回主键
- <where>：where条件
- <if>：if判断
- <foreach>：for循环
- <set>：set设置
- <sql>：sql片段抽取
三 Mybatis核心配置文件深入
3.1 plugins标签
MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据
开发步骤：
- ①导入通用PageHelper的坐标
- ②在mybatis核心配置文件中配置PageHelper插件
- ③测试分页数据获取
①导入通用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核心配置文件中配置PageHelper插件
<!-- 分页助手的插件 -->
<plugin interceptor="com.github.pagehelper.PageHelper">
<!-- 指定方言 -->
<property name="dialect" value="mysql"/>
</plugin>③测试分页代码实现
@Test
public void testPageHelper(){
//设置分页参数
PageHelper.startPage(1,2);
List<User> select = userMapper2.select(null);
for(User user : select){
System.out.println(user);
}
}
获得分页相关的其他参数
//其他分页的数据
PageInfo<User> pageInfo = new PageInfo<User>(select);
System.out.println("总条数："+pageInfo.getTotal());
System.out.println("总页数："+pageInfo.getPages());
System.out.println("当前页："+pageInfo.getPageNum());
System.out.println("每页显示长度："+pageInfo.getPageSize());
System.out.println("是否第一页："+pageInfo.isIsFirstPage());
System.out.println("是否最后一页："+pageInfo.isIsLastPage());
3.2 知识小结
MyBatis核心配置文件常用标签：
- 1、properties标签：该标签可以加载外部的properties文件
- 2、typeAliases标签：设置类型别名
- 3、environments标签：数据源环境配置标签
- 4、plugins标签：配置MyBatis的插件
四 Mybatis多表查询
4.1 数据库表关系介绍
关系型数据库表关系分为
- 一对一
- 一对多
- 多对多
举例
* 人和身份证号就是一对一
- 一个人只能有一个身份证号
- 一个身份证号只能属于一个人
* 用户和订单就是一对多，订单和用户就是多对一
- 一个用户可以下多个订单
- 多个订单属于同一个用户
* 学生和课程就是多对多
- 一个学生可以选修多门课程
- 一个课程可以被多个学生选修
* 特例
- 一个订单只从属于一个用户，所以mybatis将多对一看成了一对一
案例环境准备
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实体
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 +
'}';
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getOrdertime() {
return ordertime;
}
public void setOrdertime(String ordertime) {
this.ordertime = ordertime;
}
public Double getTotal() {
return total;
}
public void setTotal(Double total) {
this.total = total;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
}
2 ）OrderMapper接口
import com.lagou.domain.Orders;
import java.util.List;
public interface OrderMapper {
/*
一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息
*/
public List<Orders> findAllWithUser();
/*
一对一嵌套查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息
*/
public List<Orders> findAllWithUser2();
/*
根据uid查询对应订单
*/
public List<Orders> findByUid(Integer uid);
}
3 ）OrderMapper.xml映射
<?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.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" 要封装的实体的属性类型
-->
<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>
<select id="findAllWithUser" resultMap="orderMap">
SELECT * FROM orders o LEFT JOIN USER u ON o.uid = u.id
</select>
<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作为参数进行传递-->
<association property="user" javaType="com.lagou.domain.User"
select="com.lagou.mapper.UserMapper.findById" column="uid" fetchType="eager"/>
</resultMap>
<!--一对一嵌套查询-->
<select id="findAllWithUser2" resultMap="orderMap2">
SELECT * FROM orders
</select>
<select id="findByUid" parameterType="int" resultType="com.lagou.domain.Orders">
SELECT * FROM orders WHERE uid = #{uid}
</select>
</mapper>
4 ）测试代码
import com.lagou.domain.Orders;
import com.lagou.domain.User;
import com.lagou.mapper.OrderMapper;
import com.lagou.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class mybatisTest {
/*
一对一关联查询：查询所有订单，与此同时还要查询出每个订单所属的用户信息
*/
@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();
}
/*
一对多关联查询：查询所有用户及关联的订单信息
*/
@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();
}
/*
多对多关联查询：查询所有用户及关联的角色信息
*/
@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();
}
/*
一对一嵌套查询：查询所有订单及关联的用户信息
*/
@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();
}
/*
一对多嵌套查询：查询所有用户及关联的订单信息
*/
@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();
}
/*
多对多嵌套查询：查询所有用户及关联的角色信息
*/
@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();
}
/*
验证mybatis中的一级缓存
*/
@Test
public void testOneCache() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 根据id查询用户信息
// 第一次查询，查询的数据库
User user1 = userMapper.findById(1);
System.out.println(user1);
// clearCache: 手动清空缓存
//sqlSession.clearCache();
// 第二次查询，查询的是一级缓存
User user2 = userMapper.findById(1);
System.out.println(user2);
sqlSession.close();
}
/*
验证mybatis中的二级缓存
*/
@Test
public void testTwoCache() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession1 = sqlSessionFactory.openSession();
UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
// 第一次查询
User user = userMapper1.findById(1);
System.out.println(user);
// 只有执行sqlSession.commit或者sqlSession.close，那么一级缓存中内容才会刷新到二级缓存
sqlSession1.close();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
User user2 = userMapper2.findById(1);
System.out.println(user2);
sqlSession2.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实体
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 +
'}';
}
public List<Role> getRoleList() {
return roleList;
}
public void setRoleList(List<Role> roleList) {
this.roleList = roleList;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public List<Orders> getOrdersList() {
return ordersList;
}
public void setOrdersList(List<Orders> ordersList) {
this.ordersList = ordersList;
}
}
2 ）UserMapper接口
package com.lagou.mapper;
import com.lagou.domain.User;
import java.util.List;
public interface UserMapper {
/*
一对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的订单信息
*/
public List<User> findAllWithOrder();
/*
多对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的角色信息
*/
public List<User> findAllWithRole();
/*
根据id查询用户
*/
public User findById(Integer id);
/*
一对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的订单信息
*/
public List<User> findAllWithOrder2();
/*
多对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的角色信息
*/
public List<User> findAllWithRole2();
}
3 ）UserMapper.xml映射
<?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.lagou.mapper.UserMapper">
<!--当前映射开启二级缓存-->
<cache></cache>
<!--一对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的订单信息-->
<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标签进行关联
-->
<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>
<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>
<!--多对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的角色信息-->
<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>
<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>
<!--根据id查询用户
useCache="true" 代表当前这个statement是使用二级缓存
-->
<select id="findById" resultType="com.lagou.domain.User" parameterType="int" useCache="true">
SELECT * FROM user WHERE id = #{id}
</select>
<!--一对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的订单信息-->
<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>
<!--fetchType="lazy" : 延迟加载策略
fetchType="eager": 立即加载策略
-->
<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>
<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>
</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
*
FROM
USER u -- 用户表
LEFT JOIN user_role ur -- 左外连接中间表
ON u.`id` = ur.`uid`
LEFT JOIN role r -- 左外连接中间表
ON ur.`rid` = r.`id` ;
4.4.2 代码实现
1 ）User和Role 实体
package com.lagou.domain;
public class Role {
private Integer id;
private String rolename;
private String roleDesc;
@Override
public String toString() {
return "Role{" +
"id=" + id +
", rolename='" + rolename + '\'' +
", roleDesc='" + roleDesc + '\'' +
'}';
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getRolename() {
return rolename;
}
public void setRolename(String rolename) {
this.rolename = rolename;
}
public String getRoleDesc() {
return roleDesc;
}
public void setRoleDesc(String roleDesc) {
this.roleDesc = roleDesc;
}
}
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 +
'}';
}
public List<Role> getRoleList() {
return roleList;
}
public void setRoleList(List<Role> roleList) {
this.roleList = roleList;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public List<Orders> getOrdersList() {
return ordersList;
}
public void setOrdersList(List<Orders> ordersList) {
this.ordersList = ordersList;
}
}
2 ）UserMapper接口
package com.lagou.mapper;
import com.lagou.domain.User;
import java.util.List;
public interface UserMapper {
/*
一对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的订单信息
*/
public List<User> findAllWithOrder();
/*
多对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的角色信息
*/
public List<User> findAllWithRole();
/*
根据id查询用户
*/
public User findById(Integer id);
/*
一对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的订单信息
*/
public List<User> findAllWithOrder2();
/*
多对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的角色信息
*/
public List<User> findAllWithRole2();
}
3 ）UserMapper.xml映射
<?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.lagou.mapper.UserMapper">
<!--当前映射开启二级缓存-->
<cache></cache>
<!--一对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的订单信息-->
<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标签进行关联
-->
<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>
<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>
<!--多对多关联查询:查询所有的用户，同时还要查询出每个用户所关联的角色信息-->
<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>
<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>
<!--根据id查询用户
useCache="true" 代表当前这个statement是使用二级缓存
-->
<select id="findById" resultType="com.lagou.domain.User" parameterType="int" useCache="true">
SELECT * FROM user WHERE id = #{id}
</select>
<!--一对多嵌套查询：查询所有的用户，同时还要查询出每个用户所关联的订单信息-->
<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>
<!--fetchType="lazy" : 延迟加载策略
fetchType="eager": 立即加载策略
-->
<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>
<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>
</mapper>4.5 小结
MyBatis多表配置方式
- * 多对一（一对一）配置：使用<resultMap>+<association>做配置
- * 一对多配置：使用<resultMap>+<collection>做配置
- * 多对多配置：使用<resultMap>+<collection>做配置
- * 多对多的配置跟一对多很相似，难度在于SQL语句的编写
五 MyBatis嵌套查询
5.1 什么是嵌套查询
嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用mybatis的语法嵌套在一起。
举个栗子
* 需求：查询一个订单，与此同时查询出该订单所属的用户
1. 联合查询
- SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`;
2. 嵌套查询
- 2.1 先查询订单
- SELECT * FROM orders
- 2.2 再根据订单uid外键，查询用户
- SELECT * FROM `user` WHERE id = #{根据订单查询的uid}
- 2.3 最后使用mybatis，将以上二步嵌套起来
- ...
5.2 一对一嵌套查询
5.2.1 介绍
需求：查询一个订单，与此同时查询出该订单所属的用户
一对一查询语句
-- 先查询订单
SELECT * FROM orders;
-- 再根据订单uid外键，查询用户
SELECT * FROM `user` WHERE id = #{订单的uid};
5.2.2 代码实现
1）OrderMapper接口
public interface OrderMapper {
public List<Order> findAllWithUser();
}
2）OrderMapper.xml映射
<!--一对一嵌套查询-->
<resultMap id="orderMap" type="order">
<id column="id" property="id"></id>
<result column="ordertime" property="ordertime"></result>
<result column="money" property="money"></result>
<!--根据订单中uid外键，查询用户表-->
<association property="user" javaType="user" column="uid"
select="com.lagou.mapper.UserMapper.findById"></association>
</resultMap>
<select id="findAllWithUser" resultMap="orderMap" >
SELECT * FROM orders
</select>3）UserMapper接口
public interface UserMapper {
public User findById(Integer id);
}
4）UserMapper.xml映射
<select id="findById" parameterType="int" resultType="user">
SELECT * FROM `user` where id = #{uid}
</select>
5）测试代码
@Test
public void testOrderWithUser() throws Exception {
OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
List<Order> list = orderMapper.findAllWithUser();
for (Order order : list) {
System.out.println(order);
}
}
5.3 一对多嵌套查询
5.3.1 介绍
需求：查询所有用户，与此同时查询出该用户具有的订单
一对多查询语句
-- 先查询用户
SELECT * FROM `user`;
-- 再根据用户id主键，查询订单列表
SELECT * FROM orders where uid = #{用户id};
5.3.2 代码实现
a）UserMapper接口
public interface UserMapper {
public List<User> findAllWithOrder();
}b）UserMapper.xml映射
<!--一对多嵌套查询-->
<resultMap id="userMap" type="user">
<id column="id" property="id"></id>
<result column="username" property="username"></result>
<result column="birthday" property="birthday"></result>
<result column="sex" property="sex"></result>
<result column="address" property="address"></result>
<!--根据用户id，查询订单表-->
<collection property="orderList" column="id" ofType="order"
select="com.lagou.mapper.OrderMapper.findByUid"></collection>
</resultMap>
<select id="findAllWithOrder" resultMap="userMap">
SELECT * FROM `user`
</select>
c）OrderMapper接口
public interface OrderMapper {
public List<Order> findByUid(Integer uid);
}
d）OrderMapper.xml映射
<select id="findByUid" parameterType="int" resultType="order">
SELECT * FROM orders where uid = #{uid}
</select>
e）测试代码
@Test
public void testUserWithOrder() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findAllWithOrder();
for (User user : list) {
System.out.println(user);
}
}5.4 多对多嵌套查询
5.4.1 介绍
需求：查询用户 同时查询出该用户的所有角色
多对多查询语句
-- 先查询用户
SELECT * FROM `user`;
-- 再根据用户id主键，查询角色列表
SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid`
WHERE ur.`uid` = #{用户id};
5.4.2 代码实现
a）UserMapper接口
public interface UserMapper {
public List<User> findAllWithRole();
}
b）UserMapper.xml映射
<!--多对多嵌套查询-->
<resultMap id="userAndRoleMap" type="user">
<id column="id" property="id"></id>
<result column="username" property="username"></result>
<result column="birthday" property="birthday"></result>
<result column="sex" property="sex"></result>
<result column="adress" property="address"></result>
<!--根据用户id，查询角色列表-->
<collection property="roleList" column="id" ofType="role"
select="com.lagou.mapper.RoleMapper.findByUid"></collection>
</resultMap>
<select id="findAllWithRole" resultMap="userAndRoleMap">
SELECT * FROM `user`
</select>c）RoleMapper接口
public interface RoleMapper {
public List<Role> findByUid(Integer uid);
}
d）RoleMapper.xml映射
<select id="findByUid" parameterType="int" resultType="role">
SELECT r.id,r.`role_name` roleName,r.`role_desc` roleDesc FROM role r
INNER JOIN user_role ur ON r.`id` = ur.`rid` WHERE ur.`uid` = #{uid}
</select>
e）测试代码
@Test
public void testUserWithRole() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findAllWithRole();
for (User user : list) {
System.out.println(user);
}
}
5.5 小结
- 一对一配置：使用<resultMap>+<association>做配置，通过column条件，执行select查询
- 一对多配置：使用<resultMap>+<collection>做配置，通过column条件，执行select查询
- 多对多配置：使用<resultMap>+<collection>做配置，通过column条件，执行select查询
- 优点：简化多表查询操作
- 缺点：执行多次sql语句，浪费数据库性能
Mybatis任务三：加载策略及注解开发
一 MyBatis加载策略
1.1 什么是延迟加载？
问题
通过前面的学习，我们已经掌握了Mybatis中一对一，一对多，多对多关系的配置及实现，可以实现
对象的关联查询。实际开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的订单
信息。此时就是我们所说的延迟加载。
举个栗子
* 在一对多中，当我们有一个用户，它有个100个订单
- 在查询用户的时候，要不要把关联的订单查出来？
- 在查询订单的时候，要不要把关联的用户查出来？
* 回答
- 在查询用户时，用户下的订单应该是，什么时候用，什么时候查询。
- 在查询订单时，订单所属的用户信息应该是随着订单一起查询出来。
延迟加载
就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。
* 优点：
- 先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。
* 缺点：
- 因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。
* 在多表中：
- 一对多，多对多：通常情况下采用延迟加载
- 一对一（多对一）：通常情况下采用立即加载
* 注意：
延迟加载是基于嵌套查询来实现的
1.2 实现
1.2.1 局部延迟加载
在association和collection标签中都有一个fetchType属性，通过修改它的值，可以修改局部的加载策略。
<!-- 开启一对多 延迟加载 -->
<resultMap id="userMap" type="user">
<id column="id" property="id"></id>
<result column="username" property="username"></result>
<result column="password" property="password"></result>
<result column="birthday" property="birthday"></result>
<!--
fetchType="lazy" 懒加载策略
fetchType="eager" 立即加载策略
-->
<collection property="orderList" ofType="order" column="id"
select="com.lagou.dao.OrderMapper.findByUid" fetchType="lazy">
</collection>
</resultMap>
<select id="findAll" resultMap="userMap">
SELECT * FROM `user`
</select>1.2.2 设置触发延迟加载的方法
大家在配置了延迟加载策略后，发现即使没有调用关联对象的任何方法，但是在你调用当前对象的
equals、clone、hashCode、toString方法时也会触发关联对象的查询。
我们可以在配置文件中使用lazyLoadTriggerMethods配置项覆盖掉上面四个方法。
<settings>
<!--所有方法都会延迟加载-->
<setting name="lazyLoadTriggerMethods" value="toString()"/>
</settings>
1.2.3 全局延迟加载
在Mybatis的核心配置文件中可以使用setting标签修改全局的加载策略。
<settings>
<!--开启全局延迟加载功能-->
<setting name="lazyLoadingEnabled" value="true"/>
</settings>
注意
局部的加载策略优先级高于全局的加载策略。
<!-- 关闭一对一 延迟加载 -->
<resultMap id="orderMap" type="order">
<id column="id" property="id"></id>
<result column="ordertime" property="ordertime"></result>
<result column="total" property="total"></result>
<!--
fetchType="lazy" 懒加载策略
fetchType="eager" 立即加载策略
-->
<association property="user" column="uid" javaType="user"
select="com.lagou.dao.UserMapper.findById" fetchType="eager">
</association>
</resultMap>
<select id="findAll" resultMap="orderMap">
SELECT * from orders
</select>二 MyBatis缓存
2.1 为什么使用缓存？
当用户频繁查询某些固定的数据时,第一次将这些数据从数据库中查询出来,保存在缓存中。当用户再次查询这些数据时,不用再通过数据库查询,而是去缓存里面查询。减少网络连接和数据库查询带来的损耗,从而提高我们的查询效率,减少高并发访问带来的系统性能问题。
一句话概括：经常查询一些不经常发生变化的数据，使用缓存来提高查询效率。
像大多数的持久化框架一样，Mybatis也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。 Mybatis中缓存分为一级缓存，二级缓存。
2.2 一级缓存
2.2.1 介绍
一级缓存是SqlSession级别的缓存，是默认开启的所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，SqlSession都会取出当前缓存的数据，而不会再次发送SQL到数据库。
2.2.2 验证
@Test
public void testOneCache() throws Exception {
SqlSession sqlSession = MyBatisUtils.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user1 = userMapper.findById(1);
System.out.println("第一次查询的用户：" + user1);
User user2 = userMapper.findById(1);
System.out.println("第二次查询的用户：" + user2);
sqlSession.close();
}我们可以发现，虽然在上面的代码中我们查询了两次，但最后只执行了一次数据库操作，这就是Mybatis提供给我们的一级缓存在起作用了。因为一级缓存的存在，导致第二次查询id为1的记录时，并没有发出sql语句从数据库中查询数据，而是从一级缓存中查询。
2.2.3 分析
一级缓存是SqlSession范围的缓存，执行SqlSession的C（增加）U（更新）D（删除）操作，或者调用clearCache()、commit()、close()方法，都会清空缓存。
- 第一次发起查询用户id为41的用户信息，先去找缓存中是否有id为41的用户信息，如果没有，从数据库查询用户信息。
- 得到用户信息，将用户信息存储到一级缓存中。
- 如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
- 第二次发起查询用户id为41的用户信息，先去找缓存中是否有id为41的用户信息，缓存中有，直接从缓存中获取用户信息。
2.2.4 清除
@Test
public void testClearOneCache() throws Exception {
SqlSession sqlSession = MybatisUtils.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user1 = userMapper.findById(41);
System.out.println("第一次查询的用户：" + user1);
//调用sqlSession清除缓存的方法
sqlSession.clearCache();
User user2 = userMapper.findById(41);
System.out.println("第二次查询的用户：" + user2);
}<!-- 每次查询时，都会清除缓存 -->
< select flushCache="true"></select>2.3 二级缓存
2.3.1 介绍
二级缓存是namspace级别（跨sqlSession）的缓存，是默认不开启的
二级缓存的开启需要进行配置，实现二级缓存的时候，MyBatis要求返回的POJO必须是可序列化的。也就是要求实现Serializable接口，配置方法很简单，只需要在映射XML文件配置<cache/> 就可以开启二级缓存了。
2.3.2 验证
a）配置核心配置文件
<settings>
<!--
因为cacheEnabled的取值默认就为true，所以这一步可以省略不配置。
为true代表开启二级缓存；为false代表不开启二级缓存。
-->
<setting name="cacheEnabled" value="true"/>
</settings>b）配置UserMapper.xml映射
<mapper namespace="com.lagou.dao.UserMapper">
<!--当前映射文件开启二级缓存-->
<cache></cache>
<!--
<select>标签中设置useCache=”true”代表当前这个statement要使用二级缓存。
如果不使用二级缓存可以设置为false
注意：
针对每次查询都需要最新的数据sql，要设置成useCache="false"，禁用二级缓存。
-->
<select id="findById" parameterType="int" resultType="user" useCache="true">
SELECT * FROM `user` where id = #{id}
</select>
</mapper>
c）修改User实体
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
private List<Role> roleList;
private List<Order> orderList;
}
d）测试结果
@Test
public void testTwoCache() throws Exception {
SqlSession sqlSession = MyBatisUtils.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = userMapper.findById(41);
System.out.println("第一次查询的用户：" + user);
sqlSession.close();
SqlSession sqlSession1 = MyBatisUtils.openSession();
UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
User user1 = userMapper1.findById(41);
System.out.println("第二次查询的用户："+user1);
sqlSession1.close();
}
2.3.3 分析
二级缓存是mapper映射级别的缓存，多个SqlSession去操作同一个Mapper映射的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。
- 映射语句文件中的所有select语句将会被缓存。
- 映射语句文件中的所有insert、update和delete语句会刷新缓存。
2.3.4 注意问题（脏读）
mybatis的二级缓存因为是namespace级别，所以在进行多表查询时会产生脏读问题
2.4 小结
- mybatis的缓存，都不需要我们手动存储和获取数据。mybatis自动维护的。
- mybatis开启了二级缓存后，那么查询顺序：二级缓存--》一级缓存--》数据库
- 注意：mybatis的二级缓存会存在脏读问题，需要使用第三方的缓存技术解决问题。
三 MyBatis注解
3.1 MyBatis常用注解
这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了。我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。
* @Insert：实现新增，代替了<insert></insert>
* @Delete：实现删除，代替了<delete></delete>
* @Update：实现更新，代替了<update></update>
* @Select：实现查询，代替了<select></select>
* @Result：实现结果集封装，代替了<result></result>
* @Results：可以与@Result 一起使用，封装多个结果集，代替了<resultMap></resultMap>
* @One：实现一对一结果集封装，代替了<association></association>
* @Many：实现一对多结果集封装，代替了<collection></collection>
3.2 MyBatis注解的增删改查【重点】
3.2.1 创建UserMapper接口
import com.lagou.domain.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;
import java.util.List;
@CacheNamespace // 配置了二级缓存
public interface UserMapper {
/*
查询用户
*/
@Select("select * from user")
public List<User> findAll();
/*
添加用户
*/
@Insert("insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})")
public void save(User user);
/*
更新用户
*/
@Update("update user set username = #{username},birthday=#{birthday} where id = #{id}")
public void update(User user);
/*
删除用户
*/
@Delete("delete from user where id = #{id}")
public void delete(Integer id);
/*
根据id查询用户
*/
@Select("select * from user where id = #{uid}")
public User findById(Integer uid);
/*
查询所有用户，及关联的订单信息
*/
@Select("select * from user")
@Results({
@Result(property = "id",column = "id",id = true),
@Result(property = "username",column = "username"),
@Result(property = "birthday",column = "birthday"),
@Result(property = "sex",column = "sex"),
@Result(property = "address",column = "address"),
@Result(property = "ordersList",javaType = List.class,column = "id",many = @Many(select = "com.lagou.mapper.OrderMapper.findOrderByUid",fetchType = FetchType.LAZY))
})
public List<User> findAllWithOrder();
/*
查询所有用户及关联的角色信息
*/
@Select("select * from user")
@Results({
@Result(property = "id",column = "id",id = true),
@Result(property = "username",column = "username"),
@Result(property = "birthday",column = "birthday"),
@Result(property = "sex",column = "sex"),
@Result(property = "address",column = "address"),
@Result(property = "roleList",javaType = List.class,column = "id",many = @Many(select = "com.lagou.mapper.RoleMapper.findAllByUid")),
})
public List<User> findAllWithRole();
}
3.2.2 编写核心配置文件
<!--我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的Mapper接口即可-->
<mappers>
<!--扫描使用注解的Mapper类-->
<mapper class="com.lagou.mapper.UserMapper"></mapper>
</mappers>
<!--或者指定扫描包含映射关系的接口所在的包也可以-->
<mappers>
<!--扫描使用注解的Mapper类所在的包-->
<package name="com.lagou.mapper"></package>
</mappers>3.2.3 测试代码
import com.lagou.domain.Orders;
import com.lagou.domain.User;
import com.lagou.mapper.OrderMapper;
import com.lagou.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
public class MybatisTest {
private SqlSessionFactory sqlSessionFactory;
private SqlSession sqlSession;
// 在 @Test方法标注的方法执行之前来执行
@Before
public void before() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
sqlSession = sqlSessionFactory.openSession();
}
@After
public void after(){
sqlSession.commit();
sqlSession.close();
}
/*
测试查询方法
*/
@Test
public void testSelect() throws IOException {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> all = mapper.findAll();
for (User user : all) {
System.out.println(user);
}
}
/*
测试添加方法
*/
@Test
public void testInsert(){
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = new User();
user.setUsername("汤唯");
user.setSex("女");
user.setBirthday(new Date());
user.setAddress("北京");
mapper.save(user);
}
@Test
public void testUpdate(){
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = new User();
user.setUsername("柳岩真美");
user.setBirthday(new Date());
user.setId(9);
mapper.update(user);
}
@Test
public void testDelete(){
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.delete(9);
}
/*
一对一查询（注解方式）
*/
@Test
public void testOneToOne(){
OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
List<Orders> allWithUser = mapper.findAllWithUser();
for (Orders orders : allWithUser) {
System.out.println(orders);
}
}
/*
一对多查询（注解方式）
*/
@Test
public void testOneToMany(){
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> allWithOrder = mapper.findAllWithOrder();
for (User user : allWithOrder) {
System.out.println(user);
System.out.println(user.getOrdersList());
}
}
/*
多对多查询（注解方式）
*/
@Test
public void testManyToMany(){
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> allWithRole = mapper.findAllWithRole();
for (User user : allWithRole) {
System.out.println(user);
System.out.println(user.getRoleList());
}
}
/*
测试注解实现二级缓存
*/
@Test
public void cacheTest(){
SqlSession sqlSession1 = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
User user1 = userMapper1.findById(1);
System.out.println(user1);
// 才能将内容从一级缓存刷新到二级缓存
sqlSession1.close();
User user2 = userMapper2.findById(1);
System.out.println(user2);
sqlSession2.close();
}
}
3.3 使用注解实现复杂映射开发
之前我们在映射文件中通过配置<resultMap>、<association>、<collection> 来实现复杂关系映射。
使用注解开发后，我们可以使用@Results、@Result，@One、@Many 注解组合完成复杂关系的配置。
3.4 一对一查询
3.4.1 介绍
需求：查询一个订单，与此同时查询出该订单所属的用户
一对一查询语句
SELECT * FROM orders;
SELECT * FROM `user` WHERE id = #{订单的uid};
3.4.2 代码实现
a）OrderMapper接口
public interface OrderMapper {
@Select("SELECT * FROM orders")
@Results({
@Result(id = true, column = "id", property = "id"),
@Result(column = "ordertime", property = "ordertime"),
@Result(column = "money", property = "money"),
@Result(property = "user", javaType = User.class,
column = "uid", one = @One(select ="com.lagou.mapper.UserMapper.findById", fetchType = FetchType.EAGER))
})
public List<Order> findAllWithUser();
}b）UserMapper接口
public interface UserMapper {
@Select("SELECT * FROM `user` WHERE id = #{id}")
public User findById(Integer id);
}
c）测试代码
@Test
public void testOrderWithUser() throws Exception {
OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
List<Order> list = orderMapper.findAllWithUser();
for (Order order : list) {
System.out.println(order);
}
}
3.5 一对多查询
3.5.1 介绍
需求：查询一个用户，与此同时查询出该用户具有的订单
一对多查询语句
SELECT * FROM `user`;
SELECT * FROM orders where uid = #{用户id};
3.5.2 代码实现
a）UserMapper接口
public interface UserMapper {
@Select("SELECT * FROM `user`")
@Results({
@Result(id = true, column = "id", property = "id"),
@Result(column = "brithday", property = "brithday"),
@Result(column = "sex", property = "sex"),
@Result(column = "address", property = "address"),
@Result(property = "orderList", javaType = List.class,
column = "id" ,many = @Many(select = "com.lagou.mapper.OrderMapper.findByUid"))
})
public List<User> findAllWithOrder();
}
b）OrderMapper接口
public interface OrderMapper {
@Select("SELECT * FROM orders WHERE uid = #{uid}")
public List<Order> findByUid(Integer uid);
}
c）测试代码
@Test
public void testUserWithOrder() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findAllWithOrder();
for (User user : list) {
System.out.println(user);
}
}
3.6 多对多查询
3.6.1 介绍
需求：查询所有用户，同时查询出该用户的所有角色
多对多查询语句
SELECT * FROM `user`;
SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid`
WHERE ur.`uid` = #{用户id};3.6.2 代码实现
a）UserMapper接口
public interface UserMapper {
@Select("SELECT * FROM `user`")
@Results({
@Result(id = true, column = "id", property = "id"),
@Result(column = "brithday", property = "brithday"),
@Result(column = "sex", property = "sex"),
@Result(column = "address", property = "address"),
@Result(property = "roleList", javaType = List.class,
column = "id" ,many = @Many(select = "com.lagou.mapper.RoleMapper.findByUid"))
})
public List<User> findAllWithRole();
}
b）RoleMapper接口
public interface RoleMapper {
@Select("SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid`
WHERE ur.`uid` = #{uid}")
public List<Role> findByUid(Integer uid);
}
c）测试代码
@Test
public void testUserWithRole() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findAllWithRole();
for (User user : list) {
System.out.println(user);
}
}
3.7 基于注解的二级缓存
3.7.1 配置SqlMapConfig.xml文件开启二级缓存的支持
<settings>
<!--
因为cacheEnabled的取值默认就为true，所以这一步可以省略不配置。
为true代表开启二级缓存；为false代表不开启二级缓存。
-->
<setting name="cacheEnabled" value="true"/>
</settings>3.7.2 在Mapper接口中使用注解配置二级缓存
@CacheNamespace
public interface UserMapper {...}
3.8 注解延迟加载
不管是一对一还是一对多 ，在注解配置中都有fetchType的属性
* fetchType = FetchType.LAZY 表示懒加载
* fetchType = FetchType.EAGER 表示立即加载
* fetchType = FetchType.DEFAULT 表示使用全局配置
3.9 小结
* 注解开发和xml配置优劣分析
- 注解开发和xml配置相比，从开发效率来说，注解编写更简单，效率更高。
- 从可维护性来说，注解如果要修改，必须修改源码，会导致维护成本增加。xml维护性更强。
扫一扫
1483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
