Skip to main content

API - How Tos

Aggregates / Rollups

How to implement ?

  • Database SQL has evolved to offer advanced aggregation and grouping abilities. Why not leverage it?
  • To get any type of aggregation on the data returned from your database and thru APIs, first create database views on the tables, with any/all table joins and groupings.
  • One can also join 2 views with each other for multi-level aggregations or transformations.
  • One can form multi-level view utilizing WITH blocks in SQL if supported by database being used.
  • Then import final view object into Builder Studio and generate code on it.
  • The APIs generated on such object will fullfill data aggregation needs of your business requirement.

Backend Templates


Templates are available for Spring Java backend. Coming soon for Express Node.js backend. One can low-code customize to implement them.

  • Pease refer to section Backend Templates

  • Code Coverage - SonarQube, JaCoCo

    • Code Coverage Analysis
  • Extend

    • Identifiers, @GeneratedValue
    • Validations
    • DTO (Data Transfer Object)
  • Security

    • OAuth2
    • Keycloak
    • Social (Google, Github, ...)
  • Logging - ELK (Elasticsearch, Logstash, and Kibana)

  • Integrating - Kafka, Kafka Streams

  • Testing

    • System Testing - Performance, Load testing
    • TDD (Test Driven Development)
    • Smoke Testing
    • BDD (Behavior-Driven Development)
  • Migrate to Spring Boot 3 (Spring Boot 3.2.3 and Java 17 or Java 21)

How to Use Redis Cache

Redis cache can store and retrieve data quickly to improve the performance of your APIs. It is primarily designed as an in-memory data store for high-performance, low-latency data access.

How to run Redis From Docker

docker pull redis:7.0.6-alpine
docker run --name my-redis -p6379:6379 -d redis

How to Stop redis docker container:

docker stop my-redis

Enable Redis Cache in

  • For dbrest REST APIs:

    • Edit emapi\app\dbrest\src\main\resources\
  • For dbgraphql GraphQL APIs:

    • Edit emapi\app\dbgraphql\src\main\resources\

Locate section as below and follow instructions to enable:

# ---- Disabled redis cache state -------------

# ---- Enable redis cache
# ---- By commenting above and un-commenting below -------------

Event-Driven Microservices - Kafka

Build Event-Driven Microservices applications using Spring Boot and Apache Kafka.

Available with EasyManage Templates : Backend Templates : Kafka

Kafka Streams

Kafka Streams enables the processing of streaming events.

Available with EasyManage Templates : Backend Templates : Kafka Streams

Distributed Transactions in Microservices

How to manage distributed transactions across multiple microservices and also solve the problem of distributed locking ?

Distributed transaction in microservices means a local transaction in the monolithic system is distributed into multiple services that will be called in a sequence.

Possible solutions

The following two patterns can resolve the problem:

  • Two-phase commit - 2pc
  • Saga Pattern

Two-phase commit - 2pc

Two-phase commit Is used in database systems, not so much good fit for microservices.

  • In microservices, it is implemented as per below.
  • Uses two phases - A prepare phase and a commit phase
  • With a Global Coordinator across microservices.
  • Gives strong consistency and guarantee that the transaction is atomic.
  • But is synchronous (blocking), need to lock the object till transaction completes.

Saga Pattern

In Saga Pattern

  • The distributed transaction is fulfilled by asynchronous local transactions on all related microservices. And finally completed.
  • The microservices communicate with each other through an event bus.
  • Each microservice fulfills its own local atomic transaction, other microservices are not blocked and there is no lock (kept throughout transaction) on any object.
  • Can be diffcult to debug and maintain.
  • Add a process manager as an orchestrator.
  • Please refer to earlier section on Event-Driven Microservices - Kafka to implement such event based transaction processing.

Serverless (Spring Java Backend)

Enabling Serverless

  • Go Serverless (Functions) with Spring Cloud Function

Spring Cloud Function

WHY ? / HOW ?

Spring Cloud Function - Goals:

- Promote the implementation of business logic via functions. 
- Decouple the development lifecycle of business logic from any specific runtime target
so that the same code can run as a web endpoint, a stream processor, or a task.

Spring Cloud Function provides the following features:
1. Wrappers for @Beans of type Function, Consumer and Supplier,
exposing them to the outside world as either HTTP endpoints
and/or message stream listeners/publishers with RabbitMQ, Kafka etc.

Spring Cloud Function embraces and builds on top of the 3 core java functional interfaces:
Function<I, O>

Please refer to Spring docs: Spring Cloud Function

How To Use

  • The generated code provides Templates For: Spring Cloud Function, e.g.
  • These can be Integrated Further with any target Cloud: AWS, GCP, or Azure

Leverage them and Trigger via AWS Lambda, or deploy Spring Cloud Functions on any of AWS, Azure or Google Cloud.

AWS Lambda

Please refer to Spring docs:

Microsoft Azure Functions

Please refer to Spring docs: Microsoft Azure Functions

Google Cloud Functions

Please refer to Spring docs: Google Cloud Functions