Mybatis 学习笔记

参考狂神说Java视频

环境

本人的，，

• JDK1.8
• Mysql 8.0.
• Maven 3.8.4
• IDEA

回顾：

• JDBC
• Mysql
• Java基础
• Maven
• Junit

SSM框架：配置文件的。
最好的方式：看官网文档 https://mybatis.org/mybatis-3/
和百度百科

1、简介

1.1 什么是Mybatis

• Mybatis是一款优秀的持久层框架
• 它支持定制化SQL、存储过程以及高级映射。
• Mybatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。
• Mybatis可以使用简单的XML或者注解来配置和映射原生类型、接口和Java的POJO（Plain Old Java Object，普通老式Java对象）为数据库中的记录。
• MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis。
• 2013年11月迁移到Github。https://github.com/mybatis

如何获得Mybatis？

• Maven仓库：https://mvnrepository.com/

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.9</version>
</dependency>

• GitHub：https://github.com/mybatis
• 官网文档 https://mybatis.org/mybatis-3/

1.2 持久化

数据持久化（动作）

• 持久化：就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失去
• 数据库（jdbc），io文件持久化。
• 生活：冷藏，罐头。

为什么需要？

• 有一些对象，不能断电就失去。
• 内存太贵了

1.3 持久层

Dao层，Service层，Controller层（概念）

• 完成持久化工作的代码块
• 层界限十分明显

1.4 为什么需要Mybatis?

• 方便
• 传统JDBC代码太复杂了，简化，框架。自动化。
• 帮助程序员将数据存入到数据库中
• 不用Mybatis也可以。更容易上手。 技术没有高低之分
• 优点
  • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件。易于学习，易于使用。通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
  • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
  • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
  • 提供映射标签，支持对象与数据库的ORM字段关系映射。
  • 提供对象关系映射标签，支持对象关系组建维护。
  • 提供xml标签，支持编写动态sql

最重要的一点：使用的人多！
Spring SpringMVC SpringBoot

2、第一个Mybatis程序

思路：搭建环境–> 导入Mybatis --> 编写代码 --> 测试！

2.1 搭建环境

mysql 和 Mybatis 的 jar包
SQLSession --> 建了个工具类（看文档）
配置文件：连接数据库（mapperRigstry）
写实体类、接口、原来是Impl，现在是写Mapper.xml

1. 搭建数据库，先建表

2. 新建项目

1. 新建一个普通的Maven项目（搭建环境）

3. 删除src目录（父工程）

导入jar包

3. 创建一个模块

1. new module

2. 编写Mybatis的核心配置文件

Mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>


</configuration>

idea连接mysql注意事项

时区问题，手动设置serverTimezone = GMT

再试就连接成功了

选择schemes

3. 编写Mybatis的工具类

类似 jdbc里的 connection

package com.sako.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

//工具类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);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法

    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }


}

2.2 编写代码

• 实体类
• Dao接口
• 接口实现类（由原来的UserDaoImpl --> 转变为一个Mapper配置）

xml配置

UserDaoImpl.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
        
<!--namespace = 绑定一个对应的Dao/Mapper接口 -->

<mapper namespace="com.sako.dao.UserDao">

    <select id="getUserList" resultType="com.sako.pojo.User">
        select * from test.user;
    </select>

</mapper>

常用 ResultType和ResultMap

2.3 测试

Junit测试

package com.sako.dao;

import com.sako.pojo.User;
import com.sako.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {

    @Test
    public void test(){
        // 第一步：获取SQLSession对象
        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();

    }

}

可能会遇到的问题

1. 配置文件没有注册（MapperRegistry）
2. 绑定接口错误（namespace写错了）（以下都是xml配置里的问题）
3. 方法名不对（id）
4. 返回类型不对（returnType）
5. Maven导出资源问题（pom.xml里改）

maven问题解决方案

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>Mybatis-Study</artifactId>
        <groupId>com.sako</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>Mybatis-01</artifactId>

    <!--在 build 中 配置resources，来防止我们资源导出失败的问题, 资源过滤开启-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>

输出问题

解决了MybatisUtils里的 多个SQLSession创建问题 之后，输出了内存地址。

输出内存地址的，看下pojo有没有override toString方法

 @Override
    public String toString() {
        return "User {id=" + id + ", name=" + name + ", pwd=" + pwd + "}";
    }

MapperRegistry

核心文件中 注册 Mappers

<!-- 每一个Mapper.xml 都需要在Mybatis 核心配置文件中注册！ -->
    <mappers>
        <mapper resource="com/sako/dao/UserMapper.xml"/>
    </mappers>

BindingError
Mybatis-config.xml文件里的Mapper配置不能删。

为什么用新版的连接方式

三个核心接口

只是建议try catch, 但是一般不用。

7步

3、 增删改查实现（CRUD）

1. namespace

namespace中的包名，要和Dao、Mapper接口的包名一致

2. select

选择，查询语句；

• id：就是对应的namespace中的方法名；
• resultType：Sql语句执行的返回值！
• parameterType：参数类型！

3. 顺序

1. 编写接口
2. 编写对应的mapper中的sql语句
3. 测试

查 getUserById

接口

    // 根据ID 查询用户
    User getUserById(int id);

Mapper.xml

<select id="getUserById" parameterType="int" resultType="com.sako.pojo.User">
        select * from test.user where id = #{id}
    </select>

测试

    @Test
    public void getUserById(){
        // 第一步：获取SQLSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.getUserById(1);
        System.out.println(user);

        // 关闭sqlSession
        sqlSession.close();

    }

增加一个User

接口

    // insert 一个用户
    int addUser(User user);

mapper.xml

    <!--insert 一个用户, 对象中的属性可以直接取出来 -->
    <insert id="addUser" parameterType="com.sako.pojo.User" >
        insert into test.user (id, name, pwd) values(#{id},#{name},#{pwd});
    </insert>

测试

  // 增删改，需要提交事务
    @Test
    public void addUser(//这里不能有参数){
        // 第一步：获取SQLSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int res = mapper.addUser(new User(4,"haha","123333"));
        if(res>0){
            System.out.println("插入成功！");
        }

        // 提交事务
        sqlSession.commit();
        // 关闭sqlSession
        sqlSession.close();
    }

SQLSession 与 Connection 功能差不多

修改一个用户的信息

接口

// 修改用户
    int updateUser(User user);

mapper.xml

<!--update 一个用户, 对象中的属性可以直接取出来 -->
    <update id="updateUser" parameterType="com.sako.pojo.User">
        update test.user set name=#{name},pwd=#{pwd} where id = #{id};
    </update>

测试

// 增删改，需要提交事务
    @Test
    public void updateUser(){
        // 第一步：获取SQLSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int res = mapper.updateUser(new User(4,"喝喝","1232123"));
        if(res>0){
            System.out.println("修改成功！");
        }

        // 提交事务
        sqlSession.commit();
        // 关闭sqlSession
        sqlSession.close();
    }

删除一个用户

接口

// 删除一个用户
    int deleteUser(int id);

mapper.xml

    <!--delete 一个用户, 对象中的属性可以直接取出来 -->
    <delete id="deleteUser" parameterType="int">
        delete from test.user where id = #{id};
    </delete>

测试

 @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int res = mapper.deleteUser(4);
        if(res>0){
            System.out.println("删除成功");
        }

        sqlSession.commit();
        sqlSession.close();
    }

4.分析错误

注意点：

• 增删改需要提交事务！
• sql标签不要匹配错误
• mybatis-config.xml resource里是 / ，sql的mapper.xml里是 .
• 程序配置文件必须符合规范（数据库连接 多个”）
• NullPointerException，没有注册到资源（多个sqlSessionFactory）
• 输出的xml文件中存在中文乱码问题！（IDEA右下角的改成UTF-8）
• maven资源没有导出问题！（pom.xml 在 build 中 配置resources，来防止我们资源导出失败的问题, 资源过滤开启）

4. 万能 Map（了解）

假如，我们的实体类，或者数据库中的表，字段或者参数过多，我们应该考虑使用Map！

mapper.xml（参数值是map）

接口

测试

Map传递参数，直接在sql中取出key即可！【parameterType=“map”】
对象传递参数，直接在sql中取对象的属性即可！【parameterType=“Object”】
只有一个基本类型参数的情况下，可以直接在sql中取到！

多个参数用Map，或者注解！（保留话题）

模糊查询

1. Java代码执行的时候，传递通配符 %内容%
2. 在sql拼接中使用通配符（会有注入危险）

测试

sql

sql注入（不安全，最好写死）

5. 配置解析

1. 核心配置文件

• Mybatis-config.xml
• Mybatis 的配置文件包含了会深深影响 Mybatis 行为的设置和属性信息。
• 默认的事务管理器就是JDBC, 连接池是 POOLED

2. 环境配置（environments）

Mybatis可以配置成适应多种环境
ps：尽管可以配置多个环境，但每个SQLSessionFactory 实例只能选择一种环境。

事务管理器

两个type

数据源

三个type

3. 属性 properties

我们可以通过properties属性 - 来实现引用配置文件。

这些属性都是可以外部配置，且动态替换的。既可以在典型的Java属性文件中配置，亦可以通过properties元素的子元素来传递。【db.properties】

编写一个配置文件db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

xml顺序（约定大于顺序）

属性优化（注意default选中默认的development，，）

• 可以直接引入外部文件
• 可以在其中增加一些属性配置
• 如果两个文件有同一个字段，优先使用外部配置文件的！

可以分开加 property （但是优先使用外部配置文件）

4. 别名优化 typeAlias

• 类型别名是为Java类型设置一个短的名字。
• 存在的意义仅在于用来减少类完全限定名的冗余

第一种：


第二种：
也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如： 扫描实体类的包，它的默认别名就为这个类的类名，首字母小写！

• 实体类较少的时候，可以使用第一种（单独设定）
• 实体类较多的时候，可以使用第二种（包）
• 第一种可以DIY别名。第二种则不行，如果非要改别名，需要在实体上增加注解（@Alias（“user”）public class user{} ）

5. 设置

这是Mybatis 中极为重要的调整设置，它们会改变Mybatis的运行时行为。

6. 其他配置

不用了解的（）

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）
  • Mybatis-generator-core
  • Mybatis-plus
  • 通用mapper

Mybatis-plus

7. 映射器 mapper

MapperRegistry：注册绑定我们的Mapper文件

注册的方法：
推荐使用方式一
注意点：

• 接口和他的Mapper配置文件必须同名
• 接口和他的Mapper配置文件必须在同一个包下！

方式三：使用扫描包进行注入绑定

练习：

8. 生命周期 和 作用域（Scope）

生命周期 和 作用域 是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder：

• 一旦创建了 SqlSessionFactory，就不再需要SqlSessionFactoryBuilder了
• 局部变量

SqlSessionFactory：

• 可以想象为：数据库连接池
• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
• 因此 SqlSessionFactory 的最佳作用域是应用作用域。
• 最简单的就是使用单例模式或者静态单例模式。（最好只有一个全局变量）

SqlSession

• 连接到连接池的一个请求！（需要开启）
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。

• 用完之后需要赶紧关闭，否则资源被占用！
  这里的每一个Mapper就代表一个具体的业务！

6. 解决属性名和字段名不一致的问题

问题

新建一个项目，拷贝之前的，测试 实体类字段不一致 的情况！

测试

解决方法

sql 的 as ：起别名（太简单了）

ResultMap

结果集映射

• resultMap 元素是 MyBatis 中最重要最强大的元素。
• ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

7. 日志

7.1 日志工厂

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的助手！
曾经：sout，debug
现在：日志工厂！

在Mybatis中具体使用哪个日志实现，在设置中设定！
STDOUT_LOGGING标准日志输出

多一个空格都不行（约定）必须叫logImpl

在Mybatis核心配置文件中，配置我们的日志，分析！

7.2 log4j

什么是log4j？

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件。
• 我们也可以控制每一条日志的输出格式；
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1. 先导入log4j的包（maven 的 pom.xml）

<!-- 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.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/kuang.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

3. 配置log4j为日志的实现

<settings>
	<setting name="logImpl" value=""/>
</settings>

4. Log4j 的使用，直接测试运行刚才的查询

简单使用

1. 在要使用log4j 的类中，导入包 import org.apache.log4j.Logger;
2. 日志对象，参数为当前类的class

static Logger logger = Logger.getLogger(UserDaoTest.class);

3. 日志级别

8.分页

思考：为什么要分页？

• 减少数据的处理量

使用Limit分页

语法：SELECT * from user limit startIndex,pageSize;

SELECT * from user limit 3; //[0,n]

使用Mybatis实现分页，核心SQL

1. 接口

    // 分页
    List<User> getUserByLimit(Map<String,Integer> map);

2. Mapper.xml

 <!--结果集映射-->
    <resultMap id="UserMap" type="User">
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwdNew" property="pwd"/>
    </resultMap>
    
    <!-- 分页 -->
    <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
        select * from user limit #{startIndex},#{pageSize}
    </select>

3. 测试

 @Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        HashMap<String,Integer> map = new HashMap<String,Integer>();
        map.put("startIndex",0);
        map.put("pageSize",2);

        List<User> userList = mapper.getUserByLimit(map);

        for (User user : userList) {
            System.out.println(user);
        }

        sqlSession.close();
    }

RowBounds分页（不使用SQL分页）

不再使用SQL实现分页

1. 接口

	//分页2
	List<User> getUserByRowBounds();

2. Mapper.xml

	<!--分页2-->
	<select id="getUserByRowBounds" resultMap="UserMap">
		select * from 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.sako.dao.UserMapper.getUserByRowBounds",null,rowBounds);

        for (User user : userList) {
            System.out.println(user);
        }

        sqlSession.close();
    }

分页插件

MyBatis 分页插件 PageHelper

底层都是 limit，了解即可，需要知道这是什么东西。

9. 使用注解开发

1. 注解在接口上实现
2. 需要在核心配置文件中绑定接口！(在 mybatis-config.xml 里注册mapper)
3. 测试

1. 面向接口编程

大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程

面向接口编程： 解耦
**根本原因：**可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好。

• 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;
• 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

• 接口从更深层次的理解，应是定义 (规范，约束)与实现 (名实分离的原则)的分离
• 接口的本身反映了系统设计人员对系统的抽象理解。
• 接口应有两类:
  • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class);
  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面 (interface) ;
• 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

1. 使用注解写 接口
   

2. 在 mybatis-config.xml 里注册mapper
   

3. 测试结果
   

建议 复杂的不使用注解

核心

注解开发
本质：应用反射机制实现 （ java 基础）
底层：动态代理！

2. Mybatis详细的执行流程（P16

↓

回滚事务

成功，关闭

3. CRUD

尽量不使用 自动提交事务

在工具类创建的时候实现自动提交事务！
设置自动提交事务，就不用在测试的地方写commit（）了

注解实现get user by id

1. 接口（注解实现）名字需要对应

	// 方法存在多个参数，所有的参数前面必须加上@Param（“id”）注解
    @Select("select * from user where id = #{id}")
    User getUserById(@Param("id") int id);

2. 测试
   

注解实现insert

1. 接口

 	@Insert("insert into user(id,name,pwdNew) values (#{id},#{name},#{pwdNew})")
    int addUser(User user);

3. 测试
   

注解实现update

1. 接口

	@Update("update user set name=#{name}, pwdNew=#{pwdNew} where id = #{id}")
    int updateUser(User user);

2. 测试
   

注解实现delete

1. 接口

	@Delete("delete from user where id = #{id}")
    int deleteUser(@Param("id") int id);

2. 测试

测试类
注意：我们必须要将接口绑定到配置核心文件中。

 <!-- 绑定接口   -->
    <mappers>
        <mapper class="com.sako.dao.UserMapper"/>
    </mappers>

关于@Param（）注解

• 基本类型的参数，或者String类型，需要加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上！
• 我们在SQL中引用的就是我们这里的@Param（） 中设定的属性名！

#{} 预编译 和 ${} 区别

10. Lombok

方便使用的 第三方工具

1
2

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>1ombok</artifactId>
	<version>1.18.10</version>
</dependency>

3. 在实体类上加注解即可!

11. 多对一处理

复杂查询环境搭建

1. 导入lombok（都行）
2. 新建实体类（Teacher，Student）
3. 建立Mapper接口
4. 建立Mapper.xml文件
5. 在核心配置文件中绑定注册我们的Mapper接口或者文件！（方式很多，随心选择）
6. 测试查询是否能够成功！

理解：

• 多个学生，对应一个老师
• 对于学生而言，关联 （多个学生，关联一个老师）多对一
• 对于老师而言，集合（一个老师，有很多学生）一对多

SQL

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','1');
insert into `student` (`id`,`name`,`tid`) values ('2','呼噜2','1');
insert into `student` (`id`,`name`,`tid`) values ('3','呼噜3','1');
insert into `student` (`id`,`name`,`tid`) values ('4','呼噜4','1');
insert into `student` (`id`,`name`,`tid`) values ('5','呼噜5','1');

1.pojo

学生

package com.sako.pojo;

public class Student {
    private int id;
    private String name;

    // 学生要关联一个老师
    private Teacher teacher;

    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 Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}

老师

package com.sako.pojo;

public class Teacher {
    private int id;
    private String name;

    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;
    }
}

mapper

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.sako.dao.StudentMapper">

</mapper>

2. 接口

public interface TeacherMapper {

    @Select("select * from teacher where id = #{tid}")
    Teacher getTeacher(@Param("tid") int id);


}

绑定

<!-- 绑定接口 -->
    <mappers>
        <mapper class="com.sako.dao.TeacherMapper"/>
        <mapper class="com.sako.dao.StudentMapper"/>
    </mappers>

3. 测试

1. 多对一

对于学生而言，关联 （多个学生，关联一个老师）多对一

按照查询嵌套处理

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.sako.dao.StudentMapper">

<!-- 思路：
        1. 查询所有的学生信息
        2. 根据查询出来的学生的tid，寻找对应的老师！
        -->
    <select id="getStudent" resultMap="StudentTeacher">
        select * from student;
    </select>

    <resultMap id="StudentTeacher" type="com.sako.pojo.Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!-- 复杂的属性，我们需要单独处理。对象: association。集合: collection -->
        <association property="teacher" column="tid" javaType="com.sako.pojo.Teacher" select="getTeacher"/>
    </resultMap>

    <select id="getTeacher" resultType="com.sako.pojo.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="com.sako.pojo.Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="com.sako.pojo.Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

回顾 Mysql 多对一的查询方式：

• 子查询
• 联表查询

2. 一对多

对于老师而言，集合（一个老师，有很多学生）一对多

搭建环境，和刚才一样

实体类（老师）

package com.sako.pojo;

import java.util.List;

public class Teacher {
    private int id;
    private String name;

    // 一个老师拥有多个学生
    private List<Student> students;

    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 List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", students=" + students +
                '}';
    }
}

学生

package com.sako.pojo;

public class Student {
    private int id;
    private String name;

    // 学生要关联一个老师
    private int tid;

    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 int getTid() {
        return tid;
    }

    public void setTid(int tid) {
        this.tid = tid;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", tid=" + tid +
                '}';
    }
}

按照结果嵌套处理(推荐）

 <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>
<!--   1. 按照结果嵌套查询-->
    <resultMap id="TeacherStudent" type="com.sako.pojo.Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--复杂的属性，我们需要单独处理。对象: association。集合: collection
            javaType-指定的属性类型
            集合中的泛型信息，我们使用ofType获取
        -->
        <collection property="students" ofType="com.sako.pojo.Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>

    </resultMap>

按照查询嵌套处理

<!--    2. 子查询-->
    <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from teacher where id = #{tid}
    </select>

    <resultMap id="TeacherStudent2" type="com.sako.pojo.Teacher">
        <collection property="students" javaType="ArrayList" ofType="com.sako.pojo.Student" select="getStudentByTeacherId" column="id"/>
    </resultMap>

    <select id="getStudentByTeacherId" resultType="com.sako.pojo.Student">
        select * from student where tid = #{tid}
    </select>

接口

package com.sako.dao;

import com.sako.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface TeacherMapper {

    // 获取老师
    //List<Teacher> getTeacher();

    // 获取指定老师下的所有学生及老师的信息
    Teacher getTeacher(@Param("tid") int id);

    Teacher getTeacher2(@Param("tid")int i);
}

测试

import com.sako.pojo.Teacher;
import com.sako.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MyTest {

//    @Test
//    public void test(){
//        SqlSession sqlSession = MybatisUtils.getSqlSession();
//        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
//        List<Teacher> teacherList = mapper.getTeacher();
//
//        for(Teacher teacher: teacherList){
//            System.out.println(teacher);
//        }
//
//        sqlSession.close();
//    }

    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);

        System.out.println(teacher);

        sqlSession.close();
    }

    @Test
    public void test2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher2(1);

        System.out.println(teacher);

        sqlSession.close();
    }

}

小结

1. 关联 - association【多对一】
2. 集合 - collection【一对多】
3. javaType & ofType
   1. javaType 用来指定 实体类中属性的类型 （List - ArrayList）
   2. ofType 用来指定 映射到 List 或者 集合 中的 pojo 类型，泛型中的约束类型！（Student - List<Student>）

注意点：

• 保证SQL的可读性，尽量保证通俗易懂
• 注意一对多和多对一中，属性名和字段的问题！
• 如果问题不好排查错误，可以使用日志，建议使用（无）

面试必问

• MySQL引擎
• InnoDB底层原理
• 索引
• 索引优化！

12. 动态SQL

什么是动态SQL：动态SQL就是指根据不同的条件，生成不同的SQL语句

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，
你对动态 SQL 元素可能会感觉似曾相识。
在 MyBatis 之前的版本中，需要花时间了解大量的元素。
借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，
大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。
	if
    choose (when, otherwise)
    trim (where, set)
    foreach

环境搭建

创建一个基础工程

1. 导包
2. 编写配置文件
3. 编写实体类

package com.sako.pojo;

import java.util.Date;

public class Blog {
    private int id;
    private String title;
    private String author;
    private Date createTime;
    private int views;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public int getViews() {
        return views;
    }

    public void setViews(int views) {
        this.views = views;
    }
}

4. 编写实体类对应 Mapper 接口 和 Mapper.xml 文件

settings

1. 接口

package com.sako.dao;

import com.sako.pojo.Blog;

public interface BlogMapper {
    // 插入数据
    int addBlog(Blog blog);
}

2. mapper

解决 org.apache.ibatis.binding.BindingException: Invalid bound statement (not found) 问题

mapper没有写 parameterType="com.sako.pojo.Blog"

完整版

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.sako.dao.BlogMapper">


    <insert id="addBlog" parameterType="com.sako.pojo.Blog">
        insert into blog (id, title, author, create_time, views)
        values (#{id}, #{title}, #{author}, #{createTime}, #{views});
    </insert>

</mapper>

3. 测试

import com.sako.dao.BlogMapper;
import com.sako.pojo.Blog;
import com.sako.utils.IDUtils;
import com.sako.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.Date;

public class MyTest {

    @Test
    public void addBlogTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        Blog blog = new Blog();
        blog.setId(IDUtils.getId());
        blog.setTitle("Mybatis");
        blog.setAuthor("狂神说");
        blog.setCreateTime(new Date());
        blog.setViews(9999);

        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("Java");
        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("Spring");
        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("微服务");
        mapper.addBlog(blog);

        sqlSession.close();
    }

}

问题：
实体类中的 private Date createTime; //属性名 - 字段名 不一致
mapper 里的 SQL （要一致！）

1. 动态SQL之IF语句

1. 接口

	// 查询博客
    List<Blog> queryBlogIF(Map map);

2. mapper.xml里

<select id="queryBlogIF" parameterType="map" resultType="com.sako.pojo.Blog">
        select * from blog where 1=1
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </select>

3. 测试

 @Test
    public void queryBlogIF(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
        // map.put("title","Java");
        map.put("author","狂神说");

        List<Blog> blogs = mapper.queryBlogIF(map);

        for(Blog blog : blogs){
            System.out.println(blog);
        }

        sqlSession.close();
    }

2. 动态SQL之 常用标签

1. choose (when, otherwise)

类似switch case（只走一个）(自动去掉）

接口

<!--    choose-->
    <select id="queryBlogChoose" resultType="com.sako.pojo.Blog">
        select * from 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>

2. trim (where, set)

where(自动去掉 and 或者 or）
(where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除)

<select id="queryBlogIF" parameterType="map" resultType="com.sako.pojo.Blog">
     select * from blog 
     <where>
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
     </where>
</select>

• set (自动去掉，）

 <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>

测试

 @Test
    public void updateBlog(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
        map.put("title","Java2");
        map.put("author","狂神说");
        map.put("id","a0cc652dd059483dbaf104ac7c7edd9c");

        mapper.updateBlog(map);

        sqlSession.close();
    }

所谓的动态SQL，本质还是写SQL语句。
只是我们可以在SQL层面，去执行一个逻辑代码。

3. 动态SQL之 Foreach

1. Foreach

1. 接口

	// 查询第1-2-3号
    List<Blog> queryBlogForeach(Map map);

2. xml

<!-- 查询 foreach
        select * from blog where 1=1 and (id=1 or id=2 or id=3)
        我们现在传递一个万能的map，这个map中可以存在一个集合！
    -->
    <select id="queryBlogForeach" parameterType="map" resultType="com.sako.pojo.Blog">
        select * from blog
        <where>
            <foreach collection="ids" item="id" open="and (" close=")" separator="or">
                id = #{id}
            </foreach>
        </where>
    </select>

3. 测试

2. SQL脚本片段

（封装）多条相同的代码。。。

1. 使用sql标签抽取公共的部分
2. 在需要使用的地方使用include标签引用即可

<sql> <include>

注意：SQL片段

• 最好基于单表来定义SQL片段
• 不要存在 where 标签

动态SQL就是在拼接SQL语句，我们只要保证SQL的正确。按照SQL的格式，去排列组合就可以了。

建议：

• 先在MySQL里写出完整的SQL，再对应的去修改成为我们的动态SQL实现通用即可！

13. 缓存 （了解）

查询： 连接数据库 ，耗资源!

一次查询的结果，给他暂存在一个可以直接取到的地方! --> 内存：缓存
我们再次查询相同数据的时候，直接走缓存，就不用走数据库了。

1. 简介

1. 什么是缓存？
   。存在内存中的临时数据
   。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

（了解）

2. 为什么使用缓存？
   。减少和数据库的交互次数，减少系统开销，提高系统效率

3. 什么样的数据能使用缓存？
   。经常查询并且不经常改变的数据

2. Mybatis缓存

• MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
  • 默认情况下，只有一级缓存开启。 (SglSession级别的缓存，也称为本地缓存)
  • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
  • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

1. 一级缓存 (本地缓存

• 与数据库同一次会话期间查询到的数据会放在本地缓存中。
• 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库

测试步骤：

1. 开启日志！
2. 测试在一个Session中查询两次记录（相同的）
3. 查看日志输出

只用了一次sql

缓存失效情况：

1. 查询不同的东西

2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存！
   

3. 查询不同的Mapper.xml

4. 手动清理缓存！

一级缓存 == 一个map

2. 二级缓存（全局缓存）

• 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存。
• 基于namespace级别(在xml文件中生效)的缓存，一个名称空间，对应一个二级缓存；
• 工作机制
  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中。
  • 如果当前会话关闭了，这个会话对应的一级缓存就没了; 但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中;
  • 新的会话查询信息，就可以从二级缓存中获取内容；
  • 不同的 mapper 查出的数据会放在自己对应的缓存 (map) 中;

步骤：

1. 开启全局缓存
   <!--显示的开启全局缓存--> <setting name="cacheEnabled" value="true"/>

2. 局部缓存，局部刷新缓存。。

3. 测试
   1. 问题：我们需要将实体类序列化（写）！否则就会报错
      Caused by: java.io.NotSerializableException: com.kuang.pojo.User

小结：
。只要开启了二级缓存，在同一个Mapper下就有效
。所有的数据都会先放在一级缓存中;
。只有当会话提交，或者关闭的时候，才会提交到二级缓冲中!

3. Mybatis缓存原理

二 --> 一 --> 数据库

4. 自定义缓存 Ehcache

P30 看视频过一下就行。
Redis数据库来做缓存！

14. Mybatis总结

从头看一遍。

15. 聊聊Spring

https://spring.io/