MyBatis 学习笔记 - 2021-7-10 - 2021-7-13

1. MyBatis简介

视频链接【狂神说Java】Mybatis最新完整教程IDEA版通俗易懂_哔哩哔哩_bilibili

环境：

• JDK 1.8
• MySQL 5.7
• maven 3.6.1
• IDEA

什么是 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。

1.1 如何获取 MyBatis

• maven 仓库

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

• Github：Releases · mybatis/mybatis-3 (github.com)

• 官方文档：mybatis – 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。

最重要的一点：时用的人多！

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,'origami','123456'),
	(2,'tt','123456'),
	(3,'hyp','123456')

新建项目

1. 新建一个普通的 maven 项目

2. 删除 src 目录

3. 导入 maven 依赖

   <!--父工程-->
   <groupId>com.tt</groupId>
   <artifactId>MyBatis-Stu</artifactId>
   <version>1.0.0</version>
   
   <!--导入依赖-->
   <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.6</version>
     </dependency>
     <!--junit-->
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
   

2.2 创建一个模块

• 编写 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核心配置文件-->
  <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&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
          <property name="username" value="root"/>
          <property name="password" value="hyp"/>
        </dataSource>
      </environment>
    </environments>
  
  </configuration>
  

• 编写 mybatis 工具类

  // sqlSessionFactory --> sqlSession
  public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
  
    static {
      String resource = "mybatis-config.xml";
      InputStream inputStream = null;
      try {
        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 编写代码

• 实现类

  public class User {
    private int id;
    private String name;
    private String pwd;
  
    public User() {
    }
  
    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 {
    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.tt.dao.UserDao">
    <!--select查询语句-->
    <select id="getUserList" resultType="com.tt.pojo.User">
      select *
      from mybatis.user
    </select>
  </mapper>
  

2.4 测试

注意点：

org.apache.ibatis.binding.BindingException: Type interface com.tt.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么？

核心配置文件种注册 mappers

• junit 测试

  public class UserDaoTest {
  
    @Test
    public void test() {
      // 第一步：获得 SqlSession对象
      SqlSession sqlSession = MyBatisUtils.getSqlSession();
      // 执行 SQL
      UserDao mapper = sqlSession.getMapper(UserDao.class);
      List<User> userList = mapper.getUserList();
      for (User user : userList) {
        System.out.println(user);
      }
      sqlSession.close();
    }
  }
  

可能遇到的问题：

1. 配置文件没有注册
2. 绑定接口错误
3. 方法名错误
4. 返回值类型不对
5. maven 导出资源问题
6. 中文注释问题

3. CRUD

1. namespace

namespace 中的包名要和 Dao/mapper 中的包名一致！

2. select

选择，查询语句：

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

1. 编写接口

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

2. 编写对应的 mapper 中的 sql 语句

   <select id="getUserById" parameterType="int" resultType="com.tt.pojo.User">
     select * from mybatis.user where id = #{0};
   </select>
   

3. 测试

   @Test
   public void getUserById() {
     SqlSession sqlSession = MyBatisUtils.getSqlSession();
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     User user = mapper.getUserById(1);
     System.out.println(user);
     sqlSession.close();
   }
   

3. insert

1. 编写接口

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

2. 编写对应的 mapper 的 sql 语句

   <insert id="addUser" parameterType="com.tt.pojo.User">
     insert into mybatis.user (id, name, pwd) values (#{id}, #{name}, #{pwd});
   </insert>
   

3. 测试

   @Test
   public void addUser() {
     SqlSession sqlSession = MyBatisUtils.getSqlSession();
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     int i = mapper.addUser(new User(23, "哈哈", "1233412"));
   
     if (i > 0) {
       System.out.println("插入成功");
     }
   //    提交事务
     sqlSession.commit();
     sqlSession.close();
   }
   

4. update

1. 编写接口

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

2. 编写对应的 mapper 的 sql 语句

   <update id="updateUser" parameterType="com.tt.pojo.User">
     update mybatis.user set name=#{name},pwd=#{pwd} where id = #{id};
   </update>
   

3. 测试

   @Test
   public void updateUser() {
     SqlSession sqlSession = MyBatisUtils.getSqlSession();
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     int i = mapper.updateUser(new User(23, "哈123哈", "12312412312"));
     if (i > 0) {
       System.out.println("更新成功");
     }
     sqlSession.commit();
     sqlSession.close();
   }
   

5. delete

1. 编写接口

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

2. 编写对应的 mapper 的 sql 语句

   <delete id="deleteUser" parameterType="int">
     delete from mybatis.user where id = #{id};
   </delete>
   

3. 测试

   @Test
   public void deleteUser() {
     SqlSession sqlSession = MyBatisUtils.getSqlSession();
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     int i = mapper.deleteUser(23);
     if (i > 0) {
       System.out.println("删除成功");
     }
     sqlSession.commit();
     sqlSession.close();
   }
   

注意点：

• 增删改需要提交事务！

6. 分析错误

• 标签不要匹配错，insert 语句使用 insert 标签。
• resource 绑定 mapper 需要使用路径。
• 程序配置文件必须符合规范
• NullPointerException，没有注册到资源。
• 输出的 xml 文件中存在中文乱码问题。
• maven 资源没有导出问题。

7. 万能Map

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

// 万能 map
User getUserById2(Map<String,Object> map);

<!--对象中的数学，可以直接取出来 传递 map 的 key-->
<insert id="addUser" parameterType="map">
  insert into mybatis.user (id, name, pwd) values (#{userId}, #{userName}, #{passWord});
</insert>

@Test
public void addUser2() {
  SqlSession sqlSession = MyBatisUtils.getSqlSession();
  UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  HashMap<String, Object> map = new HashMap<>();
  map.put("userId", 5);
  map.put("userName", "哈哈哈");
  map.put("passWord", "1234124");
  int i = mapper.addUser2(map);
  System.out.println(i);
  sqlSession.commit();
  sqlSession.close();
}

Map 传递参数，直接在 sql 中取出 key 即可。 [ parameterType=“map” ]

对象传递参数时，直接在 sql 中取对象的属性即可 [ parameterType=“Object” ]

只有一个参数的情况下，可以直接在 sql 中取到！

多个参数用 Map，或者注解！

8. 思考题

模糊查询

1. java 代码执行的时候，传递通配符 % %

   List<User> userList = mapper.getUserLike("%ga%");
   

2. 在 SQL 拼接中使用通配符。

   <!--select * from mybatis.user where name like "%"#{value}"%";-->
   

4. 配置解析

1. 核心配置文件

• mybatis-config.xml

• mybatis 的核心配置文件包含了会深深影响 mybatis 行为的设置和属性信息。

  configuration（配置）
  properties（属性）
  settings（设置）
  typeAliases（类型别名）
  typeHandlers（类型处理器）
  objectFactory（对象工厂）
  plugins（插件）
  environments（环境配置）
  environment（环境变量）
  transactionManager（事务管理器）
  dataSource（数据源）
  databaseIdProvider（数据库厂商标识）
  mappers（映射器）
  

2. 环境配置 （environments）

MyBatis 可以配置成适应多种环境

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

学会使用配置多套运行环境！

MyBatis 默认的事务管理器假设 JDBC，连接池：POOLED

3. 属性（properties）

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

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。[ db.properties ]

编写一个配置文件

db.properties

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

在核心配置文件中引入

<!--引入外部配置文件-->
<properties resource="db.properties">
  <property name="username" value="root"/>
</properties>

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

4.类型别名（typeAliases）

• 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置。
• 意在降低冗余的全限定类名书写。

<!--可以给实体类取别名-->
<typeAliases>
  <typeAlias type="com.tt.pojo.User" alias="User"/>
</typeAliases>

也可也指定一个包名，MyBatis 会在包名下搜索需要的Java Bean 比如：

扫描实体类的包，它的默认别名就为这个类的类名，首字母小写！

<typeAliases>
  <package name="com.tt.pojo"/>
</typeAliases>

在实体类比较少的时候，使用第一种方式

如果实体类十分多，建议使用第二种。

第一种可以DIY别名，第二种不写，如果非要改，需要在实体上增加注解

@Alias("user")
public class User { ... }

5. 设置 (settings)

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true | false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true | false	false
aggressiveLazyLoading	开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。	true | false	false （在 3.4.1 及之前的版本中默认为 true）
multipleResultSetsEnabled	是否允许单个语句返回多结果集（需要数据库驱动支持）。	true | false	true
useColumnLabel	使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。	true | false	true
useGeneratedKeys	允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）。	true | false	False
autoMappingBehavior	指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射；PARTIAL 只会自动映射没有定义嵌套结果映射的字段。 FULL 会自动映射任何复杂的结果集（无论是否嵌套）。	NONE, PARTIAL, FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定发现自动映射目标未知列（或未知属性类型）的行为。NONE: 不做任何反应WARNING: 输出警告日志（'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的日志等级必须设置为 WARN）FAILING: 映射失败 (抛出 SqlSessionException)	NONE, WARNING, FAILING	NONE
defaultExecutorType	配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定数据库驱动等待数据库响应的秒数。	任意正整数	未设置 (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。	任意正整数	未设置 (null)
defaultResultSetType	指定语句默认的滚动策略。（新增于 3.5.2）	FORWARD_ONLY | SCROLL_SENSITIVE | SCROLL_INSENSITIVE | DEFAULT（等同于未设置）	未设置 (null)
safeRowBoundsEnabled	是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。	true | false	False
safeResultHandlerEnabled	是否允许在嵌套语句中使用结果处理器（ResultHandler）。如果允许使用则设置为 false。	true | false	True
mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true | false	False
localCacheScope	MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 默认值为 SESSION，会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。	SESSION | STATEMENT	SESSION
jdbcTypeForNull	当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。 某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。	JdbcType 常量，常用值：NULL、VARCHAR 或 OTHER。	OTHER
lazyLoadTriggerMethods	指定对象的哪些方法触发一次延迟加载。	用逗号分隔的方法列表。	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态 SQL 生成使用的默认脚本语言。	一个类型别名或全限定类名。	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler	指定 Enum 使用的默认 TypeHandler 。（新增于 3.4.5）	一个类型别名或全限定类名。	org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls	指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。	true | false	false
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回 null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）	true | false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀。	任何字符串	未设置
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	未设置
proxyFactory	指定 Mybatis 创建可延迟加载对象所用到的代理工具。	CGLIB | JAVASSIST	JAVASSIST （MyBatis 3.3 以上）
vfsImpl	指定 VFS 的实现	自定义 VFS 的实现的类全限定名，以逗号分隔。	未设置
useActualParamName	允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。（新增于 3.4.1）	true | false	true
configurationFactory	指定一个提供 Configuration 实例的类。 这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。 这个类必须包含一个签名为static Configuration getConfiguration() 的方法。（新增于 3.2.3）	一个类型别名或完全限定类名。	未设置
shrinkWhitespacesInSql	从SQL中删除多余的空格字符。请注意，这也会影响SQL中的文字字符串。 (新增于 3.5.5)	true | false	false
defaultSqlProviderType	Specifies an sql provider class that holds provider method (Since 3.5.6). This class apply to the type(or value) attribute on sql provider annotation(e.g. @SelectProvider), when these attribute was omitted.	A type alias or fully qualified class name	Not set

6. 其他设置

• typeAliases（类型别名）
• objectFactory（对象工厂）
• plugins 插件
  • mybatis-generator-core
  • mybatis-plus
  • 通用 mapper

7. 映射器 (mappers)

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

方式一：

<mappers>
  <mapper resource="com/tt/dao/UserMapper.xml"/>
</mappers>

方式二：使用 class 文件绑定文件

<mappers>
  <mapper class="com.tt.dao.UserMapper"/>
</mappers>

注意点：

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

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

<mappers>
  <package name="com.tt.dao"/>
</mappers>

注意点：

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

5. 生命周期和作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iZ9RHBEP-1626154896879)(pic/生命周期和作用域.png)]
理解我们之前讨论过的不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。 — 官方文档

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

SqlSessionFactory

SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

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

SqlSession

每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。 下面的示例就是一个确保 SqlSession 关闭的标准模式：

try (SqlSession session = sqlSessionFactory.openSession()) {
// 你的应用逻辑代码
}

在所有代码中都遵循这种使用模式，可以保证所有数据库资源都能被正确地关闭。

• 连接到连接池的一个请求！
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
• 用完之后需要赶紧关闭，否则资源被占用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qNzeJuK3-1626154721526)(pic/SqlSessionFactory.png)]

这里面每一个 Mapper，就代表一个具体的业务！

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

1. 问题

数据库的字段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-18OVeybR-1626154721528)(pic/mybatis-数据库字段.png)]

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

修改 User 属性字段，使其和数据库中字段名不一致

public class User {
  private int id;
  private String name;
  private String password;
	...
}

测试时，出现问题

User{id=1, name='origami', pwd='null'}

//      select * from mybatis.user where id = #{id}
//      类型处理器
//      select id,name,pwd from mybatis.user where id = #{id}

解决方法：

• 起别名

  <select id="getUserById" parameterType="int" resultType="User">
    select id, name, pwd as password
    from mybatis.user
    where id = #{0}
  </select>
  

2. resultMap

resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的操作。实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的数千行代码。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

结果集映射

id name pwd
id name password

<!--结果集映射-->
<resultMap id="UserMap" type="User">
  <!--column数据库中的字段，property实体类中的属性 简单来说就是让 pwd 映射为 password -->
  <result column="id" property="id"/>
  <result column="name" property="name"/>
  <result column="pwd" property="password"/>
</resultMap>

<select id="getUserById" resultMap="UserMap"> <!-- resultMap! -->
  select *
  from mybatis.user
  where id = #{id}
</select>

• resultMap 元素是 MyBatis 中最重要最强大的元素。
• ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
• ResultMap 的优秀之处——你完全可以不用显式地配置它们

6. 日志

6.1 日志工厂

如果一个数据库操作，出现异常，我们需要排错。日志就是最好的助手。

曾经：sout、debug

现在：日志工厂

设置名	描述	有效值	默认值
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J |LOG4J |LOG4J2 |JDK_LOGGING |COMMONS_LOGGING |STDOUT_LOGGING |NO_LOGGING	未设置

• SLF4J
• LOG4J 【掌握】
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING 【掌握】
• NO_LOGGING

在 MyBatis 中具体使用哪一个日志实现，在设置中设定！

STDOUT_LOGGING标准日志输出

在mybatis核心配置文件中，配置日志。

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

Opening JDBC Connection
Created connection 1765250898.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@69379752]
==>  Preparing: select * from mybatis.user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, pwd
<==        Row: 1, origami, 123456
<==      Total: 1
User{id=1, name='origami', pwd='123456'}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@69379752]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@69379752]
Returned connection 1765250898 to pool.

6.2 Log4j

什么是Log4j?

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等。
• 我们也可以控制每一条日志的输出格式
• 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1. 先导入 log4j 的包

   <dependencies>
     <!-- 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/tt.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="LOG4J"/>
   </settings>
   

4. log4j 的使用，执行测试运行刚才的查询

   Connected to the target VM, address: '127.0.0.1:64439', transport: 'socket'
   [org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
   [org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
   [org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
   [org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
   [org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
   [org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
   [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Opening JDBC Connection
   [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1062186835.
   [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3f4faf53]
   [com.tt.dao.UserMapper.getUserById]-==>  Preparing: select * from mybatis.user where id = ?
   [com.tt.dao.UserMapper.getUserById]-==> Parameters: 1(Integer)
   [com.tt.dao.UserMapper.getUserById]-<==      Total: 1
   User{id=1, name='origami', pwd='123456'}
   [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3f4faf53]
   [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3f4faf53]
   [org.apache.ibatis.datasource.pooled.PooledDataSource]-Returned connection 1062186835 to pool.
   Disconnected from the target VM, address: '127.0.0.1:64439', transport: 'socket'
   

简单使用

1. 在要使用 log4j 的类中，导入包 import org.apache.log4j.Logger;

2. 日志对象，参数为当前类的 class

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

3. 日志级别

   logger.info("info:进入了testLog4j");
   logger.debug("debug:进入了testLog4j");
   logger.error("error:进入了testLog4j");
   

7. 分页

为什么要分页？

• 减少数据的处理量

7.1 使用分页

# 语法： 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

   <select id="getUserByLimit" parameterType="map" resultType="user">
     select * from mybatis.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<>();
     map.put("startIndex", 0);
     map.put("pageSize", 2);
     List<User> userList = mapper.getUserByLimit(map);
     for (User user : userList) {
       System.out.println(user);
     }
     sqlSession.close();
   }
   

7.2 RowsBounds 分页

不再使用 SQL 实现分页

1. 接口

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

2. mapper.xml

   <!--分页2-->
   <select id="getUserByRowBounds" resultMap="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.tt.dao.UserMapper.getUserByRowBounds", null, rowBounds);
   
     for (User user : userList) {
       System.out.println(user);
     }
   
     sqlSession.close();
   }
   

不推荐使用，效率低。

7.3 分页插件

Mybatis_PageHelper: Mybatis分页插件 (gitee.com)

8. 使用注解开发

8.1 面向接口编程

• 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程。
• 根本原因：解耦，可扩展，提高复用，分层开发中，上层不用管具体的实现，大家遵守共同的标准，使得开发变得容易，规范性更好。
• 在一个面向对象的系统中，系统的各个功能是由区区多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的。对系统设计人员来将就不那么重要了。
• 而各个对象之间的协作关系则成为了系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之处都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程技术按照这种思想来编程的。

关于接口的理解

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

三个面向的区别

• 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法。
• 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现
• 接口设计和非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现就是对系统整体的架构

8.2 使用注解开发

1. 注解在接口上实现

   @Select("select * from user")
   List<User> getUser();
   

2. 需要在核心配置文件绑定接口！

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

3. 测试

   @Test
   public void test() {
     SqlSession sqlSession = MyBatisUtils.getSqlSession();
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     List<User> userList = mapper.getUser();
     for (User user : userList) {
       System.out.println(user);
     }
     sqlSession.close();
   }
   

本质：反射机制实现

底层：动态代理模式！

mybatis 详细执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bCvn9LFG-1626154721532)(pic/mybatis 详细执行流程.png)]

8.3 注解实现 CRUD

我们可以在工具类创建的时候实现自动提交事务！

public static SqlSession getSqlSession() {
return sqlSessionFactory.openSession(true); // 参数设置为 true 自动提交
}

编写接口，添加注解

public interface UserMapper {

  @Select("select * from user")
  List<User> getUser();

  @Select("select * from user where id = #{id}")
  User getUserByID(@Param("id") int id/*, @Param("name") String name*/);

  @Insert("insert into user(id,name,pwd) value(#{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);
}

测试

@Test
public void test() {
  SqlSession sqlSession = MyBatisUtils.getSqlSession();
  UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  List<User> userList = mapper.getUser();
  for (User user : userList) {
    System.out.println(user);
  }
  sqlSession.close();
}
.... others

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

关于 @Param() 注解

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

#{} 和 ${} 区别

1. #是预编译的方式，$是直接拼接；

2. #不需要关注数据类型，mybatis实现自动数据类型转换；$不做数据类型转换，需要自行判断数据类型；

3. #可以防止sql注入；$不能防止sql注入；

4. 如果只有一个参数，默认情况下，#{}中可以写任意的名字；${}中只能用value来接收。

9. Lombox

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.

• java library
• plugs
• bulid tools
• with one annotation your class

使用步骤：

1. 在 IDEA 中安装 Lombok 插件

2. 在项目中导入 lombok 的 jar 包

   <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
   <dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <version>1.18.12</version>
     <scope>provided</scope>
   </dependency>
   

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

   @Data
   @AllArgsConstructor
   @NoArgsConstructor
   public class User {
     private int id;
     private String name;
     private String password;
   }
   

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass
Lombok config system
Code inspections
Refactoring actions (lombok and delombok)

说明：

@Data：无参构造、get、set、toString、hashcode、equals
@AllArgsConstructor：全参构造
@NoArgsConstructor：无参构造

10. 多对一处理

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

实体类

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

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

@Data
public class Teacher {
  private int id;
  private String name;
}

测试环境搭建

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

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

按照查询嵌套处理

<!-- 按照查询嵌套处理
    思路：
      1. 查询所有的学生
      2. 根据查询学生的 tid，寻找对应老师
  -->
<select id="getStudent" resultMap="StudentTeacher">
  select *
  from student;
</select>

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

接口

public interface StudentMapper {
  // 查询所有的学生信息，以及对应的老师的信息
  public List<Student> getStudent();

  public List<Student> getStudent2();
}

回顾 MySQL 多对一查询方式：

• 子查询 (对应按照查询嵌套处理)
• 连表查询 (对应按照结果嵌套处理)

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

按照查询嵌套处理

<!--按查询嵌套处理-->
<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" column="id"/>
</resultMap>

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

按照结果嵌套处理

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

小结

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

注意点：

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

结果映射（resultMap）

• constructor - 用于在实例化类时，注入结果到构造方法中

• idArg - ID 参数；标记出作为 ID 的结果可以帮助提高整体性能

• arg - 将被注入到构造方法的一个普通结果

• id – 一个 ID 结果；标记出作为 ID 的结果可以帮助提高整体性能

• result – 注入到字段或 JavaBean 属性的普通结果

• association – 一个复杂类型的关联；许多结果将包装成这种类型

• 嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用

• collection – 一个复杂类型的集合

• 嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用

• discriminator – 使用结果值来决定使用哪个resultMap

• case – 基于某些值的结果映射

  • 嵌套结果映射 – case 也是一个结果映射，因此具有相同的结构和元素；或者引用其它的结果映射

属性	描述
id	当前命名空间中的一个唯一标识，用于标识一个结果映射。
type	类的完全限定名, 或者一个类型别名（关于内置的类型别名，可以参考上面的表格）。
autoMapping	如果设置这个属性，MyBatis 将会为本结果映射开启或者关闭自动映射。 这个属性会覆盖全局的属性 autoMappingBehavior。默认值：未设置（unset）。

面试高频

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

12. 动态 SQL

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

利用动态 SQL 这一特性可以彻底摆脱这种痛苦。

使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 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

创建一个基础工厂

1. 导包

2. 编写配置文件

3. 编写实体类

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

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

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>

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 层面，去执行一些逻辑代码。

SQL 片段

有的时候，我们可能会将一些功能的部分抽取出来，方便复用

1. 使用 SQL 标签抽取公共的部分

   <sql id="if-title-author">
     <if test="title != null">
       title = #{title}
     </if>
     <if test="author != null">
       and author = #{author}
     </if>
   </sql>
   

2. 在需要使用的时候，使用 include 标签引用

   <select id="queryBlogIf" parameterType="map" resultType="blog">
     select *
     from mybatis.blog
     <where>
       <include refid="if-title-author"/>
     </where>
   </select>
   

注意事项：

• 最好基于单表来定义 SQL 片段。（如果SQL片段过于复杂，反而很难复用）
• 不要存在 where 标签

Foreach

查询 id 为 1 2 3 的记录

select * from user where 1=1 or (id=1 or id=2 or id=3)

抽象方法

// 查询第 1~3 号id的博客
List<Blog> queryBlogForeach(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>

测试

@Test
public void queryBlogForeach() {
  SqlSession sqlSession = MyBatisUtils.getSqlSession();

  BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
  HashMap hashMap = new HashMap();
  ArrayList<Integer> ids = new ArrayList<>();
  ids.add(1);
  ids.add(2);
  ids.add(3);
  hashMap.put("ids", ids);
  List<Blog> blogs = mapper.queryBlogForeach(hashMap);
  for (Blog blog : blogs) {
    System.out.println(blog);
  }
  sqlSession.close();
}

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

建议：

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

13. 缓存

13.1 简介

查询 : 连接数据库，耗资源
	一次查询的结果，给他暂存再一个可以直接取到的地方 --> 内存 : 缓存
当再次查询时，直接走缓存，就不用走数据库了

1. 什么是缓存[ Cache ]?
   • 存在内存的临时数据
   • 将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
2. 为什么使用缓存?
   • 减少和数据库的交互次数，减少系统开销，提高系统效率。
3. 什么样的数据能使用缓存?
   • 经常查询并且不经常改变的数据。

13.2 MyBatis 缓存

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

13.3 一级缓存

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

测试步骤：

1. 开启日志

2. 测试一个 Session 中查询两次相同记录

   @Test
   public void test() {
     SqlSession sqlSession = MyBatisUtils.getSqlSession();
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     User user = mapper.queryUserById(1);
     System.out.println(user);
     User user2 = mapper.queryUserById(1);
     System.out.println(user2);
     System.out.println(user == user2);
     sqlSession.close();
   }
   

3. 查看日志输出

   ... 
   PooledDataSource forcefully closed/removed all connections.
   PooledDataSource forcefully closed/removed all connections.
   PooledDataSource forcefully closed/removed all connections.
   PooledDataSource forcefully closed/removed all connections.
   Opening JDBC Connection
   Created connection 322836221.
   ==>  Preparing: select * from user where id = ?
   ==> Parameters: 1(Integer)
   <==    Columns: id, name, pwd
   <==        Row: 1, origami, 123456
   <==      Total: 1
   User(id=1, name=origami, pwd=123456)
   User(id=1, name=origami, pwd=123456)
   true
   Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@133e16fd]
   Returned connection 322836221 to pool.
   

缓存失效的情况

1. 查询不同的东西

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

   ==>  Preparing: select * from user where id = ?
   ==> Parameters: 1(Integer)
   <==    Columns: id, name, pwd
   <==        Row: 1, origami, 123456
   <==      Total: 1
   
   ==>  Preparing: update mybatis.user set name = ?, pwd=? where id = ?;
   ==> Parameters: 123(String), 23214(String), 2(Integer)
   <==    Updates: 1
   
   ==>  Preparing: select * from user where id = ?
   ==> Parameters: 1(Integer)
   <==    Columns: id, name, pwd
   <==        Row: 1, origami, 123456
   <==      Total: 1
   User(id=1, name=origami, pwd=123456)
   

3. 查询不同的 Mapper.xml

4. 手动清理缓存

   @Test
   public void test() {
     SqlSession sqlSession = MyBatisUtils.getSqlSession();
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     User user = mapper.queryUserById(1);
   
   	// 清理缓存
     sqlSession.clearCache();
   
     User user2 = mapper.queryUserById(1);
     System.out.println(user2);
     System.out.println(user == user2);
     sqlSession.close();
   }
   

   ==>  Preparing: select * from user where id = ?
   ==> Parameters: 1(Integer)
   <==    Columns: id, name, pwd
   <==        Row: 1, origami, 123456
   <==      Total: 1
   ==>  Preparing: select * from user where id = ?
   ==> Parameters: 1(Integer)
   <==    Columns: id, name, pwd
   <==        Row: 1, origami, 123456
   <==      Total: 1
   

小结：一级缓存是默认开启的，只在一个 SqlSession 中有效，也就是拿到连接到关闭连接这个区间段。

一级缓存就是一个 Map

13.4 二级缓存

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

步骤：

1. 开启全局缓存

   设置名	描述	有效值	默认值
   cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true | false	true

   <!--开启全局缓存-->
   <setting name="cacheEnabled" value="true"/>
   

2. 在要使用二级缓存的 Mapper 中开启

   <!--在当前 Mapper.xml 中使用二级缓存-->
   <cache/>
   

   也可也自定义一些参数

   <!--在当前 Mapper.xml 中使用二级缓存-->
   <cache eviction="FIFO"
          flushInterval="60000"
          size="512"
          readOnly="true"/>
   

3. 测试

   1. 问题：我们需要将实体类序列化，否则就会报错

      Caused by: java.io.NotSerializableException: com.tt.pojo.User

      public class User implements Serializable {
        ... 
      }
      

小结：

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

13.5 缓存原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m0bDpSB9-1626154721540)(pic/mybatis-缓存原理.png)]

13.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.2.1</version>
</dependency>

在 mapper 中指定我们的 ehcache

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="java.io.tmpdir/Tmp_EhCache"/>
    <!--
       defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk：硬盘最大缓存个数。
      eternal:对象是否永久有效，一但设置了，timeout将不起作用。
      overflowToDisk:是否保存到磁盘，当系统当机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
      diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
      memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
      clearOnFlush：内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
      FIFO，first in first out，这个是大家最熟的，先进先出。
      LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
      LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
 
</ehcache>