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

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的值保持一致。
  • 通过规范式的开发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<StringObject> hashMap);

编写测试代码

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

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

        // 构造查询条件HashMap对象
        HashMap<StringObject> hashMap = new HashMap<StringObject>();
        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项目等。



You must enable javascript to see captcha here!

Copyright © All Rights Reserved · Green Hope Theme by Sivan & schiy · Proudly powered by WordPress

无觅相关文章插件,快速提升流量