mybatis-flex探索

最新推荐文章于 2024-05-25 11:15:47 发布
最新推荐文章于 2024-05-25 11:15:47 发布
阅读量1k 收藏 2
点赞数
分类专栏： Springboot 3.x 文章标签： mybatis java mybatis-flex openapi3 knife4j
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14926283/article/details/132191179
版权

mybatis古今未来

最近无意之中发现了一个非常棒的持久层框架mybatis-flex，迫不及待研究了一下

发现简直就是我的梦中情框，之前写ibatis，后来写mybatis，接着写mybatis-plus，接着研究mybatis-flex

ibatis

    ibatis是apache开源的，当时是一款轻量级的数据据持久层的半自动式开发框架

   它简化直接用jdbc开发的60%以上的代码量，并且支持将sql写入xml中，使结构变得非常清晰，而且能灵活配置，从此进入了ibatis的时代，受到当时大量的开发人员的喜爱

优点：

  1. 简化了直接使用jdbc产生的大量代码
  2. 定义xml映射器，将sql语句与java代码分离，维护更轻松
  3. 查询能将结果集反映射到java对象中
  4. 提供了事物管理和连接池管理
  5. 。。。。

缺点：

  1. 结果集封装单一，不够灵活
  2. 增删改查，入参有限制，只有一个
  3. 配置关系太多
  4. 不够优化，大量的单表操作仍旧需要手动写增删改查等sql
  5. 复杂查询逻辑会出现嵌套查询 n+1的情况，造成资源抢占，拥护，卡顿
  6. 。。。。

mybatis：

   它就是千锤百炼锻造出来的，它的前身就是ibatis

优点：

  1. 前身是ibatis，所以它有ibatis的一切优点
  2. 借助jdk的泛型和注解特性进一步做了简化
  3. 实现了接口绑定，自动生成接口的具体实现，简化了ibatis在dao与xml的映射关系需要指定的操作
  4. 对象关系映射改进，效率更高
  5. 性能高：提供了缓存机制提高性能，存储过程等
  6. 。。。。

缺点

  1. sql编写工作量较大，大量的单表操作仍旧需要写常规的sql语句
  2. 配置关系仍旧太多
  3. 复杂的查询操作需要自己编写sql语句
  4. 缓存使用不当，容易产生脏数据
  5. 。。。

mybatis-plus

   它是mybatis的增强工具，在mybatis的基础上只做增强不做改变

优点：

  1. 它只是增强mybatis，所以mybatis一切优点它全都继承了过来
  2. 依赖少，仅仅依赖 Mybatis 以及 Mybatis-Spring 。
  3. 预防sql注入，内置sql注入剥离器，可以很好的防止sql注入
  4. 内置多种主键策略
  5. 单表增删改查等业务可以不用写sql
  6. 强大的条件构造器可以满足各种使用需求
  7. 支持Lambda形式调用
  8. 。。。。

缺点：

  1. 分页查询无sql解析设计
  2. 不支持多表查询
  3. 不支持多主键，复合主键
  4. 。。。。

MyBatis-Flex

它也是在mybatis上做了增强

  1. 拥有mybatis所有的优点
  2. 仅依赖mybatis，体积更小更轻量
  3. 支持多表查询
  4. 支持多主键，复合主键
  5. 。。。。。

我的要求：

  1. 不用写重复性单表增删改查的业务，
  2. 能支持分页查询
  3. 支持多表查询
  4. 支持rpc远程调用

mybatis-flex满足了我所有的要求，所以我觉得自己很有必要去了解一下

例子截图

 

代码部分

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zxs</groupId>
    <artifactId>springboot-mybatis-flex</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-mybatis-flex</name>
    <description>springboot-mybatis-flex</description>
    <properties>
        <java.version>17</java.version>
        <mybatis-flex.version>1.5.6</mybatis-flex.version>
        <fastjson.version>1.2.47</fastjson.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.github.xiaoymin</groupId>
                <artifactId>knife4j-dependencies</artifactId>
                <version>4.1.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mybatis-flex</groupId>
            <artifactId>mybatis-flex-spring-boot-starter</artifactId>
            <version>${mybatis-flex.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test
    username: root
    password: zkb.com
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      maximum-pool-size: 100
      minimum-idle: 10
      pool-name: HikaraPool-1
springdoc:
  swagger-ui:
    path: /swagger-ui.html
    tags-sorter: alpha
  api-docs:
    path: /v3/api-docs
  group-configs:
    - group: '查询接口'
      paths-to-match: '/**'
      packages-to-scan: com.zxs.springbootmybatisflex.controller.sys
    - group: '增删改接口'
      paths-to-match: '/**'
      packages-to-scan: com.zxs.springbootmybatisflex.controller.client
  default-flat-param-object: true

knife4j:
  enable: true

package com.zxs.springbootmybatisflex.config;

import com.github.xiaoymin.knife4j.spring.annotations.EnableKnife4j;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableKnife4j
public class SwaggerConfig {
    // 设置 openapi 基础参数
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
                .info(new Info()
                        .title("zxs API 管理")
                        .version("1.0")
                        .description("探索mybatis-flex demo")
                        .license(new License().name("Apache 2.0")));
    }
}

package com.zxs.springbootmybatisflex.controller.client;

import com.mybatisflex.core.query.QueryCondition;
import com.mybatisflex.core.query.QueryWrapper;
import com.zxs.springbootmybatisflex.entity.User;
import com.zxs.springbootmybatisflex.service.UserService;
import com.zxs.springbootmybatisflex.uitl.DataResult;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import static com.zxs.springbootmybatisflex.entity.table.UserTableDef.USER;

@RestController
@Tag(name="用户增删改")
@RequestMapping("/suser")
public class SuserController {
    @Autowired
    UserService userService;



    @Operation(summary = "根据id删除用户",description = "方式一")
    @GetMapping("/deleteUser/{id}")
    public DataResult<User> deleteUser(@PathVariable(value = "id") Long id){
        DataResult<User> result = DataResult.success();
        userService.deleteUser(id);
        return result;
    }

    @Operation(summary = "根据id删除用户",description = "方式二")
    @GetMapping("/deleteUser2/{id}")
    public DataResult<User> deleteUser2(@PathVariable(value = "id") Long id){
        DataResult<User> result = DataResult.success();
        userService.removeById(id);
        return result;
    }

    @Operation(summary = "根据id删除用户",description = "方式三")
    @GetMapping("/deleteUser3/{id}")
    public DataResult<User> deleteUser3(@PathVariable(value = "id") Long id){
        DataResult<User> result = DataResult.success();
        userService.deleteUser3(id);
        return result;
    }

    @Operation(summary = "根据id删除用户",description = "方式四")
    @GetMapping("/deleteUser4/{id}")
    public DataResult<User> deleteUser4(@PathVariable(value = "id") Long id){
        DataResult<User> result = DataResult.success();
        QueryCondition queryCondition =USER.ID.eq(id);
        userService.remove(queryCondition);
        return result;
    }

    @Operation(summary = "增加用户",description = "方式一")
    @PostMapping("/addUser1")
    public DataResult<User> addUser1(@RequestBody User user){
        DataResult<User> result = DataResult.success();
        userService.save(user);
        return result;
    }

    @Operation(summary = "修改用户",description = "方式一")
    @PostMapping("/updateUser1")
    public DataResult<User> updateUser1(@RequestBody User user){
        DataResult<User> result = DataResult.success();
        QueryWrapper queryWrapper = QueryWrapper.create().
                where(USER.USERNAME.eq(user.getUsername())).
                and(USER.PASSWORD.eq(user.getPassword()));
        userService.update(user,queryWrapper);
        return result;
    }

    @Operation(summary = "修改用户",description = "方式二")
    @PostMapping("/updateUser2")
    public DataResult<User> updateUser2(@RequestBody User user){
        DataResult<User> result = DataResult.success();
        QueryWrapper queryWrapper = QueryWrapper.create().
                where(USER.USERNAME.eq(user.getUsername())).
                and(USER.PASSWORD.eq(user.getPassword()));
        userService.update(user,queryWrapper);
        return result;
    }

}

package com.zxs.springbootmybatisflex.controller.sys;

import com.zxs.springbootmybatisflex.entity.User;
import com.zxs.springbootmybatisflex.service.UserService;
import com.zxs.springbootmybatisflex.uitl.DataResult;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@Tag(name="用户查询")
@RequestMapping("/user")
public class UserController {
    @Autowired
    UserService userService;

    @Operation(summary = "获取全部用户",description="获取全部用户")
    @GetMapping("/selectUsers")
    public DataResult<List<User>> selectUsers(){
        DataResult<List<User>> result = DataResult.success();
        List<User> list = userService.list();
        result.setData(list);
        return result;
    }

    @Operation(summary = "根据id获取用户",description = "方式一")
    @GetMapping("/selectUser/{id}")
    public DataResult<User> selectUser(@PathVariable(value = "id") Long id){
        DataResult<User> result = DataResult.success();
        User user = userService.selectUserById(id);
        result.setData(user);
        return result;
    }

    @Operation(summary = "根据id获取用户",description = "方式二")
    @GetMapping("/selectUser2/{id}")
    public DataResult<User> selectUser2(@PathVariable(value = "id") Long id){
        DataResult<User> result = DataResult.success();
        User user = userService.getById(id);
        result.setData(user);
        return result;
    }

    @Operation(summary = "根据id获取用户",description = "方式三")
    @GetMapping("/selectUser3/{id}")
    public DataResult<User> selectUser3(@PathVariable(value = "id") Long id){
        DataResult<User> result = DataResult.success();
        User user = userService.selectUserById2(id);
        result.setData(user);
        return result;
    }
}

package com.zxs.springbootmybatisflex.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.mybatisflex.annotation.Column;
import com.mybatisflex.annotation.Id;
import com.mybatisflex.annotation.KeyType;
import com.mybatisflex.annotation.Table;
//import io.swagger.annotations.ApiModel;
//import io.swagger.annotations.ApiModelProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.util.Date;


@Data
@EqualsAndHashCode(callSuper = false)
@Tag(name = "用户", description = "用户实体类")
@Table("user")
public class User{

    @Schema(description="用户id")
    @JsonSerialize(using = ToStringSerializer.class)
    @Id(keyType = KeyType.Auto)
    private Long id;

    /**
     * 用户名
     */
    @Schema(description="用户名")
    private String username;
    /**
     * 密码
     */
    @Schema(description="密码")
    private String password;
    /**
     * 名称
     */
    @Schema(description="名称")
    private String name;

    /**
     * 邮箱
     */
    @Schema(description="邮箱")
    private String email;
    /**
     * 联系方式
     */
    @Schema(description="手机号")
    private String phone;

    /**
     * 用户状态：1有效; 2删除
     */
    @Schema(description="状态")
    private Integer status;
    /**
     * 创建时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @Column("createTime")
    private Date createTime;
    /**
     * 用户类型
     */
    @Schema(description="登录次数")
    private Integer logins;


}

package com.zxs.springbootmybatisflex.exception.code;


public enum BaseResponseCode implements ResponseCodeInterface {
    /**
     * 这个要和前段约定好
     * 引导用户去登录界面的
     * code=401001 引导用户重新登录
     * code=401002 token 过期刷新token
     * code=401008 无权限访问
     */
    SUCCESS(200,"操作成功"),
    SYSTEM_BUSY(500001, "系统繁忙，请稍候再试"),
    OPERATION_ERRO(500002,"操作失败"),
    METHODARGUMENTNOTVALIDEXCEPTION(500003, "方法参数校验异常"),
    ;

    /**
     * 错误码
     */
    private final int code;
    /**
     * 错误消息
     */
    private final String msg;

    BaseResponseCode(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    @Override
    public int getCode() {
        return code;
    }

    @Override
    public String getMsg() {
        return msg;
    }
}

package com.zxs.springbootmybatisflex.exception.code;


public interface ResponseCodeInterface {
    int getCode();

    String getMsg();
}

package com.zxs.springbootmybatisflex.exception.handler;


import com.zxs.springbootmybatisflex.exception.BusinessException;
import com.zxs.springbootmybatisflex.exception.code.BaseResponseCode;
import com.zxs.springbootmybatisflex.uitl.DataResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.List;


@RestControllerAdvice
@Slf4j
public class RestExceptionHandler {


    @ExceptionHandler(Exception.class)
    public <T> DataResult<T> handleException(Exception e){
        log.error("Exception,exception:{}", e);
        return DataResult.getResult(BaseResponseCode.SYSTEM_BUSY);
    }


    @ExceptionHandler(value = BusinessException.class)
    <T> DataResult<T> businessExceptionHandler(BusinessException e) {
        log.error("BusinessException,exception:{}", e);
        return new DataResult<>(e.getMessageCode(),e.getDetailMessage());
    }


    @ExceptionHandler(MethodArgumentNotValidException.class)
    <T> DataResult<T> methodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e) {
        log.error("methodArgumentNotValidExceptionHandler bindingResult.allErrors():{},exception:{}", e.getBindingResult().getAllErrors(), e);
        List<ObjectError> errors = e.getBindingResult().getAllErrors();
        return createValidExceptionResp(errors);
    }
    private <T> DataResult<T> createValidExceptionResp(List<ObjectError> errors) {
        String[] msgs = new String[errors.size()];
        int i = 0;
        for (ObjectError error : errors) {
            msgs[i] = error.getDefaultMessage();
            log.info("msg={}",msgs[i]);
            i++;
        }
        return DataResult.getResult(BaseResponseCode.METHODARGUMENTNOTVALIDEXCEPTION.getCode(), msgs[0]);
    }
}

package com.zxs.springbootmybatisflex.exception;


import com.zxs.springbootmybatisflex.exception.code.ResponseCodeInterface;

public class BusinessException extends RuntimeException{
    /**
     * 异常编号
     */
    private final int messageCode;

    /**
     * 对messageCode 异常信息进行补充说明
     */
    private final String detailMessage;

    public BusinessException(int messageCode,String message) {
        super(message);
        this.messageCode = messageCode;
        this.detailMessage = message;
    }
    /**
     * 构造函数
     * @param code 异常码
     */
    public BusinessException(ResponseCodeInterface code) {
        this(code.getCode(), code.getMsg());
    }

    public int getMessageCode() {
        return messageCode;
    }

    public String getDetailMessage() {
        return detailMessage;
    }
}

package com.zxs.springbootmybatisflex.exception;


import com.zxs.springbootmybatisflex.exception.code.ResponseCodeInterface;

public class RoleSaveException extends RuntimeException{
    /**
     * 异常编号
     */
    private final int messageCode;

    /**
     * 对messageCode 异常信息进行补充说明
     */
    private final String detailMessage;

    public RoleSaveException(int messageCode, String message) {
        super(message);
        this.messageCode = messageCode;
        this.detailMessage = message;
    }
    /**
     * 构造函数
     * @param code 异常码
     */
    public RoleSaveException(ResponseCodeInterface code) {
        this(code.getCode(), code.getMsg());
    }

    public int getMessageCode() {
        return messageCode;
    }

    public String getDetailMessage() {
        return detailMessage;
    }
}

package com.zxs.springbootmybatisflex.mapper;

import com.mybatisflex.core.BaseMapper;
import com.zxs.springbootmybatisflex.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

package com.zxs.springbootmybatisflex.service.impl;

import com.mybatisflex.core.query.QueryWrapper;
import com.mybatisflex.spring.service.impl.ServiceImpl;
import com.zxs.springbootmybatisflex.entity.User;
import com.zxs.springbootmybatisflex.mapper.UserMapper;
import com.zxs.springbootmybatisflex.service.UserService;
import org.springframework.stereotype.Service;

import static com.zxs.springbootmybatisflex.entity.table.UserTableDef.USER;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Override
    public User selectUserById(Long id) {
        return getById(id);
    }

    @Override
    public User selectUserById2(Long id) {
        QueryWrapper queryWrapper = QueryWrapper.create().where(USER.ID.eq(id));
        return getOne(queryWrapper);
    }

    @Override
    public void deleteUser(Long id) {
        removeById(id);
    }

    @Override
    public void deleteUser3(Long id) {
        QueryWrapper queryWrapper = QueryWrapper.create().where(USER.ID.eq(id));
        remove(queryWrapper);
    }
}

package com.zxs.springbootmybatisflex.service;

import com.mybatisflex.core.service.IService;
import com.zxs.springbootmybatisflex.entity.User;

public interface UserService extends IService<User> {

    User selectUserById(Long id);

    User selectUserById2(Long id);

    void deleteUser(Long id);

    void deleteUser3(Long id);
}

package com.zxs.springbootmybatisflex.uitl;

import com.zxs.springbootmybatisflex.exception.code.BaseResponseCode;
import com.zxs.springbootmybatisflex.exception.code.ResponseCodeInterface;
import lombok.Data;


@Data
public class DataResult<T>{

    /**
     * 请求响应code，0为成功 其他为失败
     */
    private int code;

    /**
     * 响应异常码详细信息
     */
    private String msg;

    /**
     * 响应内容 ， code 0 时为 返回 数据
     */
    private T data;

    public DataResult(int code, T data) {
        this.code = code;
        this.data = data;
        this.msg=null;
    }

    public DataResult(int code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    public DataResult(int code, String msg) {
        this.code = code;
        this.msg = msg;
        this.data=null;
    }


    public DataResult() {
        this.code= BaseResponseCode.SUCCESS.getCode();
        this.msg=BaseResponseCode.SUCCESS.getMsg();
        this.data=null;
    }

    public DataResult(T data) {
        this.data = data;
        this.code=BaseResponseCode.SUCCESS.getCode();
        this.msg=BaseResponseCode.SUCCESS.getMsg();
    }

    public DataResult(ResponseCodeInterface responseCodeInterface) {
        this.data = null;
        this.code = responseCodeInterface.getCode();
        this.msg = responseCodeInterface.getMsg();
    }

    public DataResult(ResponseCodeInterface responseCodeInterface, T data) {
        this.data = data;
        this.code = responseCodeInterface.getCode();
        this.msg = responseCodeInterface.getMsg();
    }

    public static <T>DataResult success(){
        return new <T>DataResult();
    }

    public static <T>DataResult success(T data){
        return new <T>DataResult(data);
    }

    public static <T>DataResult getResult(int code,String msg,T data){
        return new <T>DataResult(code,msg,data);
    }

    public static <T>DataResult getResult(int code,String msg){
        return new <T>DataResult(code,msg);
    }

    public static <T>DataResult getResult(BaseResponseCode responseCode){
        return new <T>DataResult(responseCode);
    }

    public static <T>DataResult getResult(BaseResponseCode responseCode,T data){

        return new <T>DataResult(responseCode,data);
    }
}

package com.zxs.springbootmybatisflex;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.zxs.springbootmybatisflex.mapper")
public class SpringbootMybatisFlexApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisFlexApplication.class, args);
    }

}

 

斗码士
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis-Flex快速入门教程
猿小白的博客
04-28 5617
与此同时，Mybatis-Flex 内置的 QueryWrapper^灵活 可以轻易的帮助我们实现 多表查询、链接查询、子查询 等等常见的 SQL 场景。这带来了几个好处：1、极高的性能；我们可以轻松的使用 Mybaits-Flex 链接任何数据库，其内置的 QueryWrapper^亮点 帮助我们极大的减少了 SQL 编写的工作的同时，减少出错的可能性。：支持任意关系型数据库，还可以通过方言持续扩展，同时支持 多（复合）主键、逻辑删除、乐观锁配置、数据脱敏、数据审计、 数据填充 等等功能。
spring+mybatis+flex4框架组合，适合初学者
10-24
spring+mybatis+flex4框架组合，适合初学者
Mybatis增强版MyBatis-Flex简介
qq_22744093的博客
07-28 4654
Mybatis增强版：Mybatis-Plus(使用的最多，老牌Mybatis增强框架，2016年开源)、Fluent-MyBatis(阿里云开发的Mybatis增强框架，来自阿里云.云效产品团队)、Mybatis-Flex。总的来说，Mybatis-Flex相对于Mybatis-Plus较为显著的特点是，多了联表查询和在Mybatis-plus中收费的Mybatis-Flex免费使用。联表查询在日常开发中使用的比较多，Mybatis-Flex支持这个，还是很不错的。
Mybatis-Flex：Mybatis-plus的增强版(使用与了解)
最新发布
WXY888888888的博客
05-25 1171
Mybatis-Flex是Mybatis的增强版，它在保留Mybatis原有的优秀特性的基础上，进行了一些改进和扩展，以提供更加灵活和强大的功能。下面将详细介绍Mybatis-Flex的主要特点和优势，以及如何将其集成到现有项目中。Account(id=1, userName=张三, age=18, birthday=Sat Jan 11 00:00:00 CST 2020)： 如果您当前使用的是 SpringBoot v3.x 版本，需要把依赖。一、Mybatis-Flex的主要特点。
【Java开发】 Mybatis-Flex 01：快速入门
尹煜的博客
07-29 3294
是一个优雅的MyBatis增强框架，它非常轻量、同时拥有极高的性能与灵活性。📌特征轻量：除了 MyBatis，没有任何第三方依赖、没有任何拦截器，在执行的过程中，没有任何的 Sql 解析（Parse）。这带来了几个好处：极高的性能、极易对代码进行跟踪和调试、把控性更高。灵活：支持 Entity 的增删改查、以及分页查询的同时，MyBatis-Flex 提供了 Db + Row 工具，可以无需实体类对数据库进行增删改查以及分页查询。
MyBatis-Flex学习手册
快乐江小鱼的博客
09-24 3165
MyBatis-Flex简介 MyBatis-Flex是什么 MyBatis-Flex是一个优雅的MyBatis增强框架，它非常轻量、同时拥有极高的性能与灵活性。我们可以使用MyBatis-Flex链接任何数据库，其内置的QueryWrapper帮助我们极大的减少了SQL编写的工作的同时，减少出错的可能性。 特征 1、轻量 除了MyBatis，没有任何第三方依赖、没有任何拦截器，其原理是通过SqlProvider的方式实现的。同时，在执行的过程中，没有任何的Sql解析（Parse）。这带来的几个好处：高
mybatis-flex-1.6.2.zip
09-01
mybatis-flex-1.6.2.zip源码： 更轻量 MyBatis-Flex 除了 MyBatis 本身，再无任何第三方依赖，因此会带来更高的自主性、把控性和稳定性。在任何一个系统中，依赖越多，稳定性越差。 更灵活 MyBatis-Flex 提供了...
mybatis-flex-main.zip
03-22
Mybatis-Flex 是一款针对 Mybatis 框架的增强工具，旨在提供更加灵活和高效的数据访问体验。这款框架的设计理念是保持 Mybatis 的简洁性，同时增加一些实用功能，以提升开发效率和代码可维护性。下面我们将深入探讨 ...
这是一款高度自定义代码生成idea插件，目前提供的 模板是依托于mybatis-flex 代码提示、自动APT，SQL预览等特性
12-16
《基于Mybatis-Flex的IDEA插件：代码生成与高效开发》 在现代软件开发过程中，提升开发效率是至关重要的。IDEA作为一款强大的Java集成开发环境，提供了丰富的插件来扩展其功能，其中“高度自定义代码生成idea插件”...
Mybatis-Flex 一个优雅的 Mybatis 增强框架
04-16
Mybatis-Flex 是一个针对 Mybatis 的增强框架，它的设计目标是使 Mybatis 更加灵活、易用且功能更加强大。Mybatis 是一个广泛使用的轻量级 Java 持久层框架，它允许开发者通过 SQL 映射文件将 SQL 语句与 Java 代码...
MyBatis-Plus 的官方示例(mybatis-plus-samples-master.zip)
05-05
本工程为 MyBatis-Plus 的官方示例，项目结构如下： mybatis-plus-sample-quickstart: 快速开始示例 mybatis-plus-sample-quickstart-springmvc: 快速开始示例（Spring MVC版本） mybatis-plus-sample-reduce-...
Mybatis-Flex
yuechuzhixing的博客
07-27 1574
Mybatis-Flex 是一个优雅的 Mybatis 增强框架，它非常轻量、同时拥有极高的性能与灵活性。我们可以轻松的使用 Mybaits-Flex 链接任何数据库，其内置的 QueryWrapper^亮点 帮助我们极大的减少了 SQL 编写的工作的同时，减少出错的可能性。总而言之，MyBatis-Flex 能够极大地提高我们的开发效率和开发体验，让我们有更多的时间专注于自己的事情。官网文档：https://mybatis-flex.com/
MyBatis-Flex、MyBatis-Plus与Fluent-Mybatis三者的比较
热门推荐
纸上得来终觉浅，绝知此事要躬行
04-10 1万+
MyBatis-Flex、MyBatis-Plus与Fluent-Mybatis三者都是对mybatis的扩展，但这三者中目前最优秀的可能是MyBatis-Flex。
SQL 审计 Mybatis-Flex
ejinxian的专栏
03-30 1336
Mybatis-Flex 是一个优雅的 Mybatis 增强框架，它非常轻量、同时拥有极高的性能与灵活性。我们可以轻松的使用 Mybaits-Flex 链接任何数据库，其内置的 QueryWrapper^ 亮点 帮助我们极大的减少了 SQL 编写的工作的同时，减少出错的可能性。 Mybatis-Flex v1.0.5 主要是添加了功能强大的 SQL 审计 功能。SQL 审计是一项非常重要的工作，是企业数据安全体系的重要组成部分，通过 SQL 审计功能为数据库请求进行全程记录，为事后追溯溯源提
MyBatis-Flex学习总结
我的青春一去不复返
03-06 1925
myabtis-flex学习
SpringBoot中MyBatis-Flex的集成和使用
小筱在线博客
12-07 2244
MyBatis-Flex是一个基于MyBatis的数据访问框架，专门为Flex应用程序而设计的。它提供了一种灵活而高效的方式来处理Flex应用程序中的数据访问，可以轻松地连接到各种数据源，并提供了一些方便的工具和功能，包括对象关系映射（ORM）、动态查询、分页、事务处理等等。它的主要目的是简化数据访问的过程，使得开发人员可以更加专注于业务逻辑的开发，而不是一些琐碎的数据访问细节。
Mybatis——强力工具
weixin_45483328的博客
03-14 4051
1.动态SQL 2.Mybatis缓存机制 3.逆向工程 4.分页插件
【Java开发】 Springboot集成Mybatis-Flex
askuld的博客
11-22 1936
MyBatis-Flex 是一个优雅的 MyBatis 增强框架，它非常轻量、同时拥有极高的性能与灵活性。📌 特征1.：除了 MyBatis，没有任何第三方依赖、没有任何拦截器，在执行的过程中，没有任何的 Sql 解析（Parse）。这带来了几个好处：极高的性能、极易对代码进行跟踪和调试、把控性更高。2.：支持 Entity 的增删改查、以及分页查询的同时，MyBatis-Flex 提供了 Db + Row 工具，可以无需实体类对数据库进行增删改查以及分页查询。
mybatis-flex对比mybatis
11-27
Mybatis-Flex是一个用于增强MyBatis的框架，相对于MyBatis-Plus，Mybatis-Flex提供了一些显著的特点，如支持联表查询以及在Mybatis-Plus中收费的功能在Mybatis-Flex中是免费的。Mybatis-Flex的主要特点包括： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

斗码士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值