• MyBatis--多案例让你熟练使用CRUD操作

     

    目录

    一、前期准备

    二、两种实现CRUD方式

    三、增加数据（INSERT）

    四、删除数据（DELETE）

    五、查询数据（SELECT）

    六、更新数据（UPDATE）

    一、前期准备

    1.创建maven项目并在pom文件中导入相关jar包

    1. <dependencies>
    2.         
    3.         <dependency>
    4.             <groupId>mysqlgroupId>
    5.             <artifactId>mysql-connector-javaartifactId>
    6.             <version>8.0.33version>
    7.         dependency>
    8.         
    9.         <dependency>
    10.             <groupId>org.junit.jupitergroupId>
    11.             <artifactId>junit-jupiter-apiartifactId>
    12.             <version>5.10.0version>
    13.             <scope>testscope>
    14.         dependency>
    15.         
    16.         <dependency>
    17.             <groupId>cn.itlym.shouldergroupId>
    18.             <artifactId>lombokartifactId>
    19.             <version>0.1version>
    20.         dependency>
    21.         
    22.         <dependency>
    23.             <groupId>org.mybatisgroupId>
    24.             <artifactId>mybatisartifactId>
    25.             <version>3.5.7version>
    26.         dependency>
    27.  
    28. dependencies>

    2.创建CURD使用到的大学生实体类

    1. @Data
    2. public class UnderGraduate {
    3. //    大学生的属性
    4.     private String name;
    5.     private String major;
    6.     private int id;
    7.     private  String gender;
    8. }

    3.数据库准备对应实体类的表

     4.创建对应业务需求的接口

    1. //业务接口
    2. public interface UnderGraduateMapper {
    3. //    增删查改
    4. //    增加 
    5.     public int insertNew(UnderGraduate underGraduate);
    6.  
    7. //    删除
    8.     public int deleteById();
    9.   
    10. //    查找
    11.     public UnderGraduate selsctById();
    12.  
    13. //    修改
    14.     public int updateById();
    15. }

    5. 相关mappers与mybatis配置

    mapper配置

    1. "1.0" encoding="UTF-8"?>
    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5.  
    7. <mapper namespace="com.alphamilk.mapper.UnderGraduateMapper">
    11. mapper>

    jdbc资源类配置

    1. jdbc.driver = com.mysql.cj.jdbc.Driver
    2. jdbc.url = jdbc:mysql://localhost:3306/对应数据库名称
    3. jdbc.username = mysql
    4. jdbc.password = xxxxxx

     mybatis配置

    1. "1.0" encoding="utf-8"?>
    2. configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    3.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    4. <configuration>
    5.     
    6.     <properties resource="jdbc.properties"/>
    7.     <environments default="development">
    8.         <environment id="development">
    9.             <transactionManager type="JDBC"/>
    10.             <dataSource type="POOLED">
    11.                 <property name="driver" value="${jdbc.driver}"/>
    12.                 <property name="url" value="${jdbc.url}"/>
    13.                 <property name="username" value="${jdbc.username}"/>
    14.                 <property name="password" value="${jdbc.password}"/>
    15.             dataSource>
    16.         environment>
    17.     environments>
    18.     <mappers>
    20.         <mapper resource="mappers/UnderGraduateMapper.xml"/>
    21.     mappers>
    22. configuration>
    23.

    6.建立对应测试类，测试代码

    1. public class CRUDTEST {
    2.  
    3.     @Test
    4.     public void Test() throws IOException {
    5. //        获取mybatis配置资源
    6.         InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    7. //        创建SqlSessionFactoryBuilder对象
    8.         SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    9. //        根据获取资源is build一个对应SqlSessionFactory
    10.         SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    11. //        通过SqlSessionFactory 获取SqlSession，并开启自动提交
    12.         SqlSession sqlSession = sqlSessionFactory.openSession(true);
    13. //        通过SqlSession获取对应mapper对象
    14.         UnderGraduateMapper mapper = sqlSession.getMapper(UnderGraduateMapper.class);
    15.  
    16. //        此处调用mapper对象测试功能
    17.  
    18.  
    19. //      关闭SqlSession
    20.         sqlSession.close();
    21.     }
    22. }

    二、两种实现CRUD方式

    在MyBatis中有两种方式可以实现增删查改的功能，分别是通过XML配置与注解类配置

    1.XML配置

    优点：

    1. 灵活性高：可以使用 MyBatis 提供的各种标签，构建复杂的查询语句。
    2. 易于维护：SQL 语句和 Java 代码分离，提高了程序的可读性和可维护性。
    3. 明确的映射关系：可以使用 resultMap 标签明确地指定查询结果和 Java 对象之间的映射关系。

    缺点：

    1. 学习成本高：使用 MyBatis 的 XML 配置需要学习一些额外的标签和配置方式。
    2. 冗余度高：相对于注解配置，XML 配置要更冗长，需要编写大量的 XML 标签。
    3. 不够直观：XML 配置需要打开多个文件进行编辑，不如注解配置那样直观。

    有四种基本的增删查改标签对应分别是、、<select>、

    各个标签中的常用属性

    特殊标签

    标签内嵌标签

    标签

    作用：用于遍历集合之中多个成员，常用于批量导入成员

    标签内的常用属性

    • collection：指定要遍历的集合或数组的属性名。可以是一个 List、Set 或数组对象。
    • item：指定在遍历过程中每个元素的别名，可以在标签内部使用该别名来引用当前遍历的元素。
    • open：指定循环开始时的字符串，在第一次遍历之前输出。
    • close：指定循环结束时的字符串，在最后一次遍历之后输出。
    • separator：指定每次遍历之间的分隔符，即每个元素之间的分隔符。
    • index：指定当前遍历元素的索引，可用于获取当前遍历元素在集合中的位置（仅适用于 List 或数组）。

    示例：

    1. <insert id="batchInsert" parameterType="java.util.List">
    2.   INSERT INTO user (name, age) VALUES
    3.   <foreach collection="list" item="item" separator=",">
    4.     (#{item.name}, #{item.age})
    5.   foreach>
    6. insert>

    以上示例演示了一个批量插入用户数据的 SQL 语句。其中，collection 属性指定了要遍历的集合属性名 "list"，item 属性指定了遍历过程中每个元素的别名 "item"，separator 属性指定了每次遍历之间的分隔符逗号。在循环体内部，可以通过 #{item.name} 和 #{item.age} 引用当前遍历的元素的属性。 

    标签

    作用：定义数据库查询结果映射到Java对象的规则。

    标签内的常用属性

    • id：给标签指定一个唯一的ID。
    • type：指定映射的Java对象类型，即查询结果将会映射到该类型的对象上。
    • extends：指定继承的父级，可以继承父级的映射规则。
    • autoMapping：如果设置为true，则自动进行数据库列名和Java属性名的映射；如果设置为false，则需要手动进行映射，默认值为true。
    • ：用于定义主键字段的映射规则。
    • ：用于定义普通字段的映射规则。

    示例：

    1. <resultMap id="userResultMap" type="com.example.User">
    2.   <id column="id" property="id"/>
    3.   <result column="name" property="name"/>
    4.   <result column="age" property="age"/>
    5. resultMap>

    以上示例定义了一个名为"userResultMap"的，映射到类型为com.example.User的Java对象。它包含三个映射规则：id、name和age，分别将数据库的id、name和age字段映射到User对象的id、name和age属性上。

    作用：在执行插入数据操作后，返回数据库生成的主键值，并将其设置到指定的属性中。

    标签内的常用属性：

    • keyProperty：指定将生成的主键值设置到哪个属性中，一般是插入对象中的主键属性。
    • order：指定执行 标签的顺序，有 BEFORE 和 AFTER 两个选项。BEFORE 表示在插入语句之前执行该标签，AFTER 表示在插入语句之后执行该标签。
    • resultType：指定生成主键值的数据类型，可以是整数类型、长整数类型、字符串类型等。
    • statementType：指定生成主键值的 SQL 语句类型，有 PREPARED 和 CALLABLE 两个选项。一般使用 PREPARED，表示使用预编译的 SQL 语句。

    示例：

    1. <insert id="insertUser" parameterType="User">
    2.   <selectKey keyProperty="id" order="AFTER" resultType="int">
    3.     SELECT LAST_INSERT_ID()
    4.   selectKey>
    5.   INSERT INTO user (name, age) VALUES (#{name}, #{age})
    6. insert>

     以上示例演示了插入用户数据时如何获取数据库生成的主键值。首先，在插入语句之后执行 标签（order="AFTER"），通过 SELECT LAST_INSERT_ID() 获取主键值，然后将该值设置到 id 属性中。最后，执行插入语句将数据插入数据库。

    2.注解方法使用

    优点：

    1. 简单易懂：注解配置使用起来比较简单，不需要额外的学习成本。
    2. 代码整洁：相对于 XML 配置，注解配置要更加简洁，不需要编写大量的 XML 标签。
    3. 直观：注解配置非常直观，能够快速地通过 Java 代码进行查询操作。

    缺点：

    1. 灵活性低：注解配置不能使用 MyBatis 提供的所有标签，因此在构建复杂的查询语句时可能会有所不便。
    2. 缺乏明确的映射关系：注解配置中的 SQL 语句和 Java 对象之间的映射关系较为隐式，不够明确。

    MyBatis提供常用的增删查改注解对应分别是@insert、@delete、@select、@update

    三、增加数据（INSERT）

    通过XML配置实现功能

    1.增加一个大学生用户(xml配置)

    思路：通过 标签定义了一个插入语句，将 UnderGraduate 对象的属性插入到数据库的 undergraduate 表中。

    业务接口：

    1. //    增加一个大学生用户
    2.     public int insertNew(UnderGraduate underGraduate);

    业务接口的实现：

    2.     <insert id="insertNew" parameterType="com.alphamilk.pojo.UnderGraduate">
    3.         insert into undergraduate.undergraduate(id, name, major, gender) values (#{id},#{name},#{major},#{gender})
    4.     insert>

     测试类代码：

    1. //        此处使用mapper对象进行测试功能
    2.  
    3. //        创建对应对象
    4.         UnderGraduate undergraduate = new UnderGraduate();
    5.         undergraduate.setId(3);
    6.         undergraduate.setName("测试用户");
    7.         undergraduate.setMajor("测试专业");
    8.         undergraduate.setGender("男");
    9.  
    10.         //实现业务接口功能
    11.         mapper.insertNew(undergraduate);
    12.

    2.批量增加一些大学生用户（xml 配置）

    思路：通过 标签结合 标签实现批量插入多个 UnderGraduate 对象到数据库的 undergraduate 表中

    业务接口：

    1. //    批量增加新用户
    2.     public  int batchNewGuy(List underGraduateList);

    业务接口实现：

    1.     <insert id="batchNewGuy" parameterType="java.util.List">
    2.         insert into undergraduate(id, name, major, gender)
    3.         VALUES
    4. #             foreach标签中属性 collection -集合 item -集合中遍历的元素 separator -分隔符
    5.         <foreach collection="list" item="item" separator=",">
    6.             (#{item.id},#{item.name},#{item.major},#{item.gender})
    7.         foreach>
    8.     insert>

    测试代码：

    1. //        此处使用mapper对象进行测试功能
    2.  
    3. //        创建对应对象集合list
    4.         List underGraduateList = new ArrayList<>();
    5.  
    6. // 添加第1个学生
    7.         UnderGraduate underGraduate1 = new UnderGraduate();
    8.         underGraduate1.setName("张三");
    9.         underGraduate1.setMajor("计算机科学与技术");
    10.         underGraduate1.setGender("男");
    11.         underGraduate1.setId(4);
    12.         underGraduateList.add(underGraduate1);
    13.  
    14. // 添加第2个学生
    15.         UnderGraduate underGraduate2 = new UnderGraduate();
    16.         underGraduate2.setName("李四");
    17.         underGraduate2.setMajor("电子信息工程");
    18.         underGraduate2.setGender("男");
    19.         underGraduate2.setId(5);
    20.         underGraduateList.add(underGraduate2);
    21.  
    22. // 添加第3个学生
    23.         UnderGraduate underGraduate3 = new UnderGraduate();
    24.         underGraduate3.setName("王五");
    25.         underGraduate3.setMajor("自动化");
    26.         underGraduate3.setGender("女");
    27.         underGraduate3.setId(6);
    28.         underGraduateList.add(underGraduate3);
    29.  
    30.  
    31.         //实现业务接口功能
    32.         mapper.batchNewGuy(underGraduateList);

    3.插入新大学生并返回自增主键值（xml配置）

    思路：通过 标签获取自增主键值，并将其设置到 UnderGraduate 对象的 id 属性上。

    业务接口:

    1. //    增加新用户并返回主键值
    2.     public int insertNewGuyAndReturnId(UnderGraduate underGraduate);

    业务实现:

    2. <insert id="insertNewGuyAndReturnId" parameterType="com.alphamilk.pojo.UnderGraduate">
    3.     <selectKey keyProperty="id" resultType="java.lang.Integer" order="AFTER">
    4. #    oder属性:
    5. # 
    6. #         BEFORE: 在插入语句执行之前触发获取自增主键值的操作。这通常适用于数据库系统在插入数据时立即生成自增主键值的情况。
    7. # 
    8. #         AFTER: 在插入语句执行之后触发获取自增主键值的操作。这通常适用于数据库系统在插入数据后才生成自增主键值的情况。
    9.  
    10.         select  last_insert_id()
    11.     selectKey>
    12.     insert into undergraduate(id, name, major, gender)
    13.     values
    14.     (#{id},#{name},#{major},#{gender})
    15. insert>

    测试类:

    1. //        此处使用mapper对象进行测试功能
    2.         //创建新的对象
    3.         UnderGraduate NewGuy = new UnderGraduate();
    4.         NewGuy.setName("王维");
    5.         NewGuy.setMajor("文学");
    6.         NewGuy.setGender("男");
    7.  
    8.         //实现业务接口功能
    9.         int ReceivedKeyValue = mapper.insertNewGuyAndReturnId(NewGuy);
    10.         System.out.println("获取到的主键值为:"+NewGuy.getId());
    11.  
    12. //      关闭sqlSession对象
    13.         sqlSession.close();

    通过注解类配置实现功能

    1. //    增加用户
    2.     @Insert("insert into undergraduate.undergraduate(id, name, major, gender) values (#{id},#{name},#{major},#{gender})")
    3.     public int insertNew(UnderGraduate underGraduate);
    1. //    增加新用户并返回主键值
    2.     @Insert("insert into undergraduate.undergraduate(id, name, major, gender) VALUES (#{id},#{name},#{major},#{gender})")
    3.     @Options(useGeneratedKeys = true , keyProperty = "id" , keyColumn = "id")
    4.     public int insertNewGuyAndReturnId(UnderGraduate underGraduate);

    四、删除数据（DELETE）

    通过XML配置实现功能

    1.根据id删除某个大学生用户

    业务接口

    1.     //1.通过id删除
    2.     public int deleteById(int id);

    业务实现

    2.     <delete id="deleteById" parameterType="java.lang.Integer">
    3.         delete from undergraduate
    4.                where id = #{id}
    5.     delete>

    测试类

    1. //        根据id删除用户
    2.         mapper.deleteById(9);

    2.根据条件删除某个大学生用户

    业务接口：

    1.     //2.通过条件删除
    2.     public int deleteByCondition(String condition);

    业务接口实现：

    2.     <delete id="deleteByCondition" parameterType="java.lang.String">
    3.         delete from undergraduate
    4.         where ${condition}
    5.     delete>

    测试类：

    1. //        根据条件删除用户
    2.         String condition = "id > 6";
    3.         mapper.deleteByCondition(condition);

    3.批量删除用户

    1. <delete id="deleteBatch" parameterType="java.util.List">
    2.     DELETE FROM UnderGraduate
    3.     WHERE id IN
    4.     <foreach collection="list" item="id" separator="," open="(" close=")">
    5.         #{id}
    6.     foreach>
    7. delete>

    open、close属性 讲解：

    在上述示例中， 标签中的 collection 属性指定了要遍历的集合对象，item 属性指定了集合中的元素变量名，separator 属性指定了元素之间的分隔符。

    对于给定的 idList 集合，循环遍历会将集合中的每个元素作为参数传递给 SQL 语句中的 #{id} 表达式。open 属性设置为 (，close 属性设置为 )，使得生成的 SQL 片段为 (item1, item2, item3)。如下所示

    1. DELETE FROM table_name
    2. WHERE id IN (item1, item2, item3)

    通过注解类配置实现功能

    业务测试接口：

    1.     //1.通过id删除
    2.     @Delete("delete from undergraduate.undergraduate where id = #{id}")
    3.     public int deleteById(int id);
    1.     //2.通过条件删除
    2.     @Delete("delete from undergraduate.undergraduate where ${condition}")
    3.     public int deleteByCondition(String condition);

    五、查询数据（SELECT）

    通过XML配置实现功能

    1.根据id查询用户（xml配置）

    业务接口：

    1.     //1.根据id查找用户
    2.     public UnderGraduate selectById(int id);

    业务实现：

    2.     <select id="selectById" parameterType="java.lang.Integer" resultType="com.alphamilk.pojo.UnderGraduate">
    3.         select * from undergraduate
    4.         where id = #{id}
    5.     select>

    测试类：

    1. //创建对象
    2.         UnderGraduate graduate;
    3. //        使用功能
    4.         graduate = mapper.selectById(1);
    5. //        输出用户
    6.         System.out.println(graduate);

    2.根据多变量查询单一用户（xml配置）

    当业务接口有多个变量时候，那么需要加上@Param注解

    业务接口：

    1.     //2.根据多参数查询单一用户
    2.     public UnderGraduate selectByParams(@Param("name") String name,
    3.                                         @Param("id") int id);

    业务实现：

    2.

    测试类：

    1.         //创建对象
    2.         UnderGraduate graduate;
    3. //        使用功能
    4.         graduate = mapper.selectByParams("admin",1);
    5. //        输出用户
    6.         System.out.println(graduate);

    3.根据条件查询多个用户（xml配置）

    业务接口：

    1.    //3.根据条件查询用户集合
    2.     public List selectListByCondition(String condition);

    业务实现：

    2. <select id="selectListByCondition" parameterType="java.lang.String" resultType="com.alphamilk.pojo.UnderGraduate">
    3.     select *
    4.     from undergraduate
    5.     where ${condition};
    6. select>

    测试代码：

    1.         //创建list对象
    2.         List list;
    3. //        使用功能
    4.         list = mapper.selectListByCondition("id > 1");
    5. //        输出用户
    6.         System.out.println(list);

    4.自定义查询结果集（通过注解@select ）

    业务接口：

    1.     //4.通过注解方式查询
    2.     @Select("SELECT name , major  FROM  undergraduate.undergraduate where id = #{id}")
    3.     public UnderGraduate selectByMap(int id);

    测试类代码：

    1.         UnderGraduate underGraduate = mapper.selectByMap(1);
    2.         System.out.println(underGraduate);

     通过注解类配置实现功能

    1.     //1.根据id查找用户
    2.     @Select("select * from undergraduate.undergraduate where id = #{id}")
    3.     public UnderGraduate selectById(int id);
    1.     //2.根据多参数查询单一用户
    2.     @Select("select * from undergraduate.undergraduate where name = #{name} and id = #{id}")
    3.     public UnderGraduate selectByParams(@Param("name") String name,
    4.                                         @Param("id") int id);
    1.     //3.根据条件查询用户集合
    2.     @Select("select * from undergraduate.undergraduate where ${condition}")
    3.     public List selectListByCondition(String condition);

    六、更新数据（UPDATE）

    通过XML配置实现功能

    1.根据id修改性别

    业务接口：

    1.     //通过id更改名称
    2.     public int updateNameById(@Param("id") int id,
    3.                               @Param("newName")String name);

    业务实现:

    2.     <update id="updateNameById">
    3.         update  undergraduate
    4.         set name = #{newName}
    5.         where id = #{id}
    6.     update>

    测试类代码：

    1.         mapper.updateNameById(1,"荒天帝");
    2.         UnderGraduate underGraduate = mapper.selectByMap(1);
    3.         System.out.println(underGraduate.getName());

     

    通过注解类配置实现功能

    1.     //通过id更改名称
    2.     @Update("update undergraduate.undergraduate set name = #{name} where id = #{id}")
    3.     public int updateNameById(@Param("id") int id,
    4.                               @Param("newName")String name);

  • 相关阅读:
    4-3：点赞功能
    VMware安装与配置Linux 虚拟机
    【八大经典排序算法】快速排序
    基于TCP的网络聊天系统
    rust结构体
    Java学习02——关键字、字面量、变量
    css3 中calc的用法？
    三电系统集成技术杂谈
    KVM虚拟化介绍和安装使用方法
    C++PrimerPlus跟读记录【第五章】循环和关系表达式
  • 原文地址：https://blog.csdn.net/dogxixi/article/details/133797732