（二）MyBatis从入门到入土——开发一个Mybatis项目

最新推荐文章于 2024-04-10 11:04:01 发布
最新推荐文章于 2024-04-10 11:04:01 发布
阅读量187 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/issunmingzhi/article/details/113636515
版权

这是mybatis系列第2篇。没看前文的建议先去【Java冢狐】公众号中查看前文，方便理解和掌握这篇文章主要接着前文介绍了如何创建并使用Mybatis。

实战演练

上一篇文章中我们大体介绍了MyBatis是如何使用的以及其内部的一些逻辑，也辅助了一些代码进行了讲解，下面我们就把这些代码写完，让整个程序运行起来。

准备数据库

mysql中运行下面脚本：创建一个数据库

/*创建数据库mybatisdemo*/
DROP DATABASE IF EXISTS `mybatisdemo`;
CREATE DATABASE `mybatisdemo`;
USE `mybatisdemo`;
/*创建表结构*/
DROP TABLE IF EXISTS `user`;
CREATE TABLE user (
  id BIGINT AUTO_INCREMENT PRIMARY KEY COMMENT '主键，用户id，自动增长',
  `name` VARCHAR(32) NOT NULL DEFAULT '' COMMENT '姓名',
  `age` SMALLINT NOT NULL DEFAULT 1 COMMENT '年龄',
  `salary` DECIMAL(12,2) NOT NULL DEFAULT 0 COMMENT '薪水'
) COMMENT '用户表';
SELECT * FROM user;

上面脚本中，创建了一个mybatisdemo数据库，然后创建了一个用户表，里面有4个字段，id为主键且自动增长。

实现的功能

基于user表，我们主要使用mybatis来演示以下几个功能

  • 通用的插入操作：支持动态插入。根据传入的字段的值，动态生成insert语句
  • 批量插入功能
  • 通用的更新操作：支持动态更新。根据传入的字段的值，动态生成update语句
  • 通用的查询操作：支持各种组合条件查询、分页、排序等各种复杂查询需求

创建maven项目

idea中创建maven项目，创建一个父项目mybatis-demo和一个子项目chat01，如下所示

项目结构

如下图：

image.gifimage

引入mybatis依赖

mybatis-demo/pom.xml内容如下：

 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 配置maven编译的时候采用的编译器版本 -->
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        <!-- 指定源代码是什么版本的，如果源码和这个版本不符将报错，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-source参数 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <!-- 该命令用于指定生成的class文件将保证和哪个版本的虚拟机进行兼容，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-target参数 -->
        <maven.compiler.target>1.8</maven.compiler.target>
        <mybatis.version>3.5.3</mybatis.version>
        <mysql.version>5.1.47</mysql.version>
        <lombok.version>1.18.10</lombok.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>1.2.3</version>

            </dependency>
        </dependencies>
    </dependencyManagement>

chat01/pom.xml内容如下：

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
        </dependency>
    </dependencies>

上面我们引入了mybatis需要的包、mysql jdbc驱动、lombok、单元测试需要的junit包、日志输出需要的logback包。

配置logback

mybatis在运行过程中会输出一些日志，比如sql信息、sql的参数信息、执行的结果等信息，mybatis中会通过logback输出出来。

在chat01/src/main/resources目录中新建文件logback.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="zhonghu" level="debug" additivity="false">
        <appender-ref ref="STDOUT" />
    </logger>
</configuration>

创建mybatis相关文件

user.xml

chat01/src/main/resources目录中新建user.xml，内容如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="zhonghu.mybatis.chat01.UserMapper">

    <!-- 插入 -->
    <insert id="insert" parameterType="zhonghu.mybatis.chat01.UserModel" keyProperty="id" useGeneratedKeys="true">
        <![CDATA[ INSERT INTO `user` ]]>
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="id!=null">
                <![CDATA[ `id`, ]]>
            </if>
            <if test="name!=null">
                <![CDATA[ `name`, ]]>
            </if>
            <if test="age!=null">
                <![CDATA[ `age`, ]]>
            </if>
            <if test="salary!=null">
                <![CDATA[ `salary`, ]]>
            </if>
        </trim>
        <![CDATA[ VALUES ]]>
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="id!=null">
                <![CDATA[ #{id}, ]]>
            </if>
            <if test="name!=null">
                <![CDATA[ #{name}, ]]>
            </if>
            <if test="age!=null">
                <![CDATA[ #{age}, ]]>
            </if>
            <if test="salary!=null">
                <![CDATA[ #{salary}, ]]>
            </if>
        </trim>
    </insert>

    <!-- 批量插入 -->
    <insert id="insertBatch" parameterType="map">
        <![CDATA[ INSERT INTO `user` (`id`, `name`, `age`, `salary`) VALUES ]]>
        <foreach collection="list" separator="," item="item">
            (#{item.id}, #{item.name}, #{item.age}, #{item.salary})
        </foreach>
    </insert>

    <!-- 更新 -->
    <update id="update" parameterType="zhonghu.mybatis.chat01.UserModel">
        <![CDATA[ UPDATE `user` ]]>
        <set>
            <if test="name!=null">
                <![CDATA[ `name` = #{name}, ]]>
            </if>
            <if test="age!=null">
                <![CDATA[ `age` = #{age}, ]]>
            </if>
            <if test="salary!=null">
                <![CDATA[ `salary` = #{salary}, ]]>
            </if>
        </set>
        <where>
            <if test="id!=null">
                <![CDATA[ AND `id` = #{id} ]]>
            </if>
        </where>
    </update>

    <!-- 更新 -->
    <update id="updateByMap" parameterType="map">
        <![CDATA[ UPDATE `user` ]]>
        <set>
            <if test="name!=null">
                <![CDATA[ `name` = #{name}, ]]>
            </if>
            <if test="age!=null">
                <![CDATA[ `age` = #{age}, ]]>
            </if>
            <if test="salary!=null">
                <![CDATA[ `salary` = #{salary}, ]]>
            </if>
        </set>
        <where>
            <if test="id!=null">
                <![CDATA[ AND `id` = #{id} ]]>
            </if>
        </where>
    </update>

    <!-- 删除 -->
    <delete id="delete" parameterType="map">
        <![CDATA[
            DELETE FROM `user`
        ]]>
        <where>
            <if test="id!=null">
                <![CDATA[ AND `id` = #{id} ]]>
            </if>
        </where>
    </delete>


    <!-- 查询记录 -->
    <select id="getModelList" parameterType="map" resultType="zhonghu.mybatis.chat01.UserModel">
        <![CDATA[
        SELECT
        ]]>
        <choose>
            <when test="tableColumnList!=null and tableColumnList.size() >= 1">
                <foreach collection="tableColumnList" item="item" separator=",">
                    <![CDATA[ ${item} ]]>
                </foreach>
            </when>
            <otherwise>
                <![CDATA[
                `id`,
                `name`,
                `age`,
                `salary`
                ]]>
            </otherwise>
        </choose>
        <![CDATA[
        FROM
        `user` a
        ]]>
        <where>
            <if test="id!=null and id.toString()!=''">
                <![CDATA[ AND a.`id` = #{id} ]]>
            </if>
            <if test="idList!=null and idList.size() >= 1">
                <![CDATA[ AND a.`id` IN ]]>
                <foreach collection="idList" item="item" open="(" separator="," close=")">
                    <![CDATA[ #{item} ]]>
                </foreach>
            </if>
            <if test="name!=null and name.toString()!=''">
                <![CDATA[ AND a.`name` = #{name} ]]>
            </if>
            <if test="age!=null and age.toString()!=''">
                <![CDATA[ AND a.`age` = #{age} ]]>
            </if>
            <if test="salary!=null and salary.toString()!=''">
                <![CDATA[ AND a.`salary` = #{salary} ]]>
            </if>
            <if test="nameLike!=null and nameLike.toString()!=''">
                <![CDATA[ AND a.`name` like '%${nameLike}%' ]]>
            </if>
            <if test="salaryGte!=null and salaryGte.toString()!=''">
                <![CDATA[ AND a.`salary` >= #{salaryGte} ]]>
            </if>
        </where>
        <if test="sort!=null and sort.toString()!=''">
            <![CDATA[ order by ${sort} ]]>
        </if>
        <if test="skip!=null and pageSize!=null">
            <![CDATA[ LIMIT #{skip},#{pageSize} ]]>
        </if>
    </select>

</mapper>
mybatis-config.xml

chat01/src/main/resources目录中新建mybatis-config.xml，内容如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties>
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatisdemo?characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/user.xml"/>
    </mappers>
</configuration>
UserMapper接口
package zhonghu.mybatis.chat01;

import java.util.List;
import java.util.Map;

public interface UserMapper {

    /**
     * 插入用户信息
     *
     * @param userModel
     * @return
     */
    void insert(UserModel userModel);

    /**
     * 批量插入用户信息
     *
     * @param userModelList
     */
    void insertBatch(List<UserModel> userModelList);

    /**
     * 更新用户信息
     *
     * @param userModel
     * @return
     */
    int update(UserModel userModel);

    /**
     * 通过map来更新用户记录
     *
     * @param map
     * @return
     */
    int updateByMap(Map<String, Object> map);

    /**
     * 通过map来删除用户记录
     *
     * @param map
     * @return
     */
    int delete(Map<String, Object> map);

    /**
     * 查询用户列表
     *
     * @param map
     * @return
     */
    List<UserModel> getModelList(Map<String, Object> map);

}
UserModel类
package zhonghu.mybatis.chat01;

import lombok.*;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Builder
@ToString
public class UserModel {
    private Long id;
    private String name;
    private Integer age;
    private Double salary;
}

这个类上面的注解都是都是lombok中的，通过这些注解，lombok可以帮助我们自动生成上面4个字段的get方法、set方法、无参构造方法、有参有参构造方法、builder模式构建对象的代码、重写toString方法，这些都在代码编译为字节码之前会写进去，通过lombok代码是不是精简了很多。

UserUtil类
package zhonghu.mybatis.chat01;

import lombok.extern.slf4j.Slf4j;
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 java.io.IOException;

@Slf4j
public class UserUtil {
    private static SqlSessionFactory sqlSessionFactory = build();

    public static SqlSessionFactory build() {
        try {
            return new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    @FunctionalInterface
    public interface SessionCall<O> {
        O call(SqlSession session) throws Exception;
    }

    @FunctionalInterface
    public interface MapperCall<T, O> {
        O call(T mapper) throws Exception;
    }

    public static <T, O> O callMapper(Class<T> tClass, MapperCall<T, O> mapper) throws Exception {
        return call(session -> mapper.call(session.getMapper(tClass)));
    }

    public static <O> O call(SessionCall<O> sessionCall) throws Exception {
        try (SqlSession session = sqlSessionFactory.openSession(true);) {
            return sessionCall.call(session);
        }
    }
}

创建单元测试类UserMapperTest

chat01\src\test\java\zhonghu\mybatis\chat01中创建UserMapperTest，代码如下：

package zhonghu.mybatis.chat01;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

@Slf4j
public class UserMapperTest {

    //动态插入
    @Test
    public void insert() throws Exception {
        UserModel userModel1 = UserModel.builder().name("Java冢狐").build();
        UserUtil.callMapper(UserMapper.class, mapper -> {
            mapper.insert(userModel1);
            return null;
        });
        log.info("插入结果：{}", this.getModelById(userModel1.getId()));
        log.info("---------------------");
        UserModel userModel2 = UserModel.builder().name("冢狐").age(23).salary(50000.00).build();
        UserUtil.callMapper(UserMapper.class, mapper -> {
            mapper.insert(userModel2);
            return null;
        });
        log.info("插入结果：{}", this.getModelById(userModel2.getId()));
    }

    //批量插入
    @Test
    public void insertBatch() throws Exception {
        List<UserModel> userModelList = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            userModelList.add(UserModel.builder().name("Java冢狐-" + i).age(23 + i).salary(10000.00 * i).build());
            userModelList.add(UserModel.builder().name("Mybatis-" + i).age(18 + i).salary(10000.00 * i).build());
        }
        UserUtil.callMapper(UserMapper.class, mapper -> {
            mapper.insertBatch(userModelList);
            return null;
        });

        List<UserModel> userModelList1 = UserUtil.callMapper(UserMapper.class, mapper -> mapper.getModelList(null));
        log.info("结果:{}", userModelList1);
    }

    //根据用户id删除数据
    @Test
    public void delete() throws Exception {
        Map<String, Object> map = new HashMap<>();
        //需要删除的用户id
        map.put("id", 1);
        Integer count = UserUtil.callMapper(UserMapper.class, mapper -> mapper.delete(map));
        log.info("删除行数：{}", count);
    }

    //动态更新
    @Test
    public void update() throws Exception {
        //将userId=2的name修改为：修改冢狐
        Long userId1 = 2L;
        Integer count = UserUtil.callMapper(UserMapper.class, mapper -> mapper.update(UserModel.builder().id(userId1).name("修改冢狐").build()));
        log.info("更新行数：{}", count);

        log.info("---------------------");
        //将userId=3的name修改为：修改冢狐,薪水为：6666.66
        Long userId2 = 3L;
        count = UserUtil.callMapper(UserMapper.class, mapper -> mapper.update(UserModel.builder().id(userId2).name("修改冢狐").salary(6666.66D).build()));
        log.info("更新行数：{}", count);
    }

    //按用户id查询
    public UserModel getModelById(Long userId) throws Exception {
        //查询指定id的数据
        Map<String, Object> map = new HashMap<>();
        map.put("id", userId);
        return UserUtil.callMapper(UserMapper.class, mapper -> {
            List<UserModel> userModelList = mapper.getModelList(map);
            if (userModelList.size() == 1) {
                return userModelList.get(0);
            }
            return null;
        });
    }

    //查询所有数据
    @Test
    public void getModelList1() throws Exception {
        List<UserModel> userModelList = UserUtil.callMapper(UserMapper.class, mapper -> mapper.getModelList(null));
        log.info("结果:{}", userModelList);
    }

    //查询多个用户id对应的数据
    @Test
    public void getModelListByIds() throws Exception {
        List<Integer> idList = Arrays.asList(2, 3, 4).stream().collect(Collectors.toList());
        Map<String, Object> map = new HashMap<>();
        map.put("idList", idList);

        List<UserModel> userModelList = UserUtil.callMapper(UserMapper.class, mapper -> mapper.getModelList(map));
        log.info("结果:{}", userModelList);
    }

    //多条件 & 指定返回的列
    @Test
    public void getModelList2() throws Exception {
        //查询姓名中包含Java冢狐以及薪资大于3万的用户id、姓名
        Map<String, Object> map = new HashMap<>();
        map.put("nameLike", "Java冢狐");
        map.put("salaryGte", 30000.00D);
        //需要返回的列
        List<String> tableColumnList = new ArrayList<>();
        tableColumnList.add("id");
        tableColumnList.add("name");
        map.put("tableColumnList", tableColumnList);

        List<UserModel> userModelList = UserUtil.callMapper(UserMapper.class, mapper -> mapper.getModelList(map));
        log.info("结果:{}", userModelList);
    }

    //条件过滤 & 排序 & 分页查询数据 & 只返回用户id、salary
    @Test
    public void getPage() throws Exception {
        //查询姓名中包含Java冢狐以及薪资大于3万的用户id，按照薪资倒叙，每页5条取第1页
        Map<String, Object> map = new HashMap<>();
        map.put("nameLike", "Java冢狐");
        map.put("salaryGte", 30000.00D);

        //加入排序参数
        map.put("sort", "salary desc");

        //加入分页参数
        int page = 1;
        int pageSize = 5;
        map.put("skip", (page - 1) * pageSize);
        map.put("pageSize", pageSize);

        //加入需要返回的列
        List<String> tableColumnList = new ArrayList<>();
        tableColumnList.add("id");
        tableColumnList.add("salary");
        map.put("tableColumnList", tableColumnList);

        List<UserModel> userModelList = UserUtil.callMapper(UserMapper.class, mapper -> mapper.getModelList(map));
        log.info("结果:{}", userModelList);
    }
}
项目最终结构如下

image

测试：动态插入

运行动态插入，输出如下：

29:45.734 [main] DEBUG z.mybatis.chat01.UserMapper.insert - ==>  Preparing: INSERT INTO `user` ( `name` ) VALUES ( ? ) 
29:45.755 [main] DEBUG z.mybatis.chat01.UserMapper.insert - ==> Parameters: Java冢狐(String)
29:45.843 [main] DEBUG z.mybatis.chat01.UserMapper.insert - <==    Updates: 1
29:45.859 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==>  Preparing: SELECT `id`, `name`, `age`, `salary` FROM `user` a WHERE a.`id` = ? 
29:45.859 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==> Parameters: 1(Long)
29:45.871 [main] DEBUG z.m.chat01.UserMapper.getModelList - <==      Total: 1
29:45.871 [main] INFO  z.mybatis.chat01.UserMapperTest - 插入结果：UserModel(id=1, name=Java冢狐, age=1, salary=0.0)
29:45.873 [main] INFO  z.mybatis.chat01.UserMapperTest - ---------------------
29:45.873 [main] DEBUG z.mybatis.chat01.UserMapper.insert - ==>  Preparing: INSERT INTO `user` ( `name`, `age`, `salary` ) VALUES ( ?, ?, ? ) 
29:45.874 [main] DEBUG z.mybatis.chat01.UserMapper.insert - ==> Parameters: 冢狐(String), 23(Integer), 50000.0(Double)
29:46.081 [main] DEBUG z.mybatis.chat01.UserMapper.insert - <==    Updates: 1
29:46.082 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==>  Preparing: SELECT `id`, `name`, `age`, `salary` FROM `user` a WHERE a.`id` = ? 
29:46.082 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==> Parameters: 2(Long)
29:46.083 [main] DEBUG z.m.chat01.UserMapper.getModelList - <==      Total: 1
29:46.083 [main] INFO  z.mybatis.chat01.UserMapperTest - 插入结果：UserModel(id=2, name=冢狐, age=23, salary=50000.0)
  • 数据库数据变为：

image

这个方法主要有4步操作：

  • 插入一条用户记录，用户记录只有name字段有值
  • 去db中查询步骤1中插入的记录
  • 插入一条用户记录，这次插入的记录所有字段都指定了值
  • 去db中查询步骤3中插入的记录

两次插入调用都是mapper.insert方法，传入的都是UserModel对象，唯一不同的是这个对象构建的时候字段的值不一样，最后再认真看一下上面输出的sql，产生的2个insert也是不一样的，这个mapper.insert方法可以根据UserModel对象字段是否有值来组装我们需要的sql，这就实现了动态插入

测试：批量插入

运行批量插入，输出如下：

33:49.134 [main] DEBUG z.m.chat01.UserMapper.insertBatch - ==>  Preparing: INSERT INTO `user` (`id`, `name`, `age`, `salary`) VALUES (?, ?, ?, ?) , (?, ?, ?, ?) , (?, ?, ?, ?) , (?, ?, ?, ?) , (?, ?, ?, ?) , (?, ?, ?, ?) , (?, ?, ?, ?) , (?, ?, ?, ?) , (?, ?, ?, ?) , (?, ?, ?, ?) 
33:49.155 [main] DEBUG z.m.chat01.UserMapper.insertBatch - ==> Parameters: null, Java冢狐-1(String), 24(Integer), 10000.0(Double), null, Mybatis-1(String), 19(Integer), 10000.0(Double), null, Java冢狐-2(String), 25(Integer), 20000.0(Double), null, Mybatis-2(String), 20(Integer), 20000.0(Double), null, Java冢狐-3(String), 26(Integer), 30000.0(Double), null, Mybatis-3(String), 21(Integer), 30000.0(Double), null, Java冢狐-4(String), 27(Integer), 40000.0(Double), null, Mybatis-4(String), 22(Integer), 40000.0(Double), null, Java冢狐-5(String), 28(Integer), 50000.0(Double), null, Mybatis-5(String), 23(Integer), 50000.0(Double)
33:49.378 [main] DEBUG z.m.chat01.UserMapper.insertBatch - <==    Updates: 10
33:49.387 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==>  Preparing: SELECT `id`, `name`, `age`, `salary` FROM `user` a 
33:49.387 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==> Parameters: 
33:49.397 [main] DEBUG z.m.chat01.UserMapper.getModelList - <==      Total: 12
33:49.397 [main] INFO  z.mybatis.chat01.UserMapperTest - 结果:[UserModel(id=1, name=Java冢狐, age=1, salary=0.0), UserModel(id=2, name=冢狐, age=23, salary=50000.0), UserModel(id=3, name=Java冢狐-1, age=24, salary=10000.0), UserModel(id=4, name=Mybatis-1, age=19, salary=10000.0), UserModel(id=5, name=Java冢狐-2, age=25, salary=20000.0), UserModel(id=6, name=Mybatis-2, age=20, salary=20000.0), UserModel(id=7, name=Java冢狐-3, age=26, salary=30000.0), UserModel(id=8, name=Mybatis-3, age=21, salary=30000.0), UserModel(id=9, name=Java冢狐-4, age=27, salary=40000.0), UserModel(id=10, name=Mybatis-4, age=22, salary=40000.0), UserModel(id=11, name=Java冢狐-5, age=28, salary=50000.0), UserModel(id=12, name=Mybatis-5, age=23, salary=50000.0)]

这次批量插入了10条用户记录，可以看到有这样的输出：

33:49.378 [main] DEBUG z.m.chat01.UserMapper.insertBatch - <==    Updates: 10

上面这个表示插入影响的行数，10表示插入了10行。

批量插入之后，又执行了全表查询，这次插入了10条，加上前面的2个单条插入，表中总计12条记录。

  • 数据库数据变为：

image

测试：根据用户id删除数据

运行删除，输出如下：

44:52.064 [main] DEBUG z.mybatis.chat01.UserMapper.delete - ==>  Preparing: DELETE FROM `user` WHERE `id` = ? 
44:52.083 [main] DEBUG z.mybatis.chat01.UserMapper.delete - ==> Parameters: 1(Integer)
44:52.383 [main] DEBUG z.mybatis.chat01.UserMapper.delete - <==    Updates: 1
44:52.386 [main] INFO  z.mybatis.chat01.UserMapperTest - 删除行数：1
  • 数据库结果如下：

image

测试：动态更新

运行动态更新代码，输出如下：

45:44.648 [main] DEBUG z.mybatis.chat01.UserMapper.update - ==>  Preparing: UPDATE `user` SET `name` = ? WHERE `id` = ? 
45:44.670 [main] DEBUG z.mybatis.chat01.UserMapper.update - ==> Parameters: 修改冢狐(String), 2(Long)
45:44.788 [main] DEBUG z.mybatis.chat01.UserMapper.update - <==    Updates: 1
45:44.790 [main] INFO  z.mybatis.chat01.UserMapperTest - 更新行数：1
45:44.792 [main] INFO  z.mybatis.chat01.UserMapperTest - ---------------------
45:44.793 [main] DEBUG z.mybatis.chat01.UserMapper.update - ==>  Preparing: UPDATE `user` SET `name` = ?, `salary` = ? WHERE `id` = ? 
45:44.793 [main] DEBUG z.mybatis.chat01.UserMapper.update - ==> Parameters: 修改冢狐(String), 6666.66(Double), 3(Long)
45:44.980 [main] DEBUG z.mybatis.chat01.UserMapper.update - <==    Updates: 1
45:44.981 [main] INFO  z.mybatis.chat01.UserMapperTest - 更新行数：1

2个更新，调用都是mapper.update方法，传入的都是UserModel类型的参数，只是2个UserModel对象的字段值不一样，最后产生的2个update语句也是不一样的，这个update语句是mybatis动态组装的，mybatis可以根据UserModel中字段是否为NULL，来拼装sql。

  • 数据库结果

image

测试：动态查询
查询所有数据

运行查询有数据代码，输出如下：

46:56.345 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==>  Preparing: SELECT `id`, `name`, `age`, `salary` FROM `user` a 
46:56.364 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==> Parameters: 
46:56.376 [main] DEBUG z.m.chat01.UserMapper.getModelList - <==      Total: 11
46:56.380 [main] INFO  z.mybatis.chat01.UserMapperTest - 结果:[UserModel(id=2, name=修改冢狐, age=23, salary=50000.0), UserModel(id=3, name=修改冢狐, age=24, salary=6666.66), UserModel(id=4, name=Mybatis-1, age=19, salary=10000.0), UserModel(id=5, name=Java冢狐-2, age=25, salary=20000.0), UserModel(id=6, name=Mybatis-2, age=20, salary=20000.0), UserModel(id=7, name=Java冢狐-3, age=26, salary=30000.0), UserModel(id=8, name=Mybatis-3, age=21, salary=30000.0), UserModel(id=9, name=Java冢狐-4, age=27, salary=40000.0), UserModel(id=10, name=Mybatis-4, age=22, salary=40000.0), UserModel(id=11, name=Java冢狐-5, age=28, salary=50000.0), UserModel(id=12, name=Mybatis-5, age=23, salary=50000.0)]

可以看到sql是没有查询条件的。

查询多个用户id对应的数据

运行查询多个用户id对应数据，输出如下：

47:46.118 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==>  Preparing: SELECT `id`, `name`, `age`, `salary` FROM `user` a WHERE a.`id` IN ( ? , ? , ? ) 
47:46.139 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==> Parameters: 2(Integer), 3(Integer), 4(Integer)
47:46.150 [main] DEBUG z.m.chat01.UserMapper.getModelList - <==      Total: 3
47:46.151 [main] INFO  z.mybatis.chat01.UserMapperTest - 结果:[UserModel(id=2, name=修改冢狐, age=23, salary=50000.0), UserModel(id=3, name=修改冢狐, age=24, salary=6666.66), UserModel(id=4, name=Mybatis-1, age=19, salary=10000.0)]

上面这个按照id列表查询也是比较常用的，比如我们在电商中查询订单列表，还需要查询每个订单对应的商品，此时可以先查询订单列表，然后在通过订单列表拿到所有的商品id集合，然后通过商品id集合去通过上面的方式检索商品信息，只需要2次查询就可以查询出订单及商品的信息了。

多条件 & 指定返回的列

运行多条件查询语句，查询姓名中包含Java冢狐以及薪资大于3万的用户id、姓名，输出如下：

48:34.925 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==>  Preparing: SELECT id , name FROM `user` a WHERE a.`name` like '%Java冢狐%' AND a.`salary` >= ? 
48:34.945 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==> Parameters: 30000.0(Double)
48:34.955 [main] DEBUG z.m.chat01.UserMapper.getModelList - <==      Total: 3
48:34.955 [main] INFO  z.mybatis.chat01.UserMapperTest - 结果:[UserModel(id=7, name=Java冢狐-3, age=null, salary=null), UserModel(id=9, name=Java冢狐-4, age=null, salary=null), UserModel(id=11, name=Java冢狐-5, age=null, salary=null)]

看一下上面select语句，select后面只有id,name2个字段，where后面有多个条件，这种查询也是比较常用的，有些表可能有几十个字段，可能我们只需要几个字段，就可以使用上面这种查询。

条件过滤 & 排序 & 分页查询数据 & 只返回用户id、salary

运行分页查询，查询姓名中包含Java冢狐以及薪资大于3万的用户id，按照薪资倒叙，每页5条取第1页，输出如下：

49:03.709 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==>  Preparing: SELECT id , salary FROM `user` a WHERE a.`name` like '%Java冢狐%' AND a.`salary` >= ? order by salary desc LIMIT ?,? 
49:03.728 [main] DEBUG z.m.chat01.UserMapper.getModelList - ==> Parameters: 30000.0(Double), 0(Integer), 5(Integer)
49:03.739 [main] DEBUG z.m.chat01.UserMapper.getModelList - <==      Total: 3
49:03.740 [main] INFO  z.mybatis.chat01.UserMapperTest - 结果:[UserModel(id=11, name=null, age=null, salary=50000.0), UserModel(id=9, name=null, age=null, salary=40000.0), UserModel(id=7, name=null, age=null, salary=30000.0)]

大家主要看一下输出的sql，如下：

SELECT id , salary FROM `user` a WHERE a.`name` like '%Java冢狐%' AND a.`salary` >= ? order by salary desc LIMIT ?,?

这个sql会根据查询条件，自动构建出我们需要的sql，十分的方便和简洁

案例总结

上面列举的一些用例基本上包含了我们对db所需的大部分操作，动态sql处理方面体现的最为强劲，如果让我们自己写，我们需要写很多判断，而用mybatis这么简单就实现了，我们在java代码中没有看到一个判断拼接语句，而这些sql的判断拼接都在一个文件中：user.xml中，这个就是mybatis中核心的文件，我们需要写的sql及判断逻辑基本上都在这个xml中，大家可以认真去看一下这个xml文件。

最后

  • 如果觉得看完有收获，希望能关注一下，顺便给我点个赞，这将会是我更新的最大动力，感谢各位的支持
  • 欢迎各位关注我的公众号【java冢狐】，专注于java和计算机基础知识，保证让你看完有所收获，不信你打我
  • 求一键三连：点赞、转发、在看。
  • 如果看完有不同的意见或者建议，欢迎多多评论一起交流。感谢各位的支持以及厚爱。

——我是冢狐，和你一样热爱编程。

欢迎关注公众号“ Java冢狐”，获取最新消息

java冢狐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Mybatis 学习笔记
weixin_46473567的博客
07-29 1029
Mybatis概述简介映射器CRUD别名动态SQL关联查询缓存特殊字符处理 概述 简介 MyBatis的读音是：[mai‘bətɪs]，中文音译：麦-波蒂斯。MyBatis的读音是：[mai‘bətɪs]，中文音译：麦-波蒂斯。 MyBatis是一个优秀的数据持久层框架，它对JDBC的操作数据库的过程进行封装。 MyBatis使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建Connection、创建Statement、手动设置参数、结果集检索等JDBC繁杂的过程代码。 MyBati
【MyBatis学习笔记一】——MyBatis入门demo.zip
05-28
【MyBatis学习笔记一】——MyBatis入门demo.zip 博客地址：https://blog.csdn.net/weixin_43817709/article/details/117370755
Mybatis基础——基本项目搭建
micrice的博客
04-05 193
Mybatis简介： MybatisMyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 官方文档：...
Java项目:智慧校园管理系统(java+SpringBoot+Mybaits+Vue+elementui+mysql)
m0_66863468的博客
04-10 573
项目介绍 基于Springboot + vue实现的智慧校园管理系统 系统包含学生、老师、管理员三个角色,分为前后台； 学生：登录、注册、查看计算机软件（收藏、下载、留言）、查看课程（在线观看、下载、留言）、查看音乐（收藏、播放、留言）、个人中心、我的收藏、记事本管理、备忘录管理、宿舍管理、成绩管理等 老师：登录、个人中心、计算机软件管理、计算机软件留言管理、课程管理、课程留言管理、宿舍管理、宿舍人员管理、宿舍归寝管理、宿舍报修管理、音乐管理、成绩管理等 管理员：登录、个人中心、基础数据管理、记事
mybatis学习记录：搭建一个简单的mybatis项目（idea版）
VVU25的博客
12-13 679
mybatis入门:简单搭建mybatis项目
Mybatis学习——用Maven快速构建Mybatis项目并测试（对比JDBC代码）
weixin_43725818的博客
03-25 218
Mybatis学习——如何快速构建Mybatis项目 学习完JDBC后再看Mybatis后，就会发现Mybatis就是将JDBC复杂繁琐的一套进行了简化，只需要数个配置xml文件，即可实现JDBC中的增删改查操作。这里就记录一下自己的学习过程。 注：学习资源来自于遇见狂神说的Mybatis学习教程以及Mybatis官方文档 使用Maven构建项目 创建好Maven项目后修改内部的pom.xml文件 首先是导入该项目会依赖的三种包——mysql，mybatis以及junit <!--导入依赖-->
Mybatis 练习项目
qq_45862617的博客
07-30 852
目的 刚学完Mybatis，用一些小项目来巩固练习。 练习1 题目描述 做一个密码验证界面，只需要一点点html和Servlet知识，整个项目使用MVC设计模式，三个包，Entity，Service，Dao。数据库有一张名为user的表，有主键Id，用户名name，密码password。 步骤 准备 1.建表 CREATE TABLE Users( `id` INT, `name` VARCHAR(24), `password` VARCHAR(24), ..
mybatis ＜if 大于小于 条件写法＞ gt gte lt lte
记录博客好习惯
10-11 3565
gt: greater than 大于 gte: greater than or equal 大于等于 lt: less than 小于 lte: less than or equal 小于等于 示例 tn>2 and tn <=9 <if test="request.tn gt 2 and request.tn lte 9"> AND aging.${request.durationField}=#{request.tn} .
Spring MVC MyBatis开发从入门到项目实战
05-03
本资源主要讲解Spring MVC和MyBatis的开发，从入门到项目实战，涵盖了开发环境搭建、JDK安装与配置、MyEclipse的安装与使用、第一个Java类的编写、MyBatis技术入门、传统JDBC开发模式的缺陷、MyBatis的介绍、MyBatis...
Mybatis动态sql
08-12
Mybatis动态SQL实现，详细，简单，！
Spring MVC+MyBatis开发从入门到项目实战
04-21
《Spring MVC+MyBatis开发从入门到项目实战》分为4篇。第1篇是Java开发环境的搭建，包括JDK的下载与安装、环境变量的配置、MyEclipse的下载与基本配置。第2篇是MyBatis技术入门，包括剖析JDBC的弊端、MyBatis的背景...
mybatis从入门到精通（第一节）
04-22
• 查询缓存（一级缓存、二级缓存） • 延迟加载（侵入式延迟加载、深度延迟加载） • 关联查询（一对一、一对映射） • 逆向工程 • PageHelper分页插件 • 注解开发 主键返回（mybatis的自增主键或者非自增主键） ...
Mybatis动态插入数据、更新数据
qq_38294614的博客
10-30 9678
有时我们控制同一张表，但传入的参数不固定，操作表的字段不固定，就要用到mybatis动态插入。xml如下： &lt;insert id="insertMessage" parameterType="com.sf.ccsp.member.client.request.MessageReq"&gt; insert cx_customer_message (ID,MEMB...
Mybatis简单入门(三)
mashizhong521的博客
04-26 233
动态sql MyBatis常用OGNL表达式 e1 or e2 e1 and e2 e1 == e2,e1 eq e2 e1 != e2,e1 neq e2 e1 lt e2：小于 e1 lte e2：小于等于，其他gt（大于）,gte（大于等于） e1 in e2 e1 not in e2 e1 + e2,e1 * e2,e1/e2,e1 - e2,e1%e2 !e,n...
Mybatis-Plus eq、ne、gt、lt、ge、le分别代表含义
热门推荐
segegefe的博客
04-21 1万+
Mybatis-Plus eq、ne、gt、lt、ge、le分别代表含义 eq 就是 equal等于 ne就是 not equal不等于 gt 就是 greater than大于 lt 就是 less than小于 ge 就是 greater than or equal 大于等于 le 就是 less than or equal 小于等于 in 就是 in 包含（数组） isNull 就是 等于null between 就是 在2个条件之间(包括边界值) like就是 模糊查询 ...
Mybatis动态SQL的用法
TayGo
03-26 281
where标签 where标签会去除第一个条件中出现的前置 and 或者or关键字。 set标签 set标签就是去除最后一个更新字段语句中出现的,[逗号]后缀。 update sys_job <set> <if test="jobName != null and jobName != ''"> job_name = #{jobName}, </if> <if test="jobGroup != null and jobGroup != ''"&gt
MyBatis动态SQL多表操作
我的博客
12-03 5975
MyBatis动态SQL、多表操作 foreach标签 多表操作 一对一 一个用户有一张订单 通过把两张表对应的实体类连接起来,只不过是主键ID要用单独的标签 SQL环节和原来没什么区别，同样也是通过resultMap把字段和属性映射封装一个用户有多张订单 property:集合名称，User实体中的orderlist属性 ofType：当前集合中的数据类型，就是order实体 原有的User实体中加上一个表示“用户有哪些订单的属性” 多对多 多
jiaoyanguizeduibi
最新发布
07-10
jiaoyanguizeduibi
Mybatis讲义laodu
11-13
第二部分是MyBatis的入门程序，讲义介绍了MyBatis的软件版本、组件版本、下载方式以及入门程序的开发步骤。通过这一部分的学习，读者可以迅速上手MyBatis的开发，了解MyBatis的基本操作及配置。 接下来的第三部分...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值