day61_Mybatis学习笔记_01

• 今天内容安排：
  • 1、mybatis的介绍
  • 2、分析原生态Jdbc程序中存在的问题
  • 3、mybatis的框架原理（重点）
  • 4、入门程序
    • 订单商品案例（用户表）
  • 5、Mybatis开发dao的方式（重点）
    • a) 原始dao的开发方式（开发dao接口和dao实现类，由ibatis遗留下来的风格）
    • b) Mapper代理的开发方式（推荐方式，开发mapper接口(相当于dao接口)）
  • 6、全局配置文件
  • 7、映射文件（重点）
    • a) 输入映射
    • b) 输出映射
    • c) 动态sql
  • 8、mybatis和hibernate的区别及应用场景

1、mybatis的介绍

• mybatis就是一个封装的jdbc的持久层框架，它和hibernate都属于ORM（Object Relational Mapping）框架，但是具体的说，hibernate是一个完全的ORM框架，而mybatis是一个不完全的ORM框架。
• mybatis让程序员只关注sql本身，而不需要去关注如：注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
• mybatis会将输入参数、输出结果进行映射。而不是把对象关系映射成sql。

详解如下：

    MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis，实质上Mybatis对ibatis进行一些改进。 
    MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如：注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
    Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

2、分析原生态Jdbc程序中存在的问题

2.1、原生态Jdbc程序代码

    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            // 1、加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2、通过驱动管理类获取数据库链接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");
            // 3、定义sql语句，?表示占位符
            String sql = "select * from user where username = ?";
            // 4、获取预处理statement对象
            preparedStatement = connection.prepareStatement(sql);
            // 5、设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
            preparedStatement.setString(1, "晓艺");
            // 6、向数据库发出sql执行查询，查询出结果集
            resultSet = preparedStatement.executeQuery();
            // 7、遍历查询结果集
            while (resultSet.next()) {
                System.out.println(resultSet.getString("id") + "  " + resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 8、释放资源
            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();
                }
            }
        }
    }

2.2、Jdbc问题总结

• 1、数据库连接频繁开启和关闭，会严重影响数据库的性能。
  • 数据库连接池（全局配置文件中）
• 2、代码中存在硬编码，分别是数据库部分(创建连接)的硬编码和SQL执行部分的硬编码。
  • 数据库部分：配置文件（全局配置文件中）
  • SQL执行部分：配置文件（映射文件中）

3、mybatis的框架原理（重点）

3.1、mybatis框架图

3.2、分析结论

• 1、mybatis配置文件，包括Mybatis全局配置文件和Mybatis映射文件，其中全局配置文件配置了数据源、事务等信息；映射文件配置了SQL执行相关的信息。
• 2、mybatis通过读取配置文件信息（全局配置文件和映射文件），构造出SqlSessionFactory，即会话工厂。
• 3、通过SqlSessionFactory，可以创建SqlSession即会话。Mybatis是通过SqlSession来操作数据库的。
• 4、SqlSession本身不能直接操作数据库，它是通过底层的Executor执行器接口来操作数据库的。Executor接口有两个实现类，一个是普通执行器，一个是缓存执行器（默认）。
• 5、Executor执行器要处理的SQL信息是封装到一个底层对象MappedStatement中。该对象包括：SQL语句、输入参数映射信息、输出结果集映射信息。其中输入参数和输出结果的映射类型包括：java的简单类型、HashMap集合对象、POJO对象类型。

4、入门程序

• Mybatis课程的所有代码程序将通过一个订单商品案例来进行讲解。
  • 订单商品案例（用户表）

4.1、需求

• 对用户信息的增删改查操作。
  • 1、根据用户ID来查询用户信息
  • 2、根据用户名称模糊查询用户信息列表
  • 3、添加用户
  • 4、删除用户（练习）
  • 5、修改用户（练习）

4.2、环境准备

• Jdk环境：jdk1.7.0_80
• Ide环境：Eclipse Oxygen.2 Release (4.7.2)
• 数据库环境：MySQL 5X
• Mybatis：3.2.7

4.2.1、数据库初始化

4.2.1.1、数据库脚本

  1、执行sql_table.sql脚本，创建数据库表；
  2、执行sql_data.sql初始化测试数据。

4.2.1.2、数据库表
订单商品案例的数据库脚本中，总共包含四张表，其中入门程序只使用user表：

用户表的表结构如下：

4.2.2、下载mybatis

• mybaits的代码由github.com管理，下载地址：https://github.com/mybatis/mybatis-3/releases
  • lib：mybatis的依赖包
  • mybatis-3.2.7.jar：mybatis的核心包
  • mybatis-3.2.7.pdf：mybatis的使用指南

4.3、工程搭建（三步）

4.3.1、第一步：创建java工程

• 用eclipse创建一个java工程，jdk使用1.7.0_80，新建标准结构：
  

4.3.2、第二步：加入jar包

• 加入以下四部分jar包，其中junit的jar包，是非必须的。
  • Mybatis核心包
  • Mybatis依赖包（没有框框的）
  • MySQL驱动包
  • Junit单元测试包（单元测试需要的包）
    
  • 之后添加至构建路径

4.3.3、第三步：添加log4j.properties文件

  Mybatis使用的日志包是log4j的，所以需要添加log4j.properties。
  在classpath下创建log4j.properties如下：
  文件内容可以从mybatis-3.2.7.pdf中拷贝

# 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

  日志级别在开发阶段设置成debug，在生产阶段设置成info或者error。

4.4、编程步骤

• 1、创建PO类，根据需求创建；
• 2、创建全局配置文件SqlMapConfig.xml；
• 3、编写对应的映射文件；
• 4、加载映射文件，在SqlMapConfig.xml中进行加载；
• 5、编写测试程序，即编写Java代码，连接并操作数据库。 思路：
  • a) 读取配置文件；
  • b) 通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂
  • c) 通过SqlSessionFactory创建SqlSession
  • d) 调用SqlSession的操作数据库方法
  • e) 关闭SqlSession

4.5、代码开发

4.5.1、创建PO类

• 创建的po类的属性要和数据库中表的列名一致（如果表中的列名是带有下划线，那么po类中对应的的属性名要采用驼峰式命名）。

User.java类如下：

public class User {
    private int id;
    private String username; // 用户姓名
    private String sex; // 性别
    private Date birthday; // 生日
    private String address; // 地址

    // getter和setter方法

4.5.2、创建全局SqlMapConfig.xml配置文件

  在classpath下，创建SqlMapConfig.xml文件，该文件名称不是固定不变的。
  SqlMapConfig.xml（文件头可以从mybatis-3.2.7.pdf文档的2.1.2小节中拷贝）：
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>
    <!-- 配置mybatis的环境信息，后面学习中，与spring整合，该信息由spring来管理 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务控制，由mybatis进行管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，采用mybatis连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

4.5.3、需求开发

  在config目录下，创建普通文件夹sqlmap。在sqlmap目录下，创建User.xml映射文件（这种命名规范是由ibatis遗留下来）。
  Mybatis的映射文件头（可以从mybatis-3.2.7.pdf文件中拷贝）：
User.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">

4.5.3.1、根据用户ID来查询用户信息
（1）编写映射文件
  在User.xml中添加以下代码：

    <!-- 
    namespace：命名空间，它的作用就是对SQL进行分类化管理，可以理解为SQL隔离。
        注意：在使用mapper代理开发时，namespace有特殊且重要的作用。
     -->
<mapper namespace="test">
    <!-- 根据用户ID，查询用户信息 -->
    <!-- 
        id：statement的id，要求在命名空间内唯一  
        parameterType：输入参数的java类型
        resultType：查询出的单条结果集对应的java类型
        #{}： 表示一个占位符?
        #{id}：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
    -->
    <!-- <select id=""></select> 该标签表示一个对象，即该标签最终会封装成一个MappedStatement对象 -->
    <select id="findUserById" parameterType="int" resultType="com.itheima.mybatis.po.User">
        SELECT * FROM USER WHERE id = #{id}
    </select>
</mapper>

（2）在全局配置文件中加载映射文件
  在SqlMapConfig.xml中，添加以下代码：

<!-- 加载mapper，即加载映射文件 -->
<mappers>
    <mapper resource="sqlmap/User.xml"/>
</mappers>

（3）编写测试程序

    @Test
    public void findUserByIdTest() throws IOException {
        // 1、读取全局配置文件（即将全局配置文件读取到输入流中）
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 2、根据全局配置文件创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 3、根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 4、使用SqlSession执行statement，并返回映射结果
        // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
        // 第二个参数：输入参数的值，它的类型要和映射文件中对应的statement的输入参数类型一致
        // 打印输出结果集
        User user = sqlSession.selectOne("test.findUserById", 10);
        System.out.println(user);
        // 5、关闭资源
        sqlSession.close();
    }
}

4.5.3.2、根据用户名称模糊查询用户信息列表
（1）编写映射文件
  在User.xml中添加以下代码：

    <!-- 根据用户名称模糊查询用户信息列表 -->
    <!-- 
            ${}：表示拼接SQL字符串，${}会原样输出，不加解释
            ${value}：表示要拼接的是简单类型参数。
             注意：
                1、如果输入参数为简单类型时，${}里面的参数名称必须为value 
                2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如 order by ${colname}
    -->
    <select id="findUsersByName" parameterType="java.lang.String" resultType="com.itheima.mybatis.po.User">
        SELECT * FROM USER WHERE username LIKE '%${value}%'
    </select>   

（2）在全局配置文件中加载映射文件
  已配置，此处无需再次配置。

（3）编写测试程序

    @Test
    public void findUsersByNameTest() throws IOException {
        // 1、读取全局配置文件（即将全局配置文件读取到输入流中）
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 2、根据全局配置文件创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 3、根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 4、使用SqlSession执行statement，并返回映射结果
        // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
        // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
        List<User> users = sqlSession.selectList("test.findUsersByName", "小明");
        System.out.println(users);
        // 5、关闭资源
        sqlSession.close();
    }

4.5.3.3、添加用户
（1）编写映射文件
  在User.xml中添加以下代码：

    <!-- 添加用户 -->
    <!-- 如果主键的值是通过MySQL自增机制生成的，那么我们此处不需要再显示的给ID赋值 
         通过OGNL表达式去User对象中查找对应的属性名称获取值，OGNL：对象图导航语言
    -->
    <insert id="insertUser" parameterType="com.itheima.mybatis.po.User">
        INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
    </insert>

（2）在全局配置文件中加载映射文件
  已配置，此处无需再次配置。

（3）编写测试程序

    @Test
    public void insertUserTest() throws IOException {
        // 1、读取全局配置文件（即将全局配置文件读取到输入流中）
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 2、根据全局配置文件创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 3、根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 构建user参数，没有赋值的属性采取默认值
        User user = new User();
        user.setUsername("晓艺");
        user.setAddress("物资学院地铁站");

        // 4、使用SqlSession执行statement，并返回映射结果
        // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
        // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
        sqlSession.insert("test.insertUser", user);

        // 提交事务，切记：增删改操作时，要执行commit操作
        sqlSession.commit();

        // 5、关闭资源
        sqlSession.close();
    }

（4）主键返回之MySQL自增主键
  当我们做完了添加后，我很想要刚才添加完用户的id，该怎么办呢？
思路：

• MySQL自增主键，是指在执行insert之前MySQL会自动生成一个自增的主键。
• 我们可以通过MySQL的函数获取到刚插入的自增主键：
  LAST_INSERT_ID()
• 这个函数是在insert语句之后去调用的。

修改映射文件：

    <!-- 添加用户之自增主键返回（selectKey方式） -->
    <!-- 
            selectKey标签：通过select查询来生成主键
            keyProperty：指定存放生成主键的属性
            resultType：生成主键所对应的Java类型
            order：指定该查询主键SQL语句的执行顺序，相对于insert语句
            last_insert_id：MySQL的函数，要配合insert语句一起使用
    -->
    <insert id="insertUser1" parameterType="com.itheima.mybatis.po.User">
        <selectKey keyProperty="id" resultType="int" order="AFTER">
            SELECT LAST_INSERT_ID()
        </selectKey>
        INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
    </insert>

（5）主键返回之MySQL函数UUID
  注意1：使用mysql的uuid()函数生成主键，需要修改表中id字段类型为string，且长度设置成35位。
  注意2：只要不是自增主键，那么order属性的值都要设置成BEFORE。

    <!-- 添加用户之UUID主键返回 -->
    <!-- 
        uuid：MySQL的函数，生成的主键是35位的字符串，所以使用它时要修改数据库表中id的类型为字符类型，且长度设置成35位。
        注意：
            1、此时order采用BEFORE，因为需要先生成出主键，再执行insert语句
            2、需要显式的给ID赋值
    --> 
    <insert id="insertUser2" parameterType="com.itheima.mybatis.po.User">
        <selectKey keyProperty="id" resultType="string" order="BEFORE">
            SELECT UUID()
        </selectKey>
        INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
    </insert>

（6）主键返回之Oracle序列返回
  序列也就是sequence，它是Oracle的主键生成策略。

    <!-- 添加用户之sequence返回 -->
    <!-- 
         序列也就是sequence，它是Oracle的主键生成策略。
          通过Oracle的sequence获取主键方式与MySQL的uuid方式基本一致。
    -->
    <insert id="insertUser3" parameterType="com.itheima.mybatis.po.User">
        <selectKey keyProperty="id" resultType="int" order="BEFORE">
            SELECT seq.nextval() FROM dual
        </selectKey>
        INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
    </insert>

4.5.3.4、删除用户
（1）编写映射文件
  在User.xml中添加以下代码：

    <!-- 根据ID删除用户 -->
    <delete id="deleteUser" parameterType="int">
        DELETE FROM USER WHERE id= #{id}
    </delete>   

（2）在全局配置文件中加载映射文件
  已配置，此处无需再次配置。

（3）编写测试程序

    @Test
    public void deleteUserTest() throws IOException {
        // 1、读取全局配置文件（即将全局配置文件读取到输入流中）
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 2、根据全局配置文件创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 3、根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 4、使用SqlSession执行statement，并返回映射结果
        // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
        // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
        sqlSession.delete("test.deleteUser", 27);

        // 提交事务，切记：增删改操作时，要执行commit操作
        sqlSession.commit();

        // 5、关闭资源
        sqlSession.close();
    }

4.5.3.5、修改用户
（1）编写映射文件
  在User.xml中添加以下代码：

    <!-- 根据传入的用户信息修改用户 -->
    <update id="updateUser" parameterType="com.itheima.mybatis.po.User">
        UPDATE USER SET username = #{username}, sex = #{sex} WHERE id = #{id}
    </update>

（2）在全局配置文件中加载映射文件
  已配置，此处无需再次配置。

（3）编写测试程序

    @Test
    public void updateUserTest() throws Exception {
        // 1、读取全局配置文件（即将全局配置文件读取到输入流中）
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 2、根据全局配置文件创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 3、根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 构建user参数，没有赋值的属性采取默认值
        User user = new User();
        user.setId(29);
        user.setUsername("李晓艺");
        user.setSex("女");

        // 4、使用SqlSession执行statement，并返回映射结果
        // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
        // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
        sqlSession.update("test.updateUser", user);

        // 提交事务，切记：增删改操作时，要执行commit操作
        sqlSession.commit();

        // 5、关闭资源
        sqlSession.close();
    }

4.6、上午小结

• #{} 和 ${}
#{} 相当于预处理中的占位符?，#{}接收简单类型的参数时，里面的名称可以任意
  #{} 可以接受HashMap、简单类型、POJO类型的参数
  #{} 可以防止SQL注入
  ${} 表示拼接符，${}接收简单类型的参数时，里面的名称必须是value
  ${} 里面的值会原样输出，不加解释（即：如果该参数值是字符串，也不会添加引号）
  ${} 存在sql注入的风险，但是有些场景下必须使用，比如排序后面会动态传入排序的列名
• parameterType 和 resultType
  parameterType 指定输入参数的java类型，parameterType只有一个，也就是说输入参数只有一个。可以填写别名或Java类的全限定名。
  resultType 指定输出结果的java类型（注意：是单条记录的java类型），可以填写别名或Java类的全限定名。
• selectOne 和 selectList
  selectOne 表示查询单个对象
  selectList 表示查询集合对象
  　　selectList：可以查询0或N条记录
  　　selectOne：只能查询0或1条记录，大于1条记录的话，编译不会报错，但运行会报错，如下图所示：
  

5、Mybatis开发dao的方式

• Mybatis在项目中主要使用的地方就是开发dao（数据访问层），所以下面讲解一下mybatis开发dao的方式。
• 有两种方式：原始dao开发方式、mapper代理开发方式（推荐）。

5.1、需求

• 1、根据用户ID来查询用户信息；
• 2、根据用户名称来模糊查询用户信息列表；
• 3、添加用户；

5.2、原始dao开发方式

• 程序员需要写dao接口和dao实现类。
• 编程步骤：
  • 1、根据需求创建po类
  • 2、编写全局配置文件
  • 3、根据需求编写映射文件
  • 4、加载映射文件
  • 5、编写dao接口
  • 6、编写dao实现类
  • 7、编写测试代码
• 程序编写
  • 步骤中的1、2、3、4都在入门程序中进行了编写，此处不需要重新编写。

5.2.1、开发dao接口

public interface UserDao {

    // 根据用户ID来查询用户信息
    public User findUserById(int id);
    // 根据用户名称来模糊查询用户信息列表
    public List<User> findUsersByName(String username);
    // 添加用户
    public void insertUser(User user);
}

5.2.2、开发dao实现类

• 通过入门程序，大家可以看出，在测试代码中，有大量的重复代码。所以我们第一反应就是想给它抽取出共性的部分，但是SqlSession、SqlSessionFactory、SqlSessionFactoryBuilder有着各自的生命周期，因为这些生命周期的不同，抽取时要有针对性的处理。所以在抽取之前，我们先来了解并总结下它们三个的生命周期：
  • SqlSessionFactoryBuilder，它的作用只是通过配置文件创建SqlSessionFactory，所以只要创建出SqlSessionFactory，它就可以销毁了。所以说，它的生命周期是在方法之内。
  • SqlSessionFactory，它的作用是创建SqlSession的工厂，工厂一旦创建，除非应用停掉，不要销毁。所以说它的生命周期是在应用范围内。这里可以通过`单例模式`来管理它。在mybatis整合spring之后，最好的处理方式是把SqlSessionFactory交由spring来做单例管理。
  • SqlSession是一个面向用户（程序员）的接口，它的默认实现是DefaultSqlSession。Mybatis是通过SqlSession来操作数据库的。它内部含有一块数据区域。SqlSession中不仅包含要处理的SQL信息，还包括一些数据信息，所以说它是线程不安全的，因此它最佳的生命周期范围是在方法体之内。

（1）dao实现类代码
  注意：需要向dao实现类中注入SqlSessionFactory，在方法体内通过SqlSessionFactory创建SqlSession，要注意SqlSession和SqlSessionFactory的生命周期。

public class UserDaoImpl implements UserDao {

    // 依赖注入SqlSessionFactory，使用构造方法注入
    private SqlSessionFactory sqlSessionFactory;

    // 使用构造方法来初始化SqlSessionFactory
    public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    @Override
    public User findUserById(int id) {
        // 3、根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 4、使用SqlSession执行statement，并返回映射结果
        // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
        // 第二个参数：输入参数的值，它的类型要和映射文件中对应的statement的输入参数类型一致
        // 打印输出结果集
        User user = sqlSession.selectOne("test.findUserById", id);
        System.out.println(user);
        // 5、关闭资源
        sqlSession.close();

        return user;
    }

    @Override
    public List<User> findUsersByName(String username) {
        // 3、根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 4、使用SqlSession执行statement，并返回映射结果
        // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
        // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
        List<User> users = sqlSession.selectList("test.findUsersByName", username);
        System.out.println(users);
        // 5、关闭资源
        sqlSession.close();
        return users;
    }

    @Override
    public void insertUser(User user) {
        // 3、根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 4、使用SqlSession执行statement，并返回映射结果
        // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
        // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
        sqlSession.insert("test.insertUser1", user);
        System.out.println(user.getId());

        // 提交事务，切记：增删改操作时，要执行commit操作
        sqlSession.commit();

        // 5、关闭资源
        sqlSession.close();
    }
}

（2）编写测试代码

public class UserDaoTest {

    // 声明全局的SqlSessionFactory
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void setUp() throws Exception {
        // 1、读取全局配置文件（即将全局配置文件读取到输入流中）
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 2、根据全局配置文件创建SqlSessionFactory
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }

    @Test
    public void testFindUserById() {
        // 构造UserDao对象
        UserDao userDao = new UserDaoImpl(sqlSessionFactory);
        // 调用UserDao对象的方法
        User user = userDao.findUserById(28);
        System.out.println(user);
    }

    @Test
    public void testFindUsersByName() {
        // 构造UserDao对象
        UserDao userDao = new UserDaoImpl(sqlSessionFactory);
        // 调用UserDao对象的方法
        List<User> users = userDao.findUsersByName("小明");
        System.out.println(users);
    }

    @Test
    public void testInsertUser() {
        // 构造UserDao对象
        UserDao userDao = new UserDaoImpl(sqlSessionFactory);
        // 构造User对象
        User user = new User();
        user.setUsername("晓艺");
        user.setAddress("在物资学院那边");
        // 调用UserDao对象的方法
        userDao.insertUser(user);
        System.out.println(user.getId());
    }

（3）问题总结

• 原始dao开发存在一些问题：
  • 存在一定量的模板代码。比如：通过SqlSessionFactory创建SqlSession；调用SqlSession的方法操作数据库；关闭Sqlsession。
  • 存在一些硬编码。调用SqlSession的方法操作数据库时，需要指定statement的id，这里存在了硬编码。

5.3、Mapper代理开发方式（推荐）

• Mapper代理的开发方式，程序员只需要编写mapper接口（相当于dao接口）即可，即：我们只需要根据接口信息，就能够推断出实现类来。Mybatis会自动的为mapper接口生成动态代理实现类。
• 不过要实现mapper代理的开发方式，需要遵循一些开发规范。
• Mapper代理使用的是jdk的代理策略。因为jdk代理是基于实现接口的。

5.3.1、开发规范

• 1、mapper接口的全限定名要和mapper映射文件的namespace的值相同。
• 2、mapper接口的方法名称要和mapper映射文件中的statement的id相同。
• 3、mapper接口的方法参数只能有一个，且类型要和mapper映射文件中statement的parameterType的值保持一致。
• 4、mapper接口的返回值类型要和mapper映射文件中statement的resultType的值或resultMap中的type的值保持一致。
• 5、mapper接口和mapper映射文件必须在同一目录下。
• 通过规范式的开发mapper接口，可以解决原始dao开发当中存在的问题：
  • 1、模板代码已经去掉。
  • 2、剩下去不掉的操作数据库的代码，其实就是一行代码。这行代码中硬编码的部分，通过第一和第二个规范就可以解决。

5.3.2、编程步骤

• 1、根据需求创建po类
• 2、编写全局配置文件
• 3、根据需求编写映射文件
• 4、加载映射文件
• 5、编写mapper接口
• 6、编写测试代码
  • 步骤中的1、2都在入门程序中进行了编写，此处不需要重新编写。

（1）编写mapper映射文件
  重新定义mapper映射文件UserMapper.xml（内容同Users.xml，除了namespace的值），放到新创建的普通目录mapper下，该普通目录mapper在config目录下。
  即：在config下创建mapper目录然后创建UserMapper.xml（这是mybatis的命名规范，当然，也不是必须是这个名称）。
  sqlSession内部的数据区域本身就是一级缓存，是通过map来存储的。

<mapper namespace="com.itheima.mybatis.mapper.UserMapper">

（2）加载mapper映射文件

    <!-- 加载mapper，即加载映射文件 -->
    <mappers>
        <mapper resource="sqlmap/User.xml"/>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>

（3）编写mapper接口
  内容同UserDao接口一样：

public interface UserMapper {

    // 根据用户ID来查询用户信息
    public User findUserById(int id);
    // 根据用户名称来模糊查询用户信息列表
    public List<User> findUsersByName(String username);
    // 添加用户
    public void insertUser(User user);
}

（4）编写测试代码

public class UserMapperTest {

    // 声明全局的SqlSessionFactory
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void setUp() throws Exception {
        // 1、读取全局配置文件（即将全局配置文件读取到输入流中）
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 2、根据全局配置文件创建SqlSessionFactory
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }

    @Test
    public void testFindUserById() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.findUserById(1);
        System.out.println(user);

        sqlSession.close();
    }

    @Test
    public void testFindUsersByName() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.findUsersByName("小明");
        System.out.println(users);

        sqlSession.close();
    }

    @Test
    public void testInsertUser() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 构造User对象
        User user = new User();
        user.setUsername("晓艺");
        user.setAddress("物资学院");
        mapper.insertUser(user);
        System.out.println(user.getId());

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

6、Mybatis全局配置文件

• SqlMapConfig.xml是mybatis的全局配置文件，它的名称可以是任意命名的。

6.1、全部配置内容

• SqlMapConfig.xml的配置内容和顺序如下（顺序不能乱）：
• Content Model : (properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, objectWrapperFactory?, plugins?, environments?, databaseIdProvider?, mappers?)
  • properties（属性）
  • settings（全局参数设置）
  • typeAliases（类型别名）
  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • objectWrapperFactory（对象代理工厂）
  • plugins（插件，Mybatis本身不支持分页）
  • environments（环境信息集合）
    • environment（单个环境信息）
      • transactionManager（事物）
      • dataSource（数据源）
  • databaseIdProvider（数据库id提供者）
  • mappers（映射器）

6.2、常用配置详解

6.2.1、properties

• SqlMapConfig.xml文件中可以引用java属性文件中的配置信息。

db.properties配置信息如下：

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8
db.username=root
db.password=root

SqlMapConfig.xml使用properties标签后，如下所示：

之前：
    <!-- 配置mybatis的环境信息，后面学习中，与spring整合，该信息由spring来管理 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务控制，由mybatis进行管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，采用mybatis连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
现在：
    <!-- 通过properties标签，读取java配置文件的内容或者声明属性信息  -->
    <properties resource="db.properties"></properties>
    <!-- 配置mybatis的环境信息，后面学习中，与spring整合，该信息由spring来管理 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务控制，由mybatis进行管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，采用mybatis连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="${db.driver}"/>
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.username}"/>
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>

注意加载顺序：

加载顺序说明：

• 1、先加载properties中property标签声明的属性。
• 2、再加载properties标签引入的java配置文件中的属性。
• 3、parameterType的值会和properties的属性值发生冲突。即：parameterType接收的值会最后被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值。

  所以说，Mybatis读取属性的顺序由高到低分别是：parameterType接收的属性值、properties引用的属性、properties标签内定义的属性。

6.2.2、settings

• mybatis全局配置参数，全局参数将会影响mybatis的运行行为。

详细参见“mybatis学习资料/mybatis-settings.xlsx”文件，如下图所示：

6.2.3、typeAliases

• 别名是使用是为了在映射文件中，更方便的去指定入参和结果集的类型，不再用写很长的一段全限定名。

（1）mybatis支持的别名

（2）自定义别名

    <!-- 自定义别名 -->
    <typeAliases>
        <!-- 单个定义别名 -->
        <!-- <typeAlias type="com.itheima.mybatis.po.User" alias="user"/> -->
        <!-- 批量定义别名（推荐） -->
        <!-- name：指定批量定义别名的类包，别名为类名（首字母大小写都可） -->
        <package name="com.itheima.mybatis.po"/>
    </typeAliases>

6.2.4、mappers

详解如下：

（1）<mapper resource=""/>
    使用相对于类路径的资源
    如：<mapper resource="sqlmap/User.xml"/>
（2）<mapper url=""/>
    使用完全限定路径
    如：<mapper url="file:///D:workspace_spingmvcmybatis_01configsqlmapUser.xml"/>
（3）<mapper class=""/>
    使用mapper接口的全限定名
    如：<mapper class="com.itheima.mybatis.mapper.UserMapper"/>
    `注意：此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下。`
（4）<package name=""/>（推荐）
    注册指定包下的所有映射文件
    如：<package name="com.itheima.mybatis.mapper"/>
    `注意：此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下。`

7、Mybatis映射文件（核心）

7.1、输入映射

7.1.1、parameterType

• 指定输入参数的java类型，可以使用别名或者类的全限定名。它可以接收简单类型、POJO、HashMap。

（1）传递简单类型
  参考入门需求：根据用户ID查询用户信息。

（2）传递POJO对象
  参考入门需求：添加用户。

（3）传递POJO包装对象

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

需求：
  综合查询用户信息，需要传入查询条件复杂，比如（用户信息、订单信息、商品信息）。
  用户信息中的查询条件由：用户的名称和性别组成。

  一般User.java类要和数据表表字段一致，最好不要在这里面添加其他字段，第二天学习mybatis的逆向工程时，会根据表结构，生成po类，如果在po类中扩展字段，此时会被覆盖掉。
  所以针对要扩展的po类，我们需要创建一个扩展类，来继承它。
定义用户扩展类：

定义POJO包装类：

编写mapper映射文件

    <!-- 综合查询，查询用户列表，即：通过传递包装类来进行复杂的用户信息综合查询 -->
    <select id="findUserList" parameterType="com.itheima.mybatis.po.UserQueryVO" resultType="userExt">
        SELECT * FROM USER WHERE sex = #{userExt.sex} AND username LIKE '%${userExt.username}%'
    </select>

  注意：入参的类型变为UserQueryVO、结果集的类型变为UserExt，#{}里面的参数变为UserQueryVO对象中的userExt属性的sex和username子属性。
编写Mapper接口

    // 综合查询：通过传递包装类来进行复杂的用户信息综合查询
    public List<UserExt> findUserList(UserQueryVO userQueryVO);

编写测试代码

    @Test
    public void testFindUserList() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        // 构造UserQueryVO对象
        UserQueryVO userQueryVO = new UserQueryVO();

        // 构造UserExt对象
        UserExt userExt = new UserExt();
        userExt.setSex("1");
        userExt.setUsername("陈小明");

        userQueryVO.setUserExt(userExt);

        List<UserExt> list = mapper.findUserList(userQueryVO);
        System.out.println(list);

        sqlSession.close();
    }

（4）传递HashMap（练习）
  同传递POJO对象一样，map的key相当于pojo的属性。
编写mapper映射文件

    <!-- 综合查询，查询用户列表，即：通过传递HashMap来进行复杂的用户信息查询 -->
    <select id="findUserByHashMap" parameterType="java.util.HashMap" resultType="user"> 
        SELECT * FROM USER WHERE sex = #{sex} AND username LIKE '%${username}%'
    </select>

  上边的sex和username是hashmap的key。
编写Mapper接口

    // 综合查询：通过传递HashMap来进行复杂的用户信息综合查询
    public List<User> findUserByHashMap(HashMap<String, Object> hashMap);

编写测试代码

    @Test
    public void testFindUserByHashMap() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        // 构造查询条件HashMap对象
        HashMap<String, Object> hashMap = new HashMap<String, Object>();
        hashMap.put("sex", "1");
        hashMap.put("username", "小明");

        List<User> list = mapper.findUserByHashMap(hashMap);
        System.out.println(list);

        sqlSession.close();
    }

异常测试：
  传递的map中的key和sql中解析的key不一致。
  测试结果没有报错，只是通过key获取值为空。

7.2、输出映射

7.2.1、resultType

  先带着同学们看下原先resultType作为输出结果映射时，它的特点，如何再把列名改为别名，看看是否还能不能映射成功。

使用方法
  使用resultType进行结果映射时，需要查询出的列名和映射的pojo属性名完全一致，该列才能映射成功。
  如果查询的列名和映射的pojo属性名全部不一致，则不会创建pojo对象，即映射的对象为空。
  如果查询的列名和映射的pojo属性名有一个一致，就会创建pojo对象，即映射的对象不为空，但是只有映射正确那一个属性才有值。
  如果查询的sql的列名有别名，那么这个别名就是和属性映射的列名。

（1）输出简单类型
  当输出结果只有一列时，可以使用ResultType指定简单类型作为输出结果类型。
  即：对简单类型的结果映射也是有要求的，查询的列必须是一列，才能映射为简单类型。

• 需求：综合查询时，需要根据综合查询的条件查询用户的总数
• 编写Mapper映射文件

    <!-- 综合查询时，需要根据综合查询的条件查询用户的总数 -->
    <select id="findUserCount" parameterType="UserQueryVO" resultType="int">
        SELECT count(*) FROM USER WHERE sex = #{userExt.sex} AND username LIKE '%${userExt.username}%'
    </select>

• 编写Mapper接口

    // 综合查询时，需要根据综合查询的条件查询用户的总数，学习：resultType输出简单类型
    public int findUserCount(UserQueryVO userQueryVO);

• 编写测试代码

    @Test
    public void testFindUserCount() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        // 构造UserQueryVO对象
        UserQueryVO userQueryVO = new UserQueryVO();

        // 构造UserExt对象
        UserExt userExt = new UserExt();
        userExt.setSex("1");
        userExt.setUsername("小明");

        userQueryVO.setUserExt(userExt);

        int count = mapper.findUserCount(userQueryVO);
        System.out.println(count);

        sqlSession.close();
    }

（2）输出POJO单个对象和列表
  参考入门程序之：根据用户ID查询用户信息和根据用户名称模糊查询用户列表。
  注意：输出单个pojo对象和pojo列表（盛放pojo对象）时，mapper映射文件中的resultType的类型是一样的，只是mapper接口的方法返回值不同。
  下面看下mapper接口的不同之处：

    // 根据用户ID来查询用户信息
    public User findUserById(int id);
    // 根据用户名称来模糊查询用户信息列表
    public List<User> findUsersByName(String username);

总结：
  同样的mapper映射文件，返回单个对象和对象列表时，mapper接口在生成动态代理的时候，会根据返回值的类型，决定调用selectOne方法还是selectList方法。

7.2.2、resultMap

• resultMap 可以进行高级结果映射（一对一、一对多映射，第二天讲解）。

使用方法
  使用resultMap进行结果映射时，不需要查询的列名和映射的属性名必须一致。但是需要声明一个resultMap，来对列名和属性名进行映射。

• 需求
  把下面SQL的输出结果集进行映射，即通过列的别名进行查询，该如何输出结果集呢？
  　　SELECT id id_,username username_,sex sex_ FROM USER WHERE id = 1;
• 编写Mapper映射文件

    <!-- resultMap入门 -->
    <!-- 声明（定义）resultMap -->
    <!-- 
        id：定义resultMap的唯一标识
        type：定义该resultMap最终映射的pojo对象
        id标签：映射结果集的唯一标识列，如果是多个字段联合唯一，则定义多个id标签
        result标签：映射结果集的普通列
            column：SQL查询的列名，如果列有别名，则该处填写别名
            property：pojo对象的属性名
    -->
    <resultMap type="user" id="userResultMap">
        <id column="id_" property="id"/>
        <result column="username_" property="username"/>
        <result column="sex_" property="sex"/>
    </resultMap>
    <!-- 定义statement，根据用户ID来查询用户信息（学习resultMap的使用）  -->
    <select id="findUserByIdResultMap" parameterType="int" resultMap="userResultMap">
        SELECT id id_,username username_,sex sex_ FROM USER WHERE id = #{id}
    </select>

图解如下：

• 编写Mapper接口

    // 根据用户ID来查询用户信息（学习resultMap的使用），注意：是通过列的别名进行查询的
    public User findUserByIdResultMap(int id);

  定义Statement使用resultMap映射结果集时，Mapper接口定义方法的返回值类型为mapper映射文件中resultMap的type类型。

• 编写测试代码

    @Test
    public void testFindUserByIdResultMap() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.findUserByIdResultMap(1);
        System.out.println(user);

        sqlSession.close();
    }

7.3、动态SQL（重点）

• 通过Mybatis提供的各种动态标签实现动态拼接sql，使得mapper映射文件在编写SQL时更加灵活，方便。
• 在mybatis中，它提供了一些动态sql标签，可以让程序员更快的进行mybatis的开发，这些动态sql可以提高sql的可重用性。
• 常用动态SQL标签有：if标签、where标签、sql片段、foreach标签。

7.3.1、if标签和where标签

• if标签：作为判断入参来使用的，如果符合条件，则把if标签体内的SQL拼接上。
  注意：用if进行判断是否为空时，不仅要判断null，也要判断空字符串""。
• where标签：会去掉条件中的第一个and符号。
• 需求：综合查询时，查询条件由用户来输入，用户名称可以为空，需要编写满足这种情况下的sql。
• 编写Mapper映射文件

    <!-- 综合查询，查询用户列表，即：通过传递包装类来进行复杂的用户信息综合查询 -->
    <select id="findUserList" parameterType="com.itheima.mybatis.po.UserQueryVO" resultType="userExt">
        SELECT * FROM USER
        <!-- where标签：默认去掉后面第一个AND，如果没有参数，则把自己干掉  -->
        <where>
            <!-- if标签：可以对输入的参数进行判断 -->
            <!-- test:指定判断表达式 -->
            <if test="userExt != null">
                <if test="userExt.sex != null and userExt.sex != ''">
                    AND sex = #{userExt.sex}
                </if>
                <if test="userExt.username != null and userExt.username != ''">
                    AND username LIKE '%${userExt.username}%'
                </if>
            </if>
        </where>
    </select>

    <!-- 综合查询时，需要根据综合查询的条件查询用户的总数 -->
    <select id="findUserCount" parameterType="UserQueryVO" resultType="int">
        SELECT count(*) FROM USER
        <!-- where标签：默认去掉后面第一个AND，如果没有参数，则把自己干掉  -->
        <where>
            <!-- if标签：可以对输入的参数进行判断 -->
            <!-- test:指定判断表达式 -->
            <if test="userExt != null">
                <if test="userExt.sex != null and userExt.sex != ''">
                    AND sex = #{userExt.sex}
                </if>
                <if test="userExt.username != null and userExt.username != ''">
                    AND username LIKE '%${userExt.username}%'
                </if>
            </if>
        </where>
    </select>

• 编写Mapper接口

    // 综合查询：通过传递包装类来进行复杂的用户信息综合查询
    public List<UserExt> findUserList(UserQueryVO userQueryVO);
    // 综合查询时，需要根据综合查询的条件查询用户的总数，学习：resultType输出简单类型
    public int findUserCount(UserQueryVO userQueryVO);

• 编写测试代码
  不传用户名：
  
  输出的SQL如下（也不包含用户名）：
  
  另一个测试代码同理，不在赘述！
  通过测试可以得知，打印出的SQL语句确实会随着条件的满足情况而不一样。

7.3.2、SQL片段

• Mybatis提供了SQL片段的功能，可以提高SQL的可重用性。
• Sql片段需要先定义后使用。
• 定义SQL片段和引用SQL片段
  

7.3.3、foreach标签

• 向sql传递数组或List时，mybatis使用foreach解析数组里的参数并拼接到SQL中。即：可以循环传入参数值。

（1）传递pojo对象中的List集合

• 需求：综合查询时，会根据用户ID集合进行查询，如下：
  • SELECT * FROM USER WHERE id IN (1,2,10)
• 在包装POJO中定义List属性
  
• 编写映射文件
  
• 编写测试代码

    @Test
    public void testFindUserList() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        // 构造UserQueryVO对象
        UserQueryVO userQueryVO = new UserQueryVO();

        // 构造UserExt对象
        UserExt userExt = new UserExt();
        // userExt.setSex("1");
        // userExt.setUsername("小明");
        userQueryVO.setUserExt(userExt);

        // 创建用户ID集合，然后设置到QueryUserVO对象中
        List<Integer> idList = new ArrayList<Integer>();
        idList.add(28);
        idList.add(29);
        idList.add(30);
        userQueryVO.setIdList(idList);      

        List<UserExt> list = mapper.findUserList(userQueryVO);
        System.out.println(list);

        sqlSession.close();
    }

输出的SQL如下：

（2）直接传递List集合（自学）

• 编写映射文件

    <!-- 根据用户ID的集合查询用户列表（学习foreach标签之直接传递ID集合） -->
    <select id="findUsersByIdList" parameterType="java.util.List" resultType="userExt">
        SELECT * FROM USER
        <where>
            <if test="list != null and list.size > 0"> <!-- 注意：如果是直接传入集合参数，则该处的参数名称只能填写list -->
                AND id IN
                <foreach collection="list" item="id" open="(" close=")" separator=",">
                    #{id}
                </foreach>
            </if>
        </where>
    </select>

• 编写Mapper接口

    // 综合查询：根据用户ID的集合查询用户列表（学习foreach标签之传递pojo对象中的List集合）
    public List<UserExt> findUsersByIdList(List<Integer> idList);

• 编写测试代码

    @Test
    public void testFindUsersByIdList() {
        // 根据SqlSessionFactory创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 创建UserMapper对象
        // 由Mybatis通过sqlSession来创建动态代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        // 构造List<Integer>集合
        List<Integer> idList = new ArrayList<Integer>();
        idList.add(28);
        idList.add(29);
        idList.add(30);

        List<UserExt> idList2 = mapper.findUsersByIdList(idList);
        System.out.println(idList2);

        sqlSession.close();
    }

8、mybatis与hibernate的区别及各自应用场景

• Mybatis技术特点：
  • 1、通过直接编写SQL语句，可以直接对SQL进行性能的优化。
  • 2、学习门槛低，学习成本低。只要有SQL基础，就可以学习mybatis，而且很容易上手；
  • 3、由于直接编写SQL语句，所以灵活多变，代码维护性更好。
  • 4、`不能支持数据库无关性`，即数据库发生变更，要写多套代码进行支持，移植性不好。
  • 5、需要编写结果映射。
• Hibernate技术特点：
  • 1、标准的ORM框架，程序员不需要编写SQL语句。
  • 2、`具有良好的数据库无关性`，即数据库发生变化的话，代码无需再次编写。
  • 3、学习门槛高，需要对`对象关系模型`有良好的基础，而且在设置OR映射的时候，需要考虑好性能和对象模型的权衡。
  • 4、程序员不能自主的去进行SQL性能优化。
• Mybatis应用场景：
  • 需求多变的互联网项目，例如：电商项目。
• Hibernate应用场景：
  • 需求明确、业务固定的项目，例如：OA项目、ERP项目等。