SpringBoot整合MyBatis-Flex的保姆级教程_Java

一、mybatis-flex 介绍

mybatis-flex 是一个基于 mybatis 的增强框架，它提供了比传统 mybatis plus 更加强大和灵活的功能特性。以下是其主要特点：

1.核心特性

轻量级设计：框架非常轻量，依赖少，启动速度快
功能强大：提供丰富的查询api，支持多表关联查询、分页查询等
灵活的查询方式：支持 querywrapper、lambda 表达式等多种查询方式
多数据库支持：兼容多种主流数据库（mysql、postgresql、oracle等）
代码生成：内置高效的代码生成器

2.优势亮点

无侵入性：对原有 mybatis 几乎无侵入，迁移成本低
性能优越：查询性能经过优化，比传统 mybatis 更高效
注解丰富：提供丰富的注解支持，简化配置
动态sql：强大的动态 sql 构建能力
多租户支持：内置多租户方案，开箱即用

二、springboot 整合 mybatis-flex 详细步骤

步骤1：创建 springboot 项目并添加依赖

<!-- pom.xml -->
<dependencies>
    <!-- spring boot starter -->
    <dependency>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-web</artifactid>
    </dependency>
    
    <!-- mybatis-flex springboot starter -->
    <dependency>
        <groupid>com.mybatis-flex</groupid>
        <artifactid>mybatis-flex-spring-boot-starter</artifactid>
        <version>1.8.6</version>
    </dependency>
    
    <!-- 数据库驱动 (以mysql为例) -->
    <dependency>
        <groupid>com.mysql</groupid>
        <artifactid>mysql-connector-java</artifactid>
        <version>8.0.33</version>
    </dependency>
    
    <!-- lombok (可选) -->
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
        <optional>true</optional>
    </dependency>
    
    <!-- 代码生成器 (可选) -->
    <dependency>
        <groupid>com.mybatis-flex</groupid>
        <artifactid>mybatis-flex-codegen</artifactid>
        <version>1.8.6</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

步骤2：配置 application.yml

# application.yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.driver
    url: jdbc:mysql://localhost:3306/mybatis_flex_db?useunicode=true&characterencoding=utf8&usessl=false&servertimezone=asia/shanghai
    username: root
    password: 123456

mybatis-flex:
  # 配置 mapper 扫描路径
  mapper-locations: classpath*:/mapper/**/*mapper.xml
  # 全局配置
  configuration:
    # 下划线转驼峰
    map-underscore-to-camel-case: true
    # 日志实现
    log-impl: org.apache.ibatis.logging.stdout.stdoutimpl
  # 多数据源配置（可选）
  datasource:
    master:
      driver-class-name: com.mysql.cj.jdbc.driver
      url: jdbc:mysql://localhost:3306/master_db
      username: root
      password: 123456
    slave:
      driver-class-name: com.mysql.cj.jdbc.driver
      url: jdbc:mysql://localhost:3306/slave_db
      username: root
      password: 123456

步骤3：创建实体类

package com.example.demo.entity;

import com.mybatisflex.annotation.id;
import com.mybatisflex.annotation.keytype;
import com.mybatisflex.annotation.table;
import lombok.data;
import lombok.experimental.accessors;

import java.time.localdatetime;

@data
@accessors(chain = true)
@table("tb_user")  // 指定表名
public class user {
    
    @id(keytype = keytype.auto)  // 主键，自动增长
    private long id;
    
    private string username;
    
    private string email;
    
    private integer age;
    
    private integer status;
    
    private localdatetime createtime;
    
    private localdatetime updatetime;
    
    // 逻辑删除注解
    @com.mybatisflex.annotation.column(islogicdelete = true)
    private boolean deleted;
}

步骤4：创建 mapper 接口

package com.example.demo.mapper;

import com.mybatisflex.core.basemapper;
import com.example.demo.entity.user;
import org.apache.ibatis.annotations.mapper;

@mapper
public interface usermapper extends basemapper<user> {
    // 可以在此定义自定义的查询方法
    // 复杂的查询建议使用 querywrapper 或 db + row
    
    /**
     * 自定义查询方法示例
     */
    user selectbyusername(string username);
}

对应的 xml 映射文件（如果需要）：

<!-- src/main/resources/mapper/usermapper.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="com.example.demo.mapper.usermapper">
    
    <select id="selectbyusername" resulttype="com.example.demo.entity.user">
        select * from tb_user where username = #{username}
    </select>
    
</mapper>

步骤5：创建 service 层

package com.example.demo.service;

import com.mybatisflex.core.query.querywrapper;
import com.mybatisflex.core.service.iservice;
import com.example.demo.entity.user;

public interface userservice extends iservice<user> {
    
    user getbyusername(string username);
    
    boolean updateemailbyid(long id, string email);
}

package com.example.demo.service.impl;

import com.mybatisflex.core.query.querywrapper;
import com.mybatisflex.core.service.impl.serviceimpl;
import com.example.demo.entity.user;
import com.example.demo.mapper.usermapper;
import com.example.demo.service.userservice;
import org.springframework.stereotype.service;

@service
public class userserviceimpl extends serviceimpl<usermapper, user> implements userservice {
    
    @override
    public user getbyusername(string username) {
        querywrapper querywrapper = querywrapper.create()
                .select()
                .from(user.class)
                .where(user::getusername).eq(username);
        return mapper.selectonebyquery(querywrapper);
    }
    
    @override
    public boolean updateemailbyid(long id, string email) {
        user user = new user();
        user.setid(id);
        user.setemail(email);
        return this.updatebyid(user);
    }
}

步骤6：创建 controller

package com.example.demo.controller;

import com.mybatisflex.core.paginate.page;
import com.mybatisflex.core.query.querywrapper;
import com.example.demo.entity.user;
import com.example.demo.service.userservice;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.*;

import java.util.list;

@restcontroller
@requestmapping("/api/users")
public class usercontroller {
    
    @autowired
    private userservice userservice;
    
    /**
     * 根据id查询用户
     */
    @getmapping("/{id}")
    public user getbyid(@pathvariable long id) {
        return userservice.getbyid(id);
    }
    
    /**
     * 分页查询用户
     */
    @getmapping("/page")
    public page<user> page(@requestparam(defaultvalue = "1") int pagenumber,
                           @requestparam(defaultvalue = "10") int pagesize) {
        querywrapper querywrapper = querywrapper.create()
                .select()
                .from(user.class)
                .where(user::getage).ge(18)
                .orderby(user::getcreatetime, false);
        
        return userservice.page(new page<>(pagenumber, pagesize), querywrapper);
    }
    
    /**
     * 条件查询
     */
    @getmapping("/list")
    public list<user> list(@requestparam(required = false) string username,
                           @requestparam(required = false) integer minage) {
        querywrapper querywrapper = querywrapper.create()
                .select()
                .from(user.class);
        
        if (username != null) {
            querywrapper.and(user::getusername).like(username);
        }
        
        if (minage != null) {
            querywrapper.and(user::getage).ge(minage);
        }
        
        return userservice.list(querywrapper);
    }
    
    /**
     * 新增用户
     */
    @postmapping
    public boolean save(@requestbody user user) {
        return userservice.save(user);
    }
    
    /**
     * 更新用户
     */
    @putmapping("/{id}")
    public boolean update(@pathvariable long id, @requestbody user user) {
        user.setid(id);
        return userservice.updatebyid(user);
    }
    
    /**
     * 删除用户
     */
    @deletemapping("/{id}")
    public boolean delete(@pathvariable long id) {
        return userservice.removebyid(id);
    }
}

步骤7：使用代码生成器（可选）

package com.example.demo;

import com.mybatisflex.codegen.generator;
import com.mybatisflex.codegen.config.globalconfig;
import com.zaxxer.hikari.hikaridatasource;

public class codegenerator {
    
    public static void main(string[] args) {
        // 配置数据源
        hikaridatasource datasource = new hikaridatasource();
        datasource.setjdbcurl("jdbc:mysql://localhost:3306/mybatis_flex_db");
        datasource.setusername("root");
        datasource.setpassword("123456");
        
        // 创建配置内容
        globalconfig globalconfig = new globalconfig();
        
        // 设置根包
        globalconfig.setbasepackage("com.example.demo");
        
        // 设置表前缀和只生成哪些表
        globalconfig.settableprefix("tb_");
        globalconfig.setgeneratetable("tb_user", "tb_order", "tb_product");
        
        // 设置生成实体类的路径
        globalconfig.setentitysourcedir("src/main/java/com/example/demo/entity");
        
        // 设置生成mapper类的路径
        globalconfig.setmappersourcedir("src/main/java/com/example/demo/mapper");
        
        // 设置生成service类的路径
        globalconfig.setservicesourcedir("src/main/java/com/example/demo/service");
        
        // 设置生成serviceimpl类的路径
        globalconfig.setserviceimplsourcedir("src/main/java/com/example/demo/service/impl");
        
        // 设置生成controller类的路径
        globalconfig.setcontrollersourcedir("src/main/java/com/example/demo/controller");
        
        // 通过 datasource 和 globalconfig 创建代码生成器
        generator generator = new generator(datasource, globalconfig);
        
        // 生成代码
        generator.generate();
    }
}

步骤8：高级查询示例

package com.example.demo.service.impl;

import com.mybatisflex.core.query.querycolumn;
import com.mybatisflex.core.query.querywrapper;
import com.mybatisflex.core.row.db;
import com.mybatisflex.core.row.row;
import org.springframework.stereotype.service;

import java.util.list;

@service
public class advancedqueryservice {
    
    /**
     * 复杂条件查询示例
     */
    public void complexquery() {
        // 使用 querywrapper 构建复杂查询
        querywrapper querywrapper = querywrapper.create()
                .select(user.id, user.username, user.email)
                .from(user.class)
                .where(user.age.between(18, 60))
                .and(user.status.eq(1))
                .and(user.username.like("张%"))
                .orderby(user.create_time.desc())
                .limit(10);
        
        // 使用 db 执行原生sql
        list<row> rows = db.selectlistbysql(
                "select u.*, o.order_count from tb_user u " +
                "left join (select user_id, count(*) as order_count from tb_order group by user_id) o " +
                "on u.id = o.user_id " +
                "where u.status = ?", 1);
    }
    
    /**
     * 关联查询示例
     */
    public void joinquery() {
        querywrapper query = querywrapper.create()
                .select()
                .from(user.class).as("u")
                .leftjoin("tb_order").as("o").on("u.id = o.user_id")
                .where("u.status = ?", 1);
    }
}

步骤9：事务管理

package com.example.demo.service.impl;

import com.example.demo.entity.user;
import com.example.demo.mapper.usermapper;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
import org.springframework.transaction.annotation.transactional;

@service
public class transactionservice {
    
    @autowired
    private usermapper usermapper;
    
    /**
     * 声明式事务管理
     */
    @transactional(rollbackfor = exception.class)
    public void transactionaloperation(user user1, user user2) {
        // 插入第一个用户
        usermapper.insert(user1);
        
        // 模拟业务逻辑
        if (user1.getage() < 0) {
            throw new runtimeexception("年龄不能为负数");
        }
        
        // 插入第二个用户
        usermapper.insert(user2);
    }
}

三、配置类示例

package com.example.demo.config;

import com.mybatisflex.core.audit.auditmanager;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.context.annotation.configuration;

import javax.annotation.postconstruct;

@configuration
public class mybatisflexconfig {
    
    private static final logger logger = loggerfactory.getlogger(mybatisflexconfig.class);
    
    @postconstruct
    public void init() {
        // 开启审计功能
        auditmanager.setauditenable(true);
        
        // 设置 sql 审计收集器
        auditmanager.setmessagecollector(auditmessage -> {
            logger.info("执行 sql: {}", auditmessage.getfullsql());
            logger.info("执行参数: {}", auditmessage.getqueryparams());
            logger.info("执行耗时: {}ms", auditmessage.getelapsedtime());
        });
    }
}

四、详细总结

1.整合优势

简化开发：mybatis-flex 提供了丰富的 api，大大减少了样板代码
灵活查询：querywrapper 和 lambda 表达式让查询条件构建更加灵活
性能优越：框架经过优化，执行效率高
易于扩展：良好的扩展性，可以方便地添加自定义功能

2.使用建议

简单crud：直接使用 basemapper 和 iservice 提供的基础方法
复杂查询：优先使用 querywrapper，复杂的关联查询可使用原生 sql
分页查询：使用内置的 page 类，支持多种数据库的分页语法
事务管理：使用 spring 的 @transactional 注解管理事务

3.注意事项

实体类需要正确使用注解标记主键、表名等
多数据源配置时注意事务管理器的配置
逻辑删除字段需要在配置中指定
生产环境建议关闭 sql 日志输出

4.最佳实践

使用代码生成器提高开发效率
复杂业务逻辑在 service 层处理
合理使用缓存提升性能
定期监控 sql 执行效率

5.常见问题解决

问题1：字段名与数据库列名映射不正确

解决：检查 @column 注解或配置 map-underscore-to-camel-case

问题2：分页查询异常

解决：检查数据库方言配置，确保使用正确的分页语法

问题3：事务不回滚

解决：确保 @transactional 注解正确使用，异常被正确捕获

mybatis-flex 作为一个现代化的 mybatis 增强框架，在保持 mybatis 灵活性的同时，提供了更多便捷的功能，特别适合需要复杂查询和高性能要求的项目。通过合理的配置和使用，可以大大提高开发效率和系统性能。

到此这篇关于springboot整合mybatis-flex的保姆级教程的文章就介绍到这了,更多相关springboot整合mybatis-flex内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

SpringBoot整合MyBatis-Flex的保姆级教程

2026年01月18日 • Java •我要评论