Mybatis --02.mybatis核心配置文件mybatis-config.xml

版权声明：转载请注明原始链接 https://blog.csdn.net/sswqzx/article/details/83713201

说明：mybatis环境搭建步骤：

1、创建Maven工程 
2、导入坐标、pom.xml
3、编写必要代码、实体类和持久层接口(domain/Dao)
4、编写核心配置文件mybatis-config.xml
5、编写映射配置文件UserMapper.xml
6、编写测试类test/java/TestMybatis.java

一、Mybatis核心配置文件

1、environments

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>
    <!--
        environments标签：用于配置多个环境（测试环境、生产环境）
            default属性：默认环境的id
        environment标签：配置一个具体的环境
            id属性：一个具体环境的id
        transactionManager标签：指定事务的类型
            type属性：可以取的值有：JDBC|MANAGED
                JDBC:表示从数据源获取数据库连接来提交或回滚事务
                MANAGED:表示把事务交给容器来管理，一般不用
        dataSource标签：配置数据源
            type属性：指定数据源类型，可以取的值有：UNPOOLED|POOLED|JNDI
                UNPOOLED:无连接池的数据源，每次都重新获取数据库连接，使用完后关闭连接
                POOLED:带连接池的数据源
                JNDI:使用JNDI数据源
    -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                 <!--指定驱动类名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!-- 指定连接地址 -->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <!-- 指定用户名 -->
                <property name="username" value="root"/>
                <!-- 指定密码 -->
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
<!--指定映射配置文件的位置、映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
        <mapper resource="com.sswblog.dao/UserMapper.xml"></mapper>
    </mappers>
</configuration>

说明：Mybatis可以配置成适应多种环境、开发、测试、和生产环境、尽管可以配置多个环境、

但每个SqlSessionFactory实列只能选择其一、可以有如下二种方式指定使用哪个环境

方式一：default

添加一个测试环境test、并在default参数中指向test环境

Mybatis-test-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>
    <!--
        environments标签：用于配置多个环境（测试环境、生产环境）
            default属性：默认环境的id
        environment标签：配置一个具体的环境
            id属性：一个具体环境的id
        transactionManager标签：指定事务的类型
            type属性：可以取的值有：JDBC|MANAGED
                JDBC:表示从数据源获取数据库连接来提交或回滚事务
                MANAGED:表示把事务交给容器来管理，一般不用
        dataSource标签：配置数据源
            type属性：指定数据源类型，可以取的值有：UNPOOLED|POOLED|JNDI
                UNPOOLED:无连接池的数据源，每次都重新获取数据库连接，使用完后关闭连接
                POOLED:带连接池的数据源
                JNDI:使用JNDI数据源
    -->
    <environments default="test">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                 <!--指定驱动类名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!-- 指定连接地址 -->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <!-- 指定用户名 -->
                <property name="username" value="root"/>
                <!-- 指定密码 -->
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
        <environment id="test">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"></mapper>
    </mappers>
</configuration>

方式二：build方法

通过build的另一个重载方法来构建sqlSessionFactory

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.Test;
import java.io.InputStream;

/**
 * @ Author     ：ssw.
 * @ Date       ：Created in 20:47 2018/11/4
 */
public class TestMyBatis {
    
    @Test
    public void test(){
        SqlSession sqlSession = null;
        try {
            //加载核心配置文件
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            //创建工厂
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in,"test");
            //获取SqlSession
            sqlSession = sqlSessionFactory.openSession();
            //执行查询语句
            /*
            执行查询语句,selectOne参数解释：
            参数1：语句的唯一标识，由namespace+id组成
            参数2：语句需要的参数
             */
            User user = sqlSession.selectOne("UserMapper.findUserById", 1L);
            System.out.println("user = " + user);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (sqlSession != null){
                sqlSession.close();
            }
        }
    }
}

演示：

A、创建Maven工程--file-new--project--maven--ok

B、导入坐标pom.xml

<dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>
        <!--log4-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>
    </dependencies>

C、编写实体类User.java

package com.sswblog.domain;

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

/**
 * @ Author     ：ssw.
 * @ Date       ：Created in 19:44 2018/11/4
 */
public class User implements Serializable {
    private static final long serialVersionUid = 1L;
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private Date created;
    private Date updated;

    public static long getSerialVersionUid() {
        return serialVersionUid;
    }

    public Long getId() {
        return id;
    }

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

    public String getUserName() {
        return userName;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getSex() {
        return sex;
    }

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

    public Date getBirthday() {
        return birthday;
    }

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

    public Date getCreated() {
        return created;
    }

    public void setCreated(Date created) {
        this.created = created;
    }

    public Date getUpdated() {
        return updated;
    }

    public void setUpdated(Date updated) {
        this.updated = updated;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", birthday=" + birthday +
                ", created=" + created +
                ", updated=" + updated +
                '}';
    }
}

数据库：

D、核心配置文件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>
    <environments default="test">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--指定驱动类名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!-- 指定连接地址 -->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <!-- 指定用户名 -->
                <property name="username" value="root"/>
                <!-- 指定密码 -->
                <property name="password" value="sswqzx"/>
            </dataSource>
        </environment>

    <environment id="test">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
            <property name="username" value="root"/>
            <property name="password" value="sswqzx"/>
        </dataSource>
    </environment>

</environments>
    <!--映射外部配置文件-->
    <mappers>
        <mapper resource="UserMappers.xml"></mapper>
    </mappers>
</configuration>

E、映射配置文件UserMappers.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">
<!--映射文件的作用：用来存放sql语句
    namespace:命名空间
-->
<mapper namespace="UserMapper">
    <!--select标签：表示一条查询的sql语句
        id属性：sql语句的唯一表示，在同一namespace下唯一，通过namespace+id的形式来调用sql语句
        resultType属性：查询语句的结果类型，此处写的是全路径名
        在select标签中写查询的sql语句：#{id}表示接收参数，如果只有一个参数，参数名随便写
    -->
    <select id="findUserById" resultType="com.sswblog.domain.User">
        select * from tb_user where id = #{id}
    </select>
</mapper>

F、编写测试类

package com.sswblog;

import com.sswblog.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 org.junit.Test;
import java.io.InputStream;

/**
 * @ Author     ：ssw.
 * @ Date       ：Created in 20:47 2018/11/4
 */
public class TestMyBatis {

    @Test
    public void test(){
        SqlSession sqlSession = null;
        try {
            //加载核心配置文件
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            //创建工厂
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in,"test");
            //获取SqlSession
            sqlSession = sqlSessionFactory.openSession();
            //执行查询语句
            /*
            执行查询语句,selectOne参数解释：
            参数1：语句的唯一标识，由namespace+id组成
            参数2：语句需要的参数
             */
            User user = sqlSession.selectOne("UserMapper.findUserById", 1L);
            System.out.println("user = " + user);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (sqlSession != null){
                sqlSession.close();
            }
        }
    }
}

2、读取外部属性资源文件

在src/main/resources下创建jdbc.properties

jdbc.properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=sswqzx

在mybatis-config.xml中引入jdbc.properties

<?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"/>
    <!--
        environments标签：用于配置多个环境（测试环境、生产环境）
            default属性：默认环境的id
        environment标签：配置一个具体的环境
            id属性：一个具体环境的id
        transactionManager标签：指定事务的类型
            type属性：可以取的值有：JDBC|MANAGED
                JDBC:表示从数据源获取数据库连接来提交或回滚事务
                MANAGED:表示把事务交给容器来管理，一般不用
        dataSource标签：配置数据源
            type属性：指定数据源类型，可以取的值有：UNPOOLED|POOLED|JNDI
                UNPOOLED:无连接池的数据源，每次都重新获取数据库连接，使用完后关闭连接
                POOLED:带连接池的数据源
                JNDI:使用JNDI数据源
    -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--指定驱动类名-->
                <property name="driver" value="${jdbc.driverClass}"/>
                <!-- 指定连接地址 -->
                <property name="url" value="${jdbc.url}"/>
                <!-- 指定用户名 -->
                <property name="username" value="${jdbc.username}"/>
                <!-- 指定密码 -->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMappers.xml"></mapper>
    </mappers>
</configuration>

 测试类

package com.sswblog;

import com.sswblog.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 org.junit.Test;
import java.io.InputStream;

/**
 * @ Author     ：ssw.
 * @ Date       ：Created in 20:47 2018/11/4
 */
public class TestMyBatis {

    @Test
    public void test(){
        SqlSession sqlSession = null;
        try {
            //加载核心配置文件
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            //创建工厂
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
            //获取SqlSession
            sqlSession = sqlSessionFactory.openSession();
            //执行查询语句
            /*
            执行查询语句,selectOne参数解释：
            参数1：语句的唯一标识，由namespace+id组成
            参数2：语句需要的参数
             */
            User user = sqlSession.selectOne("UserMapper.findUserById", 1L);
            System.out.println("user = " + user);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (sqlSession != null){
                sqlSession.close();
            }
        }
    }
}

 

3、settings设置

mybatis核心配置文件中settings中可以设置参数很多，今天咱们先学习驼峰匹配

经典数据库命名规则：如果多个单词之间，通常使用下划线进行连接。

Java中属性命名规则：驼峰式命名。

前面事例中、我们发现user_name列的值没有查询出来，就是因为默认情况下，不能完成user_name列到userName属性的映射。

方式一：需要在mybatis-config.xml中开启驼峰匹配：

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"/>
    <settings>
        <!--开启驼峰匹配-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!--
        environments标签：用于配置多个环境（测试环境、生产环境）
            default属性：默认环境的id
        environment标签：配置一个具体的环境
            id属性：一个具体环境的id
        transactionManager标签：指定事务的类型
            type属性：可以取的值有：JDBC|MANAGED
                JDBC:表示从数据源获取数据库连接来提交或回滚事务
                MANAGED:表示把事务交给容器来管理，一般不用
        dataSource标签：配置数据源
            type属性：指定数据源类型，可以取的值有：UNPOOLED|POOLED|JNDI
                UNPOOLED:无连接池的数据源，每次都重新获取数据库连接，使用完后关闭连接
                POOLED:带连接池的数据源
                JNDI:使用JNDI数据源
    -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--指定驱动类名-->
                <property name="driver" value="${jdbc.driverClass}"/>
                <!-- 指定连接地址 -->
                <property name="url" value="${jdbc.url}"/>
                <!-- 指定用户名 -->
                <property name="username" value="${jdbc.username}"/>
                <!-- 指定密码 -->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMappers.xml"></mapper>
    </mappers>
</configuration>

UserMappers.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">
<!--映射文件的作用：用来存放sql语句
    namespace:命名空间
-->
<mapper namespace="UserMapper">
    <!--select标签：表示一条查询的sql语句
        id属性：sql语句的唯一表示，在同一namespace下唯一，通过namespace+id的形式来调用sql语句
        resultType属性：查询语句的结果类型，此处写的是全路径名
        在select标签中写查询的sql语句：#{id}表示接收参数，如果只有一个参数，参数名随便写
    -->
    <select id="findUserById" resultType="com.sswblog.domain.User">
        select * from tb_user where id = #{id}
    </select>
</mapper>

测试类：

package com.sswblog;

import com.sswblog.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 org.junit.Test;
import java.io.InputStream;

/**
 * @ Author     ：ShaoWei Sun.
 * @ Date       ：Created in 20:47 2018/11/4
 */
public class TestMyBatis {
    @Test
    public void test(){
        SqlSession sqlSession = null;
        try {
            //加载核心配置文件
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            //创建工厂
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
            //获取SqlSession
            sqlSession = sqlSessionFactory.openSession();
            //执行查询语句
            /*
            执行查询语句,selectOne参数解释：
            参数1：语句的唯一标识，由namespace+id组成
            参数2：语句需要的参数
             */
            User user = sqlSession.selectOne("UserMapper.findUserById", 1L);
            System.out.println("user = " + user);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (sqlSession != null){
                sqlSession.close();
            }
        }
    }
}

方式二：在UserMapper.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">
<!--映射文件的作用：用来存放sql语句
    namespace:命名空间
-->
<mapper namespace="UserMapper">
    <!--select标签：表示一条查询的sql语句
        id属性：sql语句的唯一表示，在同一namespace下唯一，通过namespace+id的形式来调用sql语句
        resultType属性：查询语句的结果类型，此处写的是全路径名
        在select标签中写查询的sql语句：#{id}表示接收参数，如果只有一个参数，参数名随便写
    -->
    <select id="findUserById" resultType="com.sswblog.domain.User">
        select *,user_name as userName from tb_user where id = #{id}
    </select>
</mapper>

4、typeAliases

typeAliases表示类型别名，是为 Java 类型取的一个短的名字，存在的意义仅在于用来减少类完全限定名的冗余。

方式一：typeAliase （在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"/>
    <settings>
        <!--开启驼峰匹配-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <typeAliases>
        <typeAlias type="cn.itcast.domain.User" alias="User"/>
    </typeAliases>
    <!--
        environments标签：用于配置多个环境（测试环境、生产环境）
            default属性：默认环境的id
        environment标签：配置一个具体的环境
            id属性：一个具体环境的id
        transactionManager标签：指定事务的类型
            type属性：可以取的值有：JDBC|MANAGED
                JDBC:表示从数据源获取数据库连接来提交或回滚事务
                MANAGED:表示把事务交给容器来管理，一般不用
        dataSource标签：配置数据源
            type属性：指定数据源类型，可以取的值有：UNPOOLED|POOLED|JNDI
                UNPOOLED:无连接池的数据源，每次都重新获取数据库连接，使用完后关闭连接
                POOLED:带连接池的数据源
                JNDI:使用JNDI数据源
    -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--指定驱动类名-->
                <property name="driver" value="${jdbc.driverClass}"/>
                <!-- 指定连接地址 -->
                <property name="url" value="${jdbc.url}"/>
                <!-- 指定用户名 -->
                <property name="username" value="${jdbc.username}"/>
                <!-- 指定密码 -->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMappers.xml"></mapper>
    </mappers>
</configuration>

UserMappers.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">
<!--映射文件的作用：用来存放sql语句
    namespace:命名空间
-->
<mapper namespace="UserMapper">
    <!--select标签：表示一条查询的sql语句
        id属性：sql语句的唯一表示，在同一namespace下唯一，通过namespace+id的形式来调用sql语句
        resultType属性：查询语句的结果类型，此处写的是全路径名
        在select标签中写查询的sql语句：#{id}表示接收参数，如果只有一个参数，参数名随便写
    -->
    <!--<select id="findUserById" resultType="com.sswblog.domain.User">-->
    <select id="findUserById" resultType="User">
        select *,user_name as userName from tb_user where id = #{id}
    </select>
</mapper>

缺点：每个实体类都要配置

方式二：package

扫描该包下所有类，别名就是类名，大小写不敏感，建议使用的时候和类名一致。

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"/>
    <settings>
        <!--开启驼峰匹配-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <typeAliases>
        <!--<typeAlias type="cn.itcast.domain.User" alias="User"/>-->
        <package name="cn.itcast.domain"/>
    </typeAliases>
    <!--
        environments标签：用于配置多个环境（测试环境、生产环境）
            default属性：默认环境的id
        environment标签：配置一个具体的环境
            id属性：一个具体环境的id
        transactionManager标签：指定事务的类型
            type属性：可以取的值有：JDBC|MANAGED
                JDBC:表示从数据源获取数据库连接来提交或回滚事务
                MANAGED:表示把事务交给容器来管理，一般不用
        dataSource标签：配置数据源
            type属性：指定数据源类型，可以取的值有：UNPOOLED|POOLED|JNDI
                UNPOOLED:无连接池的数据源，每次都重新获取数据库连接，使用完后关闭连接
                POOLED:带连接池的数据源
                JNDI:使用JNDI数据源
    -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--指定驱动类名-->
                <property name="driver" value="${jdbc.driverClass}"/>
                <!-- 指定连接地址 -->
                <property name="url" value="${jdbc.url}"/>
                <!-- 指定用户名 -->
                <property name="username" value="${jdbc.username}"/>
                <!-- 指定密码 -->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"></mapper>
    </mappers>
</configuration>

UserMappers.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">
<!--映射文件的作用：用来存放sql语句
    namespace:命名空间
-->
<mapper namespace="UserMapper">
    <!--select标签：表示一条查询的sql语句
        id属性：sql语句的唯一表示，在同一namespace下唯一，通过namespace+id的形式来调用sql语句
        resultType属性：查询语句的结果类型，此处写的是全路径名
        在select标签中写查询的sql语句：#{id}表示接收参数，如果只有一个参数，参数名随便写
    -->
    <!--<select id="findUserById" resultType="com.sswblog.domain.User">-->
    <select id="findUserById" resultType="User">
        select *,user_name as userName from tb_user where id = #{id}
    </select>
</mapper>

内置的类型别名：

别名	映射的类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
object	Object
map	Map
hashmap	HashMap
list	List
arraylist	ArrayList
collection	Collection
iterator	Iterator

在UserMappers.xml中增加一条根据id查询用户名的sql语句：

UserMappers.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">
<!--映射文件的作用：用来存放sql语句
    namespace:命名空间
-->
<mapper namespace="UserMapper">
    <!--select标签：表示一条查询的sql语句
        id属性：sql语句的唯一表示，在同一namespace下唯一，通过namespace+id的形式来调用sql语句
        resultType属性：查询语句的结果类型，此处写的是全路径名
        在select标签中写查询的sql语句：#{id}表示接收参数，如果只有一个参数，参数名随便写
    -->
    <select id="findUserById" resultType="User">
        select * from tb_user where id = #{id}
    </select>
    
    <select id="findUserNameById" resultType="string">
        SELECT user_name from tb_user where id = #{id}
    </select>
</mapper>

在TestMyBatis中编写单元测试方法：

package com.sswblog;

import com.sswblog.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 org.junit.Test;
import java.io.InputStream;

/**
 * @ Author     ：ShaoWei Sun.
 * @ Date       ：Created in 20:47 2018/11/4
 */
public class TestMyBatis {
    @Test
    public void test(){
        SqlSession sqlSession = null;
        try {
            //加载核心配置文件
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            //创建工厂
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
            //获取SqlSession
            sqlSession = sqlSessionFactory.openSession();
            //执行查询语句
            /*
            执行查询语句,selectOne参数解释：
            参数1：语句的唯一标识，由namespace+id组成
            参数2：语句需要的参数
             */
            User user = sqlSession.selectOne("UserMapper.findUserById", 1L);
            System.out.println("user = " + user);

            String userName = sqlSession.selectOne("UserMapper.findUserNameById", 1L);
            System.out.println(userName);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (sqlSession != null){
                sqlSession.close();
            }
        }
    }
}

5、mappers

mybatis核心配置文件Mappers标签是引入映射文件