mybatis-flex探索

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);
    }

}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/67299.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Markdown和LaTex的学习

Markdown和LaTex的学习

下载Typora Typora(免费版) 轻量级Markdown编辑器 - 哔哩哔哩 (bilibili.com) 部分编辑器需要进入设置 中开启特定的 Markdown 语法&#xff0c;例如 Typora 就需要手动开启 高亮 功能 Typora的使用&#xff1a; Typora中各种使用 - lyluoye - 博客园 (cnblogs.com) 标题 #…
阅读更多...
MyBatisPlus快速入门

MyBatisPlus快速入门

MyBatisPlus概述和快速入门 概述 基础框架 MyBatisSpringSpringMVC 为什么需要学习&#xff1f; MyBatisPlus可以节省我们大量的工作时间&#xff0c;所有的CRUD都可以自动化完成。还有其他框架JPA、tk-mapper。 简介 是什么&#xff1f; Mybatis本来就是简化JDBC操作的…
阅读更多...
redis原理 3：未雨绸缪 —— 持久化

redis原理 3：未雨绸缪 —— 持久化

redis原理 3&#xff1a;未雨绸缪 —— 持久化 Redis 的数据全部在内存里&#xff0c;如果突然宕机&#xff0c;数据就会全部丢失&#xff0c;因此必须有一种机制来保证 Redis 的数据不会因为故障而丢失&#xff0c;这种机制就是 Redis 的持久化机制。 Redis 的持久化机制有两种…
阅读更多...
（三）Node.js - 模块化

（三）Node.js - 模块化

1. Node.js中的模块化 Node.js中根据模块来源不同&#xff0c;将模块分为了3大类&#xff0c;分别是&#xff1a; 内置模块&#xff1a;内置模块由Node.js官方提供的&#xff0c;例如fs、path、http等自定义模块&#xff1a;用户创建的每个.js文件&#xff0c;都是自定义模块…
阅读更多...
企升编辑器word编写插件

企升编辑器word编写插件

面向用户群体招投标人员&#xff0c;用统一的模板来编写标书&#xff0c;并最终合并标书。项目经理&#xff0c;编写项目开发计划书&#xff0c;项目验收文档等。开发人员&#xff0c;编写项目需求规格说明书、设计说明书、技术总结等文档。其他文档编写工作量较多的岗位人员。…
阅读更多...
flowable-ui部署(6.80)

flowable-ui部署(6.80)

前置条件&#xff1a;Apache Tomcat/9.0.78版本及以下 https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.78/bin/apache-tomcat-9.0.78-windows-x64.zip 一、下载资源 https://github.com/flowable/flowable-engine/releases/download/flowable-6.8.0/flowable-6.8.0.zip 二…
阅读更多...
Apoll 多项式规划求解

Apoll 多项式规划求解

一、纵向规划 void QuarticPolynomialCurve1d::ComputeCoefficients(const float x0, const float dx0, const float ddx0, const float dx1,const float ddx1, const float p) {if (p < 0.0) {std::cout << "p should be greater than 0 at line 140." &…
阅读更多...
伦敦金费用有哪几方面？

伦敦金费用有哪几方面？

通常在网上开设伦敦金投资账户是没有成本的&#xff0c;而它交易的费用&#xff0c;主要是由点差和过夜利息&#xff08;仓息&#xff09;构成。如果伦敦金投资者只是做短线的日内交易&#xff0c;做一手完整的100盎司的标准合约&#xff0c;需要支付大约50美元点差费用&#x…
阅读更多...
分支和循环语句（1）（C语言）

分支和循环语句（1）（C语言）

目录 什么是语句&#xff1f; 分支语句&#xff08;选择结构&#xff09; if语句 悬空else if书写形式的对比 switch语句 在switch语句中的 break default子句 循环语句 while循环 while语句中的break和continue for循环 语法 break和continue在for循环中 for语句和…
阅读更多...
fastadmin、vue、react图标库适用于多种框架

fastadmin、vue、react图标库适用于多种框架

在二开fastadmin中&#xff0c;在写vue以及react时&#xff0c;侧边导航栏以及按钮中常常需要很多图标&#xff0c;那么这些图标应该去哪里得到呢&#xff0c;在这里给大家一个链接&#xff0c;这里有丰富的图标库&#xff0c;可以找到自己想要的进行使用。 点击下方链接&…
阅读更多...
AI lightning学习

AI lightning学习

真的是没有mmlab的框架好理解&#xff0c;hook调用没问题&#xff0c;就是代码写的不整洁&#xff0c;hook放的到处都是&#xff0c;而且hook的名字和run的名字也不好对应。 又是捧mmengine的一天 &#x1f603;
阅读更多...
Leetcode-每日一题【剑指 Offer 14- I. 剪绳子】

Leetcode-每日一题【剑指 Offer 14- I. 剪绳子】

题目 给你一根长度为 n 的绳子&#xff0c;请把绳子剪成整数长度的 m 段&#xff08;m、n都是整数&#xff0c;n>1并且m>1&#xff09;&#xff0c;每段绳子的长度记为 k[0],k[1]...k[m-1] 。请问 k[0]*k[1]*...*k[m-1] 可能的最大乘积是多少&#xff1f;例如&#xff0…
阅读更多...
Electron 开发，报handshake failed； returned -1, SSL error code 1,错误

Electron 开发，报handshake failed； returned -1, SSL error code 1,错误

代码说明 在preload.js代码中&#xff0c;暴露参数给渲染线程renderer.js访问&#xff0c; renderer.js 报&#xff1a;ERROR:ssl_client_socket_impl.cc(978)] failed; returned -1, SSL error code 1,错误 问题原因 如题所说&#xff0c;跨进程传递消息&#xff0c;这意味…
阅读更多...
实验笔记之——Android项目的适配

实验笔记之——Android项目的适配

android有一个很烦人的点就是版本之间差距较大&#xff0c;且不兼容&#xff0c;导致不同版本之间代码兼容很容易出问题&#xff0c;一个常见的例子就是几年前自己开发的app&#xff0c;几年后再用竟然配置不了。。。为此&#xff0c;写下本博客记录一下配置旧项目的过程。 …
阅读更多...
vue3报错

vue3报错

这是因为eslint对代码的要求严格导致的&#xff0c;可以在package.json里面删掉"eslint:recommended"&#xff0c;然后重启就可以正常运行了
阅读更多...
三步免费接入 Claude 2.0，支持多账号轮询！

三步免费接入 Claude 2.0，支持多账号轮询！

Claude 2.0 已经发布了一段时间&#xff0c;经过我的非暴力测试&#xff0c;比 ChatGPT 3.5 的能力是要强的&#xff0c;有更强大的上下文 100k&#xff0c;相当于 10 万字的上下文记忆,非常适合处理长文档和大的代码段&#xff0c;虽说有些方面略逊色 ChatGPT 4.0 &#xff0c…
阅读更多...
Scala（第一章Scala入门）

Scala（第一章Scala入门）

文章目录 1.1 概述 1.1.1 为什么学习Scala1.1.2 Scala发展历史1.1.3 Scala和Java关系1.1.4 Scala语言特点 1.2 Scala环境搭建1.3 Scala插件安装1.4 HelloWorld案例 1.4.1 创建IDEA项目工程1.4.2 class和object说明1.4.3 Scala程序反编译 1.5 关联Scala源码1.6官方编程指南 1.1…
阅读更多...
【云原生】Docker 详解（一）：从虚拟机到容器

【云原生】Docker 详解（一）：从虚拟机到容器

Docker 详解&#xff08;一&#xff09;&#xff1a;从虚拟机到容器 1.虚拟化 要解释清楚 Docker&#xff0c;首先要解释清楚 容器&#xff08;Container&#xff09;的概念。要解释容器的话&#xff0c;就需要从操作系统说起。操作系统太底层&#xff0c;细说的话一两本书都说…
阅读更多...
C#实现SqlServer数据库同步

C#实现SqlServer数据库同步

实现效果&#xff1a; 设计思路&#xff1a; 1. 开启数据库及表的cdc&#xff0c;定时查询cdc表数据&#xff0c;封装sql语句(通过执行类型&#xff0c;主键;修改类型的cdc数据只取最后更新的记录)&#xff0c;添加到离线数据表&#xff1b; 2. 线程定时查询离线数据表&#xf…
阅读更多...
IoT 物联网安全事件的持续检测和监控解决方案

IoT 物联网安全事件的持续检测和监控解决方案

对于IoT物联网安全事件的持续检测和监控&#xff0c;可以采用以下解决方案&#xff1a; 设备管理和漏洞修复&#xff1a;确保设备的固件和软件及时更新&#xff0c;并修补已知的漏洞。建立一个设备清单&#xff0c;并定期审查和更新其中的设备。 流量分析和异常检测&#xff1a…
阅读更多...
最新文章

Copyright @ 2022~2023