如何使用多个 yaml 文件生成 openAPI 代码

Question

我有两个yaml文件，customer.yaml和employee.yaml。如何在单个项目中从这两个yaml文件生成java代码。我正在使用 gradle，我知道单个 yaml 的任务规范，但我如何指定多个 yaml。我应该在单个 openApiGenerator 下指定多个输入规范吗？如果是，那么这样做的确切语法是什么。下面是我在build.gradle文件中的openApiGenerator任务。

``
openApiGenerate {
generatorName = "spring"
apiPackage = "com.xxx.generated.controller"
modelPackage = "com.xxx.generated.model"
inputSpec = "$rootDir//schema/employee.yaml".toString()
outputDir = "$rootDir/generated".toString()
configOptions = [
dateLibrary: "java8"
]
systemProperties = [
invoker : "false", 
generateSupportingFiles: "true"
]
additionalProperties = [
interfaceOnly : "true",
]
}
``

我听说过openApiGenerators任务，它列出了通过Open API生成器可用的生成器，但找不到使用它的方法。

Answer 1

我成功地为您项目中的每个 yaml 文件动态创建任务。我正在使用 gradle 4.8.1，但我认为这也适用于下一个版本。

import groovy.io.FileType
import org.openapitools.generator.gradle.plugin.tasks.GenerateTask
plugins {
id "org.openapi.generator" version "4.1.3"
}
//here we are going to store swagger files
def swaggerList = []
//iteration by swagger file root folder and save into swaggerList variable
def dir = new File("$rootDir/src/main/resources/api/".toString())
dir.eachFileRecurse(FileType.FILES) { file ->
if (file.getName().endsWith(".yaml"))
swaggerList << file
}
// Iterate on all swagger files and generate a task for each one with the nomenclature openApiGenerate + swagger name
swaggerList.each {
println it.path
def apiName = it.getName().replace(".yaml", "");
tasks.create("openApiGenerate" + apiName.capitalize(), GenerateTask.class, {
generatorName = "jaxrs-spec"
inputSpec = "$rootDir/src/main/resources/api/".toString() + "${apiName}.yaml"
outputDir = "$buildDir/generated/openapi".toString()
apiPackage = "my.package.rest.api.definition.".toString() + "${apiName}"
modelPackage = "my.package.rest.api.model.".toString() + "${apiName}"
templateDir = "$rootDir/src/main/resources/api/templates".toString()
//    https://github.com/OpenAPITools/openapi-generator/blob/master/docs/generators/jaxrs-spec.md
configOptions = [
dateLibrary: "java8",
java8: true,
useBeanValidation: true,
interfaceOnly: true,
useOptional: true,
useLombok: true
]
})
}
sourceSets {
main {
java {
srcDir("$buildDir/generated/openapi/src/gen/java")
srcDir("$buildDir/generated/openapi/src/main/java")
}
}
}

在此之后，如果我有一个名为login.yaml的招摇文件和其他命名user.yaml user.yaml，我调用下一个gradle任务：

gradle openApiGenerateLogin

或

gradle openApiGenerateUser

Answer 2

在build.gradle中添加了以下代码，我能够生成java代码。复制架构文件夹下的spec1和spec2 yaml文件。此外，您需要在build.gradle中配置openApi插件和依赖项。

task buildPaymentClient(type: org.openapitools.generator.gradle.plugin.tasks.GenerateTask){
generatorName = "spring"
inputSpec = "$rootDir//schema/spec1.yaml".toString()
outputDir = "$rootDir/generated".toString()
apiPackage = "com.abc.code.generated.controller"
modelPackage = "com.abc.code.generated.model"
configOptions = [
dateLibrary: "java8"
]
systemProperties = [
invoker : "false", 
generateSupportingFiles: "true"
]
additionalProperties = [
interfaceOnly : "true",
]
}

openApiGenerate {
generatorName = "spring"
apiPackage = "com.abc.code.generated.controller"
modelPackage = "com.abc.code.generated.model"
inputSpec = "$rootDir//schema/spec2.yaml".toString()
outputDir = "$rootDir/generated".toString()
configOptions = [
dateLibrary: "java8"
]
systemProperties = [
invoker : "false", 
generateSupportingFiles: "true"
]
additionalProperties = [
interfaceOnly : "true",
]
}
compileJava.dependsOn buildPaymentClient, tasks.openApiGenerate 

Answer 3

在我的情况下，我使用相同的任务选项和具有不同规范 yml 文件名的 ony，所以这是我的解决方案：

假设您有 2 个大摇大摆的 yml 文件：

src/

• main/resources/swagger/api1.yml
src/
• main/resources/swagger/api2.yml

然后：

swagger.gradle：

buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath "org.openapitools:openapi-generator-gradle-plugin:${openapiPluginDependencyVersion}"
}
}
apply plugin: "org.openapi.generator"
void createOpenApiGenerateTask(String ymlName) {
String taskName = "openApiGenerate_" + ymlName;
task(taskName, type: org.openapitools.generator.gradle.plugin.tasks.GenerateTask) {
inputSpec = "$rootDir/src/main/resources/swagger/${ymlName}.yml".toString()
// other common task options goes here...
// e.g.
// outputDir = "$buildDir/openapi".toString()
// apiPackage = "com.example.api"
// ...
}
compileJava.dependsOn(taskName)
}
String[] ymlNames = [
"api1",
"api2"
]
for (String ymlName : ymlNames) {
createOpenApiGenerateTask(ymlName);
}
sourceSets {
main {
java {
srcDir file("${project.buildDir.path}/openapi/src/main/java")
}
}
}

gradle.properties：

openapiPluginDependencyVersion=4.3.0

build.gradle：

apply from: "gradle/swagger.gradle"

Answer 4

同样的问题在这里，不同的解决方案。我真的很喜欢在单独的文件中工作的想法，但是，在开发团队中共享规范或将其导入邮递员、失眠或某些 API 网关等工具时，单个文件确实更加准确和简单。

因此，我想建议使用此任务使用openapi-merger-plugin。它就像一个魅力。

这是我解决这个问题的方法：

// Merging all OpenAPI Files
openApiMerger {
inputDirectory.set(file("${rootDir}/src/main/resources/api/".toString()))
output {
directory.set(file("${buildDir}/generated/openapi/".toString()))
fileName.set("openapi")
fileExtension.set("yaml")
}
openApi {
openApiVersion.set("3.0.1")
info {
title.set("Open API Merger")
description.set("All files merged by open api merger")
version.set("${project.version}".toString())
termsOfService.set("http://openapimerger.com/terms-of-service")
contact {
name.set("OpenApiMerger Team")
email.set("[e-mail]")
url.set("http://openapimerger.com")
}
license {
name.set("Apache License v2.0")
url.set("http://apache.org/v2")
}
}
externalDocs {
description.set("External docs description")
url.set("http://external-docs.com/uri")
}
}
}
// Generating code only once
openApiGenerate {
generatorName   = "spring"
inputSpec       = "${buildDir}/generated/openapi/openapi.yaml"
outputDir       = "${buildDir}/generated/openapi"
packageName     = "com.xxx.generated"
apiPackage      = "com.xxx.generated.controller"
modelPackage    = "com.xxx.generated.model"
modelNameSuffix = ""
validateSpec    = true
configOptions   = [
dateLibrary         : "java8",
interfaceOnly       : "true",
swaggerDocketConfig : "false"
]
}
// Making generated source visible (classpath)
sourceSets {
main {
java {
srcDir "${buildDir}/generated/openapi/src/main/java"
}
}
}
// Integrating plugin tasks with compiling
tasks.openApiGenerate {
dependsOn  tasks.mergeOpenApiFiles
}
compileJava {
dependsOn  tasks.openApiGenerate
source "${buildDir}/generated/openapi/src/main/java"
}

Answer 5

以下内容对我有用，将其添加到build.gradle.kts中：

val openapiSpecs = mapOf(
"api1" to "src/main/resources/openapi/api1.yml",
"api2" to "src/main/resources/openapi/api2.yml"
)
openapiSpecs.forEach {
tasks.create("openApiGenerate-${it.key}", org.openapitools.generator.gradle.plugin.tasks.GenerateTask::class) {
generatorName.set("kotlin")
inputSpec.set("$rootDir/${it.value}")
outputDir.set("$buildDir/generated/openapi")
apiPackage.set("my.company.service.openapi")
modelPackage.set("my.company.domain.openapi.${it.key}")
configOptions.set(mapOf(
"dateLibrary" to "java8"
))
sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).java.srcDir("$buildDir/generated/openapi/src")
}
}
tasks.register("openApiGenerateAll") { dependsOn(openapiSpecs.keys.map { "openApiGenerate-$it" }) } 

然后gradle openApiGenerateAll将生成一切。