MyBatis笔记
第一章 Mybatis简介
1.1 内容概要
一，MyBatis简介
二，MyBatis-入门案列
三，MyBatis-全局配置文件
四，MyBatis-映射文件
五，MyBatis-动态SQL
六，MyBatis-缓存机制
七，MyBatis-Spring整合
八，MyBatis-逆向工程
九，MyBatis-工作原理
十，插件开发
1.2 Mybatis简介
- MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。
- MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
- MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和JavaPOJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录.
1.3 Mybatis历史
- 原是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation 迁移到了Google Code，随着开发团队转投Google Code旗下， iBatis3.x正式更名为MyBatis ，代码于2013年11月迁移到Github（下载地址见后）
- iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。 iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）
1.4 为什么要使用Mybatis?
MyBatis是一个半自动化的持久化层框架。
JDBC
– SQL夹在Java代码块里，耦合度高导致硬编码内伤
– 维护不易且实际开发需求中sql是有变化，频繁修改的情况多见
Hibernate和JPA
– 长难复杂SQL，对于Hibernate而言处理也不容易
– 内部自动生产的SQL，不容易做特殊优化。
– 基于全映射的全自动框架，大量字段的POJO进行部分映射时比较困难。导致数据库性能下降
对开发人员而言，核心sql还是需要自己优化
sql和java编码分开，功能边界清晰，一个专注业务、一个专注数据
1.5 Mybatis下载
https://github.com/mybatis/mybatis-3/
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-neT2LhN7-1641648417996)(MyBatis3系列笔记/clipboard-1612166365727.png)]](https://i-blog.csdnimg.cn/blog_migrate/d514fde4c08fc4046987395e99e2e359.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-APogHw6b-1641648417998)(MyBatis3系列笔记/clipboard-1612166374032.png)]](https://i-blog.csdnimg.cn/blog_migrate/58edebe97d830196ff1a812634098d1f.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DssLB6wE-1641648417999)(MyBatis3系列笔记/clipboard-1612166379367.png)]](https://i-blog.csdnimg.cn/blog_migrate/177da5307e11634ebe5f24e5da907d8e.png)
第二章 Mybatis入门案例
2.1 项目目录结构图
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8xngTGqh-1641648418000)(MyBatis3系列笔记/clipboard-1612166656761.png)]](https://i-blog.csdnimg.cn/blog_migrate/93af21aa99c8096e1289f232b896ade8.png)
2.2 代码示例
- 表结构及数据
DROP TABLE IF EXISTS `tbl_employee`;
CREATE TABLE `tbl_employee` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`last_name` varchar(20) DEFAULT NULL,
`email` varchar(20) DEFAULT NULL,
`gender` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
INSERT INTO `tbl_employee` VALUES ('1', '张三', 'zhangsan@163.com', '1');
INSERT INTO `tbl_employee` VALUES ('2', '李四', 'lisi@qq.com', '0');
- 配置log4j.xml日志文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
<logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>
- 配置mybatis-config.xml文件
<?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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<mapper resource="EmployeeMapper.xml" />
</mappers>
</configuration>
- 编写java实体类
package com.atguigu.mybatis.bean;
@Data
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
}
- 编写对应的映射文件
<?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.atguigu.mybatis.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
public Employee getEmpById(Integer id);
-->
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee">
select id,last_name lastName,email,gender from tbl_employee where id = #{id}
</select>
</mapper>
- 编写测试类
package com.atguigu.mybatis.test;
import java.io.IOException;
import java.io.InputStream;
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 com.atguigu.mybatis.bean.Employee;
/**
* 1、接口式编程
* 原生:Dao ====> DaoImpl
* mybatis Mapper ====> xxMapper.xml
* 2、SqlSession代表和数据库的一次会话；用完必须关闭；
* 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
* 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。（将接口和xml进行绑定）
* EmployeeMapper empMapper = sqlSession.getMapper(EmployeeMapper.class);
* 5、两个重要的配置文件：
* mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
* sql映射文件：保存了每一个sql语句的映射信息：将sql抽取出来。
*/
public class MyBatisTest {
/**
* 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
* 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。
* 3、将sql映射文件注册在全局配置文件中
* 4、写代码：
* 1）、根据全局配置文件得到SqlSessionFactory；
* 2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
* 一个sqlSession就是代表和数据库的一次会话，用完关闭
* 3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
*/
@Test
public void test() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 2、获取sqlSession实例，能直接执行已经映射的sql语句
// sql的唯一标识：statement Unique identifier matching the statement to use.
// 执行sql要用的参数：parameter A parameter object to pass to the statement.
SqlSession openSession = sqlSessionFactory.openSession();
try {
Employee employee = openSession.selectOne(
"com.atguigu.mybatis.EmployeeMapper.getEmpById", 1);
System.out.println(employee);
} finally {
openSession.close();
}
}
}
第三章 全局配置文件
3.1 项目目录结构图
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hf7atPmC-1641648418002)(MyBatis3系列笔记/clipboard-1612170344873.png)]](https://i-blog.csdnimg.cn/blog_migrate/ac9fb0dcfa4ff402f3aae08f3021feb7.png)
3.2 代码示例
- 配置log4j.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
<logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>
- 配置Mybatis-config.xml文件
<?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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<mapper resource="EmployeeMapper.xml" />
</mappers>
</configuration>
- 编写java实体类
package com.atguigu.mybatis.bean;
@Data
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
}
- 编写接口文件,用于映射Mapper.xml文件
package com.atguigu.mybatis.dao;
import com.atguigu.mybatis.bean.Employee;
/**
* 定义接口
*/
public interface EmployeeMapper {
public Employee getEmpById(Integer id);
}
- 编写对应映射文件
<?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.atguigu.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识,取接口的方法名称:public Employee getEmpById(Integer id);
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
-->
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee">
select id,last_name lastName,email,gender from tbl_employee where id = #{id}
</select>
</mapper>
- 编写测试类
package com.atguigu.mybatis.test;
import java.io.IOException;
import java.io.InputStream;
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 com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.EmployeeMapper;
/**
1、接口式编程
* 原生：Dao ====> DaoImpl
* mybatis：Mapper ====> xxMapper.xml
* 2、SqlSession代表和数据库的一次会话；用完必须关闭；
* 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
* 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。（将接口和xml进行绑定）
* EmployeeMapper empMapper = sqlSession.getMapper(EmployeeMapper.class);
* 5、两个重要的配置文件：
* mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
* sql映射文件：保存了每一个sql语句的映射信息：将sql抽取出来。
*/
public class MyBatisTest {
//封装获取SqlSessionFactory
public SqlSessionFactory getsqSessionFactory(){
String resource = "mybatis-config.xml";
InputStream inputStream = null;
try {
inputStream = Resources.getResourceAsStream(resource);
} catch (IOException e) {
e.printStackTrace();
}
return new SqlSessionFactoryBuilder().build(inputStream);
}
/**
* 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
* 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。
* 3、将sql映射文件注册在全局配置文件中
* 4、写代码：
* 1）、根据全局配置文件得到SqlSessionFactory；
* 2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
* 一个sqlSession就是代表和数据库的一次会话，用完关闭
* 3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
*/
@Test
public void test(){
//1.获取SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
//2.获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
Employee employee = employeeMapper.getEmpById(1);
System.out.println(employeeMapper);
System.out.println(employee);
sqlSession.close();
}
}
3.3 注意细节
- SqlSession的实例不是线程安全的,因此是不能被共享的.
- SqlSession每次使用完成后需要正确关闭,这个关闭操作是必须的.
- SqlSession可以直接调用方法的id进行数据库操作,但是我们
一般还是推荐使用SqlSession获取到DAO接口的代理类,执行代理对象的方法,可以更安全的进行类型检查.
3.4 Mybatis全局配置文件
Mybatis的配置文件包含了影响MyBatis行为甚深的设置（settings）和属性（properties）信息。文档的顶层结果如下：
- configuration配置：
- properties属性
- settings设置
- typeAliases类型命名
- typeHandlers类型处理器
- objectFactory对象工厂
- plugins插件
- environments环境
- environment环境变量
- transactionManager 事务管理器
- dataSource 数据源
- databaseProvider 数据库产商标识
- mappers 映射器
3.4.1 全局配置文件_引入dtd约束
在Eclipse中引入XML的dtd约束文件,方便编写XML的时候有提示.
- Mybatis的核心配置文件与映射配置文件的dtd路径在jar
- Eclipse中引入XML的dtd约束文件方式
3.4.2 properties引入外部配置文件
-
代码示例
- Mybatis-config.xml文件
<?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> <!-- 1、mybatis可以使用properties来引入外部properties配置文件的内容； resource：引入类路径下的资源 url：引入网络路径或者磁盘路径下的资源 --> <properties resource="dbconfig.properties"></properties> <environments default="development"> <environment id="development"> <transactionManager type="JDBC" /> <dataSource type="POOLED"> <!-- ${jdbc.driver}获取dbconfig.properties属性文件中的值 --> <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> <!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 --> <mappers> <mapper resource="EmployeeMapper.xml" /> </mappers> </configuration> -
dbconfig.properties文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=root
3.4.3 settings运行时行为设置
- Mybatis-config.xml文件配置
<!--
settings包含很多重要的设置项
setting:用来设置每一个设置项
name：设置项名
value：设置项取值
-->
<!-- 设置是否开启驼峰命名法则,默认是false -->
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
启用上面的设置后,配置中的字段与数据库表中的字段不一致,但是遵循xxx_xxx的驼峰命名法则,Mybatis也是可以识别出来的
- 代码示例
private String lastName;
DROP TABLE IF EXISTS `tbl_employee`;
CREATE TABLE `tbl_employee` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`last_name` varchar(20) DEFAULT NULL,
`email` varchar(20) DEFAULT NULL,
`gender` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee">
<!-- select id,last_name lastName,email,gender from tbl_employee where id = #{id} -->
select * from tbl_employee where id = #{id}
</select>
3.4.4 typeAliases别名
typeAliase别名处理器
1. 类型别名是为java类型设置一个端的名字,可以方便我们引用某个类.
<typeAliase>
<typeAlias type="com.atguigu.bean.Employee" alias="employee"></typeAlias>
<typeAlias type="com.atguigu.bean.Department" alias="department"></typeAlias>
</typeAliase>
2. 类很多的情况下,可以批量设置别名,这个包下的每一个类创建一个默认的别名,就是简单类名小写.
<typeAliases>
<pageage name="com.atguigu.bean"/>
</typeAliases>
3. 也可以使用@Alias注解为其制定一个别名
@Alias("emp")
public class Employee{}
- Mybatis-config.xml配置
<!-- 3、typeAliases：别名处理器：可以为我们的java类型起别名
别名不区分大小写,有三种取别名的方式
-->
<typeAliases>
<!-- 第一种、typeAlias:为某个java类型起别名
type:指定要起别名的类型全类名;默认别名就是类名(不区分大小写):employee
alias:指定新的别名
-->
<!-- <typeAlias type="com.atguigu.mybatis.bean.Employee"/> -->
<!-- 第二种、package:为某个包下的所有类批量起别名
name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名不区分大小写）
弊端:因为是统一起别名,如果多个包下有相同的类,该方式的别名会识别不出来具体是哪个包下的类.
-->
<package name="com.atguigu.mybatis.bean"/>
<!-- 第三种、批量起别名的情况下，使用@Alias注解为某个类型指定新的别名,可以解决第二步批量起别名的弊端 -->
</typeAliases>
package com.atguigu.mybatis.bean;
import org.apache.ibatis.type.Alias;
@Alias(value="emp")
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
public Integer getId() {
return id;
}
<?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.atguigu.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识,取接口的方法名称:public Employee getEmpById(Integer id);
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
-->
<select id="getEmpById" resultType="emp">
<!-- select id,last_name lastName,email,gender from tbl_employee where id = #{id} -->
select * from tbl_employee where id = #{id}
</select>
</mapper>
3.4.5 typeHandlers类型处理器简介
- 日期和时间的处理,JDK1.8以前一直是个头疼的问题.我们通常使用JSR310规范领导者Stephen Colebourne创建Joda-Time来操作.1.8已经实现全部的JSR310规范了.
- 日期时间处理上,我们可以使用Mybatis基于JSR310(Date and Time API)编写的各种日期
时间类型处理器.- Mybaits3.4以前的版本需要我们手动注册这些处理器,以后的版本都是自动注册的.
自定义类型处理器
- 我们可以重写类型处理器或创建自己的类型处理器来处理不支持的或非标准的类型.
- 步骤:
1). 实现org.apache.ibatis.type.TypeHandler接口或者继承org.apache.ibatis.type.BeanTypeHandler
2). 指定其映射某个JDBC类型(可选操作).
3). 在mybatis全局配置文件中注册.
3.4.6 plugins插件简介
- 插件是Mybatis提供了一个非常强大的机制,我们可以通过插件来修改Mybatis的一些核心行为.
插件通过动态代理机制,可以介入四大对象的任何一个方法的执行.后面会有专门的章节我们来介绍Mybatis运行原理的以及插件.- Executor(update,query,flushStatements,commit,rollback,getTransaction,close,isClosed)
- ParameterHandler(getParameterObject,setParameters)
- ResultSetHandler(handleResultSets,handleOutputParameters)
- StatementHandler(prepare,parameterize,batch,update,query)
environments环境
- Mybatis可以配置多种环境,比如开发,测试和生产环境需要有不同的配置.
- 每种环境使用一个environment标签进行配置并指定唯一标识符.
- 可以通过environments标签中的default属性指定一个环境的标识符来快速的切换环境.
environment - 指定具体环境
id: 指定当前环境的唯一表示
transactionManager和dataSource都必须有
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
transactionManager
type: JDBC | MANAGER | 自定义
JDBC: 使用了JDBC的提交和回滚设置,依赖于从数据源得到的连接来管理事务范围
JdbcTransactionFactory
MANAGER: 不提交或回滚一个连接,让容器来管理事务的整个生命周期(比如JEE应用服务器的上下文)
ManagedTransactionFactory
自定义: 实现TransactionFactory接口,type=全类名/别名.
dataSource
type: UNPOOLED | POOLED | JNDI | 自定义
- UNPOOLED: 不使用连接池,UnpooledDataSourceFactory.
- POOLED: 使用连接池,PooledDataSourceFactory.
- JNDI: 在EJB或应用服务器这类容器中查找指定的数据源.
- 自定义: 实现DataSourceFactory接口,定义数据源的获取方式.
实际开发中我们使用Spring历数据源,并进行事务控制的配置来覆盖上述配置.
-
代码示例
- 数据库配置
#mysql jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/mybatis jdbc.username=root jdbc.password=root #Oracle orcl.driver=oracle.jdbc.OracleDriver orcl.url=jdbc:oracle:thin:@localhost:1521:orcl orcl.username=scott orcl.password=123456- mybatis-config.xml配置
<!-- 4.environments:环境们,mybatis可以配置多种环境,default指定使用某种环境,可以达到快速切换环境. environment:配置一个具体的环境信息,必须有两个标签:id代表当前环境的唯一标识 transactionManager:事务管理器 type:事务管理器的类型 JDBC(JdbcTransactionFactory) managed(ManagedTransactionFactory) 自定义事务管理器:实现TransactionFactory接口.type指定为全类名 dataSource:数据源 type:数据源类型: UNPOOLED(UnpooledDataSourceFactory) POOLED(PooledDataSourceFactory) JNDI(JndiDataSourceFactory) 自定义数据源：实现DataSourceFactory接口，type是全类名 --> <environments default="dev_mysql"> <environment id="dev_mysql"> <transactionManager type="JDBC" /> <dataSource type="POOLED"> <!-- ${jdbc.driver}获取dbconfig.properties属性文件中的值 --> <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> <environment id="dev_oracle"> <transactionManager type="JDBC" /> <dataSource type="POOLED"> <!-- ${jdbc.driver}获取dbconfig.properties属性文件中的值 --> <property name="driver" value="${orcl.driver}"/> <property name="url" value="${orcl.url}"/> <property name="username" value="${orcl.username}"/> <property name="password" value="${orcl.password}"/> </dataSource> </environment> </environments>
3.4.7 databaseldProvider多数据库支持
databaseldProvider环境
1. Mybatis可以根据不同的数据库厂商执行不同的语句.
<databaseIdProvider type="DB_VENDDR">
<property name="MySQL" value="mysql" />
<property name="Oracle" value="oracle" />
<property name="SQL Server" value="sqlserver" />
</databaseIdProvider>
2. Type: DB_VENDDR
- 使用MyBatis提供的VendorDatabaseldProvider解析数据库厂商标识.也可以使用实现DatabaseldProvider接口来自定义.
3. Property-name: 数据库厂商标识.
4. Property-value: 为标识起一个别名,方便SQL语句使用databaseld属性引用.
- 代码示例
<!--5.databaseIdProvider:支持多数据厂商的
type="DB_VENDOR"：VendorDatabaseIdProvider
作用就是得到数据库厂商的标识(也就是驱动,通过getDatabaseProductName()可以获取标识),
mybatis就能根据数据库厂商标识来执行不同的sql.
各厂商标识:MySQL,Oracle,SQL Server
-->
<databaseIdProvider type="DB_VENDOR">
<!-- 为不同的数据库厂商起别名 -->
<property name="MySQL" value="mysql"/>
<property name="Oracle" value="oracle"/>
<property name="SQL Server" value="sqlserver"/>
</databaseIdProvider>
<?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.atguigu.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识,取接口的方法名称:public Employee getEmpById(Integer id);
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
-->
<select id="getEmpById" resultType="emp">
<!-- select id,last_name lastName,email,gender from tbl_employee where id = #{id} -->
select * from tbl_employee where id = #{id}
</select>
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
databaseId="mysql">
select * from tbl_employee where id = #{id}
</select>
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
databaseId="oracle">
select EMPLOYEE_ID id,LAST_NAME lastName,EMAIL email
from employees where EMPLOYEE_ID=#{id}
</select>
</mapper>
3.4.8 mappers映射注册
1. mapper逐个注册SQL映射文件
<mappers>
<mapper resource="mybatis/mapper/PersonDao.xml"/>
<mapper url="file:///D:/UserDao.xml" />
<mapper class="com.atguigu.dao.PersonDaoAnnotation" />
</mappers>
2. 或者使用批量注册: 这种方式要求SQL映射文件名必须和接口名相同并且在同一个目录下.
<mappers>
<package name="com.atguigu.dao" />
</mappers>
- 代码示例
将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中
<mappers>
<!-- 6、mappers：将sql映射注册到全局配置中 -->
<!--
mapper:注册一个sql映射
注册配置文件:
resource：引用类路径下的sql映射文件
mybatis/mapper/EmployeeMapper.xml
url：引用网路路径或者磁盘路径下的sql映射文件
file:///var/mappers/AuthorMapper.xml
注册接口
class：引用（注册）接口，
1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
2、没有sql映射文件，所有的sql都是利用注解写在接口上;
推荐：
比较重要的，复杂的Dao接口我们来写sql映射文件
不重要，简单的Dao接口为了开发快速可以使用注解；
-->
<mapper resource="EmployeeMapper.xml" />
<!-- 如果xml文件和java文件不再一起,配置时需要配置全路径 -->
<!-- <mapper resource="mybatis/mapper/EmployeeMapper.xml"/> -->
<!-- 接口注册 -->
<mapper class="com.atguigu.mybatis.dao.EmployeeMapperAnnotation"/>
<!-- 批量注册,使用包扫描的方式,需要将xml文件和java文件放在一起,且名称一样 -->
<!-- <package name="com.atguigu.mybatis.dao"/> -->
</mappers>
package com.atguigu.mybatis.dao;
import org.apache.ibatis.annotations.Select;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapperAnnotation {
@Select("select * from tbl_employee where id=#{id}")
public Employee getEmpById(Integer id);
}
第四章 Mybatis映射文件
映射文件指导着Mybatis如何进行数据库增删改查,有着非常重要的意义:
- cache: 命名空间的二级缓存配置.
- cache-ref: 其他命名空间缓存配置的引用.
- resultMap: 自定义结果集映射.
- parameterMap: 已废弃,老风格的参数映射.
- sql: 抽取可重用语句块.
- insert: 映射插入语句.
- update: 映射更新语句.
- delete: 映射删除语句.
- select: 映射查询语句.
4.1 主键生成方式
1. 若数据库支持自动生成主键的字段(比如MySQL和SQL Server),则可以设置useGeneratedKeys="true",然后再把keyProperty设置到目标属性上.
<insert id="insertCutomer" databaseId="mysql" useGeneratedKeys="true" key property="id">
insert into customers2(lash_name,email,age) Value(#{lastName},#{email},#{age})
</insert>
- 代码示例
public Long addEmp(Employee employee);
<!-- parameterType：参数类型，可以省略，
获取自增主键的值：
mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
useGeneratedKeys="true"；使用自增主键获取主键值策略
keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性
-->
<insert id="addEmp" parameterType="com.atguigu.mybatis.bean.Employee"
useGeneratedKeys="true" keyProperty="id"
>
insert into tbl_employee(last_name,email,gender)
values(#{lastName},#{email},#{gender})
</insert>
@Data
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
}
/**
* 测试增删改
* 1、mybatis允许增删改直接定义以下类型返回值:Integer、Long、Boolean、void
* 2、我们需要手动提交数据
* sqlSessionFactory.openSession();===>手动提交
* sqlSessionFactory.openSession(true);===>自动提交
*/
@Test
public void test03(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
//1.获取到的SqlSession不会自动提交数据
SqlSession openSession = sqlSessionFactory.openSession(true);
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
//测试添加
Employee employee = new Employee(null, "chentf", "chentf@ctf.com", "1");
mapper.addEmp(employee);
System.out.println(employee.getId());
//测试修改
//Employee employee = new Employee(3, "liuqiong", "liuqiong@163.com", "0");
//boolean updateEmp = mapper.updateEmp(employee);
//System.out.println(updateEmp);
//测试删除
mapper.deleteEmpById(3);
//2.手动提交数据
//openSession.commit();
} catch (Exception e) {
// TODO: handle exception
}finally{
openSession.close();
}
}
4.2 insert获取非自增主键的值(selectKey)
主键生成方式
1. 而对于不支持自增型主键的数据库(Oralce),则可以使用selectKey子元素.
selectKey元素将会首先运行,id会被设置,然后插入语句会被调用.
<insert id="inserCustomer" databaseId="oracle" parameterType="customer">
<selectKey order="BEFORE" keyProperty="id" resultType="_int">
select crm_seq.nextval from dual
</selectKey>
insert into customer2(id,last_name,email,age)
value(#{id},#{lastName},#{email},#{age})
</insert>
- 代码示例
<!--
获取非自增主键的值:
Oracle不支持自增,Oracle使用序列来模拟自增
每次插入的数据的主键是从序列中拿到的值,如何获取到这个值呢!
-->
<insert id="addEmp" databaseId="oracle">
<!--
keyProperty:查出的主键值封装给javaBean的哪个属性.
order ="before":当前sql在查询sql之前运行
="after":当前sql在插入sql之后运行
resultType:查出的数据的返回值类型
before运行顺序:
先运行selectKey查询id的sql,查询id值封装给javaBean的id属性.
再运行插入的sql,就可以去除id属性对应的值.
after运行顺序:
先运行插入的sql(从序列中去除新值作为id).
再运行selectKey查询id的sql.
-->
<selectKey keyProperty="id" order="BEFORE" resultType="Integer">
<!-- 编写查询主键的sql语句 -->
<!-- before: -->
select employees_seq.nextval from dual
<!-- after: -->
<!-- select employees_seq.currval from dual -->
</selectKey>
<!-- 插入时的主键是从序列中拿到的 -->
<!-- before: -->
insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
values(#{id},#{lastName},#{email<!-- ,jdbcType=NULL -->})
<!-- AFTER：
insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL)
values(employees_seq.nextval,#{lastName},#{email})
-->
</insert>
4.3 参数传递
- 单个参数
单个参数: Mybtis不会做特殊处理.
#{参数名/任意名}: 取出参数值
- 多个参数
多个参数:Mybatis会特殊处理.
多个参数会被封装成一个map.
key: param1,param2…paramN,或者参数的索引也可以.
value: 传入的参数值.
#{} 就是从map中获取指定的key的值,并且key必须parma1,param2...paramN或者索引,否则会报如下的异常:
org.apache.ibatis.binding.BindingException: Parameter 'id' not found. Available parameters are [1, 0, param1, param2]
- 代码实例
public Employee getEmpByIdAndLastName(Integer id,String lastName);
<select id="getEmpByIdAndLastName" resultType="com.atguigu.mybatis.bean.Employee" databaseId="mysql">
select * from tbl_employee where id = #{param1} and last_name=#{param2}
</select>
@Test
public void test04(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
//1.获取到的SqlSession不会自动提交数据
SqlSession openSession = sqlSessionFactory.openSession(true);
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Employee employee = mapper.getEmpByIdAndLastName(1, "张三");
System.out.println(employee);
} catch (Exception e) {
}finally{
openSession.close();
}
注意: 如果不想通过param1,param2…paramN或者索引等固定值接收参数,可以在接口方法上指定接收参数的属性值,使用下面的命名cas的方式.
- 命名参数
明确指定封装参数时map的key : @Param(“id”).
多个参数会被封装成一个map.
key: 使用@Param注解指定的值.
value: 参数值.
#{指定的key}取值对应的参数
- 代码示例
public Employee getEmpByIdAndLastName1(@Param("id")Integer id,@Param("lastName")String lastName);
<select id="getEmpByIdAndLastName1" resultType="com.atguigu.mybatis.bean.Employee" databaseId="mysql">
select * from tbl_employee where id = #{id} and last_name=#{lastName}
</select>
@Test
public void test04(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
//1.获取到的SqlSession不会自动提交数据
SqlSession openSession = sqlSessionFactory.openSession(true);
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
//Employee employee = mapper.getEmpByIdAndLastName(1, "张三");
Employee employee = mapper.getEmpByIdAndLastName1(1, "张三");
System.out.println(employee);
} catch (Exception e) {
}finally{
openSession.close();
}
}
- POJO
如果多个参数正好是我们业务逻辑的数据模型,我们就可以直接传入POJO.
#{属性值}: 取出传入的pojo的属性值.
- map:
如果多个参数不是业务模型中的数据,没有对应的pojo,不经常使用,为了方便,我们也可以传入map.
#{key}: 取出map中对应的值.
- 代码示例
public Employee getEmpByMap(Map<String, Object> map);
<!-- public Employee getEmpByMap(Map<String, Object> map); -->
<select id="getEmpByMap" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where id=${id} and last_name=#{lastName}
</select>
@Test
public void test05(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
//1.获取到的SqlSession不会自动提交数据
SqlSession openSession = sqlSessionFactory.openSession(true);
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Map<String, Object> map = new HashMap<String, Object>();
map.put("id", 1);
map.put("lastName", "张三");
Employee employee = mapper.getEmpByMap(map);
System.out.println(employee);
} catch (Exception e) {
}finally{
openSession.close();
}
}
如果多个参数不是业务模型中的数据,但是经常要使用,推荐来编写一个To(Transfer Object)数据传输对象.
- 参数传递思考及源码分析
public Employee getEmp(@Param("id")Integer id,String lastName);
取值：id==>#{id/param1} lastName==>#{param2}
public Employee getEmp(Integer id,@Param("e")Employee emp);
取值：id==>#{param1} lastName===>#{param2.lastName/e.lastName}
##特别注意：如果是Collection（List、Set）类型或者是数组，也会特殊处理。
也是把传入的list或者数组封装在map中。
key：Collection（collection）,如果是List还可以使用这个key(list)
数组(array)
public Employee getEmpById(List<Integer> ids);
取值：取出第一个id的值： #{list[0]}
===================结合源码，mybatis怎么处理参数======================
总结：参数多时会封装map，为了不混乱，我们可以使用@Param来指定封装时使用的key；
#{key}就可以取出map中的值；
(@Param("id")Integer id,@Param("lastName")String lastName);
ParamNameResolver解析参数封装map的；
//1、names：{0=id, 1=lastName}；构造器的时候就确定好了
确定流程：
1.获取每个标了param注解的参数的@Param的值：id，lastName；赋值给name;
2.每次解析一个参数给map中保存信息：（key：参数索引，value：name的值）
name的值：
标注了param注解：注解的值
没有标注：
1.全局配置：useActualParamName（jdk1.8）：name=参数名
2.name=map.size()；相当于当前元素的索引
{0=id, 1=lastName,2=2}
args【1，"Tom",'hello'】:
public Object getNamedParams(Object[] args) {
final int paramCount = names.size();
//1、参数为null直接返回
if (args == null || paramCount == 0) {
return null;
//2、如果只有一个元素，并且没有Param注解；args[0]：单个参数直接返回
} else if (!hasParamAnnotation && paramCount == 1) {
return args[names.firstKey()];
//3、多个元素或者有Param标注
} else {
final Map<String, Object> param = new ParamMap<Object>();
int i = 0;
//4、遍历names集合；{0=id, 1=lastName,2=2}
for (Map.Entry<Integer, String> entry : names.entrySet()) {
//names集合的value作为key; names集合的key又作为取值的参考args[0]:args【1，"Tom"】:
//eg:{id=args[0]:1,lastName=args[1]:Tom,2=args[2]}
param.put(entry.getValue(), args[entry.getKey()]);
// add generic param names (param1, param2, ...)param
//额外的将每一个参数也保存到map中，使用新的key：param1...paramN
//效果：有Param注解可以#{指定的key}，或者#{param1}
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
// ensure not to overwrite parameter named with @Param
if (!names.containsValue(genericParamName)) {
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}
}
4.4 参数处理
1. 参数位置支持的属性
javaType,jdbcType,mode,numericScale,resultMap,typeHandle,jdbcTypeName,expression
2. 实际上通常被设置的是: 可能为空的列名指定jdbcType.
3. #{key}: 获取参数的值,预编译到SQL中,安全.
4. ${key}: 获取参数的值,拼接道SQL中.有SQL注入问题.ORDER BY ${name}
1. 参数也可以指定一个特殊的数据类型:
#{property,javaType,jdbcType=NUMERIC}
#{height,javaType=double,jdbcType=NUMERIC,numericScale=2}
2. javaType通常可以从参数对象中来去确定.
3. 如果null被当做值传递,对于所有可能为空的列,jdbcType需要被设置.
4. 对于数值类型,还可以设置小数点后保留的位数.
5. model属性允许指定in,out或者inout参数.如果参数为out或者inout,参数对象属性的真实值将会被改变,就像在获取输出参数时所期望的那样.
1. #{}: 可以获取map中的值或者pojo对象属性的值.
2. ${}: 可以获取map中的值或者pojo对象属性的值.
select * from tbl_employee where id=${id} and last_name=#{lastName}
Preparing: select * from tbl_employee where id=2 and last_name='chentengfei'
区别:
1. #{}: 是预编译的形式,将参数设置到sql预警中,PreparedStatement,防止sql注入.
2. ${}: 取出的值直接拼装在sql语句中,会有安全问题.
大多情况下,我们去参数的值都应该使用#{}.
原生jdbc不支持占位符的地方,我们就可以使用${}进行取值,比如分表,排序...
例如:按照年份分表拆分:
select * from ${year}_salary where xxx;
select * from tbl_employee order by ${f_name} ${order}
#{}更丰富的用法:
规定参数的一些规则:
javaType,jdbcType,mode(存储过程),numericScale,resultMap,typeHandle,jdbcTypeName,expression(未来准备支持的功能).
jdbcType通常需要在某种特定的条件下被设置: 在我们数据未null的时候,有些数据库可能不能识别Mybatis对null默认处理,比如Oracle(会报错).
jdbcType other: 无效的类型,因为Mybaits对所有的null都映射的是原生jdbc的OTHER类型,oracle不能正确处理.
由于全局配置中,jdbcTypeForNull=OTHER,oracle并不支持,可以用以下两种办法解决:
1. #{email,jdbcType=OTHER}
2.jdbcTypeForNull=NULL
<setting name="jdbcTypeForNull" value="NULL" />
第五章 select元素
select元素
1. select元素用来定义查询操作.
id: 唯一标识符.
- 用来引用这条语句,需要和接口的方法名一致.
parameterType: 参数类型.
- 可以不穿,Mybatis会根据TypeHandler自动推断.
resultType: 返回值类型.
- 别名或者全类名,如果返回的是集合,定义集合中原色的类型.不能和resultMap同时使用.
5.1 select元素代码示例
- select查询返回Llist
public List<Employee> getEmpsByLastNameLike(String lastName);
<!--resultType：如果返回的是一个集合，要写集合中元素的类型,此处返回的是Employee对象-->
<select id="getEmpsByLastNameLike" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where last_name like #{lastName}
</select>
@Test
public void test06(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
//1.获取到的SqlSession不会自动提交数据
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
List<Employee> nameLike = mapper.getEmpsByLastNameLike("%c%");
for(Employee employee : nameLike){
System.out.println(employee);
}
} catch (Exception e) {
}finally{
openSession.close();
}
}
执行结果:
Employee [id=4, lastName=chentf, email=chentf@ctf.com, gender=1]
Employee [id=5, lastName=chentf11, email=chentf@ctf.com, gender=1]
- select记录封装map
//返回一条记录的map；key就是列名，值就是对应的值
public Map<String, Object> getEmpByIdReturnMap(Integer id);
<!--如果返回值是map类型,resultType直接写map,Mybatis底层会将数据封装成map集合.-->
<select id="getEmpByIdReturnMap" resultType="map">
select * from tbl_employee where id=#{id}
</select>
@Test
public void test07(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Map<String, Object> returnMap = mapper.getEmpByIdReturnMap(1);
System.out.println(returnMap);
} catch (Exception e) {
}finally{
openSession.close();
}
}
- select记录封装map(返回多条记录)
@MapKey: 告诉Mybatis封装这个map的时候使用哪个属性作为map的key.
//多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean
//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
@MapKey("lastName")
public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);
<select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where last_name like #{lastName}
</select>
@Test
public void test08(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Map<String, Employee> map = mapper.getEmpByLastNameLikeReturnMap("%c%");
System.out.println(map);
} catch (Exception e) {
}finally{
openSession.close();
}
}
5.2 select_resultMap_自定义结果映射规则
1. 全局setting设置
- autoMappingBehavior默认是PARTIAL,开启自动映射的功能.唯一的要求是列名和javaBean属性名一致.
- 如果autoMappingBehavior设置为null则会取消自动映射.
- 数据库字段命名规范,POJO属性符合驼峰命名法,如A_CCLUMN -> aColumn,我们可以开启自动驼峰命名规则映射功能,mapUnderscoreToCameCase=true.
2. 自定义resultMap,实现高级结果集映射.
resultMap
1. constructor: 类在实例化时,用来注入结果到构造方法中.
- idArg: ID参数,标记结果作为ID可以帮助提供整体效能.
- arg: 注入到构造方法的一个普通结果.
2. id: 一个ID结果,标记结果作为ID可以帮助提供整体效能.
3. result: 注入到字段或者javaBean属性的普通结果.
4. association: 一个复杂的类型关联,许多结果将包成这种类型.
- 嵌入结果映射,结果映射吱声的关联,或者参考一个.
5. collection: 复杂类型的集
- 嵌入结果映射,结果映射自身的集,或者参考一个.
6. dicriminator: 使用结果值类决定使用哪个结果映射.
- case: 基于某些值的结果映射.
* 嵌入结果映射: 这种情形结果也映射它本身,incident可以包含很多相同的元素,或者它可以参照一个外部的几个映射.
id & result
1. id和result映射一个单独列的值到简单数据类型(字符串,整型,双精度浮点型,日期等)的属性或字段.
- 代码示例
//创建接口EmployeeMapperPlus,定义接口方法getEmpById()
public interface EmployeeMapperPlus {
public Employee getEmpById(Integer id);
}
<!--注意resultMap和resultType不能同时使用-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MySimpleEmp">
<!--
指定主键列的封装规则:
id 定义主键,底层会有优化
column:指定数据库的列
property:指定对应的javaBean属性
-->
<id column="id" property="id"/>
<!-- 定义普通列封装规则 -->
<result column="last_name" property="lastName"/>
<!-- 其他不指定的列会自动封装,但是我们只要写resultMap,一般会把全部的映射规则都写上. -->
<result column="email" property="email"/>
<result column="gender" property="gender"/>
</resultMap>
<!-- resultMap:自定义结果集映射规则； -->
<select id="getEmpById" resultMap="MySimpleEmp">
select * from tbl_employee where id=#{id}
</select>
//测试类
@Test
public void test09(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
Employee employee = mapper.getEmpById(1);
System.out.println(employee);
} catch (Exception e) {
}finally{
openSession.close();
}
}
5.3 select_resultMap_关联查询
#创建tbl_dept表
CREATE TABLE tb1_dept(
id INT(11) PRIMARY KEY AUTO_INCREMENT,
dept_name VARCHAR(255)
)
#在tbl_employee表中新增列
ALTER TABLE tbl_employee ADD COLUMN d_id INT(11);
#建立外键关联关系
ALTER TABLE tbl_employee ADD CONSTRAINT fk_emp_dept
FOREIGN KEY(d_id) REFERENCES tbl_dept(id)
- 级联属性封装结果
association
复杂对相关映射
POJO中的属性可能会是一个对象
我们可以使用联合查询,并以级联的方式封装对象
> <resultMap type = "com.atguigu.bean.Lock" id = "myLock">
> <id column = "id" property = "id"/>
> <result column = "lockName" property = "lockName" />
> <result column = "key_id" property = "key.id" />
> <result column = "keyName" property = "key.keyName" />
> </resultMap>
- 使用association标签定义对象的封装规则
- 定义javaBean对象Employee
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
private Department dept;
}
- 定义javaBean对象
public class Department {
private Integer id;
private String departmentName;
}
- 定义接口及接口方法
package com.atguigu.mybatis.dao;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapperPlus {
public Employee getEmpById(Integer id);
public Employee getEmpAndDept(Integer id);
}
-
编写xml映射文件
第一种方式: 使用级联属性封装结果集
<!--
场景一：
查询Employee的同时查询员工对应的部门
Employee===Department
一个员工有与之对应的部门信息；
id last_name gender d_id did dept_name (private Department dept;)
-->
<!--
联合查询：级联属性封装结果集
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<result column="did" property="dept.id"/>
<result column="dept_name" property="dept.departmentName"/>
</resultMap>
<!-- public Employee getEmpAndDept(Integer id); -->
<select id="getEmpAndDept" resultMap="MyDifEmp">
SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
d.id did,d.dept_name dept_name
FROM tbl_employee e,tbl_dept d
WHERE e.d_id=d.id AND e.id=#{id}
</select>
- 编写测试类
@Test
public void test10(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
Employee employee = mapper.getEmpAndDept(1);
System.out.println(employee);
System.out.println(employee.getDept());
} catch (Exception e) {
}finally{
openSession.close();
}
}
-
编写xml映射文件
第二种方式: 使用association定义关联的单个对象的封装规则
<!--
使用association定义关联的单个对象的封装规则；
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp2">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<!-- association可以指定联合的javaBean对象
property="dept"：指定哪个属性是联合的对象
javaType:指定这个属性对象的类型[不能省略]
-->
<association property="dept" javaType="com.atguigu.mybatis.bean.Department">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
</association>
</resultMap>
<!-- public Employee getEmpAndDept(Integer id); -->
<select id="getEmpAndDept" resultMap="MyDifEmp2">
SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
d.id did,d.dept_name dept_name
FROM tbl_employee e,tbl_dept d
WHERE e.d_id=d.id AND e.id=#{id}
</select>
- 编写javaBean文件Employee.java
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
private Department dept;
}
- 编写javaBean文件Department.java
public class Department {
private Integer id;
private String departmentName;
}
- 编写接口文件DepartmentMapper.java
public interface DepartmentMapper {
public Department getDeptById(Integer id);
}
- 编写DepartmentMapper.java对应的映射文件DepartmentMapper.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.atguigu.mybatis.dao.DepartmentMapper">
<!-- public Department getDeptById(Integer id); -->
<select id="getDeptById" resultType="com.atguigu.mybatis.bean.Department">
select id,dept_name departmentName from tbl_dept where id=#{id}
</select>
</mapper>
- 编写EmployeeMapperPlus.java对应的映射文件EmployeeMapperPlus.xml
<!-- 使用association进行分步查询：
1、先按照员工id查询员工信息
2、根据查询员工信息中的d_id值去部门表查出部门信息
3、部门设置到员工中；
-->
<!-- id last_name email gender d_id -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!-- association定义关联对象的封装规则
select:表明当前属性是调用select指定的方法查出的结果
column:指定将哪一列的值传给这个方法
流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
-->
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</resultMap>
<!-- public Employee getEmpByIdStep(Integer id); -->
<select id="getEmpByIdStep" resultMap="MyEmpByStep">
select * from tbl_employee where id=#{id}
</select>
- 编写测试用例
@Test
public void test10(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
//Employee employee = mapper.getEmpAndDept(1);
Employee employee = mapper.getEmpByIdStep(2);
System.out.println(employee);
System.out.println(employee.getDept());
} catch (Exception e) {
}finally{
openSession.close();
}
}
- 在mybatis-config.xml配置全局属性
<!-- 设置是否开启驼峰命名法则,默认是false -->
<settings>
<!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 关闭按需加载的配置,默认是true -->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
- 创建javaBean文件Department.java
public class Department {
private Integer id;
private String departmentName;
private List<Employee> emps;
}
- 创建接口类DepartmentMapper.java并定义接口方法
public interface DepartmentMapper {
public Department getDeptByIdPlus(Integer id);
}
- 编写DepartmentMapper.java对应的映射文件DepartmentMapper.xml
<!--
public class Department {
private Integer id;
private String departmentName;
private List<Employee> emps;
did dept_name || eid last_name email gender
-->
<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="myDept">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
<!--
collection定义关联集合类型的属性的封装规则
ofType:指定集合里面元素的类型
-->
<collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
<!-- 定义这个集合中元素的封装规则 -->
<id column="eid" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
</collection>
</resultMap>
<!-- public Department getDeptByIdPlus(Integer id); -->
<select id="getDeptByIdPlus" resultMap="myDept">
SELECT d.id did,d.dept_name dept_name,
e.id eid,e.last_name last_name,e.email email,e.gender gender
FROM tbl_dept d
LEFT JOIN tbl_employee e ON d.id=e.d_id
WHERE d.id=#{id}
</select>
- 编写EmployeeMapperPlus.java接口对应的方法
package com.atguigu.mybatis.dao;
import java.util.List;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapperPlus {
public List<Employee> getEmpsByDeptId(Integer deptId);
}
- 编写EmployeeMapperPlus.java类对应的映射文件
<!--
场景二：
查询部门的时候将部门对应的所有员工信息也查询出来：注释在DepartmentMapper.xml中
-->
<!-- public List<Employee> getEmpsByDeptId(Integer deptId); -->
<select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where d_id=#{deptId}
</select>
- 编写DepartmentMapper.java接口对应的方法
package com.atguigu.mybatis.dao;
import com.atguigu.mybatis.bean.Department;
public interface DepartmentMapper {
public Department getDeptByIdStep(Integer id);
}
- 编写DepartmentMapper.java对应的映射文件
<!-- collection：分段查询 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
<id column="id" property="id"/>
<id column="dept_name" property="departmentName"/>
<collection property="emps"
select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
column="{deptId=id}" fetchType="lazy"></collection>
</resultMap>
<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
select id,dept_name from tbl_dept where id=#{id}
</select>
<!-- 扩展：多列的值传递过去：
将多列的值封装map传递；
column="{key1=column1,key2=column2}"
fetchType="lazy"：表示使用延迟加载；
- lazy：延迟
- eager：立即
-->
- 测试用例
@Test
public void test12() throws IOException{
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
Department deptByIdPlus = mapper.getDeptByIdStep(2);
System.out.println(deptByIdPlus);
System.out.println(deptByIdPlus.getEmps());
}finally{
openSession.close();
}
}
- 映射文件_select_resultMap_discriminator鉴别器(一般不使用)
<!-- =======================鉴别器============================ -->
<!-- <discriminator javaType=""></discriminator>
鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
封装Employee：
如果查出的是女生：就把部门信息查询出来，否则不查询；
如果是男生，把last_name这一列的值赋值给email;
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!--
column：指定判定的列名
javaType：列值对应的java类型 -->
<discriminator javaType="string" column="gender">
<!--女生 resultType:指定封装的结果类型；不能缺少。/resultMap-->
<case value="0" resultType="com.atguigu.mybatis.bean.Employee">
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</case>
<!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
<case value="1" resultType="com.atguigu.mybatis.bean.Employee">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="last_name" property="email"/>
<result column="gender" property="gender"/>
</case>
</discriminator>
</resultMap>
5.4 动态sql
- 动态sql是MyBatis强大特性之一.极大的简化我们拼装sql的操作.
- 动态sql元素和使用JSTL或者其他类似基于XML的文本处理器相似.
- MyBatis采用功能强大的基于OGNL的表达式来简化操作.
- if
- choose (when , otherwise)
- trim (where , set)
- foreach
5.4.1 动态sql_if_判断
- 编写接口类EmployeeMapperDynamicSQL.java及对应的方法
package com.atguigu.mybatis.dao;
import java.util.List;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapperDynamicSQL {
//携带了哪个字段查询条件就带上这个字段的值
public List<Employee> getEmpsByConditionIf(Employee employee);
}
- 编写EmployeeMapperDynamicSQL.java文件对应的映射文件
<?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.atguigu.mybatis.dao.EmployeeMapperDynamicSQL">
<!--
• if:判断
• choose (when, otherwise):分支选择；带了break的swtich-case
如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个
• trim 字符串截取(where(封装查询条件), set(封装修改条件))
• foreach 遍历集合
-->
<!-- 查询员工，要求，携带了哪个字段查询条件就带上这个字段的值 -->
<!-- public List<Employee> getEmpsByConditionIf(Employee employee); -->
<select id="getEmpsByConditionIf" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!-- where有两种方式,第一种可以直接在sql后面加where 1=1来拼接,另一种就是使用下面的where标签 -->
<where>
<!-- test：判断表达式（OGNL）OGNL参照PPT或者官方文档。
c:if test 从参数中取值进行判断
遇见特殊符号应该去写转义字符：例如&&,""等.
-->
<!-- test="id"取得就是方法中传过来的id值 -->
<if test="id">
id=#{id}
</if>
<!-- &&需要使用转义字符&&, ""需要使用转义字符""-->
<if test="lastName!=null && lastName!=""">
and last_name like #{lastName}
</if>
<if test="email!=null and email.trim()!=""">
and email=#{email}
</if>
<!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
<if test="gender==0 or gender==1">
and gender=#{gender}
</if>
</where>
</select>
</mapper>
- 测试用例
@Test
public void testDynamicSql(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
//查询的时候如果某些条件没带可能sql拼装会有问题
//1、给where后面加上1=1，以后的条件都and xxx.
//2、mybatis使用where标签来将所有的查询条件包括在内。mybatis就会将where标签中拼装的sql，多出来的and或者or去掉
//where只会去掉第一个多出来的and或者or。
EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
Employee employee = new Employee(null, "%e%", "chentf@ctf.com", null);
List<Employee> list = mapper.getEmpsByConditionIf(employee);
for (Employee emp : list) {
System.out.println(emp);
}
}finally{
openSession.close();
}
}
5.4.2 动态sql_trim_截取
- 编写接口类EmployeeMapperDynamicSQL.java及对应的方法
package com.atguigu.mybatis.dao;
import java.util.List;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapperDynamicSQL {
public List<Employee> getEmpsByConditionTrim(Employee employee);
}
- 编写EmployeeMapperDynamicSQL.java文件对应的映射文件
<!-- public List<Employee> getEmpsByConditionTrim(Employee employee); -->
<select id="getEmpsByConditionTrim" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!-- 前面多出来的第一个and,where标签可以自定忽略掉,但是后面多出的and或者or where标签不能解决
prefix="":前缀：trim标签体中是整个字符串拼串后的结果。
prefix给拼串后的整个字符串加一个前缀
prefixOverrides="":
前缀覆盖： 去掉整个字符串前面多余的字符
suffix="":后缀
suffix给拼串后的整个字符串加一个后缀
suffixOverrides=""
后缀覆盖：去掉整个字符串后面多余的字符
-->
<!-- 自定义字符串的截取规则 -->
<trim prefix="where" suffixOverrides="and">
<if test="id!=null">
id=#{id} and
</if>
<if test="lastName!=null && lastName!=""">
last_name like #{lastName} and
</if>
<if test="email!=null and email.trim()!=""">
email=#{email} and
</if>
<!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
<if test="gender==0 or gender==1">
gender=#{gender}
</if>
</trim>
</select>
注意：where标签和trim的区别用法在于and条件写在前面还是后面
5.4.3 动态sql_choose_分支选择
- 编写接口类EmployeeMapperDynamicSQL.java及对应的方法
package com.atguigu.mybatis.dao;
import java.util.List;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapperDynamicSQL {
public List<Employee> getEmpsByConditionChoose(Employee employee);
}
- 编写EmployeeMapperDynamicSQL.java文件对应的映射文件
<!-- public List<Employee> getEmpsByConditionChoose(Employee employee); -->
<select id="getEmpsByConditionChoose" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<where>
<!-- 如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个,同时满足两个when条件,之后进入第一个when -->
<choose>
<when test="id != null">
id=#{id}
</when>
<when test="lastName!=null">
last_name like #{lastName}
</when>
<when test="email!=null">
email = #{email}
</when>
<otherwise>
gender = 0
</otherwise>
</choose>
</where>
</select>
- 测试用例
@Test
public void testDynamicSql(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
//测试choose
EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
Employee employee = new Employee(null, "%e%", "chentf@ctf.com", "1");
List<Employee> list = mapper.getEmpsByConditionChoose(employee);
for (Employee emp : list) {
System.out.println(emp);
}
}finally{
openSession.close();
}
}
5.4.4 动态sql_set与if动态更新
- 编写接口类EmployeeMapperDynamicSQL.java及对应的方法
package com.atguigu.mybatis.dao;
import java.util.List;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapperDynamicSQL {
public void updateEmp(Employee employee);
}
- 编写EmployeeMapperDynamicSQL.java文件对应的映射文件
<!-- public void updateEmp(Employee employee); -->
<update id="updateEmp">
update tbl_employee
<!-- 第一种方式:Set标签的使用 -->
<set>
<if test="lastName!=null">
last_name=#{lastName},
</if>
<if test="email!=null">
email=#{email},
</if>
<if test="gender!=null">
gender=#{gender}
</if>
</set>
where id = #{id}
<!-- 第二种方式:不使用set标签,使用Trim标签更新拼串 -->
<!--
update tbl_employee
<trim prefix="set" suffixOverrides=",">
<if test="lastName!=null">
last_name=#{lastName},
</if>
<if test="email!=null">
email=#{email},
</if>
<if test="gender!=null">
gender=#{gender}
</if>
</trim>
where id=#{id}
-->
</update
- 测试用例
@Test
public void testDynamicSql(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
//测试set标签
EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
Employee employee = new Employee(4, "chentf", "chentf@ctf.com", "0");
mapper.updateEmp(employee);
openSession.commit();
}finally{
openSession.close();
}
}
5.4.5 动态sql_foreach
- 编写EmployeeMapperDynamicSQL.java对应的方法
//查询员工id'在给定集合中的
public List<Employee> getEmpsByConditionForeach(@Param("ids")List<Integer> ids);
- 编写EmployeeMapperDynamicSQL.java接口对应的映射文件
<!-- public List<Employee> getEmpsByConditionForeach(@Param("ids")List<Integer> ids); -->
<select id="getEmpsByConditionForeach" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!--
collection:指定要遍历的集合,list类型的参数会特殊处理封装在map中,map的key就叫list.
item:将当前遍历出的元素赋值给指定的变量.
separator:每一个元素之间使用何种分隔符.
open:遍历出所有结果拼接一个开始的字符.
close:遍历出所有结果拼接一个结束的字符.
index索引:遍历list的时候index就是索引,item就是当前的值.
遍历map的时候index表示的就是map的key,item就是map的值.
#{变量名}:就能取出变量的值也就是当前遍历出的元素.
-->
<foreach collection="ids" item="item_id" separator="," open=" where id in(" close=")">
#{item_id}
</foreach>
</select>
- 编写测试用例
@Test
public void testDynamicSql(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
List<Employee> empsByConditionForeach = mapper.getEmpsByConditionForeach(Arrays.asList(1,3));
for(Employee emp : empsByConditionForeach){
System.out.println(emp);
}
}finally{
openSession.close();
}
}
5.4.6 动态sql_foreach批量插入
- 编写EmployeeMapperDynamicSQL.java对应的接口方法
public void addEmps(@Param("emps")List<Employee> emps);
- 编写EmployeeMapperDynamicSQL.java中方法对应的映射文件代码
- 第一种保存方式:
<!-- 批量保存 -->
<!-- public void addEmps(@Param("emps")List<Employee> emps); -->
<!--MySQL下批量保存：可以foreach遍历 mysql支持values(),(),()语法-->
<insert id="addEmps">
insert into tbl_employee(last_name,email,gender,d_id)
values
<foreach collection="emps" item="emp" separator=",">
(#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
</foreach>
</insert>
- 第二种保存方式: 种方式需要增加数据库连接属性allowMultiQueries=true；表示支持插入语句使用分号分割
dbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true
<!-- 这种方式需要增加数据库数据库连接属性allowMultiQueries=true；表示支持插入语句使用分号分割.
这种分号分隔多个sql可以用于其他的批量操作（删除，修改） -->
<insert id="addEmps">
<foreach collection="emps" item="emp" separator=";">
insert into tbl_employee(last_name,email,gender,d_id)
values(#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
</foreach>
</insert>
- 测试用例
@Test
public void testBatchSave(){
SqlSessionFactory sqSessionFactory = getsqSessionFactory();
SqlSession openSession = sqSessionFactory.openSession();
try{
EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
List<Employee> emps = new ArrayList<Employee>();
emps.add(new Employee(null, "zhangsan", "zhangsan@163.com", "1",new Department(1)));
emps.add(new Employee(null, "lisi", "lisi@163.com", "1",new Department(1)));
mapper.addEmps(emps);
openSession.commit();
}finally{
openSession.close();
}
}
<!-- Oracle数据库批量保存：
Oracle不支持values(),(),()
Oracle支持的批量方式
1、多个insert放在begin - end里面
begin
insert into employees(employee_id,last_name,email)
values(employees_seq.nextval,'test_001','test_001@atguigu.com');
insert into employees(employee_id,last_name,email)
values(employees_seq.nextval,'test_002','test_002@atguigu.com');
end;
2、利用中间表：
insert into employees(employee_id,last_name,email)
select employees_seq.nextval,lastName,email from(
select 'test_a_01' lastName,'test_a_e01' email from dual
union
select 'test_a_02' lastName,'test_a_e02' email from dual
union
select 'test_a_03' lastName,'test_a_e03' email from dual
)
-->
<insert id="addEmps" databaseId="oracle">
<!-- oracle第一种批量方式 -->
<!-- <foreach collection="emps" item="emp" open="begin" close="end;">
insert into employees(employee_id,last_name,email)
values(employees_seq.nextval,#{emp.lastName},#{emp.email});
</foreach> -->
<!-- oracle第二种批量方式 -->
insert into employees(
<!-- 引用外部定义的sql -->
<include refid="insertColumn">
<property name="testColomn" value="abc"/>
</include>
)
<foreach collection="emps" item="emp" separator="union"
open="select employees_seq.nextval,lastName,email from("
close=")">
select #{emp.lastName} lastName,#{emp.email} email from dual
</foreach>
</insert>
5.4.7 动态sql_内置参数databaseId
- 编写EmployeeMapperDynamicSQL.java的接口方法
public List<Employee> getEmpTestInnerParameter(Employee employee);
- 编写EmployeeMapperDynamicSQL.java接口对应的映射文件
<!-- 两个内置参数：
不只是方法传递过来的参数可以被用来判断，取值。。。
mybatis默认还有两个内置参数：
_parameter:代表整个参数
单个参数：_parameter就是这个参数
多个参数：参数会被封装为一个map；_parameter就是代表这个map
_databaseId:如果全局配置文件配置了databaseIdProvider标签。
_databaseId就是代表当前数据库的别名oracle或者mysql
-->
<!-- public List<Employee> getEmpTestInnerParameter(Employee employee); -->
<select id="getEmpTestInnerParameter" resultType="com.atguigu.mybatis.bean.Employee">
<!-- _databaseId等于全局配置文件中配置的数据库value值.-->
<if test="_databaseId=='mysql'">
select * from tbl_employee
<!-- _parameter!=null内置参数代表控制层传递过来的参数,此处标识 Employee对象-->
<if test="_parameter!=null">
where last_name like #{_parameter.lastName}
</if>
</if>
<if test="_databaseId=='oracle'">
select * from employee
<if test="_parameter!=null">
where last_name like #{_parameter.lastName}
</if>
</if>
</select>
- 编写测试用例
@Test
public void EmpTestInnerParameter(){
SqlSessionFactory sqSessionFactory = getsqSessionFactory();
SqlSession openSession = sqSessionFactory.openSession();
try {
EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
Employee employee = new Employee();
employee.setLastName("%z%");
List<Employee> innerParameter = mapper.getEmpTestInnerParameter(employee);
for(Employee employee2 : innerParameter){
System.out.println(employee2);
}
} finally{
openSession.close();
}
}
5.4.8 动态sql_bind_绑定
bind：可以将OGNL表达式的值绑定到一个变量中，方便后来引用这个变量的值,例如传递的参数需要模糊查询,我们可以使用bind将参数进行转换绑定,一般不适用bind,直接前台传递的时候带%%
<!--public List<Employee> getEmpsTestInnerParameter(Employee employee); -->
<select id="getEmpsTestInnerParameter" resultType="com.atguigu.mybatis.bean.Employee">
<!-- bind：可以将OGNL表达式的值绑定到一个变量中，方便后来引用这个变量的值 -->
<bind name="_lastName" value="'%'+lastName+'%'"/>
<if test="_databaseId=='mysql'">
select * from tbl_employee
<if test="_parameter!=null">
where last_name like #{lastName}
</if>
</if>
<if test="_databaseId=='oracle'">
select * from employees
<if test="_parameter!=null">
where last_name like #{_parameter.lastName}
</if>
</if>
</select>
<!--
抽取可重用的sql片段。方便后面引用
1、sql抽取：经常将要查询的列名，或者插入用的列名抽取出来方便引用
2、include来引用已经抽取的sql：
3、include还可以自定义一些property，sql标签内部就能使用自定义的属性
include-property：取值的正确方式${prop},
#{不能使用这种方式}
-->
<sql id="insertColumn">
<if test="_databaseId=='oracle'">
employee_id,last_name,email
</if>
<if test="_databaseId=='mysql'">
last_name,email,gender,d_id
</if>
</sql>
<insert id="addEmps" databaseId="oracle">
<!-- oracle第一种批量方式 -->
<!-- <foreach collection="emps" item="emp" open="begin" close="end;">
insert into employees(employee_id,last_name,email)
values(employees_seq.nextval,#{emp.lastName},#{emp.email});
</foreach> -->
<!-- oracle第二种批量方式 -->
insert into employees(
<!-- 引用外部定义的sql -->
<include refid="insertColumn">
<property name="testColomn" value="abc"/>
</include>
)
<foreach collection="emps" item="emp" separator="union"
open="select employees_seq.nextval,lastName,email from("
close=")">
select #{emp.lastName} lastName,#{emp.email} email from dual
</foreach>
</insert>
第六章 Mybatis缓存
6.1 一级缓存
/**
* 两级缓存：
* 一级缓存：（本地缓存）：sqlSession级别的缓存。一级缓存是一直开启的；SqlSession级别的一个Map
* 与数据库同一次会话期间查询到的数据会放在本地缓存中。
* 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；
*
* 一级缓存失效情况（没有使用到当前一级缓存的情况，效果就是，还需要再向数据库发出查询）：
* 1、sqlSession不同。
* 2、sqlSession相同，查询条件不同.(当前一级缓存中还没有这个数据)
* 3、sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)
* 4、sqlSession相同，手动清除了一级缓存（缓存清空）
*
* 二级缓存：
* @throws IOException
*/
@Test
public void testFirstLevelCache() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Employee emp01 = mapper.getEmpById(1);
System.out.println(emp01);
//xxxxx
//1、sqlSession不同。
//SqlSession openSession2 = sqlSessionFactory.openSession();
//EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);
//2、sqlSession相同，查询条件不同
//3、sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)
//mapper.addEmp(new Employee(null, "testCache", "cache", "1"));
//System.out.println("数据添加成功");
//4、sqlSession相同，手动清除了一级缓存（缓存清空）
//openSession.clearCache();
Employee emp02 = mapper.getEmpById(1);
//Employee emp03 = mapper.getEmpById(3);
System.out.println(emp02);
//System.out.println(emp03);
System.out.println(emp01==emp02);
//openSession2.close();
}finally{
openSession.close();
}
}
6.2 二级缓存
<!-- 全局配置文件:开启二级缓存 -->
<setting name="cacheEnabled" value="true"/>
<!--
eviction:缓存的回收策略：
• LRU – 最近最少使用的：移除最长时间不被使用的对象。
• FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
• SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
• WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
• 默认的是 LRU。
flushInterval：缓存刷新间隔
缓存多长时间清空一次，默认不清空，设置一个毫秒值
readOnly:是否只读：
true：只读；mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。
mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快
false：非只读：mybatis觉得获取的数据可能会被修改。
mybatis会利用序列化&反序列的技术克隆一份新的数据给你。安全，速度慢
size：缓存存放多少元素；
type=""：指定自定义缓存的全类名；
实现Cache接口即可；
-->
<cache eviction="FIFO" flushInterval="60000" readOnly="false" size="1024"></cache>
/**
* 两级缓存：
* 一级缓存：（本地缓存）：sqlSession级别的缓存。一级缓存是一直开启的；SqlSession级别的一个Map
* 与数据库同一次会话期间查询到的数据会放在本地缓存中。
* 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；
*
* 一级缓存失效情况（没有使用到当前一级缓存的情况，效果就是，还需要再向数据库发出查询）：
* 1、sqlSession不同。
* 2、sqlSession相同，查询条件不同.(当前一级缓存中还没有这个数据)
* 3、sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)
* 4、sqlSession相同，手动清除了一级缓存（缓存清空）
*
* 二级缓存：（全局缓存）：基于namespace级别的缓存：一个namespace对应一个二级缓存：
* 工作机制：
* 1、一个会话，查询一条数据，这个数据就会被放在当前会话的一级缓存中；
* 2、如果会话关闭；一级缓存中的数据会被保存到二级缓存中；新的会话查询信息，就可以参照二级缓存中的内容；
* 3、sqlSession===EmployeeMapper==>Employee
* DepartmentMapper===>Department
* 不同namespace查出的数据会放在自己对应的缓存中（map）
* 效果：数据会从二级缓存中获取
* 查出的数据都会被默认先放在一级缓存中。
* 只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中
* 使用：
* 1）、开启全局二级缓存配置：<setting name="cacheEnabled" value="true"/>
* 2）、去mapper.xml中配置使用二级缓存：
* <cache></cache>
* 3）、我们的POJO需要实现序列化接口
*
* 和缓存有关的设置/属性：
* 1）、cacheEnabled=true：false：关闭缓存（二级缓存关闭）(一级缓存一直可用的)
* 2）、每个select标签都有useCache="true"：
* false：不使用缓存（一级缓存依然使用，二级缓存不使用）
* 3）、【每个增删改标签的：flushCache="true"：（一级二级都会清除）】
* 增删改执行完成后就会清楚缓存；
* 测试：flushCache="true"：一级缓存就清空了；二级也会被清除；
* 查询标签：flushCache="false"：
* 如果flushCache=true;每次查询之后都会清空缓存；缓存是没有被使用的；
* 4）、sqlSession.clearCache();只是清楚当前session的一级缓存；
* 5）、localCacheScope：本地缓存作用域：（一级缓存SESSION）；当前会话的所有数据保存在会话缓存中；
* STATEMENT：可以禁用一级缓存；
*
*第三方缓存整合：
* 1）、导入第三方缓存包即可；
* 2）、导入与第三方缓存整合的适配包；官方有；
* 3）、mapper.xml中使用自定义缓存
* <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>
*
* @throws IOException
*
*/
@Test
public void testSecondLevelCache02() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
SqlSession openSession2 = sqlSessionFactory.openSession();
try{
//1、
DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
DepartmentMapper mapper2 = openSession2.getMapper(DepartmentMapper.class);
Department deptById = mapper.getDeptById(1);
System.out.println(deptById);
openSession.close();
Department deptById2 = mapper2.getDeptById(1);
System.out.println(deptById2);
openSession2.close();
//第二次查询是从二级缓存中拿到的数据，并没有发送新的sql
}finally{
}
}
6.3. Mybatis整合ehcache
- 导入第三方支持的ehcache
ehcache-core-2.6.8.jar
mybatis-ehcache-1.0.3.jar
slf4j-api-1.6.1.jar
slf4j-log4j12-1.6.2.jar
- 导入与第三方缓存整合的适配包；官方有
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<!-- 磁盘保存路径 -->
<diskStore path="D:\44\ehcache" />
<defaultCache
maxElementsInMemory="10000"
maxElementsOnDisk="10000000"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
</defaultCache>
</ehcache>
<!--
属性说明：
l diskStore：指定数据在磁盘中的存储位置。
l defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
以下属性是必须的：
l maxElementsInMemory - 在内存中缓存的element的最大数目
l maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
l eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
l overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
以下属性是可选的：
l timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
l timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
l diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
l diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
l memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
-->
- mapper.xml中使用自定义缓存,例如在EmployeeMapper.xml中引入第三方缓存
<!-- 引用缓存：namespace：指定和哪个名称空间下的缓存一样 -->
<cache-ref namespace="com.atguigu.mybatis.dao.EmployeeMapper"/>
如果其他的xml文件中也需要使用第三方缓存,不需要再写上面的代码,可以通过以下方式引入,例如在DepartmentMapper.xml也需要使用ehcache缓存,可以通过直接引用EmployeeMapper.xml中配置好的ehcache缓存
<!-- 引用缓存：namespace：指定和哪个名称空间下的缓存一样 -->
<cache-ref namespace="com.atguigu.mybatis.dao.EmployeeMapper"/>
第七章 整合Spring
- 导入相关的spring jar包
- 导入数据库驱动包
mysql-connector-java-5.1.37-bin.jar
c3p0-0.9.1.2.jar
- mybatis jar包以及整合spring的jar包
mybatis-3.4.1.jar
mybatis-spring-1.3.0.jar
- 项目结构如下
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g8rcjDcm-1641648418043)(MyBatis3系列笔记/clipboard-1639221516822.png)]](https://i-blog.csdnimg.cn/blog_migrate/40d7024704ce135b16696f2337fa3265.png)
- web.xml配置文件
<!--spring配置: needed for ContextLoaderListener -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!-- Bootstraps the root web application context before servlet initialization -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- springmvc配置: The front controller of this Spring Web application, responsible for handling all application requests -->
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<!-- Map all requests to the DispatcherServlet for handling -->
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
- spring-servlet.xml文件配置如下
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!-- springmvc只管理网站跳转逻辑 -->
<!-- 只扫描带有@controll注解的控制权 -->
<!-- use-default-filters="false"禁用springmvc默认的过滤器 -->
<context:component-scan base-package="com.atguigu.mybatis" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- springmvc的视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!-- 开启mvc扫描静态资源已经注解驱动 -->
<mvc:annotation-driven></mvc:annotation-driven>
<mvc:default-servlet-handler/>
</beans>
- applicationContext.xml文件配置如下
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
<!-- spring希望管理所有的业务逻辑,排除springmvc控制的@controller注解(控制层 ) -->
<context:component-scan base-package="com.atguigu.mybatis">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 引入数据库配置文件 -->
<context:property-placeholder location="classpath:dbconfig.properties"/>
<!-- spring用来控制业务逻辑,数据源,事务控制,aop等 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- spring事务管理 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 开启基于注解的事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
<!--
整合mybatis
目的：1、spring管理所有组件。mapper的实现类。
service==>Dao @Autowired:自动注入mapper；
2、spring用来管理事务，spring声明式事务
-->
<!-- 创建出SqlsessionFactory对象 -->
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<!-- configLocation指定全局配置文件的位置 -->
<property name="configLocation" value="classpath:mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath:mybatis/mapper/*.xml"></property>
</bean>
<!--配置一个可以进行批量执行的sqlSession -->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBean"></constructor-arg>
<constructor-arg name="executorType" value="BATCH"></constructor-arg>
</bean>
<!--
扫描所有的mapper接口的实现，让这些mapper能够自动注入；
base-package：指定mapper接口的包名
-->
<!-- 第一种方式 -->
<mybatis-spring:scan base-package="com.atguigu.mybatis.dao"/>
<!-- 第二种方式(旧版本) -->
<!--
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.atguigu.mybatis.dao"></property>
</bean>
-->
</beans>
- dbconfig.properties数据库配置文件如下
#mysql
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true
jdbc.username=root
jdbc.password=root
#Oracle
orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456
- mybatis-config.xml配置文件如下
<?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>
<!--
2、settings包含很多重要的设置项
setting:用来设置每一个设置项
name：设置项名
value：设置项取值
-->
<!-- 设置是否开启驼峰命名法则,默认是false -->
<settings>
<!-- 开启二级缓存 -->
<setting name="cacheEnabled" value="true"/>
<setting name="mapUnderscoreToCamelCase" value="true"/>
<!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 关闭按需加载的配置,默认是true -->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
<!--5.databaseIdProvider:支持多数据厂商的
type="DB_VENDOR"：VendorDatabaseIdProvider
作用就是得到数据库厂商的标识(也就是驱动,通过getDatabaseProductName()可以获取标识),mybatis
就能根据数据库厂商标识来执行不同的sql.
各厂商标识:MySQL,Oracle,SQL Server
-->
<databaseIdProvider type="DB_VENDOR">
<!-- 为不同的数据库厂商起别名 -->
<property name="MySQL" value="mysql"/>
<property name="Oracle" value="oracle"/>
<property name="SQL Server" value="sqlserver"/>
</databaseIdProvider>
</configuration>
- 实体类Employee代码如下
public class Employee implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private Integer id;
private String lastName;
private String email;
private String gender;
private Department dept;
//无参构造方法
//有参构造方法
//get/set方法
//toString方法
- Controller层EmployeeController.java代码如下
package com.atguigu.mybatis.controller;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.service.EmployeeService;
@Controller
public class EmployeeController {
@Autowired
EmployeeService employeeService;
@RequestMapping("/getEmps")
public String emps(Map<String,Object> map){
List<Employee> emps = employeeService.getEmps();
map.put("allEmps", emps);
return "list";
}
}
- service层EmployeeService.java代码如下
package com.atguigu.mybatis.service;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.EmployeeMapper;
@Service
public class EmployeeService {
@Autowired
private EmployeeMapper employeeService;
@Autowired
private SqlSession sqlSession;
public List<Employee> getEmps(){
return employeeService.getEmps();
}
}
- dao接口对应的映射文件EmployeeMapper.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.atguigu.mybatis.dao.EmployeeMapper">
<!-- public Employee getEmpById(Integer id); -->
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where id = #{id}
</select>
<!-- public List<Employee> getEmps(); -->
<select id="getEmps" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
</select>
</mapper>
- 前台页面index.jsp代码如下
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<a href="getEmps">查询所有员工</a>
</body>
</html>
- 前台页面list.jsp代码如下
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=IUTF-8">
<title>员工列表</title>
</head>
<body>
<table>
<tr>
<td>id</td>
<td>lastName</td>
<td>email</td>
<td>gender</td>
</tr>
<c:forEach items="${allEmps}" var="emp">
<tr>
<td>${emp.id }</td>
<td>${emp.lastName }</td>
<td>${emp.email }</td>
<td>${emp.gender }</td>
</tr>
</c:forEach>
</table>
</body>
</html>
第八章 逆向工程
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vvjXWgvA-1641648418045)(MyBatis3系列笔记/clipboard-1639224513515.png)]](https://i-blog.csdnimg.cn/blog_migrate/1053b0a2e0dd437ecfe800d27f68bf81.png)
官方文档地址
http://www.mybatis.org/generator/
官方工程地址
https://github.com/mybatis/generator/releases
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nylED5vD-1641648418046)(MyBatis3系列笔记/clipboard-1639224551611.png)]](https://i-blog.csdnimg.cn/blog_migrate/43f5d51a4df4fe5509f4d51e03ac1756.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bxNmQxAM-1641648418046)(MyBatis3系列笔记/clipboard-1639224567662.png)]](https://i-blog.csdnimg.cn/blog_migrate/690fdd1f502cefffa1cc2510a3e84a66.png)
- MyBatis Generator生成Mybatis的bean,dao,以及映射配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!--
targetRuntime="MyBatis3Simple":生成简单版的CRUD
MyBatis3:豪华版,带动态参数和一些列高级增删改查方法
-->
<context id="DB2Tables" targetRuntime="MyBatis3" >
<!-- jdbcConnection：指定如何连接到目标数据库 -->
<jdbcConnection
driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true"
userId="root"
password="root">
</jdbcConnection>
<!--
Java类型解析器用于根据数据库列信息计算Java类型
forceBigDecimals默认值为false
-->
<javaTypeResolver>
<property name="forceBigDecimals" value="flase"/>
</javaTypeResolver>
<!--
javaModelGenerator：指定javaBean的生成策略
targetPackage="test.model"：目标包名(目标bean的包名)
targetProject="\MBGTestProject\src"：目标工程
-->
<javaModelGenerator targetPackage="com.atguigu.mybatis.bean" targetProject=".\src">
<property name="enableSubPackages" value="true"/>
<property name="trimStrings" value="true"/>
</javaModelGenerator>
<!-- sqlMapGenerator：sql映射生成策略： -->
<sqlMapGenerator targetPackage="com.atguigu.mybatis.dao" targetProject=".\config">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- javaClientGenerator:指定mapper接口所在的位置 -->
<javaClientGenerator type="XMLMAPPER" targetPackage="com.atguigu.mybatis.dao" targetProject=".\src">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 指定要逆向分析哪些表：根据表要创建javaBean -->
<table tableName="tbl_dept" domainObjectName="Department"></table>
<table tableName="tbl_employee" domainObjectName="Employee"></table>
</context>
</generatorConfiguration>
- 运行MyBatis Generator的代码:
@Test
public void testMbg() throws Exception{
List<String> warnings = new ArrayList<String>();
boolean overwrite = true;
File configFile = new File("mbg.xml");
ConfigurationParser cp = new ConfigurationParser(warnings);
Configuration configuration = cp.parseConfiguration(configFile);
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator myBatisGenerator = new MyBatisGenerator(configuration, callback, warnings);
myBatisGenerator.generate(null);
}
- 测试用例
package com.atguigu.mybatis.test;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.MapKey;
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 org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.bean.EmployeeExample;
import com.atguigu.mybatis.bean.EmployeeExample.Criteria;
import com.atguigu.mybatis.dao.EmployeeMapper;
public class MyBatisTest {
public SqlSessionFactory getSqlSessionFactory() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
return new SqlSessionFactoryBuilder().build(inputStream);
}
@Test
public void testMbg() throws Exception{
List<String> warnings = new ArrayList<String>();
boolean overwrite = true;
File configFile = new File("mbg.xml");
ConfigurationParser cp = new ConfigurationParser(warnings);
Configuration configuration = cp.parseConfiguration(configFile);
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator myBatisGenerator = new MyBatisGenerator(configuration, callback, warnings);
myBatisGenerator.generate(null);
}
@Test
public void testMyBatis3Simple() throws Exception{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
List<Employee> example = mapper.selectByExample(null);
for(Employee employee:example){
System.out.println(employee.getId());
}
}finally{
openSession.close();
}
}
@Test
public void testMyBatis3() throws Exception{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
//查询员工名字中有e字母,和员工性别是1的.
//封装员工查询条件的example
EmployeeExample example = new EmployeeExample();
//创建一个Criteria,这个Criteria就是拼接查询条件
Criteria criteria = example.createCriteria();
criteria.andLastNameLike("%e%");
criteria.andGenderEqualTo(1);
Criteria criteria2 = example.createCriteria();
criteria2.andEmailLike("%e%");
example.or(criteria2);
List<Employee> list = mapper.selectByExample(example);
for(Employee employee : list){
System.out.println(employee.getId());
}
}finally{
openSession.close();
}
}
}
第九章 Mybatis运行原理
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZpQ9Ih2I-1641648418050)(MyBatis3系列笔记/clipboard-1639224740279.png)]](https://i-blog.csdnimg.cn/blog_migrate/919d2ce97158187d7e800984ab58bcaf.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0bAB9iPq-1641648418055)(MyBatis3系列笔记/clipboard-1639224780459.png)]](https://i-blog.csdnimg.cn/blog_migrate/4bd22ab73d5765a929cf2ae67cde539b.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fxy61pW1-1641648418056)(MyBatis3系列笔记/clipboard-1639224789138.png)]](https://i-blog.csdnimg.cn/blog_migrate/6067580e43fbf898954bf991cbca85c1.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0qnqbfiE-1641648418058)(MyBatis3系列笔记/clipboard-1639224809352.png)]](https://i-blog.csdnimg.cn/blog_migrate/40fbb683cdba3a0484aa64ca2f4ad4db.png)
package com.atguigu.mybatis.test;
import java.io.IOException;
import java.io.InputStream;
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 com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.EmployeeMapper;
public class MyBatisTest {
public SqlSessionFactory getSqlSessionFactory() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
return new SqlSessionFactoryBuilder().build(inputStream);
}
/**
* 1、获取sqlSessionFactory对象:
* 解析文件的每一个信息保存在Configuration中，返回包含Configuration的DefaultSqlSession；
* 注意：【MappedStatement】：代表一个增删改查的详细信息
*
* 2、获取sqlSession对象
* 返回一个DefaultSQlSession对象，包含Executor和Configuration;
* 这一步会创建Executor对象；
*
* 3、获取接口的代理对象（MapperProxy）
* getMapper，使用MapperProxyFactory创建一个MapperProxy的代理对象
* 代理对象里面包含了，DefaultSqlSession（Executor）
* 4、执行增删改查方法
*
* 总结：
* 1、根据配置文件（全局，sql映射）初始化出Configuration对象
* 2、创建一个DefaultSqlSession对象，
* 他里面包含Configuration以及
* Executor（根据全局配置文件中的defaultExecutorType创建出对应的Executor）
* 3、DefaultSqlSession.getMapper（）：拿到Mapper接口对应的MapperProxy；
* 4、MapperProxy里面有（DefaultSqlSession）；
* 5、执行增删改查方法：
* 1）、调用DefaultSqlSession的增删改查（Executor）；
* 2）、会创建一个StatementHandler对象。
* （同时也会创建出ParameterHandler和ResultSetHandler）
* 3）、调用StatementHandler预编译参数以及设置参数值;
* 使用ParameterHandler来给sql设置参数
* 4）、调用StatementHandler的增删改查方法；
* 5）、ResultSetHandler封装结果
* 注意：
* 四大对象每个创建的时候都有一个interceptorChain.pluginAll(parameterHandler);
*
* @throws IOException
*/
@Test
public void test01() throws IOException {
// 1、获取sqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
// 2、获取sqlSession对象
SqlSession openSession = sqlSessionFactory.openSession();
try {
// 3、获取接口的实现类对象
//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Employee employee = mapper.getEmpById(1);
System.out.println(mapper);
System.out.println(employee);
} finally {
openSession.close();
}
}
}
第十章 Mybatis插件开发及扩展
10.1 Mybatis插件开发
- 编写Interceptor的实现类,使用@Intercepts注解完成插件签名
package com.atguigu.mybatis.dao;
import java.util.Properties;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
/**
* 完成插件签名：
* 告诉MyBatis当前插件用来拦截哪个对象的哪个方法
*/
@Intercepts({
@Signature(type=StatementHandler.class,method="parameterize",args=java.sql.Statement.class)
})
public class MyFirstPlugin implements Interceptor{
/**
* intercept拦截.
* 拦截目标对象的目标方法的执行.
*/
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("MyFirstPlugin...invocation:"+invocation.getMethod());
//动态的改变一下sql运行的参数：以前1号员工，实际从数据库查询3号员工
Object target = invocation.getTarget();
System.out.println("当前拦截到的对象："+target);
//拿到：StatementHandler==>ParameterHandler===>parameterObject
//拿到target的元数据
MetaObject metaObject = SystemMetaObject.forObject(target);
Object value = metaObject.getValue("parameterHandler.parameterObject");
System.out.println("sql语句用的参数是："+value);
//修改完sql语句要用的参数
metaObject.setValue("parameterHandler.parameterObject", 2);
//执行目标方法,在执行目标方法之前可以做很多的操作.
Object proceed = invocation.proceed();
//返回执行后的返回值
return proceed;
}
/**
* plugin：
* 包装目标对象的：包装：为目标对象创建一个代理对象
*/
@Override
public Object plugin(Object target) {
//我们可以借助Plugin的wrap方法来使用当前Interceptor包装我们目标对象
System.out.println("MyFirstPlugin...plugin:mybatis将要包装的对象"+target);
Object wrap = Plugin.wrap(target, this);
return wrap;
}
/**
* setProperties：
* 将插件注册时 的property属性设置进来
*/
@Override
public void setProperties(Properties properties) {
System.out.println("插件配置的信息："+properties);
}
}
package com.atguigu.mybatis.dao;
import java.util.Properties;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
@Intercepts(
{
@Signature(type=StatementHandler.class,method="parameterize",args=java.sql.Statement.class)
})
public class MySecondPlugin implements Interceptor{
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("MySecondPlugin...intercept:"+invocation.getMethod());
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
// TODO Auto-generated method stub
System.out.println("MySecondPlugin...plugin:"+target);
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
// TODO Auto-generated method stub
}
}
- 将写好的插件注册到全局配置文件中
<!--plugins：注册插件 -->
<plugins>
<plugin interceptor="com.atguigu.mybatis.dao.MyFirstPlugin">
<property name="username" value="root"/>
<property name="password" value="123456"/>
</plugin>
<plugin interceptor="com.atguigu.mybatis.dao.MySecondPlugin"></plugin>
</plugins>
10.2 Mybatis分页PageHelpler
- PageHelper插件进行分页
- 批量操作
- 存储过程
- typeHandler处理枚举
PageHelper插件进行分页
PageHelper是Mybatis中非常方便的第三方分页插件.
官方文档:
https://github.com/pageHelper/Mybatis-PageHelper/blob/master/README_zh.md
我们可以对照官方文档的说明,快速的使用插件
- 导入分页相关的jar包
pagehelper-5.0.0-rc.jar
jsqlparser-0.9.5.jar
- 编写EmployeeMapper.java的接口方法
/**
* 定义接口
* @author chentf
*/
public interface EmployeeMapper {
public Employee getEmpById(Integer id);
public List<Employee> getEmps();
}
- 编写接口对应的EmployeeMapper.xml映射
<!--public List<Employee> getEmps(); -->
<select id="getEmps" resultType="com.atguigu.mybatis.bean.Employee">
select id,last_name lastName,email,gender from tbl_employee
</select>
- 在全局配置文件中注册分页插件
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
- 测试用例
@Test
public void test01(){
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
//第一种方式
Page<Object> page = PageHelper.startPage(1, 2);
List<Employee> emps = mapper.getEmps();
//第二种:传入要连续显示多少页
PageInfo<Employee> info = new PageInfo<>(emps,5);
for(Employee employee : emps){
System.out.println(employee);
}
System.out.println("当前页码："+page.getPageNum());
System.out.println("总记录数："+page.getTotal());
System.out.println("每页的记录数："+page.getPageSize());
System.out.println("总页码："+page.getPages());
System.out.println("------------------------------");
System.out.println("当前页码："+info.getPageNum());
System.out.println("总记录数："+info.getTotal());
System.out.println("每页的记录数："+info.getPageSize());
System.out.println("总页码："+info.getPages());
System.out.println("是否第一页："+info.isIsFirstPage());
System.out.println("连续显示的页码：");
int[] nums = info.getNavigatepageNums();
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
}finally{
openSession.close();
}
}
10.3 Mybatis批量BatchExecutor
- 编写EmployeeMapper.java对应的方法
public Long addEmp(Employee employee);
- 编写EmployeeMapper.xml的映射方法
<!--public Long addEmp(Employee employee); -->
<insert id="addEmp" useGeneratedKeys="true" keyProperty="id">
insert into tbl_employee(last_name,email,gender)
values(#{lastName},#{email},#{gender})
</insert>
- 测试用例
@Test
public void testBatch() throws IOException{
SqlSessionFactory sqlSessionFactory = getsqSessionFactory();
//可以执行批量操作的sqlSession
SqlSession openSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
long start = System.currentTimeMillis();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
for (int i = 0; i < 10; i++) {
mapper.addEmp(new Employee(UUID.randomUUID().toString().substring(0, 5), "b", "1"));
}
openSession.commit();
long end = System.currentTimeMillis();
//批量：（预编译sql一次==>设置参数===>10000次===>执行（1次））
//Parameters: 616c1(String), b(String), 1(String)==>4598
//非批量：（预编译sql=设置参数=执行）==》10000 10200
System.out.println("执行时长："+(end-start));
}finally{
openSession.close();
}
}
10.4 Mybatis调用存储过程
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xYMHDOog-1641648418070)(MyBatis3系列笔记/clipboard-1639225908855.png)]](https://i-blog.csdnimg.cn/blog_migrate/5f34ec1285aa7a7d26cdd61e048d4872.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4QPN91LM-1641648418072)(MyBatis3系列笔记/clipboard-1639225921551.png)]](https://i-blog.csdnimg.cn/blog_migrate/6a9bc625b63b2b550308254c3d1c8a2b.png)
-
创建一个带游标的Oracle分页存储过程
-
创建一个用于分页的试题类OraclePage.java类
package com.atguigu.mybatis.bean;
import java.util.List;
/**
* 封装分页查询数据
* @author lfy
*/
public class OraclePage {
private int start;
private int end;
private int count;
private List<Employee> emps;
public int getStart() {
return start;
}
public void setStart(int start) {
this.start = start;
}
public int getEnd() {
return end;
}
public void setEnd(int end) {
this.end = end;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public List<Employee> getEmps() {
return emps;
}
public void setEmps(List<Employee> emps) {
this.emps = emps;
}
}
- 编写EmployeeMapper.java对应的方法
public void getPageByProcedure(OraclePage page);
- 编写EmployeeMapper.xml对应方法
<!-- public void getPageByProcedure();
1、使用select标签定义调用存储过程
2、statementType="CALLABLE":表示要调用存储过程
3、{call procedure_name(params)}
-->
<select id="getPageByProcedure" statementType="CALLABLE" databaseId="oracle">
{call hello_test(
#{start,mode=IN,jdbcType=INTEGER},
#{end,mode=IN,jdbcType=INTEGER},
#{count,mode=OUT,jdbcType=INTEGER},
#{emps,mode=OUT,jdbcType=CURSOR,javaType=ResultSet,resultMap=PageEmp}
)}
</select>
<resultMap type="com.atguigu.mybatis.bean.Employee" id="PageEmp">
<id column="EMPLOYEE_ID" property="id"/>
<result column="LAST_NAME" property="email"/>
<result column="EMAIL" property="email"/>
</resultMap>
- 测试用例
/**
* oracle分页：
* 借助rownum：行号；子查询；
* 存储过程包装分页逻辑
* @throws IOException
*/
@Test
public void testProcedure() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
OraclePage page = new OraclePage();
page.setStart(1);
page.setEnd(5);
mapper.getPageByProcedure(page);
System.out.println("总记录数："+page.getCount());
System.out.println("查出的数据："+page.getEmps().size());
System.out.println("查出的数据："+page.getEmps());
}finally{
openSession.close();
}
}
10.5 Mybatis自定义类型处理器
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NKtOQkoX-1641648418075)(MyBatis3系列笔记/clipboard-1639228003973.png)]](https://i-blog.csdnimg.cn/blog_migrate/010ac761dfd04ca8c3f139e199e41b39.png)
扫一扫
271
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
