DEV Community: Khadija Ashraf

Unfolding: LeetCode 560. Subarray Sum Equals K

Khadija Ashraf — Thu, 22 May 2025 04:45:21 +0000

A disguised medium difficulty problem in LeetCode. We must honor this as a hard one... :) Source Code

560. Subarray Sum Equals K

Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k.

A subarray is a contiguous non-empty sequence of elements within an array.

Example 1:

Input: nums = [1,1,1], k = 2
Output: 2
Example 2:

Input: nums = [1,2,3], k = 3
Output: 2


Constraints:

1 <= nums.length <= 2 * 104
-1000 <= nums[i] <= 1000
-107 <= k <= 107

Solution

Approach 1: Brute Force

Brute Force: Generate every possible sub array

Algorithm:

Initialize a variable count = 0 to keep track of the number of subarrays with sum equal to k.
for every index in the input array consider the index as i index of a sub array
for each i index Loop through the array from i index to n - 1 using index j
- Add nums[j] to sum
- if sum == k, increment count
after both loops complete, return count.

Example all possible subarray of Input: {1, -1, 2, 1, 1, -2, 2}

-> i = 0, j = i ... len(nums)
(1), (1,-1), (1,-1, 2), (1, -1, 2, 1), (1,-1, 2, 1, 1), (1,-1, 2, 1, 1, -2), (1,-1, 2, 1, 1, -2, 2)

-> i = 1, j = i ... len(nums)
(-1), (-1, 2), (-1, 2, 1), (-1, 2, 1, 1), (-1, 2, 1, 1, -2), (-1, 2, 1, 1, -2, 2)

so on..


public int subarraySum(int[] nums, int k) {
    int count = 0;
        for(int i = 0; i < nums.length; i++) {
            int sum = 0;
            for(int j = i; j < nums.length; j++) {
                sum += nums[j];
                if(sum == k) {
                    count = count + 1;
                }
            }
        } 
        return count;
}

All the k-sum subarrays for k = 2, in the given input array,

inputs : 0, 1,-1, 2, 1, 1,-2, 2
prefix : 0, 1, 0, 2, 3, 4, 2, 4
- index [1,3] : (1,-1,2)
- index [3,3] : (2)
- index [2,4] : (-1,2,1)
- index [3,6] : (2,1,1,-2)
- index [4,7] : (1,1,-2,2)

Time & Space:

Time O(n^2): check all subarrays, and there are roughly n(n+1)/2 subarrays.
Space O(1): using only a few variables, no extra data structures.

Approach 2: Prefix Sum

Key Concept and Algorithm:

Intuition: "As you move forward, keep looking behind to check if the numbers you’ve summed so far equals to K."

We traverse the input array from left towards right. While traversing we calculate the prefix sum for every index. Prefix sum is the running sum of every index position on the input array. Either we can maintain a new separate array for prefix sums or we can modify the input array itself if allowed. In this problem we are storing the prefixes in a new array.
We traverse the prefix array from left to right. The idea is, in every index we ask, does this currenPrefixSum (current index position's prefixSum) already contains the sum of one/more subarray summing to k?
To check this, we go k amount backwards by subtracting the amount 'k' from the currentPrefixSum. This subtracted value is the complementPrefixSum.
complementPrefixSum is a number that is 'k' less than the currentPrefixSum in the prefixsum array.
Then we check every index from the beginning until the current index of the prefix sum array to find any complementPrefixSum == (currentPrefixSum-k),
If we find, than we have got a sub array that resides between the complementPrefixSum and the currentPrefixSum and this subarray is k-sum amount.
So, currentPrefixSum - complementPrefixSum = k or, we can re-write, currentPrefixSum - k = complementPrefixSum

public int subarraySumPrefixSum(int[] nums, int k) {
        int[] prefixSum = new int[nums.length + 1];
        int count = 0;
        prefixSum[0] = 1;
        for(int i = 1; i <= nums.length; i++) {
            prefixSum[i] += prefixSum[i - 1] + nums[i-1]; // prefix-sum until position 'i'
        }
        for(int i = 1; i <= nums.length; i++) {
            int currentPrefixSum = prefixSum[i];
            int complementSum = currentPrefixSum - k;

            for(int j = 0; j < i; j++) {
                if(prefixSum[j] == complementSum) {
                    count += 1;
                }
            }
        }
        return count;
}

For example:

Now, we demonstrate a portion of the algorithm execution. Note that, we traverse the precalculated prefix array.

The k-sum subarray count for k = 2, in the given input array,

indexs : 0, 1, 2, 3, 4, 5, 6 ,7
inputs : 0, 1,-1, 2, 1, 1,-2, 2
prefix : 0, 1, 0, 2, 3, 4, 2, 4

Dry Run for Prefix index 4: we ask, does this currenPrefixSum already contains the sum of one/more subarray summing to k?

prefix[4] - k = 3-2 => 1. This '1' is the complementPrefixSum.
if we can find this complementPrefixSum in the prefix array starting from index 0 until index 4, then we can say atleast a subarray exists of sum-k between the complementPrefixSum and the currentPrefixSum. if we find the complementPrefixSum more than once we count all of them as separate k-sum subarrays.
we find prefix[1] == 1, which is equal to complementPrefixSum. therefore we found one k-sum subarray between inputs[1] and inputs[4].
Verification: The subarray starts at index 2 and ends at 4, thus the index range is [2,4] and the values subarray values are (-1, 2, 1) = -1+2+1 = 2 = k.
since we found a complementSum in the prefix array so we increase the total number of k-sum subarray count.
There is no more complementPrefixSum == 1 found until the current index in the prefix array.

Dry Run for prefix index 5: we ask, does this currenPrefixSum already contains the sum of one/more subarray summing to k?

prefix[5] - k = 4-2 => 2. This '2' is the complementPrefixSum.
if we can find this complementPrefixSum in the prefix array starting from index 0 until index 5, then we can say atleast a subarray exists of sum-k between the complementPrefixSum and the currentPrefixSum. if we find the complementPrefixSum more than once we count all of them as separate k-sum subarrays.
we find prefix[3] == 2, which is equal to complementPrefixSum. therefore we found one k-sum subarray between inputs[3] and inputs[5].
Verification: The subarray starts at index 4 and ends at 5, thus the index range is [4,5] and the subarray values are (1, 1) = 1+1 = 2 = k.
since we found a complementSum in the prefix array so we increase the total number of k-sum subarray count.
There is no more complementPrefixSum == 2 found until the current index in the prefix array.

Dry Run for prefix index 6: we ask, does this currenPrefixSum already contains the sum of one/more subarray summing to k

prefix[6] - k = 2-2 => 0. This '0' is the complementPrefixSum.
If we can find this complementPrefixSum in the prefix array starting from index 0 until index 6, then we can say atleast a subarray exists of sum-k between the complementPrefixSum and the currentPrefixSum. If we find the complementPrefixSum more than once we count all of them as separate k-sum subarrays.
We find prefix[0] == 0, which is equal to complementPrefixSum. Therefore we found one k-sum subarray between inputs[0] and inputs[6].
Verification: The subarray starts at index 1 and ends at 6, thus the index range is [1,6] and the subarray values are (1,-1, 2, 1, 1,-2) = 1+(-1)+2+1+1+(-2) = 2 = k.
Since we found a complementSum in the prefix array so we increase the total number of k-sum subarray count.
There is no more complementPrefixSum == 0 found until the current index in the prefix array.

Dry Run for prefix index 7: we ask, does this currenPrefixSum already contains the sum of one/more subarray summing to k?

prefix[7] - k = 4-2 => 2. This '2' is the complementPrefixSum.
If we can find this complementPrefixSum in the prefix array starting from index 0 until index 7, then we can say atleast a subarray exists of sum-k between the complementPrefixSum and the currentPrefixSum. If we find the complementPrefixSum more than once we count all of them as separate k-sum subarrays.
We find prefix[3] == 2, which is equal to complementPrefixSum. Therefore we found one k-sum subarray between inputs[3] and inputs[7].
Verification: The subarray starts at index 4 and ends at 7, thus the index range is [4,7] and the subarray values are (1, 1,-2, 2) = 1+1+(-2)+2 = 2 = k.
Since we found a complementSum in the prefix array so we increase the total number of k-sum subarray count.
Wait, we still have to scan the prefix array until the current index 7. While scanning forward, we found one more (complementPrefixSum == 2) at the index 6.
We find prefix[6] == 2, which is equal to complementPrefixSum. Therefore we found one more k-sum subarray between inputs[6] and inputs[7].
Verification: The subarray starts at index 7 and ends at 7, thus the index range is [7,7] and the subarray values are (2) = k.
Since we found one more complementPrefixSum in the prefix array so again we increase the total number of k-sum subarray count.

Time & Space:

Time O(n^2): check all previous prefixes until the current index
Space O(n): using an extra array of size n for storing prefixes.

Approach 3: Prefix Sum + HashMap (optimized Time O(n))

Key Concept and Algorithm:

In the approach 2: Prefix Sum we used an array for storing our prefixes. There is a performance drain when we have to lookup for a complemenPrefixSum. We have to scan the prefix array until the current index to find if there is a prefix already in the map that matches the complemenPrefixSum. This is an average O(n) operation.

To enhance the performance we can keep our prefixes in a HashMap. Then looking up for a complemenPrefixSum in that map would be a O(1) operation. We store the frequency of the prefixes so that we get the total number of occurrences of that prefix in the prefix array. The frequency of prefix is added to the k-sum subarray count when the prefix of that position matches to a complemenPrefixSum.

Though for an all positive input array the prefix always increases from left to right.

However, note that, since this problem allows negative numbers, therefor we might have duplicate prefixes in the prefix array.
For example the input array mentioned under Approach 2, has prefix 2 at both index 3, and 6. Because, the negative numbers at index 2 and 6 are bringing the prefix down. So at some point we might find duplicate prefix values in the array.


public int subarraySumPrefixSumHashMap(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        int count = 0;
        int currentPrefixSum = 0;
        map.put(0, 1);
        for(int i = 0; i < nums.length; i++) {
            currentPrefixSum += nums[i]; // prefix-sum until position 'i'
            int complementSum = currentPrefixSum - k; 
            if(map.containsKey(complementSum)) {
                count = count + map.get(complementSum);
            }
            map.put(currentPrefixSum, map.getOrDefault(currentPrefixSum, 0) + 1);
        }
        return count;
}

In this implementation we initialize the map(key=0, val=1), intuition behind is, the prefix of an empty array is 0, and it occurs at least 1 time.

Time & Space:

Time O(n): traverses the prefix array once O(n), for every index the hashMap lookup is O(1) operation.
Space O(n): using a HashMap of size n (worst case) for storing prefixes.

Data Structure & Algorithm: Merge Sort

Khadija Ashraf — Wed, 19 Mar 2025 17:12:02 +0000

Recursive Algorithm:

Step 1: find the mid index of the array
Step 2: go for sorting left half
Step 3: go for sorting right half
Step 4: merge the left and right half, sorting is done during merging

Source Code Repository: https://github.com/khadija-ashraf/data-structure-algorithm/blob/main/src/com/sorting/MergeSort.java

If we analyze the order of the steps in this recursive algorithm then, we see that, we keep slicing the array until no more slicing can be done, follow steps 1, 2, 3. No sorting is done in this slicing period. Only when the sliced array reaches to zero or 1 elements then we return from slicing and starting merging in the step 4.

Since the the Step 2 executes before the Step 3 therefore the left part of the array will be sliced until it reaches to 1-element arrays, then the sort-and-merge will execute on the left side of the recursive tree, upon return from the left subtree the right subtree sort-and-merge will be executed.


public class MergeSort {
    public void sort(int[] arr, int left, int right) {
        if(left < right) {
            int midIndex = left + (right - left) / 2;

            sort(arr, left, midIndex);
            sort(arr, midIndex+1, right);

            merge(arr, left, midIndex, right);
        }
    }

    public void merge(int[] arr, int left, int midIndex, int right) {
        int leftArraySize = midIndex - left + 1;
        int rightArraySize = right - midIndex;

        int[] leftTempArr = new int[leftArraySize];
        int[] rightTempArr = new int[rightArraySize];

        for(int i = 0; i < leftArraySize; i++) {
            leftTempArr[i] = arr[left + i];
        }

        for(int i = 0; i < rightArraySize; i++) {
            rightTempArr[i] = arr[midIndex + 1 + i];
        }

        // merge

        int i = 0; 
        int j = 0; 
        int k = left;

        while(i < leftArraySize && j < rightArraySize) {
            if(leftTempArr[i] <= rightTempArr[j]) {
                arr[k] = leftTempArr[i];
                i++;
            } else {
                arr[k] = rightTempArr[j];
                j++;
            }
            k++;
        }

        while(i < leftArraySize) {
            arr[k] = leftTempArr[i];
            i++;
            k++;
        }

        while(j < rightArraySize) {
            arr[k] = rightTempArr[j];
            j++;
            k++;
        }

    }

    public void print(int[] arr) {
        for(int n: arr) {
            System.out.print(n + ", ");
        }
    }

    public static void main(String a[]) {
        MergeSort ob = new MergeSort();

        int[] arr = {4,7,1,8,3,8,9};

        ob.sort(arr, 0, arr.length - 1);

        ob.print(arr);
    }
}

Data Structure & Algorithm: Quick Sort

Khadija Ashraf — Mon, 17 Mar 2025 17:25:15 +0000

The algorithm:

chose an element from the input array (arbitrary or, or the first, or the last one)
partition the array in left and right portions. The left part of the partition has all the elements smaller than the partition point. The right part of the partition has all the elements grater than the partition point.
The partition point is called the pivot element. After a partition completion the pivot element achieves its actual final position in the final answer, that means, after every partition we get at least one element sorted and positioned in the final sorted result.
Therefore, the later partitions excludes the pivot element cause its already sitting in the index where it is suppose to be in the final sorted array.
We treat each left and right partition as a new input array and call quicksort on both of them recursively.

Concept behind the partition method:
For every pivot element we scan the entire input array of its scope. during this scan our goal is to find any smaller elements than the pivot and place them to left side of the input array. Any left element that is not smaller than the pivot will leave its space gracefully for a smaller (than pivot) element. Therefore, we can say, after a single scan all the elements smaller than the current pivot are to the left side of the input array. Then we place the pivot element right after those smaller elements. In this process we can not assert that all those smaller elements are sorted but we can say that the pivot element is the grater than all those small elements. and since we scanned the entire input array, so it is intuitive that the pivot is sitting at the right position where it will be in the final sorted array, because all the elements left to the pivot are smaller than it, and obviously, all the elements right to the pivot must be grater than it.

This process run recursively in the left and right parts of the input array.


public class QuickSort {

    public void sort(int[] arr, int lowIndex, int highIndex) {
        if(lowIndex < highIndex) {
            int pivotIndex = partition(arr, lowIndex, highIndex);

            sort(arr, lowIndex, pivotIndex - 1);
            sort(arr, pivotIndex + 1, highIndex);
        }
    }

    public int partition(int[] arr, int lowIndex, int highIndex) {
        int pivotIndex = highIndex;
        int leftIndex = lowIndex - 1;

        for(int i = lowIndex; i <= highIndex - 1; i++) {
            if(arr[i] < arr[pivotIndex]) {
                leftIndex++;
                swap(arr, leftIndex, i);
            }
        }
        leftIndex++;
                // in this swap we are setting the pivot to the correct 
                // index where all elements to it's left are small,
                // and, all elements to the pivot's right are grater.
        swap(arr, leftIndex, pivotIndex); 
        return leftIndex;
    }

    public void swap(int[] arr, int leftIndex, int i) {
        int temp = arr[i];
        arr[i] = arr[leftIndex];
        arr[leftIndex] = temp;
    }

    public static void main(String a[]) {
//      int[] input = {8,2,6,1,7,9,3};
        int[] input = {5,2,3,1};

        QuickSort ob = new QuickSort();

        ob.sort(input, 0, input.length-1);

        for(int num: input)
        {
            System.out.println(num+", ");
        }
    }
}

Data structure: Implement Type safe, Generic, Double-ended Queue.

Khadija Ashraf — Sun, 16 Mar 2025 15:14:07 +0000

Today we will implement a Double-ended queue in Java. We will use generics so that our queue can work with any datatypes, like Integer, Double, String, Cars, Trucks, Cats, Dogs, etc... :)

The source code is in this github repository. https://github.com/khadija-ashraf/data-structure-algorithm.git

The Node is a generic class. That means this class can take different dataypes. A Node object has a generic type 'data' and two pointer 'prev' and 'next'. 'prev' points to the previous node, and 'next' pointer points to the next node in the queue.

package com.deque;


class Node<T>{
    T data;
    Node<T> prev;
    Node<T> next;

    public Node(T data){
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}

MyDeque is the deque interface. It layout the deque behaviour.

package com.deque;

// A custom Double Ended Queue (Deque) implementation:

public interface MyDeque<T> {

    public <T> T addHead(T data);
    public <T> T addTail(T data);

    public T getHead();
    public T getTail();

    public <T> boolean contains(T data);

    public T removeHead();
    public T removeTail();

    public T peekHead();
    public T peekTail();

    public T pollHead();
    public T pollTail();

    public T pop();

    public int size();
    public void printDequq() ;

}

A deque is a queue in which we can insert and remove from both the front and rear end. Conversely, in an original queue we insert at the front and remove from the rear end.

In a deque, we have a head node and a tail node representing the start and the end of the queue respectively. We add remove from both front and rear ends from the head and tail referencing nodes.

class MyDequeImpl<T> implements MyDeque<T>{
    private Node<T> head;
    private Node<T> tail;
    private int size;

    public MyDequeImpl(){
        head = null;
        tail = null;
        size = 0;
    }

    public <T> T addHead(T data) {
        Node current = new Node<>(data);
        if(head == null) {
            head = current;
            tail = current;
            size++;
            return data;
        }
        current.next = head;
        head.prev = current;
        head = current;
        size++;

        return data;
    }

    public <T> T addTail(T data) {
        Node current = new Node<T>(data);

        if(tail == null) {
            head = current;
            tail = current;
            size++;
            return data;
        }
        tail.next = current;
        current.prev = tail;
        tail = current;
        size++;
        return data;
    }

    public T getHead() {
        if (head == null)
            return null;
        return head.data;
    }

    public T getTail() {
        if(tail == null)
            return null;
        return tail.data;
    }

    public <T> boolean contains(T data) {
        if(head == null)
            return false;

        if(head.data == data) {
            return true;
        }

        if(tail.data == data) {
            return true;
        }

        Node current = head;

        while(current != null) {
            if(current.data == data) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    public T removeHead() {
        if(head == null) {
            return null;
        }

        T removedData = head.data;

        head = head.next;

        if(head == null) {
            tail = null;
        } else {
            head.prev = null;
        }
        size--;
        return removedData;
    }

    public T removeTail() {
        if(tail == null) {
            return null;
        }
        if(tail.prev == null) {
            return null;
        }
        T removedData = tail.data;
        tail = tail.prev;
        if(tail == null) {
            head = null;
        } else {
            tail.next = null;
        }
        size--;
        return removedData;
    }

    public T peekHead() {
        if(head == null)
            return null;

        return head.data;
    }

    public T peekTail() {
        if(tail == null)
            return null;

        return tail.data;
    }

    public T pollHead() {
        if(head == null)
            return null;

        T polledData = head.data;

        head = head.next;

        if(head == null) {
            tail = null;
        } else {
            head.prev = null;
        }
        size--;

        return polledData;
    }

    @Override
    public T pollTail() {
        if(tail == null) {
            return null;
        }
        T pollData = tail.data;

        tail = tail.prev;

        if(tail == null)
            head = null;
        else {
            tail.next = null;
        }

        size--;
        return pollData;
    }

    public T pop() {
        if(tail == null)
            return null;

        T popedData = tail.data;

        tail = tail.prev;

        if(tail == null)
            head = null;
        else {
            tail.next = null;
        }
        size--;
        return popedData;
    }

    public int size() {
        return size;
    }
    public void printDequq() {
        System.out.println("Printing the deque of size: "+size());
        if (head == null) {
            System.out.println("Dequq is empty.");
        }
        Node<T> current = head;
        while(current != null) {
            System.out.println(current.data);
            current = current.next;
        }
    }

}

Below is some test insertions, removal, polling, peeking, and pop.

package com.deque;

public class TestDeque{
    public static void main(String arg[]) {
        MyDeque<String> deque = new MyDequeImpl<>();
        deque.addHead("cat");
        deque.printDequq();
        deque.addHead("dog");
        deque.printDequq();
        deque.addHead("rabbit");
        deque.printDequq();
        deque.addHead("elephant");
        deque.printDequq();
        deque.addTail("squirrel");
        deque.printDequq();

        System.out.println("=============");
        System.out.println(deque.getHead());
        System.out.println(deque.getTail());
        System.out.println(deque.contains("monkey"));
        System.out.println(deque.contains("rabbit"));
        System.out.println(deque.removeHead());
        System.out.println(deque.removeTail());
        System.out.println("=======");

        System.out.println(deque.getHead());
        System.out.println(deque.getTail());
        System.out.println("=======");
        System.out.println(deque.peekHead());
        System.out.println(deque.peekTail());
        System.out.println("========");
        System.out.println(deque.pollHead());
        System.out.println(deque.pollTail());
        deque.printDequq();

        System.out.println("========");
        System.out.println(deque.pop());
        deque.printDequq();

        deque.addHead("birds");

        deque.printDequq();
    }
}

Beginner Tutorial: Build, Test, and deploy Spring Boot microservices with MongoDB and Docker

Khadija Ashraf — Thu, 13 Mar 2025 22:30:45 +0000

This is a beginner application to create a group of microservices to perform CRUD and filtering on a group of Users. This project is implemented in a MacBook Pro. The source code is available in the GitHub Repository.

The steps we follow to successfully implement this project are below:

Initialize the springboot application.

Download a Springboot application from the spring initializr website, https://start.spring.io/. Add dependency Spring Web, Spring Data MongoDB, and Mockito.

From the website spring initializr downloading the project:

pom.xml dependencies:

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
        </dependency>
    </dependencies>

Tips: Add the mockito-core dependency explicitly in your pom.xml if you don't find in the dependency directory in the spring initializr website.

Now import the project in your IDE. I'm using the eclipse community version. Then run the project from the entry point of the application that is the project name you selected while downloading from spring initializr website. In my example the application name is MongoDemoApplication.

Tips: Remember that the tomcat is embedded with the spring-boot-starter-web dependency. So when we run the application the tomcat server runs on port 8080. If we fail to stop the server before running the spring application again then a Port 8080 was already in use error will fail the application to start again. So we need to stop the underlying tomcat server before we try starting that again. Among many options we can run the below command in the terminal.

kill -9 $(lsof -t -i:8080) This stops any process running on port 8080, which is Tomcat’s default port.)

Now its time to install and configure the MongoDB.

Install and run the MongoDB in the local machine.

Install MongoDB Using Homebrew (this example uses Macbook Pro):
To install HomeBrew (if not already installed):
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

check if Homebrew is installed correctly:
brew --version

Add Homebrew to Your Path:
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zshrc source ~/.zshrc

Then follow below steps to install MongoDB:

brew update -- Update Homebrew
brew tap mongodb/brew -- Install MongoDB Community Edition
brew install mongodb-community@7.0
brew services start mongodb-community@7.0 -- Start MongoDB as a background service
brew services stop mongodb-community@7.0 --To stop MongoDB
mongod --version -- Check if MongoDB is running

To add MongoDB in your application add below properties in the application.properties. The application.properties file is located under src/main/resources directory. In this example the DB name is myFirstDB.

spring.application.name=MongoDemo spring.data.mongodb.uri=mongodb://localhost:27017/myFirstDB spring.data.mongodb.database=myFirstDB

Create the MVC layers for User Services.

Next we create the layers of the User managing microservice application. Controller (RESTApi endpoints) Layer, Service Layer, Repository Layer, and the Entity Layer.

Tips: You can separate java packages or keep them in a single package. However, be sure to keep the main class in the parent package. In this example I'm keeping MongoDemoApplication in the parent package com.example. If your controller, service, repository, entity classes are spread in different packages then be sure to the @ComponentScan() to link the inner package classes.
,

@SpringBootApplication
@ComponentScan(basePackages = "com.example.controller, com.example.Service, com.example.repository")
public class MongoDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(MongoDemoApplication.class, args); 
        System.out.println("Welcome to user world!");
    }

}

The User entity is defined below:

package com.example.entity;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

import com.mongodb.lang.NonNull;

@Document (collection = "users")
public class User {

    @Id
    private String id;

    @NonNull
    private String name;

    @NonNull
    private String email;

    public User() {}

    public User(String name, String email) {
        super();
        this.name = name;
        this.email = email;
    }

    public User(String id, String name, String email) {
        super();
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

The UserRepository is defined below:

package com.example.repository;

import java.util.List;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import com.example.entity.User;

@Repository
public interface UserRepository extends MongoRepository<User, String>{
    User findByEmail(String email);
    List<User> findByName(String name);
}

The UserService interface is defined below:

package com.example.service;

import java.util.List;

import com.example.entity.User;

public interface UserService {
    List<User> getAllUsers();

    User getUserById(String id);
    User getUserByEmail(String email);
    List<User> getUsersByName(String name);

    User createUser(User user);
    User updateUser(String id, User user);
    void deleteUser(String Id);
}

The UserServiceImpl defined below:

package com.example.service;

import java.util.List;

import org.springframework.stereotype.Service;

import com.example.entity.User;
import com.example.repository.UserRepository;

@Service
public class UserServiceImpl implements UserService{

    private final UserRepository userRepo;

    public UserServiceImpl(UserRepository userRepo) {
        super();
        this.userRepo = userRepo;
    }

    public List<User> getAllUsers() {
        return userRepo.findAll();
    }

    public User getUserById(String id) throws RuntimeException{
        return userRepo.findById(id).orElseThrow(() -> new RuntimeException("User not found "+id));
    }

    public User getUserByEmail(String email) {
        return userRepo.findByEmail(email);
    }

    public List<User> getUsersByName(String name) {
        return userRepo.findByName(name);
    }

    public User createUser(User user) {
        return userRepo.save(user);
    }

    public User updateUser(String id, User user) {
        User existing = getUserById(id);
        existing.setEmail(user.getEmail());
        existing.setName(user.getName());
        return userRepo.save(existing);
    }

    public void deleteUser(String id) {
        userRepo.deleteById(id);
    }
}

Now that, we have all our repository and service code implemented we write our RESTApi endpoints, that is the controller layer.

package com.example.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.annotation.AccessType;
import org.springframework.http.HttpStatus;
import org.springframework.http.HttpStatusCode;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.service.UserService;
import com.example.entity.User;

import java.util.List;


@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public User getAllUserById(@PathVariable String id){
        return userService.getUserById(id);
    }

    @GetMapping("/name/{name}")
    public List<User> getAllUsersByName(@PathVariable String name){
        return userService.getUsersByName(name);
    }

    @GetMapping("/email/{email}")
    public User getUserByEmail(@PathVariable String email) {
        return userService.getUserByEmail(email);
    }

    @PostMapping("/create")
    public ResponseEntity<User> createUser(@RequestBody User user) {
        userService.createUser(user);
        return ResponseEntity.status(HttpStatusCode.valueOf(HttpStatus.CREATED.value()))
                .body(user);
    }

    @PostMapping("/update/{id}")
    public User updateUser(@PathVariable String id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/delete/{id}")
    public void deleteUserById(@PathVariable String id) {
        userService.deleteUser(id);
    }
}

Testing the service layer and the RESTApi endpoints using Mockito

Now, that we have our DB, and service layer, and REST endpoints we can write our test methods.

Tips: Mockito does not run the entire application. It only mocks the service and controller objects to test their methods. The test results are valid however, since the application is not running and the RESTApis are not called over HTTP, therefore no DB actions are performed. To test the DB interactions we can use Postman, other RESTApi clients. However, these calls will make real and persistent changes in the DB. If we still want to test DB interactions but want to avoid testing in the development DB instance, then we can use Spring TestContainers. In the Testcontainers we can run real DB instances inside a Docker container. For a testing session, Spring-boot spins up a Docker container with as new DB instance. When testing is done the container is stopped. TestContainers are out of scope of this tutorial. We will see Mockito test classes.

Test Service layer with Mockito

The UserServiceTest is designated to the User @service class.

package com.example.MongoDemo;

// import static org.junit.Assert.assertNotNull;  — incorrect import
import static org.junit.jupiter.api.Assertions.assertNotNull; // -correct import

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;

import java.util.Optional;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.boot.test.context.SpringBootTest;

import com.example.entity.User;
import com.example.repository.UserRepository;
import com.example.service.UserServiceImpl;

@SpringBootTest
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserServiceImpl userServiceImpl;

    @Test
    void testGetUserById() {
        String id = "1";
        String name = "John Doe";
        String email = "john@gmail.com";
        User user = new User(name, email);
        user.setId(id);

        when(userRepository.findById(id)).thenReturn(Optional.of(user));

        User result = userServiceImpl.getUserById(id);
        assertNotNull(result);
        assertEquals(result.getName(), user.getName());

    }
}

Tips: Be sure to import the right assertNotNull dependency. Importing import static org.junit.Assert.assertNotNull will give a compile error during building your project's .jar file. I'm copying the compilation error for your reference. src/test/java/com/example/MongoDemo/UserServiceTest.java:[3,24] cannot find symbol symbol: class Assert location: package org.junit

The UserControllerTest is designated to the User @RestController class.

package com.example.MongoDemo;

import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.log;
// Import for status(), jsonPath()
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;

import com.example.controller.UserController;
import com.example.entity.User;
import com.example.service.UserService;

@WebMvcTest(UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    void testGetUserById() throws Exception {
        when(userService.getUserById("1")).thenReturn(new User("1", "John Doe", "john@gmail.com"));

        mockMvc.perform(get("/users/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.id").value(1))
               .andExpect(jsonPath("$.name").value("John Doe"))
               .andExpect(jsonPath("$.email").value("john@gmail.com"));
    }

    @Test
    void testCreateUser() throws Exception {
        String userJson = "{\"name\": \"Jane Doe\", \"email\": \"jane@gmail.com\"}";

        ResultActions resultActions = mockMvc.perform(post("/users/create")
                .contentType(MediaType.APPLICATION_JSON)
                .content(userJson))
                .andDo(print())
                .andDo(log())
               .andExpect(status().isCreated())
               .andExpect(jsonPath("$.name").value("Jane Doe"));
    }
}

Tips: In the UserControllerTest file be sure to include the static imports. They are often not recommended by the IDE and you explicitly have to find the dependencies to be able to import them. Below are the static import used in this UserControllerTest class.

import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.log;
// Import for status(), jsonPath()
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

To log the HTTP req/res from the test methods add below properties in the application.properties file.

# Enable logging to a file
logging.file.name=logs/app.log  # Creates logs/app.log
# OR (alternative)
logging.file.path=logs  # Creates logs/spring.log

# Set log level (Optional)
logging.level.root=INFO

Tips: To ensure log of the actual HTTP requests and responses use the print() and log() methods in the mockMvc.perform() method.

import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.log;

Run the UserControllerTest.java and UserServiceTest.java separately to test the RESTApi methods and service methods in a mock environment. The actual HTTP req/res will be printed in the log file when you run UserControllerTest.java.

HTTP Request and corresponding response printed by running the RestController UserControllerTest.java.

MockHttpServletRequest:
      HTTP Method = POST
      Request URI = /users/create
       Parameters = {}
          Headers = [Content-Type:"application/json;charset=UTF-8", Content-Length:"47"]
             Body = {"name": "Jane Doe", "email": "jane@gmail.com"}
    Session Attrs = {}

Handler:
             Type = com.example.controller.UserController
           Method = com.example.controller.UserController#createUser(User)

Async:
    Async started = false
     Async result = null

Resolved Exception:
             Type = null

ModelAndView:
        View name = null
             View = null
            Model = null

FlashMap:
       Attributes = null

MockHttpServletResponse:
           Status = 201
    Error message = null
          Headers = [Content-Type:"application/json"]
     Content type = application/json
             Body = {"id":null,"name":"Jane Doe","email":"jane@gmail.com"}
    Forwarded URL = null
   Redirected URL = null
          Cookies = []

Deploy the User-microservice application and the MongoDb in Docker

We will deploy our microservice app and the mongoDB in docker containers. Please install Docker Desktop in your system. This example uses Docker Desktop on Mac (Apple Silicon chip). Follow the link for installation on Mac, https://docs.docker.com/desktop/setup/install/mac-install/

The steps we follow:

Creating a docker image of the springboot microservice application.
Then upload the microservice image that we just created into Docker hub (Docker Hub is a cloud-based registry service provided by Docker for storing, sharing, and managing container images [ref. docker.com])
Write and execute a file named docker-compose.yml. This fill will be responsible to pull both the microservice and mongodb images from the docker hub and also run both the containers. >Tips: We don't need to create a docker image for mongoDB because its already up in the docker hub.

1. Creating a docker image of the springboot microservice application.

Step 1: Build the Spring Boot JAR
Navigate to your Spring Boot project directory and run below command in your terminal.(You can install maven in you system or you can use the IDE integrated maven. This example uses maven outside the IDE eclipse):

mvn clean package -DskipTests

This generates a JAR file inside the target/ directory. My .jar file name is, MongoDemo-0.0.1-SNAPSHOT.jar.

Step 2: Create a Dockerfile: Inside your project root directory, create a file named Dockerfile (without any extension).

# Use an official OpenJDK image as the base image
FROM openjdk:17-jdk-slim

# Set the working directory inside the container
WORKDIR /app

# Copy the JAR file from the host machine to the container
COPY target/MongoDemo-0.0.1-SNAPSHOT.jar app.jar

# Expose the application port
EXPOSE 8080

# Command to run the application
ENTRYPOINT ["java", "-jar", "app.jar"]

Step 3. Build the Docker Image
From the terminal run the following command in the directory where your Dockerfile is located. I've this file right under the application folder, MongoDemo/dockerfile

docker build -t my-user-microservice .

• -t my-microservice → Assigns a name (my-microservice) to the image.
• . → Tells Docker to look for the Dockerfile in the current directory.

You will see below longs in your terminal upon executing the docker build command.

Step 4. Verify the Docker Image
After building, check if the image is created:
docker images --You should see my-user-microservice in the list.

Step 5. Run the Container
docker run -d --name microservice-container -p 8080:8080 my-user-microservice

• -d → Runs in detached mode (background).
• --name microservice-container → Assigns a name to the container.
• -p 8080:8080 → Maps container port 8080 to host port 8080.

After running this command a container Id will be returned similar to this one 695bd664bd94155b1d8640bcc2a74633110e0f11ce830796b72e4fb57bda9e4c

Now, your microservice should be accessible at: http://localhost:8080

Step 6. Check Running Containers

To verify if your container is running: docker ps

If you need logs: docker logs microservice-container

Step 7. Stop & Remove a single Container (Optional)
docker stop microservice-container

Step 8: To remove the container:
docker rm microservice-container

Step 9.Stop & Remove all the Containers
docker-compose down. --This stops and removes all containers.

Step 10. Restart Services
docker-compose restart

Step 11. Rebuild Images (If Needed)
docker-compose up --build -d --If you made changes to the Dockerfile or code and want to rebuild

2. Then upload the microservice image that we just created into Docker hub

Step 1: Login to Docker Hub using command: docker login
Enter your Docker Hub username and password.

Step 2: Tag the Image.
docker tag my-user-microservice <your-dockerhub-username>/my-user-microservice:latest

Example: docker tag my-user-microservice johndoe/my-user-microservice:latest

Step 3: Push the Image.
docker push <your-dockerhub-username>/my-user-microservice:latest

Now, your image is available on Docker Hub and can be pulled from anywhere using: docker pull johndoe/my-user-microservice:latest

You can try this docker pull command just to verify. However, the docker-decompose.yml will pull the microservice image from the docker huband lunch a container for that.

3. Now to write and execute a file names docker-compose.yml.

Step1: Our microservice needs to run alongside a MongoDB so we create create a docker-compose.yml file. We can use docker-compose when we have multiple containers for example for microservices, databases, and more, interacting with each other. docker-compose is used to manage multiple Docker containers as a single service. Follow these steps to run a docker-compose.yml file.

Step2: Run Docker Compose

Navigate to the Directory Containing docker-compose.yml, then run the command: docker-compose up -d

-d→ Runs the containers in detached mode (in the background).

Note: In Docker, use container names/services instead of localhost.

Verify the MongoDB activity inside from its Docker Container

We can open the terminal in the docker container from the docker GUI by clicking the Terminal.

Once the terminal is open run the below commands to see the users entries.

docker exec -it mongodb mongosh-- Run the MongoDB shell inside the container:

-it → Interactive mode.
mongodb → Name of the running container.
mongosh → Starts the MongoDB shell.
Now, you can run MongoDB queries:

show dbs;
use myFirstDB;
db.users.find();

To test the containerized microservice application including the DB interactions use Postman or any other RESTApi client for calling microservices. First make the api call from Postman, then access the Docker container terminal to look into the users collection.

I've copied the "/users/create" API endpoint calling details below.

_POST http://localhost:8080/users/create
Request headers: Content-Type: application/json
Request Body (raw) : {"name": "mina", "email": "mina@g.com"}

Response headers:Content-Type: application/json
Response Body: {"id":"67d351220527311ea262f733","name":"rina","email":"rina@g.com"}_

This concludes the tutorial. I tried to create an entire lifecycle of a microservice based application from development to deployment. Hope this helps!