ORM框架之Mybatis（一）基于mapper配置增删改查

Mybatis是现在非常流行的SSM框架中的M部分，Mybatis也是一个主流的ORM框架，在项目中用来处理持久层数据。

一、Mybatis框架介绍及使用

1.1 mybatis框架概述：

      mybatis是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。 mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射为java对象并返回。 采用ORM思想解决了实体和数据库映射的问题，对jdbc进行了封装，屏蔽了jdbc api底层访问细节，使我们不用与jdbc api打交道，就可以完成对数据库的持久化操作。

1.2 从 jdbc编程说起

1.2.1 使用jdbc处理持久层

public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		try {
			// 加载数据库驱动
			Class.forName("com.mysql.jdbc.Driver");
			// 通过驱动管理类获取数据库链接
			connection =DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8","root", "root");
			// 定义sql语句 ?表示占位符
			String sql = "select * from user where username = ?";

			// 获取预处理
			preparedStatement = connection.prepareStatement(sql);
			// 设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
			preparedStatement.setString(1, "王五");
			// 向数据库发出sql执行查询，查询出结果集
			resultSet = preparedStatement.executeQuery();
			// 遍历查询结果集
			while (resultSet.next()) {
				System.out.println(resultSet.getString("id") + " " + resultSet.getString("username"));
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 释放资源
			if (resultSet != null) {
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {

					e.printStackTrace();
				}
			}
		}
	}

上边使用jdbc的原始方法（未经封装）实现了查询数据库表记录的操作。

1.2.2 jdbc问题分析

1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

2、Sql语句在代码中硬编码，造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

3、使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。

4、对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便。

二，Mybatis上场

2.1 搭建Mybatis开发环境

使用maven引入mybatis依赖

可以从mybatis官网查看mybatis依赖坐标：https://mybatis.org/mybatis-3/

在首页选择中文：利用官网可以快速入门

2.2 创建maven工程mybatis01

 2.2.1 pom文件，jar包依赖导入

    4.0.0

    com.xiaomifeng1010
    day01_mybatis
    1.0-SNAPSHOT
    jar

    
        
            org.mybatis
            mybatis
            3.4.5
        
        
            mysql
            mysql-connector-java
            5.1.6
        
        
            log4j
            log4j
            1.2.12
        
        
            junit
            junit
            4.10
        
    

2.2.2 编写实体类User以及IUserdao接口

package com.xiaomifeng1010.domain;

import java.io.Serializable;
import java.util.Date;

public class User implements Serializable{

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

 IUserDao接口就是我们的持久层接口（也可以写成UserDao或者UserMapper）,具体代码如下

package com.xiaomifeng1010.dao;

import java.util.List;

import com.xiaomifeng1010.domain.User;

/**
 * 用户的持久层接口
 */
public interface IUserDao {

    /**
     * 查询所有操作
     * @return
     */
    List findAll();
}

2.2.3 编写持久层接口的映射文件IUserDao.xml

要求： 创建位置：必须和持久层接口在相同的包中。

名称：必须以持久层接口名称命名文件名，扩展名是.xml

    
    
        select * from user
    

2.2.4 编写SqlMapConfig.xml配置文件

注意mybatis的配置文件和mapper映射文件的xml约束是不同的

mapper文件的约束：

        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

而mybatis的配置文件的约束为：

        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

2.2.5 配置日志文件log4j.properties

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

2.2.6 编写测试文件：

package com.xiaomifeng1010.test;

import com.xiaomifeng1010.dao.IUserDao;
import com.xiaomifeng1010.domain.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.InputStream;
import java.util.List;

/**
 * mybatis的入门案例
 */
public class MybatisTest {

    /**
     * 入门案例
     * @param args
     */
    public static void main(String[] args)throws Exception {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //5.使用代理对象执行方法
        List users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }
}

2.4 mybatis基于注解的使用

实际开发中，简单的增删改查操作，使用注解的方式会更常见，当然复杂的sql查询，还是会结合mapper.xml文件以配置的形式。

2.4.1 使用注解做增删改查，需要改动配置SqlMapConfig.xml

将之前的mapper标签中的标记配置文件位置的resource属性，改为class

 

2.4.2 在IUserDao接口中添加注解

/** * 
* 
Title: IUserDao
 
* 
Description: 用户的持久层操作
 public interface IUserDao { 
/** 
* 查询所有用户 
* @return 
*/
 @Select("select * from user")
 List findAll();
 }

注意事项：在使用基于注解的Mybatis配置时，请移除xml的映射配置（IUserDao.xml）。

三、基于代理Dao实现CRUD操作

使用要求： 1、持久层接口和持久层接口的映射配置必须在相同的包下

2、持久层映射配置中mapper标签的namespace属性取值必须是持久层接口的全限定类名

3、SQL语句的配置标签,,,的id属性必须和持久层接口的方法名相同。

3.1 增删改查操作：

3.1.1在IUserDao接口添加相应的方法（增删改查以及统计的方法）

 /**
 * 用户的持久层接口
 */
public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    List findAll();

    /**
     * 保存用户
     * @param user
     */
    void saveUser(User user);

    /**
     * 更新用户
     * @param user
     */
    void updateUser(User user);

    /**
     * 根据Id删除用户
     * @param userId
     */
    void deleteUser(Integer userId);

    /**
     * 根据id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);

    /**
     * 根据名称模糊查询用户信息
     * @param username
     * @return
     */
    List findByName(String username);

    /**
     * 查询总用户数
     * @return
     */
    int findTotal();

}

3.1.2 在IUserDao.xml映射配置文件中配置

select * from user; select last_insert_id(); insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday}); update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id=#{id} delete from user where id = #{uid} select * from user where id = #{uid} select * from user where username like #{name} select count(id) from user;

细节： resultType属性： 用于指定结果集的类型。

parameterType属性：用于指定传入参数的类型。

sql语句中使用#{}字符： 它代表占位符，相当于原来jdbc部分所学的?，都是用于执行语句时替换实际的数据。 具体的数据是由#{}里面的内容决定的。 #{}中内容的写法：当数据类型是基本类型，此处可以随意写。当保存方法的参数是 一个User对象，此处要写User对象中的属性名称。 它用的是ognl表达式。

ognl表达式： 它是apache提供的一种表达式语言，全称是： Object Graphic Navigation Language 对象图导航语言 它是按照一定的语法格式来获取数据的。 语法格式就是使用 #{对象.对象}的方式

#{user.username}它会先去找user对象，然后在user对象中找到username属性，并调用getUsername()方法把值取出来。但是我们在parameterType属性上指定了实体类名称，所以可以省略user.而直接写username。

我们在配置文件中没有加入%来作为模糊查询的条件，所以在传入字符串实参时，就需要给定模糊查询的标识%。配置文件中的#{username}也只是一个占位符，所以SQL语句显示为“？”

3.1.3 编写测试方法

package com.itheima.test;

import com.itheima.dao.IUserDao;
import com.itheima.dao.impl.UserDaoImpl;
import com.itheima.domain.User;
import org.apache.ibatis.io.Resources;
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.InputStream;
import java.util.Date;
import java.util.List;

/**
 * 测试mybatis的crud操作
 */
public class MybatisTest {

    private InputStream in;
    private IUserDao userDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用工厂对象，创建dao对象
        userDao = new UserDaoImpl(factory);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
//我们在实现增删改时一定要去控制事务的提交，那么在mybatis中如何控制事务提交呢？ 可以使
//用:session.commit();来实现事务提交
        session.commit();
        //6.释放资源
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        //5.执行查询所有方法
        List users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }

    }
    /**
     * 测试保存操作
     */
    @Test
    public void testSave(){
        User user = new User();
        user.setUsername("xiaomifeng1010");
        user.setAddress("湖北省襄陽市");
        user.setSex("男");
        user.setBirthday(new Date());
        System.out.println("保存操作之前："+user);
        //5.执行保存方法
        userDao.saveUser(user);

        System.out.println("保存操作之后："+user);
    }

    /**
     * 测试更新操作
     */
    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(50);
        user.setUsername("罗山仔");
        user.setAddress("广东省广州市");
        user.setSex("男");
        user.setBirthday(new Date());

        //5.执行保存方法
        userDao.updateUser(user);
    }

    /**
     * 测试删除操作
     */
    @Test
    public void testDelete(){
        //5.执行删除方法
        userDao.deleteUser(54);
    }

    /**
     * 测试删除操作
     */
    @Test
    public void testFindOne(){
        //5.执行查询一个方法
        User  user = userDao.findById(50);
        System.out.println(user);
    }

    /**
     * 测试模糊查询操作
     */
    @Test
    public void testFindByName(){
        //5.执行查询一个方法
        List users = userDao.findByName("%王%");
        for(User user : users){
            System.out.println(user);
        }
    }

    /**
     * 测试查询总记录条数
     */
    @Test
    public void testFindTotal(){
        //5.执行查询一个方法
        int count = userDao.findTotal();
        System.out.println(count);
    }



}

模糊查询的另一种配置方式

第一步：修改SQL语句的配置，配置如下：

 
 
select * from user where username like '%${value}%' 

我们在上面将原来的#{}占位符，改成了${value}。注意如果用模糊查询的这种写法，那么${value}的写法就是固定的，不能写成其它名字。

测试模糊查询的方法，做小幅度改动

/** 
* 测试模糊查询操作 
*/ 
@Test
 public void testFindByName(){ 
//5.执行查询一个方法 
List users = userDao.findByName("王"); 
for(User user : users){
 System.out.println(user);
 } 
}

可以发现，我们在程序代码中就不需要加入模糊查询的匹配符%了，这两种方式的实现效果是一样的，但执行的语句是不一样的。

3.2 #{}与${}的区别

#{}表示一个占位符号 通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}表示拼接sql串 通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value。

3.3 模糊查询的${value}源码分析

我们一起来看TextSqlNode类的源码：

这就说明了源码中指定了读取的key的名字就是”value”，所以我们在绑定参数时就只能叫value的名字了。

 测试方法中的findTotal是使用聚合函数进行记录条数查询。

3.4 Mybatis与JDBC编程的比较

1.数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。 解决： 在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。

2.Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。 解决： 将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

3.向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数对应。 解决： Mybatis自动将java对象映射至sql语句，通过statement中的parameterType定义输入参数的类型。

4.对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。 解决： Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型。

四、Mybatis的参数深入

4.1 parameterType配置参数

4.1.1 使用说明

已经介绍了SQL语句传参，使用标签的parameterType属性来设定。该属性的取值可以是基本类型，引用类型（例如:String类型），还可以是实体类类型（POJO类）。同时也可以使用实体类的包装类，接下来将介绍如何使用实体类的包装类作为参数传递

4.1.2 注意事项

基本类型和String我们可以直接写类型名称，也可以使用包名.类名的方式，例如：java.lang.String。 实体类类型，目前我们只能使用全限定类名。 究其原因，是mybaits在加载时已经把常用的数据类型注册了别名，从而我们在使用时可以不写包名，而我们的是实体类并没有注册别名，所以必须写全限定类名。

这些都是支持的默认别名。我们也可以从源码角度来看它们分别都是如何定义出来的。 可以参考TypeAliasRegistery.class的源码。

4.2 传递pojo包装对象

开发中通过pojo传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。 Pojo类中包含pojo。

需求：根据用户名查询用户信息，查询条件放到QueryVo的user属性中。

4.2.1 在domain包下创建QueryVo类

public class QueryVo {

    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

4.2.2 编写持久层接口，添加findUserByVo方法。

public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    List findAll();

    /**
     * 保存用户
     * @param user
     */
    void saveUser(User user);

    /**
     * 更新用户
     * @param user
     */
    void updateUser(User user);

    /**
     * 根据Id删除用户
     * @param userId
     */
    void deleteUser(Integer userId);

    /**
     * 根据id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);

    /**
     * 根据名称模糊查询用户信息
     * @param username
     * @return
     */
    List findByName(String username);

    /**
     * 查询总用户数
     * @return
     */
    int findTotal();

    /**
     * 根据queryVo中的条件查询用户
     * @param vo
     * @return
     */
    List findUserByVo(QueryVo vo);
}

4.2.3 持久层接口的映射文件IUserDao中添加findUserByVo的映射

 
    
        select * from user where username like #{user.username}
    

4.2.4 测试类MybatisTest中添加对应测试方法。

  /**
     * 测试使用QueryVo作为查询条件
     */
    @Test
    public void testFindByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUserName("%王%");
        vo.setUser(user);
        //5.执行查询一个方法
        List users = userDao.findUserByVo(vo);
        for(User u : users){
            System.out.println(u);
        }
    }

五、Mybatis的输出结果封装
5.1 resultType配置结果类型

resultType属性可以指定结果集的类型，它支持基本类型和实体类类型。 我们在前面的CRUD案例中已经对此属性进行过应用了。 需要注意的是，它和parameterType一样，如果注册过类型别名的，可以直接使用别名。没有注册过的必须使用全限定类名。例如：我们的实体类此时必须是全限定类名（后边会讲解如何配置实体类的别名） 同时，当是实体类名称是，还有一个要求，实体类中的属性名称必须和查询语句中的列名保持一致，否则无法实现封装。

5.1.1 基本类型示例
5.1.1.1 Dao接口

/** 
* 查询总记录条数
 * @return 
*/

int findTotal();

5.1.1.2 映射配置

 

 
select count(*) from user;
 

5.1.2 实体类类型示例
5.1.2.1 Dao接口

/** 
* 查询所有用户 
* @return 
*/ 
List findAll();

5.1.2.2 映射配置

 

 select * from user
 

5.1.3 特殊情况示例

5.1.3.1 修改domain包下实体类User

实体类代码如下：(此时的实体类属性和数据库表的列名已经不一致了) 

public class User implements Serializable {

    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

    public Date getUserBirthday() {
        return userBirthday;
    }

    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAddress='" + userAddress + '\'' +
                ", userSex='" + userSex + '\'' +
                ", userBirthday=" + userBirthday +
                '}';
    }
}

5.1.3.2 IUserDao接口不变

/** 
* 查询所有用户
 * @return 
*/ 
List findAll();

5.1.3.3 映射配置IUserDao.xml

  
select * from user 

5.1.3.4 测试查询结果

 /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        //5.执行查询所有方法
        List users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }

    }

控制台输出：

但是部署在linux服务器时，实体类的属性（如userName）对应数据表中的字段(username）不一致会出错

此时可以通过查询时设置数据表中字段的别名，将别名设置和实体类属性一致

5.1.3.5 修改映射配置（使用别名查询 ）

  
select id as userId,username as userName,birthday as userBirthday, sex as userSex,address as userAddress from user 

运行结果：

但是如果数据表字段较多，这种方式需要设置过多别名，在sql语句中直接写，会导致sql语句过长，非常麻烦。这时就需要使用mybatis提供的一个非常强大的标签resultmap

5.2 resultMap结果类型

resultMap标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。 在select标签中使用resultMap属性指定引用即可。同时resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。

5.2.1 定义resultMap

修改IUserDao.xml配置文件：

    
    
        
        
        
        
        
        
        
    


    
    
        
        select * from user;
    

    
    
        
        
            select last_insert_id();
        
        insert into user(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#{userBirthday});
    

    
    
        update user set username=#{userName},address=#{userAddress},sex=#{userAex},birthday=#{userBirthday} where id=#{userId}
    

    
    
        delete from user where id = #{uid}
    
    
    
    
        select * from user where id = #{uid}
    

    
    
          select * from user where username like #{name}
        
   

    
    
        select count(id) from user;
    

    
    
        select * from user where username like #{user.username}
    

resultmap标签说明：

type属性：指定实体类的全限定类名

id属性：给定一个唯一标识，是给查询select标签引用用的。

id标签：用于指定主键字段

result标签：用于指定非主键字段

column属性：用于指定数据库列名

property属性：用于指定实体类属性名称

5.2.2测试testFindAll()方法结果

六、SqlMapConfig.xml配置文件
6.1 配置内容
6.1.1 SqlMapConfig.xml中配置的内容和顺序

6.2 properties（属性）

在使用properties标签配置时，我们可以采用两种方式指定属性配置。
6.2.1 第一种

6.2.2 第二种
6.2.2.1 在classpath下定义jdbcConfig.properties文件

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

6.2.2.2 properties标签配置

6.2.3 此时我们的sqlMapconfig.xml配置文件中的dataSource标签就变成了引用上面的配置

6.3 typeAliases（类型别名）

Mybatis支持的默认别名，我们也可以采用自定义别名方式来开发。
6.3.1 自定义别名： 

在SqlMapConfig.xml中配置：

6.4 mappers（映射器）
6.4.1

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

6.4.2

使用mapper接口类路径 如：

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

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

如：

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