DEV Community: Galisetty Priyatham

Building a Mailbox Pattern in Spring Boot to Decouple Your Application Layers

Galisetty Priyatham — Thu, 31 Jul 2025 18:56:07 +0000

Introduction
In a typical Spring Boot application, synchronous service calls between layers can create tight coupling and reduce flexibility for long-running or delayed processes. In this article, we’ll walk through a clean implementation of the Mailbox Pattern using BlockingQueue, allowing decoupled, asynchronous processing between the controller and the background worker.

Imagine how you drop a letter in a mailbox and the postman picks it up later. You don’t wait at the box for delivery to happen.

Similarly, the Mailbox Pattern in a Spring application allows you to accept incoming tasks instantly, drop them into a queue, and let a background thread process them later. This makes your application faster, more scalable, and loosely coupled.

Use Case
Imagine you’re receiving task requests via a REST API, but you don’t want to process them immediately either because they’re slow or you want to manage them in batches or queues.

A Mailbox Pattern helps solve this by:

📨 Receiving the task
📥 Putting it into a mailbox (queue)
🛠️ Processing it in a background worker

Architecture

+------------+        +-------------+        +-------------+
| REST API   |        | Mailbox     |        | Worker      |
| Controller | -----> | (Queue)     | -----> | Thread/Task |
+------------+        +-------------+        +-------------+

Tech Stack

Spring Boot 3
Java 17+
Maven

Project Structure

spring-mailbox-demo/
├── pom.xml
└── src/
    └── main/
        ├── java/com/example/mailbox/
        │   ├── SpringMailboxDemoApplication.java
        │   ├── controller/TaskController.java
        │   ├── model/TaskRequest.java
        │   └── service/
        │       ├── Mailbox.java
        │       └── TaskWorker.java
        └── resources/application.properties

Full Source Code

<project xmlns="http://maven.apache.org/POM/4.0.0"
         ...>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>spring-mailbox-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.2</version>
    </parent>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

SpringMailboxDemoApplication.java

package com.example.mailbox;

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

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

model/TaskRequest.java

package com.example.mailbox.model;

public class TaskRequest {
    private String taskId;
    private String payload;

    public TaskRequest() {}

    public TaskRequest(String taskId, String payload) {
        this.taskId = taskId;
        this.payload = payload;
    }

    public String getTaskId() {
        return taskId;
    }

    public void setTaskId(String taskId) {
        this.taskId = taskId;
    }

    public String getPayload() {
        return payload;
    }

    public void setPayload(String payload) {
        this.payload = payload;
    }
}

How does the Controller fit in?
The controller is like the person dropping a letter in the mailbox. It doesn't care how or when the letter gets delivered — it just drops it and responds immediately with “Task submitted.”

TaskController.java

@RestController
@RequestMapping("/task")
public class TaskController {

    @Autowired
    private Mailbox mailbox;

    @PostMapping
    public ResponseEntity<String> submitTask(@RequestBody TaskRequest task) {
        mailbox.submit(task); // drop it into the mailbox
        return ResponseEntity.ok("Task submitted: " + task.getTaskId());
    }
}

📥 What is the Mailbox really doing?

We use a BlockingQueue in Java, which works like a thread-safe to-do list.
The controller adds a task to it using offer().
The worker thread pulls tasks from it using take().
This lets the web request return instantly while the real work is still happening behind the scenes.

service/Mailbox.java

package com.example.mailbox.service;

import com.example.mailbox.model.TaskRequest;
import org.springframework.stereotype.Component;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

@Component
public class Mailbox {
    private final BlockingQueue<TaskRequest> queue = new LinkedBlockingQueue<>();

    public void submit(TaskRequest request) {
        queue.offer(request);
    }

    public TaskRequest take() throws InterruptedException {
        return queue.take();
    }
}

What is the Worker Thread doing?
The worker acts like a postman. It runs in the background and keeps checking the mailbox for new tasks.
When it finds one, it processes it (in our case, just logs it). You can later expand this to send emails, call APIs, or save to a DB.

service/TaskWorker.java

package com.example.mailbox.service;

import com.example.mailbox.model.TaskRequest;
import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TaskWorker {

    @Autowired
    private Mailbox mailbox;

    @PostConstruct
    public void startWorker() {
        Thread workerThread = new Thread(() -> {
            while (true) {
                try {
                    TaskRequest task = mailbox.take();
                    System.out.println("Processing task: " + task.getTaskId() + " | Payload: " + task.getPayload());
                    Thread.sleep(2000); // simulate work
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });

        workerThread.setDaemon(true);
        workerThread.start();
    }
}

application.properties

server.port=8080

Why It Matters

Helps with performance by not blocking HTTP threads.
Supports scalability by isolating heavy processing.
Promotes loose coupling between controller and business logic.

You can expand this pattern by:

Adding retry or error queues
Using ScheduledExecutorService
Swapping BlockingQueue with a Kafka topic or Spring Integration MessageChannel

Even if you're a beginner, this pattern teaches you:

How to run background threads in Spring
How to decouple HTTP input from business logic
How to simulate real-world job queues
You now understand not just how to build it but why it’s useful in real-world applications.

Summary
This pattern may seem simple, but it unlocks powerful asynchronous processing patterns for real-world Spring applications with minimal complexity and maximum decoupling.

You can also download from :

pgalisetty / spring-mailbox-demo

A Mailbox Pattern example

Dynamic Dropdown Filtering in JSP Using AJAX and Custom Tags

Galisetty Priyatham — Thu, 10 Jul 2025 19:43:02 +0000

In legacy enterprise web applications using JSP and Spring MVC, rendering dropdowns with server-side values is a common practice. But what happens when the dropdown values need to change dynamically based on user selections? Especially when the options are served by custom JSP tags and driven by server-side session state?

In this blog post, we'll walk through how we implemented a smart, user-driven filtering mechanism for dropdowns all without touching or rewriting existing custom tags.

🔎 Problem Overview

We had a dropdown for selecting a cause of device malfunction. The list of causes depended on the types of devices selected from another multi-select dropdown.

The challenge?

The malfunction dropdown was rendered via a custom JSP tag (<app:filteredDropdown> ).
The options were pulled from a generalized code table using a categoryGroup value.
We had to update the dropdown options dynamically based on selected device type codes.

✨ The Goal

✅ Detect which device types the user selected

✅ Send those types to the backend

✅ Backend updates session with new categoryGroup

✅ Page reloads and custom tag picks up new values via session

📄 Frontend (JSP) Setup
We added hidden fields to carry the server-generated filter state:
<input type="hidden" id="hiddenCategoryGroup" value="${categoryGroup}" /> <input type="hidden" id="hiddenDeviceIds" value="${chosenDeviceIds}" />

Device Dropdown

<app:select path="deviceList" id="deviceSelector" multiple="true" onchange="onDeviceChange()">
  <c:forEach items="${sessionData.activeDevices}" var="device">
    <app:option value="${device.id}" data-categorycode="${device.categoryCode}">
      ${device.name} (${device.categoryCode})
    </app:option>
  </c:forEach>
</app:select>

Malfunction Dropdown (Custom Tag)

<app:filteredDropdown path="issueCause"
  gpc="143"
  filterGroup="${categoryGroup}"
  id="issueDropdown"
  includeBlankOption="true"
  blankOptionText="Select" />

JavaScript to Handle Dropdown Logic

function onDeviceChange() {
  const selectedCodes = [];
  $('#deviceSelector option:selected').each(function () {
    const code = $(this).data('categorycode');
    if (code) selectedCodes.push(code);
  });

  const categoryGroup = selectedCodes.join(',');
  const selectedIds = ($('#deviceSelector').val() || []).join(',');

  $.ajax({
    type: "GET",
    url: "/filterIssueDropdown",
    data: { typeCodes: categoryGroup, selectedDeviceIds: selectedIds },
    success: function () {
      location.reload();
    }
  });
}

💻 Backend Spring Controller

@RequestMapping(value = "/filterIssueDropdown", method = RequestMethod.GET)
public String filterIssueDropdown(HttpServletRequest request,
                                  Model model,
                                  @ModelAttribute("sessionData") SessionData sessionData,
                                  @RequestParam("typeCodes") String typeCodes,
                                  @RequestParam("selectedDeviceIds") String selectedDeviceIds) {

    sessionData.getDeviceState().setCategoryGroup(typeCodes);
    sessionData.getDeviceState().setChosenDeviceIds(selectedDeviceIds);

    return "redirect:/addDeviceIssue?reload=true";
}

🧩 Custom Tag Class: FilteredDropdownTag

public class FilteredDropdownTag extends AbstractDropdownTag {
    private String gpc;
    private String filterGroup;

    @Override
    protected int writeTagContent(TagWriter tagWriter) throws JspException {
        initializeFilteredItems();
        return super.writeTagContent(tagWriter);
    }

    private void initializeFilteredItems() {
        Map<String, String> allItems = CodeHelper.getAllCodesForTypeAsMap(gpc);

        if (filterGroup == null || filterGroup.isEmpty()) {
            setItems(allItems);
            return;
        }

        String[] groups = Arrays.stream(filterGroup.split(","))
            .map(String::trim)
            .filter(s -> !s.isEmpty())
            .toArray(String[]::new);

        Set<String> allowedCodes = null;
        for (String group : groups) {
            List<String> groupCodes = MalfunctionGroupHelper.getAllowedCodesForGroup(group);
            if (allowedCodes == null) {
                allowedCodes = new HashSet<>(groupCodes);
            } else {
                allowedCodes.retainAll(groupCodes);
            }
        }

        if (allowedCodes == null) {
            allowedCodes = Collections.emptySet();
        }

        Map<String, String> filtered = new HashMap<>();
        for (Map.Entry<String, String> entry : allItems.entrySet()) {
            if (allowedCodes.contains(entry.getKey())) {
                filtered.put(entry.getKey(), entry.getValue());
            }
        }

        setItems(filtered);
    }

    public void setGpc(String gpc) {
        this.gpc = gpc;
    }

    public void setFilterGroup(String filterGroup) {
        this.filterGroup = filterGroup;
    }
}

🔍 Explanation

initializeFilteredItems() retrieves all GPC values and filters them based on intersection logic.
This means only codes common to all selected device types are shown.
The custom tag does all the filtering server-side, using parameters passed from the session.

📖 Malfunction Group Helper Utility

public class MalfunctionGroupHelper {
    private static final Map<String, List<String>> GROUP_CODE_MAP = new HashMap<>();

    static {
        GROUP_CODE_MAP.put("1", Arrays.asList("1", "2", "3", "6", "8", "9", "10"));
        GROUP_CODE_MAP.put("2", Arrays.asList("2", "3", "5", "6", "8", "9", "10"));
        GROUP_CODE_MAP.put("3", Arrays.asList("2", "3", "4", "5", "6", "7", "8", "9", "10"));
        GROUP_CODE_MAP.put("4", Arrays.asList("2", "3", "5", "6", "8", "9", "10"));
        GROUP_CODE_MAP.put("5", Arrays.asList("2", "3", "5", "6", "8", "9", "10"));
        GROUP_CODE_MAP.put("6", Arrays.asList("2", "3", "4", "5", "6", "7", "8", "9", "10"));
    }

    public static List<String> getAllowedCodesForGroup(String group) {
        return GROUP_CODE_MAP.getOrDefault(group.toUpperCase(), Collections.emptyList());
    }
}

✅ Outcome

✔ Smooth, dynamic dropdown updates using existing infrastructure

✔ No need to rewrite the custom JSP tag

✔ AJAX-enabled UX while keeping server-driven rendering intact

📝 Final Thoughts

When working in JSP-heavy legacy systems, you can still build reactive behavior using a mix of:

Session state
Light AJAX
Custom tag parameter binding

This hybrid approach helps modernize the UI without a full rewrite. Have a similar challenge? Try this pattern first — it might just save you from rewriting that 10-year-old tag library!

Note: All class and method names in this post are generalized examples.

A Guide to the Spring Framework with Examples

Galisetty Priyatham — Wed, 18 Jun 2025 13:06:29 +0000

1. Introduction to Spring Framework

The Spring Framework is a powerful platform for developing Java applications. It started in 2002 and helps developers build secure, efficient, and maintainable software. Think of Spring as a toolkit that organizes and wires up all the parts of a Java application so you don’t have to do it manually.
At the heart of Spring is Inversion of Control (IoC) and Dependency Injection (DI)—fancy terms that simply mean Spring creates and manages the objects your app needs and connects them together.

2. The Problem Spring Solves

Traditional Java EE (Before Spring):
• Lots of repetitive code.
• Hard to test small parts without setting up everything.
• Complex setup with XML files and interfaces.

Spring’s Solution:
• Less code: Write only what’s necessary.
• Better testability: Easily test parts of your app without starting the whole app.
• Simpler wiring: Let Spring create and connect the objects.

3. Spring Framework Architecture vs Legacy Java EE

Legacy Java EE Architecture:

• Tightly coupled components
• Deployment descriptors (XML) needed for almost everything
• Testing required full application server (like JBoss or WebLogic)

Spring Architecture:

• Loose coupling using IoC/DI
• Annotations replace XML
• Easy unit and integration testing without full container

Visual Comparison Diagram

Analogy:

Imagine a company:
• In Java EE, every department (EJB, DAO) manages its own setup—forms, meetings, permissions. A huge overhead for small changes.
• In Spring, there’s an office manager (Spring Container) that wires up teams, resources, and schedules, so departments only focus on their job.

4. Core Concepts with Examples

a) Dependency Injection (DI)
Imagine you’re making a car, and the car needs an engine. Instead of making the engine inside the Car class, Spring gives the Car class an already-built engine.

public class Engine {
    public String start() {
        return "Engine started";
    }
}

public class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void drive() {
        System.out.println(engine.start());
    }
}

With Spring:

@Configuration
public class AppConfig {
    @Bean
    public Engine engine() {
        return new Engine();
    }

    @Bean
    public Car car() {
        return new Car(engine());
    }
}

b) Bean Scopes
• singleton: One object per Spring container (default).
• prototype: A new object every time you ask for it.

@Component
@Scope("prototype")
public class Toy {
    public Toy() {
        System.out.println("New Toy created!");
    }
}

c) Autowiring
Let Spring inject dependencies automatically.

@Component
public class Engine {
    public String start() {
        return "Engine running";
    }
}

@Component
public class Car {
    @Autowired
    private Engine engine;

    public void drive() {
        System.out.println(engine.start());
    }
}

5. Enterprise Services in Spring

a) Spring MVC (Web Development)

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

b) Data Access with Spring Data JPA

@Entity
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
}

public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByName(String name);
}

c) Transactions

@Service
public class BankService {
    @Autowired
    private AccountRepository accountRepo;

    @Transactional
    public void transferMoney(Long fromId, Long toId, double amount) {
        Account from = accountRepo.findById(fromId).get();
        Account to = accountRepo.findById(toId).get();
        from.setBalance(from.getBalance() - amount);
        to.setBalance(to.getBalance() + amount);
    }
}

d) Messaging (JMS)

@Component
public class MyReceiver {
    @JmsListener(destination = "myQueue")
    public void receiveMessage(String msg) {
        System.out.println("Received: " + msg);
    }
}

6. What is Spring Boot?

Spring Boot simplifies everything.
• Adds built-in servers like Tomcat.
• No need to configure everything manually.
• Provides “starters” to get going quickly.

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

application.properties
server.port=8081
spring.datasource.url=jdbc:h2:mem:test

7. Different Flavors of Spring

@EnableDiscoveryClient
@SpringBootApplication
public class MyMicroserviceApp {
    public static void main(String[] args) {
        SpringApplication.run(MyMicroserviceApp.class, args);
    }
}
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .and().formLogin();
    }
}

8. Other Key Spring Projects

• Spring Security: Secures your app with login, roles, and more.
• Spring Cloud: Helps in building scalable microservices (e.g., Netflix Eureka, Ribbon).
• Spring Batch: Supports batch processing of large data.

9. Spring Cheat Sheet Summary

Spring makes Java development modern, testable, and easier to manage. Spring Boot takes this one step further by reducing configuration and giving you production-ready defaults. Different flavors of Spring make it versatile enough to handle small apps, large enterprise systems, microservices, and everything in between.
In short, Spring helps developers focus on building features instead of spending time on repetitive configurations and setups. It’s like having a well-organized kitchen where every tool is ready for you to cook a great dish—fast, efficient, and hassle-free.

Preventing Duplicate or Nearby Location Entries Using the Haversine Formula in Java

Galisetty Priyatham — Mon, 16 Jun 2025 16:47:01 +0000

When you're building geospatial applications, it's surprisingly easy for users to accidentally create duplicate or very close records. Imagine trying to add a location (like a traffic signal or utility pole) at a GPS point that’s just 30 feet away from an existing one. Should the system allow that? Should the user be warned?

In this post, I’ll show how I implemented a proximity detection system using the Haversine formula in Java to solve this problem cleanly and effectively.

🎯 The Requirement

My goal was to prevent duplicate entries by:

Calculating the distance between the new location and existing ones
Alerting the user if any location was within X feet (say, 100 ft)
Letting them decide whether to continue

So instead of relying on exact latitude/longitude matches, we used distance-based detection.

🌍 Why Haversine?

The Earth is round, not flat — and the Haversine formula accounts for that. It calculates the shortest distance over the Earth's surface between two latitude/longitude points, returning a value in meters (or feet, in our case).

💻 Java Code: Checking Nearby Locations

Here’s how I implemented it in Java:

Step 1: Find All Locations Within a Given Distance

public static List<Location> findNearbyLocations(List<Location> locations, double newLat, double newLon, double maxDistanceInFeet) {
    List<Location> nearby = new ArrayList<>();

    for (Location loc : locations) {
        double distance = calculateDistanceInFeet(newLat, newLon, loc.getLatitude(), loc.getLongitude());
        loc.setDistanceInFeet(distance);
        if (distance <= maxDistanceInFeet) {
            nearby.add(loc);
        }
    }

    return nearby;
}

Step 2: Calculate Distance Using Haversine Formula

public static double calculateDistanceInFeet(double lat1, double lon1, double lat2, double lon2) {
    double earthRadiusMeters = 6371000.0;

    double dLat = Math.toRadians(lat2 - lat1);
    double dLon = Math.toRadians(lon2 - lon1);

    double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
             + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))
             * Math.sin(dLon / 2) * Math.sin(dLon / 2);

    double angularDistance = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    double distanceMeters = earthRadiusMeters * angularDistance;

    return Math.ceil(distanceMeters * 3.28084); // Convert to feet
}

🧪 Example Usage

List<Location> existingLocations = fetchFromDatabase();
double newLat = 40.4406;
double newLon = -79.9959;

List<Location> nearby = findNearbyLocations(existingLocations, newLat, newLon, 100);

if (!nearby.isEmpty()) {
    System.out.println("⚠️ A location already exists within 100 feet:");
    for (Location loc : nearby) {
        System.out.println(" - ID: " + loc.getId() + " | Distance: " + loc.getDistanceInFeet() + " feet");
    }
}

🔄 Real-World Applications

This technique can help with:

Deduplication in asset management systems

Avoiding overlapping POIs in mapping tools

Notifying users of nearby infrastructure

You could extend this further by:

Visualizing nearby matches on a map

Using a UI modal with “Continue Anyway” option

Applying clustering or spatial indexing for large datasets

🧠 Final Thoughts

The Haversine formula gave us a lightweight and accurate way to detect duplicate or nearby location entries. It’s especially useful when latitude and longitude are just a few decimal points apart but still physically very close.

From Redundancy to Reusability: A Better Way to Manage Shared Records in Relational Databases

Galisetty Priyatham — Sun, 15 Jun 2025 02:47:48 +0000

The Use Case
Let’s say we’re building a system to track maintenance sessions (WorkSession). Each session requires an approval (Approval) from a contractor before work can begin.

At first, we had a simple schema:

WorkSession

session_id (PK)

Approval

approval_id (PK)
session_id (FK)
contractor_name

Each Approval was linked directly to a WorkSession. But soon, a real-world need surfaced:

Sometimes, one approval covers multiple sessions.

But our database design didn't allow that. Instead, we had to duplicate approval records for each session — not ideal.

The Solution
We redesigned the schema to support many-to-many relationships using a join table:

WorkSession_Approval

session_id (FK)
approval_id (FK)

Now, a single Approval can be reused across multiple sessions.

In the UI, we added a feature for users to search and select existing approvals, reducing redundancy and simplifying workflows.

Why It Matters
Reusable data = fewer records, less clutter

Easier to maintain & more accurate

Reflects actual business logic

These kinds of small design shifts from tightly coupled to normalized lead to systems that scale better, adapt to real-world use cases, and are easier to evolve.

Solving One-to-Many Update Issues in Status Tracking Systems

Galisetty Priyatham — Sat, 14 Jun 2025 21:11:37 +0000

In a recent project, we ran into an interesting design limitation involving a status tracking system where multiple entities were tied to a single parent event. Each entity could become active or inactive at different times, but the system was recording status changes at the parent level, not individually.

This led to a common but critical problem: updating the status for one entity ended up updating it for all related entities, even if some were still active. While this might be fine in tightly coupled scenarios, it didn’t reflect the real-world behavior of our system.

The Problem
The core issue was that the data model assumed uniformity — that all associated items shared the same start and end times. But in reality, each item had its own lifecycle. Treating them the same led to inaccurate records and operational inefficiencies.

The Solution
To fix this, we moved the status tracking from the parent event level to the relation level — the table that mapped events to individual items. This allowed us to record and update status per item, giving users the ability to manage them individually through the UI.

A simple shift in data design made the system far more flexible and accurate.