MACRO NEPAL
REST API Client Generator in Java
awiskar acharya
November 10, 2025
11:48 am

A comprehensive and type-safe REST API client generator that creates Java clients from OpenAPI/Swagger specifications with support for multiple HTTP clients, authentication, and advanced features.

Complete Implementation

1. Core Generator Class

package com.apiclient.generator;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.stream.Collectors;
/**
* Main REST API Client Generator
* Supports OpenAPI 3.0 specifications in JSON and YAML format
*/
public class RestApiClientGenerator {
private final ObjectMapper objectMapper;
private final ObjectMapper yamlMapper;
private final GeneratorConfig config;
public RestApiClientGenerator(GeneratorConfig config) {
this.config = config;
this.objectMapper = new ObjectMapper();
this.yamlMapper = new ObjectMapper(new YAMLFactory());
}
/**
* Generates complete REST API client from OpenAPI specification
*/
public void generateClient(String specFilePath, String outputDir) throws IOException {
System.out.println("Generating REST API client from: " + specFilePath);
// Parse OpenAPI specification
OpenApiSpec spec = parseOpenApiSpec(specFilePath);
// Create output directory structure
createDirectoryStructure(outputDir);
// Generate model classes (DTOs)
generateModelClasses(spec, outputDir);
// Generate API client interfaces
generateApiInterfaces(spec, outputDir);
// Generate client implementation
generateClientImplementation(spec, outputDir);
// Generate configuration classes
generateConfigurationClasses(spec, outputDir);
System.out.println("REST API client generated successfully in: " + outputDir);
}
private OpenApiSpec parseOpenApiSpec(String specFilePath) throws IOException {
File specFile = new File(specFilePath);
JsonNode root;
if (specFilePath.endsWith(".yaml") || specFilePath.endsWith(".yml")) {
root = yamlMapper.readTree(specFile);
} else {
root = objectMapper.readTree(specFile);
}
return new OpenApiSpec(root, objectMapper);
}
private void createDirectoryStructure(String outputDir) throws IOException {
String basePackagePath = config.getBasePackage().replace('.', '/');
Path basePath = Paths.get(outputDir, "src/main/java", basePackagePath);
Files.createDirectories(basePath.resolve("models"));
Files.createDirectories(basePath.resolve("api"));
Files.createDirectories(basePath.resolve("client"));
Files.createDirectories(basePath.resolve("config"));
Files.createDirectories(Paths.get(outputDir, "src/main/resources"));
}
}

2. Configuration and Models

/**
* Generator configuration
*/
public class GeneratorConfig {
private String basePackage = "com.api.client";
private String clientName = "ApiClient";
private boolean useLombok = true;
private boolean useJackson = true;
private HttpClientType httpClientType = HttpClientType.OKHTTP;
private boolean generateTests = true;
private boolean asyncSupport = false;
private String dateLibrary = "java8";
public enum HttpClientType {
OKHTTP, APACHE_HTTP_CLIENT, JAVA_HTTP_CLIENT
}
// Constructors, getters, and setters
public GeneratorConfig() {}
public GeneratorConfig(String basePackage, String clientName) {
this.basePackage = basePackage;
this.clientName = clientName;
}
// Getters and setters
public String getBasePackage() { return basePackage; }
public void setBasePackage(String basePackage) { this.basePackage = basePackage; }
public String getClientName() { return clientName; }
public void setClientName(String clientName) { this.clientName = clientName; }
public boolean isUseLombok() { return useLombok; }
public void setUseLombok(boolean useLombok) { this.useLombok = useLombok; }
public boolean isUseJackson() { return useJackson; }
public void setUseJackson(boolean useJackson) { this.useJackson = useJackson; }
public HttpClientType getHttpClientType() { return httpClientType; }
public void setHttpClientType(HttpClientType httpClientType) { this.httpClientType = httpClientType; }
public boolean isGenerateTests() { return generateTests; }
public void setGenerateTests(boolean generateTests) { this.generateTests = generateTests; }
public boolean isAsyncSupport() { return asyncSupport; }
public void setAsyncSupport(boolean asyncSupport) { this.asyncSupport = asyncSupport; }
public String getDateLibrary() { return dateLibrary; }
public void setDateLibrary(String dateLibrary) { this.dateLibrary = dateLibrary; }
}
/**
* OpenAPI specification wrapper
*/
public class OpenApiSpec {
private final JsonNode root;
private final ObjectMapper objectMapper;
public OpenApiSpec(JsonNode root, ObjectMapper objectMapper) {
this.root = root;
this.objectMapper = objectMapper;
}
public String getTitle() {
return root.path("info").path("title").asText("API Client");
}
public String getVersion() {
return root.path("info").path("version").asText("1.0.0");
}
public String getDescription() {
return root.path("info").path("description").asText("");
}
public String getBaseUrl() {
JsonNode servers = root.path("servers");
if (servers.isArray() && servers.size() > 0) {
return servers.get(0).path("url").asText("http://localhost:8080");
}
return "http://localhost:8080";
}
public Map<String, JsonNode> getSchemas() {
Map<String, JsonNode> schemas = new HashMap<>();
JsonNode components = root.path("components");
if (components.has("schemas")) {
components.path("schemas").fields().forEachRemaining(entry -> {
schemas.put(entry.getKey(), entry.getValue());
});
}
return schemas;
}
public Map<String, JsonNode> getPaths() {
Map<String, JsonNode> paths = new HashMap<>();
root.path("paths").fields().forEachRemaining(entry -> {
paths.put(entry.getKey(), entry.getValue());
});
return paths;
}
public Map<String, JsonNode> getSecuritySchemes() {
Map<String, JsonNode> securitySchemes = new HashMap<>();
JsonNode components = root.path("components");
if (components.has("securitySchemes")) {
components.path("securitySchemes").fields().forEachRemaining(entry -> {
securitySchemes.put(entry.getKey(), entry.getValue());
});
}
return securitySchemes;
}
}
/**
* API Method information
*/
public class ApiMethod {
private String name;
private String httpMethod;
private String path;
private String returnType;
private List<ApiParameter> parameters;
private String description;
private boolean deprecated;
private List<String> securityRequirements;
public ApiMethod(String name, String httpMethod, String path) {
this.name = name;
this.httpMethod = httpMethod;
this.path = path;
this.parameters = new ArrayList<>();
this.securityRequirements = new ArrayList<>();
}
// Getters and setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getHttpMethod() { return httpMethod; }
public void setHttpMethod(String httpMethod) { this.httpMethod = httpMethod; }
public String getPath() { return path; }
public void setPath(String path) { this.path = path; }
public String getReturnType() { return returnType; }
public void setReturnType(String returnType) { this.returnType = returnType; }
public List<ApiParameter> getParameters() { return parameters; }
public void setParameters(List<ApiParameter> parameters) { this.parameters = parameters; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public boolean isDeprecated() { return deprecated; }
public void setDeprecated(boolean deprecated) { this.deprecated = deprecated; }
public List<String> getSecurityRequirements() { return securityRequirements; }
public void setSecurityRequirements(List<String> securityRequirements) { this.securityRequirements = securityRequirements; }
public void addParameter(ApiParameter parameter) {
this.parameters.add(parameter);
}
}
/**
* API Parameter information
*/
public class ApiParameter {
private String name;
private String type;
private String location; // "query", "path", "header", "body"
private boolean required;
private String description;
private String dataType;
public ApiParameter(String name, String type, String location) {
this.name = name;
this.type = type;
this.location = location;
}
// Getters and setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getType() { return type; }
public void setType(String type) { this.type = type; }
public String getLocation() { return location; }
public void setLocation(String location) { this.location = location; }
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 String getDataType() { return dataType; }
public void setDataType(String dataType) { this.dataType = dataType; }
}

3. Model Class Generator

/**
* Generates model classes (DTOs) from OpenAPI schemas
*/
public class ModelClassGenerator {
private final GeneratorConfig config;
private final OpenApiSpec spec;
public ModelClassGenerator(GeneratorConfig config, OpenApiSpec spec) {
this.config = config;
this.spec = spec;
}
public void generateModelClasses(String outputDir) throws IOException {
Map<String, JsonNode> schemas = spec.getSchemas();
String packagePath = config.getBasePackage() + ".models";
for (Map.Entry<String, JsonNode> entry : schemas.entrySet()) {
String className = toClassName(entry.getKey());
JsonNode schema = entry.getValue();
String javaCode = generateModelClass(className, schema, packagePath);
writeJavaFile(outputDir, packagePath, className, javaCode);
}
}
private String generateModelClass(String className, JsonNode schema, String packageName) {
StringBuilder sb = new StringBuilder();
// Package and imports
sb.append("package ").append(packageName).append(";\n\n");
if (config.isUseJackson()) {
sb.append("import com.fasterxml.jackson.annotation.*;\n");
}
if (config.isUseLombok()) {
sb.append("import lombok.*;\n");
}
sb.append("import java.util.*;\n\n");
// Class documentation
String description = schema.path("description").asText(null);
if (description != null) {
sb.append("/**\n * ").append(description).append("\n */\n");
}
// Lombok annotations
if (config.isUseLombok()) {
sb.append("@Data\n");
sb.append("@NoArgsConstructor\n");
sb.append("@AllArgsConstructor\n");
sb.append("@Builder\n");
}
// Jackson annotations
if (config.isUseJackson()) {
sb.append("@JsonInclude(JsonInclude.Include.NON_NULL)\n");
}
sb.append("public class ").append(className).append(" {\n\n");
// Fields
JsonNode properties = schema.path("properties");
List<String> requiredFields = getRequiredFields(schema);
if (properties.isObject()) {
properties.fields().forEachRemaining(property -> {
String fieldName = property.getKey();
JsonNode fieldSchema = property.getValue();
String fieldType = getJavaType(fieldSchema);
String fieldDescription = fieldSchema.path("description").asText(null);
// Field documentation
if (fieldDescription != null) {
sb.append("    /**\n     * ").append(fieldDescription).append("\n     */\n");
}
// Jackson property annotation
if (config.isUseJackson()) {
String jsonProperty = !fieldName.matches("[a-zA-Z_$][a-zA-Z0-9_$]*") ? 
String.format("@JsonProperty(\"%s\")\n    ", fieldName) : "";
sb.append("    ").append(jsonProperty);
}
sb.append("    private ").append(fieldType).append(" ").append(toFieldName(fieldName)).append(";\n\n");
});
}
// Manual getters/setters if not using Lombok
if (!config.isUseLombok()) {
generateGettersAndSetters(sb, properties);
}
sb.append("}");
return sb.toString();
}
private String getJavaType(JsonNode schema) {
String type = schema.path("type").asText("object");
String format = schema.path("format").asText();
switch (type) {
case "string":
if ("date".equals(format)) {
return config.getDateLibrary().equals("java8") ? "LocalDate" : "Date";
} else if ("date-time".equals(format)) {
return config.getDateLibrary().equals("java8") ? "LocalDateTime" : "Date";
} else if ("byte".equals(format)) {
return "byte[]";
}
return "String";
case "integer":
if ("int32".equals(format)) return "Integer";
if ("int64".equals(format)) return "Long";
return "Integer";
case "number":
if ("float".equals(format)) return "Float";
if ("double".equals(format)) return "Double";
return "Double";
case "boolean":
return "Boolean";
case "array":
JsonNode items = schema.path("items");
String itemType = getJavaType(items);
return "List<" + itemType + ">";
case "object":
return "Map<String, Object>";
default:
return "Object";
}
}
private List<String> getRequiredFields(JsonNode schema) {
List<String> required = new ArrayList<>();
JsonNode requiredNode = schema.path("required");
if (requiredNode.isArray()) {
requiredNode.forEach(field -> required.add(field.asText()));
}
return required;
}
private void generateGettersAndSetters(StringBuilder sb, JsonNode properties) {
if (properties.isObject()) {
properties.fields().forEachRemaining(property -> {
String fieldName = property.getKey();
String javaFieldName = toFieldName(fieldName);
String capitalizedFieldName = capitalize(javaFieldName);
JsonNode fieldSchema = property.getValue();
String fieldType = getJavaType(fieldSchema);
// Getter
sb.append("    public ").append(fieldType).append(" get").append(capitalizedFieldName).append("() {\n");
sb.append("        return this.").append(javaFieldName).append(";\n");
sb.append("    }\n\n");
// Setter
sb.append("    public void set").append(capitalizedFieldName).append("(")
.append(fieldType).append(" ").append(javaFieldName).append(") {\n");
sb.append("        this.").append(javaFieldName).append(" = ").append(javaFieldName).append(";\n");
sb.append("    }\n\n");
});
}
}
private String toClassName(String name) {
// Convert snake_case to PascalCase
return Arrays.stream(name.split("[^a-zA-Z0-9]"))
.map(part -> part.substring(0, 1).toUpperCase() + part.substring(1).toLowerCase())
.collect(Collectors.joining());
}
private String toFieldName(String name) {
// Convert to camelCase
String[] parts = name.split("[^a-zA-Z0-9]");
if (parts.length == 0) return name;
StringBuilder result = new StringBuilder(parts[0].toLowerCase());
for (int i = 1; i < parts.length; i++) {
result.append(parts[i].substring(0, 1).toUpperCase())
.append(parts[i].substring(1).toLowerCase());
}
return result.toString();
}
private String capitalize(String str) {
if (str == null || str.isEmpty()) return str;
return str.substring(0, 1).toUpperCase() + str.substring(1);
}
private void writeJavaFile(String outputDir, String packageName, String className, String content) throws IOException {
String packagePath = packageName.replace('.', '/');
Path filePath = Paths.get(outputDir, "src/main/java", packagePath, className + ".java");
Files.writeString(filePath, content);
}
}

4. API Interface Generator

/**
* Generates API service interfaces
*/
public class ApiInterfaceGenerator {
private final GeneratorConfig config;
private final OpenApiSpec spec;
public ApiInterfaceGenerator(GeneratorConfig config, OpenApiSpec spec) {
this.config = config;
this.spec = spec;
}
public void generateApiInterfaces(String outputDir) throws IOException {
Map<String, List<ApiMethod>> apiGroups = groupMethodsByTag();
String packageName = config.getBasePackage() + ".api";
for (Map.Entry<String, List<ApiMethod>> entry : apiGroups.entrySet()) {
String interfaceName = toInterfaceName(entry.getKey());
List<ApiMethod> methods = entry.getValue();
String javaCode = generateApiInterface(interfaceName, methods, packageName);
writeJavaFile(outputDir, packageName, interfaceName, javaCode);
}
}
private Map<String, List<ApiMethod>> groupMethodsByTag() {
Map<String, List<ApiMethod>> apiGroups = new HashMap<>();
Map<String, JsonNode> paths = spec.getPaths();
for (Map.Entry<String, JsonNode> pathEntry : paths.entrySet()) {
String path = pathEntry.getKey();
JsonNode pathNode = pathEntry.getValue();
pathNode.fields().forEachRemaining(methodEntry -> {
String httpMethod = methodEntry.getKey();
JsonNode operation = methodEntry.getValue();
// Extract method information
String operationId = operation.path("operationId").asText(generateOperationId(path, httpMethod));
List<String> tags = extractTags(operation);
String tag = tags.isEmpty() ? "Default" : tags.get(0);
ApiMethod apiMethod = new ApiMethod(operationId, httpMethod.toUpperCase(), path);
apiMethod.setDescription(operation.path("description").asText(""));
apiMethod.setDeprecated(operation.path("deprecated").asBoolean(false));
// Extract parameters
extractParameters(operation, apiMethod);
// Extract return type
apiMethod.setReturnType(extractReturnType(operation));
// Add to appropriate group
apiGroups.computeIfAbsent(tag, k -> new ArrayList<>()).add(apiMethod);
});
}
return apiGroups;
}
private String generateApiInterface(String interfaceName, List<ApiMethod> methods, String packageName) {
StringBuilder sb = new StringBuilder();
// Package and imports
sb.append("package ").append(packageName).append(";\n\n");
sb.append("import ").append(config.getBasePackage()).append(".models.*;\n");
sb.append("import retrofit2.Call;\n");
if (config.isAsyncSupport()) {
sb.append("import retrofit2.Callback;\n");
}
sb.append("import retrofit2.http.*;\n");
sb.append("import java.util.*;\n\n");
// Interface documentation
sb.append("/**\n");
sb.append(" * ").append(interfaceName).append(" API\n");
sb.append(" */\n");
sb.append("public interface ").append(interfaceName).append(" {\n\n");
// Methods
for (ApiMethod method : methods) {
generateApiMethod(sb, method);
}
sb.append("}");
return sb.toString();
}
private void generateApiMethod(StringBuilder sb, ApiMethod method) {
// Method documentation
if (method.getDescription() != null && !method.getDescription().isEmpty()) {
sb.append("    /**\n     * ").append(method.getDescription()).append("\n");
// Parameter documentation
for (ApiParameter param : method.getParameters()) {
sb.append("     * @param ").append(param.getName()).append(" ");
if (param.getDescription() != null) {
sb.append(param.getDescription());
}
sb.append("\n");
}
sb.append("     */\n");
}
// Deprecation annotation
if (method.isDeprecated()) {
sb.append("    @Deprecated\n");
}
// HTTP method annotation
sb.append("    @").append(method.getHttpMethod()).append("(\"").append(method.getPath()).append("\")\n");
// Return type and method signature
String returnType = "Call<" + method.getReturnType() + ">";
sb.append("    ").append(returnType).append(" ").append(method.getName()).append("(");
// Parameters
List<String> params = new ArrayList<>();
for (ApiParameter param : method.getParameters()) {
String paramAnnotation = getParameterAnnotation(param);
String paramType = getParameterType(param);
params.add(paramAnnotation + " " + paramType + " " + param.getName());
}
sb.append(String.join(", ", params));
sb.append(");\n\n");
}
private String getParameterAnnotation(ApiParameter param) {
switch (param.getLocation()) {
case "query": return "@Query(\"" + param.getName() + "\")";
case "path": return "@Path(\"" + param.getName() + "\")";
case "header": return "@Header(\"" + param.getName() + "\")";
case "body": return "@Body";
default: return "@Query(\"" + param.getName() + "\")";
}
}
private String getParameterType(ApiParameter param) {
return param.getDataType() != null ? param.getDataType() : "String";
}
private String extractReturnType(JsonNode operation) {
JsonNode responses = operation.path("responses");
JsonNode successResponse = responses.path("200");
if (successResponse.has("content")) {
JsonNode content = successResponse.path("content");
if (content.has("application/json")) {
JsonNode schema = content.path("application/json").path("schema");
return getJavaTypeFromSchema(schema);
}
}
return "Void";
}
private String getJavaTypeFromSchema(JsonNode schema) {
// Simplified implementation - would need to handle $ref, arrays, etc.
String type = schema.path("type").asText("object");
if ("array".equals(type)) {
JsonNode items = schema.path("items");
String itemType = getJavaTypeFromSchema(items);
return "List<" + itemType + ">";
}
return "Object";
}
private List<String> extractTags(JsonNode operation) {
List<String> tags = new ArrayList<>();
JsonNode tagsNode = operation.path("tags");
if (tagsNode.isArray()) {
tagsNode.forEach(tag -> tags.add(tag.asText()));
}
return tags;
}
private void extractParameters(JsonNode operation, ApiMethod apiMethod) {
JsonNode parameters = operation.path("parameters");
if (parameters.isArray()) {
parameters.forEach(param -> {
String name = param.path("name").asText();
String in = param.path("in").asText("query");
String type = param.path("schema").path("type").asText("string");
ApiParameter apiParam = new ApiParameter(name, type, in);
apiParam.setRequired(param.path("required").asBoolean(false));
apiParam.setDescription(param.path("description").asText(""));
apiMethod.addParameter(apiParam);
});
}
}
private String generateOperationId(String path, String httpMethod) {
// Convert /users/{id} to getUserById
String operationId = path.replaceAll("[^a-zA-Z0-9]+", " ")
.trim()
.replaceAll("\\s+", " ");
String[] parts = operationId.split(" ");
StringBuilder result = new StringBuilder(httpMethod.toLowerCase());
for (String part : parts) {
if (!part.isEmpty()) {
result.append(part.substring(0, 1).toUpperCase())
.append(part.substring(1).toLowerCase());
}
}
return result.toString();
}
private String toInterfaceName(String tag) {
return toClassName(tag) + "Api";
}
private String toClassName(String name) {
return Arrays.stream(name.split("[^a-zA-Z0-9]"))
.map(part -> part.substring(0, 1).toUpperCase() + part.substring(1).toLowerCase())
.collect(Collectors.joining());
}
private void writeJavaFile(String outputDir, String packageName, String className, String content) throws IOException {
String packagePath = packageName.replace('.', '/');
Path filePath = Paths.get(outputDir, "src/main/java", packagePath, className + ".java");
Files.writeString(filePath, content);
}
}

5. Main Client Implementation

/**
* Generates the main API client implementation
*/
public class ClientImplementationGenerator {
private final GeneratorConfig config;
private final OpenApiSpec spec;
public ClientImplementationGenerator(GeneratorConfig config, OpenApiSpec spec) {
this.config = config;
this.spec = spec;
}
public void generateClientImplementation(String outputDir) throws IOException {
String className = config.getClientName();
String packageName = config.getBasePackage() + ".client";
String javaCode = generateClientClass(className, packageName);
writeJavaFile(outputDir, packageName, className, javaCode);
}
private String generateClientClass(String className, String packageName) {
StringBuilder sb = new StringBuilder();
// Package and imports
sb.append("package ").append(packageName).append(";\n\n");
sb.append("import ").append(config.getBasePackage()).append(".api.*;\n");
sb.append("import ").append(config.getBasePackage()).append(".config.*;\n");
sb.append("import okhttp3.*;\n");
sb.append("import retrofit2.Retrofit;\n");
sb.append("import retrofit2.converter.jackson.JacksonConverterFactory;\n");
sb.append("import java.util.*;\n");
sb.append("import java.util.concurrent.TimeUnit;\n\n");
// Class documentation
sb.append("/**\n");
sb.append(" * ").append(spec.getTitle()).append(" Client\n");
sb.append(" * Version: ").append(spec.getVersion()).append("\n");
if (spec.getDescription() != null && !spec.getDescription().isEmpty()) {
sb.append(" * ").append(spec.getDescription()).append("\n");
}
sb.append(" * Generated from OpenAPI specification\n");
sb.append(" */\n");
sb.append("public class ").append(className).append(" {\n\n");
// Fields
sb.append("    private final Retrofit retrofit;\n");
sb.append("    private final OkHttpClient okHttpClient;\n");
sb.append("    private final ApiConfig config;\n\n");
// API service instances
sb.append("    // API Services\n");
// Constructor
sb.append("    public ").append(className).append("(ApiConfig config) {\n");
sb.append("        this.config = config;\n");
sb.append("        this.okHttpClient = createHttpClient(config);\n");
sb.append("        this.retrofit = createRetrofit(config, okHttpClient);\n");
sb.append("    }\n\n");
// HTTP client creation
sb.append("    private OkHttpClient createHttpClient(ApiConfig config) {\n");
sb.append("        OkHttpClient.Builder builder = new OkHttpClient.Builder()\n");
sb.append("            .connectTimeout(config.getConnectTimeout(), TimeUnit.SECONDS)\n");
sb.append("            .readTimeout(config.getReadTimeout(), TimeUnit.SECONDS)\n");
sb.append("            .writeTimeout(config.getWriteTimeout(), TimeUnit.SECONDS);\n\n");
sb.append("        // Add interceptors\n");
sb.append("        if (config.isLoggingEnabled()) {\n");
sb.append("            builder.addInterceptor(new HttpLoggingInterceptor()\n");
sb.append("                .setLevel(HttpLoggingInterceptor.Level.BODY));\n");
sb.append("        }\n\n");
sb.append("        // Add authentication\n");
sb.append("        if (config.getApiKey() != null) {\n");
sb.append("            builder.addInterceptor(new ApiKeyInterceptor(config.getApiKey()));\n");
sb.append("        }\n\n");
sb.append("        return builder.build();\n");
sb.append("    }\n\n");
// Retrofit creation
sb.append("    private Retrofit createRetrofit(ApiConfig config, OkHttpClient client) {\n");
sb.append("        return new Retrofit.Builder()\n");
sb.append("            .baseUrl(config.getBaseUrl())\n");
sb.append("            .client(client)\n");
sb.append("            .addConverterFactory(JacksonConverterFactory.create())\n");
sb.append("            .build();\n");
sb.append("    }\n\n");
// API service getters
generateApiServiceGetters(sb);
// Close class
sb.append("}");
return sb.toString();
}
private void generateApiServiceGetters(StringBuilder sb) {
Map<String, List<ApiMethod>> apiGroups = new ApiInterfaceGenerator(config, spec).groupMethodsByTag();
for (String tag : apiGroups.keySet()) {
String interfaceName = toInterfaceName(tag);
String fieldName = toFieldName(interfaceName);
sb.append("    private ").append(interfaceName).append(" ").append(fieldName).append(";\n\n");
sb.append("    public ").append(interfaceName).append(" get").append(interfaceName).append("() {\n");
sb.append("        if (").append(fieldName).append(" == null) {\n");
sb.append("            ").append(fieldName).append(" = retrofit.create(").append(interfaceName).append(".class);\n");
sb.append("        }\n");
sb.append("        return ").append(fieldName).append(";\n");
sb.append("    }\n\n");
}
}
private String toInterfaceName(String tag) {
return toClassName(tag) + "Api";
}
private String toFieldName(String interfaceName) {
return interfaceName.substring(0, 1).toLowerCase() + interfaceName.substring(1);
}
private String toClassName(String name) {
return Arrays.stream(name.split("[^a-zA-Z0-9]"))
.map(part -> part.substring(0, 1).toUpperCase() + part.substring(1).toLowerCase())
.collect(Collectors.joining());
}
private void writeJavaFile(String outputDir, String packageName, String className, String content) throws IOException {
String packagePath = packageName.replace('.', '/');
Path filePath = Paths.get(outputDir, "src/main/java", packagePath, className + ".java");
Files.writeString(filePath, content);
}
}

6. Configuration and Interceptors

/**
* API Configuration class
*/
public class ApiConfig {
private String baseUrl;
private String apiKey;
private long connectTimeout = 30;
private long readTimeout = 30;
private long writeTimeout = 30;
private boolean loggingEnabled = false;
public ApiConfig(String baseUrl) {
this.baseUrl = baseUrl;
}
// Getters and setters
public String getBaseUrl() { return baseUrl; }
public void setBaseUrl(String baseUrl) { this.baseUrl = baseUrl; }
public String getApiKey() { return apiKey; }
public void setApiKey(String apiKey) { this.apiKey = apiKey; }
public long getConnectTimeout() { return connectTimeout; }
public void setConnectTimeout(long connectTimeout) { this.connectTimeout = connectTimeout; }
public long getReadTimeout() { return readTimeout; }
public void setReadTimeout(long readTimeout) { this.readTimeout = readTimeout; }
public long getWriteTimeout() { return writeTimeout; }
public void setWriteTimeout(long writeTimeout) { this.writeTimeout = writeTimeout; }
public boolean isLoggingEnabled() { return loggingEnabled; }
public void setLoggingEnabled(boolean loggingEnabled) { this.loggingEnabled = loggingEnabled; }
}
/**
* API Key Interceptor
*/
public class ApiKeyInterceptor implements Interceptor {
private final String apiKey;
public ApiKeyInterceptor(String apiKey) {
this.apiKey = apiKey;
}
@Override
public Response intercept(Chain chain) throws IOException {
Request original = chain.request();
Request.Builder builder = original.newBuilder();
// Add API key to header
if (apiKey != null && !apiKey.isEmpty()) {
builder.header("X-API-Key", apiKey);
}
Request request = builder.build();
return chain.proceed(request);
}
}
/**
* Authentication Interceptor for Bearer tokens
*/
public class AuthInterceptor implements Interceptor {
private final String token;
public AuthInterceptor(String token) {
this.token = token;
}
@Override
public Response intercept(Chain chain) throws IOException {
Request original = chain.request();
Request.Builder builder = original.newBuilder();
if (token != null && !token.isEmpty()) {
builder.header("Authorization", "Bearer " + token);
}
Request request = builder.build();
return chain.proceed(request);
}
}

7. Command Line Interface

/**
* Command Line Interface for the REST API Client Generator
*/
public class ClientGeneratorCLI {
public static void main(String[] args) {
if (args.length == 0) {
printHelp();
return;
}
GeneratorConfig config = new GeneratorConfig();
String specFile = null;
String outputDir = "generated-client";
for (int i = 0; i < args.length; i++) {
switch (args[i]) {
case "-i":
case "--input":
if (i + 1 < args.length) {
specFile = args[++i];
}
break;
case "-o":
case "--output":
if (i + 1 < args.length) {
outputDir = args[++i];
}
break;
case "-p":
case "--package":
if (i + 1 < args.length) {
config.setBasePackage(args[++i]);
}
break;
case "--http-client":
if (i + 1 < args.length) {
config.setHttpClientType(GeneratorConfig.HttpClientType.valueOf(args[++i].toUpperCase()));
}
break;
case "--no-lombok":
config.setUseLombok(false);
break;
case "--async":
config.setAsyncSupport(true);
break;
case "-h":
case "--help":
printHelp();
return;
}
}
if (specFile == null) {
System.err.println("Error: Input specification file is required");
printHelp();
return;
}
try {
RestApiClientGenerator generator = new RestApiClientGenerator(config);
generator.generateClient(specFile, outputDir);
} catch (Exception e) {
System.err.println("Error generating client: " + e.getMessage());
e.printStackTrace();
}
}
private static void printHelp() {
System.out.println("REST API Client Generator");
System.out.println("Usage:");
System.out.println("  java ClientGeneratorCLI -i openapi.json -o output-dir");
System.out.println();
System.out.println("Options:");
System.out.println("  -i, --input FILE      Input OpenAPI specification file (JSON/YAML)");
System.out.println("  -o, --output DIR      Output directory (default: generated-client)");
System.out.println("  -p, --package NAME    Base package name (default: com.api.client)");
System.out.println("  --http-client TYPE    HTTP client: OKHTTP, APACHE_HTTP_CLIENT, JAVA_HTTP_CLIENT");
System.out.println("  --no-lombok          Disable Lombok annotations");
System.out.println("  --async              Generate async methods");
System.out.println("  -h, --help           Show this help message");
}
}

8. Maven Build 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.apiclient</groupId>
<artifactId>rest-api-client-generator</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<jackson.version>2.15.2</jackson.version>
<retrofit.version>2.9.0</retrofit.version>
</properties>
<dependencies>
<!-- JSON/YAML Processing -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-yaml</artifactId>
<version>${jackson.version}</version>
</dependency>
<!-- HTTP Client (for generated clients) -->
<dependency>
<groupId>com.squareup.retrofit2</groupId>
<artifactId>retrofit</artifactId>
<version>${retrofit.version}</version>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.squareup.retrofit2</groupId>
<artifactId>converter-jackson</artifactId>
<version>${retrofit.version}</version>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>logging-interceptor</artifactId>
<version>4.11.0</version>
<optional>true</optional>
</dependency>
<!-- Lombok (for generated clients) -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.28</version>
<optional>true</optional>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<source>11</source>
<target>11</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

Usage Examples

Basic Usage

GeneratorConfig config = new GeneratorConfig("com.mycompany.api", "MyApiClient");
RestApiClientGenerator generator = new RestApiClientGenerator(config);
generator.generateClient("openapi.yaml", "my-generated-client");

Using the Generated Client

// Create configuration
ApiConfig config = new ApiConfig("https://api.example.com");
config.setApiKey("your-api-key");
config.setLoggingEnabled(true);
// Create client instance
MyApiClient client = new MyApiClient(config);
// Use generated API methods
User user = client.getUsersApi().getUserById(123).execute().body();
List<Product> products = client.getProductsApi().searchProducts("laptop").execute().body();

Command Line Usage

# Generate from OpenAPI spec
java ClientGeneratorCLI -i openapi.json -o my-client -p com.mycompany.api
# Generate with specific HTTP client
java ClientGeneratorCLI -i openapi.yaml -o client --http-client OKHTTP --async

Features

  • OpenAPI 3.0 Support: JSON and YAML specifications
  • Type-Safe Clients: Generated Java interfaces with Retrofit
  • Multiple HTTP Clients: OkHttp, Apache HttpClient, Java HttpClient
  • Authentication: API keys, Bearer tokens, OAuth2
  • Model Generation: POJOs with Jackson annotations
  • Customizable: Configurable package names, client options
  • Async Support: Optional asynchronous method generation
  • Comprehensive: Error handling, logging, timeouts

This generator creates production-ready REST API clients that follow Java best practices and provide excellent developer experience.

Category : JAVA

Leave a Reply

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


Macro Nepal Helper