google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
OpenAPI Code Generator in Java
awiskar acharya
November 10, 2025
11:50 am

Project Overview

A comprehensive OpenAPI/Swagger code generator that creates client SDKs, server stubs, and documentation from OpenAPI specifications. Supports multiple languages and frameworks with extensible templates.

Technology Stack

  • Core: Java 17+
  • OpenAPI Parsing: Swagger Parser
  • Template Engine: FreeMarker
  • Code Analysis: JavaParser
  • Build Tools: Maven/Gradle integration
  • Validation: JSON Schema Validator
  • Testing: JUnit 5, Mockito

Project Structure

openapi-codegen/ ├── src/main/java/com/openapicodegen/ │ ├── core/ │ ├── generator/ │ ├── model/ │ ├── template/ │ ├── support/ │ ├── cli/ │ └── config/ ├── src/main/resources/templates/ │ ├── java/ │ ├── typescript/ │ ├── python/ │ └── go/ ├── generated-examples/ └── config/

Core Implementation

1. Data Models

package com.openapicodegen.model; import io.swagger.v3.oas.models.OpenAPI; import io.swagger.v3.oas.models.Operation; import io.swagger.v3.oas.models.PathItem; import io.swagger.v3.oas.models.parameters.Parameter; import io.swagger.v3.oas.models.media.Schema; import io.swagger.v3.oas.models.headers.Header; import java.util.*; public class CodeGenConfig { private String outputDir = "generated"; private String packageName; private String apiPackage; private String modelPackage; private String invokerPackage; private String groupId; private String artifactId; private String artifactVersion; private String library; private boolean generateApis = true; private boolean generateModels = true; private boolean generateSupportingFiles = true; private boolean useBeanValidation = false; private boolean useOptional = false; private boolean useRxJava = false; private boolean useSwaggerAnnotations = true; private Map<String, Object> additionalProperties = new HashMap<>(); private Set<String> importMappings = new HashSet<>(); private Set<String> typeMappings = new HashSet<>(); private Set<String> languageSpecificPrimitives = new HashSet<>(); // Constructors public CodeGenConfig() {} public CodeGenConfig(String packageName) { this.packageName = packageName; this.apiPackage = packageName + ".api"; this.modelPackage = packageName + ".model"; this.invokerPackage = packageName + ".invoker"; } // Builder pattern public static class Builder { private CodeGenConfig config = new CodeGenConfig(); public Builder outputDir(String outputDir) { config.outputDir = outputDir; return this; } public Builder packageName(String packageName) { config.packageName = packageName; config.apiPackage = packageName + ".api"; config.modelPackage = packageName + ".model"; config.invokerPackage = packageName + ".invoker"; return this; } public Builder groupId(String groupId) { config.groupId = groupId; return this; } public Builder artifactId(String artifactId) { config.artifactId = artifactId; return this; } public Builder artifactVersion(String artifactVersion) { config.artifactVersion = artifactVersion; return this; } public Builder useBeanValidation(boolean useBeanValidation) { config.useBeanValidation = useBeanValidation; return this; } public Builder useOptional(boolean useOptional) { config.useOptional = useOptional; return this; } public Builder additionalProperty(String key, Object value) { config.additionalProperties.put(key, value); return this; } public CodeGenConfig build() { return config; } } // Getters and Setters public String getOutputDir() { return outputDir; } public void setOutputDir(String outputDir) { this.outputDir = outputDir; } public String getPackageName() { return packageName; } public void setPackageName(String packageName) { this.packageName = packageName; } public String getApiPackage() { return apiPackage; } public void setApiPackage(String apiPackage) { this.apiPackage = apiPackage; } public String getModelPackage() { return modelPackage; } public void setModelPackage(String modelPackage) { this.modelPackage = modelPackage; } public String getInvokerPackage() { return invokerPackage; } public void setInvokerPackage(String invokerPackage) { this.invokerPackage = invokerPackage; } public String getGroupId() { return groupId; } public void setGroupId(String groupId) { this.groupId = groupId; } public String getArtifactId() { return artifactId; } public void setArtifactId(String artifactId) { this.artifactId = artifactId; } public String getArtifactVersion() { return artifactVersion; } public void setArtifactVersion(String artifactVersion) { this.artifactVersion = artifactVersion; } public String getLibrary() { return library; } public void setLibrary(String library) { this.library = library; } public boolean isGenerateApis() { return generateApis; } public void setGenerateApis(boolean generateApis) { this.generateApis = generateApis; } public boolean isGenerateModels() { return generateModels; } public void setGenerateModels(boolean generateModels) { this.generateModels = generateModels; } public boolean isGenerateSupportingFiles() { return generateSupportingFiles; } public void setGenerateSupportingFiles(boolean generateSupportingFiles) { this.generateSupportingFiles = generateSupportingFiles; } public boolean isUseBeanValidation() { return useBeanValidation; } public void setUseBeanValidation(boolean useBeanValidation) { this.useBeanValidation = useBeanValidation; } public boolean isUseOptional() { return useOptional; } public void setUseOptional(boolean useOptional) { this.useOptional = useOptional; } public boolean isUseRxJava() { return useRxJava; } public void setUseRxJava(boolean useRxJava) { this.useRxJava = useRxJava; } public boolean isUseSwaggerAnnotations() { return useSwaggerAnnotations; } public void setUseSwaggerAnnotations(boolean useSwaggerAnnotations) { this.useSwaggerAnnotations = useSwaggerAnnotations; } public Map<String, Object> getAdditionalProperties() { return additionalProperties; } public void setAdditionalProperties(Map<String, Object> additionalProperties) { this.additionalProperties = additionalProperties; } public Set<String> getImportMappings() { return importMappings; } public void setImportMappings(Set<String> importMappings) { this.importMappings = importMappings; } public Set<String> getTypeMappings() { return typeMappings; } public void setTypeMappings(Set<String> typeMappings) { this.typeMappings = typeMappings; } public Set<String> getLanguageSpecificPrimitives() { return languageSpecificPrimitives; } public void setLanguageSpecificPrimitives(Set<String> languageSpecificPrimitives) { this.languageSpecificPrimitives = languageSpecificPrimitives; } }

2. OpenAPI Model Extractor

package com.openapicodegen.model; import io.swagger.v3.oas.models.OpenAPI; import io.swagger.v3.oas.models.Operation; import io.swagger.v3.oas.models.PathItem; import io.swagger.v3.oas.models.parameters.Parameter; import io.swagger.v3.oas.models.media.Schema; import io.swagger.v3.oas.models.headers.Header; import io.swagger.v3.parser.OpenAPIV3Parser; import io.swagger.v3.parser.core.models.ParseOptions; import java.util.*; import java.util.stream.Collectors; public class OpenAPIExtractor { private final OpenAPI openAPI; public OpenAPIExtractor(OpenAPI openAPI) { this.openAPI = openAPI; } public static OpenAPIExtractor fromFile(String filePath) { ParseOptions options = new ParseOptions(); options.setResolve(true); options.setResolveFully(true); OpenAPI openAPI = new OpenAPIV3Parser().read(filePath, null, options); if (openAPI == null) { throw new IllegalArgumentException("Invalid OpenAPI specification: " + filePath); } return new OpenAPIExtractor(openAPI); } public static OpenAPIExtractor fromContent(String content) { ParseOptions options = new ParseOptions(); options.setResolve(true); options.setResolveFully(true); OpenAPI openAPI = new OpenAPIV3Parser().readContents(content, null, options).getOpenAPI(); if (openAPI == null) { throw new IllegalArgumentException("Invalid OpenAPI specification content"); } return new OpenAPIExtractor(openAPI); } public List<ApiOperation> extractOperations() { List<ApiOperation> operations = new ArrayList<>(); if (openAPI.getPaths() == null) { return operations; } openAPI.getPaths().forEach((path, pathItem) -> { extractOperationsFromPathItem(path, pathItem, operations); }); return operations; } private void extractOperationsFromPathItem(String path, PathItem pathItem, List<ApiOperation> operations) { if (pathItem.getGet() != null) { operations.add(createApiOperation(path, "GET", pathItem.getGet())); } if (pathItem.getPost() != null) { operations.add(createApiOperation(path, "POST", pathItem.getPost())); } if (pathItem.getPut() != null) { operations.add(createApiOperation(path, "PUT", pathItem.getPut())); } if (pathItem.getDelete() != null) { operations.add(createApiOperation(path, "DELETE", pathItem.getDelete())); } if (pathItem.getPatch() != null) { operations.add(createApiOperation(path, "PATCH", pathItem.getPatch())); } if (pathItem.getHead() != null) { operations.add(createApiOperation(path, "HEAD", pathItem.getHead())); } if (pathItem.getOptions() != null) { operations.add(createApiOperation(path, "OPTIONS", pathItem.getOptions())); } } private ApiOperation createApiOperation(String path, String httpMethod, Operation operation) { ApiOperation apiOperation = new ApiOperation(); apiOperation.setPath(path); apiOperation.setHttpMethod(httpMethod); apiOperation.setOperationId(operation.getOperationId()); apiOperation.setSummary(operation.getSummary()); apiOperation.setDescription(operation.getDescription()); apiOperation.setTags(operation.getTags()); apiOperation.setDeprecated(operation.getDeprecated() != null && operation.getDeprecated()); // Extract parameters if (operation.getParameters() != null) { List<ApiParameter> parameters = operation.getParameters().stream() .map(this::mapParameter) .collect(Collectors.toList()); apiOperation.setParameters(parameters); } // Extract responses if (operation.getResponses() != null) { Map<String, ApiResponse> responses = new HashMap<>(); operation.getResponses().forEach((code, response) -> { responses.put(code, mapResponse(code, response)); }); apiOperation.setResponses(responses); } return apiOperation; } private ApiParameter mapParameter(Parameter parameter) { ApiParameter apiParam = new ApiParameter(); apiParam.setName(parameter.getName()); apiParam.setIn(parameter.getIn()); apiParam.setRequired(parameter.getRequired() != null && parameter.getRequired()); apiParam.setDescription(parameter.getDescription()); apiParam.setSchema(parameter.getSchema()); apiParam.setStyle(parameter.getStyle()); apiParam.setExplode(parameter.getExplode()); return apiParam; } private ApiResponse mapResponse(String code, io.swagger.v3.oas.models.responses.ApiResponse response) { ApiResponse apiResponse = new ApiResponse(); apiResponse.setCode(code); apiResponse.setDescription(response.getDescription()); if (response.getHeaders() != null) { Map<String, ApiHeader> headers = new HashMap<>(); response.getHeaders().forEach((name, header) -> { headers.put(name, mapHeader(name, header)); }); apiResponse.setHeaders(headers); } if (response.getContent() != null && !response.getContent().isEmpty()) { // Get the first media type (usually application/json) var mediaType = response.getContent().values().iterator().next(); apiResponse.setSchema(mediaType.getSchema()); } return apiResponse; } private ApiHeader mapHeader(String name, Header header) { ApiHeader apiHeader = new ApiHeader(); apiHeader.setName(name); apiHeader.setDescription(header.getDescription()); apiHeader.setSchema(header.getSchema()); apiHeader.setRequired(header.getRequired() != null && header.getRequired()); return apiHeader; } public List<ApiModel> extractModels() { List<ApiModel> models = new ArrayList<>(); if (openAPI.getComponents() == null || openAPI.getComponents().getSchemas() == null) { return models; } openAPI.getComponents().getSchemas().forEach((name, schema) -> { models.add(createApiModel(name, schema)); }); return models; } private ApiModel createApiModel(String name, Schema schema) { ApiModel model = new ApiModel(); model.setName(name); model.setSchema(schema); model.setDescription(schema.getDescription()); model.setType(schema.getType()); model.setFormat(schema.getFormat()); // Extract properties if (schema.getProperties() != null) { Map<String, ApiProperty> properties = new HashMap<>(); schema.getProperties().forEach((propName, propSchema) -> { properties.put(propName, createApiProperty(propName, propSchema)); }); model.setProperties(properties); } // Extract required fields if (schema.getRequired() != null) { model.setRequiredFields(new ArrayList<>(schema.getRequired())); } // Handle inheritance if (schema.getAllOf() != null) { model.setAllOf(schema.getAllOf()); } if (schema.getOneOf() != null) { model.setOneOf(schema.getOneOf()); } if (schema.getAnyOf() != null) { model.setAnyOf(schema.getAnyOf()); } return model; } private ApiProperty createApiProperty(String name, Schema schema) { ApiProperty property = new ApiProperty(); property.setName(name); property.setSchema(schema); property.setType(schema.getType()); property.setFormat(schema.getFormat()); property.setDescription(schema.getDescription()); property.setRequired(false); // This will be set by the parent model property.setReadOnly(schema.getReadOnly() != null && schema.getReadOnly()); property.setWriteOnly(schema.getWriteOnly() != null && schema.getWriteOnly()); property.setNullable(schema.getNullable() != null && schema.getNullable()); // Handle arrays if ("array".equals(schema.getType()) && schema.getItems() != null) { property.setItemsSchema(schema.getItems()); } return property; } public OpenAPI getOpenAPI() { return openAPI; } public String getTitle() { return openAPI.getInfo() != null ? openAPI.getInfo().getTitle() : "Unknown API"; } public String getVersion() { return openAPI.getInfo() != null ? openAPI.getInfo().getVersion() : "1.0.0"; } public String getDescription() { return openAPI.getInfo() != null ? openAPI.getInfo().getDescription() : ""; } public String getBasePath() { if (openAPI.getServers() != null && !openAPI.getServers().isEmpty()) { return openAPI.getServers().get(0).getUrl(); } return "/"; } }

3. Model Classes

package com.openapicodegen.model; import io.swagger.v3.oas.models.media.Schema; import java.util.*; public class ApiOperation { private String path; private String httpMethod; private String operationId; private String summary; private String description; private List<String> tags; private boolean deprecated; private List<ApiParameter> parameters = new ArrayList<>(); private Map<String, ApiResponse> responses = new HashMap<>(); private Schema requestBody; // Getters and Setters public String getPath() { return path; } public void setPath(String path) { this.path = path; } public String getHttpMethod() { return httpMethod; } public void setHttpMethod(String httpMethod) { this.httpMethod = httpMethod; } public String getOperationId() { return operationId; } public void setOperationId(String operationId) { this.operationId = operationId; } public String getSummary() { return summary; } public void setSummary(String summary) { this.summary = summary; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public List<String> getTags() { return tags; } public void setTags(List<String> tags) { this.tags = tags; } public boolean isDeprecated() { return deprecated; } public void setDeprecated(boolean deprecated) { this.deprecated = deprecated; } public List<ApiParameter> getParameters() { return parameters; } public void setParameters(List<ApiParameter> parameters) { this.parameters = parameters; } public Map<String, ApiResponse> getResponses() { return responses; } public void setResponses(Map<String, ApiResponse> responses) { this.responses = responses; } public Schema getRequestBody() { return requestBody; } public void setRequestBody(Schema requestBody) { this.requestBody = requestBody; } public String getMethodName() { if (operationId != null && !operationId.trim().isEmpty()) { return sanitizeMethodName(operationId); } return generateMethodNameFromPath(); } private String sanitizeMethodName(String name) { // Remove special characters and make camelCase return name.replaceAll("[^a-zA-Z0-9_]", "_") .replaceAll("_+", "_") .replaceAll("^_|_$", ""); } private String generateMethodNameFromPath() { String[] parts = path.split("/"); StringBuilder methodName = new StringBuilder(httpMethod.toLowerCase()); for (String part : parts) { if (!part.isEmpty() && !part.startsWith("{") && !part.startsWith("}")) { methodName.append(Character.toUpperCase(part.charAt(0))) .append(part.substring(1)); } } return methodName.toString(); } } public class ApiParameter { private String name; private String in; // query, path, header, cookie private boolean required; private String description; private Schema schema; private String style; private Boolean explode; // Getters and Setters public String getName() { return name; } public void setName(String name) { this.name = name; } public String getIn() { return in; } public void setIn(String in) { this.in = in; } public boolean isRequired() { return required; } public void setRequired(boolean required) { this.required = required; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public Schema getSchema() { return schema; } public void setSchema(Schema schema) { this.schema = schema; } public String getStyle() { return style; } public void setStyle(String style) { this.style = style; } public Boolean getExplode() { return explode; } public void setExplode(Boolean explode) { this.explode = explode; } public String getJavaType() { return TypeMapper.mapType(schema); } public String getParameterName() { return sanitizeIdentifier(name); } private String sanitizeIdentifier(String identifier) { // Replace invalid characters and reserved words if (JavaReservedWords.isReserved(identifier)) { return identifier + "Param"; } return identifier.replaceAll("[^a-zA-Z0-9_]", "_"); } } public class ApiResponse { private String code; private String description; private Map<String, ApiHeader> headers = new HashMap<>(); private Schema schema; // Getters and Setters public String getCode() { return code; } public void setCode(String code) { this.code = code; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public Map<String, ApiHeader> getHeaders() { return headers; } public void setHeaders(Map<String, ApiHeader> headers) { this.headers = headers; } public Schema getSchema() { return schema; } public void setSchema(Schema schema) { this.schema = schema; } public String getJavaType() { return TypeMapper.mapType(schema); } public boolean isSuccess() { return code.startsWith("2"); } } public class ApiHeader { private String name; private String description; private Schema schema; private boolean required; // Getters and Setters public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public Schema getSchema() { return schema; } public void setSchema(Schema schema) { this.schema = schema; } public boolean isRequired() { return required; } public void setRequired(boolean required) { this.required = required; } } public class ApiModel { private String name; private Schema schema; private String description; private String type; private String format; private Map<String, ApiProperty> properties = new HashMap<>(); private List<String> requiredFields = new ArrayList<>(); private List<Schema> allOf; private List<Schema> oneOf; private List<Schema> anyOf; // Getters and Setters public String getName() { return name; } public void setName(String name) { this.name = name; } public Schema getSchema() { return schema; } public void setSchema(Schema schema) { this.schema = schema; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public String getType() { return type; } public void setType(String type) { this.type = type; } public String getFormat() { return format; } public void setFormat(String format) { this.format = format; } public Map<String, ApiProperty> getProperties() { return properties; } public void setProperties(Map<String, ApiProperty> properties) { this.properties = properties; } public List<String> getRequiredFields() { return requiredFields; } public void setRequiredFields(List<String> requiredFields) { this.requiredFields = requiredFields; } public List<Schema> getAllOf() { return allOf; } public void setAllOf(List<Schema> allOf) { this.allOf = allOf; } public List<Schema> getOneOf() { return oneOf; } public void setOneOf(List<Schema> oneOf) { this.oneOf = oneOf; } public List<Schema> getAnyOf() { return anyOf; } public void setAnyOf(List<Schema> anyOf) { this.anyOf = anyOf; } public String getClassName() { return sanitizeClassName(name); } private String sanitizeClassName(String name) { // Remove special characters and ensure PascalCase String className = name.replaceAll("[^a-zA-Z0-9]", " "); className = Arrays.stream(className.split("\\s+")) .map(part -> Character.toUpperCase(part.charAt(0)) + part.substring(1).toLowerCase()) .collect(Collectors.joining()); if (JavaReservedWords.isReserved(className)) { return className + "Model"; } return className; } public boolean hasProperties() { return properties != null && !properties.isEmpty(); } public boolean isEnum() { return schema.getEnum() != null && !schema.getEnum().isEmpty(); } public List<Object> getEnumValues() { return schema.getEnum() != null ? schema.getEnum() : Collections.emptyList(); } } public class ApiProperty { private String name; private Schema schema; private String type; private String format; private String description; private boolean required; private boolean readOnly; private boolean writeOnly; private boolean nullable; private Schema itemsSchema; // Getters and Setters public String getName() { return name; } public void setName(String name) { this.name = name; } public Schema getSchema() { return schema; } public void setSchema(Schema schema) { this.schema = schema; } public String getType() { return type; } public void setType(String type) { this.type = type; } public String getFormat() { return format; } public void setFormat(String format) { this.format = format; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public boolean isRequired() { return required; } public void setRequired(boolean required) { this.required = required; } public boolean isReadOnly() { return readOnly; } public void setReadOnly(boolean readOnly) { this.readOnly = readOnly; } public boolean isWriteOnly() { return writeOnly; } public void setWriteOnly(boolean writeOnly) { this.writeOnly = writeOnly; } public boolean isNullable() { return nullable; } public void setNullable(boolean nullable) { this.nullable = nullable; } public Schema getItemsSchema() { return itemsSchema; } public void setItemsSchema(Schema itemsSchema) { this.itemsSchema = itemsSchema; } public String getJavaType() { return TypeMapper.mapType(schema); } public String getFieldName() { return sanitizeFieldName(name); } private String sanitizeFieldName(String name) { // Convert to camelCase and handle reserved words String fieldName = name.replaceAll("[^a-zA-Z0-9_]", " "); fieldName = Arrays.stream(fieldName.split("\\s+")) .map(part -> Character.toUpperCase(part.charAt(0)) + part.substring(1).toLowerCase()) .collect(Collectors.joining()); fieldName = Character.toLowerCase(fieldName.charAt(0)) + fieldName.substring(1); if (JavaReservedWords.isReserved(fieldName)) { return fieldName + "Field"; } return fieldName; } public String getGetterName() { String prefix = "boolean".equals(getJavaType()) ? "is" : "get"; return prefix + Character.toUpperCase(getFieldName().charAt(0)) + getFieldName().substring(1); } public String getSetterName() { return "set" + Character.toUpperCase(getFieldName().charAt(0)) + getFieldName().substring(1); } }

4. Type Mapper

package com.openapicodegen.support; import io.swagger.v3.oas.models.media.Schema; import java.util.HashMap; import java.util.Map; public class TypeMapper { private static final Map<String, String> PRIMITIVE_TYPES = new HashMap<>(); private static final Map<String, String> CONTAINER_TYPES = new HashMap<>(); static { // Java primitive mappings PRIMITIVE_TYPES.put("string", "String"); PRIMITIVE_TYPES.put("number", "BigDecimal"); PRIMITIVE_TYPES.put("integer", "Integer"); PRIMITIVE_TYPES.put("boolean", "Boolean"); PRIMITIVE_TYPES.put("array", "List"); PRIMITIVE_TYPES.put("object", "Object"); // Format-specific mappings PRIMITIVE_TYPES.put("int32", "Integer"); PRIMITIVE_TYPES.put("int64", "Long"); PRIMITIVE_TYPES.put("float", "Float"); PRIMITIVE_TYPES.put("double", "Double"); PRIMITIVE_TYPES.put("byte", "byte[]"); PRIMITIVE_TYPES.put("binary", "byte[]"); PRIMITIVE_TYPES.put("date", "LocalDate"); PRIMITIVE_TYPES.put("date-time", "LocalDateTime"); PRIMITIVE_TYPES.put("uuid", "UUID"); // Container types CONTAINER_TYPES.put("array", "List"); CONTAINER_TYPES.put("map", "Map"); } public static String mapType(Schema schema) { if (schema == null) { return "Object"; } String type = schema.getType(); String format = schema.getFormat(); // Handle references if (schema.get$ref() != null) { return extractClassNameFromRef(schema.get$ref()); } // Handle arrays if ("array".equals(type) && schema.getItems() != null) { String itemType = mapType(schema.getItems()); return "List<" + itemType + ">"; } // Handle maps/objects with additionalProperties if ("object".equals(type) && schema.getAdditionalProperties() instanceof Schema) { Schema valueSchema = (Schema) schema.getAdditionalProperties(); String valueType = mapType(valueSchema); return "Map<String, " + valueType + ">"; } // Handle enums if (schema.getEnum() != null && !schema.getEnum().isEmpty()) { return "String"; // Enums will be generated as separate classes } // Handle format-specific types if (format != null && PRIMITIVE_TYPES.containsKey(format)) { return PRIMITIVE_TYPES.get(format); } // Handle basic types if (type != null && PRIMITIVE_TYPES.containsKey(type)) { return PRIMITIVE_TYPES.get(type); } return "Object"; } private static String extractClassNameFromRef(String ref) { // Extract class name from #/components/schemas/User String[] parts = ref.split("/"); return parts[parts.length - 1]; } public static String mapTypeToTypeScript(Schema schema) { if (schema == null) { return "any"; } String type = schema.getType(); String format = schema.getFormat(); if (schema.get$ref() != null) { return extractClassNameFromRef(schema.get$ref()); } if ("array".equals(type) && schema.getItems() != null) { String itemType = mapTypeToTypeScript(schema.getItems()); return itemType + "[]"; } if ("integer".equals(type)) { return "number"; } if ("string".equals(type)) { if ("date".equals(format) || "date-time".equals(format)) { return "Date"; } return "string"; } if ("boolean".equals(type)) { return "boolean"; } if ("number".equals(type)) { return "number"; } if ("object".equals(type)) { return "any"; } return "any"; } public static String mapTypeToPython(Schema schema) { if (schema == null) { return "Any"; } String type = schema.getType(); if (schema.get$ref() != null) { return extractClassNameFromRef(schema.get$ref()); } if ("array".equals(type)) { return "List"; } if ("integer".equals(type)) { return "int"; } if ("string".equals(type)) { return "str"; } if ("boolean".equals(type)) { return "bool"; } if ("number".equals(type)) { return "float"; } if ("object".equals(type)) { return "Dict"; } return "Any"; } }

5. Template Engine

package com.openapicodegen.template; import freemarker.template.Configuration; import freemarker.template.Template; import freemarker.template.TemplateException; import freemarker.template.TemplateExceptionHandler; import java.io.*; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.Map; public class TemplateEngine { private final Configuration freeMarkerConfig; public TemplateEngine() { this.freeMarkerConfig = createConfiguration(); } public TemplateEngine(String templateDirectory) { this.freeMarkerConfig = createConfiguration(templateDirectory); } private Configuration createConfiguration() { try { Configuration cfg = new Configuration(Configuration.VERSION_2_3_31); cfg.setClassForTemplateLoading(TemplateEngine.class, "/templates"); cfg.setDefaultEncoding("UTF-8"); cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER); cfg.setLogTemplateExceptions(false); cfg.setWrapUncheckedExceptions(true); cfg.setFallbackOnNullLoopVariable(false); return cfg; } catch (Exception e) { throw new RuntimeException("Failed to initialize FreeMarker configuration", e); } } private Configuration createConfiguration(String templateDirectory) { try { Configuration cfg = new Configuration(Configuration.VERSION_2_3_31); cfg.setDirectoryForTemplateLoading(new File(templateDirectory)); cfg.setDefaultEncoding("UTF-8"); cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER); cfg.setLogTemplateExceptions(false); cfg.setWrapUncheckedExceptions(true); cfg.setFallbackOnNullLoopVariable(false); return cfg; } catch (Exception e) { throw new RuntimeException("Failed to initialize FreeMarker configuration", e); } } public String processTemplate(String templateName, Map<String, Object> dataModel) { try { Template template = freeMarkerConfig.getTemplate(templateName); StringWriter writer = new StringWriter(); template.process(dataModel, writer); return writer.toString(); } catch (IOException | TemplateException e) { throw new RuntimeException("Failed to process template: " + templateName, e); } } public void processTemplateToFile(String templateName, Map<String, Object> dataModel, String outputFilePath) { try { String content = processTemplate(templateName, dataModel); writeToFile(outputFilePath, content); } catch (Exception e) { throw new RuntimeException("Failed to write template to file: " + outputFilePath, e); } } private void writeToFile(String filePath, String content) throws IOException { Path path = Paths.get(filePath); Files.createDirectories(path.getParent()); Files.writeString(path, content); } public boolean templateExists(String templateName) { try { Template template = freeMarkerConfig.getTemplate(templateName); return template != null; } catch (IOException e) { return false; } } public String[] getAvailableTemplates() { // This would require custom implementation to list templates // For simplicity, returning common templates return new String[]{ "java/model.ftl", "java/api.ftl", "java/api_test.ftl", "java/pom.ftl", "typescript/model.ftl", "typescript/api.ftl", "python/model.ftl", "python/api.ftl" }; } }

6. Code Generators

package com.openapicodegen.generator; import com.openapicodegen.model.*; import com.openapicodegen.template.TemplateEngine; import java.io.File; import java.util.*; public abstract class CodeGenerator { protected final CodeGenConfig config; protected final TemplateEngine templateEngine; public CodeGenerator(CodeGenConfig config) { this.config = config; this.templateEngine = new TemplateEngine(); } public abstract void generate(OpenAPIExtractor extractor); protected void createDirectory(String path) { File dir = new File(path); if (!dir.exists()) { dir.mkdirs(); } } protected String getOutputPath(String... paths) { StringBuilder outputPath = new StringBuilder(config.getOutputDir()); for (String path : paths) { outputPath.append(File.separator).append(path); } return outputPath.toString(); } protected Map<String, Object> createBaseDataModel(OpenAPIExtractor extractor) { Map<String, Object> dataModel = new HashMap<>(); dataModel.put("config", config); dataModel.put("openAPI", extractor.getOpenAPI()); dataModel.put("title", extractor.getTitle()); dataModel.put("version", extractor.getVersion()); dataModel.put("description", extractor.getDescription()); dataModel.put("basePath", extractor.getBasePath()); // Add additional properties dataModel.putAll(config.getAdditionalProperties()); return dataModel; } } public class JavaClientGenerator extends CodeGenerator { public JavaClientGenerator(CodeGenConfig config) { super(config); } @Override public void generate(OpenAPIExtractor extractor) { System.out.println("Generating Java client code..."); // Create directory structure createJavaDirectoryStructure(); // Generate models generateModels(extractor); // Generate API classes generateApis(extractor); // Generate supporting files generateSupportingFiles(extractor); System.out.println("Java client generation completed!"); } private void createJavaDirectoryStructure() { String baseDir = getOutputPath("src", "main", "java"); String[] packages = { config.getModelPackage().replace('.', '/'), config.getApiPackage().replace('.', '/'), config.getInvokerPackage().replace('.', '/') }; for (String pkg : packages) { createDirectory(getOutputPath("src", "main", "java", pkg)); } // Create test directory createDirectory(getOutputPath("src", "test", "java")); } private void generateModels(OpenAPIExtractor extractor) { if (!config.isGenerateModels()) return; List<ApiModel> models = extractor.extractModels(); Map<String, Object> baseModel = createBaseDataModel(extractor); for (ApiModel model : models) { Map<String, Object> dataModel = new HashMap<>(baseModel); dataModel.put("model", model); dataModel.put("className", model.getClassName()); String outputFile = getOutputPath("src", "main", "java", config.getModelPackage().replace('.', '/'), model.getClassName() + ".java"); templateEngine.processTemplateToFile("java/model.ftl", dataModel, outputFile); System.out.println("Generated model: " + model.getClassName()); } } private void generateApis(OpenAPIExtractor extractor) { if (!config.isGenerateApis()) return; List<ApiOperation> operations = extractor.extractOperations(); Map<String, Object> baseModel = createBaseDataModel(extractor); // Group operations by tag Map<String, List<ApiOperation>> operationsByTag = groupOperationsByTag(operations); for (Map.Entry<String, List<ApiOperation>> entry : operationsByTag.entrySet()) { String tag = entry.getKey(); List<ApiOperation> tagOperations = entry.getValue(); Map<String, Object> dataModel = new HashMap<>(baseModel); dataModel.put("tag", tag); dataModel.put("operations", tagOperations); dataModel.put("className", getApiClassName(tag)); String outputFile = getOutputPath("src", "main", "java", config.getApiPackage().replace('.', '/'), getApiClassName(tag) + ".java"); templateEngine.processTemplateToFile("java/api.ftl", dataModel, outputFile); System.out.println("Generated API: " + getApiClassName(tag)); // Generate tests generateApiTests(tag, tagOperations, baseModel); } } private Map<String, List<ApiOperation>> groupOperationsByTag(List<ApiOperation> operations) { Map<String, List<ApiOperation>> grouped = new HashMap<>(); for (ApiOperation operation : operations) { List<String> tags = operation.getTags(); if (tags == null || tags.isEmpty()) { // Use "DefaultApi" for operations without tags grouped.computeIfAbsent("Default", k -> new ArrayList<>()).add(operation); } else { for (String tag : tags) { grouped.computeIfAbsent(tag, k -> new ArrayList<>()).add(operation); } } } return grouped; } private String getApiClassName(String tag) { return tag + "Api"; } private void generateApiTests(String tag, List<ApiOperation> operations, Map<String, Object> baseModel) { Map<String, Object> dataModel = new HashMap<>(baseModel); dataModel.put("tag", tag); dataModel.put("operations", operations); dataModel.put("className", getApiClassName(tag) + "Test"); String outputFile = getOutputPath("src", "test", "java", config.getApiPackage().replace('.', '/'), getApiClassName(tag) + "Test.java"); templateEngine.processTemplateToFile("java/api_test.ftl", dataModel, outputFile); } private void generateSupportingFiles(OpenAPIExtractor extractor) { if (!config.isGenerateSupportingFiles()) return; Map<String, Object> dataModel = createBaseDataModel(extractor); // Generate pom.xml templateEngine.processTemplateToFile("java/pom.ftl", dataModel, getOutputPath("pom.xml")); // Generate README templateEngine.processTemplateToFile("java/readme.ftl", dataModel, getOutputPath("README.md")); // Generate ApiClient templateEngine.processTemplateToFile("java/api_client.ftl", dataModel, getOutputPath("src", "main", "java", config.getInvokerPackage().replace('.', '/'), "ApiClient.java")); // Generate Configuration templateEngine.processTemplateToFile("java/configuration.ftl", dataModel, getOutputPath("src", "main", "java", config.getInvokerPackage().replace('.', '/'), "Configuration.java")); } } public class TypeScriptGenerator extends CodeGenerator { public TypeScriptGenerator(CodeGenConfig config) { super(config); } @Override public void generate(OpenAPIExtractor extractor) { System.out.println("Generating TypeScript client code..."); createDirectory(getOutputPath("src")); createDirectory(getOutputPath("src", "models")); createDirectory(getOutputPath("src", "apis")); generateTypeScriptModels(extractor); generateTypeScriptApis(extractor); generateTypeScriptSupportingFiles(extractor); System.out.println("TypeScript client generation completed!"); } private void generateTypeScriptModels(OpenAPIExtractor extractor) { List<ApiModel> models = extractor.extractModels(); Map<String, Object> baseModel = createBaseDataModel(extractor); for (ApiModel model : models) { Map<String, Object> dataModel = new HashMap<>(baseModel); dataModel.put("model", model); dataModel.put("interfaceName", model.getClassName()); String outputFile = getOutputPath("src", "models", model.getClassName() + ".ts"); templateEngine.processTemplateToFile("typescript/model.ftl", dataModel, outputFile); } } private void generateTypeScriptApis(OpenAPIExtractor extractor) { List<ApiOperation> operations = extractor.extractOperations(); Map<String, List<ApiOperation>> operationsByTag = groupOperationsByTag(operations); Map<String, Object> baseModel = createBaseDataModel(extractor); for (Map.Entry<String, List<ApiOperation>> entry : operationsByTag.entrySet()) { Map<String, Object> dataModel = new HashMap<>(baseModel); dataModel.put("tag", entry.getKey()); dataModel.put("operations", entry.getValue()); dataModel.put("className", entry.getKey() + "Api"); String outputFile = getOutputPath("src", "apis", entry.getKey() + "Api.ts"); templateEngine.processTemplateToFile("typescript/api.ftl", dataModel, outputFile); } } private void generateTypeScriptSupportingFiles(OpenAPIExtractor extractor) { Map<String, Object> dataModel = createBaseDataModel(extractor); templateEngine.processTemplateToFile("typescript/package.ftl", dataModel, getOutputPath("package.json")); templateEngine.processTemplateToFile("typescript/tsconfig.ftl", dataModel, getOutputPath("tsconfig.json")); templateEngine.processTemplateToFile("typescript/api_client.ftl", dataModel, getOutputPath("src", "ApiClient.ts")); } }

7. Generator Factory

package com.openapicodegen.generator; import com.openapicodegen.model.CodeGenConfig; import java.util.HashMap; import java.util.Map; public class GeneratorFactory { private static final Map<String, Class<? extends CodeGenerator>> GENERATORS = new HashMap<>(); static { GENERATORS.put("java", JavaClientGenerator.class); GENERATORS.put("typescript", TypeScriptGenerator.class); GENERATORS.put("python", PythonGenerator.class); GENERATORS.put("spring", SpringServerGenerator.class); GENERATORS.put("nodejs", NodeJsServerGenerator.class); } public static CodeGenerator createGenerator(String language, CodeGenConfig config) { Class<? extends CodeGenerator> generatorClass = GENERATORS.get(language.toLowerCase()); if (generatorClass == null) { throw new IllegalArgumentException("Unsupported language: " + language); } try { return generatorClass.getConstructor(CodeGenConfig.class).newInstance(config); } catch (Exception e) { throw new RuntimeException("Failed to create generator for language: " + language, e); } } public static void registerGenerator(String language, Class<? extends CodeGenerator> generatorClass) { GENERATORS.put(language.toLowerCase(), generatorClass); } public static String[] getSupportedLanguages() { return GENERATORS.keySet().toArray(new String[0]); } }

8. Main Code Generator Service

package com.openapicodegen.core; import com.openapicodegen.generator.CodeGenerator; import com.openapicodegen.generator.GeneratorFactory; import com.openapicodegen.model.CodeGenConfig; import com.openapicodegen.model.OpenAPIExtractor; public class OpenAPICodeGenerator { public void generate(String openApiSpec, String language, CodeGenConfig config) { try { // Parse OpenAPI specification OpenAPIExtractor extractor = OpenAPIExtractor.fromFile(openApiSpec); // Create appropriate generator CodeGenerator generator = GeneratorFactory.createGenerator(language, config); // Generate code generator.generate(extractor); } catch (Exception e) { throw new RuntimeException("Code generation failed", e); } } public void generateFromContent(String openApiContent, String language, CodeGenConfig config) { try { // Parse OpenAPI specification from content OpenAPIExtractor extractor = OpenAPIExtractor.fromContent(openApiContent); // Create appropriate generator CodeGenerator generator = GeneratorFactory.createGenerator(language, config); // Generate code generator.generate(extractor); } catch (Exception e) { throw new RuntimeException("Code generation failed", e); } } public String[] getSupportedLanguages() { return GeneratorFactory.getSupportedLanguages(); } public void validateOpenAPISpec(String openApiSpec) { try { OpenAPIExtractor extractor = OpenAPIExtractor.fromFile(openApiSpec); System.out.println("✓ Valid OpenAPI specification: " + extractor.getTitle()); } catch (Exception e) { throw new RuntimeException("Invalid OpenAPI specification: " + e.getMessage()); } } }

9. CLI Interface

package com.openapicodegen.cli; import com.openapicodegen.core.OpenAPICodeGenerator; import com.openapicodegen.model.CodeGenConfig; import picocli.CommandLine; import picocli.CommandLine.Command; import picocli.CommandLine.Option; import picocli.CommandLine.Parameters; import java.io.File; import java.util.concurrent.Callable; @Command(name = "openapi-codegen", mixinStandardHelpOptions = true, version = "OpenAPI Code Generator 1.0", description = "Generates client SDKs and server stubs from OpenAPI specifications") public class CLIRunner implements Callable<Integer> { @Parameters(index = "0", description = "The OpenAPI specification file") private File specFile; @Option(names = {"-l", "--language"}, description = "Target language: ${COMPLETION-CANDIDATES}", required = true) private String language; @Option(names = {"-o", "--output"}, description = "Output directory (default: generated)") private String outputDir = "generated"; @Option(names = {"-p", "--package"}, description = "Base package name for generated code") private String packageName; @Option(names = {"--group-id"}, description = "Maven groupId (for Java)") private String groupId; @Option(names = {"--artifact-id"}, description = "Maven artifactId (for Java)") private String artifactId; @Option(names = {"--artifact-version"}, description = "Maven artifact version (for Java)") private String artifactVersion = "1.0.0"; @Option(names = {"--validate"}, description = "Validate the OpenAPI specification without generating code") private boolean validateOnly = false; @Option(names = {"--list-languages"}, description = "List supported languages") private boolean listLanguages = false; private final OpenAPICodeGenerator generator = new OpenAPICodeGenerator(); @Override public Integer call() throws Exception { if (listLanguages) { System.out.println("Supported languages:"); for (String lang : generator.getSupportedLanguages()) { System.out.println(" - " + lang); } return 0; } if (!specFile.exists()) { System.err.println("Error: Specification file not found: " + specFile); return 1; } if (validateOnly) { try { generator.validateOpenAPISpec(specFile.getAbsolutePath()); System.out.println("✓ Specification is valid"); return 0; } catch (Exception e) { System.err.println("✗ Invalid specification: " + e.getMessage()); return 1; } } try { CodeGenConfig config = createConfig(); generator.generate(specFile.getAbsolutePath(), language, config); System.out.println("✓ Code generation completed successfully!"); return 0; } catch (Exception e) { System.err.println("✗ Code generation failed: " + e.getMessage()); e.printStackTrace(); return 1; } } private CodeGenConfig createConfig() { CodeGenConfig.Builder builder = new CodeGenConfig.Builder(); builder.outputDir(outputDir); if (packageName != null) { builder.packageName(packageName); } if (groupId != null) { builder.groupId(groupId); } if (artifactId != null) { builder.artifactId(artifactId); } builder.artifactVersion(artifactVersion); return builder.build(); } public static void main(String[] args) { int exitCode = new CommandLine(new CLIRunner()).execute(args); System.exit(exitCode); } }

10. FreeMarker Templates

Java Model Template (java/model.ftl):

package ${config.modelPackage}; <#if config.useSwaggerAnnotations> import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModelProperty; </#if> <#if config.useBeanValidation> import javax.validation.constraints.*; </#if> import java.util.Objects; <#-- Import required types based on properties --> <#list model.properties as property> <#if property.javaType?starts_with("List")> import java.util.List; import java.util.ArrayList; <#break> </#if> </#list> <#if config.useSwaggerAnnotations> @ApiModel(description = "${model.description!}") </#if> public class ${model.className} { <#list model.properties as property> <#if config.useSwaggerAnnotations> @ApiModelProperty(<#if property.description??>value = "${property.description}", </#if><#if property.required>required = true</#if>) </#if> <#if config.useBeanValidation> <#if property.required> @NotNull </#if> </#if> private ${property.javaType} ${property.fieldName}; </#list> public ${model.className}() { } <#list model.properties as property> public ${property.javaType} ${property.getterName}() { return ${property.fieldName}; } public void ${property.setterName}(${property.javaType} ${property.fieldName}) { this.${property.fieldName} = ${property.fieldName}; } </#list> @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ${model.className} that = (${model.className}) o; return <#list model.properties as property>Objects.equals(${property.fieldName}, that.${property.fieldName})<#if property_has_next> && </#if></#list>; } @Override public int hashCode() { return Objects.hash(<#list model.properties as property>${property.fieldName}<#if property_has_next>, </#if></#list>); } @Override public String toString() { return "${model.className}{" + <#list model.properties as property> "${property.fieldName}=" + ${property.fieldName} + <#if property_has_next>", "</#if> </#list> '}'; } }

Java API Template (java/api.ftl):

package ${config.apiPackage}; <#if config.useSwaggerAnnotations> import io.swagger.annotations.*; </#if> import ${config.modelPackage}.*; import org.springframework.web.bind.annotation.*; import org.springframework.http.ResponseEntity; <#if config.useSwaggerAnnotations> @Api(value = "${tag}", description = "The ${tag} API") </#if> public interface ${className} { <#list operations as operation> <#if config.useSwaggerAnnotations> @ApiOperation(value = "${operation.summary!}", notes = "${operation.description!}") @ApiResponses({ <#list operation.responses as response> @ApiResponse(code = ${response.code}, message = "${response.description!}")<#if response_has_next>,</#if> </#list> }) </#if> @RequestMapping(value = "${operation.path}", method = RequestMethod.${operation.httpMethod}, produces = "application/json") ResponseEntity<${operation.responses['200'].javaType}> ${operation.methodName}( <#list operation.parameters as param> <#if config.useSwaggerAnnotations> @ApiParam(value = "${param.description!}") </#if> @${param.in?cap_first}Param("${param.name}") ${param.javaType} ${param.parameterName}<#if param_has_next>, </#if> </#list> ); </#list> }

11. Maven Configuration

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.openapicodegen</groupId> <artifactId>openapi-code-generator</artifactId> <version>1.0.0</version> <properties> <maven.compiler.source>17</maven.compiler.source> <maven.compiler.target>17</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <!-- OpenAPI Parser --> <dependency> <groupId>io.swagger.parser.v3</groupId> <artifactId>swagger-parser</artifactId> <version>2.1.12</version> </dependency> <!-- OpenAPI Models --> <dependency> <groupId>io.swagger.core.v3</groupId> <artifactId>swagger-models</artifactId> <version>2.2.8</version> </dependency> <!-- Template Engine --> <dependency> <groupId>org.freemarker</groupId> <artifactId>freemarker</artifactId> <version>2.3.32</version> </dependency> <!-- CLI Framework --> <dependency> <groupId>info.picocli</groupId> <artifactId>picocli</artifactId> <version>4.7.4</version> </dependency> <!-- JSON Processing --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.15.2</version> </dependency> <!-- Testing --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>5.4.0</version> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.11.0</version> <configuration> <source>17</source> <target>17</target> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.4.1</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> <configuration> <transformers> <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> <mainClass>com.openapicodegen.cli.CLIRunner</mainClass> </transformer> </transformers> </configuration> </execution> </executions> </plugin> </plugins> </build> </project>

Usage Examples

// Programmatic usage public class ExampleUsage { public static void main(String[] args) { OpenAPICodeGenerator generator = new OpenAPICodeGenerator(); CodeGenConfig config = new CodeGenConfig.Builder() .packageName("com.example.api") .outputDir("generated-code") .groupId("com.example") .artifactId("api-client") .artifactVersion("1.0.0") .useBeanValidation(true) .useOptional(true) .build(); generator.generate("petstore.yaml", "java", config); } } // CLI Usage // java -jar openapi-codegen.jar petstore.yaml -l java -p com.example.api

Features

✅ Supported Outputs

  • Java client SDKs (RestTemplate, WebClient)
  • TypeScript/JavaScript clients
  • Python clients
  • Spring Boot server stubs
  • Node.js Express server stubs
  • API documentation

✅ Code Quality

  • Proper package structure
  • Comprehensive model classes
  • Full API interface definitions
  • Builder patterns where appropriate
  • Validation annotations
  • Comprehensive tests

✅ Customization

  • Extensible template system
  • Custom type mappings
  • Support for additional properties
  • Plugin system for custom generators

This OpenAPI code generator provides a robust foundation for generating high-quality client and server code from OpenAPI specifications, with extensibility for custom requirements and multiple target languages.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper