Mybatis
Mybatis
1、简介
1.1、什么是Mybatis
- MyBatis 是一款优秀的持久层框架
- 它支持自定义 SQL、存储过程以及高级映射。
- MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
- MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
- MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。
- 2013年11月迁移到Github。
如何获得Mybatis
-
maven仓库
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.2</version> </dependency> -
Github：https://github.com/mybatis/mybatis-3/releases/tag/mybatis-3.5.5
1.2、持久化
数据持久化
- 就是把数据（如内存中的对象）保存到存储设备中，如磁盘。
- 内存：断电即失，导致我们不能将一些总要数据存储在内存中，只能持久化到硬盘。
- 数据库（jdbc），io文件持久化
1.3、持久层
- 完成持久化工作的代码块 ----> dao层 【DAO (Data Access Object) 数据访问对象】
- 大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。
- 不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.
- 与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。【说白了就是用来操作数据库存在的！】
1.4、为什么需要Mybatis
- 方便
- 传统的JDBC代码太复杂了
- 帮助程序员将数据放入到数据库中
- 不用Mybatis也可以，但学Mybatis更容易上手
- MyBatis的优点
- 简单易学
- 灵活
- sql和代码的分离，提高了可维护性。
- 提供映射标签，支持对象与数据库的orm字段关系映射
- 提供对象关系映射标签，支持对象关系组建维护
- 提供xml标签，支持编写动态sql。
2、第一个Mybatis程序
思路：搭建环境-->导入Mybatis-->编写代码-->测试
2.1、搭建环境
1、搭建数据库
CREATE DATABASE mybatis;
USE mybatis;
CREATE TABLE user(
id INT(20) NOT NULL PRIMARY KEY,
name VARCHAR(30) DEFAULT NULL,
pwd VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO USER(id,name,pwd) VALUES
(1,"张三","123456"),
(2,"李四","1234567"),
(3,"王五","1234568");
2、新建项目
-
新建一个普通的Maven项目
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.2</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency> -
删除src目录
-
编写配置文件 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核心配置文件--> <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?useSSL=true&userUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="0927"/> </dataSource> </environment> </environments> <mappers> <mapper resource="com/hao/dao/userMapper.xml"/> </mappers> </configuratio </configuration> -
编写mybatis工具类
//sqlSessionFactory ---> sqlSession public class MybatisUtils { private static SqlSessionFactory sqlSessionFactory; static { try { //使用mybatis第一步：获取sqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); } catch (IOException e) { e.printStackTrace(); } } //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。 // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。 public static SqlSession getSqlSession() { return sqlSessionFactory.openSession(); } }
2.3、编写代码
-
实体类
package com.hao.pojo; /** * @author 许浩 * @date 2020/7/26 - 1:30 */ public class User { private int id; private String name; private String pwd; public User() { } public User(int id, String name, String pwd) { this.id = id; this.name = name; this.pwd = pwd; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPwd() { return pwd; } public void setPwd(String pwd) { this.pwd = pwd; } @Override public String toString() { return "User{" + "id=" + id + ", name='" + name + '\'' + ", pwd='" + pwd + '\'' + '}'; } } -
Dao接口
public interface UserDao { public List<User> getUserList(); } -
接口实现类 由原来的UserDaoImpl转换为一个Mapper配置文件
<?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"> <!--namespace=绑定一个对应的Dao/Mapper接口--> <mapper namespace="com.hao.dao.UserDao"> <!--select查询语句--> <select id="getUserList" resultType="com.hao.pojo.User"> select * from mybatis.user </select> </mapper>
2.4、注册
注意点：
org.apache.ibatis.binding.BindingException: Type interface com.hao.dao.UserMapper is not known to the MapperRegistry.
MapperRegistry是什么？
核心配置文件中注册Mapper
-
junit测试
@Test public void test(){ //第一步：获得SqlSession对象 SqlSession sqlSession = MybatisUtils.getSqlSession(); //方式一：getMapper UserMapper userMapper = sqlSession.getMapper(UserMapper.class); List<User> userList = userMapper.getUserList(); for (User user : userList) { System.out.println(user); } //关闭sqlSession sqlSession.close(); } -
注意
当出现xml文件不能导出的时候加入build
<!--在build中配置resources，防止资源导出失败--> <build> <resources> <resource> <directory>src/main/resources</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> </resources> </build>
3、CRUD
1、namespace
namespace中的包要和Dao/mapper接口的包名一致
2、select
选择，查询语句
- select语句有很多属性可以详细配置每一条SQL语句
- SQL语句返回值类型。【完整的类名或者别名】
- 传入SQL语句的参数类型 。【万能的Map，可以多尝试使用】
- 命名空间中唯一的标识符
- 接口中的方法名与映射文件中的SQL语句ID 一一对应
- id
- parameterType
- resultType
流程：
-
编写接口
//查询全部用户 List<User> getUserList(); -
编写对应的mapper中的sql语句
<!--select查询语句--> <select id="getUserList" resultType="com.hao.pojo.User"> select * from mybatis.user </select> -
测试
@Test public void test() { //第一步：获得SqlSession对象 SqlSession sqlSession = MybatisUtils.getSqlSession(); //方式一：getMapper UserMapper userMapper = sqlSession.getMapper(UserMapper.class); List<User> userList = userMapper.getUserList(); for (User user : userList) { System.out.println(user); } //关闭sqlSession sqlSession.close(); }
3、Insert
<insert id="addUser" parameterType="com.hao.pojo.User">
insert into mybatis.user (id,name,pwd) value (#{id},#{name},#{pwd});
</insert>
4、update
<update id="updateUser" parameterType="com.hao.pojo.User">
update mybatis.user set pwd=${pwd} where id=#{id};
</update>
5、Delete
<delete id="deleteUser" parameterType="int">
delete from mybatis.user where id=#{id};
</delete>
注意：执行增删改操作时需要提交事务
//提交事务
sqlSession.commit();
6、万能的Map
假设，我们的实体类，或者数据库中的表的字段或者参数过多，我们应当考虑使用Map
//万能的Map测试
int addUser2(Map<String,Object> map);
<!--Map插入测试-->
<insert id="addUser2" parameterType="map">
insert into mybatis.user (id,name,pwd) value (#{userId},#{userName},#{UserPwd});
</insert>
@Test
public void addUser2(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Map<String, Object> map = new HashMap<String, Object>();
map.put("userId",4);
map.put("userName","杨欣馨");
map.put("UserPwd",321321);
mapper.addUser2(map);
sqlSession.commit();
sqlSession.close();
}
Map传递参数，直接在sql中取出key即可
对象传递参数，直接在sql中取对象的属性即可
只有一个基本类型参数的情况下，可以直接在sql中取到
多个参数用Map，或者注解@Param()
7、模糊查询
模糊查询怎么写？
-
java代码执行的时候，传递通配符% %
string wildcardname = “%smi%”; list<name> names = mapper.selectlike(wildcardname); <select id=”selectlike”> select * from foo where bar like #{value} </select> -
在sql拼接中使用通配符（容易引起sql注入）
string wildcardname = “smi”; list<name> names = mapper.selectlike(wildcardname); <select id=”selectlike”> select * from foo where bar like "%"#{value}"%" </select> -
使用mysql的concat函数
string wildcardname = “smi”; list<name> names = mapper.selectlike(wildcardname); <select id=”selectlike”> select * from foo where bar like concat('%',#{wildcardname},'%') </select>
4、配置解析
1、核心配置文件
-
mybatis-config.xml
-
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
configuration（配置） properties（属性） settings（设置） typeAliases（类型别名） typeHandlers（类型处理器） objectFactory（对象工厂） plugins（插件） environments（环境配置） environment（环境变量） transactionManager（事务管理器） dataSource（数据源） databaseIdProvider（数据库厂商标识） mappers（映射器）
2、环境配置（environments）
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">
<property name="..." value="..."/>
</transactionManager>
<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>
Mybatis可以配置成适应多种环境
不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
学会使用配置多套运行环境（配置多套，在使用时要使用哪个，就填写哪个环境的Id）
Mybatis的默认事务管理器就是JDBC，连接池：POOLED
3、属性（properties）
我们可以通过properties属性来实现引用配置文件
这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置【db.properties】
编写一个配置文件
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&userUnicode=true&characterEncoding=UTF-8
username=root
password=0927
在配置文件中引入
<!--引入外部配置文件-->
<properties resource="db.properties"/>
注意：
- 可以直接引入外部文件
- 可以在其中增加一些属性配置
- 如果两个文件中有同一字段，优先使用外部文件的字段
4、类型别名（typeAliases）
- 类型别名可为 Java 类型设置一个缩写名字。
- 它仅用于 XML 配置，意在降低冗余的全限定类名书写
<!--可以给实体类起别名-->
<typeAliases>
<typeAlias type="com.hao.pojo.User" alias="User"/>
</typeAliases>
也可以指定一个包名，Mybatis会在包名下面搜索需要的Java Bean，比如：
扫描实体类的包，它的默认别名就为这个类的 类名，首字母小写
<typeAliases>
<package name="com.hao.pojo"/>
</typeAliases>
在实体类比较少的时候，使用第一种
如果实体类十分多，建议使用第二种
第一种可以DIY别名，第二种则不行，如果非要改，需要在实体上增加注解
@Alias("user")
public class User {
5、设置（settings）
这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。
-
懒加载
-
日志实现
-
缓存开启关闭
-
一个配置完整的 settings 元素的示例如下：
<settings> <setting name="cacheEnabled" value="true"/> <setting name="lazyLoadingEnabled" value="true"/> <setting name="multipleResultSetsEnabled" value="true"/> <setting name="useColumnLabel" value="true"/> <setting name="useGeneratedKeys" value="false"/> <setting name="autoMappingBehavior" value="PARTIAL"/> <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/> <setting name="defaultExecutorType" value="SIMPLE"/> <setting name="defaultStatementTimeout" value="25"/> <setting name="defaultFetchSize" value="100"/> <setting name="safeRowBoundsEnabled" value="false"/> <setting name="mapUnderscoreToCamelCase" value="false"/> <setting name="localCacheScope" value="SESSION"/> <setting name="jdbcTypeForNull" value="OTHER"/> <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/> </settings>
6、映射器（mappers）
MapperRegistry：注册绑定我们的Mapper文件
方式一：（推荐）
<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
<!-- 使用相对于类路径的资源引用 -->
<mappers>
<mapper resource="com/hao/dao/UserMapper.xml"></mapper>
</mappers>
方式二：使用class文件绑定注册
<!--
使用映射器接口实现类的完全限定类名
需要配置文件名称和接口名称一致，并且位于同一目录下
-->
<mappers>
<mapper class="com.hao.dao.UserMapper"></mapper>
</mappers>
注意点：
- 接口和他的Mapper配置文件必须同名
- 接口和他的Mapper配置文件必须在同一包下
方式三：使用包扫描来绑定注册
<mappers>
<!--<mapper resource="com/hao/dao/UserMapper.xml"></mapper>-->
<mapper class="com.hao.dao.UserMapper"></mapper>
<package name="com.hao.dao"/>
</mappers>
注意点：
- 接口和他的Mapper配置文件必须同名
- 接口和他的Mapper配置文件必须在同一包下
7、Mapper文件
<?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.kuang.mapper.UserMapper">
</mapper>
-
namespace中文意思：命名空间，作用如下：
-
- namespace的命名必须跟某个接口同名
- 接口中的方法与映射文件中sql语句id应该一一对应
-
- namespace和子元素的id联合保证唯一 , 区别不同的mapper
- 绑定DAO接口
- namespace命名规则 : 包名+类名
8、声明周期和作用域
理解我们目前已经讨论过的不同作用域和生命周期类是至关重要的，因为错误的使用会导致非常严重的并发问题。
我们可以先画一个流程图，分析一下Mybatis的执行过程！
生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder：
- SqlSessionFactoryBuilder 的作用在于创建 SqlSessionFactory，创建成功后，SqlSessionFactoryBuilder 就失去了作用，所以它只能存在于创建 SqlSessionFactory 的方法中，而不要让其长期存在。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。
SqlSessionFactory：
- 可以想象为数据库连接池，它的作用是创建 SqlSession 接口对象
- 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
- SqlSessionFactory 的最佳作用域是应用作用域
- 由于 SqlSessionFactory 是一个对数据库的连接池，所以它占据着数据库的连接资源。如果创建多个 SqlSessionFactory，那么就存在多个数据库连接池，这样不利于对数据库资源的控制，也会导致数据库连接资源被消耗光，出现系统宕机等情况，所以尽量避免发生这样的情况。
- 因此在一般的应用中我们往往希望 SqlSessionFactory 作为一个单例，让它在应用中被共享。所以说 SqlSessionFactory 的最佳作用域是应用作用域。
SqlSession
- 连接到连接池的一个请求
- SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
- 用完之后需要赶紧关闭，否则资源被占用
这里面每一个Mapper，就代表要执行一个业务
5、解决属性名和字段名不一致的问题
1、问题引出
1、数据库中的字段
2、Java中的实体类设计
public class User {
private int id; //id
private String name; //姓名
private String password; //密码和数据库不一样！
//构造
//set/get
//toString()
}
3、接口
//根据id查询用户
User selectUserById(int id);
4、mapper映射文件
<select id="selectUserById" resultType="user">
select * from user where id = #{id}
</select>
5、测试
@Test
public void testSelectUserById() {
SqlSession session = MybatisUtils.getSession(); //获取SqlSession连接
UserMapper mapper = session.getMapper(UserMapper.class);
User user = mapper.selectUserById(1);
System.out.println(user);
session.close();
}
结果:
- User
- 查询出来发现 password 为空 . 说明出现了问题！
分析：
-
select * from user where id = #{id} 可以看做
select id,name,pwd from user where id = #
-
mybatis会根据这些查询的列名(会将列名转化为小写,数据库不区分大小写) , 去对应的实体类中查找相应列名的set方法设值 , 由于找不到setPwd() , 所以password返回null ; 【自动映射】
解决方法：
- 起别名
- 结果集映射
2、resultMap
结果集映射
id name pwd
id name password
<!--结果集映射-->
<resultMap id="UserMap" type="User">
<!--column数据库中的字段，property实体类中的属性-->
<result column="id" property="id"/>
<result column="name" property="name"/>
<result column="pwd" property="password"/>
</resultMap>
<!--根据Id查询语句-->
<select id="getUserById" resultMap="UserMap" parameterType="int">
select * from mybatis.user where id=#{id};
</select>
resultMap元素是 MyBatis 中最重要最强大的元素。- ResultMap的设计思想是，对于简单的语句根部不需要配置显式的结果映射，而对于复杂一点的语句只需描述他们的关系就好了。
6、日志
6.1、日志工厂
思考：我们在测试SQL的时候，要是能够在控制台输出 SQL 的话，是不是就能够有更快的排错效率？
如果一个 数据库相关的操作出现了问题，我们可以根据输出的SQL语句快速排查问题。
对于以往的开发过程，我们会经常使用到debug模式来调节，跟踪我们的代码执行过程。但是现在使用Mybatis是基于接口，配置文件的源代码执行过程。因此，我们必须选择日志工具来作为我们开发，调节程序的工具。
-
SLF4J
-
LOG4J 【掌握】
-
LOG4J2
-
JDK_LOGGING
-
COMMONS_LOGGING
-
STDOUT_LOGGING 【掌握】
-
NO_LOGGING
在Mybatis中具体使用哪个日志，只需要在配置文件中进行相应配置
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
测试，可以看到控制台有大量的输出！我们可以通过这些输出来判断程序到底哪里出了Bug
6.2、Log4j
什么是Log4j？
- Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件等；
- 我们也可以控制每一条日志的输出格式；
- 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
- 可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
使用步骤：
-
先导入Log4j的包
<dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency> -
log4j.properties
#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码 log4j.rootLogger=DEBUG,console,file #控制台输出的相关设置 log4j.appender.console = org.apache.log4j.ConsoleAppender log4j.appender.console.Target = System.out log4j.appender.console.Threshold=DEBUG log4j.appender.console.layout = org.apache.log4j.PatternLayout log4j.appender.console.layout.ConversionPattern=[%c]-%m%n #文件输出的相关设置 log4j.appender.file = org.apache.log4j.RollingFileAppender log4j.appender.file.File=./log/hao.log log4j.appender.file.MaxFileSize=10mb log4j.appender.file.Threshold=DEBUG log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n #日志输出级别 log4j.logger.org.mybatis=DEBUG log4j.logger.java.sql=DEBUG log4j.logger.java.sql.Statement=DEBUG log4j.logger.java.sql.ResultSet=DEBUG log4j.logger.java.sql.PreparedStatement=DEBUG -
配置log4j为日志的实现
<settings> <!--标准的日志工厂实现--> <!--<setting name="logImpl" value="STDOUT_LOGGING"/>--> <setting name="logImpl" value="LOG4J"/> </settings> -
Log4j的使用
简单使用
-
在要使用Log4j的类中，导入包 import org.apache.log4j.Logger;
-
日志对象,参数为当前类的class
static Logger logger = Logger.getLogger(UserDaoTest.class); -
日志级别
logger.info("info:进入了testLog4j"); logger.debug("debug:进入了testLog4j"); logger.debug("error:进入了testLog4j");
7、分页
为什么要分页？
- 在学习mybatis等持久层框架的时候，会经常对数据进行增删改查操作，使用最多的是对数据库进行查询操作，如果查询大量数据的时候，我们往往使用分页进行查询，也就是每次处理小部分数据，这样对数据库压力就在可控范围内。
7.1、使用Limit分页
使用Limit分页
# 语法
SELECT * FROM table LIMIT stratIndex，pageSize
SELECT * FROM table LIMIT 5,10; // 检索记录行 6-15
# 为了检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为 -1：
SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last.
# 如果只给定一个参数，它表示返回最大的记录行数目：
SELECT * FROM table LIMIT 5; //检索前 5 个记录行
# 换句话说，LIMIT n 等价于 LIMIT 0,n。
使用Mybatis实现分页，核心SQL
-
接口
//分页 List<User> getUserByLimit(Map<String,Integer> map); -
Mapper.xml
<!--分页查询--> <select id="getUserByLimit" parameterType="map" resultMap="UserMap"> select * from mybatis.user limit #{startIndex},#{pageSize}; </select> -
测试
@Test public void getUserByLimit(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlSession.getMapper(UserMapper.class); Map<String,Integer> map=new HashMap<String,Integer>(); map.put("startIndex",0); map.put("pageSize",2); List<User> userByLimit = mapper.getUserByLimit(map); for (User user : userByLimit) { System.out.println(user); } sqlSession.close(); }
7.2、使用RowBounds分页
不再使用SQL实现分页
-
接口
//RowBounds分页 List<User> getUserByRowBounds(Map<String,Integer> map); -
mapper.xml
<!--RowBounds分页查询--> <select id="getUserByLimit" resultMap="UserMap"> select * from mybatis.user; </select> -
测试
@Test public void getUserByRowBounds(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); //RowBounds实现 RowBounds rowBounds=new RowBounds(1,2); //通过java代码层面实现分页 List<User> userList = sqlSession.selectList("com.hao.dao.UserMapper.getUserByRowBounds", null, rowBounds); for (User user : userList) { System.out.println(user); } sqlSession.close(); }
7.3、分页插件
Mybatis PageHelper
官方文档：https://pagehelper.github.io/
8、使用注解开发
8.1、使用注解开发
-
注解在接口上实现
@Select("select * from user") List<User> getUsers(); -
需要在配置文件上绑定接口
<!--绑定接口--> <mappers> <mapper class="com.hao.dao.UserMapper"/> </mappers> -
测试
本质：反射机制实现
底层：动态代理！
8.2、Mybatis详细的执行流程
8.3、CRUD
我们可以在工具类创建的时候自动提交事务
public static SqlSession getSqlSession() {
//设置为true，自动提交事务
return sqlSessionFactory.openSession(true);
}
编写接口，增加注解
@Select("select * from user")
List<User> getUsers();
//方法存在多个参数，所有参数前面必须加上@Param
@Select("Select * from user where id= #{id}")
User getUserByID(@Param("id") int id);
@Insert("insert into user(id,name,pwd) values(#{id},#{name},#{password})")
int addUser(User user);
@Update("update user set name=#{name},pwd=#{password} where id = #{id}")
int updateUser(User user);
@Delete("delete from user where id = #{uid}")
int deleteUser(@Param("uid") int id);
测试类
注意：我们必须要将接口注册表绑定到我们的核心配置文件
关于@Param()
@Param注解用于给方法参数起一个名字。以下是总结的使用原则：
- 基本类型的参数或者String类型需要加上
- 引用类型不需要加
- 如果只有一个基本类型的话，可以忽略，但是建议都加上
- 我们在sql中引用的就是这里@Param()里面的属性名
关于@Param
@Param注解用于给方法参数起一个名字。以下是总结的使用原则：
-
#{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用】
INSERT INTO user (name) VALUES (#{name}); INSERT INTO user (name) VALUES (?); -
${} 的作用是直接进行字符串替换
INSERT INTO user (name) VALUES ('${name}'); INSERT INTO user (name) VALUES ('nuoxin');
9、Lombok
- java library
- plugs
- build tools
使用步骤：
-
在IDEA中安装Lombok插件
-
在项目中导入lombok的jar包
<dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.10</version> </dependency> -
在实体类上加注解
注解：
@Data：无参构造，set，get，tostring，hashcode，equals
@AllArgsConstructor：有参
@NoArgsConstructor：无参
@ToString：toString方法
10、多对一处理
CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');
CREATE TABLE `student` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');
测试环境搭建
-
导入Lombok
-
新建实体类Teacher，Student
-
建立Mapper接口
-
建立Mapper.XML文件
-
在核心配置文件中绑定注册我们的Mapper接口或者文件
-
测试查询是否能成功
-
模板
<!--column不做限制，可以为任意表的字段，而property须为type 定义的pojo属性--> <resultMap id="唯一的标识" type="映射的pojo对象"> <id column="表的主键字段，或者可以为查询语句中的别名字段" jdbcType="字段类型" property="映射pojo对象的主键属性" /> <result column="表的一个字段（可以为任意表的一个字段）" jdbcType="字段类型" property="映射到pojo对象的一个属性（须为type定义的pojo对象中的一个属性）"/> <association property="pojo的一个对象属性" javaType="pojo关联的pojo对象"> <id column="关联pojo对象对应表的主键字段" jdbcType="字段类型" property="关联pojo对象的字段对象属性"/> <result column="任意表的字段" jdbcType="字段类型" property="关联pojo对象的属性"/> </association> <association property="关联pojo对象的字段对象属性" column="向查询语句中传递的参数" javaType="pojo关联的pojo对象" select="相关查询语句的id号"></association> <!-- 集合中的property须为oftype定义的pojo对象的属性--> <collection property="pojo的集合属性" ofType="集合中的pojo对象"> <id column="集合中pojo对象对应的表的主键字段" jdbcType="字段类型" property="集合中pojo对象的主键属性" /> <result column="可以为任意表的字段" jdbcType="字段类型" property="集合中的pojo对象的属性" /> </collection> </resultMap>
按照查询嵌套处理
<mapper namespace="com.hao.dao.StudentMapper">
<resultMap id="StudentTeacher" type="Student">
<result property="id" column="id"/>
<result property="name" column="name"/>
<!--复杂的属性，我们需要单独处理
对象：association
集合：collection
-->
<association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>
<select id="getStudent" resultMap="StudentTeacher">
select * from mybatis.student
</select>
<select id="getTeacher" resultType="Teacher">
select * from teacher where id = #{id};
</select>
</mapper>
按照结果嵌套处理
<!--按照结果嵌套处理-->
<select id="getStudent2" resultMap="StudentTeacher2">
select s.id sid,s.name sname,t.name tname from student s,teacher t where s.tid=t.id
</select>
<resultMap id="StudentTeacher2" type="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<association property="teacher" javaType="Teacher">
<result property="name" column="tname"/>
</association>
</resultMap>
11、一对多处理
@Data
public class Teacher {
private int id;
private String name;
//一个老师拥有多个学生
private List<Student> students;
}
@Data
public class Student {
private int id;
private String name;
private int tid;
}
按结果嵌套查询
<mapper namespace="com.hao.dao.TeacherMapper">
<!--按结果嵌套查询-->
<select id="getTeacher" resultMap="TeacherStudent">
select s.id sid,s.name sname,t.name tname ,t.id tid
from student s,teacher t
where s.tid=t.id and t.id=#{tid}
</select>
<resultMap id="TeacherStudent" type="Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<!--
javaType:是一个指定的属性的类型
集合中的泛型信息，我们使用ofType获取
-->
<collection property="students" ofType="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
</collection>
</resultMap>
</mapper>
按查询嵌套处理
<collection column="传递给嵌套查询语句的字段参数" property="pojo对象中集合属性" ofType="集合属性中的pojo对象" select="嵌套的查询语句" >
</collection>
注意：<collection>标签中的column：要传递给select查询语句的参数，如果传递多个参数，格式为column= ” {参数名1=表字段1,参数名2=表字段2} ；
<!--按查询嵌套查询-->
<select id="getTeacher2" resultMap="TeacherStudent2">
select * from teacher where id=#{tid}
</select>
<resultMap id="TeacherStudent2" type="Teacher">
<collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
select * from student where tid=#{tid}
</select>
小结
- 关联 - association 多对一
- 集合 - collection 一对多
- javaType & ofType
- JavaType 用来指定实体类中属性的类型
- ofType 用来指定映射到List或者集合中的pojo类型
12、动态SQL
什么是动态SQL：动态SQL就是根据不同的条件生成不同的SQL
在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。
- if
- choose (when, otherwise)
- trim (where, set)
- foreach
搭建环境
CREATE TABLE `blog` (
`id` varchar(50) NOT NULL COMMENT '博客id',
`title` varchar(100) NOT NULL COMMENT '博客标题',
`author` varchar(30) NOT NULL COMMENT '博客作者',
`create_time` datetime NOT NULL COMMENT '创建时间',
`views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE=InnoDB DEFAULT CHARSET=utf8
创建一个基础工程
-
导包
-
编写配置文件
-
编写实体类
@Data public class Blog { private String id; private String title; private String author; private Date createTime; private int views; } -
编写实体类对应Mapper接口和Mapper.XML文件
IF
<select id="queryBlogIF" parameterType="map" resultType="Blog">
select * from blog where 1=1
<if test="title != null">
and title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</select>
choose(when,otherwise)
choose可以嵌套在where标签里面，且choose不管怎样满足条件，一次都只会执行一次when标签里面的语句，类似于java中的switch
<select id="queryBlogChoose" parameterType="map" resultType="Blog">
select * from blog
<where>
<choose>
<when test="title != null">
title =# {title}
</when>
<when test="author != null">
author = #{author}
</when>
<otherwise>
and views = #{views}
</otherwise>
</choose>
</where>
</select>
trim(where,set)
把原本sql语句中的where替换为标签，原先的IF标签，当直接查询进入第二个IF的时候会报错，替换以后会自动识别，当选择的IF中含有and且是接在where后面，则会自动将and舍弃，当都不进入IF时，则自动去掉where
set也是同理，可以自动去掉“，”
<select id="queryBlogIF" parameterType="map" resultType="Blog">
select * from blog
<where>
<if test="title != null">
title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</where>
</select>
<update id="updateBlog" parameterType="map">
update blog
<set>
<if test="title != null">
title = #{title},
</if>
<if test="author != null">
author = #{author},
</if>
</set>
where id = #{id}
</update>
所谓的动态SQL，本质还是SQL语句，只是外面可以在SQL层面，增加逻辑代码
if,where,set,choose,when
SQL片段
有的时候，外面可能会将一些功能的部分抽取出来，方法复用
-
使用SQL标签抽取公共部分
<sql id="if-title-author"> <if test="title != null"> title = #{title} </if> <if test="author != null"> and author = #{author} </if> </sql> -
在需要使用的地方使用Include
<select id="queryBlogIF" parameterType="map" resultType="Blog"> select * from blog <where> <include refid="if-title-author"></include> </where> </select>
注意事项：
- 最好基于单标来定义SQL片段
- 公共部分不要存在where标签
Foreach
查询一张表的前两个数据
<!--collection的值可以是map中存在的一个集合-->
<select id="queryBlogForeach" parameterType="map" resultType="Blog">
select * from blog
<where>
<foreach collection="ids" item="id" open="and (" close=")" separator="or">
id = #{id}
</foreach>
</where>
</select>
<!--用in也可以实现-->
<select id="queryBlogForeach" parameterType="map" resultType="Blog">
select * from blog
<where>
<foreach collection="ids" item="id" open="and id in (" close=")" separator=",">
#{id}
</foreach>
</where>
</select>
@Test
public void queryBlogForeach() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map = new HashMap();
ArrayList<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(2);
map.put("ids", ids);
List<Blog> blogs = mapper.queryBlogForeach(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
sqlSession.close();
}
动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了
13、缓存
1、什么是缓存 [ Cache ]？
- 存在内存中的临时数据。
- 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
2、为什么使用缓存？
- 减少和数据库的交互次数，减少系统开销，提高系统效率。
3、什么样的数据能使用缓存？
- 经常查询并且不经常改变的数据。
13.1、缓存原理
13.2、一级缓存
在同一个 SqlSession 中, Mybatis 会把执行的方法和参数通过算法生成缓存的键值， 将键值和结果存放在一个 Map 中， 如果后续的键值一样， 则直接从 Map 中获取数据；
不同的 SqlSession 之间的缓存是相互隔离的；
用一个 SqlSession， 可以通过配置使得在查询前清空缓存；
任何的 UPDATE, INSERT, DELETE 语句都会清空缓存。
13.3、二级缓存
二级缓存存在于 SqlSessionFactory 生命周期中。其中二级缓存在配置文件是默认打开的，但为了使可读性更强，通常也会写上开启二级缓存。
全局开关
在 mybatis 中， 二级缓存有全局开关和分开关， 全局开关， 在 mybatis-config.xml 中如下配置:
<settings>
<!--全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。 -->
<setting name="cacheEnabled" value="true"/>
</settings>
默认是为 true， 即默认开启总开关。
分开关
分开关就是说在 *Mapper.xml 中开启或关闭二级缓存， 默认是不开启的。
当需要使用的时候则在Mapper.xml文件中加入cache标签。
<cache
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
配置详解
<!ELEMENT cache (property*)>
<!ATTLIST cache
type CDATA #IMPLIED
eviction CDATA #IMPLIED
flushInterval CDATA #IMPLIED
size CDATA #IMPLIED
readOnly CDATA #IMPLIED
blocking CDATA #IMPLIED
>
从中可以看出：
cache 中可以出现任意多个 property子元素;
cache 有一些可选的属性 type, eviction, flushInterval, size, readOnly, blocking.
type
type 用于指定缓存的实现类型， 默认是PERPETUAL, 对应的是 mybatis 本身的缓存实现类 org.apache.ibatis.cache.impl.PerpetualCache。
后续如果我们要实现自己的缓存或者使用第三方的缓存， 都需要更改此处。
eviction
eviction 对应的是回收策略， 默认为 LRU。
LRU: 最近最少使用， 移除最长时间不被使用的对象。
FIFO: 先进先出， 按对象进入缓存的顺序来移除对象。
SOFT: 软引用， 移除基于垃圾回收器状态和软引用规则的对象。
WEAK: 弱引用， 移除基于垃圾回收器状态和弱引用规则的对象。
flushInterval
flushInterval 对应刷新间隔， 单位毫秒， 默认值不设置， 即没有刷新间隔， 缓存仅仅在刷新语句时刷新。
如果设定了之后， 到了对应时间会过期， 再次查询需要从数据库中取数据。
size
size 对应为引用的数量，即最多的缓存对象数据， 默认为 1024。
readOnly
readOnly 为只读属性， 默认为 false
false: 可读写， 在创建对象时， 会通过反序列化得到缓存对象的拷贝。 因此在速度上会相对慢一点， 但重在安全。
true: 只读， 只读的缓存会给所有调用者返回缓存对象的相同实例。 因此性能很好， 但如果修改了对象， 有可能会导致程序出问题。
blocking
blocking 为阻塞， 默认值为 false。 当指定为 true 时将采用 BlockingCache 进行封装。
使用 BlockingCache 会在查询缓存时锁住对应的 Key，如果缓存命中了则会释放对应的锁，否则会在查询数据库以后再释放锁，这样可以阻止并发情况下多个线程同时查询数据。
结论
注意要点
-
由于在更新时会刷新缓存， 因此需要注意使用场合：查询频率很高， 更新频率很低时使用， 即经常使用 select, 相对较少使用delete, insert, update。
-
缓存是以 namespace 为单位的，不同 namespace 下的操作互不影响。但刷新缓存是刷新整个 namespace 的缓存， 也就是你 update 了一个， 则整个缓存都刷新了。
-
最好在 「只有单表操作」 的表的 namespace 使用缓存， 而且对该表的操作都在这个 namespace 中。 否则可能会出现数据不一致的情况。
- 只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
- 查出的数据都会被默认先放在一级缓存中
- 只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中
浙公网安备 33010602011771号