Spring Boot整合Mybatis Plus和Swagger2的教程详解

2023-07-05 05:37:03 354

前言：如果你是初学者，请完全按照我的教程以及代码来搭建（文末会附上完整的项目代码包，你可以直接下载我提供的完整项目代码包然后自行体验！），为了照顾初学者所以贴图比较多，请耐心跟着教程来，希望这个项目Demo能给你一些帮助，如果觉得写的还可以请给个关注和点赞，谢谢！

题外话：这是我第一篇用markdown来写的博文，格式不好的地方请见谅

一、pom.xml和application.yml

1、pom.xml中添加相关依赖，这里我把我的pom.xml代码贴出来



4.0.0

org.springframework.boot
spring-boot-starter-parent
2.4.3


com.example
study
0.0.1-SNAPSHOT
study
DemoprojectforSpringBoot



1.8
8.0.13
3.4.1
1.0.9
2.9.2
5.5.8




org.springframework.boot
spring-boot-starter-web



org.projectlombok
lombok
true


org.springframework.boot
spring-boot-starter-test
test




mysql
mysql-connector-java
runtime
${mysql.version}




com.baomidou
mybatis-plus-boot-starter
${mybatisPlus.version}


com.baomidou
mybatis-plus-generator
${mybatisPlus.version}




com.alibaba
druid
${druid.version}




io.springfox
springfox-swagger2
${swagger.version}


io.springfox
springfox-swagger-ui
${swagger.version}




cn.hutool
hutool-all
${hutool.version}






org.springframework.boot
spring-boot-maven-plugin



org.projectlombok
lombok

2、在resources下新建application.yml文件，并添加如下配置

#配置端口
server:
port:8080

#----------------druid数据源配置-----------------------
spring:
datasource:
type:com.alibaba.druid.pool.DruidDataSource
druid:
#这里跟pom里面mysql-connector版本相关8.0之后用com.mysql.cj.jdbc.Driver，之前用com.mysql.jdbc.Driver
driver-class-name:com.mysql.cj.jdbc.Driver
#这里改成你自己的数据库名称以及账号和密码
url:jdbc:mysql://127.0.0.1:3306/study?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
username:root
password:123456
initialSize:10
minIdle:10
maxActive:30
#配置获取连接等待超时的时间
maxWait:60000
#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
timeBetweenEvictionRunsMillis:60000
#配置一个连接在池中最小生存的时间，单位是毫秒
minEvictableIdleTimeMillis:300000
validationQuery:SELECT1FROMDUAL
testWhileIdle:true
testOnBorrow:false
testOnReturn:false
#打开PSCache，并且指定每个连接上PSCache的大小
poolPreparedStatements:true
#配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
#filters:stat,wall,log4j
#通过connectProperties属性来打开mergeSql功能；慢SQL记录
connection-properties:druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
#合并多个DruidDataSource的监控数据
useGlobalDataSourceStat:true

#----------------mybatisplus配置-----------------------
mybatis-plus:
#xml扫描，多个目录用逗号或者分号分隔(告诉Mapper所对应的XML文件位置)
mapper-locations:classpath:mapper/*.xml
configuration:
#是否开启自动驼峰命名规则映射:从数据库列名到Java属性驼峰命名的类似映射
map-underscore-to-camel-case:true
#如果查询结果中包含空值的列，则MyBatis在映射的时候，不会映射这个字段
call-setters-on-nulls:true
#这个配置会将执行的sql打印出来，在开发或测试的时候可以用
log-impl:org.apache.ibatis.logging.stdout.StdOutImpl
#实体扫描，多个package用逗号或者分号分隔（这里更改为你的实体类存放路径）
typeAliasesPackage:com.example.study.model.entity
global-config:
db-config:
#主键类型AUTO:"数据库ID自增"INPUT:"用户输入ID",ID_WORKER:"全局唯一ID(数字类型唯一ID)",UUID:"全局唯一IDUUID";
id-type:auto
#字段策略IGNORED:"忽略判断"NOT_NULL:"非NULL判断")NOT_EMPTY:"非空判断"
field-strategy:NOT_EMPTY
#数据库类型
db-type:MYSQL
#逻辑删除配置
#删除前
logic-not-delete-value:1
#删除后
logic-delete-value:0

#----------------swagger配置-----------------------
swagger:
#生产环境改为false（改为false后swagger-ui.html则无法访问）
enable:true
#解决Swagger2异常NumberFormatException:Forinputstring:""
logging:
level:
io:
swagger:
models:
parameters:
AbstractSerializableParameter:ERROR

二、整合Swagger2

1、添加swagger的配置类SwaggerConfig.java

packagecom.example.study.config;

importio.swagger.annotations.Api;
importorg.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importspringfox.documentation.builders.ApiInfoBuilder;
importspringfox.documentation.builders.PathSelectors;
importspringfox.documentation.builders.RequestHandlerSelectors;
importspringfox.documentation.service.ApiInfo;
importspringfox.documentation.service.ApiKey;
importspringfox.documentation.spi.DocumentationType;
importspringfox.documentation.spring.web.plugins.Docket;
importspringfox.documentation.swagger2.annotations.EnableSwagger2;

importjava.util.ArrayList;
importjava.util.List;

/**
*Swagger配置类
*
*@author154594742@qq.com
*@date:2021/2/2210:02:00
*/
@Configuration
@EnableSwagger2
@ConditionalOnProperty(name="swagger.enable",havingValue="true")
publicclassSwaggerConfig{
/**
*创建API应用
*apiInfo()增加API相关信息
*通过select()函数返回一个ApiSelectorBuilder实例,用来控制哪些接口暴露给Swagger来展现，
*本例采用指定扫描的包路径来定义指定要建立API的目录。
*
*@return
*/
@Bean
publicDocketcreateRestApi(){
returnnewDocket(DocumentationType.SWAGGER_2)
.apiInfo(this.apiInfo())
.select()
//设置选择器，选择带Api接口类的类
.apis(RequestHandlerSelectors.withClassAnnotation(Api.class))
//api包扫描
.apis(RequestHandlerSelectors.basePackage("com.example.study"))
.paths(PathSelectors.any())
.build()
.securitySchemes(securitySchemes());
}

/**
*创建该API的基本信息（这些基本信息会展现在文档页面中）
*访问地址：http://ip:端口/swagger-ui.html
*
*@returnApiInfo
*/
privateApiInfoapiInfo(){
returnnewApiInfoBuilder().title("demo项目")
.description("demo项目API文档")
.termsOfServiceUrl("http://localhost")
.version("1.0")
.build();
}

privateListsecuritySchemes(){
ListapiKeyList=newArrayList<>();
//apiKeyList.add(newApiKey("token","令牌","header"));
returnapiKeyList;
}
}

2、新建controller包并且在controller包下新建IndexController.java

packagecom.example.study.controller;

importio.swagger.annotations.Api;
importio.swagger.annotations.ApiOperation;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.web.bind.annotation.GetMapping;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RestController;

/**
*首页控制器
*@author154594742@qq.com
*@date:2021/2/2210:02:00
*/
@Api(tags="首页控制器")
@RestController
publicclassIndexController{

@ApiOperation("首页html")
@GetMapping("/")
publicStringindex(){
return"helloindex";
}
}

3、启动StudyApplication.java后访问http://localhost:8080/swagger-ui.html，出现第二图所示则表示swagger整合完成

三、整合MybatisPlus

1、如图创建MybatisPlusConfi.java配置分页插件

packagecom.example.study.config;

importcom.baomidou.mybatisplus.annotation.DbType;
importcom.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
importcom.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
importcom.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
importorg.mybatis.spring.annotation.MapperScan;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;

/**
*配置MybatisPlus分页插件
*
*@author154594742@qq.com
*@date:2021/2/2210:02:00
*/
@Configuration
@MapperScan("com.example.study.mapper")
publicclassMybatisPlusConfig{

/**
*Mybatis-plus3.4.0版本过后使用MybatisPlusInterceptor分页插件
*注意：DbType.MYSQL必须为自己使用的数据库类型，否则分页不生效
*/
@Bean
publicMybatisPlusInterceptormybatisPlusInterceptor(){
MybatisPlusInterceptorinterceptor=newMybatisPlusInterceptor();
interceptor.addInnerInterceptor(newPaginationInnerInterceptor(DbType.MYSQL));
returninterceptor;
}

/**
*设置useDeprecatedExecutor=false避免缓存出现问题
*@return
*/
@Bean
publicConfigurationCustomizerconfigurationCustomizer(){
returnconfiguration->configuration.setUseDeprecatedExecutor(false);
}
}

2、在数据库中创建测试表

CREATETABLE`t_user`(
`id`bigintNOTNULLAUTO_INCREMENT,
`name`varchar(32)DEFAULTNULL,
`age`intDEFAULTNULL,
PRIMARYKEY(`id`)
)ENGINE=InnoDBDEFAULTCHARSET=utf8

3、创建实体类UserEntity.java

packagecom.example.study.model.entity;

importcom.baomidou.mybatisplus.annotation.IdType;
importcom.baomidou.mybatisplus.annotation.TableField;
importcom.baomidou.mybatisplus.annotation.TableId;
importcom.baomidou.mybatisplus.annotation.TableName;
importio.swagger.annotations.ApiModel;
importio.swagger.annotations.ApiModelProperty;
importlombok.AllArgsConstructor;
importlombok.Data;
importlombok.NoArgsConstructor;

importjava.io.Serializable;

/**
*用户信息实体类
*
*@author154594742@qq.com
*@date:2021/2/2210:02:00
*/

@Data
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value="UserEntity",description="用户实体")
@TableName("t_user")
publicclassUserEntityimplementsSerializable{

privatestaticfinallongserialVersionUID=6928834261563057243L;

/**
*唯一标识，自增主键
*/
@ApiModelProperty(value="id")
@TableId(value="id",type=IdType.AUTO)
privateLongid;

/**
*姓名
*/
@ApiModelProperty(value="姓名")
@TableField("name")
privateStringname;

/**
*年龄
*/
@ApiModelProperty(value="年龄")
@TableField("age")
privateIntegerage;
}

4、创建UserMapper.java

packagecom.example.study.mapper;

importcom.baomidou.mybatisplus.core.mapper.BaseMapper;
importcom.example.study.model.entity.UserEntity;

/**
*@author154594742@qq.com
*/
publicinterfaceUserMapperextendsBaseMapper{
}

5、创建UserService.java

packagecom.example.study.service;

importcom.baomidou.mybatisplus.extension.service.IService;
importcom.example.study.model.entity.UserEntity;

/**
*@author154594742@qq.com
*/
publicinterfaceUserServiceextendsIService{
}

6、创建UserServiceImpl.java

packagecom.example.study.service.impl;

importcom.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
importcom.example.study.model.entity.UserEntity;
importcom.example.study.mapper.UserMapper;
importcom.example.study.service.UserService;
importorg.springframework.stereotype.Service;

/**
*@author154594742@qq.com
*/
@Service
publicclassUserServiceImplextendsServiceImplimplementsUserService{
}

7、创建UserController.java(这里编译器会提示一些错误暂时不用管，因为缺少一些类的代码)

packagecom.example.study.controller;

importcom.baomidou.mybatisplus.core.metadata.IPage;
importcom.example.study.model.entity.UserEntity;
importcom.example.study.model.param.UserParam;
importcom.example.study.model.vo.ResponseVo;
importcom.example.study.service.UserService;
importcom.example.study.util.CommonQueryPageUtils;
importcom.example.study.util.BuildResponseUtils;
importio.swagger.annotations.Api;
importio.swagger.annotations.ApiOperation;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.web.bind.annotation.*;

/**
*用户控制器
*
*@author154594742@qq.com
*@date:2021/2/2210:02:00
*/

@RestController
@Api(tags="用户控制器")
publicclassUserController{

@Autowired
privateUserServiceuserService;

@ApiOperation("新增")
@PostMapping("user")
publicResponseVoadd(UserEntityentity){
returnuserService.save(entity)?BuildResponseUtils.success():BuildResponseUtils.error();
}

@ApiOperation("通过id查询")
@GetMapping("user/{id}")
publicResponseVogetById(@PathVariableStringid){
returnBuildResponseUtils.buildResponse(userService.getById(id));
}

@ApiOperation("修改")
@PutMapping("user")
publicResponseVoupdate(UserEntityentity){
returnuserService.updateById(entity)?BuildResponseUtils.success():BuildResponseUtils.error();
}

@ApiOperation("通过id删除")
@DeleteMapping("user/{id}")
publicResponseVodelete(@PathVariableStringid){
returnuserService.removeById(id)?BuildResponseUtils.success():BuildResponseUtils.error();
}


@ApiOperation("分页查询")
@GetMapping("userPage")
publicResponseVo>selectPage(UserParamparam){
returnBuildResponseUtils.buildResponse(CommonQueryPageUtils.commonQueryPage(param,userService));
}

}

8、创建枚举CodeMsgEnum.java

packagecom.example.study.enums;

/**
*异常类code常量（code值不要重复）
*
*@author154594742@qq.com
*@date:2021/2/229:42:00
*/
publicenumCodeMsgEnum{
//请求成功
SUCCESS("0","成功!"),
//系统异常
FAIL("1","失败!"),
//以下是业务异常
LOGIN_NO_PASS("1001","用户名或密码错误"),
;

/**
*状态码
*/
publicStringcode;

/**
*状态码对应信息
*/
publicStringmsg;

CodeMsgEnum(Stringcode,Stringmsg){
this.code=code;
this.msg=msg;
}
}

9、创建统一的返回结果类ResponseVo.java

packagecom.example.study.model.vo;

importio.swagger.annotations.ApiModel;
importio.swagger.annotations.ApiModelProperty;
importlombok.AllArgsConstructor;
importlombok.Data;
importlombok.NoArgsConstructor;

importjava.io.Serializable;

/**
*统一的返回对象VO
*
*@author154594742@qq.com
*@date:2021/2/2210:02:00
*/

@Data
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value="ResponseVo",description="统一的返回对象")
publicclassResponseVoimplementsSerializable{
privatestaticfinallongserialVersionUID=7748070653645596712L;
/**
*状态码
*/
@ApiModelProperty(value="状态码")
privateStringcode;

/**
*状态码对应描述信息
*/
@ApiModelProperty(value="状态码对应描述信息")
privateStringmsg;

/**
*数据
*/
@ApiModelProperty(value="数据")
privateTdata;
}

10、创建常量类QueryMethodConstant.java

packagecom.example.study.constant;

/**
*mybatisplus常用的查询方式
*@author154594742@qq.com
*@date2021/2/2311:24
*/

publicinterfaceQueryMethodConstant{
/**
*相同
*/
StringEQ="EQ";

/**
*不相同
*/
StringNE="NE";

/**
*相似，左右模糊(like'%值%')
*/
StringLIKE="LIKE";

/**
*相似，左模糊(like'%值')
*/
StringLIKE_LIFT="LIKE_LIFT";

/**
*相似，右模糊(like'值%')
*/
StringLIKE_RIGHT="LIKE_RIGHT";

/**
*不相似(notlike'%值%')
*/
StringNOT_LIKE="NOT_LIKE";

/**
*大于
*/
StringGT="GT";

/**
*大于等于
*/
StringGE="GE";

/**
*小于
*/
StringLT="LT";

/**
*小于等于
*/
StringLE="LE";
}

11、创建自定义注解QueryMethod.java(用于后续的通用分页查询工具类)

packagecom.example.study.annotation;

importjava.lang.annotation.ElementType;
importjava.lang.annotation.Retention;
importjava.lang.annotation.RetentionPolicy;
importjava.lang.annotation.Target;

/**
*查询方式的自定义注解
*@author154594742@qq.com
*@date2021/2/2311:24
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(value=ElementType.FIELD)
public@interfaceQueryMethod{

/**
*字段名
*/
Stringfield()default"";

/**
*匹配方式
*/
Stringmethod()default"";
}

12、创建构建返回结果工具类BuildResponseUtils.java

packagecom.example.study.util;

importcom.example.study.enums.CodeMsgEnum;
importcom.example.study.model.vo.ResponseVo;

/**
*构建返回结果工具类
*
*@author154594742@qq.com
*@date:2021/2/2210:02:00
*/
publicfinalclassBuildResponseUtils{

/**
*构建正确请求的response
*
*@returnResponseVo统一的返回结果
*/
publicstaticResponseVosuccess(){
ResponseVoresponse=newResponseVo<>();
response.setCode(CodeMsgEnum.SUCCESS.code);
response.setMsg(CodeMsgEnum.SUCCESS.msg);
returnresponse;
}

/**
*构建业务异常的response
*@paramcodeMsgEnum枚举
*@returnResponseVo统一的返回结果
*/
publicstaticResponseVosuccess(CodeMsgEnumcodeMsgEnum){
ResponseVoresponse=newResponseVo<>();
response.setCode(codeMsgEnum.code);
response.setMsg(codeMsgEnum.msg);
returnresponse;
}

/**
*构建自定义code和msg的业务异常
*
*@paramcode自定义code
*@parammsg自定义msg
*@returnResponseVo统一的返回结果
*/
publicstaticResponseVosuccess(Stringcode,Stringmsg){
ResponseVoresponse=newResponseVo<>();
response.setCode(code);
response.setMsg(msg);
returnresponse;
}

/**
*构建系统异常的response(只用于系统异常)
*@returnResponseVo统一的返回结果
*/
publicstaticResponseVoerror(){
ResponseVoresponse=newResponseVo<>();
response.setCode(CodeMsgEnum.FAIL.code);
response.setMsg(CodeMsgEnum.FAIL.msg);
returnresponse;
}

/**
*构建返回结果
*@paramobj结果数据
*@param结果数据的泛型
*@returnResponseVo统一的返回结果
*/
publicstaticResponseVobuildResponse(Tobj){
ResponseVoresponse=newResponseVo<>();
response.setData(obj);
response.setCode(CodeMsgEnum.SUCCESS.code);
response.setMsg(CodeMsgEnum.SUCCESS.msg);
returnresponse;
}
}

13、创建分页查询工具类CommonQueryPageUtils.java(本人自己封装的，功能可能不是很完善，但是基本的单表查询够用了)

packagecom.example.study.util;

importcom.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
importcom.baomidou.mybatisplus.core.metadata.IPage;
importcom.baomidou.mybatisplus.core.metadata.OrderItem;
importcom.baomidou.mybatisplus.core.toolkit.StringUtils;
importcom.baomidou.mybatisplus.extension.plugins.pagination.Page;
importcom.baomidou.mybatisplus.extension.service.IService;
importcom.example.study.annotation.QueryMethod;
importcom.example.study.constant.QueryMethodConstant;
importcom.example.study.model.param.PageParam;

importjava.lang.reflect.Field;
importjava.util.Locale;

/**
*分页查询工具类
*
*@author154594742@qq.com
*@date:2021/2/2210:02:00
*/
publicfinalclassCommonQueryPageUtils{

/**
*正序
*/
privatestaticfinalStringASC="asc";

/**
*倒序
*/
privatestaticfinalStringDESC="desc";

/**
*通用的带排序功能的分页查询
*/
publicstaticIPagecommonQueryPage(PageParamparam,IServiceservice){
//构建page
//根据传入的排序设置order
//排序字段(格式：字段名:排序方式，字段名:排序方式（asc正序，desc倒序）示例:id:desc,age:asc)
Pagepage=newPage<>(param.getPage(),param.getLimit());
Stringorders=param.getOrders();
if(StringUtils.isNotBlank(orders)){
String[]splitArr=orders.split(",");
for(Stringstr:splitArr){
if(StringUtils.isBlank(str)){
continue;
}
String[]strArr=str.split(":");
if(strArr.length!=2||StringUtils.isBlank(strArr[0])||StringUtils.isBlank(strArr[1])){
continue;
}
if(ASC.equals(strArr[1].toLowerCase(Locale.ROOT))){
page.addOrder(OrderItem.asc(strArr[0]));
continue;
}
if(DESC.equals(strArr[1].toLowerCase(Locale.ROOT))){
page.addOrder(OrderItem.desc(strArr[0]));
}
}
}
//根据自定义注解构建queryWrapper
QueryWrapperqueryWrapper=newQueryWrapper<>();
Classclazz=param.getClass();
Field[]fields=clazz.getDeclaredFields();
for(Fieldfield:fields){
//设置对象的访问权限，保证对private的属性可以访问
field.setAccessible(true);
QueryMethodannotation=field.getAnnotation(QueryMethod.class);
try{
//属性没有值则跳过
if(null==field.get(param)){
continue;
}
//没有加@QueryMethod默认属性名为字段名，默认匹配方式为eq
if(null==annotation){
queryWrapper.eq(field.getName(),field.get(param));
continue;
}

switch(annotation.method()){
caseQueryMethodConstant.EQ:
queryWrapper.eq(annotation.field(),field.get(param));
break;
caseQueryMethodConstant.NE:
queryWrapper.ne(annotation.field(),field.get(param));
break;
caseQueryMethodConstant.LIKE:
queryWrapper.like(annotation.field(),field.get(param));
break;
caseQueryMethodConstant.LIKE_LIFT:
queryWrapper.likeLeft(annotation.field(),field.get(param));
break;
caseQueryMethodConstant.LIKE_RIGHT:
queryWrapper.likeRight(annotation.field(),field.get(param));
break;
caseQueryMethodConstant.GT:
queryWrapper.gt(annotation.field(),field.get(param));
break;
caseQueryMethodConstant.GE:
queryWrapper.ge(annotation.field(),field.get(param));
break;
caseQueryMethodConstant.LT:
queryWrapper.lt(annotation.field(),field.get(param));
break;
caseQueryMethodConstant.LE:
queryWrapper.le(annotation.field(),field.get(param));
break;
default:
;
}
}catch(IllegalAccessExceptione){
e.printStackTrace();
}
}
returnservice.page(page,queryWrapper);
}
}

14、创建统一的分页查询请求参数类PageParam.java

packagecom.example.study.model.param;

importio.swagger.annotations.ApiModel;
importio.swagger.annotations.ApiModelProperty;
importlombok.Data;

importjava.util.LinkedHashMap;

/**
*统一的分页查询请求参数
*
*@author154594742@qq.com
*@date2021/2/2217:24
*/

@Data
@ApiModel(value="PageParam",description="分页参数")
publicclassPageParam{
/**
*页码
*/
@ApiModelProperty(value="页码，不传则默认1")
privateIntegerpage=1;

/**
*每页条数
*/
@ApiModelProperty(value="每页条数，不传则默认10")
privateIntegerlimit=10;

/**
*排序字段(格式：字段名:排序方式，字段名:排序方式（asc正序，desc倒序）示例:id:desc,age:asc)
*/
@ApiModelProperty(value="排序字段(格式：字段名:排序方式，字段名:排序方式（asc正序，desc倒序）示例:id:desc,age:asc)")
privateStringorders;
}

15、创建用户查询条件类UserParam.java继承PageParam（以后分页查询的参数类都要继承PageParam）

packagecom.example.study.model.param;

importcom.example.study.annotation.QueryMethod;
importcom.example.study.constant.QueryMethodConstant;
importio.swagger.annotations.ApiModel;
importio.swagger.annotations.ApiModelProperty;
importlombok.Data;

/**
*用户查询条件类（需要根据哪些字段查询就添加哪些字段）
*@author154594742@qq.com
*@date2021/2/2217:24
*/

@Data
@ApiModel(value="UserParam",description="用户查询条件")
publicclassUserParamextendsPageParam{

/**
*通过@QueryMethod注解来控制匹配的方式，这里查询条件为namelike‘%值%'
*/
@ApiModelProperty(value="姓名")
@QueryMethod(field="name",method=QueryMethodConstant.LIKE)
privateStringname;

/**
*这里没有@QueryMethod注解则如果age有值，则默认查询条件为age=值
*/
@ApiModelProperty(value="年龄")
privateIntegerage;

/**
*假如要查询(值125
*/
@ApiModelProperty(value="年龄下限")
@QueryMethod(field="age",method=QueryMethodConstant.GT)
privateStringminAge;

@ApiModelProperty(value="年龄上限")
@QueryMethod(field="age",method=QueryMethodConstant.LT)
privateStringmaxAge;
}

16、先在数据库中添加几条测试数据，然后启动项目后打开http://localhost:8080/swagger-ui.html

insertinto`t_user`(`id`,`name`,`age`)values
(1,'小二',20),
(2,'张三',20),
(3,'李四',20),
(4,'王五',35),
(5,'小六',18);

17、按上图填入查询条件，然后点击“Execute”执行

返回的Responsebody：

{
"code":"0",
"msg":"成功!",
"data":{
"records":[
{
"id":5,
"name":"小六",
"age":18
},
{
"id":1,
"name":"小二",
"age":20
},
{
"id":2,
"name":"张三",
"age":20
},
{
"id":3,
"name":"李四",
"age":20
}
],
"total":4,
"size":10,
"current":1,
"orders":[
{
"column":"age",
"asc":true
}
],
"optimizeCountSql":true,
"hitCount":false,
"countId":null,
"maxLimit":null,
"searchCount":true,
"pages":1
}
}

通过上面的返回结果可以看出我们带条件带排序的的分页查询功能是ok的！！！

感谢你看完了此篇博文，如果有什么问题可以评论留言，附上完整代码点击下载完整代码包

到此这篇关于SpringBoot整合MybatisPlus和Swagger2的文章就介绍到这了,更多相关SpringBoot整合MybatisPlus和Swagger2内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

Spring Boot整合Mybatis Plus和Swagger2的教程详解

一、pom.xml和application.yml

二、整合Swagger2

三、整合MybatisPlus

热门推荐

随机推荐