Mybatis
环境
JDK1.8
Mysql5.7
maven3.6.1
IDEA
回顾
JDBC
Mysql
Java 基础
Maven
Junit
ssm 框架：配置文件的，最好的方式：看官网文档
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](https://baike.baidu.com/item/google code/2346604)，并且改名为 MyBatis。
2013 年 11 月迁移到Github。
如何获得 Mabatis？
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.10</version> </dependency>
复制代码
1.2 持久层
数据持久化
1.3 持久层
Dao 层 Service 层 Controller 层
1.4 为什么需要 Mybaits
帮助程序员将数据存入到数据库中
方便
传统的 JDBC 代码太复杂了，简化，框架，自动化
优点：
简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个 jar 文件+配置几个 sql 映射文件。易于学习，易于使用。通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
灵活：mybatis 不会对应用程序或者数据库的现有设计强加任何影响。 sql 写在 xml 里，便于统一管理和优化。通过 sql 语句可以满足操作数据库的所有需求。
解除 sql 与程序代码的耦合：通过提供 DAO 层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql 和代码的分离，提高了可维护性。
提供映射标签，支持对象与数据库的 orm 字段关系映射。
提供对象关系映射标签，支持对象关系组建维护。
提供 xml 标签，支持编写动态 sql。
2.第一个 Mybatis 程序
思路：搭建环境-->导入 Mybatis-->编写代码-->测试
2.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,'饼干1号','123456'),(2,'饼干3号','123456'),(3,'饼干3号','123456')
复制代码
新建项目
1.新建一个普通的 maven 项目
2.删除 src 目录
3.导入 maven 依赖
<!--导入依赖--> <dependencies> <!--mysql驱动--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency>
<!--mybatis--> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.10</version> </dependency>
<!--junit--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> </dependencies>
复制代码
2.2 创建一个模块
<?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&useUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments> </configuration>
复制代码
//SqlSessionFactory SqlSession public class MybatisUtils { private static SqlSessionFactory sqlSessionFactory; static { try { //使用Mybatis 第一步：获取SqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); } catch (IOException e) { e.printStackTrace(); } } // 既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。 // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法 public static SqlSession getSqlSession(){ SqlSession sqlSession = sqlSessionFactory.openSession(); return sqlSession; } }
复制代码
2.3 编写代码
package com.he.pojo; //实体类 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 + '\'' + '}'; } }
复制代码
public interface UserDao { List<User> getUserList(); }
复制代码
<?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.he.Dao.UserDao"> <select id="getUserList" resultType="com.he.pojo.User"> select * from mybatis.user </select> </mapper>
复制代码
2.4 测试
MapperRegister 是什么？
核心配置文件中注册 mappers
public class UserDaoTest { @Test public void test(){ // 第一步：获得sqkSession对象 SqlSession sqlSession = MybatisUtils.getSqlSession(); // 第二步：执行sql // 方式一：getMapper UserDao userDao = sqlSession.getMapper(UserDao.class); List<User> userList = userDao.getUserList(); for (User user : userList) { System.out.println(user); } // 关闭sqlSession sqlSession.close(); } }
复制代码
问题：
配置文件没有注册
绑定接口错误
方法名错误
返回类型不对
Maven 导出资源问题
**在之前版本的 MyBatis 中，**命名空间（Namespaces）的作用并不大，是可选的。 但现在，随着命名空间越发重要，你必须指定命名空间。
全限定名（比如 “com.mypackage.MyMapper.selectAllThings）将被直接用于查找及使用。
短名称（比如 “selectAllThings”）如果全局唯一也可以作为一个单独的引用。 如果不唯一，有两个或两个以上的相同名称（比如 “com.foo.selectAllThings” 和 “com.bar.selectAllThings”），那么使用时就会产生“短名称不唯一”的错误，这种情况下就必须使用全限定名。
SqlSessionFactoryBuilder
这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。
SqlSessionFactory
SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。
SqlSession
每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。下面的示例就是一个确保 SqlSession 关闭的标准模式：
try (SqlSession session = sqlSessionFactory.openSession()) { // 你的应用逻辑代码}
复制代码
3.CRUD
1.命名空间
namespace 中的包名要和 Dao/mapper 接口中的包名一致
2.select
选择 查询语句
id：就是对应的 namespace 中的方法名
resultType：sql 语句执行的返回值
parameterType：参数类型
1.编写接口
// 查询全部用户 List<User> getUserList();
复制代码
2.编写对应的 sql 语句
<!--select查询语句--> <select id="getUserList" resultType="com.he.pojo.User"> select * from mybatis.user </select>
复制代码
3.测试
@Test public void getUserById(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); User user = mapper.getUserById(1); System.out.println(user); sqlSession.close(); }
复制代码
3.insert
<!--对象中的属性，可以直接取出来--> <insert id="addUser" parameterType="com.he.pojo.User" > insert into mybatis.user (id, name, pwd) values (#{id},#{name},#{pwd}) </insert>
复制代码
// insert一个用户 int addUser(User user);
复制代码
public void addUser(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); int res = mapper.addUser(new User(4,"饼干4号","123456")); if(res>0){ System.out.println("插入成功！"); }
// 提交事务 sqlSession.commit(); sqlSession.close(); }
复制代码
4.update
<update id="updateUser" parameterType="com.he.pojo.User"> update mybatis.user set name=#{name} ,pwd=#{pwd} where id=#{id} </update>
复制代码
// 修改用户 int updateUser(User user);
复制代码
@Testpublic void updateUser(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); mapper.updateUser(new User(4,"石头1号","123456")); sqlSession.commit(); sqlSession.close();}
复制代码
5.delete
<delete id="deleteUser" parameterType="int" > delete from mybatis.user where id = #{id} </delete>
复制代码
// 删除一个事务 int deleteUser(int id);}
复制代码
@Test public void deleteUser(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); mapper.deleteUser(4); sqlSession.commit(); sqlSession.close(); }
复制代码
注意：增删改需要提交事务
6.标签不要匹配错
7.万能的 Map
假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用 Map
int addUser2(Map<String, Object> map);
复制代码
<insert id="addUser2" parameterType="map" > insert into mybatis.user (id, name, pwd) values (#{userid},#{username},#{passWord}) </insert>
复制代码
@Test public void addUser2(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); Map<String, Object> map = new HashMap<String, Object>(); map.put("userid",5); map.put("username","饼干5号"); map.put("passWord","123456"); mapper.addUser2(map); sqlSession.commit(); sqlSession.close(); }
复制代码
Map 传递参数，直接在 sql 中取出 key 即可
对象传递参数，直接在 sql 中取对象的属性即可
只有一个基本类型参数的情况下，可以直接在 sql 中取到
多个参数用 Map，或者注解
8.思考题：
模糊查询怎么写？
java 代码执行的时候，传递通配符 % %
List<User> userList = userDao.getUserLike("%饼干%");
复制代码
在 sql 拼接·中使用通配符
select * from mybatis.user where name like "%"#{value }"%"
复制代码
4.配置解析
1.核心配置文件
2.环境变量（environments）
MyBatis 可以配置成适应多种环境
不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
学会使用多套运行环境
Mybatis 默认的事务管理器就是 JDBC，连接池：POOLED
3.属性（properties）
我们可以通过 properties 属性来实现引用配置文件
这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置
编写一个配置文件
db.properties
driver = com.mysql.jdbc.Driverurl = jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8username = rootpassword = 123456
复制代码
在核心配置文件中映入
<!--引入外部配置文件--> <properties resource="db.properties"> <property name="username" value="root"/> <property name="password" value="123456"/> </properties>
复制代码
可以直接引入外部文件
可以在其中增加一些属性配置
如果两个文件有同一个字段，优先使用外部配置文件的
4.类型别名([typeAliases)
<!--可以给实体类起别名--><typeAliases> <typeAlias type="com.he.pojo.User" alias="User"/></typeAliases>
复制代码
也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean
扫描实体类的包，它的默认别名就为这个类的类名，首字母小写
<typeAliases> <package name="com.he.pojo"/> </typeAliases>
复制代码
在实体类比较少的时候，使用第一种方式
如果实体类十分多，建议使用第二种
第一种可以 diy 别名，第二种则不行，如果非要改，需要在实体类上增加注释
5.设置
这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。
6.其他配置
7.映射器（mappers）
MapperRegistry：注册绑定我们的 Mapper 文件
方式一：
<!--每一个Mapper.xml都需要在mybatis核心配置文件中注册--><mappers> <mapper resource="com/he/dao/UserMapper.xml"/> </mappers>
复制代码
方式二：
<mappers> <mapper class="com.he.dao.UserMapper"/> </mappers>
复制代码
注意：
方式三：
使用扫描包进行注入绑定
<mappers> <package name="com.he.dao"/> </mappers>
复制代码
8.生命周期和作用域
生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder
SqlSessionFactory
SqlSession
这里面的每一个 Mapper，就代表一个具体的业务
5.解决属性名和字段名不一致的问题
1.问题
数据库中的字段
新建一个项目，拷贝之前的，测试实体类字段不一致的情况
public class User { private int id; private String name; private String password;}
复制代码
测试出现问题
解决方法：
<select id="getUserById" resultType="com.he.pojo.User"> select id,name,pwd as password from mybatis.user where id = #{id} </select>
复制代码
2.resultMap
结果集映射
id name pwdid name password
复制代码
<resultMap id="UserMap" type="User"> <result column="id" property="id"/> <result column="name" property="name"/> <result column="pwd" property="password"/></resultMap><select id="getUserById" resultType="UserMap"> select * from mybatis.user where id = #{id}</select>
复制代码
resultMap 元素是 MyBatis 中最重要最强大的元素。
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
ResultMap 的优秀之处——你完全可以不用显式地配置它们
6.日志
1.日志工厂
如果一个数据库操作出现了异常，我们需要排错，日志就是最好的助手
曾经：sout debug
现在：日志工厂
SLF4J
LOG4J 【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 【掌握】
NO_LOGGING
在 Mybatis 中具体使用那一个日志实现，在设置中设定
STDOUT_LOGGING 标准日志输出
在 mybatis 核心配置文件中，配置我们的日志
<settings> <setting name="logImpl" values = "STDOUT_LOGGING"/></settings>
复制代码
2.Log4j
什么是 Log4j？
Log4j 是Apache的一个开源项目，通过使用 Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
我们也可以控制每一条日志的输出格式；
过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程
通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
1.先导入 log4j 的包
<!-- https://mvnrepository.com/artifact/log4j/log4j --><dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version></dependency>
复制代码
2.log4j.properties
#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码log4j.rootLogger=DEBUG,console,file
#控制台输出的相关设置log4j.appender.console = org.apache.log4j.ConsoleAppenderlog4j.appender.console.Target = System.outlog4j.appender.console.Threshold=DEBUGlog4j.appender.console.layout = org.apache.log4j.PatternLayoutlog4j.appender.console.layout.ConversionPattern=[%c]-%m%n
#文件输出的相关设置log4j.appender.file = org.apache.log4j.RollingFileAppenderlog4j.appender.file.File=./log/he.loglog4j.appender.file.MaxFileSize=10mblog4j.appender.file.Threshold=DEBUGlog4j.appender.file.layout=org.apache.log4j.PatternLayoutlog4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n
#日志输出级别log4j.logger.org.mybatis=DEBUGlog4j.logger.java.sql=DEBUGlog4j.logger.java.sql.Statement=DEBUGlog4j.logger.java.sql.ResultSet=DEBUGlog4j.logger.java.sql.PreparedStatement=DEBUG
复制代码
3.配置 log4j 为日志的实现
<settings> <setting name="logImpl" value="LOG4J"/> </settings>
复制代码
4.log4j 的使用，直接测试运行刚才的查询
简单使用
在要使用 log4j 的类中，导入包 import org.apache.log4j.Logger;
日志参数，参数为当前类的 class
static Logger logger = Logger.getLogger(UserDaoTest.class);
复制代码
日志级别
logger.info("info:进入了testLog4j"); logger.debug("debug:进入了testLog4j"); logger.error("error:进入了testLog4j");
复制代码
7.分页
思考：为什么要分页
1.使用 limit 分页
语法：select *from user limit startIndex,pageSize;select *from user limit 3; #[0,n]
复制代码
使用 Mybatis 实现分页，核心 sql
接口
// 分页 List<User> getUserByLimit(Map<String,Integer> map);
复制代码
Mapper.xml
<!--分页--> <select id="getUserByLimit" parameterType="map" resultType="UserMap"> select *from mybatis.user limit #{startIndex},#{pageSize} </select>
复制代码
测试
@Test public void GetUserByLimit(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); HashMap<String,Integer>map = new HashMap<String,Integer>(); map.put("startIndex",0); map.put("pageIndex",2); List<User> userList = mapper.getUserByLimit(map); for (User user : userList) { System.out.println(user); } sqlSession.close(); }
复制代码
2.RoeBounds 分页
不再使用 sql 实现分页
接口
// 分页2 List<User> getUserByRowBounds();
复制代码
2.mapper.xml
<!--分页2--><select id="getUserByRowBounds" resultType="UserMap"> select *from mybatis.user</select>
复制代码
3.测试
@Test public void getUserByRowBounds(){ SqlSession sqlSession = MybatisUtils.getSqlSession();
// 通过RowBounds实现 RowBounds rowBounds = new RowBounds(1, 2);
// 通过java代码实现分页 List<User> UserList = sqlSession.selectList("com.he.dao.UserDao.getUserByRowBounds",null,rowBounds); for (User user : UserList) { System.out.println(user); } sqlSession.close(); }
复制代码
3.分页插件
8.使用注解开发
1.面向接口编程
2.使用注解开发
注解在接口上实现
@Select("select * from User") List<User> getUsers();
复制代码
2.需要在核心配置文件中绑定接口
<!--绑定接口--> <mappers> <mapper class="com.he.dao.UserDao"/> </mappers>
复制代码
3.测试
本质：反射机制实现
底层：动态代理
Mybatis 详细的执行流程
3.CRUD
我们可以在工具类创建的时候实现自动提交事务
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession(true); }
复制代码
编写接口，增加注解
// 方法存在多个参数， @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 delete(@Param("uid")int id);
复制代码
测试类
注意：我们必须要将接口绑定到我们的核心配置文件中
关于 @Param()注解
9.lombok
Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.
@Getter and @Setter@NonNull@ToString@EqualsAndHashCode@Data@Cleanup@Synchronized@SneakyThrows
复制代码
使用步骤：
在 IDEA 中安装 Lombok 插件
在项目中导入 Lombok 的 jar 包
在实体类上加注解即可
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);
复制代码
搭建测试环境
导入 lombok
新建实体类 Teacher，Student
建立 Mapper 接口
建立 Mapper.xml 文件
在核心配置文件中绑定注册我们的 mapper 接口或者文件
测试查询是否能够成功
按照查询嵌套处理
<!-- 思路： 1.查询所有的学生信息 2.根据查询出来的学生的tid，寻找对应的老师 --><select id="getStudent" resultType="Student"> select * from student </select> <resultMap id="StudentTeacher" type="Student"> <result property="id" column="id"/> <result property="name" column="name"/> <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/> </resultMap> <select id="getTeacher" resultType="Teacher"> select * from teacher where id = #{id} </select>
复制代码
按照结果嵌套查询
<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>
复制代码
回顾 Mysql 多对一查询方式
11.一对多处理
比如：一个老师拥有多个学生
对于老师而言，就是一对多的关系
1.环境搭建
实体类
@Datapublic class Student { private int id; private String name; private int tid;}
复制代码
@Datapublic class Teacher{ private int id; private String name;
// 一个老师拥有多个学生 private List<Student> students;
}
复制代码
<!--复杂的属性，我们需要单独处理 对象：association 集合： collectionjavaType=""指定属性的类型集合中的泛型信息，我们使用ofType获取-->
复制代码
按照结果嵌套处理
<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"/>
<collection property="students" ofType="Student"> <result property="id" column="sid"/> <result property="name" column="sname"/> <result property="tid" column="tid"/> </collection></resultMap>
复制代码
按照查询嵌套处理
<select id="getTeacher2" resultMap="TeacherStudent2"> select * from mybatis.teacher where id = #{tid} </select>
<resultMap id="TeacherStudent2" type="Teacher"> <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId"/></resultMap>
<select id="getStudentByTeacherId" resultType="Student"> select * from mybatis.student where tid = #{tid}</select>
复制代码
小结
1.关联-association【多对一】
2.集合-collection【一对多】
3.javaType & ofType
javaType 用来指定实体类中属性的类型
ofType 用来指定映射到 list 或者集合中的 pojo 类型，泛型中的约束类型
注意点：
面试高频：
Mysql 引擎
InnoDB 底层原理
索引
索引优化
12.动态 SQL
什么是动态 SQL：动态 SQL 就是指根据不同的条件生成不同的 SQL 语句
使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。
如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。
ifchoose (when, otherwise)trim (where, set)foreach
复制代码
搭建环境
CREATE TABLE blog( id varchar(50) not null comment '博客id', title varchar(100) not null comment '博客标题', auther varchar(30) not null comment '博客作者', create_time datetime not null comment '创建时间', view int(30) not null comment '浏览量')engine = InnoDB default charset = utf8;
复制代码
创建一个基础工程
导包
编写配置文件
编写实体类
@Datapublic class Blog { private int id; private String title; private String auther; private Date create_time; private int views;}
复制代码
4.编写实体类对应 Mapper 和 Mapper.xml 文件
<insert id="addBlog" parameterType="blog"> insert into mybatis.blog(id, title, author, createTime, views) values (#{id}, #{title}, #{author}, #{createTime}, #{views})</insert>
复制代码
IF
<select id="queryBlogIF" parameterType="map" resultType="blog"> select *from mybatis.blog where 1=1 <if test="title!=null"> and title = #{title} </if> <if test="author!=null"> and author = #{author} </if></select>
复制代码
@Test public void queryBlogIF(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); BlogMapper mapper = sqlSession.getMapper(BlogMapper.class); HashMap map = new HashMap();// map.put("title","我是小仙女"); map.put("author","小何"); List<Blog> blogs = mapper.queryBlogIF(map); for (Blog blog : blogs) { System.out.println(blog); } sqlSession.close(); }
复制代码
choose(when,otherwise)
<select id="queryBlogChoose" parameterType="map" resultType="blog"> select * from mybatis.blog <where> <choose> <when test="title != null"> title = #{title} </when>
<when test="author != null"> and author = #{author} </when> <otherwise> and views = #{views} </otherwise> </choose> </where></select>
复制代码
trim(where,set)
<select id="queryBlogIF" parameterType="map" resultType="blog"> select *from mybatis.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 mybatis.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
foreach
select * from user where 1=1 and
<foreach item="id" index="index" collection="list" open="(" separator="or" close=")"> #{id} </foreach>
(id = 1 or id = 2 or id = 3)
复制代码
<!-- select *from mybatis.blog where 1=1 and (id = 1 or id = 2 or id = 3)
我们现在传递一个万能的map，这map中可以存在一个集合--><select id="queryBlogForeach" parameterType="map" resultType="blog"> select * from mybatis.blog <where> <foreach collection="ids" item="id" open="and (" close=")" separator="or"> id = #{id} </foreach> </where></select>
复制代码
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 mybatis.blog
<where> <include refid="if-title-author">
</include> </where>
</select>
复制代码
注意：
最好基于单表来定义 SQL 片段
不要存在 where 标签
动态 sql 就是在拼接 sql 语句，我们只需要保证 sql 的正确性，按照 sql 的格式，去排列组合就好了
建议：先在 Mysql 中写出完整的 sql，再对应修改成为我们的动态 sql 实现通用即可
13.缓存
1.简介：
查询 ：连接数据库 耗费资源一次查询的结果，给他暂存到一个可以直接取到的地方 --->内存:缓存我们再次查询相同的数据的时候，直接走缓存，就不用走数据库了
复制代码
什么是缓存？
为什么使用缓存？
什么样的数据能够使用缓存？
2.Myabtis 缓存
3.一级缓存
测试步骤：
开启日志
测试在一个 Session 中查询两次相同的记录
查看日志输出
缓存失效的情况：
查询不同的东西
增删改操作，可能会改变原理的数据，所以必定会刷新缓存
查询不同的 Mapper.xml
手动清理缓存
@Test public void test(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlSession.getMapper(UserMapper.class); User user = mapper.queryUsersById(1); System.out.println(user);
// mapper.updateUser(new User(2,"aaa","bbb")); sqlSession.clearCache();//手动清理缓存 System.out.println("=========================="); User user2 = mapper.queryUsersById(1); System.out.println(user2); System.out.println(user==user2); sqlSession.close(); }
复制代码
小结：一级缓存默认是开启的，只在一次 sqlsession 中有效，也就是拿到连接到关闭连接这个区间段
一级缓存相当于一个 map
4.二级缓存
二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存；
基于 namespace 级别的缓存，一个名称空间，对应一个二级缓存；
工作机制
一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；新的会话查询信息，就可以从二级缓存中获取内容；不同的 mapper 查出的数据就会放在自己对应的缓存（map）中；
步骤：
在 mybatis-config.xml 开启全局缓存
<!--显示的开启全局缓存--><setting name="cacheEnabled" value="true"/>
复制代码
2.在要使用二级缓存的 Mapper 中开启
也可以自定义参数
<!--在当前Mapper.xml中使用二级缓存--> <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
复制代码
3.测试
问题：我们需要将实体类序列化
小结：
5.缓存原理
6 .自定义缓存-ehcache（可以了解）
Ehcache 是一种广泛使用的开源 Java 分布式缓存，主要面向通用缓存。
要在程序中使用 ehcache，先要导包！
<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache --> <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-ehcache</artifactId> <version>1.1.0</version> </dependency>
复制代码
在 mapper 中指定使用我们的 ehcache 缓存实现！
Redis 数据库来做缓存
评论