关于MyBatis的基础操作

王二hhh

已于 2023-04-22 19:19:51 修改

阅读量282

点赞数

文章标签： mybatis java mysql

于 2023-04-18 22:32:28 首次发布

本文链接：https://blog.csdn.net/m0_62912377/article/details/130160909

版权

一、MyBatis概述

MyBatis 是一款优秀的半自动ORM持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

ORM(Object Relation Mapping)，对象关系映射。对象指的是Java对象，关系指的是数据库中的关系模型，对象关系映射，指的就是在Java对象和数据库的关系模型之间建立一种对应关系，比如用一个Java的Student类，去对应数据库中的一张student表，类中的属性和表中的列一一对应。Student类就对应student表，一个Student对象就对应student表中的一行数据。

二、MyBatis入门

完成利用MyBatis查询User表中所有数据

1.创建user表

数据库名：mybatis_db 表名：user

2.创建Maven项目，导入坐标

新建一个Maven项目，在pom.xml下导入坐标

    <dependencies>
        <!--mybatis依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.13</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!--junit单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

3.创建对应的User类

在main.java包下创建一个com.pojo.User类

public class User {

    private Integer id;
    private String name;
    private String password;
    private Integer grade;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getGrade() {
        return grade;
    }

    public void setGrade(Integer grade) {
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                ", grade=" + grade +
                '}';
    }
}

4.编写MyBatis核心配置文件

在resources下创建一个mybatis-config.xml文件，在文件内编写

<?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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--数据库连接信息-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatis_db?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--加载sql映射文件-->
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

5.编写SQL映射文件

在resources下创建一个UserMapper.xml，在文件内编写

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

<!--
      namespace:名称空间
-->
<mapper namespace="test">
    <select id="selectAll" resultType="com.pojo.User"><!--对应pojo类的地址-->
        select * from user;
    </select>
</mapper>

将UserMapper.xml的路径写入mybatis-config.xml的mapper标签里

    <mappers>
        <!--加载sql映射文件-->
        <mapper resource="UserMapper.xml"/>
    </mappers>

6.编码

在com包下创建一个MyBatisDemo类

public class MyBatisDemo {
    public static void main(String[] args) throws IOException {
        //1.加载mybatis的核心配置文件，获取SqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //2.获取SQLSession对象，用它来执行sql
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //3.执行sql
        List<User> users = sqlSession.selectList("test.selectAll");

        System.out.println(users);

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

控制台输出

三、Mapper代理开发

Mapper的代理开发相对于原生的MyBatis开发的几个优势

有效解决了原生方式中的硬编码
简化后期执行SQL
不依赖字符串字面值，更加安全
如果你的 IDE 有代码补全功能，那么代码补全可以帮你快速选择到映射好的 SQL 语句

同样使用Mapper代理开发完成查询User表中所有数据

1. 定义与SQL映射文件同名的Mapper接口，并将Mapper接口和SQL映射文件放置在同一目录下

在MyBatis入门创建的com包下创建一个mapper包。在mapper包下创建一个与映射文件的同名UserMapper接口

并在resources下新建一个Directory目录，以com/mapper的方式命名，将UserMapper.xml放入该目录中

此时Mapper接口和SQL映射文件便位于同一目录下了

2.设置SQL映射文件的namespace属性为Mapper接口全限定名

在UserMapper.xml中将namespace改为UserMapper接口

<mapper namespace="com.mapper.UserMapper">
    <select id="selectAll" resultType="com.pojo.User"><!--对应pojo类的地址-->
        select * from user;
    </select>
</mapper>

3.在Mapper接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型的一致

在UserMapper接口中定义selectAll方法

public interface UserMapper {

    //根据SQL语义来决定使用集合还是实体对象
    List<User> selectAll();
    
}

4.将mybatis-config.xml映射文件的路径更改为UserMapper的具体路径

因为换了目录，和mybatis-config.xml便不同级了

    <mappers>
        <!--加载sql映射文件-->
        <mapper resource="com/mapper/UserMapper.xml"/>
    </mappers>

5.编码

在com包下创建一个MyBatisDemo2类，用于测试Mapper代理开发

public class MyBatisDemo2 {
    public static void main(String[] args) throws IOException {
        //1.加载mybatis的核心配置文件，获取SqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //2.获取SQLSession对象，用它来执行sql
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //3.获取UserMapper接口的代理对象（只有此处和原生开发不同）
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.selectAll();

        System.out.println(users);

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

控制台输出

如果Mapper接口名称和SQL映射文件名称相同，并且在同一目录下，则可以使用包扫描的方式简化SQL映射文件的加载（当在mapper包中有多个xml文件时，这种方式可一次性导入）

    <mappers>
        <!--加载sql映射文件-->
        <!--<mapper resource="com/mapper/UserMapper.xml"/>-->
        
        <!--Mapper代理方式-->
        <package name="com.mapper"/>
    </mappers>

四、基于MyBatis的一些基本的增删改查操作

数据库名：mybatis_db 表名：brand

在com包下新建Dao.MybatisDao类,MyBatisDemo类,pojo.Brand类,mapper.BrandMapper接口

在Brand类中写入数据库表中信息

public class Brand {
    private Integer id;
    private String brandName;//对应数据库brand_name
    private String companyName;//对应数据库company_name
    private Integer order;//对应数据库ordered

    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 getOrder() {
        return order;
    }

    public void setOrder(Integer order) {
        this.order = order;
    }

    @Override
    public String toString() {
        return "Brand{" +
                "id=" + id +
                ", brandName='" + brandName + '\'' +
                ", companyName='" + companyName + '\'' +
                ", order=" + order +
                '}'+"\r\n";
    }
}

在resources的com.mapper包下新建一个BrandMapper.xml文件，写入

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

<mapper namespace="com.mapper.BrandMapper">
    
</mapper>

以下增删改查操作都遵循如下流程（BrandMapper是我这里定义的接口名，实际操作过程中根据实际情况在对应的接口，XML文件，Dao类中编写具体方法）

在BrandMapper中编写对应的接口方法
在BrandMapper.xml的mapper标签里编写SQL语句
在MyBatisDao中编写具体方法
在MyBatisDemo3中调用对应的Dao类方法

1.查询

在查询操作中，可将对应的Dao类方法返回值定义为需返回的类，以下为了方便测试返回值都为void

1.1查询所有数据

在BrandMapper中编写对应的接口方法

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

在BrandMapper.xml的mapper标签里编写SQL语句，注意这个resultMap标签，如果使用resultType标签，在列名和属性名不一致的情况下会导致有些数据封装不上的情况，使用resultMap标签则可以有效解决这个问题

    <!--用resultMap可以有效解决在类名和列名不一致的情况-->
    <!--id完成主键字段映射-->
    <!--result完成一般字段的映射-->
    <!--column:列名    property:实体类的属性名-->
    <resultMap id="brandResultMap" type="com.pojo.Brand">
        <result column="brand_name" property="brandName"/>
        <result column="company_name" property="companyName"/>
    </resultMap>

    <!--查询所有-->
    <select id="selectAll" resultMap="brandResultMap">
        select * from brand
    </select>

在MyBatisDao中编写具体方法

    //查询全部的方法
    public static void SelectAll() 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();

在MyBatisDemo3中调用对应的Dao类方法

    public static void main(String[] args) throws IOException {
        //查询全部
        MybatisDao.SelectAll();
    }

控制台输出

1.2查询单条数据

在BrandMapper中编写对应的接口方法

    //查询单条
    Brand selectById(int id);

在BrandMapper.xml的mapper标签里编写SQL语句

参数占位符:
    1.#{}:会将其替换为?,为了防止SQL注入
    2.${}:拼sql,会存在SQL注入问题
    3.使用时机:
        参数传递的时候:#{}(大多数情况都用这个)
        表名或列名不固定的情况下:${}(少部分动态传参用这个)
 SQL语句中特殊字符处理(如小于)
    1.转义字符:&lt;
    2.<![CDATA[  <  ]]>

    <!--查询单条-->
    <select id="selectById" resultMap="brandResultMap">
        select * from brand where id = #{id}
    </select>

在MyBatisDao中编写具体方法

    //查询单条
    public static void SelectById(int i) 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.执行方法
        Brand brand = brandMapper.selectById(i);
        System.out.println(brand);

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

在MyBatisDemo3中调用对应的Dao类方法

        //查询单条
        int id = 1;
        MybatisDao.SelectById(id);

控制台输出

1.3多条件查询

在BrandMapper中编写对应的接口方法

    //多条件查询
    List<Brand> selectByCondition(Brand brand);

在BrandMapper.xml的mapper标签里编写SQL语句

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

在MyBatisDao中编写具体方法

    //多条件查询
    public static void SelectByCondition(Brand brand) throws IOException {
        //处理参数
        String companyName = brand.getCompanyName();
        String brandName = brand.getBrandName();

        //将值取出给其两端加上%以符合SQL语句规范
        companyName = "%" + companyName + "%";
        brandName = "%" + brandName + "%";

        //将处理后的值再次传入brand
        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.selectByCondition(brand);
        System.out.println(brands);

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

在MyBatisDemo3中调用对应的Dao类方法

        //多条件查询
        String cName = "小米";//公司名
        String bName = "红米";//品牌名

        Brand brand = new Brand();
        brand.setCompanyName(cName);
        brand.setBrandName(bName);

        MybatisDao.SelectByCondition(brand);

控制台输出

1.4动态SQL实现多条件查询

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。具体标签用法及讲解见官网mybatis – MyBatis 3 | 动态 SQL

在BrandMapper中编写对应的接口方法

    //动态多条件查询
    List<Brand> selectByCondition1(Brand brand);

在BrandMapper.xml的mapper标签里编写SQL语句

    <!--动态SQL实现多条件查询-->
    <!--if标签即相当于Java语法中的if-->
    <!--where标签则可以根据SQL语境来解决中间连接词问题-->
    <select id="selectByCondition1" resultMap="brandResultMap">
        select * from brand
        <where>
            <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>

在MyBatisDao中编写具体方法

    //动态多条件查询
    public static void SelectByCondition1(Brand brand) throws IOException {
        //处理参数
        String companyName = brand.getCompanyName();
        String brandName = brand.getBrandName();

        //判断是否传入参数为空，将值取出给其两端加上%以符合SQL语句规范
        if (companyName != null) {
            companyName = "%" + companyName + "%";
        }
        if (brandName != null) {
            brandName = "%" + brandName + "%";
        }

        //将处理后的值再次传入brand
        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.selectByCondition1(brand);
        System.out.println(brands);

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

在MyBatisDemo3中调用对应的Dao类方法

        //动态多条件查询
        String cName1 = "小米";//公司名
        String bName1 = "";//品牌名

        Brand brand1 = new Brand();
        brand1.setCompanyName(cName1);
        brand1.setBrandName(bName1);

        MybatisDao.SelectByCondition1(brand1);

控制台输出

2.添加

完成添加操作并返回主键值

注：增删改相对于查询来说要注意提交事务，可通过以下两种方法实现
1.在获取SqlSession对象时，传入参数true,设置自动提交事务
SqlSession sqlSession = sqlSessionFactory.openSession(true);
2.在执行完SQL语句后，提交事务
sqlSession.commit();

在BrandMapper中编写对应的接口方法

    //添加数据并返回主键值
    void addReId(Brand brand);

在BrandMapper.xml的mapper标签里编写SQL语句

    <!--添加数据并返回主键值-->
    <!--useGeneratedKeys和keyProperty用于返回主键值-->
    <insert id="addReId" useGeneratedKeys="true" keyProperty="id">
        insert into brand(brand_name,company_name,ordered)
        values (#{brandName},#{companyName},#{order});
    </insert>

在MyBatisDao中编写具体方法

    //添加数据并返回主键
    public static void AddReId(Brand brand) 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();
        //2.1可以在此处设置自动提交事务，用以下方式便不需要5步骤提交事务
        //SqlSession sqlSession = sqlSessionFactory.openSession(true);

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

        //4.执行方法
        brandMapper.addReId(brand);
        Integer id = brand.getId();
        System.out.println(id);

        //5.提交事务
        sqlSession.commit();

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

在MyBatisDemo3中调用对应的Dao类方法

        //添加数据并返回主键值
        String companyName = "魅族科技有限公司";
        String brandName = "魅族手机";
        Integer order = 13;

        Brand brand2 = new Brand();
        brand2.setCompanyName(companyName);
        brand2.setBrandName(brandName);
        brand2.setOrder(order);

        MybatisDao.AddReId(brand2);

控制台输出

数据库变化

3.修改

3.1修改全部字段

在BrandMapper中编写对应的接口方法

    //修改全部数据
    void update(Brand brand);

在BrandMapper.xml的mapper标签里编写SQL语句

    <!--修改所选字段的全部内容-->
    <update id="update">
        update brand
        set
            brand_name = #{brandName},
            company_name = #{companyName},
            ordered = #{order}
        where id = #{id}
    </update>

在MyBatisDao中编写具体方法

    //修改数据
    public static void Update(Brand brand) 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.执行方法
        brandMapper.update(brand);

        //5.提交事务
        sqlSession.commit();

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

在MyBatisDemo3中调用对应的Dao类方法

        //修改数据
        String companyName = "魅族科技有限公司";
        String brandName = "魅族手机我被修改啦";
        Integer order = 13;
        Integer id = 4;

        Brand brand3 = new Brand();
        brand3.setCompanyName(companyName);
        brand3.setBrandName(brandName);
        brand3.setOrder(order);
        brand3.setId(id);

        MybatisDao.Update(brand3);

数据库变化

3.2动态SQL实现修改数据

在我们用修改全部数据时，需要传入所有数据的参数，当我们只需要修改其中一个数据时，可用动态SQL来实现

在BrandMapper中编写对应的接口方法

    //动态修改数据
    void update1(Brand brand);

在BrandMapper.xml的mapper标签里编写SQL语句

    <!--动态修改所选字段的一部分内容-->
    <update id="update1">
        update brand
        <set>
            <if test="brandName != null and brandName != ''">
                brand_name = #{brandName},
            </if>
            <if test="companyName != null and companyName != ''">
                company_name = #{companyName},
            </if>
            <if test="order != null and order != ''">
                ordered = #{order},
            </if>
        </set>
        where id = #{id}
    </update>

在MyBatisDao中编写具体方法

    //动态修改数据
    public static void Update1(Brand brand) 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.执行方法
        brandMapper.update1(brand);

        //5.提交事务
        sqlSession.commit();

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

在MyBatisDemo3中调用对应的Dao类方法

        //动态修改数据
        String brandName = "红米手机我被修改啦";
        Integer id = 1;

        Brand brand4 = new Brand();
        brand4.setBrandName(brandName);
        brand4.setId(id);

        MybatisDao.Update1(brand4);

数据库变化

4.删除

4.1删除单个数据

在BrandMapper中编写对应的接口方法

    //删除单个数据
    void deleteById(int id);

在BrandMapper.xml的mapper标签里编写SQL语句

    <!--删除单个数据-->
    <delete id="deleteById">
        delete from brand where id = #{id};
    </delete>

在MyBatisDao中编写具体方法

    //删除单个数据
    public static void DeleteById(int id) 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.执行方法
        brandMapper.deleteById(id);

        //5.提交事务
        sqlSession.commit();

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

在MyBatisDemo3中调用对应的Dao类方法

        //删除单个数据
        int id = 4;
        MybatisDao.DeleteById(id);

数据库变化

4.2批量删除数据

这部分亦可以将遍历数组循环放在Demo方法中实现，此处主要介绍利用MyBatis中foreach标签来实现批量删除

在BrandMapper中编写对应的接口方法

    //批量删除数据
    void deleteByIds(@Param("ids") int[] ids);

在BrandMapper.xml的mapper标签里编写SQL语句

MyBatis会将数组参数，封装成一个Map集合，在collection处可以有两种引用方式
    1.默认:array = 数组
    2.使用@Param注解改变Map集合的默认key的名称
separator:分隔符   open:foreach前面的符号   close:foreach后面的符号

    <!--批量删除数据-->
    <delete id="deleteByIds">
        delete from brand where
        id in
        <foreach collection="ids" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>

在MyBatisDao中编写具体方法

    //批量删除数据
    public static void DeleteByIds(int[] ids) 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.执行方法
        brandMapper.deleteByIds(ids);

        //5.提交事务
        sqlSession.commit();

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

在MyBatisDemo3中调用对应的Dao类方法

        //批量删除数据
        int[] ids = {1,3};
        MybatisDao.DeleteByIds(ids);

数据库变化

五、MyBatis参数传递

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

单个参数
1. POJO类型：直接使用，实体类属性名和参数占位符名称一致
2. Map集合：直接使用，键名和参数占位符名称一致
3. Collection集合：封装为Map集合
```
    map.put("collection",collection集合);
    map.put("arg0",collection集合);
```
4. List集合：封装为Map集合
```
    map.put("collection",list集合);
    map.put("list",list集合);
    map.put("arg0",list集合);
```
5. Array数组：封装为Map集合
```
    map.put("array",数组);
    map.put("arg0",数组);
```
6. 其他类型：直接使用

多个参数：封装为Map集合

    map.put("arg0",参数值1);
    map.put("param1",参数值1);
    map.put("arg1",参数值2);
    map.put("param2",参数值2);

当遇到或没遇到这种被Map集合封装的情况，都可以通过@Param注解来修改Map集合中默认的键名，并使用修改后的名称来获取值，这样可读性更高

六、注解开发

在MyBatis官网上对于注解开发是这样评价的

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

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

简而言之，注解可以完成简单功能，使代码更简洁；配置文件完成复杂功能，防止代码耦合度太高导致代码混乱，下面演示用注解来实现查询单条数据的功能

查询：@Select

添加：@Insert

修改：@Update

删除：@Delete

在UserMapper中编写注解方法

    //注解开发
    @Select("select * from user where id = #{id}")
    User SelectById(int id);

在MyBatisDao中编写具体方法

    //利用注解查询单条
    public static void SelectByIdUser(int i) 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接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //4.执行方法
        User user = userMapper.SelectById(i);
        System.out.println(user);

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

在MyBatisDemo3中调用对应的Dao类方法

        //注解开发
        int id = 2;
        MybatisDao.SelectByIdUser(id);

控制台输出

王二hhh

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
关于MyBatis的基础操作

MyBatis 是一款优秀的半自动ORM持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
复制链接

扫一扫