Скачать или смотреть Generate OpenAPI Spec & Client Code from Spring Boot REST API

Hello and welcome, in this video, you'll learn how to generate an OpenAPI YAML file from a Spring Boot application and create client code from it.
OpenAPI is becoming the standard for describing REST APIs, making integration between different services much easier.

First, we’ll create a REST API using Spring Boot. Then, we’ll generate the OpenAPI specification as a YAML file. Finally,
I’ll show you how to generate client code to consume the API using that specification.

Let’s create a Spring Boot project in IntelliJ. We’ll use Maven as the build tool and add the Spring Web starter to set up our REST controller.

Inside the project, we’ll define a REST controller based on a User model. So, let’s start by creating the model class.
It will have two fields—name and age—and we’ll use Lombok’s @Data annotation to generate boilerplate code.

Next, we define our REST controller UserController with two endpoints: getUser, mapped to a GET request, and addUser, mapped to a POST request.
This forms a simple functional REST API.

Now to make the work easy for client to consume this api, there is a nice library called openAPI that helps to document the api and not only that, it provides a plugin that generate
the client code.


To make it easier for clients to consume this API, there's a powerful library called OpenAPI. It helps document the API and, on top of that, provides a plugin to automatically
generate client code.

All we need to do is add the Maven dependency and run the application. OpenAPI will then automatically generate the API specification in YAML format (or JSON, if you prefer). T
his specification will be available at the following URL:
Let’s take a look.

The file contains all the necessary information for the client to generate the client code (even manually, if needed).
You can also enhance the API documentation using OpenAPI annotations, such as the @Tag or @Operation annotations.


Now, using the specification YAML file, it's easy to generate the client code. Let’s assume the client is a Spring Boot application (other frameworks are also supported,
but for this demo, we’ll focus on Spring Boot). You can either generate the code directly within the Spring Boot project or create a separate JAR file containing the client code.
I prefer the latter approach, and I’ll demonstrate that here.

Let’s create another Maven project like this one. We’ll need to add the necessary dependencies to ensure the project compiles. This includes the Spring Boot Web starter, Jackson libraries,
and OpenFeign from Spring Cloud. I prefer using OpenFeign client, as it’s very convenient in the microservices world, but you could also use WebClient or RestTemplate.

In the resources folder, we add the specification YAML file. Then, in the pom.xml, we define the OpenAPI plugin.

In the plugin configuration, we need to specify the path to the specification file, like this. We also define the name of the API package and the output directory for the generated sources.
In the configOptions, you can specify that we want to use the Feign client by adding spring-cloud. This step is crucial.

All we need to do now is run mvn install. As you can see, the client code has been generated. Here is the model, and the API client is using Feign. Let’s take a look—the interface defines the
host of the remote API as a variable with a default value, which you can modify when generating the specification on the server side.

Now, you just need to add the generated artifact (for example, as a Maven dependency) to your project and enable scanning of the Feign client interfaces.

https://tramotech.de