Mybatis 练习---mybatis 代理形式

目标

能够使用映射配置文件实现 CRUD 操作
能够使用注解实现 CRUD 操作

1，配置文件实现 CRUD

如上图所示产品原型，里面包含了品牌数据的 查询 、按条件查询、添加、删除、批量删除、修改 等功能，而这些功能其实就是对数据库表中的数据进行 CRUD 操作。接下来我们就使用 Mybatis 完成品牌数据的增删改查操作。以下是我们要完成功能列表：

查询
查询所有数据
查询详情
条件查询
添加
修改
修改全部字段
修改动态字段
删除
删除一个
批量删除

我们先将必要的环境准备一下。

1.1 环境准备

数据库表（tb_brand）及数据准备

sql

use mybatis;
-- 删除tb_brand表
drop table if exists tb_brand;
-- 创建tb_brand表
create table tb_brand
(
    -- id 主键
    id           int primary key auto_increment,
    -- 品牌名称
    brand_name   varchar(20),
    -- 企业名称
    company_name varchar(20),
    -- 排序字段
    ordered      int,
    -- 描述信息
    description  varchar(100),
    -- 状态：0：禁用  1：启用
    status       int
);
-- 添加数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
       ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
       ('小米', '小米科技有限公司', 50, 'are you ok', 1);

创建一个新的模块 brand-demo

复制依赖 jar 包坐标

xml

    <!--
            属性配置
              maven.compiler.source  maven编译源码环境 是jdk8
              maven.compiler.target  maven目标代码运行环境 jdk8
              <project.build.sourceEncoding 当前模块中 源码的编码集 utf-8
        -->
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!--
       mybatis
          需要导入哪些依赖
                 lombok
                 mysql
                 junit
                 mybatis
                 导入日志包  复制粘贴  就是可以看到 底层数据库运行的状态
    -->
    <dependencies>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>

        <!--mybatis 依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>

        <!--mysql 驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>

        <!--junit 单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

        <!-- 添加slf4j日志api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.20</version>
        </dependency>
        <!-- 添加logback-classic依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- 添加logback-core依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>

实体类 Brand

在 com.itheima.pojo 包下创建 Brand 实体类。

java

package com.itheima.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Brand {
    // id 主键
    private Integer id;
    // 品牌名称  brand_name  数据库中 字段名如果俩单词之间_
    // java是不是 第二单词首字母大写
    private String brandName;
    // 企业名称  company_name
    private String companyName;
    // 排序字段
    private Integer ordered;
    // 描述信息
    private String description;
    // 状态：0：禁用  1：启用
    private Integer status;
}

复制模板修改模板

mybatis-config.xml logback.xml XxxMapper.xml

注意 XxxMapper.xml 方法 resources 下面创建的目录 com\itheima\mapper

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">
<!--
  映射   现在BrandMapper.xml是一个 关于 user表操作的 映射文件
-->
<!--
   namespace=""  跟接口名 包名+类名 一致
      复制之后需要关注 这个名字是不 接口的包名+类名
   mapper标签里面子标签
     根据的不同操作 选择不同的 标签
       <select>  <insert> <update> <delete>
     id值 跟 接口方法名一致
     参数类型 跟接口方法参数类型一致
     返回值 跟接口的方法的返回值一致

-->
<mapper namespace="com.itheima.mapper.BrandMapper">


</mapper>

编写测试用例
测试代码需要在 test/java 目录下创建包及测试用例。

1.2 查询所有数据

如上图所示就页面上展示的数据，而这些数据需要从数据库进行查询。接下来我们就来讲查询所有数据功能，而实现该功能我们分以下步骤进行实现：

编写接口方法：Mapper 接口
- 参数：无
  查询所有数据功能是不需要根据任何条件进行查询的，所以此方法不需要参数。
- 结果：List<Brand>
  我们会将查询出来的每一条数据封装成一个 Brand 对象，而多条数据封装多个 Brand 对象，需要将这些对象封装到 List 集合中返回。
- 执行方法、测试

1.2.1 编写接口方法

在 com.itheima.mapper 包写创建名为 BrandMapper 的接口。并在该接口中定义 List<Brand> selectAll() 方法。

java

public interface BrandMapper {

    /**
     * 查询所有
     */
    List<Brand> selectAll();
}

1.2.2 编写 SQL 语句

在 reources 下创建 com/itheima/mapper 目录结构，并在该目录下创建名为 BrandMapper.xml 的映射配置文件

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">

<mapper namespace="com.itheima.mapper.BrandMapper">
    <select id="selectAll" resultType="brand">
        select *
        from tb_brand;
    </select>
</mapper>

1.2.3 编写测试方法

在 MybatisTest 类中编写测试查询所有的方法

java



    @Test
    public void selectAll() throws Exception{
        //开头三步 直接复制
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //测试步骤
        // 根据接口类型获取其实现类对象   (代理对象)
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        // 调用功能
        List<Brand> brands = mapper.selectAll();

        for (Brand brand : brands) {
            System.out.println(brand);
        }


        sqlSession.close();
    }

注意：现在我们感觉测试这部分代码写起来特别麻烦，我们可以先忍忍。以后我们只会写上面的第 3 步的代码，其他的都不需要我们来完成。

执行测试方法结果如下：

从上面结果我们看到了问题，有些数据封装成功了，而有些数据并没有封装成功。为什么这样呢？

这个问题可以通过两种方式进行解决：

给字段起别名
使用 resultMap 定义字段和属性的映射关系

1.2.4 起别名解决上述问题

从上面结果可以看到 brandName 和 companyName 这两个属性的数据没有封装成功，查询实体类和表中的字段发现，在实体类中属性名是 brandName 和 companyName ，而表中的字段名为 brand_name 和 company_name，如下图所示。那么我们只需要保持这两部分的名称一致这个问题就迎刃而解。

我们可以在写 sql 语句时给这两个字段起别名，将别名定义成和属性名一致即可。

xml

<select id="selectAll" resultType="brand">
    select
    id, brand_name as brandName, company_name as companyName, ordered, description, status
    from tb_brand;
</select>

而上面的 SQL 语句中的字段列表书写麻烦，如果表中还有更多的字段，同时其他的功能也需要查询这些字段时就显得我们的代码不够精炼。Mybatis 提供了sql 片段可以提高 sql 的复用性。

SQL 片段：

将需要复用的 SQL 片段抽取到 sql 标签中
xml
```
<sql id="brand_column">
 id, brand_name as brandName, company_name as companyName, ordered, description, status
</sql>
```
id 属性值是唯一标识，引用时也是通过该值进行引用。

在原 sql 语句中进行引用

使用 include 标签引用上述的 SQL 片段，而 refid 指定上述 SQL 片段的 id 值。

xml

<select id="selectAll" resultType="brand">
    select
    <include refid="brand_column" />
    from tb_brand;
</select>

1.2.5 使用 resultMap 解决上述问题

起别名 + sql 片段的方式可以解决上述问题，但是它也存在问题。如果还有功能只需要查询部分字段，而不是查询所有字段，那么我们就需要再定义一个 SQL 片段，这就显得不是那么灵活。

那么我们也可以使用 resultMap 来定义字段和属性的映射关系的方式解决上述问题。

在映射配置文件中使用 resultMap 定义字段和属性的映射关系

xml

<!--手动映射规则
            完成了表中 tb_brand中字段和 Brand类中属性的一一映射
    -->
    <resultMap id="brandResultMap" type="Brand">

        <!--
           Brand类型
           id;brandName; companyName;ordered;description; status;
           tb_brand表
           id,brand_name, company_name, ordered, description, status
           除了  brandName companyName以外其他的都一样 采用自动映射

           想要 表中的列 brand_name 的值  映射 给  Brand类型中的 属性 brandName
           想要 表中的列 company_name 的值  映射 给  Brand类型中的 属性 companyName

           每个 result代表一个映射
               column  列名
               property 属性名
        -->
        <result column="brand_name" property="brandName"/>
        <result column="company_name" property="companyName"/>
    </resultMap>

注意：在上面只需要定义字段名和属性名不一样的映射，而一样的则不需要专门定义出来。

SQL 语句正常编写

xml

<!--
   resultType  实现的是 表中字段和类中属性 自动的形式
   resultMap  实现手动映射  传入你写好的手动映射
-->
    <select id="selectAll" resultMap="brandResultMap">
        select * from tb_brand
    </select>

1.2.6 小结

实体类属性名和数据库表列名不一致，不能自动封装数据

==起别名：==在 SQL 语句中，对不一样的列名起别名，别名和实体类属性名一样
- 可以定义 <sql>片段，提升复用性
==resultMap：==定义<resultMap> 完成不一致的属性名和列名的映射

而我们最终选择使用 resultMap 的方式。查询映射配置文件中查询所有的 statement 书写如下：

xml

 <resultMap id="brandResultMap" type="brand">
     <!--
            id：完成主键字段的映射
                column：表的列名
                property：实体类的属性名
            result：完成一般字段的映射
                column：表的列名
                property：实体类的属性名
        -->
     <result column="brand_name" property="brandName"/>
     <result column="company_name" property="companyName"/>
</resultMap>



<select id="selectAll" resultMap="brandResultMap">
    select *
    from tb_brand;
</select>

1.3 查询详情

有些数据的属性比较多，在页面表格中无法全部实现，而只会显示部分，而其他属性数据的查询可以通过 查看详情 来进行查询，如上图所示。

查看详情功能实现步骤：

编写接口方法：Mapper 接口
- 参数：id
  查看详情就是查询某一行数据，所以需要根据 id 进行查询。而 id 以后是由页面传递过来。
- 结果：Brand
  根据 id 查询出来的数据只要一条，而将一条数据封装成一个 Brand 对象即可
编写 SQL 语句：SQL 映射文件
执行方法、进行测试

1.3.1 编写接口方法

在 BrandMapper 接口中定义根据 id 查询数据的方法

java

/**
  * 查看详情：根据Id查询
  */
Brand selectById(int id);

1.3.2 编写 SQL 语句

在 BrandMapper.xml 映射配置文件中编写 statement，使用 resultMap 而不是使用 resultType

xml

<select id="selectById"  resultMap="brandResultMap">
    select *
    from tb_brand where id = #{id};
</select>

注意：上述 SQL 中的 #{id}先这样写，一会我们再详细讲解

1.3.3 编写测试方法

在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法

java

 @Test
public void testSelectById() throws IOException {
    //接收参数，该id以后需要传递过来
    int id = 1;

    //1. 获取SqlSessionFactory
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    //2. 获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();

    //3. 获取Mapper接口的代理对象
    BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);

    //4. 执行方法
    Brand brand = brandMapper.selectById(id);
    System.out.println(brand);

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

执行测试方法结果如下：

1.3.4 参数占位符

查询到的结果很好理解就是 id 为 1 的这行数据。而这里我们需要看控制台显示的 SQL 语句，能看到使用？进行占位。说明我们在映射配置文件中的写的 #{id} 最终会被？进行占位。接下来我们就聊聊映射配置文件中的参数占位符。

mybatis 提供了两种参数占位符：

#{} ：执行 SQL 时，会将 #{} 占位符替换为？，将来自动设置参数值。从上述例子可以看出使用#{} 底层使用的是 PreparedStatement
${} ：拼接 SQL。底层使用的是 Statement，会存在 SQL 注入问题。如下图将映射配置文件中的 #{} 替换成 ${} 来看效果
xml
```
<select id="selectById"  resultMap="brandResultMap">
    select *
    from tb_brand where id = ${id};
</select>
```
重新运行查看结果如下：

==注意：==从上面两个例子可以看出，以后开发我们使用 #{} 参数占位符。

1.3.5 parameterType 使用

对于有参数的 mapper 接口方法，我们在映射配置文件中应该配置 ParameterType 来指定参数类型。只不过该属性都可以省略。如下图：

xml

<select id="selectById" parameterType="int" resultMap="brandResultMap">
    select *
    from tb_brand where id = ${id};
</select>

1.3.6 SQL 语句中特殊字段处理

以后肯定会在 SQL 语句中写一下特殊字符，比如某一个字段大于某个值，如下图

可以看出报错了，因为映射配置文件是 xml 类型的问题，而 > < 等这些字符在 xml 中有特殊含义，所以此时我们需要将这些符号进行转义，可以使用以下两种方式进行转义

转义字符
下图的 < 就是 < 的转义字符。
<![CDATA[内容]]>

1.4 多条件查询

我们经常会遇到如上图所示的多条件查询，将多条件查询的结果展示在下方的数据列表中。而我们做这个功能需要分析最终的 SQL 语句应该是什么样，思考两个问题

条件表达式
如何连接

条件字段 企业名称 和 品牌名称 需要进行模糊查询，所以条件应该是：

简单的分析后，我们来看功能实现的步骤：

编写接口方法
- 参数：所有查询条件
- 结果：List<Brand>
在映射配置文件中编写 SQL 语句
编写测试方法并执行

1.4.1 编写接口方法

在 BrandMapper 接口中定义多条件查询的方法。

而该功能有三个参数，我们就需要考虑定义接口时，参数应该如何定义。Mybatis 针对多参数有多种实现

使用 @Param("参数名称") 标记每一个参数，在映射配置文件中就需要使用 #{参数名称} 进行占位

java

List<Brand> selectByCondition(@Param("status") int status, @Param("companyName") String companyName,@Param("brandName") String brandName);

将多个参数封装成一个实体对象，将该实体对象作为接口的方法参数。该方式要求在映射配置文件的 SQL 中使用 #{内容} 时，里面的内容必须和实体类属性名保持一致。
java
```
List<Brand> selectByCondition(Brand brand);
```
将多个参数封装到 map 集合中，将 map 集合作为接口的方法参数。该方式要求在映射配置文件的 SQL 中使用 #{内容} 时，里面的内容必须和 map 集合中键的名称一致。
java
```
List<Brand> selectByCondition(Map map);
```

1.4.2 编写 SQL 语句

开发推荐采用第一种形式

在接口中定义

java

/*
     需求
        根据  状态  品牌名称  公司名称  进行多条件查询
           其中 状态是准确查询  品牌名称和公司名称 都是模糊查询
        查出来的是0-n条数据

        两个确定
          确定返回值类型   List<Brand>
          确定参数列表    int status  ,String brandName,String companyName
        一个方法名
            selectByCondition  根据条件查询
    */
   List<Brand> selectByCondition(@Param("status") int statu  ,@Param("brandName") String brandName, @Param("companyName") String companyName);

在 BrandMapper.xml 映射配置文件中编写 statement，使用 resultMap 而不是使用 resultType

xml

<select id="selectByCondition" resultMap="brandResultMap">
    select *
    from tb_brand
    where status = #{status}
    and company_name like #{companyName}
    and brand_name like #{brandName}
</select>

1.4.3 编写测试方法

在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法

java

  @Test
    public void selectByCondition() throws Exception{
        //开头三步 直接复制
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //测试步骤
        // 根据接口类型获取其实现类对象   (代理对象)
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        // 调用功能
       //定义好三个条件
        int status = 1;
        String brandName = "%华%";
        String companyName="%华为%";

        List<Brand> brands = mapper.selectByCondition(1, brandName, companyName);

        //方式二 ：接口方法参数是 实体类对象 方式调用的方法
     //封装对象
    /* Brand brand = new Brand();
        brand.setStatus(status);
        brand.setCompanyName(companyName);
        brand.setBrandName(brandName);*/

    //List<Brand> brands = brandMapper.selectByCondition(brand);

        for (Brand brand : brands) {
            System.out.println(brand);
        }

        sqlSession.close();
    }

还可以使用 map 集合对象形式进行多条件查询

接口:

java

   /*
     实现多条件
    */
    List<Brand> selectByMap(Map map);

xml

 <!--
      List<Brand> selectByMap(Map map);
    -->
    <select id="selectByMap" resultMap="brandResultMap">
 select * from tb_brand
        where status=#{status}
            and brand_name like #{brandName}
              and company_name like #{companyName}
    </select>

测试:

java

@Test
    public void selectByMap() throws Exception{
        //开头三步 直接复制
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //测试步骤
        // 根据接口类型获取其实现类对象   (代理对象)
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        // 调用功能
        //定义好三个条件
        int status = 1;
        String brandName = "%华%";
        String companyName="%华为%";

        Map map = new HashMap();

        map.put("status",status);//键是 #{名字}  #{status}
//        map.put("brandName",brandName);//#{brandName}
//        map.put("companyName",companyName);//#{companyName}
        List<Brand> brands = mapper.selectByMap(map);

        for (Brand brand : brands) {
            System.out.println(brand);
        }

        sqlSession.close();
    }

1.4.4 动态 SQL

上述功能实现存在很大的问题。用户在输入条件时，肯定不会所有的条件都填写，这个时候我们的 SQL 语句就不能那样写的

例如用户只输入当前状态时，SQL 语句就是

sql

select * from tb_brand where status = #{status}

而用户如果只输入企业名称时，SQL 语句就是

sql

select * from tb_brand where company_name like #{companName}

而用户如果输入了 当前状态 和 企业名称 时，SQL 语句又不一样

sql

select * from tb_brand where status = #{status} and company_name like #{companName}

如果啥也不输入呢？

sql

select * from tb_brand

简单形式就是有什么条件加什么条件！！没有条件就没有 where!!

xml

<where>
     特点就是 有条件就where 关键字
        没条件就没where

针对上述的需要，Mybatis 对动态 SQL 有很强大的支撑：

if
choose (when, otherwise)
trim (where, set)
foreach

我们先学习 if 标签和 where 标签：

if 标签：条件判断

test 属性：逻辑表达式

xml

<select id="selectByMap" resultMap="brandResultMap">
    select *
    from tb_brand
    where
        <if test="status != null">
            and status = #{status}
        </if>
        <if test="companyName != null and companyName != '' ">
            and company_name like #{companyName}
        </if>
        <if test="brandName != null and brandName != '' ">
            and brand_name like #{brandName}
        </if>
</select>

如上的这种 SQL 语句就会根据传递的参数值进行动态的拼接。如果此时 status 和 companyName 有值那么就会值拼接这两个条件。

执行结果如下：

但是它也存在问题，如果此时给的参数值是

java

Map map = new HashMap();
// map.put("status" , status);
map.put("companyName", companyName);
map.put("brandName" , brandName);

拼接的 SQL 语句就变成了

sql

select * from tb_brand where and company_name like ? and brand_name like ?

而上面的语句中 where 关键后直接跟 and 关键字，这就是一条错误的 SQL 语句。这个就可以使用 where 标签解决

where 标签

作用：
- 替换 where 关键字
- 会动态的去掉第一个条件前的 and
- 如果所有的参数没有值则不加 where 关键字

xml

<select id="selectByMap" resultMap="brandResultMap">
    select *
    from tb_brand
    <where>
        <if test="status != null">
            and status = #{status}
        </if>
        <if test="companyName != null and companyName != '' ">
            and company_name like #{companyName}
        </if>
        <if test="brandName != null and brandName != '' ">
            and brand_name like #{brandName}
        </if>
    </where>
</select>

注意：需要给每个条件前都加上 and 关键字。

1.5 单个条件（动态 SQL）

如上图所示，在查询时只能选择 品牌名称、当前状态、企业名称 这三个条件中的一个，但是用户到底选择哪儿一个，我们并不能确定。这种就属于单个条件的动态 SQL 语句。

这种需求需要使用到 choose（when，otherwise）标签 实现，而 choose 标签类似于 Java 中的 switch 语句。

通过一个案例来使用这些标签

1.5.1 编写接口方法

在 BrandMapper 接口中定义单条件查询的方法。

java

  /*
      多个条件里面选一个 进行单条件查询

        返回值类型   List<Brand>根据一个条件可以查询出多个结果
        参数列表
               int status String brandName String companyName
               Brand类型--因为三种数据是不是都是brand类型中属性
        方法名
           selectByConditionSingle
     */
    List<Brand> selectByConditionSingle(Brand brand);

1.5.2 编写 SQL 语句

在 BrandMapper.xml 映射配置文件中编写 statement，使用 resultMap 而不是使用 resultType

xml

<!--
      根据单条件查询
       List<Brand> selectByConditionSingle(Brand brand);

         choose   选择  有点像  switch  多个里面选一个
           当满足什么条件就选择什么
            <when test=>    就像  case
   -->
    <select id="selectByConditionSingle" resultMap="brandResultMap">
        select * from tb_brand
            <where>
               <choose>
                   <when test="status!=null">
                       status=#{status}
                   </when>
                   <when test="brandName!=null and brandName!=''">
                       brand_name like  #{brandName}
                   </when>
                   <when test="companyName!=null and companyName!=''">
                       company_name like #{companyName}
                   </when>
               </choose>
            </where>
    </select>

1.5.3 编写测试方法

在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法

java

  @Test
    public void selectByConditionSingle() throws Exception{
        //开头三步 直接复制
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //测试步骤
        // 根据接口类型获取其实现类对象   (代理对象)
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        // 调用功能
        //定义好三个条件
        int status = 0;
        String brandName = "%华%";
        String companyName="%华为%";

       Brand brand = new Brand();
//       brand.setStatus(status);
//       brand.setBrandName(brandName);
        brand.setCompanyName(companyName);
        List<Brand> brands = mapper.selectByConditionSingle(brand);

        for (Brand brand2 : brands) {
            System.out.println(brand2);
        }

        sqlSession.close();
    }

执行测试方法结果如下：

1.6 添加数据

如上图是我们平时在添加数据时展示的页面，而我们在该页面输入想要的数据后添加 提交 按钮，就会将这些数据添加到数据库中。接下来我们就来实现添加数据的操作。

编写接口方法
参数：除了 id 之外的所有的数据。id 对应的是表中主键值，而主键我们是 ==自动增长== 生成的。
编写 SQL 语句
编写测试方法并执行

明确了该功能实现的步骤后，接下来我们进行具体的操作。

1.6.1 编写接口方法

在 BrandMapper 接口中定义添加方法。

java

 /**
   * 添加
   */
void add(Brand brand);

1.6.2 编写 SQL 语句

在 BrandMapper.xml 映射配置文件中编写添加数据的 statement

xml

<insert id="add">
    insert into tb_brand (brand_name, company_name, ordered, description, status)
    values (#{brandName}, #{companyName}, #{ordered}, #{description}, #{status});
</insert>

1.6.3 编写测试方法

在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法

java

@Test
public void testAdd() throws IOException {
    //接收参数
    int status = 1;
    String companyName = "波导手机";
    String brandName = "波导";
    String description = "手机中的战斗机";
    int ordered = 100;

    //封装对象
    Brand brand = new Brand();
    brand.setStatus(status);
    brand.setCompanyName(companyName);
    brand.setBrandName(brandName);
    brand.setDescription(description);
    brand.setOrdered(ordered);

    //1. 获取SqlSessionFactory
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    //2. 获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //SqlSession sqlSession = sqlSessionFactory.openSession(true); //设置自动提交事务，这种情况不需要手动提交事务了
    //3. 获取Mapper接口的代理对象
    BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
    //4. 执行方法
    brandMapper.add(brand);
    //提交事务
    sqlSession.commit();
    //5. 释放资源
    sqlSession.close();
}

执行结果如下：

1.6.4 添加-主键返回

在数据添加成功后，有时候需要获取插入数据库数据的主键（主键是自增长）。

比如：添加订单和订单项，如下图就是京东上的订单

订单数据存储在订单表中，订单项存储在订单项表中。

添加订单数据
添加订单项数据，订单项中需要设置所属订单的 id

明白了什么时候 主键返回 。接下来我们简单模拟一下，在添加完数据后打印 id 属性值，能打印出来说明已经获取到了。

我们将上面添加品牌数据的案例中映射配置文件里 statement 进行修改，如下

xml

   <!--    /*
      完成 添加操作
     */
    void add(Brand brand);

    需要做主键回显
        就需要两个属性 写出来
          useGeneratedKeys  是否要获取自增主键的值。
          keyProperty  把这个主键的值 给谁？给哪个属性信息

    -->
    <insert id="add" useGeneratedKeys="true" keyProperty="id">
        insert into tb_brand
         values(null,#{brandName},#{companyName},#{ordered},#{description},#{status})
    </insert>

在 insert 标签上添加如下属性：
useGeneratedKeys：是够获取自动增长的主键值。true 表示获取
keyProperty ：指定将获取到的主键值封装到哪儿个属性里

测试代码

java

 @Test
    public void add() throws Exception{
        //开头三步 直接复制
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //测试步骤
        // 根据接口类型获取其实现类对象   (代理对象)
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);

        //设置添加的数据
        Brand brand = new Brand();

        //添加的数据不包含id 因为是自增的
        brand.setBrandName("波导手机");
        brand.setCompanyName("波导");
        brand.setOrdered(10);
        brand.setDescription("手机中的战斗机");
        brand.setStatus(1);
        System.out.println("我们添加之前的brand对象:"+brand);
        mapper.add(brand);
        System.out.println("我们添加之后的brand对象:"+brand);
        //我们的sqlsession是手动提交事务 需要我们做提交 。
        sqlSession.commit();
        //释放资源
        sqlSession.close();
    }

效果

1644374036905

1.7 修改

如图所示是修改页面，用户在该页面书写需要修改的数据，点击 提交 按钮，就会将数据库中对应的数据进行修改。注意一点，如果哪儿个输入框没有输入内容，我们是将表中数据对应字段值替换为空白还是保留字段之前的值？答案肯定是保留之前的数据。

接下来我们就具体来实现

1.7.1 编写接口方法

在 BrandMapper 接口中定义修改方法。

java

 /**
   * 修改
   */
void update(Brand brand);

上述方法参数 Brand 就是封装了需要修改的数据，而 id 肯定是有数据的，这也是和添加方法的区别。

1.7.2 编写 SQL 语句

在 BrandMapper.xml 映射配置文件中编写修改数据的 statement。

xml

<!--修改动态字段，我修改了哪个字段 那个字段就进行设置  没有修改哪个字段就保留(不用设置)

       set标签用于包裹住需要设置的字段
          哪些数据需要被更新呢？
             brand对象中 封装了就需要被更新 没有封装就保留 不需要设置
             怎么判断  提供一个标签 <if>

             我们先判断 该字段有没有被封装，是不是有效数据
                被封装了还是有效数据  要更新
                没有被封装 或者不是有效数据  不更新 保留原来的数据
    -->
    <update id="update">
        update tb_brand
           <set>
               <if test="brandName!=null and brandName!=''">
                   brand_name=#{brandName},
               </if>
               <if test="companyName!=null and companyName!=''">
                   company_name=#{companyName},
               </if>
               <if test="ordered!=null and ordered!=''">
                   ordered=#{ordered},
               </if>
               <if test="description!=null and description!=''">
                   description=#{description},
               </if>
               <if test="status!=null and status!=''">
                   status=#{status},
               </if>
           </set>
            where id=#{id}
    </update>

set 标签可以用于动态包含需要更新的列，忽略其它不更新的列。

1.7.3 编写测试方法

在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法

java

   @Test
    public void update() throws Exception{
        //开头三步 直接复制
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //测试步骤
        // 根据接口类型获取其实现类对象   (代理对象)
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);

        Brand brand1 = mapper.selectById(28);
        System.out.println("修改前的信息:"+brand1);

        //设置修改的数据
        Brand brand = new Brand();
        //修改数据 必须要写id  如果是修改全部字段 需要设置全部字段
                          //如果动态修改，修改什么设置什么
        brand.setId(28);
        brand.setBrandName("望谷");
        brand.setCompanyName("美");
//        brand.setOrdered(10);
//        brand.setDescription("手机中的战斗机");
//        brand.setStatus(1);
        System.out.println("我们修改时候传递的brand对象:"+brand);
           //修改
        mapper.update(brand);
        Brand brand2 = mapper.selectById(28);
        System.out.println("修改后的信息:"+brand2);

        //我们的sqlsession是手动提交事务 需要我们做提交 。
        sqlSession.commit();
        //释放资源
        sqlSession.close();
    }

执行测试方法结果如下：

1644374128747

从结果中 SQL 语句可以看出，只修改了 status 字段值，因为我们给的数据中只给 Brand 实体对象的 status 属性设置值了。这就是 set 标签的作用。

1.8 删除一行数据

如上图所示，每行数据后面都有一个 删除 按钮，当用户点击了该按钮，就会将改行数据删除掉。那我们就需要思考，这种删除是根据什么进行删除呢？是通过主键 id 删除，因为 id 是表中数据的唯一标识。

接下来就来实现该功能。

1.8.1 编写接口方法

在 BrandMapper 接口中定义根据 id 删除方法。

java

/**
  * 根据id删除
  */
void deleteById(int id);

1.8.2 编写 SQL 语句

在 BrandMapper.xml 映射配置文件中编写删除一行数据的 statement

xml

<delete id="deleteById">
    delete from tb_brand where id = #{id};
</delete>

1.8.3 编写测试方法

在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法

java

 @Test
public void testDeleteById() throws IOException {
    //接收参数
    int id = 6;

    //1. 获取SqlSessionFactory
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    //2. 获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //SqlSession sqlSession = sqlSessionFactory.openSession(true);
    //3. 获取Mapper接口的代理对象
    BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
    //4. 执行方法
    brandMapper.deleteById(id);
    //提交事务
    sqlSession.commit();
    //5. 释放资源
    sqlSession.close();
}

运行过程只要没报错，直接到数据库查询数据是否还存在。

1.9 批量删除

如上图所示，用户可以选择多条数据，然后点击上面的 删除 按钮，就会删除数据库中对应的多行数据。

1.9.1 编写接口方法

在 BrandMapper 接口中定义删除多行数据的方法。

java

/**
  * 批量删除
  */
void deleteByIds(int[] ids);

参数是一个数组，数组中存储的是多条数据的 id

1.9.2 编写 SQL 语句

在 BrandMapper.xml 映射配置文件中编写删除多条数据的 statement。

编写 SQL 时需要遍历数组来拼接 SQL 语句。Mybatis 提供了 foreach 标签供我们使用

foreach 标签

用来迭代任何可迭代的对象（如数组，集合）。

collection 属性：
- mybatis 会将数组参数，封装为一个 Map 集合。
  - 默认：array = 数组
  - 使用@Param 注解改变 map 集合的默认 key 的名称
item 属性：本次迭代获取到的元素。
separator 属性：集合项迭代之间的分隔符。foreach 标签不会错误地添加多余的分隔符。也就是最后一次迭代不会加分隔符。
open 属性：该属性值是在拼接 SQL 语句之前拼接的语句，只会拼接一次
close 属性：该属性值是在拼接 SQL 语句拼接后拼接的语句，只会拼接一次

xml

   <!--
    void deleteByIds(int[] ids);
    根据多个id进行删除
         int[] ids = {3,4,5};
         delete from tb_brand where id in(3,4,5);
            问题:  (3,4,5)  应该是由 遍历 数组 ids出来的内容
            <foreach>完成遍历 数组或者集合
               属性
                  collection 容器类型  如果是数组写 array  如果是list集合 写 list
                  open 遍历之前干点啥 拼接点啥
                  close 遍历之后干点啥   拼接点啥
                  item 项的意思 就是数组中每个元素项
                       item="id"  每次遍历的时候 id用于接收 每个元素
                       #{id}  把每个元素拿出来进行拼接

           delete from tb_brand where id in (3,4,5)
    -->
    <delete id="deleteByIds">
        delete from tb_brand where id in
             <foreach collection="array" open="(" close=")" item="id" separator=",">
                 #{id}
             </foreach>
    </delete>

假如数组中的 id 数据是{1,2,3}，那么拼接后的 sql 语句就是：
sql
delete from tb_brand where id in (1,2,3);

1.9.3 编写测试方法

在 test/java 下的 com.itheima.mapper 包下的 MybatisTest类中 定义测试方法

java

 @Test
    public void deleteByIds() throws Exception{
        //开头三步 直接复制
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //测试步骤
        // 根据接口类型获取其实现类对象   (代理对象)
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);

     int[] ids = {3,4,5};

     mapper.deleteByIds(ids);

        //我们的sqlsession是手动提交事务 需要我们做提交 。
        sqlSession.commit();
        //释放资源
        sqlSession.close();
    }

1.10 Mybatis 参数传递

Mybatis 接口方法中可以接收各种各样的参数，如下：

多个参数
单个参数：单个参数又可以是如下类型
- POJO 类型
- Map 集合类型
- Collection 集合类型
- List 集合类型
- Array 类型
- 其他类型

1.10.1 多个参数

如下面的代码，就是接收两个参数，而接收多个参数需要使用 @Param 注解，那么为什么要加该注解呢？这个问题要弄明白就必须来研究 Mybatis 底层对于这些参数是如何处理的。

java

User select(@Param("username") String username,@Param("password") String password);

xml

<select id="select" resultType="user">
 select *
    from tb_user
    where
     username=#{username}
     and password=#{password}
</select>

我们在接口方法中定义多个参数，Mybatis 会将这些参数封装成 Map 集合对象，值就是参数值，而键在没有使用 @Param 注解时有以下命名规则：

以 arg 开头：第一个参数就叫 arg0，第二个参数就叫 arg1，以此类推。如：
map.put("arg0"，参数值 1);
map.put("arg1"，参数值 2);
以 param 开头：第一个参数就叫 param1，第二个参数就叫 param2，依次类推。如：
map.put("param1"，参数值 1);
map.put("param2"，参数值 2);

代码验证：

在 UserMapper 接口中定义如下方法

java

User select(String username,String password);

在 UserMapper.xml 映射配置文件中定义 SQL

xml

<select id="select" resultType="user">
 select *
    from tb_user
    where
     username=#{arg0}
     and password=#{arg1}
</select>

或者

xml

<select id="select" resultType="user">
 select *
    from tb_user
    where
     username=#{param1}
     and password=#{param2}
</select>

运行代码结果如下
在映射配合文件的 SQL 语句中使用用 arg 开头的和 param 书写，代码的可读性会变的特别差，此时可以使用 @Param 注解。

在接口方法参数上使用 @Param 注解，Mybatis 会将 arg 开头的键名替换为对应注解的属性值。

代码验证：

在 UserMapper 接口中定义如下方法，在 username 参数前加上 @Param 注解
java
```
User select(@Param("username") String username, String password);
```
Mybatis 在封装 Map 集合时，键名就会变成如下：
map.put("username"，参数值 1);
map.put("arg1"，参数值 2);
map.put("param1"，参数值 1);
map.put("param2"，参数值 2);

在 UserMapper.xml 映射配置文件中定义 SQL

xml

<select id="select" resultType="user">
 select *
    from tb_user
    where
     username=#{username}
     and password=#{param2}
</select>

运行程序结果没有报错。而如果将 #{} 中的 username 还是写成 arg0

xml

<select id="select" resultType="user">
 select *
    from tb_user
    where
     username=#{arg0}
     and password=#{param2}
</select>

运行程序则可以看到错误

==结论：以后接口参数是多个时，在每个参数上都使用 @Param 注解。这样代码的可读性更高。==

1.10.2 单个参数

POJO 类型
直接使用。要求 属性名 和 参数占位符名称 一致
Map 集合类型
直接使用。要求 map集合的键名 和 参数占位符名称 一致
Collection 集合类型
Mybatis 会将集合封装到 map 集合中，如下：
map.put("arg0"，collection 集合);
map.put("collection"，collection) 集合;
==可以使用 @Param 注解替换 map 集合中默认的 arg 键名。==
List 集合类型
Mybatis 会将集合封装到 map 集合中，如下：
map.put("arg0"，list 集合);
map.put("collection"，list 集合);
map.put("list"，list 集合);
==可以使用 @Param 注解替换 map 集合中默认的 arg 键名。==
Array 类型
Mybatis 会将集合封装到 map 集合中，如下：
map.put("arg0"，数组);
map.put("array"，数组);
==可以使用 @Param 注解替换 map 集合中默认的 arg 键名。==
其他类型
比如 int 类型，参数占位符名称 叫什么都可以。尽量做到见名知意

2，注解实现 CRUD

使用注解开发会比配置文件开发更加方便。如下就是使用注解进行开发

java

@Select(value = "select * from tb_user where id = #{id}")
public User select(int id);

==注意：==
注解是用来替换映射配置文件方式配置的，所以使用了注解，就不需要再映射配置文件中书写对应的 statement

Mybatis 针对 CURD 操作都提供了对应的注解，已经做到见名知意。如下：

查询：@Select
添加：@Insert
修改：@Update
删除：@Delete

接下来我们做一个案例来使用 Mybatis 的注解开发

代码实现：

将之前案例中 UserMapper.xml 中的根据 id 查询数据的 statement 注释掉
在 UserMapper 接口的 selectById 方法上添加注解
运行测试程序也能正常查询到数据

我们课程上只演示这一个查询的注解开发，其他的同学们下来可以自己实现，都是比较简单。

==注意：==在官方文档中 入门 中有这样的一段话：

所以，==注解完成简单功能，配置文件完成复杂功能。==

而我们之前写的动态 SQL 就是复杂的功能，如果用注解使用的话，就需要使用到 Mybatis 提供的 SQL 构建器来完成，而对应的代码如下：

上述代码将 java 代码和 SQL 语句融到了一块，使得代码的可读性大幅度降低。

安装 MyBatisX 插件

MybatisX 是一款基于 IDEA 的快速开发插件，为效率而生。
主要功能
- XML 映射配置文件和接口方法间相互跳转
- 根据接口方法生成 statement
安装方式
点击 file ，选择 settings ，就能看到如下图所示界面
注意：安装完毕后需要重启 IDEA
插件效果
红色头绳的表示映射配置文件，蓝色头绳的表示 mapper 接口。在 mapper 接口点击红色头绳的小鸟图标会自动跳转到对应的映射配置文件，在映射配置文件中点击蓝色头绳的小鸟图标会自动跳转到对应的 mapper 接口。也可以在 mapper 接口中定义方法，自动生成映射配置文件中的 statement ，如图所示

Mybatis 练习---mybatis 代理形式 ​

目标 ​

1，配置文件实现 CRUD ​

1.1 环境准备 ​

1.2 查询所有数据 ​

1.2.1 编写接口方法 ​

1.2.2 编写 SQL 语句 ​

1.2.3 编写测试方法 ​

1.2.4 起别名解决上述问题 ​

1.2.5 使用 resultMap 解决上述问题 ​

1.2.6 小结 ​

1.3 查询详情 ​

1.3.1 编写接口方法 ​

1.3.2 编写 SQL 语句 ​

1.3.3 编写测试方法 ​

1.3.4 参数占位符 ​

1.3.5 parameterType 使用 ​

1.3.6 SQL 语句中特殊字段处理 ​

1.4 多条件查询 ​

1.4.1 编写接口方法 ​

1.4.2 编写 SQL 语句 ​

1.4.3 编写测试方法 ​

1.4.4 动态 SQL ​

1.5 单个条件（动态 SQL） ​

1.5.1 编写接口方法 ​

1.5.2 编写 SQL 语句 ​

1.5.3 编写测试方法 ​

1.6 添加数据 ​

1.6.1 编写接口方法 ​

1.6.2 编写 SQL 语句 ​

1.6.3 编写测试方法 ​

1.6.4 添加-主键返回 ​

1.7 修改 ​

1.7.1 编写接口方法 ​

1.7.2 编写 SQL 语句 ​

1.7.3 编写测试方法 ​

1.8 删除一行数据 ​

1.8.1 编写接口方法 ​

1.8.2 编写 SQL 语句 ​

1.8.3 编写测试方法 ​

1.9 批量删除 ​

1.9.1 编写接口方法 ​

1.9.2 编写 SQL 语句 ​

foreach 标签 ​

1.9.3 编写测试方法 ​

1.10 Mybatis 参数传递 ​

1.10.1 多个参数 ​

1.10.2 单个参数 ​

2，注解实现 CRUD ​

Mybatis 练习---mybatis 代理形式

目标

1，配置文件实现 CRUD

1.1 环境准备

1.2 查询所有数据

1.2.1 编写接口方法

1.2.2 编写 SQL 语句

1.2.3 编写测试方法

1.2.4 起别名解决上述问题

1.2.5 使用 resultMap 解决上述问题

1.2.6 小结

1.3 查询详情

1.3.1 编写接口方法

1.3.2 编写 SQL 语句

1.3.3 编写测试方法

1.3.4 参数占位符

1.3.5 parameterType 使用

1.3.6 SQL 语句中特殊字段处理

1.4 多条件查询

1.4.1 编写接口方法

1.4.2 编写 SQL 语句

1.4.3 编写测试方法

1.4.4 动态 SQL

1.5 单个条件（动态 SQL）

1.5.1 编写接口方法

1.5.2 编写 SQL 语句

1.5.3 编写测试方法

1.6 添加数据

1.6.1 编写接口方法

1.6.2 编写 SQL 语句

1.6.3 编写测试方法

1.6.4 添加-主键返回

1.7 修改

1.7.1 编写接口方法

1.7.2 编写 SQL 语句

1.7.3 编写测试方法

1.8 删除一行数据

1.8.1 编写接口方法

1.8.2 编写 SQL 语句

1.8.3 编写测试方法

1.9 批量删除

1.9.1 编写接口方法

1.9.2 编写 SQL 语句

foreach 标签

1.9.3 编写测试方法

1.10 Mybatis 参数传递

1.10.1 多个参数

1.10.2 单个参数

2，注解实现 CRUD