三、入门MyBatis

3.1、开发环境的准备

3.1.1、导入 jar包

​ 一般的我们要导入三个jar包。

myBatis-3.4.1.jar
mysql-connector-java-5.1.37-bin.jar
log4j.jar

3.1.2、导入 log4j 的配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
    <logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>

3.1.3、创建测试表

-- 创建库
CREATE DATABASE test_mybatis;
-- 使用库
USE test_mybatis;
-- 创建表
CREATE TABLE user(
id INT(11) PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(50),
pwd VARCHAR(50),
);

3.1.4、创建 javaBean

package com.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author Xiao_Lin
 * @date 2021/1/5 11:33
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
  private Integer id;
  private String username;
  private String pwd;
}

3.1.5、创建 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>
	<!--配置 mybatis 环境-->
	<environments default="mysql">
		<!--id:数据源的名称-->
		<environment id="mysql">
		<!--配置事务类型：使用 JDBC 事务（使用 Connection 的提交和回滚）-->
			<transactionManager type="JDBC"/>
			<!--数据源 dataSource：创建数据库 Connection 对象
			type: POOLED 使用数据库的连接池
			-->
                <dataSource type="POOLED">
                    <!--连接数据库的四个要素-->
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql:///javaweb?characterEncoding=utf-8&amp;useSSL=false"/>
                    <property name="username" value="root"/>
                    <property name="password" value="1101121833"/>
                </dataSource>
		</environment>
	</environments>
	<mappers>
		<!--告诉 mybatis 要执行的 sql 语句的位置,写的路径是字节码输出路径-->
		<mapper resource="com/dao/StudentDao.xml"/>
	</mappers>
</configuration>

3.1.6、编写UserDao接口

public interface UserDao {
	/*查询所有数据*/
	List<User> selectAll();
}

3.1.7、创建 Mybatis 的 sql 映射文件

<?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" >
    <!--
      用来存储SQL语句的
      namespace属性里面必须写 用来书写当前的mapper是对哪个DAO接口的实现
      他的意思是表示该配置文件的唯一标识，意味着不同的XxxMapper.xml文件的namespace的值时不同的
      -->

    <!--
      select标签表示查询操作，
     	  id属性表示在mapper配置文件中是唯一标识，一般使用方法名作为其值。
     	  paraType属性表示传入参数的类型，可省略不写，底层使用了反射，根据传入参数得到对象的类型		   标签体中编写sql语句，#{变量},#表示占位符，和jdbc的?一样。
          如果传入的参数是简单类型（包括String）,那么该类型可以任意写
          如果传入的参数是对象类型，那么变量的名称必须使用对象对应的类中的属性
		  resultType: 查询语句的返回结果数据类型，使用全限定类名
      -->

<mapper namespace="com.mapper.UserDao">
  <select id="selectAll" resultType="com.domain.User">
    select * from user
  </select>
</mapper>

3.1.8、配日志

​ mybatis.xml文件加入日志配置，可以在控制台输出执行的 sql 语句和参数。

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

3.1.9、测试

public class test {
        /*
		* mybatis 入门
		*/
	@Test
	public void testStart() throws IOException {
		//1.mybatis 主配置文件
		String config = "mybatis-config.xml";
		//2.读取配置文件
		InputStream in = Resources.getResourceAsStream(config);
		//3.创建 SqlSessionFactory 对象,目的是获取 SqlSession
		SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
		//4.获取 SqlSession,SqlSession 能执行 sql 语句
		SqlSession session = factory.openSession();
		//5.执行 SqlSession 的 selectList()
		List<User> users = session.selectList("com.dao.UserDao.selectAll");
		//6.循环输出查询结果
		studentList.forEach( u -> System.out.println(u));
		//7.关闭 SqlSession，释放资源
		session.close();
    }
}

3.2、CRUD操作

3.2.1、insert

接口中新增方法

int insertUser(User user);

xml中新增sql语句

<insert id="insertUser">
insert into user(id,username,pwd) values(#{id},#{username},#{pwd})
</insert>

新增测试方法

@Test
public void testInsert() throws IOException {
	//1.mybatis 主配置文件
	String config = "mybatis-config.xml";
	//2.读取配置文件
	InputStream in = Resources.getResourceAsStream(config);
	//3.创建 SqlSessionFactory 对象
	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
	//4.获取 SqlSession
	SqlSession session = factory.openSession();
	//5.创建保存数据的对象
	User user = new User();
	user.setId(1005);
	user.setUsername("张三");
	user.setPwd("123456");
	//6.执行插入 insert
	int rows = session.insert("com.dao.UserDao.insertUser",student);
	//7.提交事务
	session.commit();
	System.out.println("增加记录的行数:"+rows);
	//8.关闭 SqlSession
	session.close();
}

3.2.2、update

UserDao 接口中增加方法

int updateUser(User user);

UserDao.xml 增加 sql 语句

<update id="updateUser">
	update user set username = #{username} where id = #{id}
</update>

新增测试方法

@Test
public void testUpdate() throws IOException {
	//1.mybatis 主配置文件
	String config = "mybatis-config.xml";
	//2.读取配置文件
	InputStream in = Resources.getResourceAsStream(config);
	//3.创建 SqlSessionFactory 对象
	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
	//4.获取 SqlSession
	SqlSession session = factory.openSession();
	//5.创建保存数据的对象
	User user = new User();
	user.setId(1005);//要修改的 id
	user.setUsername("李四"); //要修改的年龄值
	//6.执行更新 update
	int rows = session.update("com.dao.UserDao.updateUser",user);
	//7.提交事务
	session.commit();
	System.out.println("修改记录的行数:"+rows);
	//8.关闭 SqlSession
	session.close();
}

3.2.3、delete

UsertDao 接口中增加方法

int deleteUser(int id);

UserDao.xml 增加 sql 语句

<delete id="deleteUser">
	delete from user where id=#{id}
</delete>

增加测试方法

@Test
public void testUpdate() throws IOException {
	//1.mybatis 主配置文件
	String config = "mybatis-config.xml";
	//2.读取配置文件
	InputStream in = Resources.getResourceAsStream(config);
	//3.创建 SqlSessionFactory 对象
	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
	//4.获取 SqlSession
	SqlSession session = factory.openSession();
	//5.删除的 id
	int id = 1001;
	//6.执行删除 delete
	int rows = session.delete("com.dao.UserDao.deleteStudent",id);
	//7.提交事务
	session.commit();
	System.out.println("修改记录的行数:"+rows);
	//8.关闭 SqlSession
	session.close();
}

3.2.2、完成两个绑定

1. Mapper 接口与 Mapper 映射文件的绑定在 Mppper 映射文件中的<mapper>标签中的 namespace 中必须指定 Mapper 接口的全类名，包名加类名。
2. Mapper 映射文件中的增删改查标签的 id 必须指定成 Mapper 接口中的方法，必须相同否则无法通过代理实现绑定。

3.3、Mybatis对象分析

3.3.1、Resources类

​ Resources 类，顾名思义就是资源，用于读取资源文件。其有很多方法通过加载并解析资源文件，返

回不同类型的 IO 流对象。

3.3.2、SqlSessionFactoryBuilder 类

​ SqlSessionFactory 的 创 建 ， 需 要 使 用 SqlSessionFactoryBuilder 对 象 的 build() 方 法 。 由 于
SqlSessionFactoryBuilder 对象在创建完工厂对象后，就完成了其历史使命，即可被销毁。所以，一般会将
该 SqlSessionFactoryBuilder 对象创建为一个方法内的局部对象，方法结束，对象销毁。

3.3.3、SqlSessionFactory类

​ SqlSessionFactory 接口对象是一个重量级对象（系统开销大的对象），是线程安全的，所以一个应用

只需要一个该对象即可。创建 SqlSession 需要使用 SqlSessionFactory 接口的的 openSession()方法。他有几个重载方法：

1. openSession(true)：创建一个有自动提交功能的 SqlSession
2. openSession(false)：创建一个非自动提交功能的 SqlSession，需手动提交
3. openSession()：同 openSession(false)

3.3.4、SqlSession 接口

​ SqlSession 接口对象用于执行持久化操作。一个 SqlSession 对应着一次数据库会话，一次会话以

SqlSession 对象的创建开始，以 SqlSession 对象的关闭结束。

​ SqlSession 接口对象是线程不安全的，所以每次数据库会话结束前，需要马上调用其 close()方法，将

其关闭。再次需要会话，再次创建。 SqlSession 在方法内部创建，使用完毕后关闭。

3.4、抽取工具类

public class MyBatisUtil {
	//定义 SqlSessionFactory
	private static SqlSessionFactory factory = null;
	static {
	//使用 静态块 创建一次 SqlSessionFactory
	try{
		String config = "mybatis-config.xml";
		//读取配置文件
		InputStream in = Resources.getResourceAsStream(config);
		//创建 SqlSessionFactory 对象
		factory = new SqlSessionFactoryBuilder().build(in);
	}catch (Exception e){
		factory = null;
	e.printStackTrace();
	}
}
	/* 获取 SqlSession 对象 */
	public static SqlSession getSqlSession(){
		SqlSession session = null;
		if( factory != null){
			session = factory.openSession();
		}
		return session;
	}
}

四、MyBatis 全局配置文件

4.1、MyBatis 全局配置文件简介

​ The MyBatis configuration contains settings and properties that have a dramatic effecton how MyBatis behaves.

​ MyBatis 的配置文件包含了影响 MyBatis 行为甚深的设置（settings ）和属性（properties）信息。

4.2、文件结构

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

4.2.1、properties 属性

​ properties属性是配置数据源相关属性，可外部配置且可动态替换的，既可以在典型的 Java 属性文件中配置，亦可通过 properties 元素的子元素来配置

<properties>
	<!--驱动名（MySQL5 和MySQL8 不同）-->
	<property name="driver" value="com.mysql.jdbc.Driver" />
	<!--url名字（MySQL5 和MySQL8 不同）-->
	<property name="url"
		<value="jdbc:mysql://localhost:3306/javaweb" />
	<property name="username" value="root" />
	<property name="password" value="123456" />
</properties>

​ 然而 properties 的作用并不单单是这样，你可以创建一个资源文件，名为db.properties 的文件,将四个连接字符串的数据在资源文件中通过键值对(key=value)的方式放置，不要任何符号，一条占一行

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/javaweb
jdbc.username=root
jdbc.password=123456

​ 引入方式是这样

<!--

properties: 引入外部的属性文件
resource: 从类路径下引入属性文件
url: 引入网络路径或者是磁盘路径下的属性文件

-->
<properties resource="db.properties" ></properties>

在 environment 元素的 dataSource 元素中为其动态设置

<environments default="mysql">
	<environment id="mysql">
	<transactionManager type="JDBC" />
	<dataSource type="POOLED">
		<property name="driver" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</dataSource>
</environment>

4.2.2、settings 属性

​ 这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。一般设置数据库的懒加载和缓存之类是否开启

<settings>
	<setting name="cacheEnabled" value="true"/>
	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="multipleResultSetsEnabled" value="true"/>
	<setting name="useColumnLabel" value="true"/>
	<setting name="useGeneratedKeys" value="false"/>
	<setting name="autoMappingBehavior" value="PARTIAL"/>
	<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
	<setting name="defaultExecutorType" value="SIMPLE"/>
	<setting name="defaultStatementTimeout" value="25"/>
	<setting name="defaultFetchSize" value="100"/>
	<setting name="safeRowBoundsEnabled" value="false"/>
	<setting name="mapUnderscoreToCamelCase" value="false"/>
	<setting name="localCacheScope" value="SESSION"/>
	<setting name="jdbcTypeForNull" value="OTHER"/>
	<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

4.2.3、typeAliases 别名

​ 类型别名是为 Java 类型设置一个短的名字，可以方便我们引用某个类，引用的时候不需要再写全路径名字

<typeAliases>
	<typeAlias type="com.domain.User" alias="user"/>
</typeAliases>

​ 更简单的写法：类很多的情况下，可以批量设置别名这个包下的每一个类创建一个默认的别名，就是简
单类名小写

<typeAliases>
	<package name="com.domain.User"/>
</typeAliases>

​ MyBatis 默认已经取好的别名，不需要我们人为去配置

4.2.4、typeHandlers 类型处理器

​ 无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型，MyBatis 中默认提供的类型处理器

注意

1. 日期和时间的处理，JDK1.8 以前一直是个头疼的问题。我们通常使用 JSR310 规范领导者 Stephen Colebourne 创建的 Joda-Time 来操作。1.8 已经实现全部的 JSR310 规范了

2. 日期时间处理上，我们可以使用 MyBatis 基于 JSR310（Date and Time API）编写的各种日期时间类型处理器。

3. MyBatis3.4 以前的版本需要我们手动注册这些处理器，以后的版本都是自动注册的,如需注册，需要下载 mybatistypehandlers-jsr310,并通过如下方式注册

4.2.5、plugins 插件机制

​ 插件是 MyBatis 提供的一个非常强大的机制，我们可以通过插件来修改 MyBatis 的一些核心行为。插件通过动态代理机制，可以介入四大对象的任何一个方法的执行，四大对象如下：

1. Executor (update, query, flushStatements, commit, rollback, getTransaction, close,
   isClosed)

2. ParameterHandler (getParameterObject, setParameters)

3. ResultSetHandler (handleResultSets, handleOutputParameters)

4. StatementHandler (prepare, parameterize, batch, update, query)

4.2.6、 environments 环境配置

​ MyBatis 可以配置多种环境，比如开发、测试和生产环境需要有不同的配置， 每种环境使用一个 environment 标签进行配置并指定唯一标识符，可以通过environments 标签中的default 属性指定一个环境的标识符来快速的切换环境

• ​ environment：指定具体环境
• ​ id：指定当前环境的唯一标识
• ​ transactionManager、dataSource 都必须有

<environments default="mysql">
	<environment id="mysql">
		<transactionManager type="JDBC" />
		<dataSource type="POOLED">
			<property name="driver" value="${jdbc.driver}" />
			<property name="url" value="${jdbc.url}" />
			<property name="username" value="${jdbc.username}" />
			<property name="password" value="${jdbc.password}" />
		</dataSource>
	</environment>
	<environment id="oracle">
		<transactionManager type="JDBC"/>
		<dataSource type="POOLED">
			<property name="driver" value="${orcl.driver}" />
			<property name="url" value="${orcl.url}" />
			<property name="username" value="${orcl.username}" />
			<property name="password" value="${orcl.password}" />
		</dataSource>
	</environment>
   </environments>

4.2.6.1、transactionManager

他有三种可选的类型：JDBC ,MANAGED ,自定义

1. JDBC：使用了 JDBC 的提交和回滚设置，依赖于从数据源得到的连接来管理事务范围，JdbcTransactionFactory。

2. MANAGED：不提交或回滚一个连接、让容器来管理事务的整个生命周期，比如JEE应用服务器上下文，ManagedTransactionFactory。

3. 自定义：实现 TransactionFactory 接口，type=全类名/别名。

4.2.6.2、dataSource

他有四种可选的类型： UNPOOLED , POOLED . JNDI , 自定义

1. UNPOOLED：不使用连接池， UnpooledDataSourceFactory。

2. POOLED：使用连接池， PooledDataSourceFactory。

3. JNDI： 在 EJB 或应用服务器这类容器中查找指定的数据源。

4. 自定义：实现 DataSourceFactory 接口，定义数据源的获取方式。

4.2.6.3、总结

​ 际开发中我们使用 Spring 管理数据源，并进行事务控制的配置来覆盖上述配置

4.2.7、databaseIdProvider 数据库厂商标识

MyBatis 可以根据不同的数据库厂商执行不同的语句

<databaseIdProvider type="DB_VENDOR">
	<property name="MySQL" value="mysql"/>
	<property name="Oracle" value="oracle"/>
</databaseIdProvider>

Type： DB_VENDOR

​ 使用 MyBatis 提供的 VendorDatabaseIdProvider 解析数据库厂商标识。也可以实现 DatabaseIdProvider 接口来自定义.会通过 DatabaseMetaData#getDatabaseProductName() 返回的字符串进行设置。由于通常情况下这个字符串都非常长而且相同产品的不同版本会返回不同的值，所以最好通过设置属性别名来使其变短.

​ Property-name：数据库厂商标识

​ Property-value：为标识起一个别名，方便 SQL 语句使用 databaseId 属性引用

​ 配置了 databaseIdProvider 后，在 SQL 映射文件中的增删改查标签中使用 databaseId来指定数据库标识的别名

<select id="getEmployeeById" resultType="com.atguigu.mybatis.beans.Employee" databaseId="mysql">
	select * from tbl_employee where id = #{id}
</select>

MyBatis 匹配规则如下:

1. 如果没有配置 databaseIdProvider 标签，那么 databaseId=null

2. 如果配置了 databaseIdProvider 标签，使用标签配置的 name 去匹配数据库信息，匹配上设置 databaseId=配置指定的值，否则依旧为 null

3. 如果 databaseId 不为 null，他只会找到配置 databaseId 的 sql 语句

4. MyBatis 会加载不带 databaseId 属性和带有匹配当前数据库 databaseId 属性的
   所有语句。如果同时找到带有 databaseId 和不带 databaseId 的相同语句，则后者
   会被舍弃。

4.2.8、mappers 映射器

用来在 mybatis 初始化的时候，告诉 mybatis 需要引入哪些 Mapper 映射文件

4.2.8.1、mapper 逐个注册 SQL 映射文件

• resource : 引入类路径下的文件

• url : 引入网络路径或者是磁盘路径下的文件

• class : 引入 Mapper 接口.

  1. 有 SQL 映射文件 , 要求 Mapper 接口与 SQL 映射文件同名同位置
  2. 没有 SQL 映射文件 , 使用注解在接口的方法上写 SQL 语句.

<mappers>
	<mapper resource="EmployeeMapper.xml" />
	<mapper class="com.dao.EmployeeMapper"/>
	<package name="com.dao.mybatis.dao"/>
</mappers>

4.2.8.2、使用批量注册

这种方式要求 SQL 映射文件名必须和接口名相同并且在同一目录下

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