Generating client code from spec in Spring Boot - Step-by-Step Execution

Concept Flow - Generating client code from spec

Start with API Spec (OpenAPI)

↓

Use Code Generator Tool

↓

Generate Client Code

↓

Integrate Client Code in Spring Boot App

↓

Use Client to Call API

↓

Run & Test

The flow starts with an API specification, uses a tool to generate client code, integrates it into a Spring Boot app, then calls the API and tests.

Execution Sample

Spring Boot

openapi-generator-cli generate \
  -i api-spec.yaml \
  -g java \
  -o ./generated-client \
  --library resttemplate

This command generates Java client code from an OpenAPI spec using RestTemplate library.

Execution Table

Step	Action	Input	Output	Notes
1	Read API Spec	api-spec.yaml	Parsed API model	OpenAPI spec file is loaded and parsed
2	Select Generator	java + resttemplate	Generator config set	Choose Java client with RestTemplate support
3	Generate Code	Parsed API model + config	Java client code files	Client classes and models created in output folder
4	Integrate Code	Generated code	Spring Boot project updated	Add generated code as source or module
5	Use Client	Client classes	API calls from app	Call API endpoints via generated client methods
6	Run & Test	Spring Boot app	API responses	Verify client calls work as expected
7	Exit	N/A	N/A	Process complete, client code ready to use

💡 All steps completed, client code generated and integrated successfully

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	Final
apiSpec	null	Parsed API model	Parsed API model	Parsed API model	Parsed API model
generatorConfig	null	null	Set to Java + RestTemplate	Set to Java + RestTemplate	Set to Java + RestTemplate
generatedCode	null	null	Java client code files	Java client code files	Java client code files integrated
springBootApp	Existing app	Existing app	Existing app	App with client code	App with client code and API calls

Key Moments - 3 Insights

Why do we need an API spec file before generating client code?

The API spec file describes the API endpoints and data models. The generator uses it to create matching client code. See execution_table step 1.

What happens if we choose the wrong generator or library?

The generated code might not work with your Spring Boot app or chosen HTTP client. Step 2 shows selecting the correct generator is important.

How do we use the generated client code in our app?

After generation, you add the code to your project and call its methods to make API requests, as shown in steps 4 and 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after Step 3?

A Spring Boot project updated

B Parsed API model

C Java client code files

D API responses

💡 Hint

Check the 'Output' column for Step 3 in the execution_table.

At which step is the client code integrated into the Spring Boot app?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look for 'Integrate Code' action in the execution_table.

If the API spec file is missing, which step will fail?

A Step 5

B Step 1

C Step 3

D Step 6

💡 Hint

Step 1 reads the API spec file; without it, parsing cannot happen.

Concept Snapshot

Generating client code from spec:
1. Start with an OpenAPI spec file describing the API.
2. Use a code generator tool (e.g., openapi-generator) with chosen language and library.
3. Generate client code files matching the API.
4. Add generated code to your Spring Boot app.
5. Use client methods to call API endpoints.
6. Run and test your app to verify calls work.

Full Transcript

This visual execution shows how to generate client code from an API specification in Spring Boot. First, the API spec file is read and parsed. Then, a code generator tool is configured to produce Java client code using RestTemplate. The generator creates client classes and models. Next, the generated code is integrated into the Spring Boot project. The app uses the client classes to call API endpoints. Finally, running the app tests the API calls. Key points include the importance of the API spec, choosing the right generator, and integrating the code properly.

Practice

1. What is the main benefit of generating client code from an API specification in Spring Boot projects?

easy

A. It automatically deploys the API to the cloud.

B. It saves time and reduces errors when calling APIs.

C. It replaces the need for a backend server.

D. It creates database schemas from the API.

Solution

1. Step 1: Understand the purpose of client code generation

   Generating client code means creating ready-to-use code to call APIs, which saves manual coding effort.

2. Step 2: Identify the main benefit in Spring Boot context

   This process reduces human errors and speeds up development by automating client creation.

3. Final Answer:

   It saves time and reduces errors when calling APIs. -> Option B

4. Quick Check:

   Client code generation = saves time and reduces errors [OK]

Hint: Remember: generated client code automates API calls [OK]

Common Mistakes:

• Thinking it deploys APIs automatically
• Confusing client code with backend code
• Assuming it creates database schemas

2. Which command correctly generates Spring client code using openapi-generator-cli from a spec file named api.yaml?

easy

A. openapi-generator-cli generate -i api.yaml -g spring -o ./client

B. openapi-generator-cli create -i api.yaml -g springboot -o ./client

C. openapi-generator-cli generate -i api.yaml -g java -o ./client

D. openapi-generator-cli build -i api.yaml -g spring -o ./client

Solution

1. Step 1: Identify the correct command syntax for code generation

   The command uses 'generate' to create code, '-i' for input spec, '-g' for generator type, and '-o' for output folder.

2. Step 2: Match the correct generator for Spring client code

   The generator name for Spring client code is 'spring', not 'springboot' or 'java'.

3. Final Answer:

   openapi-generator-cli generate -i api.yaml -g spring -o ./client -> Option A

4. Quick Check:

   Correct command = generate + -g spring [OK]

Hint: Use 'generate' and '-g spring' for Spring client code [OK]

Common Mistakes:

• Using 'create' or 'build' instead of 'generate'
• Using wrong generator name like 'springboot'
• Using '-g java' which is for Java server, not Spring client

3. Given the command openapi-generator-cli generate -i petstore.yaml -g spring -o ./client, what will be the main output?

medium

A. A Spring Boot server application implementing the API

B. A database migration script

C. A JavaScript client library for the API

D. A Spring client library to call the API endpoints

Solution

1. Step 1: Analyze the generator option '-g spring'

   The 'spring' generator creates Spring client code, not server code or JavaScript libraries.

2. Step 2: Understand the output folder './client'

   The generated code will be placed in './client' as a client library to call API endpoints.

3. Final Answer:

   A Spring client library to call the API endpoints -> Option D

4. Quick Check:

   Generator 'spring' = Spring client library [OK]

Hint: '-g spring' generates client code, not server or JS [OK]

Common Mistakes:

• Confusing client code with server implementation
• Expecting JavaScript code from Spring generator
• Thinking it creates database scripts

4. You ran openapi-generator-cli generate -i api.yaml -g springboot -o ./client but got an error: Unknown generator: springboot. What is the likely cause?

medium

A. You need to install Java separately.

B. The input file 'api.yaml' is missing.

C. You used the wrong generator name 'springboot' instead of 'spring'.

D. The output folder './client' already exists.

Solution

1. Step 1: Check the error message details

   The error says 'Unknown generator: springboot', indicating the generator name is invalid.

2. Step 2: Verify correct generator name for Spring client

   The correct generator is 'spring', not 'springboot'. Using 'springboot' causes this error.

3. Final Answer:

   You used the wrong generator name 'springboot' instead of 'spring'. -> Option C

4. Quick Check:

   Error 'Unknown generator' = wrong generator name [OK]

Hint: Check generator name spelling carefully [OK]

Common Mistakes:

• Typing 'springboot' instead of 'spring'
• Ignoring error details
• Assuming missing input file causes this error

5. You want to generate a Spring client from an OpenAPI spec but only want to include APIs tagged with 'user'. Which approach should you take?

hard

A. Modify the OpenAPI spec to only include 'user' tagged APIs before generation.

B. Manually delete unwanted APIs from the generated code after generation.

C. Use --ignore-file-override to exclude APIs by tag.

D. Use the --global-property apis=user option with openapi-generator-cli.

Solution

1. Step 1: Understand filtering options in openapi-generator-cli

   The CLI does not support filtering APIs by tag directly during generation.

2. Step 2: Consider practical ways to generate only 'user' APIs

   Modifying the OpenAPI spec to include only desired tags is the cleanest and recommended approach.

3. Final Answer:

   Modify the OpenAPI spec to only include 'user' tagged APIs before generation. -> Option A

4. Quick Check:

   Filter APIs by editing spec before generation [OK]

Hint: Filter APIs by editing spec before generating client [OK]

Common Mistakes:

• Expecting CLI to filter APIs by tag automatically
• Deleting code manually after generation (error-prone)
• Using unsupported CLI options for filtering