maven project integration swagger3 generate openapi files in json and yaml format

summarize

unmixedmavenProject integration swagger3, project according to swagger3API definition specification definition api interface, by scanning the package path to generate json oryamlformat, which can be used for front-end presentations.

pom dependencies

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="/POM/4.0.0"
         xmlns:xsi="http:///2001/XMLSchema-instance"
         xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.">
    <modelVersion>4.0.0</modelVersion>

    <groupId></groupId>
    <artifactId>swagger3-generate-file</artifactId>
    <version>1.0-SNAPSHOT</version>


    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId></groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <!-- /artifact/.v3/swagger-jaxrs2 -->
        <dependency>
            <groupId>.v3</groupId>
            <artifactId>swagger-jaxrs2</artifactId>
            <version>2.1.11</version>
        </dependency>

        <dependency>
            <groupId></groupId>
            <artifactId>-api</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId></groupId>
            <artifactId>-api</artifactId>
            <version>3.1.0</version>
        </dependency>

        <dependency>
            <groupId></groupId>
            <artifactId>plexus-utils</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId></groupId>
            <artifactId>maven-plugin-api</artifactId>
            <version>3.3.9</version>
        </dependency>
        <dependency>
            <groupId>.v3</groupId>
            <artifactId>swagger-integration</artifactId>
            <version>2.1.11</version>
        </dependency>

        <dependency>
            <groupId></groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.10.1</version>
        </dependency>

        <dependency>
            <groupId></groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.10.1</version>
        </dependency>

        <dependency>
            <groupId></groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.10.1</version>
        </dependency>
    </dependencies>

</project>

ApiResource

package ;

import ;
import .;
import .;
import .;
import .;
import .;

import ;
import ;
import ;
import ;

@Path("/students")
public class StudentResource {

    @GET
    @Path("/getStudentById/{student_id}")
    @Operation(summary = "according toidAccess to student information",
    tags = {"students"})
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200",content = @Content(mediaType = "application/json",schema = @Schema(implementation = )),description = "Successful query"),
            @ApiResponse(responseCode = "404",description = "Students do not exist")


    })
    public StudentDTO getStudentById(@PathParam("student_id") Long studentId){
        return new StudentDTO();
    }

    @GET
    @Path("/listStudents")
    @Operation(summary = "Query Student List",
            tags = {"students"})
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200",content = @Content(mediaType = "application/json",schema = @Schema(implementation = )),description = "Successful query"),
    })

    public StudentDTO listStudents(@QueryParam("pageNo") Integer pageNo,
                                   @QueryParam("pageSize")Integer pageSize,
                                   @QueryParam("name") String name){
        return new StudentDTO();
    }

}

openapi basic information configuration file()

openapi: 3.0.1
info.
  title: Student API
  description: Student API documentation
  contact.
    email: 13928121916@
  version: "1.1"

Document Generation Class

package ;

import ;
import ;
import .;
import .;
import .;
import .;
import .v3.;
import .;
import .;
import .;
import .;
import .slf4j.Slf4j;
import .;
import ;
import ;
import ;
import ;

import ;
import ;
import ;
import ;
import ;
import ;
import .*;
import ;

import static ;


@Slf4j
public class GenerateOpenApiFileTest {

    private static String encoding = "UTF-8";
    private SwaggerConfiguration config;
    private String contextId;
    private String filterClass;
    private String outputPath  = "src/test/resources";
    //Packages that need to be scanned to generate files
    private Set<String> resourcePackages ;
    private enum Format {JSON,YAML,JSONANDYAML}
    //Name of the generated file
    private String outputFileName="generateopenapi";
    //Format of generated documents
    private Format outputFormat = ;
    private Boolean  prettyPrint;

    private Boolean sortOutput;

    private Boolean alwaysResolveAppPath;
    private Boolean readAllResources;


    @Test
    public void createOpenApiFile() throws MojoFailureException {
        String baseInfoPath = "src/main/resources/";
        resourcePackages = new HashSet<>();
        ("");

        Optional<OpenAPI> openapiInput = readStructuredDataFromFile(baseInfoPath, , "openapiFilePath");
        config = mergeConfig((null),new SwaggerConfiguration());

        setDefaultsIfMissing(config);

        JaxrsOpenApiContextBuilder builder = new JaxrsOpenApiContextBuilder<>().openApiConfiguration(config);
        if((contextId)){
            (contextId);
        }
        OpenApiContext context = null;
        try {
            context = (true);
            OpenAPI openAPI = ();
            //Filtering of documents that do not need to be generatedclass
            if((())){
                try {
                    OpenAPISpecFilter filterImpl = (OpenAPISpecFilter) ().getClassLoader().loadClass(()).newInstance();
                    SpecFilter f = new SpecFilter();
                    openAPI = (openAPI, filterImpl, new HashMap<>(), new HashMap<>(),
                            new HashMap<>());
                } catch (Exception e) {
                    ( "Error applying filter to API specification" , e);
                    throw new MojoExecutionException("Error applying filter to API specification: " + (), e);
                }
            }
            String openapiJson = null;
            String openapiYaml = null;
            if ((outputFormat) || (outputFormat)) {
                if (() != null && ()) {
                    openapiJson = ().writer(new DefaultPrettyPrinter()).writeValueAsString(openAPI);
                } else {
                    openapiJson = ().writeValueAsString(openAPI);
                }
            }
            if ((outputFormat) || (outputFormat)) {
                if (() != null && ()) {
                    openapiYaml = ().writer(new DefaultPrettyPrinter()).writeValueAsString(openAPI);
                } else {
                    openapiYaml = ().writeValueAsString(openAPI);
                }
            }
            Path path = (outputPath, "temp");
            final File parentFile = ().getParentFile();
            if (parentFile != null) {
                ();
            }

            if (openapiJson != null) {
                path = (outputPath, outputFileName + ".json");
                (path, ((encoding)));
                ( "JSON output: " + ().getCanonicalPath());
            }
            if (openapiYaml != null) {
                path = (outputPath, outputFileName + ".yaml");
                (path, ((encoding)));
                ( "YAML output: " + ().getCanonicalPath());
            }

        } catch (OpenApiConfigurationException | MojoExecutionException | JsonProcessingException e) {
            ();
        } catch (IOException e) {
            ();
        }


    }
    private void setDefaultsIfMissing(SwaggerConfiguration config) {

        if (prettyPrint == null) {
            prettyPrint = ;
        }
        if (readAllResources == null) {
            readAllResources = ;
        }
        if (sortOutput == null) {
            sortOutput = ;
        }
        if (alwaysResolveAppPath == null) {
            alwaysResolveAppPath = ;
        }
        if (() == null) {
            (prettyPrint);
        }
        if (() == null) {
            (readAllResources);
        }
        if (() == null) {
            (sortOutput);
        }
        if (() == null) {
            (alwaysResolveAppPath);
        }
    }
    private SwaggerConfiguration mergeConfig(OpenAPI openAPIInput, SwaggerConfiguration config) {
        // overwrite all settings provided by other maven config
        if ((filterClass)) {
            (filterClass);
        }
        /*if (isCollectionNotBlank(ignoredRoutes)) {
            (ignoredRoutes);
        }*/
        if (prettyPrint != null) {
            (prettyPrint);
        }
        if (sortOutput != null) {
            (sortOutput);
        }
        if (alwaysResolveAppPath != null) {
            (alwaysResolveAppPath);
        }
        if (readAllResources != null) {
            (readAllResources);
        }
      /*  if ((readerClass)) {
            (readerClass);
        }
        if ((scannerClass)) {
            (scannerClass);
        }
        if (isCollectionNotBlank(resourceClasses)) {
            (resourceClasses);
        }*/
        if (openAPIInput != null) {
            (openAPIInput);
        }
        if (isCollectionNotBlank(resourcePackages)) {
            (resourcePackages);
        }
        /*if ((objectMapperProcessorClass)) {
            (objectMapperProcessorClass);
        }
        if (isCollectionNotBlank(modelConverterClasses)) {
            (modelConverterClasses);
        }*/

        return config;
    }
    private boolean isCollectionNotBlank(Collection<?> collection) {
        return collection != null && !();
    }

    /**
     * Read the content of given file as either json or yaml and maps it to given class
     *
     * @param filePath    to read content from
     * @param outputClass to map to
     * @param configName  for logging, what user config will be read
     * @param <T>         mapped type
     * @return empty optional if not path was given or the file was empty, read instance otherwis
     * @throws MojoFailureException if given path is not file, could not be read or is not proper json or yaml
     */
    private <T> Optional<T> readStructuredDataFromFile(String filePath, Class<T> outputClass, String configName)
            throws MojoFailureException {
        try {
            // ignore if config is not provided
            if ((filePath)) {
                return ();
            }

            Path pathObj = (filePath);

            // if file does not exist or is not an actual file, finish with error
            if (!().exists() || !().isFile()) {
                throw new IllegalArgumentException(
                        format("passed path does not exist or is not a file: '%s'", filePath));
            }

            String fileContent = new String((pathObj), encoding);

            // if provided file is empty, log warning and finish
            if ((fileContent)) {
                (format("It seems that file '%s' defined in config %s is empty",
                        (), configName));
                return ();
            }

            // get mappers in the order based on file extension
            List<BiFunction<String, Class<T>, T>> mappers = getSortedMappers(pathObj);

            T instance = null;
            Throwable caughtEx = null;

            // iterate through mappers and see if one is able to parse
            for (BiFunction<String, Class<T>, T> mapper : mappers) {
                try {
                    instance = (fileContent, outputClass);
                    break;
                } catch (Exception e) {
                    caughtEx = e;
                }
            }

            // if no mapper could read the content correctly, finish with error
            if (instance == null) {
                if (caughtEx == null) {
                    caughtEx = new IllegalStateException("undefined state");
                }
                (format("Could not read file '%s' for config %s", (), configName), caughtEx);
                throw new IllegalStateException((), caughtEx);
            }

            return (instance);
        } catch (Exception e) {
            (format("Error reading/deserializing config %s file", configName), e);
            throw new MojoFailureException((), e);
        }
    }

    /**
     * Get sorted list of mappers based on given filename.
     * <p>
     * Will sort the 2 supported mappers: json and yaml based on what file extension is used.
     *
     * @param pathObj to get extension from.
     * @param <T>     mapped type
     * @return list of mappers
     */
    private <T> List<BiFunction<String, Class<T>, T>> getSortedMappers(Path pathObj) {
        String ext = (());
        boolean yamlPreferred = false;
        if (("yaml") || ("yml")) {
            yamlPreferred = true;
        }

        List<BiFunction<String, Class<T>, T>> list = new ArrayList<>(2);

        ((content, typeClass) -> {
            try {
                return ().readValue(content, typeClass);
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }
        });
        ((content, typeClass) -> {
            try {
                return ().readValue(content, typeClass);
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }
        });

        if (yamlPreferred) {
            (list);
        }

        return (list);
    }

}

Demo project gitee address
References.
/swagger-api/swagger-core/blob/master/modules/swagger-maven-plugin/src/main/java/io/swagger/v3/plugin/maven/