MyBatis基础学习

MyBatis

什么是MyBatis

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

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

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

高级映射：JavaBean

持久化

数据持久化

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

为什么需要持久化？

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

持久层

层：Dao层、Service层、Controller层…

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

优点：

• 不需要手动设置参数以及结果、类型。

• 不需要写常规的JDBC链接

• 通过注解来映射原生信息：数据库查出来的字段信息

• 可以直接将JavaBean映射反序列化变成数据库中的数据

使用JDBC的问题

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

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

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对象属性的名称要与数据库对应字段的名称保持一致，并且数据类型要相同。

测试

测试程序步骤：

1. 创建SqlSessionFactoryBuilder对象，并加载SqlMapConfig.xml配置文件

2. 调用SqlSessionFactoryBuilder的build方法，创建SqlSessionFactory

3. 调用SqlSessionFactory.openSession()创建SqlSession对象

4. 执行SqlSession.selectOne()，进行查询，并获取结果Grade

5. 处理结果、释放资源

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映射文件名称相同，且放在同一个目录中。