[Java知识库]MyBatis框架快速入门

内容列表：
快速开始一个MyBatis
基本CURD的操作
MyBatis内部对象分析
使用Dao对象

入门案例

搭建MyBatis开发环境，实现第一个案例。

使用MyBatis准备

下载MyBatis

https://github.com/mybatis/mybatis-3/releases

搭建MyBatis开发环境

创建mysql数据库和表

数据库名 ssm ；表名 student 。

创建数据库

CREATE DATABASE `ssm`CHARACTER SET utf8 COLLATE utf8_general_ci; 

创建数据表

CREATE TABLE `student` (
 `id` int(11) NOT NULL ,
 `name` varchar(255) DEFAULT NULL,
 `email` varchar(255) DEFAULT NULL,
 `age` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

手动插入一条数据，方便后续的查询操作

创建maven工程

创建一个空项目

检查设置环境

创建模块

设置JDK和语言级别

删除默认创建的App类文件

修改pom.xml文件

<?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">
  <modelVersion>4.0.0</modelVersion>
  <!--当前项目的坐标-->
  <groupId>com.lln</groupId>
  <artifactId>learnMybatis</artifactId>
  <version>1.0</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <!--依赖的列表-->
  <dependencies>
    <!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>

    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>

    <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <!--资源插件 处理src/main/java目录中的xml文件-->
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>

    <!--指定编译插件，可以不用写，因为前面指定了JDK版本-->
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>

  </build>
</project>

创建Student实体类

package com.lln.vo;

public class Student {
    //属性名和数据库表的列名保持一致
    private Integer id;
    private String name;
    private String email;
    private Integer age;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "学生实体的信息:{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }
}

编写 Dao 接口 StudentDao 类

package com.lln.dao;

import com.lln.vo.Student;

public interface StudentDao {

    //查询一个学生
    Student selectStudentById(Integer id);

}

编写 Dao 接口 Mapper 映射文件

创建mapper文件，写sql语句，文件名：StudentDao.xml
目前与StudentDao接口类在同一目录下

<?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 namespace="com.lln.dao.StudentDao">
    <!--
    <select>: 表示查询数据， 标签中必须是 select 语句
    id: 要执行的sql 语句的唯一标识，自定义名称，推荐使用 dao 接口中方法名称
    resultType: 告诉mybatis，执行sql语句后，把数据赋值给哪个类型的java对象，即查询语句的返回结果数据类型，使用全限定类名
    -->
    <select id="selectStudentById" resultType="com.lln.vo.Student">
        <!--要执行的 sql 语句-->
        select id,name,email,age
        from student
        where id=1
        <!--结尾不写分号-->
    </select>
</mapper>

<!--
    1.约束文件
        约束文件作用：定义和限制当前文件中可以使用的标签和属性，以及标签出现的顺序。
    2.mapper是根标签
        namespace：命名空间，必须有值，不能为空，唯一值。
                   推荐使用Dao接口的全限定名称。
             作用：参与识别sql语句。
    3.在mapper里面可以写<insert>,<update>,<delete>,<select>等标签
        <insert>里面是insert语句，表示执行的是insert操作
-->

创建 MyBatis 主配置文件

项目 src/main 下创建 resources 资源目录，设置 resources 目录名为 resources

在resources目录下创建主配置文件（xml文件），名称为 mybatis.xml

<?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">
                <!--连接数据库的四个要素-->
                <!--driver：驱动的内容-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?useUnicode=true&amp;characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--
    指定其他mapper文件的位置
    目的是找到其他文件中的sql语句
    -->
    <mappers>
        <!--
        使用mapper的resource属性指定mapper文件的路径
        告诉 mybatis 要执行的 sql 语句的位置
        使用注意：
        resources="mapper文件的路径，使用/分割路径"
        一个mapper resource 指定一个 mapper文件
        -->
        <mapper resource="com/lln/dao/StudentDao.xml"/>
    </mappers>
</configuration>

HTML字符实体

HTML中的预留字符必须被替换为字符实体。

创建测试类 MybatisTest

package com.lln;

import com.lln.vo.Student;
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 org.junit.Test;

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

public class MybatisTest {
    //测试mybatis执行sql查询语句
    @Test
    public void testSelectStudentById() throws IOException {
        //调用mybatis某个对象的方法，执行mapper文件中的sql语句
        //mybatis核心类：SqlSessionFactory
        //1.定义mybatis 主配置文件的位置，从类路径开始的相对路径
        String config = "mybatis.xml";
        //2.读取主配置文件，使用mybatis框架中的Resources类
        InputStream inputStream = Resources.getResourceAsStream(config);
        //3.使用SqlSessionFactoryBuilder类创建 SqlSessionFactory 对象,目的是获取 SqlSession
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //4.获取 SqlSession 对象，SqlSession 能执行 sql 语句
        SqlSession session = factory.openSession();
        //5.指定要执行的sql语句中的id
        //sql的id = namespace+"."+ <select>标签中的id属性值
        //String sqlId = "com.lln.dao.StudentDao"+"."+"selectStudentById";
        String sqlId = "com.lln.dao.StudentDao.selectStudentById";
        //6.通过SqlSession的方法，执行sql语句
        Student student = session.selectOne(sqlId);
        //7.控制台输出
        System.out.println("使用mybatis根据id查询一个学生："+student);
        //8.关闭 SqlSession，释放资源
        session.close();
    }
}

输出结果：

使用mybatis根据id查询一个学生：学生实体的信息:{id=1, name='张三', email='123@163.com', age=18}

初次使用占位符

修改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">
<!--
 namespace：必须有值，自定义的唯一字符串
 推荐使用：dao 接口的全限定名称
-->
<mapper namespace="com.lln.dao.StudentDao">
    <!--
    <select>: 表示查询数据， 标签中必须是 select 语句
    id: 要执行的sql 语句的唯一标识，自定义名称，推荐使用 dao 接口中方法名称
    resultType: 告诉mybatis，执行sql语句后，把数据赋值给哪个类型的java对象，即查询语句的返回结果数据类型，使用全限定类名
    -->
    <select id="selectStudentById" resultType="com.lln.vo.Student">
        <!--要执行的 sql 语句-->
        select id,name,email,age
        from student
--         where id=1
        where id=#{studentId}
        <!--结尾不写分号-->
        <!--#{studentId} 占位符，表示从java程序中传过来的数据-->
    </select>
</mapper>

<!--
    1.约束文件
        约束文件作用：定义和限制当前文件中可以使用的标签和属性，以及标签出现的顺序。
    2.mapper是根标签
        namespace：命名空间，必须有值，不能为空，唯一值。
                   推荐使用Dao接口的全限定名称。
             作用：参与识别sql语句。
    3.在mapper里面可以写<insert>,<update>,<delete>,<select>等标签
        <insert>里面是insert语句，表示执行的是insert操作
-->

修改测试语句

package com.lln;


import com.lln.vo.Student;
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 org.junit.Test;

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


public class MybatisTest {
    //测试mybatis执行sql查询语句
    @Test
    public void testSelectStudentById() throws IOException {
        //调用mybatis某个对象的方法，执行mapper文件中的sql语句
        //mybatis核心类：SqlSessionFactory
        //1.定义mybatis 主配置文件的位置，从类路径开始的相对路径
        String config = "mybatis.xml";
        //2.读取主配置文件，使用mybatis框架中的Resources类
        InputStream inputStream = Resources.getResourceAsStream(config);
        //3.使用SqlSessionFactoryBuilder类创建 SqlSessionFactory 对象,目的是获取 SqlSession
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //4.获取 SqlSession 对象，SqlSession 能执行 sql 语句
        SqlSession session = factory.openSession();
        //5.指定要执行的sql语句中的id
        //sql的id = namespace+"."+ <select>标签中的id属性值
        //String sqlId = "com.lln.dao.StudentDao"+"."+"selectStudentById";
        String sqlId = "com.lln.dao.StudentDao.selectStudentById";
        //6.通过SqlSession的方法，执行sql语句
        //Student student = session.selectOne(sqlId);
        Student student = session.selectOne(sqlId,1);

        //7.控制台输出
        System.out.println("使用mybatis根据id查询一个学生："+student);
        //8.关闭 SqlSession，释放资源
        session.close();
    }
}

配置日志功能

mybatis.xml主配置文件中添加setting设置

<?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>
    <!--设置日志-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>
    <!--配置 mybatis 环境-->
    <environments default="mysql">
        <!--id:数据源的名称-->
        <environment id="mysql">
            <!--配置事务类型：使用 JDBC 事务（使用 Connection 的提交和回滚）-->
            <transactionManager type="JDBC"/>
            <!--数据源 dataSource：创建数据库 Connection 对象
            type: POOLED 使用数据库的连接池-->
            <dataSource type="POOLED">
                <!--连接数据库的四个要素-->
                <!--driver：驱动的内容-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?useUnicode=true&amp;characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--
    指定其他mapper文件的位置
    目的是找到其他文件中的sql语句
    -->
    <mappers>
        <!--
        使用mapper的resource属性指定mapper文件的路径
        告诉 mybatis 要执行的 sql 语句的位置
        使用注意：
        resources="mapper文件的路径，使用/分割路径"
        一个mapper resource 指定一个 mapper文件
        -->
        <mapper resource="com/lln/dao/StudentDao.xml"/>
    </mappers>
</configuration>

再次执行查询测试，输出结果：

Logging initialized using 'class org.apache.ibatis.logging.stdout.StdOutImpl' adapter.
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 1131316523.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@436e852b]
==>  Preparing: select id,name,email,age from student where id=? 
==> Parameters: 1(Integer)
<==    Columns: id, name, email, age
<==        Row: 1, 张三, 123@163.com, 18
<==      Total: 1
使用mybatis根据id查询一个学生：学生实体的信息:{id=1, name='张三', email='123@163.com', age=18}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@436e852b]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@436e852b]
Returned connection 1131316523 to pool.

Process finished with exit code 0

提交事务

1.自动提交：当sql语句执行完毕后，自动提交事务，数据库更新操作直接保存到数据库。

2.手动提交：在需要提交事务的位置，执行方法，提交事务或者回滚事务。

3.mybatis默认执行sql语句是手动提交事务，在insert,update,delete后需要提交事务

添加数据

接口类添加接口：

package com.lln.dao;

import com.lln.vo.Student;

public interface StudentDao {

    //查询一个学生
    Student selectStudentById(Integer id);

    //添加学生
    //返回值int：影响行数
    int insertStudent(Student student);

}

添加sql语句（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 namespace="com.lln.dao.StudentDao">
    <!--
    <select>: 表示查询数据， 标签中必须是 select 语句
    id: 要执行的sql 语句的唯一标识，自定义名称，推荐使用 dao 接口中方法名称
    resultType: 告诉mybatis，执行sql语句后，把数据赋值给哪个类型的java对象，即查询语句的返回结果数据类型，使用全限定类名
    -->
    <select id="selectStudentById" resultType="com.lln.vo.Student">
        <!--要执行的 sql 语句-->
        select id,name,email,age
        from student
        where id=#{studentId}
        <!--结尾不写分号-->
    </select>


    <!--添加操作-->
    <insert id="insertStudent">
        insert into student values(2,"李四","456@163.com",26)
    </insert>


</mapper>

<!--
    1.约束文件
        约束文件作用：定义和限制当前文件中可以使用的标签和属性，以及标签出现的顺序。
    2.mapper是根标签
        namespace：命名空间，必须有值，不能为空，唯一值。
                   推荐使用Dao接口的全限定名称。
             作用：参与识别sql语句。
    3.在mapper里面可以写<insert>,<update>,<delete>,<select>等标签
        <insert>里面是insert语句，表示执行的是insert操作
-->

测试类：

package com.lln;


import com.lln.vo.Student;
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 org.junit.Test;

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


public class MybatisTest {
    //测试mybatis执行sql查询语句
    @Test
    public void testSelectStudentById() throws IOException {
        //调用mybatis某个对象的方法，执行mapper文件中的sql语句
        //mybatis核心类：SqlSessionFactory
        //1.定义mybatis 主配置文件的位置，从类路径开始的相对路径
        String config = "mybatis.xml";
        //2.读取主配置文件，使用mybatis框架中的Resources类
        InputStream inputStream = Resources.getResourceAsStream(config);
        //3.使用SqlSessionFactoryBuilder类创建 SqlSessionFactory 对象,目的是获取 SqlSession
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //4.获取 SqlSession 对象，SqlSession 能执行 sql 语句
        SqlSession session = factory.openSession();
        //5.指定要执行的sql语句中的id
        //sql的id = namespace+"."+ <select>标签中的id属性值
        //String sqlId = "com.lln.dao.StudentDao"+"."+"selectStudentById";
        String sqlId = "com.lln.dao.StudentDao.selectStudentById";
        //6.通过SqlSession的方法，执行sql语句
        //Student student = session.selectOne(sqlId);
        Student student = session.selectOne(sqlId,1);

        //7.控制台输出
        System.out.println("使用mybatis根据id查询一个学生："+student);
        //8.关闭 SqlSession，释放资源
        session.close();
    }

    //测试mybatis执行sql添加语句
    @Test
    public void testInsertStudent() throws IOException {
        //调用mybatis某个对象的方法，执行mapper文件中的sql语句
        //mybatis核心类：SqlSessionFactory
        //1.定义mybatis 主配置文件的位置，从类路径开始的相对路径
        String config = "mybatis.xml";
        //2.读取主配置文件，使用mybatis框架中的Resources类
        InputStream inputStream = Resources.getResourceAsStream(config);
        //3.使用SqlSessionFactoryBuilder类创建 SqlSessionFactory 对象,目的是获取 SqlSession
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //4.获取 SqlSession 对象，SqlSession 能执行 sql 语句
        SqlSession session = factory.openSession();
        //5.指定要执行的sql语句中的id
        //sql的id = namespace+"."+ <select>标签中的id属性值
        String sqlId = "com.lln.dao.StudentDao.insertStudent";
        //6.通过SqlSession的方法，执行sql语句
        int rows = session.insert(sqlId);
        //mybatis默认执行sql语句是手动提交事务
        //在insert,update,delete后需要提交事务
        session.commit();

        //7.控制台输出
        System.out.println("使用mybatis添加一个学生，影响行数rows="+rows);
        //8.关闭 SqlSession，释放资源
        session.close();
    }
}

更新数据库查看添加结果：添加成功！

使用占位符添加数据

修改sql语句（mapper映射文件：StudentDao.xml）

<?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 namespace="com.lln.dao.StudentDao">
    <!--
    <select>: 表示查询数据， 标签中必须是 select 语句
    id: 要执行的sql 语句的唯一标识，自定义名称，推荐使用 dao 接口中方法名称
    resultType: 告诉mybatis，执行sql语句后，把数据赋值给哪个类型的java对象，即查询语句的返回结果数据类型，使用全限定类名
    -->
    <select id="selectStudentById" resultType="com.lln.vo.Student">
        <!--要执行的 sql 语句-->
        select id,name,email,age
        from student
        where id=#{studentId}
        <!--结尾不写分号-->
    </select>


    <!--添加操作-->
    <!--
        如果传给mybatis的是一个对象，使用#{属性名}获取此属性的值。
        属性名放到#{}占位符的位置，mybatis执行此属性的getxxx()方法。
    -->
    <insert id="insertStudent">
        insert into student values(#{id},#{name},#{email},#{age})
    </insert>


</mapper>

<!--
    1.约束文件
        约束文件作用：定义和限制当前文件中可以使用的标签和属性，以及标签出现的顺序。
    2.mapper是根标签
        namespace：命名空间，必须有值，不能为空，唯一值。
                   推荐使用Dao接口的全限定名称。
             作用：参与识别sql语句。
    3.在mapper里面可以写<insert>,<update>,<delete>,<select>等标签
        <insert>里面是insert语句，表示执行的是insert操作
-->

修改测试类

package com.lln;


import com.lln.vo.Student;
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 org.junit.Test;

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


public class MybatisTest {
    //测试mybatis执行sql查询语句
    @Test
    public void testSelectStudentById() throws IOException {
        //调用mybatis某个对象的方法，执行mapper文件中的sql语句
        //mybatis核心类：SqlSessionFactory
        //1.定义mybatis 主配置文件的位置，从类路径开始的相对路径
        String config = "mybatis.xml";
        //2.读取主配置文件，使用mybatis框架中的Resources类
        InputStream inputStream = Resources.getResourceAsStream(config);
        //3.使用SqlSessionFactoryBuilder类创建 SqlSessionFactory 对象,目的是获取 SqlSession
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //4.获取 SqlSession 对象，SqlSession 能执行 sql 语句
        SqlSession session = factory.openSession();
        //5.指定要执行的sql语句中的id
        //sql的id = namespace+"."+ <select>标签中的id属性值
        //String sqlId = "com.lln.dao.StudentDao"+"."+"selectStudentById";
        String sqlId = "com.lln.dao.StudentDao.selectStudentById";
        //6.通过SqlSession的方法，执行sql语句
        //Student student = session.selectOne(sqlId);
        Student student = session.selectOne(sqlId,1);

        //7.控制台输出
        System.out.println("使用mybatis根据id查询一个学生："+student);
        //8.关闭 SqlSession，释放资源
        session.close();
    }

    //占位符测试mybatis执行sql添加语句
    @Test
    public void testInsertStudent() throws IOException {
        //调用mybatis某个对象的方法，执行mapper文件中的sql语句
        //mybatis核心类：SqlSessionFactory
        //1.定义mybatis 主配置文件的位置，从类路径开始的相对路径
        String config = "mybatis.xml";
        //2.读取主配置文件，使用mybatis框架中的Resources类
        InputStream inputStream = Resources.getResourceAsStream(config);
        //3.使用SqlSessionFactoryBuilder类创建 SqlSessionFactory 对象,目的是获取 SqlSession
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //4.获取 SqlSession 对象，SqlSession 能执行 sql 语句
        SqlSession session = factory.openSession();
        //5.指定要执行的sql语句中的id
        //sql的id = namespace+"."+ <select>标签中的id属性值
        String sqlId = "com.lln.dao.StudentDao.insertStudent";
        //6.通过SqlSession的方法，执行sql语句
        Student student = new Student();
        student.setId(3);
        student.setName("王五");
        student.setEmail("789@163.com");
        student.setAge(30);

        int rows = session.insert(sqlId,student);
        //mybatis默认执行sql语句是手动提交事务
        //在insert,update,delete后需要提交事务
        session.commit();

        //7.控制台输出
        System.out.println("使用mybatis添加一个学生，影响行数rows="+rows);
        //8.关闭 SqlSession，释放资源
        session.close();
    }
}

运行结果：

Logging initialized using 'class org.apache.ibatis.logging.stdout.StdOutImpl' adapter.
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 205962452.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@c46bcd4]
==>  Preparing: insert into student values(?,?,?,?) 
==> Parameters: 3(Integer), 王五(String), 789@163.com(String), 30(Integer)
<==    Updates: 1
Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@c46bcd4]
使用mybatis添加一个学生，影响行数rows=1
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@c46bcd4]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@c46bcd4]
Returned connection 205962452 to pool.

更新数据库查看添加结果：添加成功！