Mybatis是什么

Mybatis是国内最受欢迎，使用人数最多（主要原因是阿里用）的ORM（对象关系映射）框架，用来操作数据库的一个半自动（自动生成sql或者自己手写sql）框架。

官方介绍如下：
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

本教程基于Mybatis3.5.3

参考资料如下：

快速入门

安装

要使用 MyBatis， 只需将 mybatis-x.x.x.jar 文件置于 classpath 中即可。
如果使用 Maven 来构建项目，则需将下面的 dependency 代码置于 pom.xml 文件中：

  1. <dependency>
  2.   <groupId>org.mybatis</groupId>
  3.   <artifactId>mybatis</artifactId>
  4.   <version>x.x.x</version>
  5. </dependency>

最新版依赖：https://mvnrepository.com/artifact/org.mybatis/mybatis

基本概念讲解

jdbc连接关系型数据库，一个连接叫做会话（SqlSession）,然后创建会话（SqlSession）由工厂类设计模式实现（SqlSessionFactory），一个SqlSession管理多个映射器（Mapper），映射器可以简单理解为JavaBean对象和Sql语句的对应关系。我们主要使用Mapper实现各种sql语句。

构建SqlSessionFactory

xml方式构建（不推荐）

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先定制的 Configuration 的实例构建出 SqlSessionFactory 的实例。

从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。 但是也可以使用任意的输入流（InputStream）实例，包括字符串形式的文件路径或者 file:// 的 URL 形式的文件路径来配置。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，可使从 classpath 或其他位置加载资源文件更加容易。

XML 配置文件中包含了对 MyBatis 系统的核心设置，包含获取数据库连接实例的数据源（DataSource）和决定事务作用域和控制方式的事务管理器（TransactionManager）。 XML 配置文件的详细内容后面再探讨，这里先给出一个简单的示例：

  1. //java代码
  2. String resource = "org/mybatis/example/mybatis-config.xml";
  3. InputStream inputStream = Resources.getResourceAsStream(resource);
  4. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  6. //xml配置
  7. <?xml version="1.0" encoding="UTF-8" ?>
  8. <!DOCTYPE configuration
  9.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  10.   "http://mybatis.org/dtd/mybatis-3-config.dtd">
  11. <configuration>
  12.   <environments default="development">
  13.     <environment id="development">
  14.       <transactionManager type="JDBC"/>
  15.       <dataSource type="POOLED">
  16.         <property name="driver" value="${driver}"/>
  17.         <property name="url" value="${url}"/>
  18.         <property name="username" value="${username}"/>
  19.         <property name="password" value="${password}"/>
  20.       </dataSource>
  21.     </environment>
  22.   </environments>
  23.   <mappers>
  24.     <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  25.   </mappers>
  26. </configuration>

Java代码构建

  1. String driver = "com.mysql.cj.jdbc.Driver";
  2. String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true&serverTimezone=Asia/Shanghai";
  3. String username="root";
  4. String password="root";
  5. //创建使用缓存池的数据源
  6. /*
  7. * <dataSource type="POOLED">
  8.   <property name="driver" value="${jdbc.driverClassName}"/>
  9.   <property name="url" value="${jdbc.url}"/>
  10.   <property name="username" value="${jdbc.username}"/>
  11.   <property name="password" value="${jdbc.password}"/>
  12. </dataSource>
  13. */
  14. DataSource dataSource =new PooledDataSource(driver,url,username,password);
  16. //创建事务
  17. /*
  18. * <transactionManager type="JDBC" />
  19. */
  20. TransactionFactory transactionFactory =  new JdbcTransactionFactory();
  22. Environment environment = new Environment("development", transactionFactory, dataSource);
  24. Configuration configuration = new Configuration(environment);
  25. //加入资源
  26. /*
  27. * <mapper resource="ssm/BlogMapper.xml"/>
  28. */
  29. configuration.addMapper(UserMapper.class);
  30. SqlSessionFactory sqlSessionFactory = new  SqlSessionFactoryBuilder().build(configuration);
  31. System.out.println(sqlSessionFactory);
  33. SqlSession session =  sqlSessionFactory.openSession();
  34. User user = new User();
  35. user.setId(6);
  36. session.insert("add", user);
  37. session.commit();
  38. session.close();

从 SqlSessionFactory 中获取 SqlSession

工厂设计模式获取SqlSession

  1. try (SqlSession session = sqlSessionFactory.openSession()) {
  2.   BlogMapper mapper = session.getMapper(BlogMapper.class);
  3.   Blog blog = mapper.selectBlog(101);
  4. }

探究一下Mapper（映射的sql）

Mapper是Mybatis的精髓，本质就是用一种方式自动的构建SQL语句，然后调用jdbc执行该sql语句，一个sql语句既可以通过 XML 定义，也可以通过注解定义。现在已经不推荐使用xml方式了，因为它在阅读上确实是反人类的设计。

另外可以通过JavaBean或者注解把sql语句标注，运行时由一段java代码拼接组装成新的sql，用于执行完成业务需求。本质上就是这么简单，现在我们熟悉一下Mybatis的基本使用方式。

xml方式简单示例

  1.  //xml mapper
  2. <?xml version="1.0" encoding="UTF-8" ?>
  3. <!DOCTYPE mapper
  4.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  5.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="org.mybatis.example.BlogMapper">
  7.   <select id="selectBlog" resultType="Blog">
  8.     select * from Blog where id = #{id}
  9.   </select>
  10. </mapper>
  12. //java代码
  13. package org.mybatis.example;
  14. public interface BlogMapper {
  15.   Blog selectBlog(int id);
  16. }
  18. //执行查询操作
  19. BlogMapper mapper = session.getMapper(BlogMapper.class);
  20. Blog blog = mapper.selectBlog(101);
  • namespace 命名空间： 表示一个Mapper.class 的java类和一个Mapper.xml的xml文件对应关系。表示一个xml文件对应一个java类，优势是代码和sql分离，方便维护，劣势是分离过多了带来的开发成本较高。推荐安装一些mybatis插件来自动生成xml代码或完成xml和java类之间的跳转工作，后边我们会慢慢讲，先简单了解。毕竟学习技术和企业级开发是不一样的。
  • java类的方法名和xml的select元素id熟悉对应，很好理解，表示把xml里的sql绑定给java类的指定方法。
  • 吐槽：mybatis的最大败笔就是把xml这种反人类的文件，当作sql的模板，如果它自己实现一种模板可能要好的多，以至于Java5以后大家尽量使用注解的方式写sql语句，而不是写在xml中，下边用注解的方式实现上述例子：
  1. //java代码
  2. package org.mybatis.example;
  3. public interface BlogMapper {
  4.   @Select("SELECT * FROM blog WHERE id = #{id}")
  5.   Blog selectBlog(int id);
  6. }
  8. //执行查询操作
  9. BlogMapper mapper = session.getMapper(BlogMapper.class);
  10. Blog blog = mapper.selectBlog(101);

好，先简单了解mapper映射器，后边会详细说明。

作用域（Scope）和生命周期

理解我们目前已经讨论过的不同作用域和生命周期类是至关重要的，因为错误的使用会导致非常严重的并发问题。

提示 对象生命周期和依赖注入框架
依赖注入框架可以创建线程安全的、基于事务的 SqlSession 和映射器，并将它们直接注入到你的 bean 中，因此可以直接忽略它们的生命周期。 如果对如何通过依赖注入框架来使用 MyBatis 感兴趣，可以研究一下 MyBatis-Spring 或 MyBatis-Guice 两个子项目。

SqlSessionFactoryBuilder

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

SqlSessionFactory

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

SqlSession

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

映射器实例

映射器是一些由你创建的、绑定你映射的语句的接口。映射器接口的实例是从 SqlSession 中获得的。因此从技术层面讲，任何映射器实例的最大作用域是和请求它们的 SqlSession 相同的。尽管如此，映射器实例的最佳作用域是方法作用域。 也就是说，映射器实例应该在调用它们的方法中被请求，用过之后即可丢弃。 并不需要显式地关闭映射器实例，尽管在整个请求作用域保持映射器实例也不会有什么问题，但是你很快会发现，像 SqlSession 一样，在这个作用域上管理太多的资源的话会难于控制。 为了避免这种复杂性，最好把映射器放在方法作用域内。下面的示例就展示了这个实践：
try (SqlSession session = sqlSessionFactory.openSession()) {
BlogMapper mapper = session.getMapper(BlogMapper.class);
// 你的应用逻辑代码
}