一、MyBatis介绍
1、MyBatis简介
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）。
MyBatis下载地址：https://github.com/mybatis/mybatis-3
MyBatis官方文档：https://mybatis.org/mybatis-3/zh_CN/index.html
2、MyBatis特性
- MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
- MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
- MyBatis 可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old JavaObjects，普通的Java对象）映射成数据库中的记录
- MyBatis 是一个半自动的ORM（Object Relation Mapping）框架
3、和其它持久化层技术对比
- JDBC
- SQL 夹杂在Java代码中耦合度高，导致硬编码内伤
- 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
- 代码冗长，开发效率低
- Hibernate 和 JPA
- 操作简便，开发效率高
- 程序中的长难复杂 SQL 需要绕过框架
- 内部自动生产的 SQL，不容易做特殊优化
- 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
- 反射操作太多，导致数据库性能下降
- MyBatis
- 轻量级，性能出色
- SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
- 开发效率稍逊于HIbernate，但是完全能够接受
二、搭建MyBatis基本步骤
1、创建Maven工程
<dependencies> <!-- Mybatis核心 --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.7</version> </dependency> <!-- junit测试 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> <!-- MySQL8驱动 --> <dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> <version>8.0.33</version> </dependency> <!-- MySQL5驱动 --> <!--<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency>--> <!-- Log4j2 dependencies --> <!-- 使用slf4j作为日志的门面,使用log4j2来记录日志 --> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.30</version> </dependency> <!-- 为slf4j绑定日志实现 log4j2的适配器 --> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-slf4j-impl</artifactId> <version>2.13.3</version> </dependency> <!-- log4j2 门面API --> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-api</artifactId> <version>2.17.1</version> </dependency> <!-- log4j2的日志实现 --> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-core</artifactId> <version>2.17.1</version> </dependency> <!-- log4j2并发编程依赖包 --> <dependency> <groupId>com.lmax</groupId> <artifactId>disruptor</artifactId> <version>3.4.0</version> </dependency> </dependencies>
2、添加log4j2的配置文件
log4j2的配置文件名为log4j2.xml，存放的位置是src/main/resources目录下
<?xml version="1.0" encoding="UTF-8"?> <!--<configuration status="OFF">--> <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL --> <!-- status：用来指定log4j本身打印日志的级别，框架默认级别为warn (若是设置debug，log4j的配置过程也会展现出来) monitorInterval：用于指定log4j自动重新配置的监测间隔时间，单位是秒(s)，最小的间隔时间是5s。(修改配置文件后无需重新发动应用，可以自动加载) --> <configuration status="warn" monitorInterval="10"> <!-- 全局参数 --> <properties> <!-- 日志打印级别 --> <property name="LOG_LEVEL">DEBUG</property> <!-- APP名称 --> <property name="APP_NAME" value="Mybatis"/> <!-- 日志文件存储路径 --> <property name="LOG_HOME">../logs</property> <!-- 日志编码 --> <property name="CHARSET" value="UTF-8"/> <!-- 存储天数 --> <property name="LOG_MAX_HISTORY" value="60d"/> <!-- 单个日志文件最大值, 单位 = KB, MB, GB --> <property name="LOG_MAX_FILE_SIZE" value="10MB"/> <!-- 每天每个日志级别产生的文件最大数量 --> <property name="LOG_TOTAL_NUMBER_DAILY" value="100"/> <!-- 压缩文件的类型,支持zip和gz,建议Linux用gz,Windows用zip --> <property name="ARCHIVE_FILE_SUFFIX" value="zip"/> <!-- 日志文件名 --> <property name="LOG_FILE_NAME" value="${LOG_HOME}"/> <property name="FILE_NAME_PATTERN" value="${LOG_HOME}/%d{yyyy-MM-dd}"/> <!--日志输出格式-控制台彩色打印--> <property name="ENCODER_PATTERN_CONSOLE">%blue{%d{yyyy-MM-dd HH:mm:ss.SSS}} | %highlight{%-5level}{ERROR=Bright RED, WARN=Bright Yellow, INFO=Bright Green, DEBUG=Bright Cyan, TRACE=Bright White} | %yellow{%t} | %cyan{%c{1.}} ： %white{%msg%n} </property> <!--日志输出格式-文件--> <property name="ENCODER_PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %5pid --- [%15.15t] %c{1.} [%L] : %m%n </property> <!--日志输出格式-控制台彩色打印--> <!--<property name="DEFAULT_PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} %highlight{%-5level} %style{%5pid}{bright,magenta} --- [%17.17t] %cyan{%c{1.} [%L]} : %m%n </property>--> <property name="DEFAULT_PATTERN">%blue{%d{yyyy-MM-dd HH:mm:ss,SSS}} %cyan{[%t]} %highlight{%-5level}{ERROR=Bright RED, WARN=Bright Yellow, INFO=Bright Green, DEBUG=Bright Magenta, TRACE=Bright White} %cyan{%logger [%L]} : %m%n </property> </properties> <Appenders> <!-- 控制台的输出配置 --> <Console name="Console" target="SYSTEM_OUT"> <!-- 输出日志的格式 --> <PatternLayout pattern="${DEFAULT_PATTERN}" charset="${CHARSET}"/> </Console> <!-- 新增包含所有级别日志的文件 Appender --> <RollingFile name="RollingFileAllLevels" fileName="${LOG_FILE_NAME}/all.log" filePattern="${FILE_NAME_PATTERN}/${APP_NAME}-all.%d{yyyy-MM-dd.HH}-%i.log"> <!-- $${date:yyyy-MM-dd} --> <Filters/> <!-- 不过滤任何日志级别 --> <!-- 日志输出格式-文件 --> <PatternLayout pattern="${ENCODER_PATTERN}"/> <!-- 触发策略 --> <Policies> <!-- 归档每天的文件，每天滚动一次 --> <TimeBasedTriggeringPolicy interval="1" modulate="true"/> <!-- 限制单个文件大小，日志达到size滚动一次 --> <SizeBasedTriggeringPolicy size="${LOG_MAX_FILE_SIZE}"/> </Policies> <!-- 限制每天文件个数 --> <DefaultRolloverStrategy compressionLevel="9" max="${LOG_TOTAL_NUMBER_DAILY}"> <!-- 日志保留策略，日志只保留60天 --> <Delete basePath="${LOG_HOME}" maxDepth="1"> <IfFileName glob="*-all.*.log"/> <IfLastModified age="${LOG_MAX_HISTORY}"/> </Delete> </DefaultRolloverStrategy> </RollingFile> <!-- 打印出所有的info及以下级别的信息，每次大小超过size进行压缩，作为存档--> <RollingFile name="RollingFileAll" fileName="${LOG_FILE_NAME}/info.log" filePattern="${FILE_NAME_PATTERN}/${APP_NAME}-info.%d{yyyy-MM-dd.HH}-%i.log"> <!-- 控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch） --> <ThresholdFilter level="${LOG_LEVEL}" onMatch="ACCEPT" onMismatch="DENY"/> <!-- 输出日志的格式 --> <PatternLayout pattern="${ENCODER_PATTERN}"/> <Policies> <!-- 归档每天的文件 --> <TimeBasedTriggeringPolicy interval="1" modulate="true"/> <!-- 限制单个文件大小 --> <SizeBasedTriggeringPolicy size="${LOG_MAX_FILE_SIZE}"/> </Policies> <!-- 限制每天文件个数 --> <DefaultRolloverStrategy compressionLevel="9" max="${LOG_TOTAL_NUMBER_DAILY}"> <Delete basePath="${LOG_HOME}" maxDepth="1"> <IfFileName glob="*-info.*.log"/> <IfLastModified age="${LOG_MAX_HISTORY}"/> </Delete> </DefaultRolloverStrategy> </RollingFile> <RollingFile name="RollingFileDebug" fileName="${LOG_FILE_NAME}/debug.log" filePattern="${FILE_NAME_PATTERN}/${APP_NAME}-debug.%d{yyyy-MM-dd.HH}-%i.log"> <Filters> <ThresholdFilter level="DEBUG"/> <ThresholdFilter level="INFO" onMatch="DENY" onMismatch="NEUTRAL"/> </Filters> <PatternLayout pattern="${ENCODER_PATTERN}"/> <Policies> <!-- 归档每天的文件 --> <TimeBasedTriggeringPolicy interval="1" modulate="true"/> <!-- 限制单个文件大小 --> <SizeBasedTriggeringPolicy size="${LOG_MAX_FILE_SIZE}"/> </Policies> <!-- 限制每天文件个数 --> <DefaultRolloverStrategy compressionLevel="9" max="${LOG_TOTAL_NUMBER_DAILY}"> <Delete basePath="${LOG_HOME}" maxDepth="1"> <IfFileName glob="*-debug.*.log"/> <IfLastModified age="${LOG_MAX_HISTORY}"/> </Delete> </DefaultRolloverStrategy> </RollingFile> <RollingFile name="RollingFileWarn" fileName="${LOG_FILE_NAME}/warn.log" filePattern="${FILE_NAME_PATTERN}/${APP_NAME}-warn.%d{yyyy-MM-dd.HH}-%i.log"> <Filters> <ThresholdFilter level="WARN"/> <ThresholdFilter level="ERROR" onMatch="DENY" onMismatch="NEUTRAL"/> </Filters> <PatternLayout pattern="${ENCODER_PATTERN}"/> <Policies> <!-- 归档每天的文件 --> <TimeBasedTriggeringPolicy interval="1" modulate="true"/> <!-- 限制单个文件大小 --> <SizeBasedTriggeringPolicy size="${LOG_MAX_FILE_SIZE}"/> </Policies> <!-- 限制每天文件个数 --> <DefaultRolloverStrategy compressionLevel="9" max="${LOG_TOTAL_NUMBER_DAILY}"> <Delete basePath="${LOG_HOME}" maxDepth="1"> <IfFileName glob="*-warn.*.log"/> <IfLastModified age="${LOG_MAX_HISTORY}"/> </Delete> </DefaultRolloverStrategy> </RollingFile> <RollingFile name="RollingFileError" fileName="${LOG_FILE_NAME}/error.log" filePattern="${FILE_NAME_PATTERN}/${APP_NAME}-error.%d{yyyy-MM-dd.HH}-%i.log"> <Filters> <ThresholdFilter level="ERROR"/> </Filters> <PatternLayout pattern="${ENCODER_PATTERN}"/> <Policies> <TimeBasedTriggeringPolicy interval="1" modulate="true"/> <SizeBasedTriggeringPolicy size="${LOG_MAX_FILE_SIZE}"/> </Policies> <DefaultRolloverStrategy compressionLevel="9" max="${LOG_TOTAL_NUMBER_DAILY}"> <Delete basePath="${LOG_HOME}" maxDepth="1"> <IfFileName glob="*-error.*.log"/> <IfLastModified age="${LOG_MAX_HISTORY}"/> </Delete> </DefaultRolloverStrategy> </RollingFile> </Appenders> <!-- 只有定义了logger并引入以上Appenders，Appender才会生效 --> <Loggers> <!-- Root：指定项目的根日志，如果没有单独指定Logger，那么默认使用该Root日志输出 --> <root level="${LOG_LEVEL}"> <!-- AppenderRef：Root的子节点，用来指定该日志输出到哪个Appender --> <appender-ref ref="Console"/> <appender-ref ref="RollingFileAll"/> <appender-ref ref="RollingFileDebug"/> <appender-ref ref="RollingFileWarn"/> <appender-ref ref="RollingFileError"/> <!-- 添加新的Appender引用 --> <appender-ref ref="RollingFileAllLevels"/> </root> </Loggers> </configuration>
- 日志的级别
在log4j2中， 共有8个级别，按照从低到高为：OFF(关闭)>FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)>Trace(追踪)>All(所有)。
- OFF：最高等级的，用于关闭所有日志记录。
- Fatal：输出每个严重的错误事件将会导致应用程序的退出的日志。
- Error：输出错误信息日志。
- Warn：输出警告及warn以下级别的日志。
- Info：消息在粗粒度级别上突出强调应用程序的运行过程。
- Debug：指出细粒度信息事件对调试应用程序是非常有帮助的。
- Trace：是追踪，就是程序推进一下。
- All：最低等级的，用于打开所有日志记录。
从左到右打印的内容越来越详细，程序会打印高于或等于所设置级别的日志，设置的日志等级越高，打印出来的日志就越少。
3、创建MyBatis的核心配置文件
习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制粘贴。
核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息，存放的位置是src/main/resources目录下：
<?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"> <!-- MyBatis核心配置文件中，标签的顺序： properties?,settings?,typeAliases?,typeHandlers?, objectFactory?,objectWrapperFactory?,reflectorFactory?, plugins?,environments?,databaseIdProvider?,mappers? --> <configuration> <!-- 引入properties文件件，此时就可以${属性名}的方式访问属性值 --> <properties resource="jdbc.properties" /> <!-- 全局参数 --> <settings> <!-- 将表中字段的下划线自动转换为驼峰 --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- 开启延迟加载 --> <setting name="lazyLoadingEnabled" value="true"/> </settings> <!-- 设置类型别名 --> <typeAliases> <!-- typeAlias：设置某个类型的别名 属性： type：设置需要设置别名的类型 alias：设置某个类型的别名，若不设置该属性，那么该类型拥有默认的别名，即类名且不区分大小写 若设置此属性，此时该类型的别名只能使用alias所设置的值 --> <!--<typeAlias type="com.aizen.mybatis.pojo.User"></typeAlias>--> <!--<typeAlias type="com.aizen.mybatis.pojo.User" alias="abc"></typeAlias>--> <!-- 以包为单位，将包下所有的类型设置默认的类型别名，即类名且不区分大小写 --> <package name="com.aizen.mybatis.pojo"/> </typeAliases> <!-- environments：配置多个连接数据库的环境 属性： default：设置默认使用的环境的id（环境的唯一标识） --> <environments default="development"> <!-- environment：配置某个具体的环境 属性： id：表示连接数据库的环境的唯一标识，不能重复 --> <!-- 开发环境数据库连接配置 --> <environment id="development"> <!-- transactionManager：设置事务管理方式 type="JDBC|MANAGED" 属性： type：设置事务管理方式，type="JDBC|MANAGED" JDBC：设置当前环境的事务管理（提交或回滚）都必须手动处理，使用JDBC中原生的事务管理方式 MANAGED：设置事务被管理，例如spring中的AOP --> <transactionManager type="JDBC"/> <!-- dataSource：设置数据源 属性： type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI" type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建 type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建 type="JNDI"：调用上下文中的数据源 --> <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> <!-- 测试环境数据库连接配置 --> <environment id="test"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=UTC&characterEncoding=UTF-8&allowPublicKeyRetrieval=true"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments> <!-- 引入映射文件 --> <mappers> <!--<mapper resource="mappers/UserMapper.xml"/>--> <!-- 以包为单位引入映射文件，将包下所有的映射文件引入核心配置文件 要求： 1、mapper接口所在的包要和mapper映射文件所在的包一致 2、mapper接口要和mapper映射文件的名字一致 --> <package name="com.aizen.mybatis.mapper"/> </mappers> </configuration>
同时创建jdbc.properties配置文件，用于配置数据库连接信息，方面读取和修改。
jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=UTC&characterEncoding=UTF-8&allowPublicKeyRetrieval=true jdbc.username=root jdbc.password=root
4、创建Mapper接口
MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类。
public interface UserMapper { /** * MyBatis面向接口编程的两个一致： * 1、映射文件的namespace要和mapper接口的全类名保持一致 * 2、映射文件中SQL语句的id要和mapper接口中的方法名一致 * * 表--实体类--mapper接口--映射文件 */ /** * 添加用户信息 */ int insertUser(User user); /** * 修改用户信息 */ int updateUser(User user); /** * 删除用户信息 */ int deleteUserById(int id); /** * 根据id查询用户信息 */ User getUserById(int id); /** * 查询所有的用户信息 */ List<User> getAllUser(); }
5、创建MyBatis映射文件（增删改查）
相关概念：ORM（Object Relationship Mapping）对象关系映射。
- 对象：Java的实体类对象
- 关系：关系型数据库
- 映射：二者之间的对应关系
Java概念 |
数据库概念 |
类 |
字段/列 |
表 |
对象 |
属性 |
记录/行 |
- 映射文件的命名规则：
表所对应的实体类的类名+Mapper.xml
例如：表t_user，映射的实体类为User，所对应的映射文件为UserMapper.xml
因此一个映射文件对应一个实体类，对应一张表的操作
MyBatis映射文件用于编写SQL，访问以及操作表中的数据
MyBatis映射文件存放的位置是src/main/resources/mappers目录下
- MyBatis中可以面向接口操作数据，要保证两个一致：
a > mapper接口的全类名和映射文件的命名空间（namespace）保持一致
b > mapper接口中方法的方法名和映射文件中编写SQL的标签的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"> <!-- MyBatis面向接口编程的两个一致： 1、映射文件的namespace要和mapper接口的全类名保持一致 2、映射文件中SQL语句的id要和mapper接口中的方法名一致 --> <mapper namespace="com.aizen.mybatis.mapper.UserMapper"> <!-- int insertUser(User user); --> <insert id="insertUser"> insert into t_user values(null, #{username}, #{password}, #{age}, #{sex}, #{email}) </insert> <!-- int updateUser(User user); --> <update id="updateUser"> update t_user set username = #{username} where id = #{id} </update> <!-- int deleteUserById(int id); --> <delete id="deleteUserById"> delete from t_user where id = #{id} </delete> <!-- 查询功能的标签必须设置resultType或resultMap resultType：设置默认的映射关系 resultMap：设置自定义的映射关系 --> <!-- User getUserById(int id); --> <select id="getUserById" resultType="com.aizen.mybatis.pojo.User"> select * from t_user where id = #{id} </select> <!-- List<User> getAllUser(); --> <select id="getAllUser" resultType="User"> select * from t_user </select> </mapper>
注意：
（1）查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射
关系。
- resultType：自动映射，用于属性名和表中字段名一致的情况
- resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况
（2）当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常
TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值。
6、创建Junit测试功能
public class MyBatisTest { private static UserMapper mapper; private static final SqlSession sqlSession; static { try { // 读取MyBatis的核心配置文件 InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); // 创建SqlSessionFactoryBuilder对象 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); // 通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象 // openSession(true)，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务 sqlSession = sqlSessionFactory.openSession(true); // 通过代理模式创建UserMapper接口的代理实现类对象 mapper = sqlSession.getMapper(UserMapper.class); } catch (IOException e) { throw new RuntimeException(e); } } /** * SqlSession默认不自动提交事务，若需要自动提交事务 * 可以使用SqlSessionFactory.openSession(true); */ @Test public void testInsert() throws IOException { // 加载核心配置文件 InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); // 获取SqlSessionFactoryBuilder SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); // 获取sqlSessionFactory SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); // 获取SqlSession SqlSession sqlSession = sqlSessionFactory.openSession(); // 获取mapper接口对象 UserMapper mapper = sqlSession.getMapper(UserMapper.class); // 测试功能 User user = User.builder() .username("张三") .password("123456") .age(23) .sex("男") .email("zhangsan@qq.com") .build(); // 调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句 int count = mapper.insertUser(user); System.out.println(count > 0 ? "插入成功" : "插入失败"); // 提交事务 sqlSession.commit(); sqlSession.close(); } @Test public void testDelete() throws IOException { int count = mapper.deleteUserById(3); System.out.println(count > 0 ? "删除成功" : "删除失败"); sqlSession.close(); } @Test public void testUpdate() throws IOException { // 获取mapper接口对象 mapper = sqlSession.getMapper(UserMapper.class); // 测试功能 User user = User.builder() .id(2) .username("李四") .email("lisi@qq.com") .build(); int count = mapper.updateUser(user); System.out.println(count > 0 ? "修改成功" : "修改失败"); sqlSession.close(); } @Test public void testGetById() throws IOException { // 测试功能 User user = mapper.getUserById(2); System.out.println(user); sqlSession.close(); } @Test public void testGetAll() throws IOException { // 测试功能 List<User> list = mapper.getAllUser(); list.forEach(System.out::println); sqlSession.close(); } }
- SqlSession：代表Java程序和数据库之间的会话。（HttpSession是Java程序和浏览器之间的会话）
- SqlSessionFactory：是“生产”SqlSession的“工厂”。
- 工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象。
7、封装SqlSessionUtils工具类
/** * SqlSession工具类 */ public class SqlSessionUtils { public static SqlSession getSqlSession(){ SqlSession sqlSession = null; try { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); sqlSession = sqlSessionFactory.openSession(true); } catch (IOException e) { e.printStackTrace(); } return sqlSession; } }
三、MyBatis获取参数值各种情况
1、MyBatis获取参数值的两种方式（重点）
（1）直接替换与预编译处理
MyBatis获取参数值的两种方式：${}和#{}
${} 是直接替换，#{} 是预编译处理；
${} 的本质就是字符串拼接，#{} 的本质就是占位符赋值
${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动添加单引号；
#{}使用占位符赋值的方式拼接sql，为字符串类型或日期类型的字段进行赋值时，底层自动添加单引号。
（2）SQL注入安全性方面
${}在处理时会将${}替换成变量的值，不会自动添加引号，可能会引发SQL注入。
#{}在处理时会将#{}替换成?号，底层使用PreparedStatement的set方法来赋值，由于引号内部的参数被当作整体处理，因此不会引发SQL注入。
（3）使用场景
能用 #{} 的地方就用 #{}，尽量少用 ${}
但是⼀些场景直接使用#{}会报错，例如like模糊查询、表名作为参数、order by排序功能、字段名作为参数时，这些情况需要使⽤${}，在文章第五章会对这些特殊场景进行说明。
2、单个字面量类型的参数
若mapper接口中的方法参数为单个的字面量类型，此时可以使用${}和#{}以任意的名称获取参数的值，注意${}需要手动加单引号。
<!-- User getUserByUsername(String username); --> <select id="getUserByUsername" resultType="User"> <!--select * from t_user where username = #{username}--> select * from t_user where username = '${username}' </select>
- 测试
@Test public void testGetUserByUsername(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class); User user = mapper.getUserByUsername("admin"); System.out.println(user); }
3、多个字面量类型的参数
若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中，以arg0,arg1...为键，以参数为值；以param1,param2...为键，以参数为值。因此只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号。
<!-- User checkLogin(String username, String password); --> <select id="checkLogin" resultType="User"> <!--select * from t_user where username = #{arg0} and password = #{arg1}--> select * from t_user where username = '${param1}' and password = '${param2}' </select>
- 测试
@Test public void testCheckLogin(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class); User user = mapper.checkLogin("admin", "123456"); System.out.println(user); }
4、map集合类型的参数
若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中。只需要通过 ${} 和 #{} 访问map集合的键就可以获取相对应的值。
<!-- User checkLoginByMap(Map<String, Object> map); --> <select id="checkLoginByMap" resultType="User"> select * from t_user where username = #{username} and password = #{password} </select>
- 测试
@Test public void testCheckLoginByMap(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class); Map<String, Object> map = new HashMap<>(); map.put("username", "admin"); map.put("password", "123456"); User user = mapper.checkLoginByMap(map); System.out.println(user); }
5、实体类类型的参数
若mapper接口方法的参数是实体类类型的参数，只需要通过#{}和${}以属性的方式访问属性值即可。
<!-- int insertUser(User user);--> <insert id="insertUser"> insert into t_user values(null, #{username}, #{password}, #{age}, #{sex}, #{email}) </insert>
- 测试
@Test public void testInsertUser(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class); int result = mapper.insertUser(new User(null, "李四", "123", 23, "男", "123@qq.com")); System.out.println(result); }
6、使用@Param标识参数
可以通过@Param注解标识mapper接口中的方法参数
此时，会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值；以param1,param2...为键，以参数为值；只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号。
<!-- User checkLoginByParam(@Param("username") String username, @Param("password") String password); --> <select id="checkLoginByParam" resultType="User"> select * from t_user where username = #{username} and password = #{password} </select>
- 测试
/** * 验证登录（使用@Param） */ User checkLoginByParam(@Param("username") String username, @Param("password") String password); @Test public void testCheckLoginByParam(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class); User user = mapper.checkLoginByParam("admin", "123456"); System.out.println(user); }
四、MyBatis查询返回的结果
1、MyBatis类型别名（typeAliases）
类型别名可为 Java 类型设置一个缩写名字，目的是为了降低mapper映射文件中冗余的全限定类名书写。例如：
<!-- 在MyBatis核心配置文件中配置实体类的别名 --> <typeAliases> <typeAlias alias="User" type="com.aizen.mybatis_demo3.pojo.User"/> <typeAlias alias="Dept" type="com.aizen.mybatis_demo3.pojo.Dept"/> <typeAlias alias="Emp" type="com.aizen.mybatis_demo3.pojo.Emp"/> </typeAliases> <!-- 在mapper映射文件的查询返回结果中配置实体类的别名简写 --> <!-- User getUserById(@Param("id") Integer id); --> <select id="getUserById" resultType="User"> select * from t_user where id = #{id} </select>
如果需要配置的实体类别名很多，也可以指定一个包名，MyBatis会扫描该包名下的所有Java Bean。
<!-- 在MyBatis核心配置文件中配置实体类别名的包扫描路径 --> <typeAliases> <package name="com.aizen.mybatis_demo3.pojo"/> </typeAliases>
下面是一些MyBatis中内置的Java数据类型别名，它们都是不区分大小写的：
别名 |
映射的类型 |
_byte |
byte |
_char (since 3.5.10) |
char |
_character (since 3.5.10) |
char |
_long |
long |
_short |
short |
_int |
int |
_integer |
int |
_double |
double |
_float |
float |
_boolean |
boolean |
string |
String |
byte |
Byte |
char (since 3.5.10) |
Character |
character (since 3.5.10) |
Character |
long |
Long |
short |
Short |
int |
Integer |
integer |
Integer |
double |
Double |
float |
Float |
boolean |
Boolean |
date |
Date |
decimal |
BigDecimal |
bigdecimal |
BigDecimal |
biginteger |
BigInteger |
object |
Object |
date[] |
Date[] |
decimal[] |
BigDecimal[] |
bigdecimal[] |
BigDecimal[] |
biginteger[] |
BigInteger[] |
object[] |
Object[] |
map |
Map |
hashmap |
HashMap |
list |
List |
arraylist |
ArrayList |
collection |
Collection |
iterator |
Iterator |
2、查询一个实体类对象
- mapper接口
/** * 根据id查询用户信息 */ User getUserById(@Param("id") Integer id); //List<User> getUserById(@Param("id") Integer id);
- mapper映射文件
<!-- User getUserById(@Param("id") Integer id); --> <select id="getUserById" resultType="User"> select * from t_user where id = #{id} </select>
3、查询一个List集合
- mapper接口
/** * 查询所有的用户信息 */ List<User> getAllUser();
- mapper映射文件
<!-- List<User> getAllUser(); --> <select id="getAllUser" resultType="User"> select * from t_user </select>
4、查询返回单条数据
- mapper接口
/** * 查询用户的总记录数 * 在MyBatis中，对于Java中常用的类型都设置了类型别名 * 例如：java.lang.Integer-->int|integer * 例如：int-->_int|_integer * 例如：Map-->map,List-->list */ Integer getCount();
- mapper映射文件
<!-- Integer getCount(); --> <!--<select id="getCount" resultType="Integer">--> <select id="getCount" resultType="_int"> select count(*) from t_user </select>
5、查询一条数据为Map集合
- mapper接口
/** * 根据id查询用户信息为一个map集合 */ Map<String, Object> getUserByIdToMap(@Param("id") Integer id);
- mapper映射文件
<!-- Map<String, Object> getUserByIdToMap(@Param("id") Integer id); --> <select id="getUserByIdToMap" resultType="map"> select * from t_user where id = #{id} </select> <!-- 结果：{password=123456, sex=男, id=3, age=23, email=12345@qq.com, username=admin} -->
6、查询多条数据为Map集合
（1）方式一：List<Map<String, Object>>
- mapper接口
/** * 查询所有用户信息为map集合 * 方式一： * 将表中的数据以map集合的方式查询，一条数据对应一个map； * 若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取 */ List<Map<String, Object>> getAllUserToMap();
- mapper映射文件
<!-- List<Map<String, Object>> getAllUserToMap(); --> <select id="getAllUserToMap" resultType="map"> select * from t_user </select> <!-- 结果： [ {password=zhangsan123, sex=男, id=1, age=20, email=zhangsan@qq.com, username=张三}, {password=lisi123, sex=女, id=2, age=21, email=lisi@qq.com, username=李四}, {password=wangwu123, sex=男, id=3, age=22, email=wangwu@qq.com, username=王五}, {password=zhaoliu123, sex=女, id=4, age=23, email=zhaoliu@qq.com, username=赵六} ] -->
（2）方式二：@MapKey注解
- mapper接口
/** * 查询所有用户信息为map集合 * 方式二： * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合， * 并且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合 */ @MapKey("id") //Map<String, Map<String, Object>> getAllUserToMap(); Map<String, Object> getAllUserToMap();
- mapper映射文件
<!-- @MapKey("id") --> <!-- Map<String, Object> getAllUserToMap(); --> <select id="getAllUserToMap" resultType="map"> select * from t_user </select> <!-- 结果： { 1={password=zhangsan123, sex=男, id=1, age=20, email=zhangsan@qq.com, username=张三}, 2={password=lisi123, sex=女, id=2, age=21, email=lisi@qq.com, username=李四}, 3={password=wangwu123, sex=男, id=3, age=22, email=wangwu@qq.com, username=王五}, 4={password=zhaoliu123, sex=女, id=4, age=23, email=zhaoliu@qq.com, username=赵六} } -->
7、查询结果总结
- 若查询出的数据只有一条
- a > 可以通过实体类对象接收
- b > 可以通过List集合接收
- c > 可以通过Map集合接收
- 若查询出的数据有多条
- a > 可以通过实体类类型的List集合接收
- b > 可以通过Map类型的List集合接收，即 List<Map<String, Object>>
- c > 可以在mapper接口的方法上添加
@MapKey注解，此时就可以将每条数据转换的Map集合作为值，以某个字段的值作为键，放在同一个Map集合中，即 Map<String, Map<String, Object>>
注意：查询返回多条数据时一定不能通过实体类对象接收，会抛TooManyResultsException异常。
五、特殊SQL的执行场景
虽然我们为了预防SQL注入，尽量选择使用#{}，但有些场景下可能需要使用${}才可以完成，下面是一些编写SQL时的特殊场景。
1、模糊查询
- mapper接口
/** * 根据用户名模糊查询用户信息 */ List<User> getUserByLike(@Param("username") String username);
- mapper映射文件
<!-- List<User> getUserByLike(@Param("username") String username); --> <select id="getUserByLike" resultType="User"> <!-- 错误写法：'%?%' 相当于'%'张'%' --> <!--select * from t_user where username like '%#{username}%'--> <!-- 正确写法：'%张%' --> <!--select * from t_user where username like '%${username}%'--> <!--select * from t_user where username like concat('%', #{username}, '%')--> select * from t_user where username like "%"#{username}"%" </select>
- 测试
@Test public void testGetUserByLike(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); SQLMapper mapper = sqlSession.getMapper(SQLMapper.class); List<User> list = mapper.getUserByLike("张"); System.out.println(list); }
2、批量删除
- mapper接口
/** * 批量删除 */ int deleteMore(@Param("ids") String ids);
- mapper映射文件
<!-- int deleteMore(@Param("ids") String ids); --> <delete id="deleteMore"> -- 方法一：通过${}进行批量删除 -- delete from t_user where id in (${ids}) -- 方法二：通过foreach标签遍历ids，配合#{}进行批量删除 delete from t_user where id in <foreach item="id" index="index" collection="ids" open="(" separator="," close=")"> #{id} </foreach> </delete>
- 测试
@Test public void testDeleteMore(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); SQLMapper mapper = sqlSession.getMapper(SQLMapper.class); int result = mapper.deleteMore("1,2,3"); System.out.println(result); }
3、动态设置表名
- mapper接口
/** * 查询指定表中的数据 */ List<User> getUserByTableName(@Param("tableName") String tableName);
- mapper映射文件
<!-- List<User> getUserByTableName(@Param("tableName") String tableName); --> <select id="getUserByTableName" resultType="User"> select * from ${tableName} </select>
- 测试
@Test public void testGetUserByTableName(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); SQLMapper mapper = sqlSession.getMapper(SQLMapper.class); List<User> list = mapper.getUserByTableName("t_user"); System.out.println(list); }
4、动态设置排序规则
- mapper接口
/** * 动态设置排序规则 */ List<User> getUserByOrder(@Param("rule") String role);
- mapper映射文件
<!-- List<User> getUserByOrder(@Param("rule") String role); --> <select id="getUserByOrder" resultType="com.aizen.mybatis_demo2.pojo.User"> <!-- 相当于order by id 'desc'，SQL语法错误 --> <!-- select * from t_user order by id #{rule} --> select * from t_user order by id ${rule} </select>
- 测试
@Test public void testGetUserByOrder(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); SQLMapper mapper = sqlSession.getMapper(SQLMapper.class); List<User> list = mapper.getUserByOrder("desc"); System.out.println(list); }
需要注意：如果使用了${}拼接参数，一定要在参数拼接之前进行严格的校验，防止SQL注入攻击。
5、insert标签中开启获取自增主键功能
- mapper接口
/** * 添加用户信息 * useGeneratedKeys：设置使用自增的主键 * keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中 */ void insertUser(User user);
- mapper映射文件
<!-- 获取递增的主键值，需要在映射文件的sql语句中使用useGeneratedKeys和keyProperty共同来设置 useGeneratedKeys:设置当前标签中sql的表是否使用自增主键 keyProperty:将自增的主键的值赋值给（实体类）参数的哪个属性 应用场景：在一对多、多对多插入时，插入每条数据后并将主键值设置到实体类属性上，方便给多的一方表或中间表的主键属性设置值 --> <!-- void insertUser(User user); --> <insert id="insertUser" useGeneratedKeys="true" keyProperty="id"> insert into t_user values(null, #{username}, #{password}, #{age}, #{sex}, #{email}) </insert>
- 测试
@Test public void testInsertUser(){ SqlSession sqlSession = SqlSessionUtils.getSqlSession(); SQLMapper mapper = sqlSession.getMapper(SQLMapper.class); User user = new User(null, "田七", "tianqi123", 24, "男", "tianqi@qq.com"); mapper.insertUser(user); System.out.println(user); }
我们在测试插入数据的时候并没有指定id值，实体类中id属性传递的是null，表示由数据库主键自增。但开启了MyBatis的获取自增主键功能，因此我们传递的实体类中的id属性在插入完成后会自动的被赋值。这就是获取自增主键的用法。
六、自定义映射resultMap
1、字段名和实体类中的属性名不一致解决方案
如果某个字段名和对应的实体类中的属性名不一致，查询出来的该字段的值为null。为了解决这个问题，有三种解决方案。
（1）为字段起别名，保持和属性名的一致
可以通过使用as关键字为字段手动指定别名，as可以省略，保证与实体类中的属性名保持一致
<!-- 使用as为字段手动指定别名，as可以省略 --> <select id="getAllEmp" resultType="Emp"> select eid,emp_name as empName,age,sex,email from t_emp </select>
（2）开启MyBatis驼峰命名自动映射
可以在MyBatis的核心配置文件中设置一个全局配置信息mapUnderscoreToCamelCase，在查询表中数据时，自动将_类型的字段名转换为驼峰别名
<!-- 全局参数 --> <settings> <!-- 将表中字段的下划线自动转换为驼峰 --> <setting name="mapUnderscoreToCamelCase" value="true"/> </settings>
注意：确保字段名符合数据库的规则（使用_），实体类中的属性名符合Java的规则（使用驼峰）
例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为userName
MyBatis全局配置参数：https://mybatis.org/mybatis-3/zh_CN/configuration.html#settings
（3）通过resultMap设置自定义的映射关系
若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射
<!-- resultMap：设置自定义映射关系 属性： id：唯一标识，不能重复 type：设置映射关系中的实体类类型 子标签： id：设置主键的映射关系 result：设置普通字段的映射关系 属性： property：设置映射关系中的属性名，必须是type属性所设置的实体类类型中的属性名 column：设置映射关系中的字段名，必须是sql语句查询出的字段名 --> <resultMap id="empResultMap" type="Emp"> <id property="eid" column="eid"></id> <result property="empName" column="emp_name"></result> <result property="age" column="age"></result> <result property="sex" column="sex"></result> <result property="email" column="email"></result> </resultMap> <!-- List<Emp> getAllEmp(); --> <select id="getAllEmp" resultMap="empResultMap"> select * from t_emp </select>
不过一般处理字段名和属性名映射问题，无需专门使用resultMap来处理，resultMap大多数情况下是用来处理多对一（association）和一对多（collection）的映射关系的。
2、多对一映射处理
- 需求：查询员工信息以及员工所对应的部门信息（对一）
表关系说明：部门表 t_dept 和员工表 t_emp 的表关系是一对多，一个部门可以有多个员工，一个员工只能属于一个部门。
在数据库中表关系有下面三种情况：
- 一对一
- 一对多 | 多对一
- 多对多
而在MyBatis查询中，只有对一和对多两种查询映射方式。
- 对一：根据员工id，查询员工基本信息以及该员工所对应的部门信息（员工对部门，对一）
- 对多：根据部门id，查询部门基本信息以及该部门下所有的员工信息（部门对员工，对多）
一般在实际开发过程中，为了提升多表联查时的效率，很多时候我们不会为数据库表中一对多、多对多的关系创建数据库层面的外键约束，而是在Java代码中去手动维护一个逻辑外键进行查询。具体操作如下：
- 数据库表结构：在处理一对多的表关系时，需要在多的一方的表中添加一的一方的主键作为多的一方的外键，但是这里不添加外键约束。
- Java代码维护外键：在处理一对多的表关系时，需要在多的一方的实体类中创建一的一方的实体类对象。并且在一的一方的实体类中创建多的一方的实体类的集合。
public class Emp { private Integer eid; private String empName; private Integer age; private String sex; private String email; // 员工所属部门，一个员工属于一个部门 private Dept dept; // 体现的是对一的关系 }
例如，在Emp的属性中添加Dept的实体类，表示该员工所对应的部门对象。
public class Dept { private Integer did; private String deptName; // 部门包含的员工集合，一个部门包含多个员工 private List<Emp> emps; // 体现的是对多的关系 }
例如，在Dept的属性中添加Emp的实体类集合，表示该部门下所有的员工集合。
多表结果实体类设计技巧：
- 对一，属性中包含一的对象
- 对多，属性中包含多的对象集合
只有真实发生多表查询时，才需要设计和修改实体类，否则不提前设计和修改实体类！
无论多少张表联查，实体类设计都是两两考虑！
在查询映射的时候，只需要关注本次查询相关的属性！例如，查询员工以及员工所对应的部门信息（对一），只需要考虑查询将did和deptName赋值给Dept属性，而Dept表中的List<Emp>属性无需查询。
（1）级联方式处理对一映射关系
- mapper接口
/** * 查询员工以及员工所对应的部门信息 */ Emp getEmpAndDept(@Param("eid") Integer eid);
- mapper映射文件
<!-- 处理多对一映射关系方式一：级联属性赋值 --> <resultMap id="empAndDeptResultMapOne" type="Emp"> <id property="eid" column="eid"></id> <result property="empName" column="emp_name"></result> <result property="age" column="age"></result> <result property="sex" column="sex"></result> <result property="email" column="email"></result> <result property="dept.did" column="did"></result> <result property="dept.deptName" column="dept_name"></result> </resultMap> <!-- Emp getEmpAndDept(@Param("eid") Integer eid); --> <select id="getEmpAndDept" resultMap="empAndDeptResultMapOne"> select * from t_emp left join t_dept on t_emp.did = t_dept .did where t_emp.eid = #{eid} </select>
（2）使用association处理对一映射关系
- mapper接口
/** * 根据员工id查询员工以及该员工所对应的部门信息 */ Emp getEmpAndDeptByEid(@Param("eid") Integer eid);
- mapper映射文件
<!-- 处理多对一映射关系方式二：association 定义嵌套对象的映射关系 --> <resultMap id="empAndDeptResultMapTwo" type="Emp"> <!-- 第一层属性赋值（相当于resultType），Emp对象 --> <id property="eid" column="eid"/> <result property="empName" column="emp_name"/> <result property="age" column="age"/> <result property="sex" column="sex"/> <result property="email" column="email"/> <!-- 对象属性赋值 association：处理多对一的映射关系 property：对一的对象属性名 javaType：对一的对象属性的类型 --> <association property="dept" javaType="Dept"> <!-- 第二层属性赋值，Dept对象 --> <id property="did" column="did"/> <result property="deptName" column="dept_name"/> </association> </resultMap> <!-- Emp getEmpAndDeptByEid(@Param("eid") Integer eid); --> <select id="getEmpAndDeptByEid" resultMap="empAndDeptResultMapTwo"> select emp.*,dept.* from t_emp emp left join t_dept dept on emp.did = dept.did where emp.eid = #{eid} </select>
（3）使用association分步查询
先查询员工信息，再根据员工所对应的部门id查询部门信息
- mapper接口
public interface EmpMapper { /** * 通过分步查询查询员工以及员工所对应的部门信息 * 分步查询第一步：查询员工信息 */ Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid); // ... } public interface DeptMapper { /** * 通过分步查询查询员工以及员工所对应的部门信息 * 分步查询第二步：通过did查询员工所对应的部门 */ Dept getEmpAndDeptByStepTwo(@Param("did") Integer did); // ... }
- mapper映射文件
<!-- EmpMapper.xml中使用resultMap做分步映射 --> <resultMap id="empAndDeptByStepResultMap" type="Emp"> <id property="eid" column="eid"></id> <result property="empName" column="emp_name"></result> <result property="age" column="age"></result> <result property="sex" column="sex"></result> <result property="email" column="email"></result> <!-- select：设置分步查询的sql的唯一标识（namespace.SQLId或mapper接口的全类名.方法名） column：设置分步查询的条件 --> <association property="dept" select="com.aizen.mybatis_demo3.mapper.DeptMapper.getEmpAndDeptByStepTwo" column="did"></association> </resultMap> <!-- Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid); --> <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap"> select * from t_emp where eid = #{eid} </select> <!-- DeptMapper.xml中使用resultType做单步查询 --> <!-- Dept getEmpAndDeptByStepTwo(@Param("did") Integer did); --> <select id="getEmpAndDeptByStepTwo" resultType="Dept"> select * from t_dept where did = #{did} </select>
（4）扩展：延迟加载
分步查询的优点：可以实现延迟加载。
需要在核心配置文件中设置全局配置信息：
- mybatis-config.xml核心配置文件
<!-- 全局配置 --> <settings> <!-- 开启驼峰命名自动映射 --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- 开启延迟加载 --> <setting name="lazyLoadingEnabled" value="true"/> </settings>
lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象默认都会延迟加载。aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个属性会按需加载。该值默认为false，也无需设置开启。- 保证
lazyLoadingEnabled=true、aggressiveLazyLoading=false即可开启懒加载。 - mapper映射文件
<resultMap id="empAndDeptByStepResultMap" type="Emp"> <id property="eid" column="eid"/> <result property="empName" column="emp_name"/> <result property="age" column="age"/> <result property="sex" column="sex"/> <result property="email" column="email"/> <!-- select：设置分步查询的sql的唯一标识（namespace.SQLId或mapper接口的全类名.方法名） column：设置分布查询的条件 fetchType:当开启了全局的延迟加载之后，可通过此属性手动控制延迟加载的效果 fetchType="lazy|eager"：lazy表示延迟加载（默认），eager表示立即加载 --> <association property="dept" select="com.aizen.mybatis_demo3.mapper.DeptMapper.getEmpAndDeptByStepTwo" column="did" fetchType="eager"/> </resultMap> <!-- Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid); --> <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap"> select * from t_emp where eid = #{eid} </select>
此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType="lazy(延迟加载) | eager(立即加载)"，实现SQL延迟加载的细粒度控制。
3、一对多映射处理
（1）使用collection处理对多映射关系
- mapper接口
public interface DeptMapper { /** * 获取部门以及部门中所有的员工信息 */ Dept getDeptAndEmp(@Param("did") Integer did); }
- mapper映射文件
<!-- 对多关系映射 --> <resultMap id="deptAndEmpResultMap" type="Dept"> <id property="did" column="did"></id> <result property="deptName" column="dept_name"></result> <!-- collection：处理一对多的映射关系 ofType：表示该属性所对应的集合中存储数据的类型 --> <collection property="emps" ofType="Emp"> <id property="eid" column="eid"></id> <result property="empName" column="emp_name"></result> <result property="age" column="age"></result> <result property="sex" column="sex"></result> <result property="email" column="email"></result> </collection> </resultMap> <!-- Dept getDeptAndEmp(@Param("did") Integer did); --> <select id="getDeptAndEmp" resultMap="deptAndEmpResultMap"> select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did} </select>
（2）使用collection分步查询
- mapper接口
public interface DeptMapper { /** * 通过分步查询查询部门以及部门中所有的员工信息 * 分步查询第一步：查询部门信息 */ Dept getDeptAndEmpByStepOne(@Param("did") Integer did); } public interface EmpMapper { /** * 通过分步查询查询部门以及部门中所有的员工信息 * 分步查询第二步：根据did查询员工信息 */ List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did); }
- mapper映射文件
<!-- DeptMapper.xml中使用resultMap做分步映射 --> <resultMap id="deptAndEmpByStepResultMap" type="Dept"> <id property="did" column="did"/> <result property="deptName" column="dept_name"/> <collection property="emps" select="com.aizen.mybatis_demo3.mapper.EmpMapper.getDeptAndEmpByStepTwo" column="did" fetchType="lazy"/> </resultMap> <!-- Dept getDeptAndEmpByStepOne(@Param("did") Integer did); --> <select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpByStepResultMap"> select * from t_dept where did = #{did} </select> <!-- EmpMapper.xml中使用resultType做单步查询 --> <!-- List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did); --> <select id="getDeptAndEmpByStepTwo" resultType="Emp"> select * from t_emp where did = #{did} </select>
总结：
对一：使用association给对象属性赋值
对多：使用collection给对象集合属性赋值
七、动态SQL
Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题。
1、if
if标签可通过test属性的表达式进行判断，若表达式的结果为true，则标签中的内容会被拼接到SQL中；反之标签中的内容不会被拼接到SQL中。
<!-- List<Emp> getEmpByCondition(Emp emp); --> <select id="getEmpByCondition" resultType="Emp"> select * from t_emp where 1=1 <if test="empName != null and empName != ''"> emp_name = #{empName} </if> <if test="age != null and age != ''"> and age = #{age} </if> <if test="sex != null and sex != ''"> and sex = #{sex} </if> <if test="email != null and email != ''"> and email = #{email} </if> </select> <!-- List<Emp> list = mapper.getEmpByCondition(new Emp(null, "张三", 23, "男", "zhangsan@qq.com")); -->
通过添加1=1恒成立条件，确保第一个条件为null或空字符串时不拼接，where和后面的条件前的and直接拼接造成SQL语法错误。
2、where
where 和 if一般结合使用：
- 若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加WHERE关键字
- 若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and或or去掉
<select id="getEmpByCondition" resultType="Emp"> select * from t_emp <where> <if test="empName != null and empName != ''"> emp_name = #{empName} </if> <if test="age != null and age != ''"> and age = #{age} </if> <if test="sex != null and sex != ''"> or sex = #{sex} </if> <if test="email != null and email != ''"> and email = #{email} </if> </where> </select> <!-- List<Emp> list = mapper.getEmpByCondition(new Emp(null, "", 23, "", null)); -->
注意：where标签不能去掉拼接内容后面多余的and或or！如果传入不符合条件的属性值，and或or拼接在后面就会报错，例如下面的情况：
<select id="getEmpByCondition" resultType="Emp"> select * from t_emp <where> <if test="empName != null and empName != ''"> emp_name = #{empName} and </if> <if test="age != null and age != ''"> age = #{age} and </if> <if test="sex != null and sex != ''"> sex = #{sex} or </if> <if test="email != null and email != ''"> email = #{email} </if> </where> </select> <!-- List<Emp> list = mapper.getEmpByCondition(new Emp(null, "张三", null, "", null)); -->
3、trim
trim标签用于去掉或添加标签中的内容。
常用属性：
- prefix：在trim标签中的内容的前面添加某些内容
- prefixOverrides：在trim标签中的内容的前面去掉某些内容
- suffix：在trim标签中的内容的后面添加某些内容
- suffixOverrides：在trim标签中的内容的后面去掉某些内容
<select id="getEmpByCondition" resultType="Emp"> select <include refid="empColumns"></include> from t_emp <trim prefix="where" suffixOverrides="and|or"> <if test="empName != null and empName != ''"> emp_name = #{empName} and </if> <if test="age != null and age != ''"> age = #{age} or </if> <if test="sex != null and sex != ''"> sex = #{sex} and </if> <if test="email != null and email != ''"> email = #{email} </if> </trim> </select> <!-- List<Emp> list = mapper.getEmpByCondition(new Emp(null, "张三", 23, "", null)); -->
注意：
（1）如果需要去掉的内容有多个以 | 分隔。
（2）如果trim标签中没有内容时，trim标签也没有任何效果
4、choose、when、otherwise
choose、when、otherwise三个标签通常是配合起来使用，相当于if...else if..else...结构，when中的条件有一个满足，choose标签中其他的when标签都不会执行。
也相当于："choose"="switch"，"when"="case"，"otherwise"="default"，且when不会穿透。
<!-- List<Emp> getEmpByChoose(Emp emp); --> <select id="getEmpByChoose" resultType="Emp"> select * from t_emp <where> <choose> <when test="empName != null and empName != ''"> emp_name = #{empName} </when> <when test="age != null and age != ''"> age = #{age} </when> <when test="sex != null and sex != ''"> sex = #{sex} </when> <when test="email != null and email != ''"> email = #{email} </when> <otherwise> did = 1 </otherwise> </choose> </where> </select>
注意：使用了choose标签后，when标签至少要有一个，otherwise标签最多只能有一个。
5、foreach
foreach标签用于遍历数组或集合，通常用来实现批量删除、批量添加等SQL。
常用属性：
- collection：设置要循环的数组或集合
- item：表示集合或数组中的每一个数据
- separator：设置循环体之间的分隔符
- open：设置foreach标签中的内容的开始符
- close：设置foreach标签中的内容的结束
（1）通过数组进行批量删除
方式一：delete from 表名 where id in (1, 2, 3);
<!-- int deleteMoreByArray(@Param("eids") Integer[] eids); --> <delete id="deleteMoreByArray"> delete from t_emp where eid in <foreach collection="eids" item="eid" separator="," open="(" close=")"> #{eid} </foreach> </delete>
方式二：delete from 表名 where id = 1 or id = 2 or id = 3;
<!-- int deleteMoreByArray(@Param("eids") Integer[] eids); --> <delete id="deleteMoreByArray"> delete from t_emp where <foreach collection="eids" item="eid" separator="or"> eid = #{eid} </foreach> </delete>
注意：
如果使用了@Param注解指定了参数key别名，则collection的值为指定的参数key别名。
如果没有使用@Param注解，则MyBatis默认会将参数封装到Map中：
- 如果参数是数组类型，以array、arg0作为key访问
- 如果参数是集合类型，以list、collection、arg0作为key访问
（2）通过集合进行批量新增
写法一：
<!-- int insertMoreByList(@Param("emps") List<Emp> emps); --> <insert id="insertMoreByList"> insert into t_emp values <foreach collection="emps" item="emp" separator=","> (null, #{emp.empName}, #{emp.age}, #{emp.sex}, #{emp.email}, null) </foreach> </insert>
写法二：
<!-- int insertMoreByList(@Param("emps") List<Emp> emps); --> <insert id="insertMoreByList"> insert into t_emp values <foreach collection="emps" item="emp" open="(" separator="), (" close=")"> null, #{emp.empName}, #{emp.age}, #{emp.sex}, #{emp.email}, null </foreach> </insert>
6、sql片段
sql片段：可以记录一段公共sql片段，在使用的地方通过include标签进行引入，目的是为了减少重复代码的编写，提高sql语句的复用性。
设置SQL片段：<sql id="empColumns">eid, emp_name, age, sex, email</sql> 引用SQL片段：<include refid="empColumns"/>
常见写法一：字段预定义
<sql id="empColumns">eid, emp_name, age, sex, email</sql> <!-- List<Emp> getEmpByCondition(Emp emp); --> <select id="getEmpByCondition" resultType="Emp"> select <include refid="empColumns"></include> from t_emp <trim prefix="where" suffixOverrides="and|or"> <if test="empName != null and empName != ''"> emp_name = #{empName} and </if> <if test="age != null and age != ''"> age = #{age} or </if> <if test="sex != null and sex != ''"> sex = #{sex} and </if> <if test="email != null and email != ''"> email = #{email} </if> </trim> </select>
常见写法二：扩大复用范围
<sql id="empSelect">select eid, emp_name, age, sex, email from t_emp</sql> <!-- List<Emp> getEmpByCondition(Emp emp); --> <select id="getEmpByCondition" resultType="Emp"> <include refid="empSelect"/> <trim prefix="where" suffixOverrides="and|or"> <if test="empName != null and empName != ''"> emp_name = #{empName} and </if> <if test="age != null and age != ''"> age = #{age} or </if> <if test="sex != null and sex != ''"> sex = #{sex} and </if> <if test="email != null and email != ''"> email = #{email} </if> </trim> </select>
八、MyBatis的缓存
MyBatis的一级缓存是默认开启的，二级缓存需要手动配置，它们的级别不一样，即作用范围不同。
1、MyBatis一级缓存
一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问。
- 测试一级缓存
@Test public void testOneCache() { // 从同一个sqlSession中获取两次Mapper SqlSession sqlSession = SqlSessionUtils.getSqlSession(); CacheMapper mapper1 = sqlSession.getMapper(CacheMapper.class); Emp emp1 = mapper1.getEmpByEid(1); System.out.println(emp1); CacheMapper mapper2 = sqlSession.getMapper(CacheMapper.class); Emp emp2 = mapper2.getEmpByEid(1); System.out.println(emp2); }
sql语句只输出了一次，第二次查询相同数据时，没有从数据库进行查询，而是从MyBatis一级缓存中直接获取。
使一级缓存失效的四种情况：
- 不同的SqlSession对应不同的一级缓存
- 一级缓存失效情况1
@Test public void testOneCacheInvalid1() { // 从不同sqlSession中获取两次Mapper（证明与Mapper无关） System.out.println("-----[创建第一个sqlSession进行查询]-----"); SqlSession sqlSession1 = SqlSessionUtils.getSqlSession(); CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class); Emp emp1 = mapper1.getEmpByEid(1); System.out.println(emp1); System.out.println("-----[第一个sqlSession查询结束]-----"); System.out.println("-----[创建第二个sqlSession进行查询]-----"); SqlSession sqlSession2 = SqlSessionUtils.getSqlSession(); CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class); Emp emp2 = mapper2.getEmpByEid(1); System.out.println(emp2); System.out.println("-----[第二个sqlSession查询结束]-----"); }
- 同一个SqlSession但是查询条件不同（查询缓存中没有查过的新数据时，不会查询缓存）
- 一级缓存失效情况2
@Test public void testOneCacheInvalid2() { // 从同一个sqlSession中获取两次Mapper，但是查询的数据不同 SqlSession sqlSession = SqlSessionUtils.getSqlSession(); CacheMapper mapper1 = sqlSession.getMapper(CacheMapper.class); Emp emp1 = mapper1.getEmpByEid(1); System.out.println(emp1); CacheMapper mapper2 = sqlSession.getMapper(CacheMapper.class); Emp emp2 = mapper2.getEmpByEid(2); System.out.println(emp2); }
- 同一个SqlSession两次查询期间执行了任何一次增删改操作（在两次查询之间执行任意一次增删改之后会清空缓存）
- 一级缓存失效情况3
@Test public void testOneCacheInvalid3() { // 同一个SqlSession两次查询期间执行了任何一次增删改操作 SqlSession sqlSession = SqlSessionUtils.getSqlSession(); CacheMapper mapper = sqlSession.getMapper(CacheMapper.class); Emp emp1 = mapper.getEmpByEid(1); System.out.println(emp1); mapper.insertEmp(new Emp(null,"abc", 23, "男", "123@qq.com")); Emp emp2 = mapper.getEmpByEid(1); System.out.println(emp2); }
只要是两次查询之间执行任意一次增删改操作，MyBatis不管该操作是否影响了缓存中的数据，都会将缓存中的数据清空掉。
- 同一个SqlSession两次查询期间手动清空了缓存（手动调用SqlSession的clearCache方法清空缓存）
- 一级缓存失效情况4
@Test public void testOneCacheInvalid4() { // 同一个SqlSession两次查询期间手动清空了缓存 SqlSession sqlSession = SqlSessionUtils.getSqlSession(); CacheMapper mapper = sqlSession.getMapper(CacheMapper.class); Emp emp1 = mapper.getEmpByEid(1); System.out.println(emp1); // 手动清空一级缓存 sqlSession.clearCache(); Emp emp2 = mapper.getEmpByEid(1); System.out.println(emp2); }
sqlSession.clearCache()方法：仅对清空一级缓存有效
2、MyBatis二级缓存
二级缓存是SqlSessionFactory级别的，一个SqlSessionFactory可以创建多个SqlSession，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取。
二级缓存开启的条件：
- 在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true，不需要设置
<!-- 设置MyBatis的全局配置 --> <settings> <!-- 开启二级缓存，默认为true开启 --> <setting name="cacheEnabled" value="true"/> </settings>
- 在映射文件中设置
<cache />标签
<?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.aizen.mybatis_demo3.mapper.CacheMapper"> <cache /> <!-- Emp getEmpByEid(@Param("eid") Integer eid); --> <select id="getEmpByEid" resultType="Emp"> select * from t_emp where eid = #{eid} </select> <!-- void insertEmp(Emp emp); --> <insert id="insertEmp"> insert into t_emp values(null, #{empName}, #{age}, #{sex}, #{email}, null) </insert> </mapper>
- 二级缓存必须在SqlSession关闭或提交之后有效
sqlSession.commit(); // 提交仅针对增删改操作 sqlSession.close();
什么时候数据才会保存在二级缓存中？
在我们没有关闭或提交SqlSession时，查询的数据会被保存在一级缓存中，当我们关闭或提交了SqlSession后，数据才会被保存到二级缓存中。
- 查询的数据所转换的实体类类型必须实现序列化的接口
import java.io.Serializable; public class Emp implements Serializable { private static final long serialVersionUID = 1L; // ... }
- 测试二级缓存
@Test public void testTwoCache() { try { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); SqlSession sqlSession1 = sqlSessionFactory.openSession(true); CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class); System.out.println(mapper1.getEmpByEid(1)); sqlSession1.close(); // 关闭sqlSession，保存查询数据到二级缓存 SqlSession sqlSession2 = sqlSessionFactory.openSession(true); CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class); System.out.println(mapper2.getEmpByEid(1)); sqlSession2.close(); // 关闭sqlSession，保存查询数据到二级缓存 } catch (IOException e) { e.printStackTrace(); } }
使二级缓存失效的情况： 两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效
- 测试二级缓存失效
@Test public void testTwoCache() { try { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); SqlSession sqlSession1 = sqlSessionFactory.openSession(true); CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class); System.out.println(mapper1.getEmpByEid(1)); // 执行增删改操作，使一级缓存和二级缓存都失效 mapper1.insertEmp(new Emp(null,"abc", 23, "男", "123@qq.com")); // 关闭sqlSession，保存查询数据到二级缓存 sqlSession1.close(); SqlSession sqlSession2 = sqlSessionFactory.openSession(true); CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class); System.out.println(mapper2.getEmpByEid(1)); // 关闭sqlSession，保存查询数据到二级缓存 sqlSession2.close(); } catch (IOException e) { e.printStackTrace(); } }
3、二级缓存相关属性
在mapper配置文件中添加的cache标签可以设置一些属性：
- eviction属性：缓存回收策略，默认的是 LRU。
- LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。
- FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。
- SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
- WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
- flushInterval属性：二级缓存刷新间隔，单位毫秒。
- 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用增删改语句时刷新。
- size属性：引用数目，正整数。
- 代表缓存最多可以存储多少个对象，太大容易导致内存溢出 。
- readOnly属性：只读，true/false，默认是false。
- true：只读缓存；返回缓存对象的相同实例给所有调用者。因此readOnly="true"表示的是不建议修改，并不是不能修改。虽然不是缓存拷贝对象不安全，但是性能快。
- false：读写缓存；会返回缓存对象的拷贝（通过序列化）。虽然性能稍慢，但是安全。
- type属性：指定二级缓存使用的类型，可用于整合第三方缓存，默认为MyBatis二级缓存。
4、MyBatis缓存查询的顺序
先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。
如果二级缓存没有命中，再查询一级缓存
如果一级缓存也没有命中，则查询数据库
SqlSession关闭之后，一级缓存中的数据会写入二级缓存
5、MyBatis整合第三方缓存EHCache
- 添加依赖
<!-- Mybatis EHCache整合包 --> <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-ehcache</artifactId> <version>1.2.1</version> </dependency> <!-- slf4j日志门面的一个具体实现 --> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.3</version> </dependency>
- 各jar包功能
jar包名称 |
作用 |
mybatis-ehcache |
Mybatis和EHCache的整合包 |
ehcache |
EHCache核心包 |
slf4j-api |
SLF4J日志门面包 |
logback-classic |
支持SLF4J门面接口的一个具体实现 |
- 在resourses目录下创建EHCache的配置文件ehcache.xml
<?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:\Develop\MyBatis\ehcache"/> <defaultCache maxElementsInMemory="1000" maxElementsOnDisk="10000000" eternal="false" overflowToDisk="true" timeToIdleSeconds="120" timeToLiveSeconds="120" diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU"> </defaultCache> </ehcache>
- 设置二级缓存的类型
<cache type="org.mybatis.caches.ehcache.EhcacheCache" />
- 加入logback日志
存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志。
在resourses目录下创建logback的配置文件logback.xml
<?xml version="1.0" encoding="UTF-8"?> <configuration debug="true"> <!-- 指定日志输出的位置 --> <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <!-- 日志输出的格式 --> <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 --> <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern> </encoder> </appender> <!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR --> <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 --> <root level="DEBUG"> <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender --> <appender-ref ref="STDOUT" /> </root> <!-- 根据特殊需求指定局部日志级别 --> <logger name="com.aizen.crowd.mapper" level="DEBUG"/> </configuration>
- EHCache配置文件说明
属性名 |
是否必须 |
作用 |
maxElementsInMemory |
是 |
在内存中缓存的element的最大数目 |
maxElementsOnDisk |
是 |
在磁盘上缓存的element的最大数目，若是0表示无穷大 |
eternal |
是 |
设定缓存的elements是否永远不过期。 如果为true，则缓存的数据始终有效， 如果为false那么还要根据timeToIdleSeconds、timeToLiveSeconds判断 |
overflowToDisk |
是 |
设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上 |
timeToIdleSeconds |
否 |
当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时， 这些数据便会删除，默认值是0,也就是可闲置时间无穷大 |
timeToLiveSeconds |
否 |
缓存element的有效生命期，默认是0，也就是element存活时间无穷大 |
diskSpoolBufferSizeMB |
否 |
DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区 |
diskPersistent |
否 |
在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。 |
diskExpiryThreadIntervalSeconds |
否 |
磁盘缓存的清理线程运行间隔，默认是120秒。每个120s， 相应的线程会进行一次EhCache中数据的清理工作 |
memoryStoreEvictionPolicy |
否 |
当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。 默认是LRU（最近最少使用），可选的有LFU（最不常使用）和 FIFO（先进先出） |
九、MyBatis的逆向工程
- 正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。Hibernate是支持正向工程的。
- 逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：
- Java实体类
- Mapper接口
- Mapper映射文件
1、创建逆向工程的步骤
- 新建一个MyBatis_MBG项目工程
- 添加依赖和插件
<!-- 依赖MyBatis核心包 --> <dependencies> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.7</version> </dependency> </dependencies> <!-- 控制Maven在构建过程中相关配置 --> <build> <!-- 构建过程中用到的插件 --> <plugins> <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 --> <plugin> <groupId>org.mybatis.generator</groupId> <artifactId>mybatis-generator-maven-plugin</artifactId> <version>1.3.0</version> <!-- 插件的依赖 --> <dependencies> <!-- 逆向工程的核心依赖 --> <dependency> <groupId>org.mybatis.generator</groupId> <artifactId>mybatis-generator-core</artifactId> <version>1.3.2</version> </dependency> <!-- 数据库连接池 --> <dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>0.9.2</version> </dependency> <!-- MySQL驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.33</version> </dependency> </dependencies> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>17</source> <target>17</target> </configuration> </plugin> </plugins> </build>
- 创建MyBatis的核心配置文件
<?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 resource="jdbc.properties"/> <!-- 设置MyBatis的全局配置 --> <settings> <!-- 将表中字段的下划线自动转换为驼峰命名 --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- 开启延迟加载 --> <setting name="lazyLoadingEnabled" value="true"/> <!-- 开启了mybatis的日志输出，选择使用system进行控制台输出 --> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> <typeAliases> <package name="com.aizen.mybatis.pojo"/> </typeAliases> <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> <mappers> <package name="com.aizen.mybatis.mapper"/> </mappers> </configuration>
- 创建逆向工程的配置文件
<?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: 生成带条件查询的CRUD（奢华尊享版） --> <context id="DB2Tables" targetRuntime="MyBatis3"> <!-- mysql的驱动是8.x的，要添加这个，不然会生成别的数据库中的同名表，出现文件名重复 --> <property name="nullCatalogMeansCurrent" value="true"/> <!-- 数据库的连接信息 --> <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=UTC&characterEncoding=UTF-8" userId="root" password="root"> </jdbcConnection> <!-- javaBean的生成策略 --> <javaModelGenerator targetPackage="com.aizen.mybatis.pojo" targetProject=".\src\main\java"> <property name="enableSubPackages" value="true" /> <property name="trimStrings" value="true" /> </javaModelGenerator> <!-- SQL映射文件的生成策略 --> <sqlMapGenerator targetPackage="com.aizen.mybatis.mapper" targetProject=".\src\main\resources"> <property name="enableSubPackages" value="true" /> </sqlMapGenerator> <!-- Mapper接口的生成策略 --> <javaClientGenerator type="XMLMAPPER" targetPackage="com.aizen.mybatis.mapper" targetProject=".\src\main\java"> <property name="enableSubPackages" value="true" /> </javaClientGenerator> <!-- 逆向分析的表 --> <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName --> <!-- domainObjectName属性指定生成出来的实体类的类名 --> <table tableName="t_emp" domainObjectName="Emp"/> <table tableName="t_dept" domainObjectName="Dept"/> </context> </generatorConfiguration>
- 执行MBG插件的generate目标
- 奢华尊享版的逆向工程生成效果
2、使用MyBatisX插件进行可视化逆向工程
在idea中安装MyBatisX插件
从Database中配置连接数据库，之后选中要逆向工程的表，右键点击MyBatisX-Generator
在界面中配置如下生成信息
这一步是调整如何生成Mapper接口和Mapper.xml文件，以及实体类生成的策略
以上就是使用MyBatisX插件生成逆向工程的方式。
3、QBC查询
Example是QBC（Query By Circumstance）查询风格
- 奢华尊享版的查询所有功能
@Test public void testMBGGetAllEmp() { try { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); // 查询所有数据 List<Emp> list = mapper.selectByExample(null); list.forEach(emp -> System.out.println(emp)); } catch (IOException e) { e.printStackTrace(); } }
- 奢华尊享版的条件查询功能
@Test public void testMBGGetEmpByCondition() { try { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); // 根据条件查询 EmpExample example = new EmpExample(); // 创建查询条件对象 example.createCriteria() // 创建查询条件 // 姓名等于张三并且年龄大于等于20 .andEmpNameEqualTo("张三") .andAgeGreaterThanOrEqualTo(20); // or条件也可以拼接前面的sql，查询所有部门id不为null的员工 example.or().andDidIsNotNull(); List<Emp> list = mapper.selectByExample(example); list.forEach(System.out::println); } catch (IOException e) { e.printStackTrace(); } }
- 奢华尊享版的选择性修改功能
@Test public void testMBGUpdateEmp() { try { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); // updateByPrimaryKey()：更新，如果条件更新的实体类有null值，会直接将该字段修改为null mapper.updateByPrimaryKey(new Emp(6,"admin",22,null,"456@qq.com",3)); // updateByPrimaryKeySelective()：选择性更新，如果条件更新的实体类有null值，会跳过该字段，不会进行更新 mapper.updateByPrimaryKeySelective(new Emp(7,"admin",22,null,"456@qq.com",3)); // 查询更新结果 EmpExample example = new EmpExample(); // 创建查询条件对象 example.createCriteria().andEidBetween(6, 7); // 创建查询条件 List<Emp> list = mapper.selectByExample(example); list.forEach(emp -> System.out.println(emp)); } catch (IOException e) { e.printStackTrace(); } }
十、分页插件
1、分页插件使用步骤
- 添加依赖
<!-- MyBatis分页插件 --> <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>5.3.3</version> </dependency>
- 在MyBatis的核心配置文件中配置分页插件
<plugins> <!-- 设置分页插件 --> <plugin interceptor="com.github.pagehelper.PageInterceptor"> <!-- 拦截mysql语法，加分页使用limit --> <property name="helperDialect" value="mysql"/> </plugin> </plugins>
2、分页插件的使用
- 在查询功能之前，使用
PageHelper.startPage(int pageNum, int pageSize)开启分页功能。
select * from tableName limit index,pageSize
pageNum：当前页的页码
pageSize：每页显示的条数
index：当前页的起始索引，index=(pageNum-1)*pageSize
例如：
pageNum=1, pageSize=4 --> index=0 limit 0,4
pageNum=3, pageSize=4 --> index=8 limit 8,4
pageNum=6, pageSize=4 --> index=20 limit 8,4
count：总记录数
totalPage：总页数，totalPage = count / pageSize
if (count % pageSize != 0) { // 不能整除说明还有不到一页的数据
totalPage += 1; // 总页数加一页展示剩余数据
}
- 在查询获取list集合之后，使用
PageInfo<T> pageInfo = new PageInfo<>(List<T> list, int navigatePages)获取分页相关详细数据。
list：表示分页数据
navigatePages：表示当前导航分页的数量，一般为奇数，保证导航分页的对称性
导航分页：最中间显示页码x，navigatePages为5，页码动态调整范围[x-2, x+2]
<a href="#">首页</a> <a href="#">上一页</a> <a href="#">2</a> <a href="#">3</a> <a href="#">4</a> <a href="#">5</a> <a href="#">6</a> <a href="#">下一页</a> <a href="#">末页</a>
情况1：如果展示的数据不够navigatePages页，则总页数有几页展示几页。
情况2：如果访问前两页，导航分页不能把前两页放在最中间，因为没有-1,0。
情况3：如果访问最后两页，导航分页的页码不能超过总页数，只能是最后navigatePages页。
- 分页相关数据
PageInfo{
pageNum=6, pageSize=4, size=4, startRow=21, endRow=24, total=31, pages=8,
list=Page{count=true, pageNum=6, pageSize=4, startRow=20, endRow=24, total=31, pages=8, reasonable=false, pageSizeZero=false}[Emp{eid=21, empName='a1', age=23, sex='男', email='123@qq.com', did=1}, Emp{eid=22, empName='a2', age=23, sex='男', email='123@qq.com', did=2}, Emp{eid=23, empName='a3', age=23, sex='男', email='123@qq.com', did=3}, Emp{eid=24, empName='a1', age=23, sex='男', email='123@qq.com', did=null}],
prePage=5, nextPage=7, isFirstPage=false, isLastPage=false, hasPreviousPage=true, hasNextPage=true, navigatePages=5, navigateFirstPage=4, navigateLastPage=8, navigatepageNums=[4, 5, 6, 7, 8]
}
常用数据：
pageNum：当前页的页码
pageSize：每页显示的条数
size：当前页显示的真实条数，比如最后一页数据不足pageSize时，显示size真实条数
total：总记录数
pages：总页数
prePage：上一页的页码
nextPage：下一页的页码
isFirstPage/isLastPage：是否为第一页/最后一页
hasPreviousPage/hasNextPage：是否存在上一页/下一页
navigatePages：导航分页的页码数
navigatepageNums：导航分页的页码，[1,2,3,4,5]
- 测试分页插件查询
/** * limit index,pageSize * index：当前页的起始索引 * pageSize：每页显示的条数 * pageNum：当前页的页码 * index=(pageNum-1)*pageSize * * 使用MyBatis的分页插件实现分页功能： * 1、需要在查询功能之前开启分页 * PageHelper.startPage(int pageNum, int pageSize); * 2、在查询功能之后获取分页相关信息 * PageInfo<T> page = new PageInfo<>(List<? extends T> list, int navigatePages); * list：表示分页数据 * navigatePages：表示当前导航分页的数量，一般为奇数，保证导航分页的对称性 */ @Test public void testPageHelper() { try { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); SqlSession sqlSession = sqlSessionFactory.openSession(true); EmpMapper mapper = sqlSession.getMapper(EmpMapper.class); Page<Object> page = PageHelper.startPage(1, 5); System.out.println(page); // 分页简单数据 List<Emp> list = mapper.selectByExample(null); System.out.println(list); PageHelper.clearPage(); // TODO: 注意不能将两条查询装到一个分页区，否则会分页失效。如果需要再次分页查询，需要再次调用PageHelper.startPage() PageHelper.startPage(6, 4); // 在查询功能之前开启分页 list = mapper.selectByExample(null); // 查询所有数据 PageInfo<Emp> pageInfo = new PageInfo<>(list, 5); // 在查询功能之后获取分页相关信息 System.out.println(pageInfo); // 分页详情数据 int pageNum = pageInfo.getPageNum(); // 当前页的页码 System.out.println("pageNum = " + pageNum); int pageSize = pageInfo.getPageSize(); // 每页显示的条数 System.out.println("pageSize = " + pageSize); int pages = pageInfo.getPages();// 总页数 System.out.println("pages = " + pages); long total = pageInfo.getTotal(); // 总条数 System.out.println("total = " + total); } catch (IOException e) { e.printStackTrace(); } }
