使用MyBatis的动态SQL注解实现实体的CRUD操作代码

 更新时间:2024年06月24日 09:00:41   作者:徐州蔡徐坤  
在使用MyBatis进行数据库操作时,动态SQL注解提供了一种优雅的方式来编写动态SQL语句,MyBatis 3.x 版本提供了下四个CRUD的高级注解,这些注解可以帮助开发者在Mapper接口中动态地构建SQL语句,本文给大家介绍了使用MyBatis的动态SQL注解实现实体的CRUD操作

1. 引言

在使用MyBatis进行数据库操作时,动态SQL注解提供了一种优雅的方式来编写动态SQL语句。MyBatis 3.x 版本提供了以下四个CRUD的高级注解:

  • @SelectProvider:用于构建动态查询SQL。
  • @InsertProvider:用于构建动态新增SQL。
  • @UpdateProvider:用于构建动态更新SQL。
  • @DeleteProvider:用于构建动态删除SQL。

这些注解可以帮助开发者在Mapper接口中动态地构建SQL语句,避免了在XML配置文件中编写大量的SQL代码,使代码更加简洁和易于维护。本文将详细介绍如何使用这些动态SQL注解来实现书籍信息的查询、新增、修改和删除操作。

此外,我们将与MyBatis Plus中的@Select注解进行对比,展示MyBatis动态SQL注解的优势和灵活性。

2. 准备工作

2.1 创建数据表

首先,需要创建一个代表书籍信息的表 tb_book

-- 判断数据表是否存在,存在则删除
DROP TABLE IF EXISTS tb_book;

-- 创建“书籍信息”数据表
CREATE TABLE IF NOT EXISTS tb_book
(
    book_id INT AUTO_INCREMENT PRIMARY KEY COMMENT '书籍编号',
    book_name VARCHAR(50) NOT NULL COMMENT '书名',
    author VARCHAR(50) NOT NULL COMMENT '作者',
    publisher VARCHAR(50) COMMENT '出版社',
    publish_date DATE COMMENT '出版日期'
) COMMENT = '书籍信息表';

-- 添加数据
INSERT INTO tb_book(book_name, author, publisher, publish_date) VALUES ('书籍1', '作者1', '出版社1', '2023-01-01');

2.2 创建实体类 Book

在 com.zhouquan.entity 包中创建 Book 类,使用 @Data 注解来自动生成getter和setter方法。

package com.zhouquan.entity;
import lombok.Data;
import java.util.Date;

/**
 * 书籍信息实体类
 */
@Data
public class Book {
    /**
     * 书籍编号
     */
    private int bookId;
    
    /**
     * 书名
     */
    private String bookName;
    
    /**
     * 作者
     */
    private String author;
    
    /**
     * 出版社
     */
    private String publisher;
    
    /**
     * 出版日期
     */
    private Date publishDate;
}

2.3 修改Mapper接口 BookMapper

在 com.zhouquan.mapper 包中创建 BookMapper 接口,并使用动态SQL注解来实现CRUD操作。

package com.zhouquan.mapper;

import com.zhouquan.entity.Book;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.jdbc.SQL;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface BookMapper {

    @SelectProvider(type = BookSqlBuilder.class, method = "buildGetBookByIdSql")
    public Book getBookById(@Param("bookId") int bookId);

    @InsertProvider(type = BookSqlBuilder.class, method = "buildInsertBookSql")
    @Options(useGeneratedKeys = true, keyColumn = "book_id", keyProperty = "bookId")
    public int insertBook(Book book);

    @UpdateProvider(type = BookSqlBuilder.class, method = "buildUpdateBookSql")
    public int updateBook(Book book);

    @DeleteProvider(type = BookSqlBuilder.class, method = "buildDeleteBookSql")
    public int deleteBook(@Param("bookId") int bookId);

    class BookSqlBuilder {
        public String buildGetBookByIdSql(@Param("bookId") int bookId) {
            return new SQL() {{
                SELECT("*");
                FROM("tb_book");
                WHERE("book_id = #{bookId}");
            }}.toString();
        }

        public String buildInsertBookSql(Book book) {
            return new SQL() {{
                INSERT_INTO("tb_book");
                VALUES("book_name", "#{bookName}");
                VALUES("author", "#{author}");
                VALUES("publisher", "#{publisher}");
                VALUES("publish_date", "#{publishDate}");
            }}.toString();
        }

        public String buildUpdateBookSql(Book book) {
            return new SQL() {{
                UPDATE("tb_book");
                SET("book_name = #{bookName}", "author = #{author}", "publisher = #{publisher}", "publish_date = #{publishDate}");
                WHERE("book_id = #{bookId}");
            }}.toString();
        }

        public String buildDeleteBookSql(@Param("bookId") int bookId) {
            return new SQL() {{
                DELETE_FROM("tb_book");
                WHERE("book_id = #{bookId}");
            }}.toString();
        }
    }
}

3. 测试CRUD操作

为了测试CRUD操作,我们将使用JUnit进行单元测试,并通过日志记录操作的结果。

3.1 配置日志

在Maven的pom.xml文件中引入SLF4J和Logback的依赖:

<dependencies>
    <!-- MyBatis 依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.4</version>
    </dependency>
    
    <!-- SLF4J 依赖 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.30</version>
    </dependency>
  
</dependencies>

3.2 查询操作

import com.zhouquan.entity.Book;
import com.zhouquan.mapper.BookMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BookMapperTest {

    private static final Logger logger = LoggerFactory.getLogger(BookMapperTest.class);

    @Autowired
    private BookMapper bookMapper;

    /**
     * 根据书籍ID,获取书籍信息
     */
    @Test
    public void getBookById() {
        Book book = bookMapper.getBookById(1);
        logger.info("书籍编号:{}", book.getBookId());
        logger.info("书名:{}", book.getBookName());
        logger.info("作者:{}", book.getAuthor());
        logger.info("出版社:{}", book.getPublisher());
        logger.info("出版日期:{}", book.getPublishDate());
    }
}

3.3 新增操作

@Autowired
private BookMapper bookMapper;

/**
 * 新增书籍,并获取自增主键
 */
@Test
public void insertBook() {
    Book book = new Book();
    book.setBookName("新书");
    book.setAuthor("新作者");
    book.setPublisher("新出版社");
    book.setPublishDate(new Date());
    bookMapper.insertBook(book);
    logger.info("新增书籍ID:{}", book.getBookId());
}

3.4 修改操作

@Autowired
private BookMapper bookMapper;

/**
 * 更新书籍信息
 */
@Test
public void updateBook() {
    Book book = bookMapper.getBookById(1);
    book.setBookName("更新后的书名");
    bookMapper.updateBook(book);
    logger.info("更新后的书名:{}", book.getBookName());
}

3.5 删除操作

@Autowired
private BookMapper bookMapper;

/**
 * 删除书籍
 */
@Test
public void deleteBook() {
    bookMapper.deleteBook(1);
    logger.info("删除书籍ID为1的记录");
}

4. 与MyBatis Plus的对比

MyBatis Plus提供了一种更加简洁的方式来编写SQL语句,例如,使用@Select注解可以直接在Mapper接口中编写SQL语句,而无需单独定义SQL构建器类。

例如,使用MyBatis Plus可以这样定义BookMapper接口:

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zhouquan.entity.Book;
import org.apache.ibatis.annotations.Select;

public interface BookMapper extends BaseMapper<Book> {

    @Select("SELECT * FROM tb_book WHERE book_id = #{bookId}")
    Book getBookById(int bookId);
}

这种方式相对于MyBatis动态SQL注解而言,更加直接和易读。但是,MyBatis动态SQL注解在处理复杂SQL语句时具有更高的灵活性和可维护性,特别是当需要根据不同条件动态生成SQL时,MyBatis动态SQL注解显得更为强大和适用

5. 动态SQL注解的适用场景

5.1 动态查询条件

在一些应用中,查询条件是动态的,可能根据不同的用户输入或业务逻辑生成不同的查询条件。使用动态SQL注解可以在运行时根据这些条件动态构建查询语句,避免了硬编码查询条件的问题。

public String buildDynamicQuerySql(Map<String, Object> params) {
    return new SQL() {{
        SELECT("*");
        FROM("tb_book");
        if (params.get("author") != null) {
            WHERE("author = #{author}");
        }
        if (params.get("publisher") != null) {
            WHERE("publisher = #{publisher}");
        }
        if (params.get("publishDate") != null) {
            WHERE("publish_date = #{publishDate}");
        }
    }}.toString();
}

5.2 动态插入和更新

在一些情况下,插入或更新的数据字段可能不是固定的,而是根据业务需求动态变化的。使用动态SQL注解可以根据传入的实体对象构建动态插入或更新语句。

public String buildDynamicInsertSql(Book book) {
    return new SQL() {{
        INSERT_INTO("tb_book");
        if (book.getBookName() != null) {
            VALUES("book_name", "#{bookName}");
        }
        if (book.getAuthor() != null) {
            VALUES("author", "#{author}");
        }
        if (book.getPublisher() != null) {
            VALUES("publisher", "#{publisher}");
        }
        if (book.getPublishDate() != null) {
            VALUES("publish_date", "#{publishDate}");
        }
    }}.toString();
}

public String buildDynamicUpdateSql(Book book) {
    return new SQL() {{
        UPDATE("tb_book");
        if (book.getBookName() != null) {
            SET("book_name = #{bookName}");
        }
        if (book.getAuthor() != null) {
            SET("author = #{author}");
        }
        if (book.getPublisher() != null) {
            SET("publisher = #{publisher}");
        }
        if (book.getPublishDate() != null) {
            SET("publish_date = #{publishDate}");
        }
        WHERE("book_id = #{bookId}");
    }}.toString();
}

5.3 复杂的业务逻辑

在一些复杂的业务场景中,SQL语句的构建逻辑可能非常复杂,涉及多个表的联接、多种条件的判断等。使用动态SQL注解可以在Java代码中使用条件逻辑来构建复杂的SQL语句,使代码更加清晰和易于维护。

public String buildComplexQuerySql(Book book) {
    return new SQL() {{
        SELECT("b.*, a.author_name, p.publisher_name");
        FROM("tb_book b");
        JOIN("tb_author a ON b.author_id = a.author_id");
        JOIN("tb_publisher p ON b.publisher_id = p.publisher_id");
        if (book.getBookName() != null) {
            WHERE("b.book_name LIKE CONCAT('%', #{bookName}, '%')");
        }
        if (book.getAuthor() != null) {
            WHERE("a.author_name LIKE CONCAT('%', #{author}, '%')");
        }
        if (book.getPublisher() != null) {
            WHERE("p.publisher_name LIKE CONCAT('%', #{publisher}, '%')");
        }
    }}.toString();
}

5.4 查询结果动态列的聚合

需求类似于下,根据专题聚合出不同的资料类型,select中的列需要动态的拼接,显然MP的mapper对于此种需求的支持并不友好

 /**
     * 资源量统计-根据专题
     * 之所以使用此种方式是因为统计的列是不固定的,所以需要动态拼接select
     *
     * @param resourceTypeNameList 资源名称列表
     * @param resourceTypeSidList  资源sid列表
     * @param start                加工开始时间
     * @param end                  加工结束时间
     * @return
     */
    public String groupTopicDynamicSQL(final List<String> resourceTypeNameList, final List<String> resourceTypeSidList,
                                       final LocalDate start, final LocalDate end) {
        // 构建外部查询
        SQL outerQuery = new SQL();
        outerQuery.SELECT("COALESCE(topic_name, '总计') AS '专题'");

        if (resourceTypeNameList != null && !resourceTypeNameList.isEmpty()) {
            for (String rt : resourceTypeNameList) {
                outerQuery.SELECT(String.format("SUM(CASE WHEN resource_type_name = '%s' THEN count ELSE 0 END) AS " +
                        "'%s'", rt, rt));
            }
        }

        // 构建子查询
        SQL subQuery = new SQL();
        subQuery.SELECT("rt.name AS resource_type_name, t.name AS topic_name, COUNT(*) AS count")
                .FROM("works w")
                .JOIN("works_topic wt ON w.sid = wt.work_sid")
                .JOIN("topic t ON wt.topic_sid = t.sid")
                .JOIN("resource_type rt ON w.type_leaf_sid = rt.sid")
                .WHERE(" w.deleted=0 ");

        if (resourceTypeNameList != null && !resourceTypeNameList.isEmpty()) {
            String joinedResourceTypes = resourceTypeSidList.stream()
                    .map(rt -> "'" + rt + "'")
                    .collect(Collectors.joining(", "));
            subQuery.WHERE("w.type_leaf_sid IN (" + joinedResourceTypes + ")");
        }
        if (start != null) {
            subQuery.WHERE("w.update_time >= #{start}");
        }
        if (end != null) {
            subQuery.WHERE("w.update_time <= #{end}");
        }
        subQuery.GROUP_BY("rt.name, t.name");

        outerQuery.SELECT("SUM(count) AS '总计'")
                .FROM("(" + subQuery + ") AS subQuery")
                .GROUP_BY("topic_name WITH ROLLUP");

        return outerQuery.toString();
    }
/**
 * 统计分析-资源量统计
 *
 * @param resourceTypeNameList
 * @param resourceTypeSidList
 * @param start
 * @param end
 * @return
 */
@SelectProvider(type = WorksSqlProvider.class, method = "groupTopicDynamicSQL")
List<Map<String, Object>> staticByTopic(@Param("resourceTypeNameList") List<String> resourceTypeNameList,
                                        @Param("resourceTypeSidList") List<String> resourceTypeSidList,
                                        @Param("start") LocalDate start,
                                        @Param("end") LocalDate end);

6. 小结

MyBatis动态SQL注解通过提供更加灵活和动态的方式来构建SQL语句,使得代码更加简洁和易于维护。而MyBatis Plus通过简化SQL编写过程,提供了一种更加便捷的方式来进行数据库操作。根据具体项目的需求和复杂度,可以选择适合的工具来实现数据库操作。

通过上述介绍,可以看出动态SQL注解在处理动态查询条件、动态插入和更新以及复杂的业务逻辑时具有明显的优势和适用性。在实际开发中,合理使用动态SQL注解可以提高代码的灵活性和可维护性。

以上就是使用MyBatis的动态SQL注解实现实体的CRUD操作代码的详细内容,更多关于MyBatis动态SQLCRUD操作的资料请关注脚本之家其它相关文章!

相关文章

  • Spring如何集成ibatis项目并实现dao层基类封装

    Spring如何集成ibatis项目并实现dao层基类封装

    这篇文章主要介绍了Spring如何集成ibatis项目并实现dao层基类封装,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-09-09
  • 解决JDK异常处理No appropriate protocol问题

    解决JDK异常处理No appropriate protocol问题

    这篇文章主要介绍了解决JDK异常处理No appropriate protocol问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-06-06
  • java并发编程中ReentrantLock可重入读写锁

    java并发编程中ReentrantLock可重入读写锁

    这篇文章主要介绍了java并发编程中ReentrantLock可重入读写锁,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2022-05-05
  • 浅谈Spring解决jar包依赖的bom

    浅谈Spring解决jar包依赖的bom

    这篇文章主要介绍了浅谈Spring解决jar包依赖的bom,具有一定借鉴价值,需要的朋友可以参考下
    2017-12-12
  • Java中的static关键字你了解多少

    Java中的static关键字你了解多少

    这篇文章主要为大家详细介绍了Java中的static关键字,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助
    2022-02-02
  • Java中Controller引起的Ambiguous mapping问题及解决

    Java中Controller引起的Ambiguous mapping问题及解决

    这篇文章主要介绍了Java中Controller引起的Ambiguous mapping问题及解决,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2022-10-10
  • 详解Java ArrayList类

    详解Java ArrayList类

    这篇文章主要介绍了Java ArrayList类的相关资料,文中示例代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
    2020-07-07
  • Java设计模式之观察者模式

    Java设计模式之观察者模式

    这篇文章主要为大家介绍了Java观察者模式,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助
    2021-12-12
  • SpringBoot + validation 接口参数校验的思路详解

    SpringBoot + validation 接口参数校验的思路详解

    这篇文章主要介绍了SpringBoot + validation 接口参数校验,本文通过项目实践+场景分析给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-10-10
  • 解读@NotNull和@NonNull的区别及使用

    解读@NotNull和@NonNull的区别及使用

    这篇文章主要介绍了解读@NotNull和@NonNull的区别及使用,具有很好的参考价值,希望对大家有所帮助。
    2023-01-01

最新评论