✅作者简介：2022年博客新星 第八。热爱国学的Java后端开发者，修心和技术同步精进。
🍎个人主页：Java Fans的博客
🍊个人信条：不迁怒，不贰过。小知识，大智慧。
💞当前专栏：SSM 框架从入门到精通
✨特色专栏：国学周更-心性养成之路
🥭本文内容：MyBatis 入门教程详解

1. SSM 框架简介

  SSM 框架是 Spring、Spring MVC 和 MyBatis 三大框架的组合，是目前主流的 Java EE 企业级框架，适用于搭建各种大型企业级应用系统。SSM 采用标准的 MVC 模式，将整个系统划分为数据访问层（DAO 层）、业务逻辑层、控制层、表示层，使用 MyBatis 管理 DAO 层，作为对象数据的持久化引擎，使用 Spring MVC 进行请求转发与视图管理，使用 Spring 实现业务对象管理并整合其它框架。

2. MyBatis 概述

  MyBatis 是当前 Java Web 开发中流行的持久化 ORM 框架，它对 JDBC 进行了封装与简化，无须 JDBC 的注册驱动、创建 Connection 连接、配置 Statement 等烦琐过程，大大减少了 JDBC 代码，使开发者只需要专注于 SQL 语句设计即可。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录，反之也可将数据库中的记录转化为 Java 类（对象）。在三层架构开发中，MyBatis 作用在数据访问层，它让数据访问层的开发变得简单、高效。

  2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

 回顾JDBC的使用步骤：

• 1.加载驱动

Class.forName("com.mysql.jdbc.Driver");

• 2.获取连接对象

DiverManerger.getConnection(url,username,password)

• 3.获取执行sql的Statement对象

connection.CreateStatement();

• 4.执行sql语句
• 5.处理结果集
• 6.释放连接

connection.Close()

 与JDBC相比：

1. Mybatis通过参数映射方式，可以将参数灵活的配置在SQL语句中的配置文件中，避免在Java类中配置参数
2. Mybatis通过输出映射机制，将结果集的检索自动映射成相应的Java对象，避免对结果集手工检索
3. Mybatis可以通过Xml配置文件对数据库连接进行管理

 2.1 ORM 框架原理

  Java 程序常常要连接并操作数据库，但两者的数据类型往往并不匹配，Java 是面向对象的语言，Java 语言中的操作的单元是类与对象，而数据库的数据格式是关系类型。为了匹配 Java 面向对象与关系数据库的数据类型，人们发明了 ORM 框架（Object Relational Mapping，对象关系映射），用于将 Java 中的对象映射成数据库中的记录，对象中的属性映射为数据库表中的字段，程序员可使用面向对象的编程方式来操作数据库。例如，在程序代码中添加一个对象，则数据库中相应添加一行记录，在程序代码中删除一个对象，则数据库中相应删除了一条记录。比较常见的ORM框架有 Hibernate、MyBatis。

  ORM 框架的原理如下图1.1所示。其中，CRUD 是在做计算处理时的增加（Create）、读取查询（Retrieve）、更新（Update）和删除（Delete）4个单词的首字母缩写，POJO（Plain Ordinary Java Object）为简单的 Java 对象，实际就是普通 JavaBeans。

 2.2 MyBatis 与 Hibernate 的比较

  Hibernate 框架是“全自动”的 ORM，使用完全的数据库封装机制实现对象和数据库表之间的映射，自动生成与执行 SQL 语句，数据库无关性比较好，方便移植。

  MyBatis 框架是“半自动”的 ORM，需要程序员自行编写SQL语句，MyBatis 再通过映射文件将返回的结果字段映射到指定对象。MyBatis 无法做到数据库无关性，每次只能针对一个数据库做开发。

  与 Hibernate 相比，MyBatis 具有以下几个优点。

• SQL语句与代码分离。只需要在XML映射文件中配置 SQL 语句，而无须在 Java 代码中编写 SQL 语句，给程序的维护带来了很大便利。
• 手写 SQL 语句，灵活方便，查询效率高，能够完成较复杂的查询。
• 采用原生 SQL 语言，无须学习面向对象的 HQL 语言，相对简单易学，容易上手。

 2.3 搭建MyBatis 开发环境

  在项目中使用 MyBatis 的基本步骤导入相关 JAR 包、编写配置文件和映射文件、创建接口、创建实体类，最后是设计 DAO 层的实现类。

  本文使用的 MyBatis 版本为 MyBatis 3.4.5，可在GitHub 网站下载，下载地址是: https://github.com/mybatis/mybatis-3/releases

  下载 mybatis-3.4.5.zip 解压后的文件结构如下图所示。

  要使用 MyBatis， 只需将下载好的 mybatis-3.4.5.zip 解压后的jar文件置于类路径（classpath）中即可。

  如果使用 Maven 来构建项目，则需将下面的依赖代码置于 pom.xml 文件中：

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>x.x.x</version>
</dependency>

3. 第一个 MyBatis 项目

实现步骤：

  （1）在 MySQL 中创建数据库 java2218，创建数据表 user，并添加若干测试用的数据记录，SQL 语句如下：

CREATE DATABASE java2218

CREATE TABLE `user`(
uid INT AUTO_INCREMENT PRIMARY KEY NOT NULL,
uname VARCHAR(20) NOT NULL,
upassword VARCHAR(20) NOT NULL
)
INSERT INTO USER (uname,upassword) VALUES('张三','123'),('李四','456')

  （2）打开 IDEA ，创建一个Java项目，具体创建的步骤，在我本栏目的上一篇博文中已经详细说明，创建好之后的完整目录结构如下：

  （3）配置pom.xml文件，添加项目所需要的 mybatis 依赖，mysql 数据库依赖以及实体类简写的 lombok 依赖

<?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>cn.kgc.mybatis</groupId>
  <artifactId>mybatis01</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>mybatis01</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <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>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version>
    </dependency>
    
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.9</version>
    </dependency>
  </dependencies>
</project>

  （4）为了方便查看控制台输出 SQL 语句，还要配置 log4j，在项目目录src—>main—>resources下创建 log4j.properties 文件，输入内容如下：

log4j.rootLogger=DEBUG,Console

#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.out
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n

log4j.logger.org.apache=ERROR
log4j.logger.org.mybatis=ERROR
log4j.logger.org.springframework=ERROR

#这个需要
log4j.logger.log4jdbc.debug=ERROR
log4j.logger.com.gk.mapper=ERROR
log4j.logger.jdbc.audit=ERROR
log4j.logger.jdbc.resultset=ERROR

#这个打印SQL语句非常重要
log4j.logger.jdbc.sqlonly=DEBUG
log4j.logger.jdbc.sqltiming=ERROR
log4j.logger.jdbc.connection=FATAL

然后再 pom.xml 文件中的 dependencies 元素中添加依赖如下：

   <!--引入log4j日志依赖-->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

  （5）在项目 src—>main—>java 目录下新建包cn.kgc.entity，创建实体类 User 如下：

package com.kgc.entity;
import lombok.Data;

@Data
public class User {
    private Integer uid;
    private String uname;
    private String upassword;
}

  @Data 注解是添加了 lombok 依赖后所使用的，主要作用是提高代码的简洁，使用这个注解可以省去实体类中大量的get()、 set()、 toString()等方法。

点击侧边栏Structure可以打开实体类的结构图，如下图所示：

  （6）在项目目录src—>main—>resources下创建mybatis-config.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>
    <!--数据源环境 default  -->
    <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:///java2218?serverTimezone=UTC&amp;useSSL=false&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="huanghuang"/>
            </dataSource>
        </environment>
    </environments>
    <!--映射文件配置-->
    <mappers>
        <mapper resource="UserMapper.xml"></mapper>
    </mappers>
</configuration>

  通过配置的方式将数据库的配置信息从应用程序中独立出来，由独立的模块管理和配置。Mybatis的数据源配置文件包含数据库驱动、数据库连接地址、用户名密码、事务管理等，还可以配置连接池的连接数、空闲时间等。

mybatis mapper文件映射

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
</mappers>

<!-- 使用映射器接口实现类的完全限定类名
	mybais去加载class对应的接口，然后还会去加载该接口同目录下的同名xml文件 
-->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
</mappers>

<!-- 将包内的映射器接口实现全部注册为映射器   
 使用package元素批量注册Mapper接口
  1.包名和接口所在的包名字一致
  2.mapper文件的名字和接口的名字一致
  3.创建包是使用/分割
-->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

设置资源文件路径

  Maven中默认是只会打包resource下的资源文件。如果我们的文件不放在resource， 则需要通过配置告知Maven

<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
     <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
          <include>**/*.tld</include>
        </includes>
        <filtering>false</filtering>
      </resource>
</resources>

Sql映射文件

  Mybatis中所有数据库的操作都会基于该映射文件和配置的sql语句，在这个配置文件中可以配置任何类型的sql语句。框架会根据配置文件中的参数配置，完成对sql语句以及输入输出参数的映射配置。

mapper-config.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="命名空间">

<select id="方法名" resultMap="返回值类型" parameterType="参数类型">

-- sql语句

</select>

</mapper>

UserMapper.xml 实例：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kgc">
    <select id="selectOne" resultType="com.kgc.entity.User">
        select * from  user  where uid = #{uid}
    </select>
    <select id="selectAll" resultType="com.kgc.entity.User">
        select * from user
    </select>
</mapper>

  （7）创建测试类 TestMyBatis，新建包 com.kgc.mybatis，包下新建类 TestMyBatis，代码如下：

package com.kgc.mybatis;
import com.kgc.entity.User;
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.InputStream;
import java.util.List;

/**
 * @author: mosin
 * @version: v1.0  2023/2/3
 */
public class TestMyBatis {

    public static void main(String[] args) {
        try {

            InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(resourceAsStream);
            System.out.println("factory = " + factory);
            SqlSession sqlSession = factory.openSession();
            // 参数1 ： sql语句的定位标识符
            System.out.println("----------根据id查询用户信息----------");
            User user = sqlSession.selectOne("com.kgc.selectOne", 1);
            System.out.println("user = " + user);

            System.out.println("----------查询用户列表----------");
            List<Object> objects = sqlSession.selectList("com.kgc.selectAll");

            System.out.println("objects = " + objects);

            sqlSession.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

测试结果：

4. MyBatis 的工作流程

  会话工厂SqlSessionFactory通过加载资源文件获取MapConfig.xml配置文件信息，然后生成可以与数据库交互的会话实例SqlSession。会话实例可以根据Mapper配置文件中的Sql配置去执行相应的增删改查操作

执行流程图：

5. 利用属性文件读取数据库连接信息

  上面案例中的 mybatis-config.xml 主配置文件中，关于数据库的连接信息，分别指定了 Java 连接数据库的4大要素：驱动、URL、数据库用户名、密码。

  为了方便对数据库连接的管理，可以快速替换到不同的数据库，连接数据库的4大要素数据一般都是单独存放在一个专门的属性文件中，MyBatis 主配置文件再从这个属性文件中读取这些数据。利用属性文件读取数据库连接信息可以方便更换不同的数据库，只需要修改属性文件或者替换为另外一个属性文件即可，可移植性较好。

实现步骤：

  【1】在项目目录 src—>main—>resources 下创建 jdbc.properties，代码如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/java2218
jdbc.username=root
jdbc.password=root

上述内容包括了数据库连接的四大属性的具体值。

  【2】修改主配置文件 mybatis-config.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>

    <!--引入外部的数据源参数-->
    <properties resource="jdbc.properties"></properties>
    <settings>
        <setting name="logImpl" value="LOG4J"/>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <typeAliases>
        <package name="cn.kgc.mybatis.entity"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <!--使用原始的jdbc进行事务控制，需要手动的完成事务的提交和回滚-->
            <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>
    <!--映射文件配置
      package: 通过包指定mapper文件的位置
      1.xml 文件的名字和接口名字保持一致
      2.xml文件的位置要和接口保持一致
    -->
    <mappers>
       <package name="cn.kgc.mybatis.mapper"/>
    </mappers>
</configuration>

  【3】运行测试，结果不变。将来数据库要更换，只需要更改属性文件 jdbc.properries 的有关信息即可，无需改动配置文件，非常实用。

6. 主配置文件简介

  主配置文件 mybatis-config.xml 用来配置系统运行环境，包含事务管理方式、数据库连接类型与信息、指定映射文件等。除了上面第一个项目用到的一些标签之外，还有其它一些标签（标签也可称为节点或元素），MyBatis 主配置文件的所有主要标签如下所示：

  <configuration>下所有子标签并不是都必须配置，但若需要配置时，必选掌上图所示的 先后顺序 来配置，否则 MyBatis 会报错。

  <properties>标签的作用是将内部的配置转化为外部的配置，从而能够动态地替换内部定义的属性。例如，数据库的连接信息，原来是在内部配置，通过<properties>属性，让系统读取外部的属性文件。

 6.1 setting标签

  <setting> 标签用来改变 Mybatis 运行时的行为，例如开启延迟加载以及二级缓存。启用延迟加载以及二级缓存有利于提高系统的性能，但在小型系统及硬件性能较强的环境下效果并不明显，一般不配置也可以。

  下面代码演示可能用到的一些配置，每一项的作用参见代码注释：

        <settings>
			<!-- 是否开启缓存 -->
			<setting name="cacheEnabled" value="true"/>
			<!-- 是否开启延迟加载,如果开启的话所有关联对象都会延迟加载 -->
			<setting name="lazyLoadingEnabled" value="true"/>
			<!-- 是否启用关联对象属性的延迟加载,如果启用,对任意延迟属性的调用都会
			使用带有延迟加载属性的对象完整加载,否则每种属性都按需加载 -->
			<setting name="aggressiveLazyLoading" value="true"/>		
	   </settings>

 6.2 typeAliases标签

  <typeAliases> 标签的作用是为 Java 的 POJO 类起别名，如果不取别名，映射文件若要引用一个 POJO 实体类，必须要输入全限定性类名，含有包名，显得比较长，用了别名之后引用起来就简单很多。

  例如，实体类 User 的全限定类名是 com.kgc.entity.User，未起别名之前，映射文件的 select 语句块要引用 POJO 类 User 必须使用全限定类名，示例如下：

    <select id="selectOne" resultType="com.kgc.entity.User">
        select * from  user  where uid = #{uid}
    </select>

  在主配置文件 mybatis-config.xml 中定义别名如下：

    <!--设置实体类的别名-->
    <typeAliases>
        <typeAlias type="com.kgc.entity.User" alias="user"></typeAlias>
    </typeAliases>

  上面代码的意思是为全限定类名 com.kgc.entity.User 创建别名 user，定义了别名之后，映射文件中只需使用别名 user 就能引用全限定类 com.kgc.entity.User。这样上例代码可简化如下：

    <select id="selectOne" resultType="user">
        select * from  user  where uid = #{uid}
    </select>

  如果有多个类要使用别名，一种方法是逐个配置别名，多个<typeAlias>示例如下：

    <!--设置实体类的别名-->
    <typeAliases>
        <typeAlias type="com.kgc.entity.User" alias="user"></typeAlias>
        <typeAlias type="com.kgc.entity.Emp" alias="emp"></typeAlias>
        <typeAlias type="com.kgc.entity.Dept" alias="dept"></typeAlias>
    </typeAliases>

  这样固然可以实现目的，但是代码冗余过多，还有个一个办法是通过自动扫描包的形式自定义别名，代码示例如下：

    <!--设置实体类的别名-->
    <typeAliases>
        <!--
            通过包名设置实体类的别名  默认设置的别名是类名首字母小写的名字  User  user
        -->
        <package name="com.kgc.entity"/>
    </typeAliases>

  这样配置后，MyBatis 会自动扫描 package 节点的 name 属性指定的包 com.kgc.entity，并自动将该包下所有实体类以首字母为小写的类名作为别名，例如它会自动给 com.kgc.entity.User 分配一个别名 user，其它类推。

 6.3 typeHandlers标签

  <typeHandlers> 标签的作用是将传入的参数的 javaType ( Java 类型)转换为 jdbcType ( JDBC 类型，对应数据库的数据类型)，反之从数据库读出结果集时将 jdbcType 转换为 javaType。

  MyBatis 提供了大量的默认的内置转换器，可以完成大部分常见的类型转换，但若默认的转换器无法满足要求时，可以自定义转换器。自定义转换器类需实现 TypeHandler 接口或者继承 BaseTypeHandler 类。创建好后需要这样注册：

<typeHandlers>
	<typeHandler handler="com.kgc.utils.MyTypeHandler"/>
</typeHandlers>

  其中 handler 属性指定的类 com.kgc.utils.MyTypeHandler 为自定义的转换器（类），然后<ResultMap> 标签中就可以引用这个转换器了。

 6.4 environments标签

<environments> 标签是环境配置，主要用于数据源的配置。

1．<transactionManager>子标签

配置事务管理器,可以配置 JDBC 和 MANAGED 两种类型。

• JDBC：使用JDBC的事务管理,通过数据源得到的连接来提交或回滚事务。
• MANAGED：使用容器来管理事务。

通常使用 JDBC 事务管理类型，配置方法如下：

    <environments default="development">
        <environment id="development">
            <!--使用原始的jdbc进行事务控制，需要手动的完成事务的提交和回滚-->
            <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>

【注意】将来使用 Spring 整合 MyBatis 后，事务交给 Spring 管理，这部分也不用配置。

2．<dataSource>子标签的类型

  <dataSource> 标签用来配置数据源，即数据库的连接，它有三种类型，UNPOOLED、POOLED、JNDI。

• UNPOOLED
   无连接池，每次请求都重新打开和关闭连接，即每一次都是新的连接，对于大型应用，连接会很频繁，浪费资源，降低效率，一般只用于小型应用。
• POOLED
   连接池，效率较高，响应速度快，通常就使用这种方式。
• JND
   JNDI数据源，通常用于EJB等容器。
   
  通常配置数据源类型为连接池，代码如下所示：

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

 6.5 mappers标签

<mappers>标签用于配置映射文件，指定映射文件的位置，有4种方法。

（1）使用resource属性引入类路径。示例：

<mappers>
	<mapper resource="cn.kgc.mybatis.mapper/UserMapper.xml"/>
</mappers>

若配置文件有多个，可以类似如下配置：

<mappers>
	<mapper resource="cn.kgc.mybatis.mapper/UserMapper.xml"/>
	<mapper resource="cn.kgc.mybatis.mapper/EmpMapper.xml"/>
	<mapper resource="cn.kgc.mybatis.mapper/DeptMapper.xml"/>
</mappers>

（2）使用 url 属性引入本地文件。示例如下：

<mappers>
	<mapper url="file:///E:/cn/kgc/mybatis/mapper/UserMapper.xml"/>
</mappers>

（3）使用 class 属性引入接口类。示例如下：

<mappers>
	<mapper class="cn.kgc.mybatis.mapper.UserMapper"/>
</mappers>

这样配置比较简单，但要满足以下3个条件 。

• 接口名称与映射文件名称一致。
• 接口与映射文件必须在同一个包中。
• 映射文件中<mapper>标签的 namespace 命名空间的值为接口的全限定类名。

<mapper namespace="cn.kgc.mybatis.mapper.UserMapper"/>

（4）使用包名引入

当映射文件较多时，可以不用一个个配置，而是使用如下形式，其中 package 的 name 属性指定映射文件所在的包，该包下的所有映射文件都会被扫描到，具体如下：

    <mappers>
       <package name="cn.kgc.mybatis.mapper"/>
    </mappers>

要使用这种配置，需满足以下4个条件。

• DAO 的实现类采用 mapper 动态代理实现 。
• 映射文件与接口的名称相同。
• 映射文件与接口在同一个包中。
• 映射文件中<mapper>标签的 namespace 命名空间的值为接口的全限定类名。

7. 连接其它数据库

【1】MyBatis连接Oracle数据库

MyBatis连接Oracle与MySQL差别并不大，只是驱动不同，连接字符串url稍有不同。关键步骤如下：

• (1)下载连接Java与Oracle专用jar包并导入到项目。
• (2)把jdbc.properties文件改为下面格式，简单修改一下即可。

jdbc.driver = oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@localhost:1521:orcl
jdbc.username=scott
jdbc.password=orcl

【2】链接 SQL Server 数据库

• (1)下载连接Java与SQL Server专用jar包并导入到项目。
• (2)把jdbc.properties文件改为下面格式，简单修改一下即可。

jdbc.driver = com.microsoft.sqlserver.jdbc.SQLServerDrvier
jdbc.url= jdbc:sqlserver://127.0.0.1:1434;Database=Users
jdbc.username=admin
jdbc.password=123

---

  码文不易，本篇文章就介绍到这里，如果想要学习更多Java系列知识，点击关注博主，博主带你零基础学习Java知识。与此同时，对于日常生活有困扰的朋友，欢迎阅读我的第四栏目：《国学周更—心性养成之路》，学习技术的同时，我们也注重了心性的养成。