MyBatis基础学习

本文介绍了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的问题

  1. 数据库连接创建、释放频繁造成系统资源浪费,从而影响系统性能。如果使用数据库连接池可解决此问题。
  2. Sql语句在代码中硬编码,造成代码不易维护,实际应用中sql变化的可能较大,sql变动需要改变java代码。
  3. 使用preparedStatement向占有位符号传参数存在硬编码,因为sql语句的where条件不一定,可能多也可能少,修改sql还要修改代码,系统不易维护。
  4. 对结果集解析存在硬编码(查询列名),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对象属性的名称要与数据库对应字段的名称保持一致,并且数据类型要相同。

测试

测试程序步骤:

  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注入

  • ${}

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

可 以 接 收 简 单 类 型 值 或 p o j o 属 性 值 , 如 果 p a r a m e t e r T y p e 传 输 单 个 简 单 类 型 值 , {}可以接收简单类型值或pojo属性值,如果parameterType传输单个简单类型值, pojoparameterType{}括号中只能是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(依赖驱动)。
statementTypeSTATEMENT,PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement,PreparedStatement 或 CallableStatement,默认值:PREPARED。
resultSetTypeFORWARD_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映射文件名称相同,且放在同一个目录中。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值