Mybatis单表操作

• 能够完成单表的CRUD操作

• 掌握mybatis框架的输入输出映射

• 掌握mybatis框架在Dao层的开发

• 掌握sqlMapConfig.xml中常用标签（properties、typeAliases、mappers）

mybatis框架实现CRUD操作

提示

• mybatis执行增删改的时候，会默认返回影响的行数
• 当映射文件只有一个基本数据类型时，占位符的名字可以随便写

需求

实现用户表（user）的增、删、改、查操作。

1. 根据用户Id查询用户

2. 根据用户名称模糊查询用户

3. 新增用户

4. 根据用户Id修改用户

5. 根据用户Id删除用户

需求实现

环境搭建

创建项目

配置pom.xml文件，加入依赖

• mybatis框架包

• 数据库驱动包

• log4j日志包

• junit单元测试包

<?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>Test</groupId>
    <artifactId>mybatis_crud</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <!-- mybatis版本号 -->
        <mybatis.version>3.4.5</mybatis.version>
        <!-- mysql版本 -->
        <mysql.version>5.1.30</mysql.version>
        <!-- log4j日志包版本 -->
        <slf4j.version>1.7.7</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <!-- junit版本 -->
        <junit.version>4.12</junit.version>
    </properties>

    <dependencies>
        <!-- mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- mysql数据库依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- log4j日志包 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- junit依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
    </dependencies>


</project>

log4j.properties

# Global logging configuration
log4j.rootLogger=DEBUG, stdout

# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

编写用户实体类对象

package com.po;

public class User {

    private int id;
    private String username;
    private String birthday;
    private String sex;
    private String address;

    public User() {
    }

    public User(int id, String username, String birthday, String sex, String address) {
        this.id = id;
        this.username = username;
        this.birthday = birthday;
        this.sex = sex;
        this.address = address;
    }

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String 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 + '\'' +
                '}';
    }
}

编写用户mapper接口

package com.dao;

import com.po.User;

import java.util.List;

public interface UserDao {

    List<User> findAll();

    List<User> findByName(String username);

    int insert(User user);

    int update(User user);

    int delete(int id);
}

编写数据库连接池配置文件

<?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配置环境数据库使用哪个连接，不能乱写-->
    <environments default="mysql">
        <!--配置具体连接到哪一个数据库，不能乱写-->
        <environment id="mysql">
            <!--transactionManager，配置事物控制类型为JDBC-->
            <transactionManager type="JDBC"/>
            <!--配置数据库连接池
                       POOLED,mybatis内置的数据库连接池（推荐使用）
                       UNPOOLED,不使用连接池
                       JNDI,使用服务器tomcat容器的数据库连接池
           -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/zzw?characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--关联接口映射配置文件-->
    <mappers>
        <!--映射com/itheima/dao/IUserDao.xml接口实现配置文件-->
        <mapper resource="dao/map/UserDaoMap.xml"/>
    </mappers>

</configuration>

编写用户mapper映射文件

mybatis框架针对数据库操作：新增/修改/删除/查询，提供了对应的标签： insert/update/delete/select标签放置

根据用户Id查询用户，说明：
​ select标签：放置查询sql语句
​ id：唯一标识名称，与接口方法名称一致
​ parameterType：输入参数类型，与接口方法形参类型一致
​ resultType：返回值类型（暂时注意：它是po类的全限定名称），与接口方法返回值类型一致
​ #{id}：占位符，相当于jdbc中的问号

使用字符串拼接符${}拼接参数（不建议使用，有sql注入风险）

<select id="findByName" resultType="com.po.User" parameterType="string">
    <!-- select * from user where username like #{username}-->
    select * from user where username like "%${value}%"
</select>

占位符#{}与字符串拼接符${}区别【重点】

1.占位符	#{}	当参数传递的是java简单类型（八种基本类型+字符串String）的时候，花括号中的内容可以是任意字符串
2.字符串拼接符	${}	当参数传递的是java简单类型（八种基本类型+字符串String）的时候，花括号中的内容只能是value
3.	#{}、${}	当参数传递的pojo类型的时候，花括号中的内容都是pojo的属性

​

<?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="com.dao.UserDao">


    <select id="findAll" resultType="com.po.User">
        select * FROM user
    </select>

    <select id="findByName" resultType="com.po.User" parameterType="string">
        select * from user where username like #{username}
        <!--      select * from user where username like "%${value}%"-->
    </select>

    <insert id="insert" parameterType="com.po.User">
        insert into user value (null ,#{username},#{birthday},#{sex},#{address})
    </insert>

    <update id="update" parameterType="com.po.User">
        update user set username = #{username},birthday=#{birthday} ,sex=#{sex},address=#{address} where id=#{id}
    </update>


    <delete id="delete" parameterType="int">
        delete  from user where id= #{int}
    </delete>

</mapper>

提交事务

注意事项：java程序代码执行成功，但是数据库中并没有新增记录。原因是没有提交事务，在对数据库的更新操作中（增、删、改）要求提交事务。

方式一：手动提交事务

/**
* 手动提交事务
*/
sqlSession.commit();

方式二：自动提交事务

	/**
     * 创建SqlSession，指定自动提交事务。true：自动提交；false：不提交。默认是false
     */
    SqlSession sqlSession = sqlSessionFactory.openSession(true);

说明：自动提交的特点，只要操作一完成，立即提交。如果在同一个方法中，有多个数据库操作，需要使用手动提交的方式。

测试

import com.dao.UserDao;
import com.po.User;
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;
import java.util.List;

public class App {

    @Test
    public void testFindAll() {
        InputStream resourceAsStream = App.class.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

    @Test
    public void testfindByName() {
        InputStream resourceAsStream = App.class.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> users = userDao.findByName("王");
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }


    @Test
    public void testInsert() throws Exception {
        InputStream resourceAsStream = App.class.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder sqlsessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory build = sqlsessionFactoryBuilder.build(resourceAsStream);
        SqlSession sqlSession = build.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User user = new User();
        user.setUsername("xxx");
        user.setBirthday("2018-08-08");
        user.setAddress("广州");
        user.setSex("男");
        int insert = userDao.insert(user);
        System.out.println(insert);

        sqlSession.commit();
        sqlSession.close();
        resourceAsStream.close();
    }

    @Test
    public void testUpdate() throws Exception {
        InputStream resourceAsStream = App.class.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory build = sqlSessionFactoryBuilder.build(resourceAsStream);
        SqlSession sqlSession = build.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User user = new User();
        user.setId(50);
        user.setUsername("xxx");
        user.setBirthday("2008-08-08");
        user.setAddress("广州");
        user.setSex("男");

        int i = userDao.update(user);
        System.out.println(i);

        sqlSession.commit();
        sqlSession.close();
        resourceAsStream.close();
    }

    @Test
    public void testDelete() throws Exception {
        InputStream resourceAsStream = App.class.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        int i = userDao.delete(50);
        System.out.println(i);

        sqlSession.commit();
        sqlSession.close();
        resourceAsStream.close();
    }
}

查询数据库维护的主键值

说明：当数据库表中，主键字段值由数据库维护（比如mysql中的自增长），则不需要我们传递。那么在新增完一条记录以后，如何获取到数据库维护的主键值呢？

方式一：selectKey

<?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="com.dao.UserDao">
    <!--新增用户，说明：
    1.获取数据库维护的主键值
    2.selectKey：
        作用：查询数据库维护的主键值
        属性：
            keyColumn：数据库主键字段
            keyProperty：实体类中的属性（与主键字段对应）
            resultType：主键数据类型
            order：在insert语句执行前，还是执行后获取主键值。BEFORE：在insert执行前；AFTER：在insert语句执行后
-->
    <insert id="insert" parameterType="com.po.User">
        <selectKey resultType="int" order="AFTER" keyColumn="id" keyProperty="id">
            select LAST_INSERT_ID()
        </selectKey>
        insert into user (username,birthday,sex,address)value (#{username},#{birthday},#{sex},#{address})
    </insert>


</mapper>

思考：什么时候使用BEFORE？

答案：oracle数据库。

<!-- 新增用户，说明：
   insert：放置新增sql语句
   -->
<insert id="insertUser" parameterType="cn.itheima.po.User">

    <!-- 获取数据库维护的主键值，说明：
     selectKey:查询主键值
     keyColumn：指定主键字段
     keyProperty：指定主键属性
     resultType：指定主键类型
     order：指定在Insert语句执行前，还是执行后获取主键值。
      BEFORE：insert执行前
      AFTER：insert语句执行后
     -->
    <selectKey keyColumn="id" keyProperty="id" resultType="int"  order="BEFORE">
        select seq.nextval from dual
    </selectKey>
    insert into `user`(id,username,birthday,sex,address) 
    values(#{id},#{username},#{birthday},#{sex},#{address})	
</insert>

方式二：直接在insert标签中增加属性（不推荐）

<insert id="addUser" parameterType="cn.po.User"
useGeneratedKeys="true" keyColumn="id" keyProperty="id">  
    insert into `user`(username,birthday,sex,address)
    values(#{username},#{birthday},#{sex},#{address})
</insert>

说明：直接在insert标签中增加属性的方式，只适合于支持自动增长主键类型的数据库，比如mysql。

mybatis输入输出映射

parameterType输入映射

java简单类型

参考：

<delete id="delete" parameterType="int">
    delete  from user where id= #{int}
</delete>

pojo类型

参考：

<insert id="insert" parameterType="com.po.User">
    insert into user value (null ,#{username},#{birthday},#{sex},#{address})
</insert>

pojo包装类型

定义：pojo包装类型，就是在pojo中包含了其它的pojo。通常用于接收综合查询条件。

需求

使用pojo包装类型，实现根据用户名称模糊查询用户。

需求实现

编写pojo包装类型

package com.po;

public class QueryPo {

    private User user;

    public QueryPo() {
    }

    public QueryPo(User user) {
        this.user = user;
    }

    public User getUser() {
        return user;
    }

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

    @Override
    public String toString() {
        return "QueryPo{" +
                "user=" + user +
                '}';
    }
}

增加mapper接口方法

 List<User> findByName(QueryPo queryPo);

配置mapper映射文件

<!--使用pojo包装类型，根据用户名称模糊查询用户-->
<select id="findByName" resultType="com.po.User" parameterType="com.po.QueryPo">
    select * from user where username like #{user.username}
</select>

测试

@Test
public void testfindByName() throws Exception{
    InputStream resourceAsStream = App.class.getResourceAsStream("/SqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);

    User user1 = new User();
    user1.setUsername("%王%");
    QueryPo queryPo = new QueryPo(user1);
    List<User> users = userDao.findByName(queryPo);
    for (User user : users) {
        System.out.println(user);
    }
    sqlSession.close();
    resourceAsStream.close();
}

​

resultType输出映射

java简单类型

<!-- 统计用户表中的用户数量 -->
<select id="acount" resultType="int">
    select count(*) from user
</select>

pojo类型

参考：

<select id="findAll" resultType="com.po.User">
    select * from user
</select>

resultMap输出映射

需求

查询全部数据封装到User2对象中。

编写User2实体类对象

package com.po;

public class User2 {
    //num对应的数据库字段是id
    private int num;
    private String username;
    //shengri对应的数据库字段是birthday
    private String shengri;
    private String sex;
    private String address;

    public User2() {
    }

    public User2(int num, String username, String shengri, String sex, String address) {
        this.num = num;
        this.username = username;
        this.shengri = shengri;
        this.sex = sex;
        this.address = address;
    }

    public int getnum() {
        return num;
    }

    public void setnum(int num) {
        this.num = num;
    }

    public String getUsername() {
        return username;
    }

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

    public String getshengri() {
        return shengri;
    }

    public void setshengri(String shengri) {
        this.shengri = shengri;
    }

    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{" +
                "num=" + num +
                ", username='" + username + '\'' +
                ", shengri='" + shengri + '\'' +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

编写订单mapper接口

List<User2> finAllUser2();

编写订单mapper映射文件

 <!--
        查询全部，使用resultMap建立：列与属性的映射关系
        resultMap  建立列与属性的映射关系
            id="userResultMap"   需要与select中引用的resultMap名称一致
            type                 要封装的对象的类型
    -->

    <resultMap id="user2map" type="com.po.User2">
        <!--建立对象的唯一标记与表的主键映射关系-->
        <id property="num" column="id"/>
        <!--建立对象的其他属性与表的非主键字段的映射关系-->
        <!--property对应类的属性名，column对应数据库字段名-->
        <result property="username" column="username"/>
        <result property="shengri" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
    </resultMap>

    <select id="finAllUser2" resultMap="user2map">
        select * from user
    </select>

测试

 @Test
    public void testfinAllUser2() throws Exception {
        InputStream resourceAsStream = App.class.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User2> user2s = userDao.finAllUser2();
        for (User2 user2 : user2s) {
            System.out.println(user2);
        }
        sqlSession.close();
        resourceAsStream.close();
    }

mybatis持久层的两种开发方法

mapper代理开发方法【掌握】

从入门程序开始，一直使用的方式，即mapper代理开发的方法。特点：

1. 在开发的时候，只需要编写持久层的接口，和持久层接口映射文件（mapper映射文件）。

2. 在执行的时候，mybatis框架通过动态代理生成接口的代理对象。

总结mapper代理开发原则【记住】

1. mapper映射文件中namespace属性值，必须是mapper接口的全限定名称

2. mapper映射文件中sql语句标签的声明，与mapper接口中接口方法声明一致

   2.1.sql语句标签中resultType属性指定的返回值类型，与mapper接口方法返回值类型一致。（如果接口方法返回的是集合list，则resultType指定的是list中存放的类型）

   2.2.sql语句标签中的id属性值，与mapper接口方法名称一致

   2.3.sql语句标签中的parameterType属性指定的类型，与mapper接口方法的形参类型一致

传统的dao开发方法【了解】

需求

1. 根据用户Id查询用户

2. 新增一个用户

需求实现

编写映射文件

<?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="test">

    <!--根据用户Id查询用户-->
    <select id="findUserById" parameterType="int" resultType="po.User">
        select * from `user` where id=#{id}
    </select>

    <!--新增用户-->
    <insert id="addUser" parameterType="po.User"
            useGeneratedKeys="true" keyColumn="id" keyProperty="id">
        insert into `user`(username,birthday,sex,address)
        values(#{username},#{birthday},#{sex},#{address})
    </insert>
</mapper>

编写用户dao接口

package mapper;

import po.User;

/**
 * 用户dao接口
 */
public interface UserDao {

    /**
     * 1.根据用户Id查询用户
     */
    User findUserById(Integer id);

    /**
     * 2.新增用户
     */
    void insertUser(User user);
}

编写用户dao实现类

package mapper.impl;

import mapper.UserDao;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import po.User;
import util.SqlSessionFactoryUtil;

/**
 * 用户dao实现类
 */
public class UserDaoImpl implements UserDao {
    /**
     * 1.根据用户Id查询用户
     *
     * @param id
     */
    public User findUserById(Integer id) {

        // 1.获取sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtil.getSqlSessionFactory();

        // 2.打开sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 3.调用方法执行
        /**
         * selectOne方法：查询单条记录
         * 参数：
         *      statement：执行的sql语句（名称空间+"."+sql语句id）
         *      parameter：传入的参数值
         */
        Object user = sqlSession.selectOne("test.findUserById", id);

        // 4.释放资源
        sqlSession.close();

        return (User) user;
    }

    /**
     * 2.新增用户
     *
     * @param user
     */
    public void insertUser(User user) {
        // 1.获取sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtil.getSqlSessionFactory();

        // 2.打开sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        // 3.调用方法执行
        /**
         * insert方法：新增记录
         * 参数：
         *      statement：执行的sql语句（名称空间+"."+sql语句id）
         *      parameter：传入的参数值
         */
        sqlSession.insert("test.addUser", user);

        // 4.释放资源
        sqlSession.close();
    }
}

在sqlMapConfig.xml中，加载User.xml

<!--加载mapper映射文件-->
<mappers>
    <!--加载用户接口映射文件-->
    <mapper resource="sqlmap/UserMapper.xml"></mapper>
    <!--加载订单接口映射文件-->
    <mapper resource="sqlmap/OrdersMapper.xml"></mapper>
    <!--加载User.xml-->
    <mapper resource="sqlmap/User.xml"></mapper>
</mappers>

测试

package test;

import mapper.UserDao;
import mapper.impl.UserDaoImpl;
import org.junit.Test;
import po.User;

/**
 * 传统的dao开发方法测试
 */
public class UserDaoTest {

    /**
     * 测试根据用户Id查询用户
     */
    @Test
    public void findUserByIdTest() {
        // 1.创建dao实现类对象
        UserDao userDao = new UserDaoImpl();

        User user = userDao.findUserById(24);
        System.out.println(user);
    }
}

测试新增用户：

/**
 * 测试新增用户
 */
@Test
public void addUserTest(){
    // 1.创建dao实现类对象
    UserDao userDao = new UserDaoImpl();

    // 创建用户对象
    User user = new User();
    user.setUsername("阿飞");
    user.setSex("1");
    user.setBirthday(new Date());
    user.setAddress("天下第一快剑");

    userDao.insertUser(user);
}

核心配置文件sqlMapConfig.xml

sqlMapConfig.xml是mybatis框架的核心配置文件，目前我们在其中配置了运行环境（数据源）和加载映射文件。该配置文件中还有其它的一些配置。

顺序	配置标签名称	说明
1	properties	属性
2	settings	配置全局参数
3	typeAliases	类型别名
4	typeHandlers	类型处理器
5	objectFactory	对象工厂
6	plugins	插件
7	environments	环境集合属性对象
8	databaseIdProvider	多数据库支持
9	mappers	映射器

说明：在sqlMapConfig.xml中必须是从上往下的配置顺序

properties（属性）

作用：加载属性资源文件和定义属性。

编写数据库连接属性资源文件（db.properties）

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/zzw?characterEncoding=utf8
jdbc.username=root
jdbc.password=root

加载db.properties属性资源文件

<!--加载属性资源文件，说明：
    1.resource：加载【本地】属性资源文件
    2.url：加载【网络上】属性资源文件（url="http://127.0.0.1:8081/db.properties"）
-->
<properties resource="jdbc.properties"/>

使用属性资源文件中定义属性

<!--environments配置环境数据库使用哪个连接，不能乱写-->
    <environments default="mysql">
        <!--配置具体连接到哪一个数据库，不能乱写-->
        <environment id="mysql">
            <!--transactionManager，配置事物控制类型为JDBC-->
            <transactionManager type="JDBC"/>
            <!--配置数据库连接池
                       POOLED,mybatis内置的数据库连接池（推荐使用）
                       UNPOOLED,不使用连接池
                       JNDI,使用服务器tomcat容器的数据库连接池
           -->
            <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>

​

使用内部property标签定义属性

加载顺序：首先加载内部property标签定义属性，再加载属性资源文件中的属性。如果有相同的属性，属性资源文件中的属性会覆盖内部property标签定义的属性。

属性资源文件优先

<!--加载属性资源文件，说明：
    1.resource：加载【本地】属性资源文件
    2.url：加载【网络上】属性资源文件（url="http://127.0.0.1:8081/db.properties"）
    3.使用内部property标签定义属性
    4.加载顺序：首先加载内部property标签定义属性，再加载属性资源文件中的属性。如果
    有相同的属性，属性资源文件中的属性会覆盖内部property标签定义的属性
-->
<properties resource="db.properties">
    <property name="db.username" value="root"></property>
    <property name="db.password" value="admin"></property>
</properties>

typeAliases（类型别名）

作用：简称。比如中华人民共和国，简称中国。

内置别名

别名	映射类型
_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

说明：

1. 内置别名可以直接使用

2. 别名不区分大小写

自定义别名

方式一：单个别名【了解】

<!-- 配置自定义别名 -->
<typeAliases>
    <!--配置用户别名，说明：
        1.type：指定别名的类型
        2.默认使用类的名称作为别名的名称
        3.alias：指定别名的名称
      -->
    <typeAlias type="cn.po.User" alias="user"/>
</typeAliases>

方式二：包扫描配置别名

<!-- 包扫描方式配置自定义别名，说明：
        1.name：指定要扫描的包
        2.默认都是使用类的明作为别名的名称
        3.如果有多个包。在同一个父包下，配置父包即可
        4.如果不在同一个父包，配置多个：<package/>
        5.实际项目中推荐使用的方式
  6、如果别名同名，则可使用类全名区分。
-->
<typeAliases>
    <package name="com.po"/>
</typeAliases>

mappers（映射器）

作用：加载映射文件。

方式一：加载单个映射文件

<!--加载mapper映射文件-->
<mappers>
    <!--加载用户接口映射文件-->
    <mapper resource="sqlmap/UserMapper.xml"></mapper>
    <!--加载订单接口映射文件-->
    <mapper resource="sqlmap/OrdersMapper.xml"></mapper>
    <!--加载User.xml-->
    <mapper resource="sqlmap/User.xml"></mapper>
</mappers>

​

方式二：包扫描加载映射文件

要求mapper映射文件的名称和路径地址，要与mapper接口的名称和路径地址要一致，否则会出现BindingException异常。

<!--加载mapper映射文件-->
 <mappers>
     <!--包扫描方式加载mapper映射文件,说明：
        1.前提必须是mapper代理的开发方法
        2.要求mapper映射文件，与mapper接口要放在同一个目录
        3.要求mapper映射文件的名称，与mapper接口的名称要一致
 -->
     <package name="com.dao" />
 </mappers>