基于EasyCode定制Mybatisplus全自动单表实现CRUD接口

  • 分页查询
  • ID查询
  • 新增
  • 批量新增
  • 修改
  • 批量删除

注意使用了MybatisPlus的自动填充功能，和insertBatchSomeColumn扩展批量插入功能,分页插件

需要几个增加插件实现类

自动填充

  1. package com.gton.config.autofull;
  3. import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.ibatis.reflection.MetaObject;
  6. import org.springframework.stereotype.Component;
  8. import java.time.LocalDateTime;
  10. /**
  11.  * @description: Mybatis -plus  自动填充
  12.  * @author: GuoTong
  13.  * @createTime: 2021-10-05 18:12
  14.  * @since JDK 1.8 OR 11
  15.  **/
  16. @Slf4j
  17. @Component
  18. public class MyMetaObjectHandler implements MetaObjectHandler {
  20.     @Override
  21.     public void insertFill(MetaObject metaObject) {
  22.         log.info("start insert fill ....");
  23.         // 或者
  24.         this.strictInsertFill(metaObject, "createTime", LocalDateTime::now, LocalDateTime.class); // 起始版本 3.3.3(推荐)
  25.         this.strictInsertFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class); // 起始版本 3.3.3(推荐)
  26.     }
  28.     @Override
  29.     public void updateFill(MetaObject metaObject) {
  30.         log.info("start update fill ....");
  31.         this.strictUpdateFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class); // 起始版本 3.3.3(推荐)
  33.     }
  34. }

分页插件


  2.     /**
  3.      * Description:  新的分页插件
  4.      *
  5.      * @author: GuoTong
  6.      */
  7.     @Bean
  8.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
  9.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  10.         // 向Mybatis过滤器链中添加分页拦截器
  11.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
  12.         // 添加乐观锁插件
  13.         interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
  14.         return interceptor;
  15.     }

自定义扩展批量插入

  1. package com.gton.handler;
  3. import com.baomidou.mybatisplus.annotation.FieldFill;
  4. import com.baomidou.mybatisplus.core.injector.AbstractMethod;
  5. import com.baomidou.mybatisplus.core.injector.DefaultSqlInjector;
  6. import com.baomidou.mybatisplus.core.metadata.TableInfo;
  7. import com.baomidou.mybatisplus.extension.injector.methods.InsertBatchSomeColumn;
  9. import java.util.List;
  11. /**
  12.  * @description: MyBatis-Plus提供的InsertBatchSomeColumn方法
  13.  * @author: GuoTong
  14.  * @createTime: 2022-12-06 16:24
  15.  * @since JDK 1.8 OR 11
  16.  **/
  17. public class EasySqlInjector extends DefaultSqlInjector {
  19.     @Override
  20.     public List<AbstractMethod> getMethodList(Class<?> mapperClass, TableInfo tableInfo) {
  21.         // 注意：此SQL注入器继承了DefaultSqlInjector(默认注入器)，调用了DefaultSqlInjector的getMethodList方法，保留了mybatis-plus的自带方法
  22.         List<AbstractMethod> methodList = super.getMethodList(mapperClass, tableInfo);
  23.         methodList.add(new InsertBatchSomeColumn(i -> i.getFieldFill() != FieldFill.UPDATE));
  24.         return methodList;
  25.     }
  27. }

批量插入插件注入

  1.  /**
  2.      * Description: 批量插入优化
  3.      *
  4.      * @author: GuoTong
  5.      */
  6.     @Bean
  7.     public EasySqlInjector sqlInjector() {
  8.         return new EasySqlInjector();
  9.     }

Controller的目标效果示例：

  1. package com.gton.user.controller;
  3. /**
  4.  * (GpLogin)表控制层
  5.  *
  6.  * @author GT
  7.  * @since 2022-12-06 20:13:00
  8.  */
  9. @RestController
  10. @RequestMapping("gpLogin")
  11. @SwaggerScanClass
  12. public class GpLoginController {
  13.     /**
  14.      * 服务对象
  15.      */
  16.     @Autowired
  17.     private GpLoginService gpLoginService;
  19.     @Autowired
  20.     private OpenFeignToCommodityServer openFeignToCommodityServer;
  22.     /**
  23.      * Description:  openfegin 调用
  24.      *
  25.      * @param request HttpServletRequest
  26.      * @author: GuoTong
  27.      * @date: 2022-12-06 16:52:18
  28.      * @return:com.gton.io.Resp Resp
  29.      */
  30.     @RequestMapping(value = "/list", method = RequestMethod.GET)
  31.     public Resp list(HttpServletRequest request) {
  33.         String id = request.getParameter("id");
  34.         if (StringUtils.isEmpty(id)) {
  35.             id = "1598659338353319937";
  36.         }
  37.         Resp<Object> objectResp = openFeignToCommodityServer.selectOne(id);
  38.         return Resp.Ok(objectResp.getData());
  39.     }
  41.     /**
  42.      * 分页查询数据
  43.      *
  44.      * @param limitRequest 查询实体
  45.      * @return 所有数据
  46.      */
  47.     @PostMapping("/queryLimit")
  48.     public Resp<BaseLimitResponse<GpLogin>> queryPage(@RequestBody BaseLimitRequest<GpLogin> limitRequest) {
  49.         // 分页查询
  50.         IPage<GpLogin> page = this.gpLoginService.queryLimitPage(limitRequest);
  51.         // 封装返回结果集
  52.         BaseLimitResponse<GpLogin> data = BaseLimitResponse.getInstance(page.getRecords(), page.getTotal(), page.getPages(), limitRequest.getPageIndex(), limitRequest.getPageSize());
  53.         return Resp.Ok(data);
  54.     }
  56.     /**
  57.      * 通过主键查询单条数据
  58.      *
  59.      * @param id 主键
  60.      * @return 单条数据
  61.      */
  62.     @GetMapping("/queryOne/{id}")
  63.     public Resp<GpLogin> selectOne(@PathVariable("id") Serializable id) {
  64.         return Resp.Ok(this.gpLoginService.getById(id));
  65.     }
  67.     /**
  68.      * 新增数据
  69.      *
  70.      * @param gpLogin 实体对象
  71.      * @return 新增结果
  72.      */
  73.     @PostMapping("/save")
  74.     public Resp<String> insert(@RequestBody GpLogin gpLogin) {
  75.         boolean save = false;
  76.         String executeMsg = null;
  77.         try {
  78.             save = this.gpLoginService.save(gpLogin);
  79.             executeMsg = "新增成功,id 是：" + gpLogin.getId();
  80.         } catch (Exception e) {
  81.             executeMsg = e.getMessage();
  82.         }
  83.         return save ? Resp.Ok(executeMsg) : Resp.error(executeMsg);
  84.     }
  86.     /**
  87.      * 批量新增数据
  88.      *
  89.      * @param gpLoginList 实体对象
  90.      * @return 新增结果
  91.      */
  92.     @PostMapping("/saveBatch")
  93.     public Resp<String> insertBatch(@RequestBody List<GpLogin> gpLoginList) {
  94.         Integer save = 0;
  95.         String executeMsg = null;
  96.         try {
  97.             save = this.gpLoginService.saveBatchByEasyBaseMapper(gpLoginList);
  98.             executeMsg = "新增成功=>id 是：" + Arrays.toString(gpLoginList.stream().map(GpLogin::getId).toArray());
  99.         } catch (Exception e) {
  100.             executeMsg = e.getMessage();
  101.         }
  102.         return save > 0 ? Resp.Ok(executeMsg) : Resp.error(executeMsg);
  103.     }
  105.     /**
  106.      * 修改数据
  107.      *
  108.      * @param gpLogin 实体对象
  109.      * @return 修改结果
  110.      */
  111.     @PutMapping("/update")
  112.     public Resp<String> update(@RequestBody GpLogin gpLogin) {
  114.         boolean update = false;
  115.         String executeMsg = null;
  116.         try {
  117.             update = this.gpLoginService.updateById(gpLogin);
  118.             executeMsg = "修改成功,id 是：" + gpLogin.getId();
  119.         } catch (Exception e) {
  120.             executeMsg = e.getMessage();
  121.         }
  122.         return update ? Resp.Ok(executeMsg) : Resp.error(executeMsg);
  123.     }
  125.     /**
  126.      * 删除数据
  127.      *
  128.      * @param idList 主键结合
  129.      * @return 删除结果
  130.      */
  131.     @DeleteMapping("/dels")
  132.     public Resp<String> delete(@RequestParam("idList") List<Long> idList) {
  133.         boolean delNumber = false;
  134.         String executeMsg = null;
  135.         try {
  136.             delNumber = this.gpLoginService.removeByIds(idList);
  137.             executeMsg = "删除成功,ids 是：" + idList;
  138.         } catch (Exception e) {
  139.             executeMsg = e.getMessage();
  140.         }
  141.         return delNumber ? Resp.Ok(executeMsg) : Resp.error(executeMsg);
  142.     }
  143. }

实际生成的代码：

首先看看EasyCode的模板

默认的Mybatisplus的模板少一个xml，我这里将其补充完整的

我这里先将模板贴出来：

Controller的模板：

  1. ##导入宏定义
  2. $!{define.vm}
  4. ##设置表后缀（宏定义）
  5. #setTableSuffix("Controller")
  7. ##保存文件（宏定义）
  8. #save("/controller", "Controller.java")
  10. ##包路径（宏定义）
  11. #setPackageSuffix("controller")
  13. ##定义服务名
  14. #set($serviceName = $!tool.append($!tool.firstLowerCase($!tableInfo.name), "Service"))
  16. ##定义实体对象名
  17. #set($entityName = $!tool.firstLowerCase($!tableInfo.name))
  19. import com.baomidou.mybatisplus.core.metadata.IPage;
  20. import com.gton.io.BaseLimitRequest;
  21. import com.gton.io.BaseLimitResponse;
  22. import com.gton.io.Resp;
  23. import $!{tableInfo.savePackageName}.entity.$!tableInfo.name;
  24. import $!{tableInfo.savePackageName}.service.$!{tableInfo.name}Service;
  25. import org.springframework.web.bind.annotation.*;
  26. import com.gton.annotation.SwaggerScanClass;
  27. import org.springframework.beans.factory.annotation.Autowired;
  28. import java.util.Arrays;
  29. import java.io.Serializable;
  30. import java.util.List;
  32. ##表注释（宏定义）
  33. #tableComment("表控制层")
  34. @RestController
  35. @RequestMapping("$!tool.firstLowerCase($!tableInfo.name)")
  36. @SwaggerScanClass
  37. public class $!{tableName}  {
  38.     /**
  39.      * 服务对象
  40.      */
  41.     @Autowired
  42.     private $!{tableInfo.name}Service $!{serviceName};
  44.    /**
  45.      * 分页查询数据
  46.      *
  47.      * @param limitRequest 查询实体
  48.      * @return 所有数据
  49.      */
  50.     @PostMapping("/queryLimit")
  51.      public Resp<BaseLimitResponse<$!tableInfo.name>> queryPage(@RequestBody BaseLimitRequest<$!tableInfo.name> limitRequest) {
  52.         // 分页查询
  53.         IPage<$!tableInfo.name> page = this.$!{serviceName}.queryLimitPage(limitRequest);
  54.         // 封装返回结果集
  55.         BaseLimitResponse<$!tableInfo.name> data = BaseLimitResponse.getInstance(page.getRecords(), page.getTotal(), page.getPages(), limitRequest.getPageIndex(), limitRequest.getPageSize());
  56.         return Resp.Ok(data);
  57.     }
  59.    /**
  60.      * 通过主键查询单条数据
  61.      *
  62.      * @param id 主键
  63.      * @return 单条数据
  64.      */
  65.     @GetMapping("/queryOne/{id}")
  66.     public Resp<$!tableInfo.name> selectOne(@PathVariable("id") Serializable id) {
  67.          return Resp.Ok(this.$!{serviceName}.getById(id));
  68.     }
  70.    /**
  71.      * 新增数据
  72.      *
  73.      * @param $!entityName 实体对象
  74.      * @return 新增结果
  75.      */
  76.     @PostMapping("/save")
  77.     public Resp<String> insert(@RequestBody $!tableInfo.name $!entityName) {
  78.         boolean save = false;
  79.         String executeMsg = null;
  80.         try {
  81.             save = this.$!{serviceName}.save($!entityName);
  82.             executeMsg = "新增成功,id 是：" + $!{entityName}.getId();
  83.         } catch (Exception e) {
  84.             executeMsg = e.getMessage();
  85.         }
  86.         return save ? Resp.Ok(executeMsg) : Resp.error(executeMsg);
  87.     }
  89.      /**
  90.      * 批量新增数据
  91.      *
  92.      * @param $!{entityName}List 实体对象
  93.      * @return 新增结果
  94.      */
  95.     @PostMapping("/saveBatch")
  96.     public Resp<String> insertBatch(@RequestBody List<$!tableInfo.name> $!{entityName}List) {
  97.         Integer save = 0;
  98.         String executeMsg = null;
  99.         try {
  100.             save = this.$!{serviceName}.saveBatchByEasyBaseMapper($!{entityName}List);
  101.             executeMsg = "新增成功=>id 是：" + Arrays.toString($!{entityName}List.stream().map($!{tableInfo.name}::getId).toArray());
  102.         } catch (Exception e) {
  103.             executeMsg = e.getMessage();
  104.         }
  105.         return save > 0 ? Resp.Ok(executeMsg) : Resp.error(executeMsg);
  106.     }
  108.     /**
  109.      * 修改数据
  110.      *
  111.      * @param $!entityName 实体对象
  112.      * @return 修改结果
  113.      */
  114.     @PutMapping("/update")
  115.     public Resp<String> update(@RequestBody $!tableInfo.name $!entityName) {
  117.         boolean update = false;
  118.         String executeMsg = null;
  119.         try {
  120.             update = this.$!{serviceName}.updateById($!entityName);
  121.             executeMsg = "修改成功,id 是：" + $!{entityName}.getId();
  122.         } catch (Exception e) {
  123.             executeMsg = e.getMessage();
  124.         }
  125.         return update ? Resp.Ok(executeMsg) : Resp.error(executeMsg);
  126.     }
  128.     /**
  129.      * 删除数据
  130.      *
  131.      * @param idList 主键结合
  132.      * @return 删除结果
  133.      */
  134.     @DeleteMapping("/dels")
  135.     public Resp<String> delete(@RequestParam("idList") List<Long> idList) {
  136.         boolean delNumber = false;
  137.         String executeMsg = null;
  138.         try {
  139.             delNumber = this.$!{serviceName}.removeByIds(idList);
  140.             executeMsg = "删除成功,ids 是：" + idList;
  141.         } catch (Exception e) {
  142.             executeMsg = e.getMessage();
  143.         }
  144.         return delNumber ? Resp.Ok(executeMsg) : Resp.error(executeMsg);
  145.     }
  146. }

实体类模板

  1. ##导入宏定义
  2. $!{define.vm}
  4. ##保存文件（宏定义）
  5. #save("/entity", ".java")
  7. ##包路径（宏定义）
  8. #setPackageSuffix("entity")
  10. ##自动导入包（全局变量）
  11. $!{autoImport.vm}
  12. import com.baomidou.mybatisplus.annotation.FieldFill;
  13. import com.baomidou.mybatisplus.annotation.IdType;
  14. import com.baomidou.mybatisplus.annotation.TableField;
  15. import com.baomidou.mybatisplus.annotation.TableId;
  16. import com.fasterxml.jackson.annotation.JsonFormat;
  17. import io.swagger.annotations.ApiModel;
  18. import io.swagger.annotations.ApiModelProperty;
  19. import lombok.Data;
  20. import lombok.experimental.Accessors;
  21. import java.io.Serializable;
  22. import java.time.LocalDateTime;
  24. ##表注释（宏定义）
  25. #tableComment("表实体类")
  26. @Data
  27. @Accessors(chain = true)
  28. @ApiModel(value = "$!{tableInfo.name}", description = "EasyCode")
  29. public class $!{tableInfo.name} implements Serializable {
  30.  private static final long serialVersionUID = 1L;
  31. #foreach($column in $tableInfo.fullColumn)
  33.     #if(${column.obj.name} == "id")
  34.     @TableId(value = "id", type = IdType.ASSIGN_ID)
  35.     #elseif(${column.obj.name} == "create_time")
  36.     @TableField(value = "create_time", fill = FieldFill.INSERT)
  37.     #elseif(${column.obj.name} == "update_time")
  38.     @TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
  39.     #else
  40.     @TableField(value = "${column.obj.name}")
  41.     #end
  42.     @ApiModelProperty("${column.comment}")
  43.     #if($!{tool.getClsNameByFullName($column.type)} == "LocalDateTime")
  44.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  45.     private LocalDateTime $!{column.name};
  46.     #else
  47.     private $!{tool.getClsNameByFullName($column.type)} $!{column.name};
  48.     #end
  49. #end
  51. }

Mapper模板

  1. ##导入宏定义
  2. $!{define.vm}
  4. ##设置表后缀（宏定义）
  5. #setTableSuffix("Mapper")
  7. ##保存文件（宏定义）
  8. #save("/mapper", "Mapper.java")
  10. ##包路径（宏定义）
  11. #setPackageSuffix("mapper")
  13. import com.gton.handler.EasyBaseMapper;
  14. import org.apache.ibatis.annotations.Mapper;
  15. import $!{tableInfo.savePackageName}.entity.$!tableInfo.name;
  17. ##表注释（宏定义）
  18. #tableComment("表数据库访问层")
  19. @Mapper
  20. public interface $!{tableName} extends EasyBaseMapper<$!tableInfo.name> {
  22. }

Service接口 模板

  1. ##导入宏定义
  2. $!{define.vm}
  4. ##设置表后缀（宏定义）
  5. #setTableSuffix("Service")
  7. ##保存文件（宏定义）
  8. #save("/service", "Service.java")
  10. ##包路径（宏定义）
  11. #setPackageSuffix("service")
  13. import com.baomidou.mybatisplus.extension.service.IService;
  14. import $!{tableInfo.savePackageName}.entity.$!tableInfo.name;
  15. import com.baomidou.mybatisplus.core.metadata.IPage;
  16. import com.gton.io.BaseLimitRequest;
  17. import java.util.List;
  19. ##表注释（宏定义）
  20. #tableComment("表服务接口")
  21. public interface $!{tableName} extends IService<$!tableInfo.name> {
  23. /**
  24.      * Description:  分页查询
  25.      *
  26.      * @param limitRequest 分页查询参数
  27.      * @author: GuoTong
  28.      * @date: 2022-12-02 14:57:06
  29.      * @return:com.baomidou.mybatisplus.core.metadata.IPage
  30.      */
  31.     IPage<$!tableInfo.name> queryLimitPage(BaseLimitRequest<$!tableInfo.name> limitRequest);
  33.     /**
  34.      * Description:  批量新增
  35.      *
  36.      * @param entityList
  37.      * @author: GuoTong
  38.      * @date: 2022-12-06 19:52:00
  39.      * @return:Integer
  40.      */
  41.     Integer saveBatchByEasyBaseMapper(List<$!tableInfo.name> entityList);
  42. }

Service实现类模板

  1. ##导入宏定义
  2. $!{define.vm}
  4. ##设置表后缀（宏定义）
  5. #setTableSuffix("ServiceImpl")
  7. ##保存文件（宏定义）
  8. #save("/service/impl", "ServiceImpl.java")
  10. ##包路径（宏定义）
  11. #setPackageSuffix("service.impl")
  13. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  14. import $!{tableInfo.savePackageName}.mapper.$!{tableInfo.name}Mapper;
  15. import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};
  16. import $!{tableInfo.savePackageName}.service.$!{tableInfo.name}Service;
  17. import org.springframework.stereotype.Service;
  18. import com.alibaba.fastjson2.JSON;
  19. import com.alibaba.fastjson2.JSONObject;
  20. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  21. import com.baomidou.mybatisplus.core.metadata.IPage;
  22. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  23. import com.gton.io.BaseLimitRequest;
  24. import org.apache.commons.lang3.StringUtils;
  25. import javax.annotation.Resource;
  26. import javax.annotation.Resource;
  27. import java.time.LocalDateTime;
  28. import java.util.Map;
  29. import java.util.Objects;
  30. import java.util.Set;
  31. import java.util.List;
  33. ##表注释（宏定义）
  34. #tableComment("表服务实现类")
  35. @Service("$!tool.firstLowerCase($tableInfo.name)Service")
  36. public class $!{tableName} extends ServiceImpl<$!{tableInfo.name}Mapper, $!{tableInfo.name}> implements $!{tableInfo.name}Service {
  38.     @Resource
  39.     private $!{tableInfo.name}Mapper $!tool.firstLowerCase($tableInfo.name)Mapper;
  41.     /**
  42.      * Description:  分页查询
  43.      *
  44.      * @param limitRequest 分页查询参数
  45.      * @author: GuoTong
  46.      * @date: 2022-12-02 14:57:06
  47.      * @return:com.baomidou.mybatisplus.core.metadata.IPage
  48.      */
  49.     @Override
  50.     public IPage<$!{tableInfo.name}> queryLimitPage(BaseLimitRequest<$!{tableInfo.name}> limitRequest) {
  51.         $!{tableInfo.name} requestBody = limitRequest.getRequestBody();
  52.         long pageIndex = limitRequest.getPageIndex();
  53.         long pageSize = limitRequest.getPageSize();
  54.         IPage<$!{tableInfo.name}> page = new Page<>(pageIndex, pageSize);
  55.         QueryWrapper<$!{tableInfo.name}> queryWrapper = new QueryWrapper<>();
  56.         byte[] bytes = JSON.toJSONBytes(requestBody);
  57.         JSONObject thisObj = JSON.parseObject(bytes);
  58.         Set<Map.Entry<String, Object>> entries = thisObj.entrySet();
  59.         for (Map.Entry<String, Object> entry : entries) {
  60.             String key = entry.getKey();
  61.             StringBuilder column = new StringBuilder();
  62.             char[] chars = key.toCharArray();
  63.             for (char aChar : chars) {
  64.                 if (Character.isUpperCase(aChar)) {
  65.                     column.append("_");
  66.                 }
  67.                 column.append(aChar);
  68.             }
  69.             queryWrapper.eq(getValueIsBoolean(entry.getValue()), column.toString(), entry.getValue());
  70.         }
  71.         LocalDateTime beginTime = limitRequest.getBeginTime();
  72.         LocalDateTime endTime = limitRequest.getEndTime();
  73.         queryWrapper.ge(getValueIsBoolean(beginTime), "create_time", beginTime);
  74.         queryWrapper.le(getValueIsBoolean(endTime), "create_time", beginTime);
  75.         return $!{tool.firstLowerCase($tableInfo.name)}Mapper.selectPage(page, queryWrapper);
  76.     }
  78.       /**
  79.      * Description:  批量新增优化版
  80.      *
  81.      * @param entityList entityList
  82.      * @author: GuoTong
  83.      * @date: 2022-12-06 19:54:59
  84.      * @return:java.lang.Integer
  85.      */
  86.     @Override
  87.     public Integer saveBatchByEasyBaseMapper(List<$!{tableInfo.name}> entityList) {
  89.         return $!{tool.firstLowerCase($tableInfo.name)}Mapper.insertBatchSomeColumn(entityList);
  90.     }
  92.     private boolean getValueIsBoolean(Object object) {
  94.         if (object instanceof String) {
  95.             return StringUtils.isNotEmpty((CharSequence) object);
  96.         }
  97.         return !Objects.isNull(object);
  98.     }
  99. }

Mapper模板

  1. ##引入mybatis支持
  2. $!{mybatisSupport.vm}
  4. ##设置保存名称与保存位置
  5. $!callback.setFileName($tool.append($!{tableInfo.name}, "Mapper.xml"))
  6. $!callback.setSavePath($tool.append($modulePath, "/src/main/resources/mapper"))
  8. ##拿到主键
  9. #if(!$tableInfo.pkColumn.isEmpty())
  10.     #set($pk = $tableInfo.pkColumn.get(0))
  11. #end
  13. <?xml version="1.0" encoding="UTF-8"?>
  14. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  15. <mapper namespace="$!{tableInfo.savePackageName}.mapper.$!{tableInfo.name}Mapper">
  17.     <resultMap type="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}" id="$!{tableInfo.name}Map">
  18. #foreach($column in $tableInfo.fullColumn)
  19.         <result property="$!column.name" column="$!column.obj.name" jdbcType="$!column.ext.jdbcType"/>
  20. #end
  21.     </resultMap>
  23. </mapper>

生成接口如下

如果你把我的方式拿过去使用，那么你肯定会报错，你还差通用请求和响应类

  1. package com.gton.io;
  3. import com.gton.util.ContextCommonMsg;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Builder;
  6. import lombok.Data;
  7. import lombok.NoArgsConstructor;
  8. import lombok.experimental.Accessors;
  10. import java.io.Serializable;
  12. /**
  13.  * @description: 通用返回对象
  14.  * 贫血型模型
  15.  * @author: GuoTong
  16.  * @createTime: 2022-09-24 13:16
  17.  * @since JDK 1.8 OR 11
  18.  **/
  19. @Data
  20. @Builder
  21. @NoArgsConstructor
  22. @AllArgsConstructor
  23. @Accessors(chain = true)
  24. public class Resp<T> implements Serializable {
  25.     //状态码
  26.     protected String code;
  28.     //提示信息
  29.     protected String msg;
  31.     //返回的数据
  32.     protected T data;
  34.     /**
  35.      * Description:常用返回数据抽离
  36.      */
  37.     public static <T> Resp<T> LoginOk() {
  38.         return new Resp<T>().
  39.                 setCode(ContextCommonMsg.LOGIN_SUCCESS_CODE).
  40.                 setMsg(ContextCommonMsg.LOGIN_SUCCESS_MSG);
  41.     }
  43.     public static <T> Resp<T> LoginFail() {
  44.         return new Resp<T>().
  45.                 setCode(ContextCommonMsg.LOGIN_FAIL_CODE).
  46.                 setMsg(ContextCommonMsg.LOGIN_FAIL_MSG);
  47.     }
  49.     public static <T> Resp<T> error(String errorMsg) {
  50.         return new Resp<T>().
  51.                 setCode(ContextCommonMsg.FAIL_CODE).
  52.                 setMsg(errorMsg);
  53.     }
  55.     public static <T> Resp<T> error() {
  56.         return new Resp<T>().
  57.                 setCode(ContextCommonMsg.FAIL_CODE).
  58.                 setMsg(ContextCommonMsg.FAIL_MSG);
  59.     }
  61.     public static <T> Resp<T> error(String errorMsg, String failCode) {
  62.         return new Resp<T>().
  63.                 setCode(failCode).
  64.                 setMsg(errorMsg);
  65.     }
  67.     public static <T> Resp<T> error(String errorMsg, String failCode, T data) {
  68.         return new Resp<T>().
  69.                 setCode(failCode).
  70.                 setData(data).
  71.                 setMsg(errorMsg);
  72.     }
  74.     public static <T> Resp<T> Ok(T data) {
  75.         return new Resp<T>().
  76.                 setCode(ContextCommonMsg.SUCCESS_CODE).
  77.                 setMsg(ContextCommonMsg.SUCCESS_MSG).
  78.                 setData(data);
  79.     }
  81.     public static <T> Resp<T> Ok() {
  82.         return new Resp<T>().
  83.                 setCode(ContextCommonMsg.SUCCESS_CODE).
  84.                 setMsg(ContextCommonMsg.SUCCESS_MSG);
  85.     }
  87.     public static <T> Resp<T> Ok(T data, String msg) {
  88.         return new Resp<T>().
  89.                 setCode(ContextCommonMsg.SUCCESS_CODE).
  90.                 setMsg(msg).
  91.                 setData(data);
  92.     }
  94.     public static <T> Resp<T> Ok(T data, String msg, String successCode) {
  95.         return new Resp<T>().
  96.                 setCode(successCode).
  97.                 setMsg(msg).
  98.                 setData(data);
  99.     }
  101. }
  1. package com.gton.io;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. import java.io.Serializable;
  9. /**
  10.  * @description: 分页参数对象
  11.  * 贫血型模型
  12.  * @author: GuoTong
  13.  * @createTime: 2022-09-24 13:31
  14.  * @since JDK 1.8 OR 11
  15.  **/
  16. @Data
  17. @AllArgsConstructor
  18. @NoArgsConstructor
  19. public class BasePage implements Serializable {
  21.     /**
  22.      * Description:  当前页 || 默认是从第一页开始
  23.      *
  24.      * @author: GuoTong
  25.      * @date: 2022-09-24 13:32:36
  26.      */
  27.     protected long pageIndex = 1;
  29.     /**
  30.      * Description:  每页显示条数 || 默认是每页展示10条
  31.      *
  32.      * @author: GuoTong
  33.      * @date: 2022-09-24 13:32:36
  34.      */
  35.     protected long pageSize = 10;
  37.     public long getPageIndex() {
  38.         if (this.pageIndex <= 1) {
  39.             this.pageIndex = 1;
  40.         }
  41.         return pageIndex;
  42.     }
  44.     public long getPageSize() {
  45.         if (this.pageSize <= 1) {
  46.             this.pageSize = 10;
  47.         }
  48.         return pageSize;
  49.     }
  51. }
  1. package com.gton.io;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. import java.util.List;
  9. /**
  10.  * @description: 通用响应
  11.  * @author: GuoTong
  12.  * @createTime: 2022-12-02 14:12
  13.  * @since JDK 1.8 OR 11
  14.  **/
  15. @Data
  16. @NoArgsConstructor
  17. @AllArgsConstructor
  18. public class BaseLimitResponse<T> extends BasePage {
  20.     /**
  21.      * Description: 当前页数据
  22.      */
  23.     private List<T> responseBody;
  25.     /**
  26.      * Description:  总条数
  27.      */
  28.     private long totalNum;
  30.     /**
  31.      * Description:  总页数
  32.      */
  33.     private long pageCount;
  35.     public static <T> BaseLimitResponse<T> getInstance() {
  36.         return new BaseLimitResponse<>();
  37.     }
  39.     /**
  40.      * Description: 获取响应对象
  41.      *
  42.      * @param responseBody 当前页数据
  43.      * @param totalNum     总数据
  44.      * @param pageCount    总页数
  45.      * @param pageIndex    当前页
  46.      * @param pageSize     每页展示数据大小
  47.      * @author: GuoTong
  48.      * @date: 2022-12-02 15:01:48
  49.      * @return:com.gton.io.BaseLimitResponse<T>
  50.      */
  51.     public static <T> BaseLimitResponse<T> getInstance(List<T> responseBody, long totalNum, long pageCount, long pageIndex, long pageSize) {
  52.         BaseLimitResponse<T> response = new BaseLimitResponse<>();
  53.         response.setResponseBody(responseBody);
  54.         response.setPageCount(pageCount);
  55.         response.setTotalNum(totalNum);
  56.         response.setPageSize(pageSize);
  57.         response.setPageIndex(pageIndex);
  58.         return response;
  59.     }
  60. }
  1. package com.gton.io;
  3. import com.fasterxml.jackson.annotation.JsonFormat;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Data;
  6. import lombok.NoArgsConstructor;
  7. import org.springframework.format.annotation.DateTimeFormat;
  9. import java.time.LocalDateTime;
  11. /**
  12.  * @description: 通用请求
  13.  * @author: GuoTong
  14.  * @createTime: 2022-12-02 14:09
  15.  * @since JDK 1.8 OR 11
  16.  **/
  17. @Data
  18. @NoArgsConstructor
  19. @AllArgsConstructor
  20. public class BaseLimitRequest<T> extends BasePage {
  22.     /**
  23.      * Description: 实体类
  24.      */
  25.     private T requestBody;
  27.     /**
  28.      * Description: 开始时间
  29.      */
  30.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  31.     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  32.     private LocalDateTime beginTime;
  34.     /**
  35.      * Description: 结束时间
  36.      */
  37.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  38.     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  39.     private LocalDateTime endTime;
  41. }

基于EasyCode定制Mybatisplus全自动单表实现：新增/批量新增/修改/批量删除/分页查询/ID查询的更多相关文章

  1. MySQL数据库实验：任务二 表数据的插入、修改及删除

    目录 任务二 表数据的插入.修改及删除 一.利用界面工具插入数据 二.数据更新 (一)利用MySQL命令行窗口更新数据 (二)利用Navicat for MySQL客户端工具更新数据 三.数据库的备份 ...

  2. 05Microsoft SQL Server 表创建，查看，修改及删除

    Microsoft SQL Server 表创建,查看,修改及删除 创建表 创建普通表 use 数据库名称 go create table 表名称( 列1 ) not null, 列2 ) not n ...

  3. MySQL数据库表的数据插入、修改、删除、查询操作及实例应用

    一.MySQL数据库表的数据插入.修改.删除和查询 CREATE DATABASE db0504; USE db0504; CREATE TABLE student ( sno ) NOT NULL ...

  4. SQL 自动记录存储过程，表，函数的创建修改和删除 -相当于SVN一样

         在项目开发过程中,项目管理者通常都很希望对项目的开发进展有一个日志的记录.代码的记录和管理可以通过TFS或者VSS等工具去管理.但是数据库却没有记录开发日志这一功能.这在实际开发中很不方便, ...

  5. 基于SpringBoot从零构建博客网站 - 新增创建、修改、删除专栏功能

    守望博客是支持创建专栏的功能,即可以将一系列相关的文章归档到专栏中,方便用户管理和查阅文章.这里主要讲解专栏的创建.修改和删除功能,至于专栏还涉及其它的功能,例如关注专栏等后续会穿插着介绍. 1.创建 ...

  6. Oracle.数据的增删改、表操作（创建，修改，删除）、数据类型

    SELECT ename,dname FROM emp,dept WHERE emp.deptno=dept.deptno; SELECT dname,loc FROM dept; SELECT JO ...

  7. Spring Boot从入门到实战：整合通用Mapper简化单表操作

    数据库访问是web应用必不可少的部分.现今最常用的数据库ORM框架有Hibernate与Mybatis,Hibernate貌似在传统IT企业用的较多,而Mybatis则在互联网企业应用较多.通用Map ...

  8. Web框架之Django_05 模型层了解（单表查询、多表查询、聚合查询、分组查询）

    摘要: 单表查询 多表查询 聚合查询 分组查询 一.Django ORM 常用字段和参数: 常用字段:#AutoFieldint自增列,必须填入参数primary_key = True,当model中 ...

  9. ORM之单表、多表操作

    参考1 参考2 表与表之间的关系: 一对一(OneToOneField):一对一字段无论建在哪张关系表里面都可以,但是推荐建在查询频率比较高的那张表里面 一对多(ForeignKey):一对多字段建在 ...

  10. 零基础学习java------37---------mybatis的高级映射(单表查询，多表（一对一，一对多）)，逆向工程，Spring(IOC,DI，创建对象，AOP)

    一.  mybatis的高级映射 1  单表,字段不一致 resultType输出映射: 要求查询的字段名(数据库中表格的字段)和对应的java类型的属性名一致,数据可以完成封装映射 如果字段和jav ...

随机推荐

  1. Centos7.6内核升级

    文章转载自:https://mp.weixin.qq.com/s?__biz=MzI1MDgwNzQ1MQ==&mid=2247483766&idx=1&sn=4750fd4e ...

  2. fastapi快速入门

    fastapi是高性能的web框架.他的主要特点是: 快速编码 减少人为bug 直观 简易 具有交互式文档 基于API的开放标准(并与之完全兼容):OpenAPI(以前称为Swagger)和JSON ...

  3. C++面向对象编程之类的写法

    1.头文件中的防卫式声明 例如自己要建复数complex类,可以建立一个complex.h的头文件. 头文件中必须先写防卫式声明: #ifndef __COMPLEX__ #define __COMP ...

  4. 汇编指令：lea

    lea指令变种(按大小分类): leaw #2个字节 leal #4个字节 leaq #8个字节 lea的用法: leaq a(b, c, d), %rax 首先lea指令是mov指令的变种,据说,l ...

  5. EFCore （三）悲观锁 和 乐观锁

    原理 UPDATE [Person] SET [FirstName] = @p1 WHERE [PersonId] = @p0 AND [LastName] = @p2; 在 SaveChanges ...

  6. Hive之安装

    Hive安装 1. 依赖hadoop(另有hadoop安装文档) 执行程序运行在yarn上面,需要启动start-yarn.sh 2. 先安装MySQL MySQL安装详见数据库MySQL之安装:ht ...

  7. 虚拟机安装Linux系统的网络配置

    1. 进入配置文件配置.如果不知道ifcfg 后的内容.使用ifconfig vi /etc/sysconfig/network-scripts/ifcfg-ens33 如果不知道网关怎样配置就找到这 ...

  8. 3.Task对象

    Task对象 用于调度或并发协程对象 在事件循环中可以添加多个任务   创建task对象三种方式 创建task对象可以让协程加入事件循环中等待被调度执行 3.7版本之后加入asyncio.create ...

  9. 重新整理 .net core 实践篇 ———— linux上排查问题 [外篇]

    前言 简单介绍一下在排查问题.献给初学者. 该文的前置篇: https://www.cnblogs.com/aoximin/p/16838657.html 正文 什么是linux系统 linux 是基 ...

  10. 网络协议之:redis protocol 详解

    目录 简介 redis的高级用法 Redis中的pipline Redis中的Pub/Sub RESP protocol Simple Strings Bulk Strings RESP Intege ...