Swagger实体类参数分组

最新推荐文章于 2025-01-12 23:52:42 发布
最新推荐文章于 2025-01-12 23:52:42 发布
阅读量3.1k 收藏 13
点赞数 2
分类专栏： java 文章标签： swagger2 java api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_36732671/article/details/121231567
版权
本文介绍了如何通过自定义注解在Springfox Swagger中实现接口参数实体类的字段选择性展示，包括body和query参数，并通过示例代码展示了如何在控制器方法中应用这些注解。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Swagger2接口参数实体类字段自定义显示

使用swagger文档的时候发现实体类参数每次都是全部显示出来，导致和前端对接很麻烦，就产生了想要自定义的实体类参数的想法，于是在百度了很久，找到了flymoringbird大神的文章Swagger2 自定义注解 ：解决一个简单的model类 适用于controller的多个方法，参考了一下发现只能实现body传参，query传参还是没有办法实现，于是又开始了百度，找到了x-easy大神swagger2 同一个实体用在多个不同的controller接口展示不同的字段的文章，最终实现了功能。
话不多说，直接上代码：

pom.xml

这里只贴出了最重要的类，其他的还请自行查找

 <properties>
    <swagger.version>2.9.2</swagger.version>
    <swagger-models.version>1.6.2</swagger-models.version>
    <transmittable.version>2.12.1</transmittable.version>
 </properties>
            <!--swagger2-->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
                <version>${swagger.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>io.swagger</groupId>
                        <artifactId>swagger-models</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
  <!-- 防止进入swagger页面报类型转换错误For input string: ""，排除swagger-models引用， ,手动增加1.6.2版本 -->
            <dependency>
                <groupId>io.swagger</groupId>
                <artifactId>swagger-models</artifactId>
                <version>${swagger-models.version}</version>
            </dependency>
            <!--swagger2-ui-->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger-ui</artifactId>
                <version>${swagger.version}</version>
            </dependency>
              <!--注意这里用的是alibaba 的 javassist 的包最好-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>transmittable-thread-local</artifactId>
                <version>${transmittable.version}</version>
            </dependency>

自定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 李永杰
 * @date 2021/10/11
 * @description swagger ApiModel参数排除字段
 */

@Target({ElementType.PARAMETER, ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiExclude {
    /**
     * 忽略的属性值
     */
    String[] value() default {};
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 李永杰
 * @date 2021/10/11
 * @description swagger ApiModel参数包含字段
 */
@Target({ElementType.PARAMETER, ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiInclude {
    /**
     * 需要的属性值
     */
    String[] value() default {};
}

测试参数实体类

/**
 * @author 李永杰
 * @date 2021/11/4
 * @description
 */
@Data
@ApiModel("测试参数")
public class Demo {
    @ApiModelProperty("参数A")
    private String a;
    @ApiModelProperty("参数B")
    private String b;
    @ApiModelProperty("参数C")
    private String c;
    @ApiModelProperty("参数D")
    private String d;
}

静态常量

 /**
     * swagger 自定义model 前缀
     */
    public static String MY_MODEL_NAME_PRE="SWAGGER";

最重要的两个plugin类

下面这个是解决body传参的

import cn.hutool.core.util.IdUtil;
import com.alibaba.ttl.threadpool.agent.internal.javassist.*;
import com.alibaba.ttl.threadpool.agent.internal.javassist.bytecode.AnnotationsAttribute;
import com.alibaba.ttl.threadpool.agent.internal.javassist.bytecode.ConstPool;
import com.alibaba.ttl.threadpool.agent.internal.javassist.bytecode.annotation.Annotation;
import com.alibaba.ttl.threadpool.agent.internal.javassist.bytecode.annotation.StringMemberValue;
import com.fasterxml.classmate.TypeResolver;
import com.google.common.base.Optional;
import com.ruoyi.common.annotation.ApiExclude;
import com.ruoyi.common.annotation.ApiInclude;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.utils.StringUtils;
import io.swagger.annotations.ApiModelProperty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ResolvedMethodParameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.ParameterBuilderPlugin;
import springfox.documentation.spi.service.contexts.ParameterContext;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author 李永杰
 * @date 2021/11/05
 * @description 读取自定义注解的dto属性并动态生成model, 只支持body参数（注意这里用的是alibaba的 javassist 的包最好）
 */
@Order
@Configuration
public class SwaggerBodyParameterPlugin implements ParameterBuilderPlugin {

    private static final Logger logger = LoggerFactory.getLogger(SwaggerBodyParameterPlugin.class);

    @Autowired
    private TypeResolver typeResolver;

    @Override
    public void apply(ParameterContext parameterContext) {
        ResolvedMethodParameter methodParameter = parameterContext.resolvedMethodParameter();
        Class<?> originClass = parameterContext.resolvedMethodParameter().getParameterType().getErasedType();
        // 排除属性
        ApiExclude apiExclude = null;
        @SuppressWarnings("Guava")
        Optional<ApiExclude> apiExcludeOptional = methodParameter.findAnnotation(ApiExclude.class);
        if (apiExcludeOptional.isPresent()) {
            apiExclude = apiExcludeOptional.get();
        }

        // 需要属性
        ApiInclude apiInclude = null;
        @SuppressWarnings("Guava")
        Optional<ApiInclude> apiIncludeOptional = methodParameter.findAnnotation(ApiInclude.class);
        if (apiIncludeOptional.isPresent()) {
            apiInclude = apiIncludeOptional.get();
        }

        if (null != apiExclude || null != apiInclude) {
            //model名称，注意名称不能一样
            String name = Constants.MY_MODEL_NAME_PRE.concat(originClass.getSimpleName()).concat(IdUtil.objectId());
            try {
                // 排除 (黑名单)
                if (null != apiExclude) {
                    String[] properties = apiExclude.value();
                    parameterContext.getDocumentationContext()
                            .getAdditionalModels()
                            //向documentContext的Models中添加我们新生成的Class
                            .add(typeResolver.resolve(createRefModelIgp(properties, originClass.getPackage() + "." + name, originClass)));
                }
                // 需要 (白名单)
                if (null != apiInclude) {
                    String[] properties = apiInclude.value();
                    parameterContext.getDocumentationContext()
                            .getAdditionalModels()
                            //向documentContext的Models中添加我们新生成的Class
                            .add(typeResolver.resolve(createRefModelNeed(properties, originClass.getPackage() + "." + name, originClass)));
                }
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("swagger切面异常", e);
            }
            //修改Map参数的ModelRef为我们动态生成的class
            parameterContext.parameterBuilder()
                    .parameterType("body")
                    .modelRef(new ModelRef(name))
                    .name(name);
        }

    }

    /**
     * 创建自定义mode给swagger2 排除参数
     *
     * @param properties 需要排除的参数
     * @param name       model 名称
     * @param origin     originClass
     * @return r
     */
    private Class<?> createRefModelIgp(String[] properties, String name, Class<?> origin) {
        
        ClassPool pool = ClassPool.getDefault();
        // 动态创建一个class
        CtClass ctClass = pool.makeClass(name);
        if (ctClass != null) {
            // 这行代码很重要 如果没有的话 那就不能和devTool 一起使用
            // 销毁旧的类
            ctClass.detach();
        }
        try {
            Field[] fields = origin.getDeclaredFields();
            List<Field> fieldList = Arrays.asList(fields);
            List<String> ignoreProperties = Arrays.asList(properties);
            // 过滤掉 properties 的参数
            List<Field> dealFields = fieldList.stream().filter(s -> !ignoreProperties.contains(s.getName())).collect(Collectors.toList());
            addField2CtClass(dealFields, origin, ctClass);
            return ctClass.toClass();
        } catch (Exception e) {
            logger.error("swagger切面异常", e);
            return null;
        }
    }

    /**
     * 创建自定义mode给swagger2 需要参数
     *
     * @param properties 需要的参数
     * @param name       model 名称
     * @param origin     originClass
     * @return r
     */
    private Class<?> createRefModelNeed(String[] properties, String name, Class<?> origin) {
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.makeClass(name);
        try {
            Field[] fields = origin.getDeclaredFields();
            List<Field> fieldList = Arrays.asList(fields);
            List<String> needProperties = Arrays.asList(properties);
            // 过滤掉 非 properties 的参数
            List<Field> dealFields = fieldList.stream().filter(s -> needProperties.contains(s.getName())).collect(Collectors.toList());
            addField2CtClass(dealFields, origin, ctClass);
            return ctClass.toClass();
        } catch (Exception e) {
            logger.error("swagger切面异常", e);
            return null;
        }
    }

    private void addField2CtClass(List<Field> dealFields, Class<?> origin, CtClass ctClass) throws NoSuchFieldException, NotFoundException, CannotCompileException {
        // 倒序遍历
        for (int i = dealFields.size() - 1; i >= 0; i--) {
            Field field = dealFields.get(i);
            CtField ctField = new CtField(ClassPool.getDefault().get(field.getType().getName()), field.getName(), ctClass);
            ctField.setModifiers(Modifier.PUBLIC);
            ApiModelProperty ampAnno = origin.getDeclaredField(field.getName()).getAnnotation(ApiModelProperty.class);
            String attributes = java.util.Optional.ofNullable(ampAnno).map(ApiModelProperty::value).orElse("");
            //添加model属性说明
            if (StringUtils.isNotBlank(attributes)) {
                ConstPool constPool = ctClass.getClassFile().getConstPool();
                AnnotationsAttribute attr = new AnnotationsAttribute(constPool, AnnotationsAttribute.visibleTag);
                Annotation ann = new Annotation(ApiModelProperty.class.getName(), constPool);
                ann.addMemberValue("value", new StringMemberValue(attributes, constPool));
                attr.addAnnotation(ann);
                ctField.getFieldInfo().addAttribute(attr);
            }
            ctClass.addField(ctField);
        }
    }

    @Override
    public boolean supports(DocumentationType documentationType) {
        return true;
    }


}

下面这个是解决query传参的

import com.fasterxml.classmate.ResolvedType;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;
import com.ruoyi.common.annotation.ApiExclude;
import com.ruoyi.common.annotation.ApiInclude;
import com.ruoyi.common.constant.Constants;
import org.apache.poi.ss.formula.functions.T;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import springfox.documentation.builders.BuilderDefaults;
import springfox.documentation.builders.OperationBuilder;
import springfox.documentation.builders.ParameterBuilder;
import springfox.documentation.service.Parameter;
import springfox.documentation.service.ResolvedMethodParameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.schema.EnumTypeDeterminer;
import springfox.documentation.spi.service.OperationBuilderPlugin;
import springfox.documentation.spi.service.contexts.OperationContext;
import springfox.documentation.spi.service.contexts.ParameterContext;
import springfox.documentation.spring.web.plugins.DocumentationPluginsManager;
import springfox.documentation.spring.web.readers.operation.OperationParameterReader;
import springfox.documentation.spring.web.readers.parameter.ExpansionContext;
import springfox.documentation.spring.web.readers.parameter.ModelAttributeParameterExpander;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;

import static com.google.common.base.Predicates.not;
import static springfox.documentation.schema.Collections.isContainerType;
import static springfox.documentation.schema.Maps.isMapType;
import static springfox.documentation.schema.Types.isBaseType;
import static springfox.documentation.schema.Types.typeNameFor;

/**
 * @author 李永杰
 * @date 2021/11/5
 * @description 读取自定义注解的dto属性并动态生成model, 只支持query参数
 */
@Order
@Configuration
public class SwaggerQueryParameterPlugin extends OperationParameterReader implements OperationBuilderPlugin {

    private static final Logger logger = LoggerFactory.getLogger(SwaggerQueryParameterPlugin.class);

    private final EnumTypeDeterminer enumTypeDeterminer;
    private final ModelAttributeParameterExpander expander;

    private Boolean changed;

    @Autowired
    private DocumentationPluginsManager pluginsManager;

    public SwaggerQueryParameterPlugin(ModelAttributeParameterExpander expander, EnumTypeDeterminer enumTypeDeterminer) {
        super(expander, enumTypeDeterminer);
        this.enumTypeDeterminer = enumTypeDeterminer;
        this.expander = expander;
    }

    @Override
    public void apply(OperationContext context) {
        changed = false;
        List<Parameter> parameters = readParameters(context);
        if (changed) {
            // 反射给parameters赋值
            try {
                Field parametersField = OperationBuilder.class.getDeclaredField("parameters");
                parametersField.setAccessible(true);
                List<Parameter> source = BuilderDefaults.nullToEmptyList(parameters);
                parametersField.set(context.operationBuilder(), source);
            } catch (Exception e) {
                logger.error("动态更改swagger参数错误", e);
            }
        }
        context.operationBuilder().parameters(context.getGlobalOperationParameters());
    }

    @Override
    public boolean supports(DocumentationType delimiter) {
        return super.supports(delimiter);
    }

    @SuppressWarnings("Guava")
    private List<Parameter> readParameters(final OperationContext context) {
        List<ResolvedMethodParameter> methodParameters = context.getParameters();
        List<Parameter> parameters = new ArrayList();
        for (ResolvedMethodParameter methodParameter : methodParameters) {
            ResolvedType alternate = context.alternateFor(methodParameter.getParameterType());
            if (!shouldIgnore(methodParameter, alternate, context.getIgnorableParameterTypes())) {

                ParameterContext parameterContext = new ParameterContext(methodParameter,
                        new ParameterBuilder(),
                        context.getDocumentationContext(),
                        context.getGenericsNamingStrategy(),
                        context);

                List<Parameter> tempItems;

                if (shouldExpand(methodParameter, alternate)) {
                    tempItems = expander.expand(
                            new ExpansionContext("", alternate, context));
                } else {
                    tempItems = new ArrayList<>(Collections.singleton(pluginsManager.parameter(parameterContext)));
                }

                // 判断遍历 是否有自定义注解 有就进行操作
                Optional<ApiExclude> apiExcludeOptional = methodParameter.findAnnotation(ApiExclude.class);
                if (apiExcludeOptional.isPresent()) {
                    String[] properties = apiExcludeOptional.get().value();
                    tempItems = tempItems.stream().filter(parameter -> {

                        for (String property : properties) {
                            //匹配 黑名单 注意这里和x-easy大神的判断不一样
                            //去掉了 ||!parameter.getName().contains(Constants.MY_MODEL_NAME_PRE),
                            //测试中发现加了这个判断回导致query排除参数失效，这里是我dedug一步步发现的
                            if (property.equals(parameter.getName())|| parameter.getName().startsWith(property + ".")){
                                return false;
                            }
                        }
                        return true;
                    }).collect(Collectors.toList());
                    changed = true;
                }

                Optional<ApiInclude> apiIncludeOptional = methodParameter.findAnnotation(ApiInclude.class);
                if (apiIncludeOptional.isPresent()) {
                    String[] properties = apiIncludeOptional.get().value();
                    tempItems = tempItems.stream().filter(parameter -> {
                        for (String property : properties) {
                            //匹配 白名单
                            if (property.equals(parameter.getName())
                                    || parameter.getName().contains(Constants.MY_MODEL_NAME_PRE)
                                    || parameter.getName().startsWith(property + ".")
                            ) {
                                return true;
                            }
                        }
                        return false;
                    }).collect(Collectors.toList());
                    changed = true;
                }
                parameters.addAll(tempItems);
            }
        }

        return FluentIterable.from(parameters).filter(not(hiddenParams())).toList();
    }

    private Predicate<Parameter> hiddenParams() {
        return Parameter::isHidden;
    }

    private boolean shouldIgnore(
            final ResolvedMethodParameter parameter,
            ResolvedType resolvedParameterType,
            final Set<Class> ignorableParamTypes) {

        if (ignorableParamTypes.contains(resolvedParameterType.getErasedType())) {
            return true;
        }
        return FluentIterable.from(ignorableParamTypes)
                .filter(isAnnotation())
                .filter(parameterIsAnnotatedWithIt(parameter)).size() > 0;

    }

    private Predicate<Class> parameterIsAnnotatedWithIt(final ResolvedMethodParameter parameter) {
        return parameter::hasParameterAnnotation;
    }

    private Predicate<Class> isAnnotation() {
        return Annotation.class::isAssignableFrom;
    }

    private boolean shouldExpand(final ResolvedMethodParameter parameter, ResolvedType resolvedParamType) {
        return !parameter.hasParameterAnnotation(RequestBody.class)
                && !parameter.hasParameterAnnotation(RequestPart.class)
                && !parameter.hasParameterAnnotation(RequestParam.class)
                && !parameter.hasParameterAnnotation(PathVariable.class)
                && !isBaseType(typeNameFor(resolvedParamType.getErasedType()))
                && !enumTypeDeterminer.isEnum(resolvedParamType.getErasedType())
                && !isContainerType(resolvedParamType)
                && !isMapType(resolvedParamType);
    }
}

接口controller类


import com.ruoyi.common.annotation.ApiExclude;
import com.ruoyi.common.annotation.ApiInclude;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;

/**
 * @author 李永杰
 * @date 2021/10/14
 * @description 登录模块
 */
@Api(tags = "自定义参数测试模块")
@RestController
@RequestMapping("/test")
public class DemoController extends BaseController {

    @PostMapping("/testExcludeBody")
    @ApiOperation("body参数测试排除")
    public AjaxResult testExcludeBody(@ApiExclude({"a", "b"}) @RequestBody Demo demo) {

        return AjaxResult.success(demo);
    }

    @PostMapping("/testIncludeBody")
    @ApiOperation("body参数测试包含")
    public AjaxResult testIncludeBody(@ApiInclude({"a", "b"}) @RequestBody Demo demo) {
        return AjaxResult.success(demo);
    }

    @GetMapping("/testExcludeQuery")
    @ApiOperation("query参数测试排除")
    public AjaxResult testExcludeQuery(@ApiExclude({"a", "b"}) Demo demo) {
        return AjaxResult.success(demo);
    }

    @GetMapping("/testIncludeQuery")
    @ApiOperation("query参数测试包含")
    public AjaxResult testIncludeQuery(@ApiInclude({"a", "b"}) Demo demo) {
        return AjaxResult.success(demo);
    }
}

测试结果

body参数测试排除
body参数测试排除
query参数测试排除
query参数测试排除

body参数测试包含
body参数测试包含

query参数测试包含
query参数测试包含

参考文档

https://www.jianshu.com/p/09a4619fb0f7
https://blog.youkuaiyun.com/flymoringbird/article/details/102919322

swagger2 同一个实体用在多个不同的controller接口展示不同的字段
simon-_-的博客
10-17 2196
同一个实体用在多个不同的controller接口展示不同的字段，如果用过spring Validation校验框架应该都懂它里面有个分组概念，作用就是同一个实体用在多个接口里面但是校验参数不同，但swagger并没有分组概念，swagger显然做不到类似作用，ApiModelProperty注解的有个hidden属性，但这个作用只能要么全显示要么全隐藏，那下面的方法就是针对同一个实体在一个接口的某些属性是隐藏，在另一个接口中是显示的这种情况。
Swagger配置：扫描接口、开启Swagger、API文档分组、实体类API文档注释
weixin_44976835的博客
02-26 1639
配置要扫描哪些接口： 开启swagger服务 如果enable为false，则不能访问swagger-ui.html界面： 设置只有特定环境下开启swagger 设置只有生产环境才开启swagger服务，其他环境不开启：创建一个参数Environment环境监听器 然后将flag这个boolean类型参数传递给enable: 选择dev生产环境： 进入swagger-ui界面： 切换为test测试环境： 进入swagger-ui界面：进入失败 配置API文档的分组 每组扫描自己的包，多组协
Swagger配置生成实体类参数的接口信息
qq_31404603的博客
03-24 8114
记录整合Springboot与Swagger的时候遇到的如下问题， 这个错误大部分时候不会影响正常使用，但也有的时候会导致无法传参测试。 此处的问题主要原因是Swagger找不到你自己定义的实体类信息。所以你需要添加一个接口让Swagger能够找到你的实体类信息，这个时候需要加一个识别的接口。 @RestController public class SwaggerController...
webapi swagger配置实体类为参数输入框
爱生活爱敏敏的博客
07-24 2068
以前用过swagger的时候，当方法的参数是实体类或者类的时候，每个参数都是用输入框输入，所以个人觉得很方便，之后一直在找实现的这种方法，经过一段时间有所收获。 为进行配置之前 当以实体类为参数的时候，需要在右边进行编辑才能发送。 这是配置之后的，直接填写。 配置： 以上是.net版本的时候的配置，讲实话这种配置应该是能够封装起来的，个人实力不够，哈哈，希望大牛们指点一番。 ....
Swagger--分组 & 接口注释
天行健 君子以自强不息，地势坤 君子以厚德载物。
06-06 5656
1. Swagger--分组和接口注释及小结 1.1 配置分组 如果没有配置分组，默认是default。通过groupName()方法即可配置分组： groupName("group01") // 配置分组 SwaggerConfig.java /** * 配置docket以配置Swagger具体参数 */ @Bean public Docket docket(Environment environment) { return new Dock
Swagger中参数与实体类中参数不一样的原因
jiandan7410的博客
08-12 1001
@ApiModel("实体类名称") 可能原因是定义实体类的时候@ApiModel在多个类上有重复命名的。
ts2swagger：从TypeScript类创建Swagger API
02-03
从TypeScript类自动创建Swagger文档和Express端点。 工具支持 从TypeScript函数声明自动推断类型 为Express生成可调用的服务端点 将类，接口和方法以及JSDoc注释读入Swagger文档 使用TypeScript定义参数和返回值...
Swagger——【SpringBoot集成Swagger、配置Swagger、配置扫描接口、配置API分组】
2401_89191885的博客
01-12 807
select()// 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口。.select()// 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口。.select()// 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口。.enable(false) //配置是否启用Swagger，如果是false，在浏览器将无法访问。
Swagger
LBKのBlog
10-25 748
背景 在前后端分离开发的时代，前端和后端的实时交互(后端接口改变前端可以及时看到)，成为了一个主要问题之一，前后端沟通成本越来越高，前后端人员无法做到“即时协商”，最终导致问题爆发 以前的解决方案： 指定schema【计划提纲】，实时更新最新的API，降低集成的风险 制定word计划文档 前后端分离： 前端测试后端接口，工具:postman 后端提供接口，需要实时更新最新的消息及改动 简介 号称世界上最流行的API框架 是一套开源的框架 RestFul Api文档在线自动生成工具 >
Springboot接收参数为实体时，swagger参数注释，@RequestBody 写法
qq_41594380的博客
07-20 1620
Springboot接收参数为实体时，swagger参数注释，@RequestBody 写法
springboot集成swagger2 API文档 接口方法一目了然 参数/返回类型基本数据类型/实体类类型 后续美化swagger UI
王sir的博客
07-16 4227
1构建springboot项目(自行百度,灰常简单) 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> ...
Swagger使用————接口参数注解的使用缺陷
热门推荐
Morty的技术乐园
05-08 7万+
问题描述在使用springboot开发web项目时，用到了swagger框架，来生成web api文档。但是其中有一项是举例说明参数的结构，如下图：但是，这个功能真的是非常方便，因为可以让前端开发人员第一时间得知参数的内部结构是什么样的，这尤其适用于那些json体结构的参数。网上的例子都是这样的：但是，我无论如何都弄不出来这个样子，前前后后研究了有好几个小时。终于找出了问题。问题原因网上的api接...
Swagger 笔记
qq_36733713的博客
04-30 449
Swagger 笔记 了解Swagger的概念及作用 掌握在项目中集成Swagger自动生成API文档 Swagger简介 前后端分离 前端 -> 前端控制层data、视图层 后端 -> 后端控制层、服务层、数据访问层 前后端通过API进行交互 前后端相对独立且松耦合（可部署在不同服务器） 产生一个问题： 前后端集成，前端或者后端无法做到“及时协商，尽早解决”，最终导致问题集...
Java使用swagger时显示实体类注解问题
老码农的博客
04-28 1万+
第一步，在实体类中@ApiModel(description= “表名描述”) 第二步，在字段属性中@ApiModelProperty(value = “字段备注”) 第三步，在controller中必须增加泛型属性，否则不会显示备注，例如： @RequestMapping(value = “/getAllPosition”, method = RequestMethod.GET) @Respon...
swagger参数注解，后台使用@RequestBody注解的实体类，但只需要传实体类中的一个属性
魑魅魍魉
10-31 5万+
一开始是这个样子的 @ApiOperation(value = "删除用户", notes = "根据用户名删除指定用户", httpMethod = "POST") @ApiImplicitParam( name = "username", value = "用户的用户名", required = true, dataType="String" ) @ApiResponses({...
Spring 注解面面通 之 @RequestParam参数绑定源码解析
键盘上流淌的日子
12-05 4931
  Spring MVC中使用HandlerMethodArgumentResolver策略接口来定义处理器方法参数解析器，@RequestParam使用的是RequestParamMapMethodArgumentResolver和RequestParamMethodArgumentResolver，接下来一起来深入了解一下其源码实现。   类结构   类解析   HandlerMethodArgumentResolver和AbstractNamedValueMethodArgumentResolve
Swagger配置个人接口信息注解和分组操作
CSNZのBlog
08-28 505
续上篇Swagger博文… 对API文档进行分组 如何配置多个分组，配置多个Docket实例即可 显示实体类 新建实体类 如果未显示User的属性， 是否你的访问修饰符为private 如果是的话提供get和set构造器也可以实现 如何给实体类加注释呢？ 访问 我们测试一下 给api接口方法做注释 执行结果： Swagger小结： 1、我们可以通过Swagger 给一些比较难理解的属性或接口，增加注释信息 2、接口文档实时更新 3、可以在线测试 ...
swagger隐藏实体类字段_swagger基本使用
weixin_42510717的博客
01-06 7592
关于 SwaggerSwagger能成为最受欢迎的REST APIs文档生成工具之一，有以下几个原因：mSwagger 可以生成一个具有互动性的API控制台，开发者可以用来快速学习和尝试API。Swagger 可以生成客户端SDK代码用于各种不同的平台上的实现。Swagger 文件可以在许多不同的平台上从代码注释中自动生成。Swagger 有一个强大的社区，里面有许多强悍的贡献者。Sw...
关于使用Swagger-ui时文档显示实体类中隐藏部分字段的问题
m0_49316283的博客
03-24 2905
关于使用Swagger-ui时文档显示实体类中隐藏部分字段的问题 所遇到的问题： 在swagger-ui测试页面测试接口时，由于在实体类中添加部分临时的实体类导致测试文档过于冗杂 解决： pom.xml添加依赖： <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version&gt
knife4j实体类显示
最新发布
01-15
### Knife4j 中实体类显示的方法与配置 为了确保在使用 Knife4j 时能够正确展示实体类的信息，需要遵循特定的配置方式。这不仅涉及到项目中的依赖管理，还包括具体的注解应用以及配置文件设置。 #### 添加必要的 Maven 或 Gradle 依赖 对于不同版本的 Spring Boot 应用程序，应当选择合适的 Knife4j 版本来匹配使用的 Spring Boot 和 Swagger 的组合[^1]： ```xml <!-- 对于Spring Boot 2.x --> <dependency> <groupId>com.github.xiaoymin</groupId> <artifactId>knife4j-spring-boot-starter</artifactId> <version>${knife4j.version}</version> </dependency> ``` #### 使用 `@ApiModelProperty` 注解描述字段 为了让 API 文档更清晰地反映实体结构，在定义 Java Bean 类时可以利用 `io.swagger.annotations.ApiModelProperty` 来标注各个属性的意义及其约束条件[^3]： ```java import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModelProperty; @ApiModel(description="用户信息") public class User { @ApiModelProperty(value = "用户名", required=true) private String username; @ApiModelProperty(value = "密码", hidden=true) // 不对外暴露此参数 private String password; } ``` 上述代码片段展示了如何通过 `@ApiModelProperty` 设置字段级别的元数据，比如是否必填(`required`)、默认值(`example`)等特性，并且可以通过 `hidden` 参数控制某些敏感信息不在API文档中公开。 #### 启用全局扫描并自定义扩展插件 除了单个模型上的注释外，还需要激活整个应用程序范围内的接口扫描机制以便自动收集所有被标记过的资源路径和服务操作。通常是在主启动类上添加如下配置项[^2]： ```yaml springfox: documentation: swagger-ui: enabled: true openapi: v3: path: /v3/api-docs ``` 同时可以在 `application.properties` 文件里指定更多个性化选项，例如启用分组视图等功能以适应复杂的多模块架构需求。 ---
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值