Generate a REST API Using Java for a Postgres database

This tutorial will show you how you can generate a rest API using Java for a 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.

What is Monstarillo

Monstarillo is a template based code generator that works against Postgres, MySQL and Oracle.

How it works 

Monstarillo runs templates that are executed by golang’s text template. The templates to run are identified in a json file. At a high level this file will identify the templates to execute, and where to put the output of the template. Monstarillo will also connect to a database and make metadata from the database available to your templates. This metadata includes column information (primary keys, column names, Golang, .Net, Java and Javascript datatypes) and table information (columns and relationships).

Monstarillo will connect to the database you provided and gather information about the tables. It then loops through all of the tables and runs each of your templates. If there are 10 tables in your database each of your template will be run 10 times, once for each table. Find out more at https://monstarillo.com.

Prerequisites

To follow along with this tutorial you will need:

• Monstarillo installed.
• 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 https://github.com/mrpatrickwright/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/shared-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/shared-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

You have now generated a rest API using Java for a Postgres database using monstarillo. You have also tested the API by executing of of the endpoints and viewed the documentation that was created for us using Springdoc.