MyBatis中配置文件实现增删改查

配置文件完成增删改查：

完成品牌数据的增删改查操作

要完成的功能列表清单：

​ 1、查询：

​ 查询所有数据

​ 查看详情

​ 条件查询

​ 2、添加

​ 3、修改：

​ 修改全部字段

​ 修改动态字段

​ 4、删除：

​ 删除一个

​ 批量删除

准备环境：

​ 数据库表tb_brand

-- 删除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);
 
 
SELECT * FROM tb_brand;

​ 实体类 Brand

package com.itheima.pojo;
 
/**
 * 品牌
 *
 * alt + 鼠标左键：整列编辑
 *
 * 在实体类中，基本数据类型建议使用其对应的包装类型
 */
 
public class Brand {
    // id 主键
    private Integer id;
    // 品牌名称
    private String brandName;
    // 企业名称
    private String companyName;
    // 排序字段
    private Integer ordered;
    // 描述信息
    private String description;
    // 状态：0：禁用  1：启用
    private Integer status;
 
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getBrandName() {
        return brandName;
    }
 
    public void setBrandName(String brandName) {
        this.brandName = brandName;
    }
 
    public String getCompanyName() {
        return companyName;
    }
 
    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }
 
    public Integer getOrdered() {
        return ordered;
    }
 
    public void setOrdered(Integer ordered) {
        this.ordered = ordered;
    }
 
    public String getDescription() {
        return description;
    }
 
    public void setDescription(String description) {
        this.description = description;
    }
 
    public Integer getStatus() {
        return status;
    }
 
    public void setStatus(Integer status) {
        this.status = status;
    }
 
    @Override
    public String toString() {
        return "Brand{" +
                "id=" + id +
                ", brandName='" + brandName + '\'' +
                ", companyName='" + companyName + '\'' +
                ", ordered=" + ordered +
                ", description='" + description + '\'' +
                ", status=" + status +
                '}';
    }
}

​ 测试用例

​ 在test的Java下创建一个测试类

​ 安装 MyBatisX 插件:

​ MyBatisX是一款基于IDEA的快速开发插件，为效率而生。

​ 主要功能：

​ XML 和 接口方法 相互跳转

​ 根据接口方法生成 statement

1、查询：

查询 - 查询所有数据

​ 1、编写接口方法：Mapper接口

​ 参数：无

​ 返回结果：List

List<Brand> selectAll();

​ 2、编写SQL语句：SQL映射文件

<select id = "selectAll" resultType = "Brand">
	select * from tb_brand;
</select>

​ 3、执行方法，测试

参考代码：

mybatis核心文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
 
    <!-- 扫描包后，这个包下的类可以直接使用类名作路径，且不区分大小写 -->
    <typeAliases>
        <package name = "com.itheima.pojo"/>
    </typeAliases>
 
    <!--
     environments：配置数据库连接环境信息，可以配置多个environment，通过default属性与environment中的id来匹配
    -->
    <environments default="development">
 
        <environment id="development">
            <!--   事务的管理方式   -->
            <transactionManager type="JDBC"/>
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <!-- 数据库的连接信息 -->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!-- 加载sql的映射文件 -->
<!--        <mapper resource="com\itheima\mapper\UserMapper.xml"/>-->
 
        <!-- Mapper代理方式 -->
        <package name="com.itheima.mapper"/>
 
    </mappers>
</configuration>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
 
<!--
    SQL映射文件
 -->
<mapper namespace="com.itheima.mapper.BrandMapper">
    <!--
        数据库表的字段名称 和 实体类的属性名称一样，则不能自动封装数据
            1、起别名：对不一样的列名起别名，让别名和实体类的属性名一样
                缺点：每次查询都要定义一次别名
                在此基础上使用sql片段
                    缺点：不灵活
 
            2、resultMap:
                定义<resultMap>标签
                在<select>标签中，使用resultMap属性替换resultType属性
 
    -->
 
    <!--
        id：唯一标识
        type：映射的类型，支持别名
    -->
 
    <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>
 
    <!-- =============================================== -->
 
    <!--
        sql片段
     -->
<!--    <sql id="brand_column">-->
<!--        id, brand_name as brandName, company_name as companyName, ordered, description, status-->
<!--    </sql>-->
 
<!--    <select id="selectAll" resultType="brand">-->
<!--        select-->
<!--            &lt;!&ndash; 将对应的sql片段放在这个位置 &ndash;&gt;-->
<!--            <include refid="brand_column"/>-->
<!--        from tb_brand;-->
<!--    </select>-->
 
    <!-- =============================================== -->
 
    <!--    <select id="selectAll" resultType="Brand">-->
<!--        select * from tb_brand;-->
<!--    </select>-->
 
</mapper>

//对应接口
package com.itheima.mapper;
 
import com.itheima.pojo.Brand;
 
import java.util.List;
 
public interface BrandMapper {
    /**
     * 查询所有
     */
    public List<Brand> selectAll();
}

package com.itheima.test;
 
import com.itheima.mapper.BrandMapper;
import com.itheima.pojo.Brand;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
 
public class MyBatisTest {
    @Test
    public void testSelectAll() throws IOException {
        //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、执行方法
        List<Brand> brands = brandMapper.selectAll();   //将来就写这一行
        System.out.println(brands);
 
        //5、释放资源
        sqlSession.close();
    }
}

问题：当数据库中的表的列名与实体类中的属性名不一样是，读取数据有问题

使用resultMap来解决的参考代码：

	<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、编写接口：Mapper接口

​ 参数：id

​ 结果：Brand

Brand selectById(int id);

2、执行SQL语句：SQL映射文件

<select id = "selectById" parameterType = "int" resultType = "Brand">
	select * from tb_brand where id = #{id};
</select>

3、执行方法，测试

参考代码：

接口中添加的方法：

/**
     * 根据id，查看详情
     */
    public Brand selectById(int id);

SQL映射添加内容

<!--
        参数占位符：
            1、#{}：会将其替换为?占位符，防止SQL注入
            2、${}：拼接SQL会存在SQL注入问题
            3、使用时机：
                参数传递时：#{}
                表名或者列名不固定的情况下：${}，会存在SQL注入问题
 
         参数类型：parameterType，可以省略
         特殊字符的处理：
            1、转义字符：特殊字符较少
            2、CDATA区：特殊字符较多
     -->
 
<!--    <select id="selectById" parameterType="int" resultMap="brandResultMap">-->
<!--        select * from tb_brand where id = #{id};-->
<!--    </select>-->
 
    <select id="selectById" parameterType="int" resultMap="brandResultMap">
        select * from tb_brand where id
        <![CDATA[
            <
        ]]>
        #{id};
    </select>

测试方法：

 	@Test
    public void testSelectById() throws IOException {
        //定义一个id模拟接收到的 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、编写接口方法：Mapper接口

​ 参数：所有查询条件

​ 结果：List

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

2、编写SQL语句：SQL映射文件

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

3、执行方法，测试

/**
     * 条件查询
     *   1、散装的参数：如果方法中有多个参数，需要使用@Param("SQL映射中的参数占位符名称，即#{}中的")
     *   2、对象参数：对象的属性名称要和参数占位符名称一致
     *   3、map集合参数
     *
     *
     * @param status
     * @param companyName
     * @param brandName
     * @return
     */
//    List<Brand> selectByCondition(@Param("status")int status, @Param("companyName") String companyName, @Param("brandName") String brandName);
 
//    List<Brand> selectByCondition(Brand brand);
 
    List<Brand> selectByCondition(Map map);

	<!-- 条件查询的SQL -->
    <select id = "selectByCondition" resultMap = "brandResultMap">
        select *
        from tb_brand
        where status = #{status}
            and company_name like #{companyName}
            and brand_name like #{brandName};
    </select>

	@Test
    public void testSelectByCondition() throws IOException {
        //接收参数
        int status = 1;
        String companyName = "华为";
        String brandName = "华为";
 
        //处理参数、用户想要进行模糊匹配
        companyName = "%" + companyName + "%";
        brandName = "%" + brandName + "%";
 
        //封装成对象
        Brand brand = new Brand();
        brand.setStatus(status);
        brand.setCompanyName(companyName);
        brand.setBrandName(brandName);
 
        Map map = new HashMap();
        map.put("status", status);
        map.put("companyName", companyName);
        map.put("brandName", brandName);
 
        //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、执行方法
//        List<Brand> brands = brandMapper.selectByCondition(status, companyName, brandName);
//        List<Brand> brands = brandMapper.selectByCondition(brand);
        List<Brand> brands = brandMapper.selectByCondition(map);
        System.out.println(brands);
 
        //5、释放资源
        sqlSession.close();
    }

问题：用户是否会将三个条件都输入，如果空一个and就将不成立，就会出现BUG

查询 - 多条件 - 动态条件查询

SQL语句会随着用户的输入或外部条件的变化而变化，我们称之为 动态SQL

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

Mybatis 对动态SQL有很强大的支撑：

​ if

​ choose(when, otherwise)

​ trim(where, set)

​ foreach

<!--
        动态条件查询
            if：条件判断
                test：逻辑表达式
            问题：当前面的条件不满足式，可能会出现SQL语法错误
                1、使用恒等式
                2、使用<where>标签 替换 where关键字
    -->
    <select id = "selectByCondition" resultMap = "brandResultMap">
        select *
        from tb_brand
<!--        where 1 = 1-->
        <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>

查询 - 单条件 - 动态条件查询

从多个条件中选择一个

choose（when, otherwise）：选择，类似于Java中的switch语句

<select id = "selectByConditionSingle" resultMap = "brandResultMap">
	select *
    from tb_brand
    where
    <choose>	<!--类似于switch-->
        <when test = "status != null">	<!--类似于case-->
        	status = #{status}
        </when>
        <when test = "companyName != null and companyName != ''">	
        	company_name like #{companyName}
        </when>
        <when test = "brandName != null and brandName != ''">	
        	brand_name like #{brandName}
        </when>
        <otherwise>	<!--相当于default-->
        	1 = 1
        </otherwise>
   </choose>
</select>

测试代码：

	@Test
    public void testSelectByConditionSingle() throws IOException {
        //接收参数
        int status = 1;
        String companyName = "华为";
        String brandName = "华为";
 
        //处理参数、用户想要进行模糊匹配
        companyName = "%" + companyName + "%";
        brandName = "%" + brandName + "%";
 
        //封装成对象
        Brand brand = new Brand();
//        brand.setStatus(status);
        brand.setCompanyName(companyName);
//        brand.setBrandName(brandName);
 
 
        //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、执行方法
        List<Brand> brands = brandMapper.selectByConditionSingle(brand);
        System.out.println(brands);
 
        //5、释放资源
        sqlSession.close();
    }

2、添加：

添加

1、编写接口方法：Mapper接口

​ 参数：除了id之外的所有数据

​ 结果：void

void add(Brand brand);

2、编写SQL语句：SQL映射文件

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

3、执行测试方法

MyBatis事务：

​ openSession()：默认开启事务，进行增删改操作后需要使用sqlSession.commit(); 手动提交事务

​ openSession(true)：可以设置为自动提交事务（关闭事务）

测试代码：

	//添加
    @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);    //表示自动提交事务
        //参数为false 就是不开启事务
 
        //3、获取Mapper接口的代理对象
        BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
 
        //4、执行方法
        brandMapper.add(brand);
 
        //手动提交事务，否则事务会回滚，则数据无法添加到表中
        sqlSession.commit();
 
        //5、释放资源
        sqlSession.close();
    }

添加 - 主键返回

在数据添加成功后，需要获取插入数据的主键的值

​ 比如：添加订单和订单项

1、添加订单

2、添加订单项，订单项中需要设置所属订单的id

<insert id = "addOrder" userGeneratedKeys = "true" keyProperty = "id">	<!-- 添加了这两个属性后可以获取主键 -->
	insert into tb_order(payment, payment_type, status)
    values (#{payment}, #{paymentType}, #{status});
</insert>

<insert id = "addOrderItem">
	insert into tb_order_item (goods_name, good_pirce, count, order_id)
    values (#{goodsName}, #{goodsPrice}, #{count}, #{order});
</insert>

3、修改

修改全部字段

1、编写接口方法：Mapper接口

​ 参数：所有数据

​ 结果：void

void update(Brand brand);

2、编写SQL语句：SQL映射文件

<update id = "update">
	update tb_brand
    set brand_name = #{brandName},
    	company_name = #{companyName},
    	ordered = #{ordered},
    	description = #{description},
    	status = #{status}
    where id = #{id};
</update>

3、执行方法，测试

	//修改 - 修改全部字段
    @Test
    public void testupdate() throws IOException {
        //接收参数
        int status = 1;
        String companyName = "波导手机";
        String brandName = "波导";
        String description = "波导手机，手机中的战斗机";
        int ordered = 200;
        int id = 4;
 
        //封装成对象
        Brand brand = new Brand();
        brand.setStatus(status);
        brand.setCompanyName(companyName);
        brand.setBrandName(brandName);
        brand.setDescription(description);
        brand.setOrdered(ordered);
        brand.setId(id);
 
 
        //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);    //表示自动提交事务
        //参数为false 就是不开启事务
 
        //3、获取Mapper接口的代理对象
        BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
 
        //4、执行方法
        int count = brandMapper.update(brand);
        System.out.println(count);
 
        //手动提交事务，否则事务会回滚，则数据无法添加到表中
        sqlSession.commit();
 
        //5、释放资源
        sqlSession.close();
    }

修改动态字段

1、编写接口方法：Mapper接口

​ 参数：部分数据，封装到对象中

​ 结果：void

2、编写SQL语句：SQL映射文件

<uppdate 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">
        	ordered = #{ordered},
        </if>
        <if test = "description != null and description != ''">
        	description = #{description},
        </if>
        <if test = "status != null">
        	status = #{status},
        </if> 
    </set>
    where id = #{id};
</uppdate>

3、执行方法，测试

	@Test
    public void testUpdate() throws IOException {
        //接收参数
        int status = 0;
        String companyName = "波导手机";
        String brandName = "波导";
        String description = "波导手机，手机中的战斗机";
        int ordered = 200;
        int id = 4;
 
        //封装成对象
        Brand brand = new Brand();
        brand.setStatus(status);
//        brand.setCompanyName(companyName);
//        brand.setBrandName(brandName);
//        brand.setDescription(description);
//        brand.setOrdered(ordered);
        brand.setId(id);
 
 
        //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);    //表示自动提交事务
        //参数为false 就是不开启事务
 
        //3、获取Mapper接口的代理对象
        BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
 
        //4、执行方法
        int count = brandMapper.update(brand);
        System.out.println(count);
 
        //手动提交事务，否则事务会回滚，则数据无法添加到表中
        sqlSession.commit();
 
        //5、释放资源
        sqlSession.close();
    }

4、删除

删除一个

1、编写接口方法：Mapper接口

​ 参数：id

​ 结果：void

void deleteById(int id);

2、编写SQL

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

3、执行方法，测试

	//删除
    @Test
    public void testDeleteById() throws IOException {
        //接收参数
        int id = 4;
 
        //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);    //表示自动提交事务
        //参数为false 就是不开启事务
 
        //3、获取Mapper接口的代理对象
        BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
 
        //4、执行方法
        brandMapper.deleteById(id);
 
        //手动提交事务，否则事务会回滚，则数据无法添加到表中
        sqlSession.commit();
 
        //5、释放资源
        sqlSession.close();
    }

批量删除

1、编写接口方法：Mapper接口

参数：id数组

结果：void

void deleteByIds(@Param("ids")int[] ids);

2、编写SQL语句：SQL映射文件

<delete id = "deleteByIds">
	delete from tb_brand
    <!-- 问号的个数不定，使用动态SQL改进 -->
    where id in (?,?,?);
</delete>

<delete id = "deleteByIds">
	delete from tb_brand
    where id in
    <!-- 这个数组或者集合 、 每一项的字段 、 中间使用什么间隔 、 开始或者结束时拼接什么(所以这里省略的大括号) -->
    <foreach collection = "ids" item = "id" separator = "," open = "("close=")">
    	#{id};
    </foreach>
</delete>

3、执行方法，测试

	<!-- 批量删除的SQL映射 -->
    <delete id="deleteByIds">
        delete from tb_brand where id
        in
            <!--
                mybatis会将数组参数，封装为一个Map集合。
                    默认：array = 数组
                    使用@Param注解改变map集合的默认key的名称
             -->
<!--            <foreach collection="array" ></foreach>-->
            <foreach collection="ids" item="id" separator="," open="(" close=")">
                #{id}
            </foreach>
        
    </delete>

		@Test		
		public void testDeleteByIds() throws IOException {
        //接收参数
        int[] ids = {2, 3, 7};
 
        //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);    //表示自动提交事务
        //参数为false 就是不开启事务
 
        //3、获取Mapper接口的代理对象
        BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
 
        //4、执行方法
        brandMapper.deleteByIds(ids);
 
        //手动提交事务，否则事务会回滚，则数据无法添加到表中
        sqlSession.commit();
 
        //5、释放资源
        sqlSession.close();
    }

MyBatis参数传递

MyBatis 接口方法中可以接收各种各样的参数，MyBatis底层对于这些参数进行不同的封装处理方式

单个参数：

​ 1、POJO类型：直接使用，属性名 和 参数占位符名称一致

​ 2、Map集合：直接使用，键名 和 参数占位符名称一致

​ 3、Collection：封装为Map集合

​ map.put("arg0", collection集合);

​ map.put("collection", collection集合);

​ 4、List：封装为Map集合

​ map.put("arg0", list集合);

​ map.put("collection", list集合);

​ map.put("list", list集合);

​ 5、Array：封装为Map集合

​ map.put("arg0", 数组);

​ map.put("array", 数组);

​ 6、其他类型：直接使用

多个参数：封装为Map集合，可以使用@Param注解，替换Map集合中默认的arg键名

map.put("arg0", 参数值1)
map.put("param1", 参数值1)
map.put("param2", 参数值2)
map.put("arg1", 参数值2)
------------------------------@Param("username")
map.put("username", 参数值1)
map.put("param1", 参数值1)
map.put("param2", 参数值2)
map.put("arg1", 参数值2)

MyBatis提供了ParamNameResolver类来进行参数封装，双击shift搜索查看

结论：不要使用默认键名，都使用@Param注解来修改Map集合中默认的键名，并且使用修改后的名称来获取值，这样可读性更高

注解完成增删改查

使用注解开发会比配置文件更加方便

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

查询：@Select

添加：@Insert

修改：@Update

删除：@Delete

提示：

​ 注解完成简单功能

​ 配置文件完成复杂功能

​ 使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java注解不仅力不从心，还会让你本就复杂的SQL语句更加混乱不堪。因此，如果你需要做一些很复杂的操作，最好使用XML来映射语句。

​ 选择何种方式来配置映射文件，以及认为是否应该要统一映射语句定义的形式，完全取决于你和你的团队。换句话说，永远不要拘泥于一种方式，你可以很轻松的在基于注解和XML的语句映射方式间自由移植和切换。