MyBatis基础学习_mybatisapi中,可实现获取批量数据的是-优快云博客

本文链接：https://blog.youkuaiyun.com/Watson2020/article/details/117471295

本文介绍了MyBatis这一优秀的持久层框架，阐述了持久化、持久层概念及MyBatis优点，分析了使用JDBC的问题。详细说明了MyBatis环境配置步骤，包括下载jar、创建项目等。还介绍了根据id查询、模糊查询、添加、删除、更新等操作的实现，以及核心对象SqlSessionFactory等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

MyBatis

什么是MyBatis

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。

MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。

MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

高级映射：JavaBean

持久化

数据持久化

持久化就是将程序的数据在持久状态和瞬时状态转化的过程
内存：断电即失
数据库（Jdbc），io文件持久化

为什么需要持久化？

有一些需要保存的对象，不能直接丢掉。
内存昂贵

持久层

层：Dao层、Service层、Controller层…

完成持久化工作的代码块
层界限十分明显

优点：

不需要手动设置参数以及结果、类型。
不需要写常规的JDBC链接
通过注解来映射原生信息：数据库查出来的字段信息
可以直接将JavaBean映射反序列化变成数据库中的数据

使用JDBC的问题

数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。如果使用数据库连接池可解决此问题。
Sql语句在代码中硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需要改变java代码。
使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。
对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便。

MyBatis架构

Mybatis架构

MyBatis环境配置

1.下载jar

源码地址：github-mybatis

如果是maven项目，配置maven地址：

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

2.创建项目，导入jar

导入mybatis的jar

3.SqlMapConfig.xml

SqlMapConfig.xml是mybatis核心配置文件，配置文件中包含了对 MyBatis 系统的核心设置，包含获取数据库连接实例的数据源（DataSource）和决定事务作用域和控制方式的事务管理器（TransactionManager）。

在config下创建SqlMapConfig.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>
	<!-- 和spring整合后 environments配置将废除 -->
	<environments default="development">
		<environment id="development">
			<!-- 使用jdbc事务管理 -->
			<transactionManager type="JDBC" />
			<!-- 数据库连接池 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
				<property name="username" value="root" />
				<property name="password" value="123456" />
			</dataSource>
		</environment>
	</environments>
</configuration>

4.创建pojo

pojo类作为mybatis进行sql映射使用，pojo类通常与数据库表对应

public class Grade{
	private int id;
	private int grade;// 用户姓名
	//get/set……
}

5.配置sql映射文件

在config下创建sql映射文件Grade.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：命名空间【重要】-->
<mapper namespace="grade">
</mapper>

6.加载配置文件

mybatis框架需要加载Mapper.xml映射文件

将Grade.xml添加在SqlMapConfig.xml，如下：

加载配置文件

实现

1.根据id查询年级信息

查询的SQL:

SELECT * FROM grade WHERE id = 1

配置映射文件：

<mapper namespace="grade">
	<!-- id:表示命名空间的唯一标识，与命名空间配合使用，组合后必须唯一-->
	<!-- parameterType：传入的SQL语句参数类的全类名或者别名（参数类型） -->
	<!-- resultType：执行SQL语句中返回的结果类型的全类名或者别名，如果是集合类型，那么返回的是集合可以包含的类型，而不是集合本身 -->
	<!-- #{}：输入参数的占位符，相当于jdbc的[?] -->
	<select id="findGradeById" parameterType="int"
		resultType="com.qsy.pojo.Grade">
		SELECT * FROM Grade WHERE id = #{id}
	</select>
</mapper>

parameterType和resultType

parameterType（传参的类型）

指定输入参数类型，mybatis通过ognl从输入对象中获取参数值拼接在sql中。

如果传的是String，要写成parameterType=“java.lang.String”，因为String是引用数据类型，而int是一般基本数据类型。

resultType（返回类型）

指定输出结果类型，mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。如果有多条数据，则分别进行映射，并把对象放到容器List中

注：pojo对象属性的名称要与数据库对应字段的名称保持一致，并且数据类型要相同。

测试

测试程序步骤：

创建SqlSessionFactoryBuilder对象，并加载SqlMapConfig.xml配置文件
调用SqlSessionFactoryBuilder的build方法，创建SqlSessionFactory
调用SqlSessionFactory.openSession()创建SqlSession对象
执行SqlSession.selectOne()，进行查询，并获取结果Grade
处理结果、释放资源

import com.qsy.pojo.Grade;
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.jupiter.api.Test;

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

public class testQueryGradeById {
    @Test
    public void testQueryGradeById() throws IOException {
        // 1. 创建SqlSessionFactoryBuilder对象，加载SqlMapConfig.xml配置文件
        SqlSessionFactoryBuilder sessionFactoryBuilder = new SqlSessionFactoryBuilder();
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2. 创建SqlSessionFactory对象
        SqlSessionFactory sessionFactory = sessionFactoryBuilder.build(is);
        // 3. 创建SqlSession对象
        SqlSession sqlSession = sessionFactory.openSession();
        // 4. 执行SqlSession对象执行查询，获取结果Grade
        Grade grade = sqlSession.selectOne("findGradeById", 1);
        // 5. 处理结果、释放资源
        System.out.println(grade);
        sqlSession.close();
    }
}

2. 根据年级模糊查询年级列表

模糊查询的SQL：

SELECT * FROM Grade WHERE grade LIKE '%18%'

方式1：#{}

映射文件

在Grade.xml配置文件中添加如下内容：

<!-- 返回结果如果是集合类型，那么返回的是集合可以包含的类型，而不是集合本身 -->
<!-- resultType的配置和返回一个结果的配置一样 -->
<select id="findGradeById" parameterType="java.lang.String" resultType="com.qsy.pojo.Grade">
    select * from grade where grade like #{grade}
</select>

方式2：${}

<!-- ${} 使用拼接符：字符串原样拼接，如果传入的参数是基本数据类型，那么${}中的变量名称必须为：value-->
<!--注意：拼接符有sql注入的风险-->
<select id="findGradeByNameLike2" parameterType="string" resultType="com.qsy.pojo.Grade" >
    SELECT * FROM grade where grade like '%${value}%'
</select>

为什么是value？推荐链接

mybatis 中的 ${value} 替代符

测试

方法1：

import com.qsy.pojo.Grade;
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.jupiter.api.Test;

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

public class testFindGradeByNameLike1 {
    @Test
    public void testFindGradeByNameLike1() throws IOException {
        SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession ss = sf.openSession();
        List<Grade> grades = ss.selectList("grade.findGradeByNameLike1", "%2%");
        System.out.println(grades);
    }
}

方法2：

import com.qsy.pojo.Grade;
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.jupiter.api.Test;

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

public class testFindGradeByNameLike2 {
    @Test
    public void testFindGradeByNameLike2() throws IOException {
        SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession ss = sf.openSession();
        List<Grade> grades = ss.selectList("grade.findGradeByNameLike2", "2");
        System.out.println(grades);
    }
}

小结

#{}、${}区别

#{}

表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值默认将其当成字符串

#{}可以有效防止sql注入

${}

${}表示拼接sql串，通过$ {}可以将parameterType 传入的内容拼接在sql中不做任何处理

${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，$ {}括号中只能是value。

推荐链接：

mybatis中的#和$的区别

selectOne和selectList

selectOne：查询一条记录，如果使用selectOne查询多条记录则抛出异常：

org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 3

at org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

selectList：可以查询一条或多条记录。

3.添加年级

SQL语句：

INSERT INTO Grade (id,grade) VALUES (2,2017)

配置映射文件：

<!--保存年级信息-->
<insert id="saveGrade" parameterType="com.qsy.pojo.Grade">
    INSERT INTO Grade (id,grade) VALUES (#{id},#{grade})
</insert>

测试

import com.qsy.pojo.Grade;
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.jupiter.api.Test;

import java.io.IOException;

public class testSaveGrade {
    @Test
    public void testSaveGrade() throws IOException {
        SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession ss = sf.openSession();
        Grade grade = new Grade();
        grade.setId(2);
        grade.setGrade(2017);
        ss.insert("grade.saveGrade",grade);
        ss.commit();
        ss.close();
    }

}

设置主键自动增长

方法1：

查询id的sql：SELECT LAST_INSERT_ID()

LAST_INSERT_ID():是mysql的函数，返回auto_increment自增列新记录id值

通过使用keyProperty属性指定PO类的某个属性接受主键的返回值（通常会设置到id上）

通过修改Grade.xml映射文件，可以将mysql自增主键返回：

添加selectKey 标签

<!-- 保存年级信息-主键自动增长 -->
<insert id="saveGradeAK1" parameterType="com.qsy.pojo.Grade">
    <!-- selectKey 标签实现主键返回 -->
    <!-- keyColumn:主键对应的表中的哪一列 -->
    <!-- keyProperty：主键对应的pojo中的哪一个属性 -->
    <!-- order：设置在执行insert语句前执行查询id的sql-->
    <!-- resultType：设置返回的id的类型 -->
    <selectKey keyColumn="id" keyProperty="id" order="AFTER"
               resultType="int">
        SELECT LAST_INSERT_ID()
    </selectKey>
    INSERT INTO Grade (id,grade) VALUES (#{id},#{grade})
</insert>

方法2：

针对于Mysql这种自己维护主键的数据库，可以直接使用以下配置在插入后获取插入主键，如果你的数据库支持自动生成主键的字段（比如 MySQL 和 SQL Server），那么你可以设置 useGeneratedKeys=”true”，然后再把 keyProperty 设置到目标属性上就OK了。

例如，如果上面的 Grade 表已经对 id 使用了自动生成的列类型，那么语句可以修改为:

<!-- 保存年级信息-主键自动增长 -->
<insert id="saveGradeAK2" useGeneratedKeys="true" keyProperty="id" parameterType="com.qsy.pojo.Grade">
    INSERT INTO Grade (grade) VALUES (#{grade})
</insert>

测试：

import com.qsy.pojo.Grade;
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.jupiter.api.Test;

import java.io.IOException;

public class testSaveGradeAK {
    @Test
    public void testSaveGradeAK() throws IOException {
        SqlSessionFactoryBuilder sfb = new SqlSessionFactoryBuilder();
        SqlSessionFactory sf = sfb.build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession ss = sf.openSession();
        Grade grade = new Grade();
        grade.setGrade(2010);
//        int i = ss.insert("grade.saveGradeAK1", grade);//方法1
        int i = ss.insert("grade.saveGradeAK2", grade);//方法2
        ss.commit();
        ss.close();
        System.out.println(i);
    }

}

4.删除年级

配置文件

<!--删除年级-->
   <delete id="deleteGradeById" parameterType="int">
   DELETE FROM Grade WHERE id=#{id}
</delete>

测试

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.jupiter.api.Test;

import java.io.IOException;

public class testDeleteGrade {
    @Test
    public void testDeleteGrade() throws IOException {
        SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession ss = sf.openSession();
        ss.delete("grade.deleteGradeById", 4);
        ss.commit();
        ss.close();
    }
}

5.更新年级

配置文件：

<!--更新年级-->
<update id="updateGradeById" parameterType="com.qsy.pojo.Grade">
    UPDATE Grade SET grade = #{grade} WHERE id = #{id}
</update>

测试

import com.qsy.pojo.Grade;
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.jupiter.api.Test;

import java.io.IOException;

public class testUpdateGradeById {
    @Test
    public void testUpdateGradeById() throws IOException {
        SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("SqlMapConfig.xml"));
        SqlSession ss = sf.openSession();
        Grade grade = new Grade();
        grade.setId(3);
        grade.setGrade(2020);
        ss.update("grade.updateGradeById", grade);
        ss.commit();
        ss.close();
    }
}

核心对象

SqlSessionFactory

SqlSessionFactory是一个接口，其主要作用是创建SqlSession（openSession方法）

SqlSessionFactory对象的实例可以通过SqlSessionFactoryBuilder对象来构建

SqlSessionFactoryBuilder：用于创建SqlSessionFacoty

1. 从XML中构建 SqlSessionFactory

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

从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。但是也可以使用任意的输入流(InputStream)实例，包括字符串形式的文件路径或者 file:// 的 URL 形式的文件路径来配置。

MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，可使从 classpath 或其他位置加载资源文件更加容易。

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

2. SqlSessionFactory注意事项

SqlSessionFactory对象是线程安全的，它一旦被创建，整个应用程序执行期间就会存在

如果我们多次地创建数据库的SqlSessionFactory，那么次数据库的资源很容易被耗尽，为了解决此问题，通常每一个数据库都会只对应一个SqlSessionFactory，所以在构建SqlSessionFactory实例时，建议使用单例

关于Mybatis配合开发Dao

Mybatis配合开发Dao

以下内容了解即可*

Mapper XML

MyBatis 的真正强大在于它的映射语句，也是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 就是针对 SQL 构建的，并且比普通的方法做的更好。

SQL 映射文件有很少的几个顶级元素（按照它们应该被定义的顺序）：

cache – 给定命名空间的缓存配置。

cache-ref – 其他命名空间缓存配置的引用。

resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。

parameterMap – 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。

sql – 可被其他语句引用的可重用语句块。

insert – 映射插入语句

update – 映射更新语句

delete – 映射删除语句

select – 映射查询语句

select

查询语句是 MyBatis 中最常用的元素之一

简单查询的 select 元素是非常简单的。比如：

<select id="selectPerson" parameterType="int" resultType="hashmap">
  SELECT * FROM PERSON WHERE ID = #{id}
</select>

这个语句被称作 selectPerson，接受一个 int（或 Integer）类型的参数，并返回一个 HashMap 类型的对象，其中的键是列名，值便是结果行中的对应值。

注意参数符号：#{id}

这就告诉 MyBatis 通过 JDBC 创建一个预处理语句参数，这样的一个参数在 SQL 中会由一个“?”来标识，并被传递到一个新的预处理语句中，就像这样：

// Similar JDBC code, NOT MyBatis…
String selectPerson = "SELECT * FROM PERSON WHERE ID=?";PreparedStatement ps = conn.prepareStatement(selectPerson);
ps.setInt(1,id);

当然，这需要很多单独的 JDBC 的代码来提取结果并将它们映射到对象实例中，这就是 MyBatis 节省你时间的地方。我们需要深入了解参数和结果映射，细节部分我们下面来了解。

select 元素有很多属性允许你配置，来决定每条语句的作用细节。

<select
  id="selectPerson"
  parameterType="int"
  parameterMap="deprecated"
  resultType="hashmap"
  resultMap="personResultMap"
  flushCache="false"
  useCache="true"
  timeout="10000"
  fetchSize="256"
  statementType="PREPARED"
  resultSetType="FORWARD_ONLY">

Select 属性

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句。
parameterType	将会传入这条语句的参数类的完全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过 TypeHandler 推断出具体传入语句的参数，默认值为 unset。
parameterMap	这是引用外部 parameterMap 的已经被废弃的方法。使用内联参数映射和 parameterType 属性。
resultType	从这条语句中返回的期望类型的类的完全限定名或别名。注意如果是集合情形，那应该是集合可以包含的类型，而不能是集合本身。使用 resultType 或 resultMap，但不能同时使用。
resultMap	外部 resultMap 的命名引用。结果集的映射是 MyBatis 最强大的特性，对其有一个很好的理解的话，许多复杂映射的情形都能迎刃而解。使用 resultMap 或 resultType，但不能同时使用。
flushCache	将其设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，默认值：false。
useCache	将其设置为 true，将会导致本条语句的结果被二级缓存，默认值：对 select 元素为 true。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为 unset（依赖驱动）。
fetchSize	这是尝试影响驱动程序每次批量返回的结果行数和这个设置值相等。默认值为 unset（依赖驱动）。
statementType	STATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
resultSetType	FORWARD_ONLY，SCROLL_SENSITIVE 或 SCROLL_INSENSITIVE 中的一个，默认值为 unset （依赖驱动）。
databaseId	如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。
resultOrdered	这个设置仅针对嵌套结果 select 语句适用：如果为 true，就是假设包含了嵌套结果集或是分组了，这样的话当返回一个主结果行的时候，就不会发生有对前面结果集的引用的情况。这就使得在获取嵌套的结果集的时候不至于导致内存不够用。默认值：false。
resultSets	这个设置仅对多结果集的情况适用，它将列出语句执行后返回的结果集并每个结果集给一个名称，名称是逗号分隔的。

推荐链接

SqlMapConfig.xml配置文件

1.主要元素

SqlMapConfig.xml中配置的内容和顺序如下：

properties（属性）

settings（全局配置参数）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境集合属性对象）

environment（环境子属性对象）

transactionManager（事务管理）

dataSource（数据源）

mappers（映射器）

2.properties（属性）

将内部的配置文件外在化，在整个配置文件中被用来替换需要动态配置的属性值

在classpath下定义db.properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&useSSL=true
jdbc.username=root
jdbc.password=123456

SqlMapConfig.xml引用如下：

<properties resource="db.properties"/>
<environments default="development">
	<environment id="development">
		<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>
</environments>

注意： MyBatis 将按照下面的顺序来加载属性：

在 properties 元素体内定义的属性首先被读取。
然后会读取properties 元素中resource或 url 加载的属性，它会覆盖已读取的同名属性。

3.typeAliases（类型别名）

为 Java 类型设置一个短的名字。它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余。

3.1 自定义别名

在SqlMapConfig.xml中配置：

<!-- 自定义别名 -->
<typeAliases>
   <!-- 单个别名定义 -->
   <!-- <typeAlias type="com.qsy.pojo.Grade" alias="grade"/> -->

   <!-- 批量别名定义（推荐） -->
   <!-- package：指定包名称来为该包下的po类声明别名，默认的别名就是类名（首字母大小写都可） -->
   <package name="com.qsy.pojo" />
</typeAliases>

type属性用于指定需要被定义别名的类的全类名

alias属性的属性值就是定义的别名

当POJO类过多时，还可以通过自动扫描包的形式自定义别名，具体如下：

<!-- 自定义别名 -->
<typeAliases>
   <package name="com.qsy.pojo" />
</typeAliases>

上述代码，MyBatis会将所有com.jf.weidong.pojo包中的POJO类以首字母小写的非限定类名来作为它的别名，如comqsy.pojo.Grade类的别名为grade

4.mappers（映射器）

Mapper配置的几种方法

4.1

<mapper resource=" " />

使用相对于类路径的资源如：

<mapper resource="mapper/Grade.xml" />

4.2

<mapper class=" " />

使用mapper接口类路径如：

<mapper class="com.qsy.mapper.GradeMapper"/>

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

4.3

<package name=""/>

注册指定包下的所有mapper接口如：

<package name="com.qsy.mapper"/>

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。