【JAVA_EE】Day02 MyBatis的核心配置

最新推荐文章于 2024-09-27 00:45:01 发布

张禹垚

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量1.2k

点赞数 23

分类专栏： JavaEE JavaSpring 文章标签： java mybatis tomcat

本文链接：https://blog.csdn.net/HLJ_Student/article/details/142346988

版权

JavaSpring 同时被 2 个专栏收录

31 篇文章 0 订阅

订阅专栏

JavaEE

3 篇文章 0 订阅

订阅专栏

MyBatis的核心配置

MyBatis的核心对象

使用MyBatis框架解决持久化问题，主要涉及3个核心对象，分别是SqlSessionFactoryBuilder、SqlSessionFactory和SqlSession。

SqlSessionFactoryBuilder

所有的MyBatis应用都是以SqlSessionFactory对象为中心，SqlSessionFactoryBuilder就是这个对象的构造器，其提供了多个build()的重载方法。

SqlSessionFactory

SqlSessionFactory用于创建SqlSession对象，所有MyBatis应用都以SqlSessionFactory对象为中心，SqlSessionFactory通过调用openSession()方法创建SqlSession对象，其提供多个重载的openSession()方法。

SqlSession

可以直接使用SqlSession对象来执行已映射的SQL语句。

方法名称	描述
<T> T selectOne(String statement)	查询方法参数statement是在配置文件中定义的<select>元素的id。该方法返回SQL语句查询结果的一个泛型对象
<T> T selectOne(String statement, Object parameter)	查询方法参数statement是在配置文件中定义的<select>元素的id， parameter是查询语句所需的参数。该方法返回SQL语句查询结果的一个泛型对象
<E> List<E> selectList(String statement)	查询方法参数statement是在配置文件中定义的<select>元素的id。该方法返回SQL语句查询结果的一个泛型对象的集合
<E> List<E> selectList(String statement, Object parameter)	查询方法参数statement是在配置文件中定义的<select>元素的id， parameter是查询语句所需的参数。该方法返回SQL语句查询结果的一个泛型对象的集合
<E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds)	查询方法参数statement是在配置文件中定义的<select>元素的id， parameter是查询语句所需的参数， rowBounds是用于分页的参数对象。该方法返回SQL语句查询结果的一个泛型对象的集合
void select(String statement, Object parameter, ResultHandler handler)	查询方法参数statement是在配置文件中定义的<select>元素的id， parameter是查询语句所需的参数， handler对象用于处理查询语句返回的复杂结果集。该方法通常用于多表联查
int insert(String statement)	插入方法参数statement是在配置文件中定义的<insert>元素的id。该方法返回SQL语句所影响的行数
int insert(String statement, Object parameter)	插入方法参数statement是在配置文件中定义的<insert>元素的id。 parameter是查询语句所需的参数，该方法返回SQL语句所影响的行数
int update(String statement)	更新方法参数statement是在配置文件中定义的<update>元素的id。该方法返回SQL语句所影响的行数
int update(String statement, Object parameter)	更新方法参数statement是在配置文件中定义的<update>元素的id。 parameter是查询语句所需的参数，该方法返回SQL语句所影响的行数
int delete(String statement)	删除方法参数statement是在配置文件中定义的<delete>元素的id。该方法返回SQL语句所影响的行数
int delete(String statement, Object parameter)	更新方法参数statement是在配置文件中定义的<delete>元素的id。 parameter是查询语句所需的参数，该方法返回SQL语句所影响的行数
void commit()	提交事务的方法
void rollback()	回滚事务的方法
void close()	关闭SqlSession对象
<T> T getMapper(class<T> type)	该方法会返回Mapper接口的代理对象，该对象关联了SqlSession对象=开发人员可以使用该对象直接调用相应方法操作数据库。参数type是Mapper的接口类型。 MyBatis官方推荐通过Mapper对象访问MyBatis
Connection getConnection()	获取JDBC数据库连接对象的方法

MyBatis核心配置文件

<properties>元素

配置属性，用于读取外部文件的配置信息，我们有配置文件db.properties配置数据库的连接信息，我们就可以通过<properties>标签标注引用配置文件

<properties resource="db.properties"/>

我们也可以动态的获取db.properties文件中的数据库连接信息，使用<property>标签进行配置，这样连接数据库的四个属性的值将由db.properties文件中对应的值动态替换，实现动态参数配置。

<dataSource type="POOLED">
    <property name="driver" value="${mysql.driver}"/>
    <property name="url" value="${mysql.url}"/>
    <property name="username" value="${mysql.username}"/>
	<property name="password" value="${mysql.password}"/>
</dataSource>

<settings>元素

用于改变MyBatis运行时的行为，例如开启二级缓存、开启延迟加载等

配置参数	描述	有效值	默认值
cacheEnabled	是否开启缓存	true或false	true
lazyLoadingEnable	（普通）是否开启延迟加载（关联的对象被使用时才会被加载，而不是主对象使用即加载），fetchType可以覆盖这一项全局配置	true或false	false
aggressiveLazyLoading	（激进）关联对象属性是否全部一起延迟加载	true或false	true
multipleResultSetsEnabled	是否允许单一语句返回多结果集	true或false	true
useColumnLable	是否使用列标签代替列名	true或false	true
useGeneratedKeys	是否允许JDBC自动强制生成主键	true或false	false
autoMappingBehavior	指定MyBatis如何自动映射到字段或属性。NONE：取消自动映射，PARTIAL：只自动映射未定义结果集映射的结果集，FULL：无论任何结果集全部映射	NONE或PARTIAL或FULL	PARTIAL
defaultStatementTimeout	配置超时时间，决定驱动等待数据库响应的时间	任何正整数	无
defalutExecutorType	配置执行器。SIMPLE是普通执行器，REUSE会复用预处理语句执行器，BATCH是复用语句并执行批量更新执行器	SIMPLE或REUSE或BATCH	SIMPLE
mapUnderscoreToCamelCase	是否开启驼峰命名规则映射	true或false	false
jdbcTypeForNull	当未对参数指定JDBC类型时，为空值指定JDBC类型，一般情况下直接选用一般类型即可	NULL或VARCHAR或OTHER	OTHER

<typeAliases>元素

为POJO实体类设置简短的别名，减少全限定类名的冗余，例如，POJO实体类User全限定类名是com.itheima.pojo.User，未设置别名前，引用代码如下：

<select id="findById" parameterType="int" resultType="com.itheima.pojo.User">
	SELECT * FROM users WHERE uid=#{id}
</select>

如果我们在核心配置文件mybatis-config.xml中定义了别名，如下：

<typeAliases>
	<typeAlias alias="User" type="com.itheima.pojo.User"/>
</typeAliases>

我们引用的时候就可以将代码写成：

<select id="findById" parameterType="int" resultType="User">
	SELECT * FROM users WHERE uid=#{id}
</select>

也可以使用自动扫描包来为全限定类设置别名，MyBatis会自动将包下的类名起一个首字母小写的别名

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

<environments>元素

定义一套运行环境，其中包含两个元素<transactionManager>和<dataSource>，前者用来配置运行环境的事务管理器，后者配置运行环境的数据源信息，如下：

<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <!-- 使用db.properties文件中的配置 -->
        <dataSource type="POOLED">
            <property name="driver" value="${mysql.driver}"/>
            <property name="url" value="${mysql.url}"/>
            <property name="username" value="${mysql.username}"/>
            <property name="password" value="${mysql.password}"/>
        </dataSource>
    </environment>
</environments>

<environments>元素是环境配置的根元素，其中default属性指定默认环境的id，一个<environments>内可以有多个<environment>子元素，id属性配置定义环境的id值。

在MyBatis中，<transactionManager>元素可以配置两种类型的事务管理器，一个是JDBC，另一个是MANAGED，前者直接使用JDBC的提交和回滚设置，依赖于从数据源得到的连接来管理事务的作用域，而后者不提交或回滚一个连接，而是让容器来管理事务的整个生命周期，默认情况下他会关闭掉连接，有的时候我们不希望这样，可以使用closeConnection属性设置为false组织默认关闭行为。

如果项目使用Spring+MyBatis，则没必要配置事务管理器，实际开发会使用Spring自带管理器实现事务管理。

<mappers>元素

用于引入MyBatis映射文件，其中包含POJO对象和数据表之间的映射信息，通过<mappers>元素引入映射文件的方法如下：

使用类路径引入映射文件：

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

使用绝对路径引入映射文件：

<mappers>
	<mapper url="file:///D:/com/itheima/mapper/UserMapper.xml"/>
</mappers>

使用接口引入映射文件（常用）：

<mappers>
	<mapper class="com.itheima.mapper.UserMapper"/>
</mappers>

使用包名引入映射文件：

<mappers>
	<package name="com.itheima.mapper"/>
</mappers>

MyBatis映射文件

从这一节开始就将见证MyBatis的真正强大之处，MyBatis控制SQL映射语句。

MyBatis映射文件中的常用元素

元素	说明
<mapper>	映射文件的根元素，该元素只有一个namespace(命名空间)属性，namespace属性作用如下： (1) 用于区分不同的mapper，全局唯一； (2) 绑定DAO接口，即面向接口编程。当namespace绑定某一接口之后，可以不用写该接口的实现类，MyBatis会通过接口的全限定类名查找到对应的mapper配置来执行SQL语句，因此namespace的命名必须和接口同名。
<cache>	配置给定命名空间的缓存
<cache-ref>	从其他命名空间引用缓存配置
<select>	用于映射查询语句
<insert>	用于映射插入语句
<update>	用于映射更新语句
<delete>	用于映射删除语句
<sql>	可以重用的SQL块，也可以被其他语句使用
<resultMap>	描述数据库结果集和对象的对应关系

<select>元素

用于映射查询语句，示例代码如下：

<!-- 查询操作 -->
<select id="findUserById" parameterType="Integer" resultType="com.itheima.pojo.User">
    SELECT * FROM mybatis.users WHERE uid = #{id}
</select>

<select>元素id属性的值为findUserById；
parameterType属性的值为Integer，表示接收一个int或Integer类型的参数；
resultType的值为User类的全限定名，表示返回一个User类型的对象；
#{参数名}表示创建一个预处理语句参数，等同于JDBC中的"?"。

以上只是我们用来演示<select>元素的示例，其实还有其他属性可供使用：

属性	说明
id	表示namespace中<select>元素的唯一标识，通过这个标识即可调用到这条查询语句。若id属性值在当前namespace中不唯一则会报抛出异常。
parameterType	指定SQL语句所需参数类的全限定类名或别名。
resultType	指定执行这条SQL语句返回的类的全限定类名或别名，若属性是集合，则需要指定集合可以包含的类型，如HashMap
resultMap	表示外部resultMap的命名引用，不能与resultType同时使用。
flushCache	用于指定SQL语句调用后是否需要MyBatis清空本地缓存和二级缓存，值为boolen类型，默认值为false。
useCache	用于控制二级缓存的开启何关闭，值为boolean类型，默认值为true，表示该SQL语句运行完毕将查询结果存入二级缓存中。
timeout	用于设置超时时间，单位为秒，若超时将抛出异常。
fetchSize	获取记录的总条数设定
statementType	用于设置MyBatis的预处理类，其值有三个：STATEMENT、PREPARED（默认值）、CALLABLE，分别对应JDBC中的：Statement、PreparedStatement和CallableStatement
resultSetType	表示结果集的类型，其值可以设置为DEFAULT、FORWARD_ONLY、SCROLL_SENSITIVE或SCROLL_INSENSITIVE

<insert>元素

用于映射插入语句，执行完元素中定义的SQL语句后会返回插入记录的数量，示例如下：

<!-- 插入数据 -->
<insert id="addUser" parameterType="com.itheima.pojo.User">
    INSERT INTO mybatis.users(uid, uname, uage) VALUES (#{uid}, #{uname}, #{uage})
</insert>

唯一标识id的值为addUser；
parameterType属性的值为User类的全限定类名，表示接受一个User类型的参数；
SQL语句中的#{uid}, #{uname}, #{uage}表示通过占位符接收参数uid、uname、uage。

以上只是我们用来演示<insert>元素的示例，其实还有其他属性可供使用：

属性	说明
id	表示namespace中<insert>元素的唯一标识。若id属性值在当前namespace中不唯一则会报抛出异常。
parameterType	指定SQL语句所需参数类的全限定类名或别名。
flushCache	用于指定SQL语句调用后是否需要MyBatis清空本地缓存和二级缓存，值为boolen类型，默认值为false。
timeout	用于设置超时时间，单位为秒，若超时将抛出异常。
statementType	用于设置MyBatis的预处理类，其值有三个：STATEMENT、PREPARED（默认值）、CALLABLE，分别对应JDBC中的：Statement、PreparedStatement和CallableStatement
keyProperty	将插入或更新操作的返回值赋给POJO类的某个属性。如需设置联合主键，在多值之间用逗号隔开
keyColumn	该属性用于设置第几列是主键，当主键列不是表中第一列时需要设置，如需设置联合主键，在多值之间用逗号隔开
useGeneratedKeys	该属性回事MyBatis调用JDBC的grtGeneratedKeys()方法来获取由数据库内部生产的主键，如MySQL和SQL Server等自动递增的字段，其默认值为false

<update>元素

<update>元素用于映射更新语句，他可以更新数据库中的数据。在执行完元素中定义的SQL语句后，会返回更新的记录数量。示例如下：

<!-- 更新数据 -->
<update id="updateUser" parameterType="com.itheima.pojo.User">
    UPDATE mybatis.users SET uname = #{uname}, uage = #{uage} WHERE uid = #{uid}
</update>

id属性值为updateUser；
parameterType的值为User类的全限定名，表示接受一个User类型的参数；
SQL语句中的#{uid}, #{uname}, #{uage}表示通过占位符接收参数uid、uname、uage。

<delete>元素

<delete>元素用于映射删除语句，执行完SQL语句之后返回记录数量。示例如下：

<!-- 删除数据 -->
<delete id="deleteUser" parameterType="Integer">
    DELETE FROM mybatis.users WHERE uid = #{uid}
</delete>

<delete>元素可以配置的属性如下：

属性	说明
id	表示namespace中<delete>元素的唯一标识。若id属性值在当前namespace中不唯一则会报抛出异常。
parameterType	指定SQL语句所需参数类的全限定类名或别名。
flushCache	用于指定SQL语句调用后是否需要MyBatis清空本地缓存和二级缓存，值为boolen类型，默认值为false。
timeout	用于设置超时时间，单位为秒，若超时将抛出异常。
statementType	用于设置MyBatis的预处理类，其值有三个：STATEMENT、PREPARED（默认值）、CALLABLE，分别对应JDBC中的：Statement、PreparedStatement和CallableStatement

<sql>元素

使用Mybatis所提供的<sql>元素，将这些SQL语句中的相同组成部分抽取出来，在需要的地方引用，作用是定义可重用的SQL片段，可以使用<include>元素机器中的refid属性包含在其他语句中，refid属性的值为自定义代码片段的id。使用<property>元素将<sql>元素参数化，<sql>元素中的属性值随包含的对象而发生变化。示例如下：

<!-- 定义可复用的 SQL 片段 -->
<sql id="userColumns">
    uname, uage
</sql>

<!-- 查询用户 -->
<select id="getUserById" resultType="com.itheima.pojo.User">
    SELECT <include refid="userColumns" />
    FROM mybatis.users
    WHERE uid = #{uid}
</select>

<!-- 插入用户 -->
<insert id="insertUser">
    INSERT INTO mybatis.users (<include refid="userColumns" />)
    VALUES (#{uname}, #{uage})
</insert>

<!-- 更新用户 -->
<update id="updateUsers">
    UPDATE mybatis.users
    SET uname = #{uname}, uage = #{uage}
    WHERE uid = #{uid}
</update>

<resultMap>元素

<resultMap>表示结果集，作用是定义映射规则、更新级联和定义类型转化其等，可以将查询到的复杂数据，例如多张表的数据一对一映射、一对多映射等复杂关系聚合到一个结果集当中。示例如下：

在名称为mybatis的数据库中，创建一个t_student表，并插入几条测试数据，具体代码如下：

USE mybatis;
CREATE TABLE t_student(
  sid INT PRIMARY KEY AUTO_INCREMENT,
  sname VARCHAR(30),
  sage INT
);
INSERT INTO t_student(sname, sage) VALUES ('Lucy', 25);
INSERT INTO t_student(sname, sage) VALUES ('Lili', 20);
INSERT INTO t_student(sname, sage) VALUES ('Jim', 20);

在项目src/main/java目录下创建com.itheima.pojo包，并在com.itheima.pojo包下创建实体类Student，用于封装学生信息。在类中定义id、name和age属性，以及属性的getter/setter方法和toString()方法。代码如下：

package com.itheima.pojo;

/**
 * @author Zhang
 */
public class Student {
    // 学生id
    private Integer id;
    // 学生姓名
    private String name;
    // 学生年龄
    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 Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

在项目的src/main/java目录下创建com.itheima.mapper包，并在com.itheima.mapper包中创建映射文件StudentMapper.xml，并在映射文件中编写映射查询语句。StudentMapper.xml映射文件主要用于实现SQL语句和Java对象之间的映射，使SQL语句查询出来的关系型数据能够被封装成Java对象。StudentMapper.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">
<mapper namespace="com.itheima.mapper.StudentMapper">
    <resultMap type="com.itheima.pojo.Student" id="studentMap">
        <id property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="age" column="sage"/>
    </resultMap>
    <select id="findAllStudent" resultMap="studentMap">
        SELECT * FROM mybatis.t_student
    </select>
</mapper>

在核心配置文件"mybatis-config.xml"中引入StudentMapper.xml，将StudentMapper.xml映射文件加载到程序中。在mybatis-config.xml中的<mappers>元素下添加的代码如下：

<mapper resource="com/itheima/mapper/StudentMapper.xml"/>

在项目的src/test/java目录下的Test包中创建测试类MyBatisTest，在测试类中编写方法findAllStudentTest()，用于测试<resultMap>元素实现查询结果的映射。MyBatisTest类的具体实现代码如下：

package Test;

import com.itheima.pojo.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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.Reader;
import java.util.List;

public class MyBatisTest {
    private SqlSessionFactory sqlSessionFactory;
    private SqlSession sqlSession;

    @Before
    public void init() {
        // 定义读取文件名
        String resources = "mybatis-config.xml";
        // 创建流
        Reader reader = null;
        try {
            // 读取mybatis-config.xml文件到reader对象中
            reader = Resources.getResourceAsReader(resources);
            // 初始化mybatis，创建SqlSessionFactory类的对象
            SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
            // 创建sqlSession对象
            sqlSession = sqlMapper.openSession();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void findAllStudentTest() {
        // SqlSession执行映射文件中定义的SQL，并返回映射结果
        List<Student> list = sqlSession.selectList("com.itheima.mapper.StudentMapper.findAllStudent");
        for (Student student : list) {
            System.out.println(student);
        }
    }

    @After
    public void destroy(){
        // 提交事务
        sqlSession.commit();
        // 关闭事务
        sqlSession.close();
    }
}

20-36行：使用JUnit中的@Before注解标注，用于初始化，每一个测试方法都要执行一次init()方法，首先读取配置文件mybatis-config.xml，之后构建SqlSessionFactory对象，最后通过SqlSessionFactory构建SqlSession对象。

38-45行：该方法执行指定id的SQL语句。其中，42-44行是为了遍历每一次SQL语句被执行的结果，并返回一个结果集。

47-54行：定义destroy()方法，用于释放资源，使用@After注解标注，使用@After注解标注，该方法执行完后都要执行一次。

每一个用@Test标注的方法成为测试方法，调用顺序为：@Before->@Test->@After。

使用工具类创建SqlSession对象

为了简化开发，可以将读取配置文件和释放资源的代码封装到一个工具类中，然后通过工具类创建SqlSession对象。创建包com.itheima.utils，再创建类MyBatisUtils，具体实现代码如下：

package com.itheima.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.Reader;

/**
 * 工具类
 * @author Zhang
 */
public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;
    // 初始化SqlSessionFactory对象
    static {
        try {
            // 使用MyBatis提供的Resources类加载MyBatis的配置文件
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            // 构建SqlSessionFactory
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    // 获取SqlSession对象的静态方法
    public static SqlSession getSession() {
        return sqlSessionFactory.openSession();
    }
}

这样，我们就只创建一了一个SqlSessionFactory对象，并可以通过工具类的getSession()方法来获取SqlSession对象。

案例：员工管理系统

本案例要求根据下表在数据库中创建一个employee表，并利用所学知识完成一个员工管理系统，该系统需要实现如下几个功能。

根据id查询员工信息；
新增员工信息；
根据id修改员工信息；
根据id删除员工信息。

员工编号（id）	员工名称（name）	员工年龄（age）	员工职位（position）
1	张三	20	员工
2	李四	18	员工
3	王五	35	经理

案例：员工管理系统-代码实现

console:

# 案例-员工管理系统
CREATE TABLE employee(
  id INTEGER AUTO_INCREMENT PRIMARY KEY ,
  name VARCHAR(10) NOT NULL ,
  age INT NOT NULL ,
  position VARCHAR(10) NOT NULL
);
DESC employee;
INSERT INTO mybatis.employee(name, age, position) 
VALUES ("张三", 20, "员工"),
	   ("李四", 18, "员工"),
	   ("王五", 35, "经理");
SELECT * FROM employee;

com.itheima.pojo包 —— Employee.java类

package com.itheima.pojo;

/**
 * @author Zhang
 */
public class Employee {
    private Integer id;
    private String name;
    private Integer age;
    private String position;

    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 Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position = position;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", position='" + position + '\'' +
                '}';
    }
}

com.itheima.mapper包 —— EmployeeMapper.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">
<mapper namespace="com.itheima.mapper.EmployeeMapper">
    <!-- 根据id查询员工信息 -->
    <select id="selectById" parameterType="Integer" resultType="com.itheima.pojo.Employee">
        SELECT id, name, age, position
        FROM mybatis.employee
        WHERE id = #{id}
    </select>

    <!-- 新增员工信息 -->
    <insert id="insertEmployee" parameterType="com.itheima.pojo.Employee">
        INSERT INTO mybatis.employee (name, age, position)
        VALUES (#{name}, #{age}, #{position})
    </insert>

    <!-- 根据id修改员工信息 -->
    <update id="updateById" parameterType="com.itheima.pojo.Employee">
        UPDATE mybatis.employee
        SET name = #{name}, age = #{age}, position = #{position}
        WHERE id = #{id}
    </update>

    <!-- 根据id删除员工信息 -->
    <delete id="deleteById" parameterType="com.itheima.pojo.Employee">
        DELETE FROM mybatis.employee
        WHERE id = #{id}
    </delete>
</mapper>

com.itheima.utils包 —— MyBatisUtils.java工具类

package com.itheima.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.Reader;

/**
 * 工具类
 * @author Zhang
 */
public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;
    // 初始化SqlSessionFactory对象
    static {
        try {
            // 使用MyBatis提供的Resources类加载MyBatis的配置文件
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            // 构建SqlSessionFactory
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 获取SqlSession对象的静态方法
    public static SqlSession getSession() {
        return sqlSessionFactory.openSession();
    }
}

mybatis-config.xml配置文件<mappers>元素添加子元素：

<mapper resource="com/itheima/mapper/EmployeeMapper.xml"/>

test.java.Test包 —— EmployeeTest.java测试类：

package Test;

import com.itheima.pojo.Employee;
import com.itheima.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class EmployeeTest {
    // 1.根据id查询员工信息
    @Test
    public void selectById() {
        SqlSession session = MyBatisUtils.getSession();
        try {
            Employee employee = session.selectOne("selectById", 3);
            System.out.println(employee);
        } finally {
            session.close();
        }
    }

    // 新增员工信息
    @Test
    public void insertById() {
        Employee employee = new Employee();
        employee.setName("赵六");
        employee.setAge(30);
        employee.setPosition("科员");
        SqlSession session = MyBatisUtils.getSession();
        try {
            int rows = session.insert("insertEmployee", employee);
            session.commit();
            System.out.println("成功插入了 " + rows + " 条记录");
        } catch (Exception e) {
            session.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    // 根据id修改员工信息
    @Test
    public void updateById(){
        Employee employee = new Employee();
        employee.setName("孙二");
        employee.setAge(22);
        employee.setPosition("后端工程师");
        employee.setId(2);
        SqlSession session = MyBatisUtils.getSession();
        try {
            int rows = session.update("updateById", employee);
            session.commit();
            System.out.println("成功修改了 " + rows + " 条记录");
        } catch (Exception e) {
            session.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    // 根据id删除员工信息
    @Test
    public void deleteById(){
        SqlSession session = MyBatisUtils.getSession();
        Employee employee = new Employee();
        employee.setId(1);
        try {
            int rows = session.delete("deleteById", employee);
            session.commit();
            System.out.println("成功删除了 " + rows + "条记录");
        } catch (Exception e) {
            session.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}

常考面试题

请简述<mappers>元素引入映射文件的四种方式？

在 MyBatis 中，<mappers> 元素有四种方式来引入映射文件：

通过 resource 引入：使用相对路径指定映射文件的位置，通常是相对于类路径（classpath）的路径。
通过 url 引入：使用绝对路径或者网络路径来加载映射文件。
通过 class 引入：指定映射接口的全限定类名，将接口与映射文件进行关联。
通过 package 批量引入：指定包名，自动扫描包下的所有映射接口。这四种方式提供了灵活的映射文件引入方案，适应不同的项目需求。

请简述MyBatis映射文件中的常用元素及其作用？

MyBatis 映射文件中的常用元素及其作用如下：

<resultMap>：
- 用于定义对象与数据库字段的映射关系，解决属性名与数据库字段名不一致的问题。
- 作用：将查询结果映射为 Java 对象。
<select>：
- 用于定义 SQL 查询语句。
- 作用：执行查询操作并返回结果，可以通过 resultType 或 resultMap 指定返回类型。
<insert>：
- 用于定义插入操作的 SQL 语句。
- 作用：将数据插入到数据库中，支持动态 SQL 和自动生成主键。
<update>：
- 用于定义更新操作的 SQL 语句。
- 作用：更新数据库中的记录。
<delete>：
- 用于定义删除操作的 SQL 语句。
- 作用：删除数据库中的记录。
<parameterType>：
- 在 <select>, <insert>, <update>, <delete> 中使用。
- 作用：指定传递给 SQL 的参数类型。