Generate a REST API Using Java and Spring Boot for your Postgres database

This tutorial will show you how you can generate a Java API for your Postgres database using monstarillo. The API will use Spring Boot and Springdoc to document it. The API will perform CRUD operations on the tables you run it against. Unit tests will also be generated for the API.
To follow along with this tutorial you will need:

monstarilloinstalled.
A Postgres database – I will be using the chinhook database. Set up the Chinhook Sample Postgres Database in Docker
Java installed
A Java IDE – I will be using InteliJ
Git

The first step will be to get the templates that we will be using to generate our API. To do so clone the repo shared-templates. The templates we will be using are in the java-api folder.
Tell Monstarillo where to put the Generated code
Next you will need to decide where you want the generated code to be placed. I will be running Monstarillo through Docker. I will be exposing the directory ~/shared-volume to the docker image running Monstarillo. The shared-templates folder created by cloning the repo is in the ~/shared-volume folder. I will be generating code in ~/shared-volume/code-gen-output. Monstarillo will create the code-gen-output folder when it generates the code.

Modify the templates.json file
Monstarillo uses a json file to tell it which templates to run, how to run them, and what to name the files it generates and where to put them. We will be modifying the file java-api/postgres/templates.json. The templates array in the templates.json file tells Monstarillo which templates to run, what to name the files it creates and where to put them. The tags array in the templates.json file defines some “tags” that are used in templates and/or the templates.json. For example the PackagePath is used numerous time in the templates.json file. The PackagePath is used in a number of templates, the tag allows us to define it once. To run the templates you will need to modify TemplateRoot and OutputPath tags in the tags array.

*TemplateRoot *– Template root needs to point to the java-api folder in the repository that you cloned.
*OutputPath *– Output path need to point to the folder that you want Monstarillo to put the files it generates in. Monstarillo will create the folder if it does not already exist.
*PackageBase *– Used to set the package in classes
*ArtifactId *– Used in the generated POM.xml
*GroupId *– Used in the generated POM.xml
*ApplicationClassName *– Used as the name of the main class of the generated application
*ModelPropertySurrondString *– Used in the template that generates the models for the application. This is useful if your column names are camel cased.

I am running Monstarillo in docker so I will set the tags to:

{
   "tagName": "TemplateRoot",
   "value": "/usr/local/monstarillo/shared-templates/java-api"
},
{
   "tagName": "OutputPath",
   "value": "/usr/local/monstarillo/code-gen-output/java-01"
}

If I was running Monstarillo locally I would set the tags to:

{
   "tagName": "TemplateRoot",
   "value": "/home/patrick/code/patrick-templates/java-api"
},
{
   "tagName": "OutputPath",
   "value": "/home/patrick/code-gen-output/java-01"
}

Run Monstarillo to Generate The Code
Next we will build the command to run Monstarillo to generate the code for us. We will need to tell Monstarillo that we are using a Postgres database and provide the connection information. We will also need to tell Monstarillo which templates to run by passing the location of the templates.json file we set up earlier.

To run Monstarillo in docker our command will look similar to:

docker run --volume=/mnt/c/code:/usr/local/monstarillo \
--network=host \
monstarillo/monstarillo:latest postgres \
--t /usr/local/monstarillo/shared-templates/java-api/postgres/templates.json  \
--u postgres \
--p <Your Database Password> \
--db "chinhook-db" \
--host "localhost" \
--schema "public"
In this command I am mounting /mnt/c/code to the docker image as /usr/local/monstarillo that is running monstarillo. My shared-templates folder is at /mnt/c/code/shared-templates and will be generating code to /mnt/c/code/code-gen-output/java-01

If I were running Monstarillo locally my command would be:

monstarillo postgres \
--t /home/patrick/code/patricks-monstarillo-templates/java-api/templates.json  \
--u postgres \
--p <Your Database Password>\
--db "chinhook-db" \
--host "localhost" \
--schema "public"

When you run the command your output will be similar to:

Notice that Monstarillo prints out each table name and that it runs against. You may be able to use this information to troubleshoot errors in your command.

View Your Generated Code
Next you can view your code by opening the output directory you chose in your IDE of choice.

Next you will need to modify the application.properties file in your generated code to update your database connection information. The file can be found at src/main/resources/application.properties

In IntelliJ I will open the PersistApi class in the IDE and run it.

My new API is running and I can test it. I will use Postman. I can access the album controller at http://localhost:8080/album

You can also surf to http://localhost:8080/swagger-ui/index.html to see the generated OpenAPI definition for the generated code.

Notice the unit tests that have been generated in src/java/com.monstarillo.persist_api

Let me know what you think in the comments

The above is the detailed content of Generate a REST API Using Java and Spring Boot for your Postgres database. For more information, please follow other related articles on the PHP Chinese website!