Forem: Ahmad Mujahid

Generate UUID in PostgreSQL

Ahmad Mujahid — Thu, 01 Jan 2026 15:37:50 +0000

UUID is an important data type that we can utilize in relational database (RDS). There are two common ways to generate UUIDs in PostgreSQL: using the uuid-ossp extension or the pgcrypto extension. In this article, we will discuss how to generate UUIDs using both pgcrypto.

To use this function, make sure that the pgcrypto extension is enabled in your database. You can do this by running this command:

CREATE EXTENSION IF NOT EXISTS "pgcrypto";

Let's say, you have a table named candidate with a UUID column named id. You can create the table like this:

CREATE TABLE candidate (
    id UUID PRIMARY KEY,
    name TEXT
);

Once the extension is enabled, you can use the gen_random_uuid() function in your INSERT statement, for example:

INSERT INTO candidate (id, name) VALUES (gen_random_uuid(), 'Ahmad');

You can also use the gen_random_uuid() function to generate UUIDs multiple data in your table in a single insert query, for example :

INSERT INTO candidate (id, name) VALUES (gen_random_uuid(), 'Ahmad'), (gen_random_uuid(), 'Mujahid');

If you want to generate UUIDs for existing rows in your table, you can use the UPDATE statement like this:

UPDATE candidate SET id = gen_random_uuid() WHERE id IS NULL;

Pro Tip

You can set the id column to be generated automatically by using the DEFAULT keyword in your table definition so that you don't need to specify the UUID in your INSERT statement.

CREATE TABLE candidate (
    id UUID PRIMARY KEY DEFAULT
        gen_random_uuid(),
    name TEXT
);

Then, you can simply insert data without specifying the id:

INSERT INTO candidate (name) VALUES ('Ahmad');

From Java OOP to Golang

Ahmad Mujahid — Thu, 01 Jan 2026 15:26:18 +0000

As a Java developer, moving to Go can be a bit challenging, especially when it comes to understanding how Go handles object-oriented programming (OOP) concepts. In this article, I will represent some common OOP concepts in Java and how they can be implemented in Go. This will help you transition from Java to Go more smoothly (hopefully, lol).

How To Make Go Classes in Go? (Compared to Java)

Let's say we have a class in Java like this:

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

In Go, we can create a similar structure using structs. Here's how you can do it:

type Person struct {
    Name string
    Age  int
}

Go is more similar to C in this regard, where we use structs to define data types. We can also create methods for the struct, but Go does not have classes in the same way Java does.

Another example, we can create a service class in Java like this:

class PersonService {
    public Person createPerson(String name, int age) {
        return new Person(name, age);
    }
}

In Go, we can achieve a similar functionality using a struct and methods. Here's how you can do it:

type PersonService struct{}
func (ps *PersonService) CreatePerson(name string, age int) Person {
    return Person{Name: name, Age: age}
}

Classes in Go are not defined in the same way as in Java. Instead, we use structs to define data types and methods to define behaviors associated with those types.

How To Do Inheritance in Go (Compared to Java)

Inheritance in Java is very straightforward, where a class can extend another class. Here's an example in Java:

class Animal {
    public void speak() {
        System.out.println("Animal speaks");
    }
}
class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

As Java developers, inheritance in Go is a bit weird at first. Go doesn't have traditional inheritance like Java, but it supports composition through struct embedding. Here's how we can achieve similar functionality in Go:

type Animal struct{}
func (a Animal) Speak() {
    fmt.Println("Animal speaks")
}
type Dog struct {
    Animal // Embedding for inheritance
}
func (d Dog) Speak() {
    fmt.Println("Dog barks")
}

How To Do Interfaces in Go (Compared to Java)

In Java, we define interfaces like this:

interface Animal {
    void Speak();
}
class Dog implements Animal {
    @Override
    public void Speak() {
        System.out.println("Dog barks");
    }
}

In Go, we define interfaces similarly, but we don't use the implements keyword. Here's how you can do it:

type Animal interface {
    Speak()
}
type Dog struct{}
func (d Dog) Speak() {
    fmt.Println("Dog barks")
}

How To Do Dependency Injection in Go (Compared to Java)

In Java, we often use interfaces and constructor injection for dependency injection. Here's an example:

class Service {
    private final Repository repository;

    public Service(Repository repository) {
        this.repository = repository;
    }

    public void doSomething() {
        repository.save();
    }
}

In Go, we can achieve dependency injection using interfaces and struct embedding. Here's how you can do it:

type Repository interface {
    Save()
}
type Service struct {
    repo Repository
}
func NewService(repo Repository) Service {
    return Service{repo: repo}
}
func (s Service) DoSomething() {
    s.repo.Save()
}

That's it! You can see that Go has a different approach to OOP compared to Java, but it still allows you to implement similar concepts. The key differences are the use of structs instead of classes, the absence of traditional inheritance, and the way interfaces are defined and implemented.

Install SDKMAN in Ubuntu

Ahmad Mujahid — Thu, 01 Jan 2026 15:20:06 +0000

Hi guys, it's been a long time since my last blog post. So currently I play with Micronaut framework and find an interesting CLI tool to initiate Micronaut project locally (mn command).

I got a problem when installing SDKMAN in my Ubuntu WSL.

Based on this documentation (sdkman.io), I just need to run these commands

$ curl -s "https://get.sdkman.io" | bash

Then use this to register the command (sdk command)

$ source "$HOME/.sdkman/bin/sdkman-init.sh"

But turns out, I also need to install zip and unzip.

$ sudo apt install zip unzip

Then, this fixed my issue. That's it!
I hope i can write more in the future!

How to Export & Import Docker Image

Ahmad Mujahid — Sat, 25 Nov 2023 06:59:43 +0000

We can always pull docker images from docker registry. But, sometimes we need to share our images manually. In this post, I will share you how to import and export docker images.

Export Docker Image

Let say we have these two docker images in my local docker

$ docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
mysql         5.7       547b3c3c15a9   4 weeks ago     501MB
postgres      12        d480c196f9b0   3 months ago    405MB

We want to export postgres docker image. To do that, we can do that using docker export command like this :

$ docker export postgres > postgres.tar

Here are the explanation for this command. In general the command is like this :

$ docker export <image-name> > <output-name>.tar

change <image-name> with the image that you want to export
change <output-name> in to the output name you intended. The output file will be on .tar format.

Import Docker Image

Let say you want to import / load the exported docker image file (the .tar file). You can use docker load command like this :

$ docker load -i postgres.tar

In general, the command is like this :

$ docker load -i <tar-file>.tar

If the import / load is successful, you will see the image if you run docker images command.

That's all, very simple :)

External sources :

Move Your WSL2 to Another Drive

Ahmad Mujahid — Mon, 13 Nov 2023 15:45:14 +0000

Windows Subsystem Linux (WSL) is one of the most useful modern tools for software development, in my opinion. Since Windows offered this feature, we don't need to use fully virtualized Linux (using VMWare or VirtualBox) but can just use WSL that fully integrated with our Windows machine.

The downside of WSL is we can't choose the directory to install it. I will installed by default in our system drive (C drive). This maybe not a problem if we allocate huge amount of storage for our C drive. But, the case is we commonly not allocate much storage for our system drive because we thought we will only use this drive to install essential things.

But there is a solution for this, you can follow this steps :

1st step, Install Linux Distro

Assume you already install any Linux distro from Microsoft Store. In this example, I will use Ubuntu (you can use whatever you own). Let's say I installed Ubuntu 22.04 in my Windows machine. I will get my installed distro on the list if I execute wsl -l -v command like below.

PS> wsl -l -v
  NAME            STATE           VERSION
* Ubuntu-22.04    Running         2

2nd Export WSL instance

In this example, I will move my WSL instance (Ubuntu) to my E drive. You can open your PowerShell and run these commands :

PS> cd E:
PS> mkdir wsl2
PS> cd wsl2
PS> mkdir Ubuntu-22.04
PS> wsl --export Ubuntu-22.04 .\Ubuntu-22.04\ext4.vhdx --vhd
PS> wsl --unregister Ubuntu-22.04
PS> wsl --import-in-place Ubuntu-22.04 .\Ubuntu-22.04\ext4.vhdx

Let me explain these commands :

wsl --export is used to export the instance of Ubuntu-22.04 to ext4.vhdx inside Ubuntu-22.04 directory.
wsl --unregister is used to unregister existing WSL2 with name Ubuntu-22.04.
wsl --import-in-place is used to register/import instance that we just export (ext4.vhdx) as new Ubuntu-22.04.

3rd step, Set default user.

After importing the new instance, you will use root user by default. To change this to our user, we need to modify /etc/wsl.conf inside our WSL instance by adding this line :

[user]
default=<your-username>

Change <your-username> with username that you want to use.

That's all, really simple :)

External source :

Configure GitHub Actions Unit Test for Java Project (Plus code coverage with Jacoco)

Ahmad Mujahid — Mon, 24 Jul 2023 05:30:00 +0000

In this short article, we will talk about how to set up GitHub Actions for Java projects (such as Spring Boot projects). We also integrate Jacoco to produce code coverage information.

Configure Jacoco

We must set up Jacoco in our build.gradle file. The script is like this :

plugins {
    /* Other plugins */
    id 'jacoco'
}

/* Other configurations and dependencies */

test {
    testLogging {
        events "passed", "failed", "skipped"
    }
    finalizedBy jacocoTestReport
}

jacoco {
    toolVersion = "0.8.9"
}

jacocoTestReport {
    dependsOn test // tests are required to run before generating the report
    reports {
        xml.required = false
        csv.required = true
        html.outputLocation = layout.buildDirectory.dir('jacocoHtml')
    }
}

Here are some explanations :

plugins {
    /* Other plugins */
    id 'jacoco'
}

We must include Jacoco in plugins to use for the code coverage generator for the Java project.

test {
    testLogging {
        events "passed", "failed", "skipped"
    }
    finalizedBy jacocoTestReport
}

The testLogging part is optional. It's just to show you which test codes are passed, failed, and skipped.

jacocoTestReport {
    dependsOn test // tests are required to run before generating the report
    reports {
        xml.required = false
        csv.required = true
        html.outputLocation = layout.buildDirectory.dir('jacocoHtml')
    }
}

In this part, we set up which location to save the code coverage report in HTML pages. We can use this to see the code coverage information when we test the code on our local machine. For the case of GitHub Action, we only use the .csv output for code coverage. The image below is an example of Jacoco output. But, we don't use it for this case.

By default, jacoco will save the .csv output in build/reports/jacoco/test/jacocoTestReport.csv. We will use this to configure the GitHub Action script in the next step.

Configure GitHub Action workflow code

name: Java CI

on:
  pull_request:
    branches:
      - master

jobs:
  tests:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      - name: Grant execute permissions to Gradle wrapper
        run: chmod +x gradlew

      - name: Validate Gradle wrapper
        uses: gradle/wrapper-validation-action@ccb4328a959376b642e027874838f60f8e596de3

      - name: Run test
        run: ./gradlew test

      - name: Generate JaCoCo Badge
        uses: cicirello/jacoco-badge-generator@v2
        with:
          jacoco-csv-file: build/reports/jacoco/test/jacocoTestReport.csv

Here are some explanations :

name: Java CI

For this case, we name the GitHub Actions with Java CI. You can name it whatever you want.

on:
  pull_request:
    branches:
      - master

The on:pull_request specifies when the workflow should be triggered. In this case, we want the script to be triggered on each pull request. In this example, we set it for master branch. This means every time developers make a pull request to master branch, this workflow will be triggered.

jobs:
  tests:
    runs-on: ubuntu-latest

The jobs section defines the jobs that will run as part of the workflow. In this case, we named the job as tests.

runs-on: ubuntu-latest specifies the operating system environment in which the job will run. We use Ubuntu's latest version for this example.

    steps:
      - uses: actions/checkout@v3

      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      - name: Grant execute permissions to Gradle wrapper
        run: chmod +x gradlew

      - name: Validate Gradle wrapper
        uses: gradle/wrapper-validation-action@ccb4328a959376b642e027874838f60f8e596de3

      - name: Run test
        run: ./gradlew test

      - name: Generate JaCoCo Badge
        uses: cicirello/jacoco-badge-generator@v2
        with:
          jacoco-csv-file: build/reports/jacoco/test/jacocoTestReport.csv

The steps section contains a list of steps that will be executed as part of the job.

uses: actions/checkout@v3: This step checks out the repository's code, allowing subsequent steps to access and interact with the project files.
name: Set up JDK 17: This step sets up JDK 17 on the runner environment. The action actions/setup-java is used to do this.
run: chmod +x gradlew: This step grants execute permissions to the Gradle wrapper script, allowing it to be executed in the next step.
name: Validate Gradle wrapper: This step uses the gradle/wrapper-validation-action to validate the Gradle wrapper.
run: ./gradlew test: This step runs the test task of Gradle using the Gradle wrapper. The test task is responsible for executing the tests of the Java project.
name: Generate JaCoCo Badge: This step uses the cicirello/jacoco-badge-generator action to generate a code coverage badge. The badge is based on the JaCoCo test coverage data stored in the jacocoTestReport.csv file, which is typically generated by the Gradle build during the test execution.

Let's give a test

The Workflow

To test whether your workflow is working or not, you must create a pull request to your GitHub repository. You can follow this GitHub documentation on how to create a pull request (PR).

If all tests are passed, you will get this notification on your PR :

Otherwise, you will get a failed notification. You can use this information to consider whether you will accept the PR or not.

You can click Show all checks to see the details. If you enter the details, you will see some information about the workflow that just ran.

Inside the Run test part, you can see the detail about the test execution.

Code Coverage

To get the code coverage information, Open your Github repository > Actions. Then, you will get the list of all previously executed workflows, like this, the list is timely ordered :

If you choose one of them, you will get this :

In the test summary part, you can see your code coverage.

Conclusion

Automated unit testing is an important part of CI (Continuous Integration) in the software development life cycle. By utilizing GitHub Actions to handle unit tests, we automate one aspect of CI in our software development.

Additional Resource

Dockerize Your Spring Boot App

Ahmad Mujahid — Sun, 02 Jul 2023 02:25:14 +0000

Docker has revolutionized the way how we develop our apps. It removes the "it works in my machine" problem from the stack of problems during development software.

In my opinion, Docker is one of the mandatory things you should add to your tech stack as many job applications (mostly for back-end engineers) add knowledge in Docker as their requirement. So, learn Docker to stay up-to-date!

What is Docker

Let's see how popular platforms describe what Docker is.

Docker is a software platform that allows you to build, test, and deploy applications quickly. Docker packages software into standardized units called containers that have everything the software needs to run including libraries, system tools, code, and runtime. Using Docker, you can quickly deploy and scale applications into any environment and know your code will run. -- AWS --

Docker is an open-source platform that enables developers to build, deploy, run, update and manage containers—standardized, executable components that combine application source code with the operating system (OS) libraries and dependencies required to run that code in any environment. -- IBM --

Docker is an open platform for developing, shipping and running applications. With Docker, you can separate your applications from your infrastructure and treat your infrastructure like a managed application. Docker helps you ship code faster, test faster, deploy faster, and shorten the cycle between writing code and running code. Docker does this by combining kernel containerization features with workflows and tooling that helps you manage and deploy your applications. -- Google --

In short, Docker can be a tool that can make your development journey run smoother and faster than without it. It allows you to build, package, and deploy applications quickly. It helps you to manage dependencies to run your app. Docker also facilitates faster code shipping, testing, and deployment, reducing the time between code development and execution.

There are 6 core components of Docker you must know :

Docker Engine. The core component of Docker. It is responsible for building and running containers. Docker Engine manages the lifecycle of containers, including image management, container execution, and resource isolation. It consists of :
- the Docker daemon, which runs on the host machine.
- the Docker client, which provides a comment-line interface (CLI) for interacting with the daemon.
Docker Images. A read-only template that contains the necessary files and dependencies to run an application in a container. Images are built from Dockerfile, which are text files that specify the instructions for creating the image. Images also can be pulled from Docker Hub or other image registries.
Docker Containers. A running instance of Docker Images. It provides an isolated environment application for the application to run, ensuring that the application and its dependencies are consistent across different environments.
Docker Registry. A central repository for storing and distributing Docker Images such as Docker Hub.
Docker Compose. A tool for defining and managing multi-container applications. It uses a YAML file to describe the services, networks, and configurations required for an application.
Docker Swarm. A native clustering and orchestration solution provided by Docker. It allows users to create and manage a swarm of Docker nodes, forming distributed system.

How Docker Works

To know how Docker works, it's better to compare it with the older technology, a virtual machine (VM).

I took this image from AWS - What is Docker? article.

In a traditional VM, each application stands above an independent virtual OS. Of course, this approach provides perfect isolation for each application. But, this gives us a huge cost to run all VMs as a consequence. That consequence is the problem we want to solve by using Docker. Instead of virtualizing an OS for each application, we can leverage Docker Engine to manage all applications (as containers) to run independently (fully isolated). It's also more simple to manage dependencies with Docker instead of VM.

Let's Dockerize your Spring Boot App

For this project, you can use my provided repository here from my GitHub as an example.

The first step, you need to build your Spring Boot app. By using this command below. It will produce a runnable .jar file from your Spring Boot app.

$ ./gradlew build

Secondly, make a Dockerfile file inside your project's root directory. Fill the file with the code below.

FROM openjdk:17-oracle
EXPOSE 8080
RUN mkdir -p /app/
ADD build/libs/spring-docker-demo-0.0.1-SNAPSHOT.jar /app/example.jar
ENTRYPOINT ["java", "-jar", "/app/example.jar"]

Thirdly, make a docker-compose.yml file in your root directory with the code below.

version: '3'
services:
  example-project:
    ports:
      - 8080:8080
    image: example-project
    build:
      context: .
      dockerfile: Dockerfile
    container_name: example-project
    restart: always

Fourthly, we use the docker-compose command to build a docker image, create the container from the image, and then run it. It will take a while sometimes because we need to download the necessary dependencies to run the container.

$ docker-compose up -d

Sixthly, after installation is finished. You can check whether it is successful by using docker ps command. If you can find your new container on the list, you have succeeded and it is already running.

$ docker ps
CONTAINER ID   IMAGE             COMMAND                  CREATED          STATUS          PORTS                    NAMES
133109f2d973   example-project   "java -jar /app/exam…"   20 seconds ago   Up 18 seconds   0.0.0.0:8080->8080/tcp   example-project

Lastly, this means you already installed your Spring Boot app in a docker environment. You can try to hit the API using HTTP client app link curl, Postman, or even directly from your browser.

$ curl http://localhost:8080
{"message":"Hello World!"}

Conclusion

From now, let's learn Docker! It is necessary to add to your skill set for becoming an up-to-date software engineer.

Wish you have a good experiment moment!

SOLID Principles in a Nutshell

Ahmad Mujahid — Fri, 23 Jun 2023 12:58:42 +0000

I think one of the most important sets of principles that should be understood by all software engineers is SOLID principles (not the only one, but the most basic). By understanding this principle, we assume that we'll be able to deliver good, cleaner and maintainable codes.

SOLID is an acronym that stands for Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. It's a best practice for developing a program using object-oriented programming.

There are so many articles that have discussed it. But, I think it is still a worthy topic to rediscuss about. Let's try to discuss this in the easiest way possible. This article also includes example codes in Java.

Single Responsibility Principle

The main goal of this principle is a single class should only responsible for one purpose. That means we will violate this principle if we create a class that consists of multiple purposes.

By following this principle, it will give us benefits:

Our code will be more modular.
This can be easier for us to trace our code in the future as we already determine the specific purpose of each class.

Wrong example

public class Person {
    private String firstname;
    private String lastname;
    private String origin;
    private String age;
    private String sex;

    //constructor, getters and setters

    // methods that directly relate to the person properties
    public String returnFullName() {
        return firstname + " " + lastname;
    }
}

Then we add the storeInDatabase method.

public class Person {
    private String firstname;
    private String lastname;
    private String origin;
    private String age;
    private String sex;

    //constructor, getters and setters

    // methods that directly relate to the person properties
    public String returnFullName() {
        return firstname + " " + lastname;
    }

    public void storeInDatabase(Person person) {
        // codes that perform database action
    }
}

What goes wrong :

storeInDatabase is not directly related to or responsible for Person class.

Correct example

To fix this, we can put storeInDatabase method in a new class, let say PersonDatabase class.

public class PersonDatabase {

    public void storeInDatabase(Person person) {
        // codes that perform database action
    }
}

Open-Closed Principle

This principle emphasizes in a class should be open for extension but closed for modification.

The benefit of following this principle is we don't modify the existing code which can probably cause new bugs. (But, it's an exception for bugs in existing code, you should fix it, not extend it 😁).

Example

Suppose that we have Car class like below.

public class Car {
    private String brand;
    private String color;

    // constructors, getters, and setters
}

Then, we want a Truck class that has the same properties with Car class, with some additions. Instead of modifying Car class, we can extend it to Truck class like below.

public class Truck extends Car {
    private int cargoVolume;

    // constructors, getters, and setters
}

By doing so, we don't need to modify the Car class that might be already used in some part of our program.

If you want to create another class like Ambulance class in the future, you can extend the Car class like you did with Truck class.

public class Ambulance extends Car {
    private hasbloodPressureGague;
    private hasThermometer;

    // constructors, getters, and setters
}

Liskov Substitution Principle

This principle is arguably the most complex principle among these 5 principles. The simple meaning of this principle may be a subclasses should be substitutable for their base classes.

Let say, Toyota class is a subclass of Car class. Toyota class should be able to replace Car class without disrupting the behavior of our program. Show this example :

class Car {
    private String brand;

    public Car(String brand) {
        this.brand = brand;
    }

    public void startEngine() {
        System.out.println("Engine started.");
    }

    public void stopEngine() {
        System.out.println("Engine stopped.");
    }
}

class Toyota extends Car {
    public Toyota() {
        super("Toyota");
    }

    @Override
    public void startEngine() {
        System.out.println("Toyota engine started.");
    }

    @Override
    public void stopEngine() {
        System.out.println("Toyota engine stopped.");
    }

    public void engageAutopilot() {
        System.out.println("Autopilot engaged.");
    }
}

In this Java example, the Car class represents a generic car and a Toyota class represents a specific type of car (Toyota brand) that extends the behavior of the base class.

We can use the Car class and the Toyota class interchangeably, as demonstrated below:

public class Main {
    public static void startCar(Car car) {
        car.startEngine();
    }

    public static void stopCar(Car car) {
        car.stopEngine();
    }

    public static void engageAutopilot(Car car) {
        if (car instanceof Toyota) {
            Toyota toyota = (Toyota) car;
            toyota.engageAutopilot();
        } else {
            System.out.println("Autopilot not available for this car.");
        }
    }

    public static void main(String[] args) {
        Car myCar = new Car("SomeBrand");
        startCar(myCar);    // Output: Engine started.
        stopCar(myCar);     // Output: Engine stopped.

        Toyota myToyota = new Toyota();
        startCar(myToyota);    // Output: Toyota engine started.
        stopCar(myToyota);     // Output: Toyota engine stopped.

        engageAutopilot(myCar);     // Output: Autopilot not available for this car.
        engageAutopilot(myToyota);  // Output: Autopilot engaged.
    }
}

The startCar() and stopCar() methods accept a Car object as a parameter. We can pass both a Car instance (myCar) and a Toyota instance (myToyota) to these methods without any issues.

The engageAutopilot() method checks if the provided Car object is an instance of Toyota. If it is, it casts it to a Toyota object and calls the engageAutopilot() method. Otherwise, it handles the case where autopilot functionality is not available for non-Toyota cars. This demonstrates the usage of the Toyota class as a subtype of the Car class without violating the Liskov substitution principle.

Interface Segregation Principle

Segregation means keeping different things separate. This principle is about separating interfaces based on their purpose.

The principle states that many client-specific interfaces are better than one general-purpose interface. Clients should not be forced to implement a function they do not need.

interface Worker {
    void work();
    void sleep();
}

Let's say that we have 2 classes that implement Worker interface, Programmer and Robot class.

class Programmer implements Worker {
    public void work() {
        System.out.println("Programmer is working.");
        // Perform programming tasks
    }

    public void sleep() {
        System.out.println("Programmer is sleeping.");
        // Sleep at night
    }
}

class Robot implements Worker {
    public void work() {
        System.out.println("Robot is working.");
        // Perform robotic tasks
    }

    // Can't be implemented
    public void sleep() {
        // Robots don't sleep!
        throw new UnsupportedOperationException("Robots don't sleep!");
    }
}

As we see, sleep() method can be implemented by the Programmer class, but not by Robot class. To solve this, we can split Worker interface.

interface Worker {
    void work();
}

interface LifeBeing {
    void sleep();
}

The Programmer class now implements all two interfaces, as it performs all the associated actions. However, the Robot class only implements the Worker interface, as it doesn't need to sleep.

class Programmer implements Worker, LifeBeing {
    public void work() {
        System.out.println("Programmer is working.");
        // Perform programming tasks
    }

    public void sleep() {
        System.out.println("Programmer is sleeping.");
        // Sleep at night
    }
}

class Robot implements Worker {
    public void work() {
        System.out.println("Robot is working.");
        // Perform robotic tasks
    }
}

Dependency Inversion Principle

This principle refers to the decoupling of the software modules. Dependency inversion is a design principle in object-oriented programming that states that high-level modules should not depend on low-level modules. Instead, both should depend on abstractions.

// High-level module
class EmployeeTracker {
    private EmployeeService employeeService;

    public EmployeeTracker(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    // other methods
    }
}

// Abstraction (interface) for employee service
interface EmployeeService {
    String getBranch(String employeeId);
    String getWage(String employeeId);
    String getPosition(String employeeId);
}

// Low-level module implementing the employee service
class EmployeeServiceImpl implements EmployeeService {
    public String getBranch(String employeeId) {
        // Logic to retrieve employee data
        return employee.getBranch();
    }
    public String getWage(String employeeId) {
        // Logic to retrieve employee data
        return employee.getWage();
    }
    public String getPosition(String employeeId) {
        // Logic to retrieve employee data
        return employee.getPosition();
    }
}

High-level module called EmployeeTracker needs to retrieve employee data. Instead of directly depending on the specific implementation, it depends on the EmployeeService abstraction/interface.

The EmployeeServiceImpl class is a low-level module that implements the EmployeeService interface. It contains the specific implementation details for retrieving employee data, such as making API calls.

EmployeeTracker class doesn't depend on these implementation details, promoting loose coupling and ensuring that the high-level module is not tightly coupled to specific low-level modules.

By applying this principle, we invert the dependency relationship between high-level and low-level modules. The high-level module depends on abstractions, while the low-level modules depend on those abstractions. This promotes modular and flexible code design.

Conclusion

That's all a short explanation of SOLID principles. You can boost your code quality by applying these principles to your code. There are several benefits we'll get by following these principles :

Maintainability: Easier code maintenance and modification.
Scalability: Ability to add new features without modifying existing code.
Testability: Facilitates effective unit testing and code verification.
Reusability: Creation of reusable and interchangeable components.
Flexibility: Greater adaptability and ability to switch implementations.
Readability and Understandability: Clear, organized code structure for easier comprehension and collaboration.

Additional Resources

A Solid Guide to SOLID Principles from Baeldung
The SOLID Principles of Object-Oriented Programming Explained in Plain English from freeCodeCamp
What are the SOLID principles in Java? from educative

What is Test Driven Development (TDD) and Why It Matters

Ahmad Mujahid — Fri, 16 Jun 2023 17:09:14 +0000

The first time I heard about Test Driven Development (TDD), it sounds weird to me. Many questions came to my mind :

How can we develop a code based on the test scenarios?
How can be possible to code your tests before your actual functionality codes?
Is it effective?
So on and so forth.

Perhaps, It happens all the time to developers the first time they overcome TDD. But, as time passes and you do a lot of implementation of TDD, you will find how beneficial it is. In this short article, I will introduce you to what TDD is, how we can implement it, and what benefits it gives to us. Additionally, I will show you a simple example of how we implement it in Java.

What is Test Driven Development?

Test Driven Development (TDD) is one of the lists of famous software development processes that are often used in the software development life cycle (SDLC).

The point of Test Driven is the development process is rely on software requirements being converted to test cases before it is fully developed. Then, we can track our development process based on the test cases that we have described previously.

An expert like Kent Beck once said about TDD :

“If you're happy slamming some code together that more or less works and you're happy never looking at the result again, TDD is not for you. TDD rests on a charmingly naïve geekoid assumption that if you write better code, you'll be more successful. TDD helps you to pay attention to the right issues at the right time so you can make your designs cleaner, you can refine your designs as you learn.”

Using TDD means you will build the building block of your logic iteratively. That means you won't skip every detail of your logic and also won't add unnecessary features. At the end, you get a clean code and design.

Red, Green, Refactor (RGR)

To apply TDD in our project, we follow the red, green, refactor (RGR) approach.

This approach will help developers to split their focus in the development processes. The meaning for every phase of the RGR approach are :

Red
- Define the test cases of the method that going to be tested
- Define the behaviors/expectations of the method
- In this phase, we will get failed on the test cases we defined earlier. It's normal in the TDD process because we fix it later.
Green
- Implement the necessary logic to make your method pass the test.
- The goal is just to pass the test! Optimization and code efficiency come later.
Refactor
- Improve your implementation!
- In this phase, don't add new functionality to your code, just optimize it.

Additionally, there are three simple rules to apply TDD from Uncle Bob :

You are not allowed to write any production code unless it is to make a failing unit test pass.
You are not allowed to write any more of a unit test than is sufficient to fail; and compilation failures are failures.
You are not allowed to write any more production code than is sufficient to pass the one failing unit test.

Benefits of TDD

By implementing TDD, you will get benefits such as :

High code coverage

The most beneficial point of TDD is code coverage. Our development is driven by test cases, so it means we declared all behavior that happens in our code and that means we already know how our codes will behave before we code it.

Well-defined logic for your codes

In TDD, we improve the logic iteratively. Start from the most simple implementation to the more complex (the final goal of our method implementation). It also makes us easier to manage the logic as we split the implementation into smaller pieces.

Early prevention of bugs in the development process

By providing tests, you can ensure that all your code works as expected. Adding new functionality or making updates sometimes leads to violations of your existing codes. This violation can be early detected through tests. So, you will get a warning before pushing flawed code to production.

Improved quality of your code

By driving with tests, you already know the specifications you aim in the beginning of the process so every unnecessary part can be eliminated and your code is clean.

Simple Example

FizzBuzz Problem

In this example, we will make a FizzBuzz problem. I believe some of you are already familiar with this problem, FizzBuzz problem is one of the famous coding problems for code interviews. The criteria for the FizzBuzz problem are :

if the input number is divisible by 3, print "Fizz"
if the input number is divisible by 5, print "Buzz"
if the input number is divisible by both 3 and 5, print "FizzBuzz"
other than that, print the input as a string.

Initialization

Following the rule of TDD, we must declare our test case first before our actual class. To initialize, we write the test code like below.

import org.junit.Assert;
import org.junit.Test;

public class FizzBuzzConverterTest {

    // First cycle test
    @Test
    public void givenNumberString_whenNotDivisibleByThreeOrFive() {
        FizzBuzzConverter converter = new FizzBuzzConverter();
    }
}

Notice that you will get an error with this code. It's expected as we haven't declare FizzBuzzConverter class. You can declare it in your resource (commonly src) folder. If you are using an IDE or kind of "smart" text editor, you can leverage its auto-generate feature.

This is the initialization part of our TDD. We create a minimal class. As you can see, we initialize it's an empty class without any methods.

public class FizzBuzzConverter {
}

First Cycle

Now, we enter the first cycle of our TDD implementation. We do a slight modification to our code test like below by adding two assertions. Assertion is an important part of code testing. we will do a comparison between the expected output and the actual output of the method. If the actual method outputs the same value as the expected value, the assertion will be passed. Otherwise, won't pass.

import org.junit.Assert;
import org.junit.Test;

public class FizzBuzzConverterTest {

    // First cycle test
    @Test
    public void givenNumberString_whenNotDivisibleByThreeOrFive() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("1", converter.convertNumberToFizzBuzz(1));
        Assert.assertEquals("2", converter.convertNumberToFizzBuzz(2));
    }
}

Also, we will get an error with the code above because we haven't created convertNumberToFizzBuzz method in FizzBuzzConverter class yet. To fix this, you must declare convertNumberToFizzBuzz method.

public class FizzBuzzConverter {
    public String convertNumberToFizzBuzz(int number) {
        return null;
    }
}

Now we can test our code. In this phase, we expect convertNumberToFizzBuzz method to return the string of each integer input. But in fact, it returns an ERROR instead. That's why we need to modify convertNumberToFizzBuzz method like the code below.

public class FizzBuzzConverter {
    public String convertNumberToFizzBuzz(int number) {
        return String.valueOf(number);
    }
}

This refactor will give us a pass on the first cycle test scenario.

Second Cycle

We iteratively add necessary test scenarios. Now, we must test the condition when the input number is divisible by 3. So, we should update our test class with the code below.

import org.junit.Assert;
import org.junit.Test;

public class FizzBuzzConverterTest {

    // First cycle test
    @Test
    public void givenNumberString_whenNotDivisibleByThreeOrFive() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("1", converter.convertNumberToFizzBuzz(1));
        Assert.assertEquals("2", converter.convertNumberToFizzBuzz(2));
    }

    // Second cycle test
    @Test
    public void givenFizz_whenDivisibleByThree() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("Fizz", converter.convertNumberToFizzBuzz(3));
        Assert.assertEquals("Fizz", converter.convertNumberToFizzBuzz(6));
    }
}

Like the first cycle, it returns an ERROR because we haven't implemented this scenario yet in our code. So, we should update our code to get the GREEN code for this cycle. The update is like this below.

public class FizzBuzzConverter {
    public String convertNumberToFizzBuzz(int number) {
        if (number % 3 == 0)
            return "Fizz";
        return String.valueOf(number);
    }
}

Third Cycle

Like the second cycle, now we will make the test for the next scenario. We should add a new test method to test the condition when the input number is divisible by 5.

import org.junit.Assert;
import org.junit.Test;

public class FizzBuzzConverterTest {

    // First cycle test
    @Test
    public void givenNumberString_whenNotDivisibleByThreeOrFive() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("1", converter.convertNumberToFizzBuzz(1));
        Assert.assertEquals("2", converter.convertNumberToFizzBuzz(2));
    }

    // Second cycle test
    @Test
    public void givenFizz_whenDivisibleByThree() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("Fizz", converter.convertNumberToFizzBuzz(3));
        Assert.assertEquals("Fizz", converter.convertNumberToFizzBuzz(6));
    }

    // Third cycle test
    @Test
    public void givenBuzz_whenDivisibleByFive() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("Buzz", converter.convertNumberToFizzBuzz(5));
        Assert.assertEquals("Buzz", converter.convertNumberToFizzBuzz(10));
    }
}

ERROR again! it's time to extend the implementation to cover the scenario.

public class FizzBuzzConverter {
    public String convertNumberToFizzBuzz(int number) {
        if (number % 3 == 0)
            return "Fizz";
        if (number % 5 == 0)
            return "Buzz";
        return String.valueOf(number);
    }
}

This code above should let you pass all three scenarios.

Fourth Cycle

Don't forget, we still have 1 scenario left. We must test if the method will return "FizzBuzz" if the input is divisible both by 3 and 5.

import org.junit.Assert;
import org.junit.Test;

public class FizzBuzzConverterTest {

    // First cycle test
    @Test
    public void givenNumberString_whenNotDivisibleByThreeOrFive() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("1", converter.convertNumberToFizzBuzz(1));
        Assert.assertEquals("2", converter.convertNumberToFizzBuzz(2));
    }

    // Second cycle test
    @Test
    public void givenFizz_whenDivisibleByThree() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("Fizz", converter.convertNumberToFizzBuzz(3));
        Assert.assertEquals("Fizz", converter.convertNumberToFizzBuzz(6));
    }

    // Third cycle test
    @Test
    public void givenBuzz_whenDivisibleByFive() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("Buzz", converter.convertNumberToFizzBuzz(5));
        Assert.assertEquals("Buzz", converter.convertNumberToFizzBuzz(10));
    }

    // Fourth cycle test
    @Test
    public void givenBuzz_whenDivisibleByThreeANdFive() {
        FizzBuzzConverter converter = new FizzBuzzConverter();

        Assert.assertEquals("FizzBuzz", converter.convertNumberToFizzBuzz(15));
        Assert.assertEquals("FizzBuzz", converter.convertNumberToFizzBuzz(30));
    }
}

As usual before an ERROR again. So, we must apply an enhancement to our code.

public class FizzBuzzConverter {
    public String convertNumberToFizzBuzz(int number) {
        if (number % 15 == 0)
            return "FizzBuzz";
        if (number % 3 == 0)
            return "Fizz";
        if (number % 5 == 0)
            return "Buzz";
        return String.valueOf(number);
    }
}

As divisible by 3 and 5 also means divisible by 3x5, we can apply the improvement above.

Final Refactorization

public class FizzBuzzConverter {
    public String convertNumberToFizzBuzz(int number) {
        StringBuilder result = new StringBuilder();

        if (number % 3 == 0)
            result.append("Fizz");
        if (number % 5 == 0)
            result.append("Buzz");

        return result.length() > 0 ? result.toString() : String.valueOf(number);
    }
}

Finally, we can refactor our after all of the test cases are passed. We do a refactoring to make convertNumberToFizzBuzz method is more elegant. Note that we shouldn't add new features or functionalities in this phase as this act will possibly impact our established tests.

But, it doesn't mean you can't do any modifications in the future. You can adjust the method by doing another TDD procedure in the future.

Improve Your Test Code

There are several things we can do to improve our test code, such as :

Structured your code with the Arrange-Act-Assert (AAA) pattern

The AAA pattern is a descriptive and intention-revealing way to structure the test cases. It describes an order of operations inside each of the test functions :

Arrange: contains the set-up logic for the tests. We do such as object initialization and prepare the execution for the system under test (SUT).
Act: invokes the things (method or API) that we are about to test.
Assert: verifies that action of the SUT behaves as expected.

Here is an example of improvement for our test code :

import org.junit.Assert;
import org.junit.Test;

public class FizzBuzzConverterTest {

    @Test
    public void givenNumberString_whenNotDivisibleByThreeOrFive() {
        // Arrange
        FizzBuzzConverter converter = new FizzBuzzConverter();

        // Act
        String result1 = converter.convertNumberToFizzBuzz(1);
        String result2 = converter.convertNumberToFizzBuzz(2);

        // Assert
        Assert.assertEquals("1", result1);
        Assert.assertEquals("2", result2);
    }

    @Test
    public void givenFizz_whenDivisibleByThree() {
        // Arrange
        FizzBuzzConverter converter = new FizzBuzzConverter();

        // Act
        String result1 = converter.convertNumberToFizzBuzz(3);
        String result2 = converter.convertNumberToFizzBuzz(6);

        // Assert
        Assert.assertEquals("Fizz", result1);
        Assert.assertEquals("Fizz", result2);
    }

    @Test
    public void givenBuzz_whenDivisibleByFive() {
        // Arrange
        FizzBuzzConverter converter = new FizzBuzzConverter();

        // Act
        String result1 = converter.convertNumberToFizzBuzz(5);
        String result2 = converter.convertNumberToFizzBuzz(10);

        // Assert
        Assert.assertEquals("Buzz", result1);
        Assert.assertEquals("Buzz", result2);
    }

    @Test
    public void givenBuzz_whenDivisibleByThreeAndFive() {
        // Arrange
        FizzBuzzConverter converter = new FizzBuzzConverter();

        // Act
        String result1 = converter.convertNumberToFizzBuzz(15);
        String result2 = converter.convertNumberToFizzBuzz(30);

        // Assert
        Assert.assertEquals("FizzBuzz", result1);
        Assert.assertEquals("FizzBuzz", result2);
    }
}

Teardown your test code

Use test properties such as beforeEach, beforeAll, afterEach, or afterAll to your test code. You don't need to use all of them at a single time, just choose which are necessary.

import org.junit.After;
import org.junit.Assert;
import org.junit.Test;

public class FizzBuzzConverterTest {
    private FizzBuzzConverter converter;

    // Setup method
    public void setup() {
        converter = new FizzBuzzConverter();
    }

    @After
    public void teardown() {
        converter = null;
    }

    @Test
    public void givenNumberString_whenNotDivisibleByThreeOrFive() {
        // Arrange
        setup();

        // Act
        String result1 = converter.convertNumberToFizzBuzz(1);
        String result2 = converter.convertNumberToFizzBuzz(2);

        // Assert
        Assert.assertEquals("1", result1);
        Assert.assertEquals("2", result2);
    }

    @Test
    public void givenFizz_whenDivisibleByThree() {
        // Arrange
        setup();

        // Act
        String result1 = converter.convertNumberToFizzBuzz(3);
        String result2 = converter.convertNumberToFizzBuzz(6);

        // Assert
        Assert.assertEquals("Fizz", result1);
        Assert.assertEquals("Fizz", result2);
    }

    @Test
    public void givenBuzz_whenDivisibleByFive() {
        // Arrange
        setup();

        // Act
        String result1 = converter.convertNumberToFizzBuzz(5);
        String result2 = converter.convertNumberToFizzBuzz(10);

        // Assert
        Assert.assertEquals("Buzz", result1);
        Assert.assertEquals("Buzz", result2);
    }

    @Test
    public void givenBuzz_whenDivisibleByThreeAndFive() {
        // Arrange
        setup();

        // Act
        String result1 = converter.convertNumberToFizzBuzz(15);
        String result2 = converter.convertNumberToFizzBuzz(30);

        // Assert
        Assert.assertEquals("FizzBuzz", result1);
        Assert.assertEquals("FizzBuzz", result2);
    }
}

Use code coverage tools

Code coverage is an important point in the development process. Having a high code coverage means you also have high protection for your code over misleading changes. You can also inspect the logic of your code according to the percentage of your code coverage. If you use Java you can use Jacoco or Serenity. Each programming languages or frameworks have its code coverage tools.

Conclusions

There are numerous benefits to implementing Test-Driven Development (TDD) in your project. Many companies incorporate TDD into their development cycles, and by gaining proficiency in its implementation, you can enhance your value proposition significantly.

Additional Resources

Test-driven development from Wikipedia
Red, Green, Refactor from Codecademy
The Benefits of Test-Driven Development (TDD) from Northcoders
The Three Laws of TDD from butunclebob.com
How to TDD a List Implementation in Java from Baeldung
TDD Manifesto

Connecting Spring Boot Microservices with Kafka

Ahmad Mujahid — Sat, 10 Jun 2023 16:08:14 +0000

There are many available ways to connect microservices. But, one of the most reliable ways is using message queue protocol. Apache Kafka is one of many message queue systems that you can use freely and it offers so many features that we can customize based on our need.

In this blog post, I will share with you how to connect two Spring Boot microservices using Apache Kafka.

Project Architecture

What this Project does

We will follow the architecture as shown in the image above. Things that happening in this project are :

We create a project that grabs news (from a public news API) and then stores the data in our Redis database.
We search the news by the published date. (yyyy-MM-dd).
If the data already exists in our Redis database, it will grab directly into the database. Otherwise, it will send a request to the news API and then stores it in the Redis database.

Microservices Compositions

Our project will consist of 2 microservices named :

user-api
- provides REST API that is accessible by clients' applications.
- works as a topics publisher to Kafka.
- it will check whether the data exists. Otherwise, it will send a topic to Kafka that later will be consumed by worker.
worker
- consumes topics that are published by the publisher (user-api) via Kafka.
- stores data from News API to Redis.

Other Requirements

To do this project, we need several things installed in our system :

Docker (To run containers)
Zookeeper (containered)
Apache Kafka (containered)
Redis (containered)

Setup Kafka Message Broker + Redis

To setup a Kafka message broker (plus Redis), we gonna choose the easiest way by using Docker. To install the containers into Docker, you can use this .yml script.

version: '3'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - 22181:2181

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - 29092:29092
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_CREATE_TOPICS: "news:1:3"
      KAFKA_OFFSETS_RETENTION_MINUTES: 60

  redis:
    image: redis:latest
    restart: always
    ports:
      - 6379:6379
    environment:
      REDIS_PASSWORD: <change to your password>
    volumes: 
      - redis-data:/data
volumes:
  redis-data:

Important explanations :

we set Kafka topic by utilizing KAFKA_CREATE_TOPICS environment variable. In this case, we name the topic with news.
we can set the offset (retention period) of Kafka message by using KAFKA_OFFSETS_RETENTION_MINUTES. We set it to 60 minutes in this project.
Redis password is optional. If you don't want to password in your Redis server you can remove the REDIS_PASSWORD.

Save this file with the name docker-compose.yml. Then, open your terminal in the same directory in which you put docker-compose.yml file. Run this command to install :

docker-compose up -d

After the command is finished, you can check the installation by using this command :

docker ps

If the installation is successful, you will see 3 new containers in your container list :

CONTAINER ID   IMAGE                              COMMAND                  CREATED         STATUS        PORTS                                         NAMES
e5e5245248ed   confluentinc/cp-kafka:latest       "/etc/confluent/dock…"   47 hours ago    Up 11 hours   9092/tcp, 0.0.0.0:29092->29092/tcp            monorepo-kafka-1
bf3a4892effa   confluentinc/cp-zookeeper:latest   "/etc/confluent/dock…"   47 hours ago    Up 11 hours   2888/tcp, 3888/tcp, 0.0.0.0:22181->2181/tcp   monorepo-zookeeper-1
3b0f8606ad00   redis:latest                       "docker-entrypoint.s…"   47 hours ago    Up 12 hours   0.0.0.0:6379->6379/tcp                        monorepo-redis-1

Setup News API

We will utilize Mediastack for this project. they offer a free tier that can be used for this project. To set up your Mediastack account you can follow their documentation page. You need an access key to use their APIs. You can generate it after successfully registered.

For this project, we will only use one API provided by Mediastack that is :

http://api.mediastack.com/v1/news?access_key=<your_access_key>&countries=us&date=2023-05-11&limit=25

Here is the example data :

{
    "pagination": {
        "limit": 25,
        "offset": 0,
        "count": 25,
        "total": 10000
    },
    "data": [
        {
            "author": "Central Oregon Daily News Sources",
            "title": "Bend-La Pine school bus driver job fairs begin Thursday",
            "description": "People interested in becoming a school bus driver ...",
            "url": "https://centraloregondaily.com/bend-la-pine-school-bus-driver-job-fair/",
            "source": "kohd",
            "image": null,
            "category": "general",
            "language": "en",
            "country": "us",
            "published_at": "2023-05-11T00:02:02+00:00"
        },
        {
            "author": "Norni Mahadi",
            "title": "Miri City Council embarks on ‘international links’ to lure tourists to the Resort City",
            "description": "MIRI (May 11): The Miri City Council (MCC) is ready to do more ...",
            "url": "https://www.theborneopost.com/2023/05/11/miri-city-council-embarks-on-international-links-to-lure-tourists-to-the-resort-city/",
            "source": "theborneopost",
            "image": "https://www.theborneopost.com/newsimages/2023/05/myy-100523-nm-MiriCityDay-p1.jpeg",
            "category": "general",
            "language": "en",
            "country": "us",
            "published_at": "2023-05-11T00:00:19+00:00"
        },
    ...
    ]
}

We will save the data straightforward to Redis database as our focus is only to demonstrate how Kafka is working with microservices.

Publisher Service (user-api)

Project Detail

You can generate your project template via Spring Initializr, with some notes to follow this project :

Use Gradle - Groovy for the project manager (you can also use Maven if you feel more confident with it, just adjust accordingly).
Use Java as the programming language.

List of Dependency :

Lombok
Kafka
Redis Reactive
Webflux

Project Structure

You can use this project structure as a reference to make it easier to follow this tutorial.


├───.gradle
│   └─── ...
├───gradle
│   └───wrapper
└───src
    ├───main
    │   ├───java
    │   │   └───com
    │   │       └───justahmed99
    │   │           └───userapi
    │   │               ├───UserApiApplication.java
    │   │               │   
    │   │               ├───config
    │ │             │   ├───KafkaProducerConfig.java
    │   │               │   ├───KafkaTopicConfig.java
    │   │               │   ├───KafkaTopicConfig.java
    │   │               │   └───RedisConfig.java
    │   │               │
    │   │               ├───controller
    │   │               │    └───MessageController.java
    │   │               ├───repository
    │   │               │
    │ │             ├───NewsRepository.java
    │   │               │   └───impl
    │   │               │        └───NewsRepositoryImpl.java
    │   │               │
    │   │               └───service
    │   │                   │   MessageService.java
    │   │                   │
    │   │                   └───impl
    │   │                           MessageServiceImpl.java
    │   │
    │   └───resources
    │        └───application.yml
    │
    └───test
        └─── ...

Codes

UserApiApplication.java

package com.justahmed99.userapi;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class UserApiApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApiApplication.class, args);
    }
}

config/KafkaProducerConfig.java

package com.justahmed99.userapi.config;

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class KafkaProducerConfig {
    @Value("${spring.kafka.bootstrap-servers}")
    private String bootstrapServers;

    @Bean
    public Map<String, Object> producerConfig() {
        HashMap<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

        return props;
    }

    @Bean
    public ProducerFactory<String, String> producerFactory() {
        return new DefaultKafkaProducerFactory<>(producerConfig());
    }

    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}

config/KafkaTopicConfig.java

package com.justahmed99.userapi.config;

import org.apache.kafka.clients.admin.NewTopic;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.config.TopicBuilder;

@Configuration
public class KafkaTopicConfig {
    @Bean
    public NewTopic newsTopic() {
        return TopicBuilder.name("news").build();
    }
}

config/RedisConfig.java

package com.justahmed99.userapi.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.ReactiveRedisOperations;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.Objects;

@Configuration
public class RedisConfig {
    @Value("${spring.data.redis.host}")
    private String host;

    @Value("${spring.data.redis.port}")
    private String port;

    @Value("${spring.data.redis.password}")
    private String password;

    @Bean
    public ReactiveRedisConnectionFactory reactiveRedisConnectionFactory() {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(Objects.requireNonNull(host));
        redisStandaloneConfiguration.setPort(Integer.parseInt(Objects.requireNonNull(port)));
        redisStandaloneConfiguration.setPassword(RedisPassword.of(Objects.requireNonNull(password)));
        return new LettuceConnectionFactory(redisStandaloneConfiguration);
    }

    @Bean
    public ReactiveRedisOperations<String, Object> redisOperations(
            ReactiveRedisConnectionFactory reactiveRedisConnectionFactory
    ) {
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);

        RedisSerializationContext.RedisSerializationContextBuilder<String, Object> builder =
                RedisSerializationContext.newSerializationContext(new StringRedisSerializer());

        RedisSerializationContext<String, Object> context = builder.value(serializer).hashValue(serializer)
                .hashKey(serializer).build();

        return new ReactiveRedisTemplate<>(reactiveRedisConnectionFactory, context);
    }
}

dto/request/MessageRequest.java

package com.justahmed99.userapi.dto.request;

import lombok.Data;

@Data
public class MessageRequest {
    private String message;
}

dto/response/DataResponse.java

package com.justahmed99.userapi.dto.response;

import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class DataResponse<T> {
    private String message;
    private Boolean status;
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private T data;
}

repository/NewsRepository.java

package com.justahmed99.userapi.repository;

import reactor.core.publisher.Mono;

public interface NewsRepository {
    Mono<Object> getNews(String date);
}

repository/impl/NewsRepositoryImpl.java

package com.justahmed99.userapi.repository.impl;

import com.justahmed99.userapi.repository.NewsRepository;
import org.springframework.data.redis.core.ReactiveRedisOperations;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Mono;

@Repository
public class NewsRepositoryImpl implements NewsRepository {

    private final ReactiveRedisOperations<String, Object> redisOperations;

    public NewsRepositoryImpl(
            ReactiveRedisOperations<String, Object> redisOperations
    ) {
        this.redisOperations = redisOperations;
    }

    @Override
    public Mono<Object> getNews(String date) {
        return redisOperations.opsForValue().get(date);
    }
}

service/MessageService.java

package com.justahmed99.userapi.service;

import reactor.core.publisher.Mono;

public interface MessageService {
    Mono<Void> publishToMessageBroker(String date);
    Mono<Object> getNews(String date);
}

service/impl/MessageServiceImpl.java

package com.justahmed99.userapi.service.impl;

import com.justahmed99.userapi.repository.NewsRepository;
import com.justahmed99.userapi.service.MessageService;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;

@Service
public class MessageServiceImpl implements MessageService {
    private final KafkaTemplate<String, String> kafkaTemplate;
    private final NewsRepository newsRepository;

    public MessageServiceImpl(
            KafkaTemplate<String, String> kafkaTemplate,
            NewsRepository newsRepository
    ) {
        this.kafkaTemplate = kafkaTemplate;
        this.newsRepository = newsRepository;
    }

    @Override
    public Mono<Void> publishToMessageBroker(String date) {
        ProducerRecord<String, String> record = new ProducerRecord<>("news", null, date);
        return Mono.fromFuture(kafkaTemplate.send(record))
                .then();
    }

    @Override
    public Mono<Object> getNews(String date) {
        return newsRepository.getNews(date)
                .flatMap(Mono::just)
                .switchIfEmpty(Mono.defer(() -> publishToMessageBroker(date)));
    }
}

controller/MessageController.java

package com.justahmed99.userapi.controller;

import com.justahmed99.userapi.dto.request.MessageRequest;
import com.justahmed99.userapi.dto.response.DataResponse;
import com.justahmed99.userapi.service.MessageService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping(value = "/message")
public class MessageController {
    private final MessageService service;

    public MessageController(
            MessageService service
    ) {
        this.service = service;
    }

    @GetMapping("")
    public Mono<ResponseEntity<DataResponse<Object>>> getNews(@RequestParam(name = "date") String date) {
        return service.getNews(date)
                .flatMap(data -> Mono.just(
                        ResponseEntity.status(HttpStatus.OK)
                                .body(new DataResponse<>
                                        ("data found", true, data))))
                .switchIfEmpty(Mono.defer(() -> Mono.just(
                        ResponseEntity.status(HttpStatus.NOT_FOUND).
                                body(new DataResponse<>
                                        ("data not found, sending request to broker", false, null)))));
    }
}

application.yml

server:
  port: 8080

spring:
  kafka:
    bootstrap-servers: localhost:29092
  data:
    redis:
      host: localhost
      port: 6379
      password: <your_redis_password>

Change your_redis_password with your Redis server's password. Otherwise, just get rid of it.

Consumer Service (worker)

Project Detail

For initializing this project, do the same with user-api project.

Project Structure

You can use this project structure as a reference to make it easier to follow this tutorial.

├───.gradle
│   └─── ...
├───gradle
│   └───wrapper
└───src
    ├───main
    │   ├───java
    │   │   └───com
    │   │       └───justahmed99
    │   │           └───worker
    │   │               ├───WorkerApplication.java
    │   │               │   
    │   │               ├───config
    │ │               ├───KafkaProducerConfig.java
    │   │               │   ├───KafkaTopicConfig.java
    │   │               │   ├───KafkaTopicConfig.java
    │   │               │   └───RedisConfig.java
    │   │               │   └───WebClientConfig.java
    │   │               │
    │   │               ├───listener
    │   │               │    └───KafkaListener.java
    │   │               │
    │   │               ├───repository
    │   │               │
    │ │             ├───NewsRepository.java
    │   │               │   └───impl
    │   │               │        └───NewsRepositoryImpl.java
    │   │               │
    │   │               └───service
    │   │                   │   WebClientService.java
    │   │                   │
    │   │                   └───impl
    │   │                           WebClientServiceImpl.java
    │   │
    │   └───resources
    │        └───application.yml
    │
    └───test
        └─── ...

Codes

config/KafkaConfigConsumer.java

package com.justahmed99.worker.config;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class KafkaConsumerConfig {
    @Value("${spring.kafka.bootstrap-servers}")
    private String bootstrapServers;

    public Map<String, Object> consumerConfig() {
        HashMap<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "message-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);

        return props;
    }

    @Bean
    public ConsumerFactory<String, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(consumerConfig());
    }

    @Bean
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }
}

config/KafkaTopicConfig.java

package com.justahmed99.worker.config;

import org.apache.kafka.clients.admin.NewTopic;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.config.TopicBuilder;

@Configuration
public class KafkaTopicConfig {
    @Bean
    public NewTopic newsTopic() {
        return TopicBuilder.name("news").build();
    }
}

config/RedisConfig.java

package com.justahmed99.worker.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.ReactiveRedisOperations;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.Objects;

@Configuration
public class RedisConfig {
    @Value("${spring.data.redis.host}")
    private String host;

    @Value("${spring.data.redis.port}")
    private String port;

    @Value("${spring.data.redis.password}")
    private String password;

    @Bean
    public ReactiveRedisConnectionFactory reactiveRedisConnectionFactory() {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(Objects.requireNonNull(host));
        redisStandaloneConfiguration.setPort(Integer.parseInt(Objects.requireNonNull(port)));
        redisStandaloneConfiguration.setPassword(RedisPassword.of(Objects.requireNonNull(password)));
        return new LettuceConnectionFactory(redisStandaloneConfiguration);
    }

    @Bean
    public ReactiveRedisOperations<String, Object> redisOperations(
            ReactiveRedisConnectionFactory reactiveRedisConnectionFactory
    ) {
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);

        RedisSerializationContext.RedisSerializationContextBuilder<String, Object> builder =
                RedisSerializationContext.newSerializationContext(new StringRedisSerializer());

        RedisSerializationContext<String, Object> context = builder.value(serializer).hashValue(serializer)
                .hashKey(serializer).build();

        return new ReactiveRedisTemplate<>(reactiveRedisConnectionFactory, context);
    }
}

config/WebClientConfig.java

package com.justahmed99.worker.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {

    @Value("${mediastack.uri}")
    private String apiUri;

    @Bean
    public WebClient webClient() {
        return WebClient.create(apiUri);
    }
}

listener/KafkaListeners.java

package com.justahmed99.worker.listener;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.justahmed99.worker.repository.NewsRepository;
import com.justahmed99.worker.service.WebClientService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;


@Component
public class KafkaListeners {

    private final WebClientService webClientService;
    private final NewsRepository newsRepository;

    public KafkaListeners (
            WebClientService webClientService,
            NewsRepository newsRepository
    ) {
        this.webClientService = webClientService;
        this.newsRepository = newsRepository;
    }

    @KafkaListener(topics = "news", groupId = "message-group")
    void listener(String date) {
        System.out.printf("Listener received: %s%n", date);

        Mono<ResponseEntity<String>> responseEntity = webClientService.sendRequest(date);

        responseEntity.subscribe(response -> {
            HttpStatus status = (HttpStatus) response.getStatusCode();
            if (status.equals(HttpStatus.OK)) {
                try {
                    newsRepository.saveNews(date, response.getBody())
                            .subscribe(isSaved -> {
                                if (isSaved)
                                    System.out.println("Data successfully saved in cache");
                                else
                                    System.out.println("Data save failed");
                            });
                } catch (JsonProcessingException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println(status.value());
        });
    }
}

repository/NewsRepository.java

package com.justahmed99.worker.repository;

import com.fasterxml.jackson.core.JsonProcessingException;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Mono;

@Repository
public interface NewsRepository {
    Mono<Boolean> saveNews(String date, Object newsObject) throws JsonProcessingException;
}

repository/impl/NewsRepositoryImpl.java

package com.justahmed99.worker.repository.impl;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.justahmed99.worker.repository.NewsRepository;
import org.springframework.data.redis.core.ReactiveRedisOperations;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Mono;

import java.time.Duration;

@Repository
public class NewsRepositoryImpl implements NewsRepository {
    private final ReactiveRedisOperations<String, Object> redisOperations;

    public NewsRepositoryImpl(
            ReactiveRedisOperations<String, Object> redisOperations
    ) {
        this.redisOperations = redisOperations;
    }

    @Override
    public Mono<Boolean> saveNews(String date, Object newsObject) throws JsonProcessingException {
        Duration ttl = Duration.ofHours(1);
        ObjectMapper objectMapper = new ObjectMapper();
        return redisOperations.opsForValue().set(date, objectMapper.readTree(newsObject.toString()), ttl);
    }
}

service/WebClientService.java

package com.justahmed99.worker.service;

import org.springframework.http.ResponseEntity;
import reactor.core.publisher.Mono;

public interface WebClientService {
    Mono<ResponseEntity<String>> sendRequest(String date);
}

service/impl/WebClientServiceImpl.java

package com.justahmed99.worker.service.impl;

import com.justahmed99.worker.service.WebClientService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Service
public class WebClientServiceImpl implements WebClientService {

    @Value("${mediastack.api-key}")
    private String apiKey;

    @Value("${mediastack.countries}")
    private String countries;

    @Value("${mediastack.limit}")
    private String limit;

    private final WebClient webClient;

    public WebClientServiceImpl(WebClient webClient) {
        this.webClient = webClient;
    }

    @Override
    public Mono<ResponseEntity<String>> sendRequest(String date) {
        return webClient.get()
                .uri(uriBuilder -> uriBuilder
                        .queryParam("access_key", apiKey)
                        .queryParam("countries", countries)
                        .queryParam("limit", limit)
                        .queryParam("date", date)
                        .build())
                .retrieve()
                .toEntity(String.class);
    }
}

application.yml

server:
  port: 9090

spring:
  kafka:
    bootstrap-servers: localhost:29092
  data:
    redis:
      host: localhost
      port: 6379
      password: myredis

mediastack:
  uri: http://api.mediastack.com/v1/news
  api-key: <your-api-key>
  countries: us
  limit: 25

NOTES:

Change your_redis_password with your Redis server's password. Otherwise, just get rid of it.
Change your-api-key with API key you got from Mediastack.

End Point

To try to make a request first you need to :

Make sure zookeeper container is running
Make sure Kafka container is running
Make sure Redis container is running
Run user-api service
Run worker service

To make a request you can hit :

http://localhost:8080/date=<yyyy-MM-dd>

Conclusion

There's how you can connect two Spring Boot microservices with Kafka. Hope this helps. 😊

Here is the GitHub repo.

CRUD REST API with Node.js, Express.js, and PostgreSQL

Ahmad Mujahid — Tue, 06 Jun 2023 12:28:04 +0000

API or Application Program Interface serves as a communication facility between services or software. In web programming, APIs are used to access available data and services.

REST API (RESTful API)

Representational State Transfer (REST) contains standards for a web service. REST API is an API architectural style that uses the HTTP protocol to access and use data. The following are some data types that REST API has:

GET — Get data
PUT — Modify the state or value of data or resource
POST — Create data or resource
DELETE — Delete data or resource

Which can be used to create a CRUD (Create, Read, Update, Delete) service/application.

CRUD

When creating a service, we want some basic functionalities to manipulate the resource. These functionalities are for creating, reading, updating, and deleting data commonly referred to as CRUD.

CRUD stands for Create, Read, Update, and Delete, which is actually an application of the data types in REST API. The details are as follows:

CREATE — To create data (POST)
READ — To retrieve/read existing data (GET)
UPDATE — To modify/update data (PUT)
DELETE — To delete data (DELETE)

Things Required

Before following this article, there are several things that need to be installed first:

Node.js
PostgreSQL
Postman application (to hit the REST API Endpoint)

Installation procedures can be found in the respective websites' documentation.

Setting up the PostgreSQL Database

Firstly, we will create a database in PostgreSQL that will be used by the service. We use psql program. Here are the steps.

psql -U postgres

By using the above command, we have logged in to PostgreSQL as the postgres user.

postgres=#

Creating a Database

To create a database, we use the command:

postgres=# CREATE DATABASE tutorial

The above command is used to create a database with the name tutorial. To use/connect to the tutorial database, use the command:

postgres=# \c tutorial

The prompt will change to the following:

tutorial=#

indicates that we have successfully connected to the tutorial database.

Creating a Table

Next, create a table in the tutorial database. We will create a table named students in the public schema. Use the following command:

tutorial=# CREATE TABLE public.students (
    id serial NOT NULL,
    firstname varchar(40) NULL,
    lastname varchar(40) NULL,
    origin varchar(50) NULL,
    CONSTRAINT students_pkey PRIMARY KEY (id)
);

Use the command \dt to check if the table has been successfully created.

tutorial=# \dt
            List of relations
Schema |   Name   |  Type | Owner
-------+----------+-------+---------
public | students | table | postgres
(1 row)

To check the details of the table, use the command \d students.

tutorial=# \d students
Table "public. students”
Column    | Type                  | Collation | Nullable | Default
----------+-----------------------+-----------+----------+-----------------------------------------
id        | integer               |           | not null | nextval(’students_id_seq’::regclass)
firstname | character varying(40) |           |          |
lastname  | character varying(40) |           |          |
origin    | character varying(56) |           |          |

Indexes:
      "students_pkey" PRIMARY KEY, btree (id)

Setting up Express.js Server

1. Project Structure

In the end of this article, the structure of the project will be like this :

tutorial
├───node_modules
│ └─── ....
├───mode
│   └───response.js
├───index.js
├───queries.js
├───package-lock.json
└───package.json

You can use this structure to avoid confusion.

2. Project Setup

First step, create a project directory with name tutorial, then initialize Node.js using this command:

mkdir tutorial
cd tutorial
npm init -y

The npm init -y command will generate package.json file with the following contents:

{
  "name": "tutorial",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Next, install dependencies (for Express.js and PostgreSQL) using this command :

npm install express dan pg

After the execution finished, the dependency files will be stored inside node_modules folder and list of dependencies will be listed in package.json file like below :

{
  "name": "tutorial",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.17.1",
    "pg": "^8.7.1"
  }
}

Next, create the index.js file in the root folder. This file is the main file that needs to be executed to run the Node.js server. Inside the index.js file, we add the following script :

const express = require("express");
const bodyParser = require("body-parser");

const app = express();
const port = 3000;

app.use(bodyParser.json());
app.use(
    bodyParser.urlencoded({
        extended: true
    })
)

The require function is used to all dependency to our project.

Next, we create a root URL (/) that returns JSON.

app.get("/", (request, response) => {
    response.json({
        info: 'Hello world!'
    });
})

Save the file. To run the server, use this command :

node index.js

If the server running successfully, you will get this on your terminal :

$ node index.js
Server is running on 3000

If you access http://localhost:3000 from your client app (Postman or web browser) you will get a JSON response like below :

{
  "info": "Hello world!"
}

3. Connect Express with PostgreSQL

The next important step is to connect Node.js with PostgreSQL. We create a file named queries.js (the name doesn't have to be exactly the same as in the article, but the usage in the program should be consistent) which will be used to set up the database connection and the queries used to access and manipulate data.

The first thing we need to do in this section is to set up a Pool connection to the database that will be used. This can be done using the following script:

const Pool = require("pg").Pool;
const pool = new Pool({
    user: 'postgres',
    host: 'localhost',
    database: 'nama_db_kamu',
    password: 'password_kamu',
    port: 5432
});

4. Create Response Class (Optional)

This is an optional step, which is my personal preference. The purpose of creating the Response class is to standardize the response or output of the API we create. The Response class that I commonly use is as follows:

class Response {
    constructor(status = false, code = 400, message = "", data = null) {
        this.status = status;
        this.code = code;
        this.message = message;
        this.data = data;
    }
}

module.exports = Response;

The Response class will be used in the queries.js file. In this article, we will always use this Response class for JSON formatting in API responses.

const Pool = require("pg").Pool;
const pool = new Pool({
    user: 'postgres',
    host: 'localhost',
    database: 'testing_db',
    password: 'development',
    port: 5432
});
const ResponseClass = require("./model/response") // opsional

Creating CRUD Operation Functions

In this section, we will create 5 CRUD functions:

getStudents() — to retrieve all student data
getStudentById() — to retrieve data of a student based on ID
createStudent() — to create a student's data
updateStudent() — to update a student's data based on ID
deleteStudent() — to delete a student's data based on ID

We will declare these five functions in the queries.js file, which will be accessed by index.js.

GET | `getStundents()`

const getStudents = (request, response) => {
    var responseReturn = new ResponseClass();
    pool.query('SELECT * FROM students ORDER BY id ASC', (error, results) => {
        if (error) {
            throw error
        }

        responseReturn.status = true;
        responseReturn.code = 200;
        responseReturn.message = "Success";
        responseReturn.data = results.rows;

        response.status(200).json(responseReturn);
    })
}

GET | `getStudentById()`

const getStudentById = (request, response) => {
    var responseReturn = new ResponseClass();
    const id = parseInt(request.params.id)
    pool.query('SELECT * FROM students WHERE id = $1', [id], (error, results) => {
        if (error) {
            throw error
        }
        if (results.rowCount == 0) {
            responseReturn.status = true;
            responseReturn.code = 404;
            responseReturn.message = "User not found";
            responseReturn.data = null;
        } else {
            responseReturn.status = true;
            responseReturn.code = 200;
            responseReturn.message = "Success";
            responseReturn.data = results.rows[0];
        }
        response.status(200).json(responseReturn);
    })
}

POST | `createStudent()`

const createStudent = (request, response) => {
    const { firstname, lastname, origin } = request.body;
    pool.query('INSERT INTO students (firstname, lastname, origin) VALUES ($1, $2, $3)', [firstname, lastname, origin], (error, results) => {
        if (error) {
            throw error
        }
        response.status(201).send("Student added");
    })
}

PUT | `updateStudent()`

const updateStudent = (request, response) => {
    const id = parseInt(request.params.id);
    var responseReturn = ResponseClass();
    try {
        const { firstname, lastname, origin } = request.body;
        pool.query('UPDATE students SET firstname = $1, lastname = $2, origin = $3 WHERE id = $4', [firstname, lastname, origin, id], (error, results) => {
            if (error) {
                throw error
            }

            responseReturn.status = true;
            responseReturn.code = 200;
            responseReturn.message = "User modification successed";
            responseReturn.data = null;
            response.status(200).send(responseReturn);
        })
    } catch (error) {
        responseReturn.status = false;
        responseReturn.code = 500;
        responseReturn.message = error.message;
        responseReturn.data = null
        response.status(500).json(responseReturn);
    }
}

The complete code for queries.js is as follows:

const Pool = require("pg").Pool;
const pool = new Pool({
    user: 'postgres',
    host: 'localhost',
    database: 'testing_db',
    password: 'development',
    port: 5432
});
const ResponseClass = require("./model/response") // opsional

const getStudents = (request, response) => {
    var responseReturn = new ResponseClass();
    pool.query('SELECT * FROM students ORDER BY id ASC', (error, results) => {
        if (error) {
            throw error
        }

        responseReturn.status = true;
        responseReturn.code = 200;
        responseReturn.message = "Success";
        responseReturn.data = results.rows;

        response.status(200).json(responseReturn);
    })
}

const getStudentById = (request, response) => {
    var responseReturn = new ResponseClass();
    const id = parseInt(request.params.id)
    pool.query('SELECT * FROM students WHERE id = $1', [id], (error, results) => {
        if (error) {
            throw error
        }
        if (results.rowCount == 0) {
            responseReturn.status = true;
            responseReturn.code = 404;
            responseReturn.message = "User not found";
            responseReturn.data = null;
        } else {
            responseReturn.status = true;
            responseReturn.code = 200;
            responseReturn.message = "Success";
            responseReturn.data = results.rows[0];
        }
        response.status(200).json(responseReturn);
    })
}

const createStudent = (request, response) => {
    const { firstname, lastname, origin } = request.body;
    pool.query('INSERT INTO students (firstname, lastname, origin) VALUES ($1, $2, $3)', [firstname, lastname, origin], (error, results) => {
        if (error) {
            throw error
        }
        response.status(201).send("Student added");
    })
}

const updateStudent = (request, response) => {
    const id = parseInt(request.params.id);
    var responseReturn = new ResponseClass();
    try {
        const { firstname, lastname, origin } = request.body;
        pool.query('UPDATE students SET firstname = $1, lastname = $2, origin = $3 WHERE id = $4', [firstname, lastname, origin, id], (error, results) => {
            if (error) {
                throw error
            }

            responseReturn.status = true;
            responseReturn.code = 200;
            responseReturn.message = "User modification successed";
            responseReturn.data = null;
            response.status(200).send(responseReturn);
        })
    } catch (error) {
        responseReturn.status = false;
        responseReturn.code = 500;
        responseReturn.message = error.message;
        responseReturn.data = null
        response.status(500).json(responseReturn);
    }
}

const deleteStudent = (request, response) => {
    const id = parseInt(request.params.id)
    pool.query('DELETE FROM students WHERE id = $1', [id], (error, results) => {
        if (error) {
            throw error
        }
        response.status(201).send("Student deleted");
    })
}


module.exports = {
    getStudents,
    getStudentById,
    createStudent,
    updateStudent,
    deleteStudent
}

Creating REST API Endpoints

The next step is to create the endpoints that will be used in the REST API. Endpoints are URLs that can be accessed according to their request methods (GET, POST, PUT, DELETE).

The first step is to import the functions from queries.js by adding the following code in index.js:

const db = require('./queries');

Next, the code that needs to be added is as follows:

const express = require("express");
const bodyParser = require("body-parser");

const app = express();
const port = 3000;
const db = require('./queries');

app.use(bodyParser.json());
app.use(
    bodyParser.urlencoded({
        extended: true
    })
)

app.listen(port, () => {
    console.log("Server is running on " + port);
});

app.get("/", (request, response) => {
    response.json({
        info: 'Hello world!'
    });
})
app.get("/students", db.getStudents);
app.get("/students/:id", db.getStudentById);
app.put("/students/:id", db.updateStudent);
app.post("/students", db.createStudent);
app.delete("/students/:id", db.deleteStudent);

Now you can run the server and access the endpoints following by correct HTTP datatype for each.

Conclusion

Thus, we have successfully created a REST API with basic CRUD functionality. Hopefully, it will be useful 🙂

Simple Java Problems That Can Drives You Crazy If You Don’t Know How To Deal With

Ahmad Mujahid — Tue, 06 Jun 2023 03:43:28 +0000

Finally I got a chance to write something again after a while. So, for this time will share you interesting things about Java. Well, not so interesting, for some it can be devastating, perhaps.

After I spent my lifetime surfing in Java World, I’ve found a unique problem with this language. The first time met these, It drove me crazy and the I realize now, those problem are just a simple things you will meet in your stepping stone in your journey in Java World.

So, I will share to you, my moment of ‘horrifying’ journey in Java World in this short article. I will list the moments by a list of problems.

#1 : How To Input Something From Terminal?

If you have experience in C++, to do input task is an easy thing. you can just do in by using std::cin << var_name; or cin << var_name; if you already include the standard namespace. In Java, you need to import a library to do so.

import java.util.Scanner;   // Scanner class that is necesserely to import

class Program {
  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);  // Scanner Object
    System.out.println("Input your name!");

    String userName = input.nextLine();  // Read user input
    System.out.println("Username is: " + userName);  // Output of user input
  }
}

So, the first thing you need to do is importing the Scanner class, declare an object, that use it’s function to input something.

#2 : Why My String Input Only Output the First Word of the Sentence?

This is the next problem that often happening when you learn Java. When you input something like “I Love You”, why the output only shows “I”? Where is the rest?

Input: I love you
Output: I

The most common cause of this, you are mistaken of using function next() instead of nextLine().

import java.util.Scanner;

class Program {
  public static void main(String[] args) {
      Scanner input = new Scanner(System.in);
    System.out.print("Input : ");
    String s = input.next();  // If you use this you won't get the whole of the sentence

    System.out.println("Output : " + s);
  }
}

If you use the code above you will mess your task. But yes you can still use the code above to print a sentence. But, you need to set a delimiter for it which we won’t talk about it this time.

You can fix this problem by changing next() with nextLine().

import java.util.Scanner;

class Program {
  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.print("Input :");
    String s = input.nextLine();  // You can use this instead of next()

    System.out.println("Output : " + s);
  }
}

#3 : Why My String Input is Skipped After I input Other Variables?

If you are using the code bellow, you will get this kinda nightmare.

import java.util.Scanner;

public class Program {
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int i = scan.nextInt();
    Double d = scan.nextDouble();
    String s = scan.nextLine();  // This section will be skipped
    scan.close();

    System.out.println("String: " + s);
    System.out.println("Double: " + d);
    System.out.println("Int: " + i);
  }
}

This is the simplest way I’ve found to fix this problem.

import java.util.Scanner;

public class Program {
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int i = scan.nextInt();
    Double d = scan.nextDouble();
    scan.nextLine();  // You just need to add this
    String s = scan.nextLine();
    scan.close();

    System.out.println("String: " + s);
    System.out.println("Double: " + d);
    System.out.println("Int: " + i);
  }
}

You just need to call nextLine() function before you do a string input. Problem solved!

#4 : What Is Package?

The simplest explanation of what package in Java is the therm “Package” in Java is refer to a sub folder inside your project main directory. Mostly, Java source codes in a single project are stored inside src/ or src/java folder.

For example, in you have a Java class named Example.java inside src/java/example folder. If you want to import this class to your main class, you must add this import statement to the main file :

import example.Example;

The . acts just like slash or backslash in directory. And why you just declare example instead of src.java.example? Because, usually, it has been declared in the root path of the project, specially if you are using any kind of IDE.

#5 : What IDE is the Best?

Well, it’s rely on yourself. You can use various kind of IDE depend on your taste. If you want a classic one, you can use Eclipse, but for me it’s a bit boring. If you want the new-fashioned one, you can use IntellIJ. NetBeans is OK too. Or, if you are using Raspberry Pi to develop Java, you can use BlueJ.

It’s a personal reference if we talk about IDE.