@ankurm

Ankur in Java

Java’s ExecutorService.invokeAny(): Winning the Race for the First Result

In the world of concurrent programming, we often face scenarios where we need to perform the same task in multiple ways, but we only care about the first successful result. Imagine querying three different microservices for the same piece of data. You don’t care which service responds, as long as you get the data as quickly as possible. Once you have it, the other requests become redundant. How do you efficiently manage this “race”? You could manually spin up threads, use a CountDownLatch or a Phaser, and manage a shared result variable with locks. But that’s complicated and error-prone. Fortunately, Java’s ExecutorService provides a clean, powerful, and built-in solution: the invokeAny() method. Let’s dive into how invokeAny() works and how you can use it to write cleaner, more efficient concurrent code. What is ExecutorService.invokeAny()? The invokeAny() method is a blocking operation that submits a collection of Callable tasks to an ExecutorService. It doesn’t wait for all of them to finish. Instead, it waits for the first task to complete successfully (i.e., without throwing an exception) and returns its result. As soon as one task finishes, invokeAny() returns its result and immediately attempts to cancel all other running or pending tasks. This “fire-and-forget-the-rest” behavior makes it the perfect tool for tasks involving redundancy and speed.

Ankur in Java

Don’t Specify Version Numbers in Spring XML Schema References

If you’ve been working with Spring Framework for a while, especially with its XML-based configuration, you’ve likely encountered a pattern in the <beans> element where schema locations are defined. It often looks something like this: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">  </beans> Notice the -3.0.xsd at the end of the schema locations? This explicitly ties your configuration to a specific version of the Spring schema. While this might seem harmless or even like a good idea for precision, it can actually lead to unnecessary headaches and maintenance overhead. Why You Shouldn’t Include Version Numbers The Spring Framework is designed with backward compatibility in mind. When a new version of Spring is released (e.g., Spring 3.0, 4.0, 5.0, etc.), the XML schemas are generally updated to include new features or deprecate old ones, but they usually remain compatible with configurations written for previous versions, especially if you’re not using any of the very latest, specific features.

Ankur in Java

Configuring ResourceBundleViewResolver in Spring MVC

In a Spring MVC application, a ViewResolver is responsible for mapping logical view names that your controllers return to actual .jsp files (or Thymeleaf templates, etc.). When you need to support multiple locales and provide messages or titles that vary per language, a ResourceBundleViewResolver is a convenient choice. This post walks through a minimal, but complete, configuration that you can drop into any Spring MVC project. Problem Statement Suppose you want a home.jsp that displays a greeting, a welcome message, and a page title, all of which should change depending on the user’s locale. You also want to keep the JSPs simple, so you delegate the translation of these messages to a standard Java ResourceBundle (properties file). Solution Overview Define the view resolver so it first looks for a messages_*.properties file. Configure the ViewResolver hierarchy to fall back to the default view resolver if a match isn’t found. Create a simple controller that forwards to a logical view name. Write the JSP that pulls values from the resource bundle.

Ankur in Java

Troubleshoot: java.lang.ClassNotFoundException: com.sun.jersey.spi.container.servlet.ServletContainer

Encountering a ClassNotFoundException is a common rite of passage for any Java developer. Specifically, the error java.lang.ClassNotFoundException: com.sun.jersey.spi.container.servlet.ServletContainer can be a head-scratcher when you’re working with web services, particularly when migrating or setting up a new project. This exception typically indicates that your application server (like Tomcat, JBoss, or Jetty) can’t find the necessary Jersey Servlet container class. Let’s break down why this happens and how to fix it. Understanding the Problem The class com.sun.jersey.spi.container.servlet.ServletContainer is a core component of the older **Jersey 1.x** framework. It’s responsible for bootstrapping and handling requests for your RESTful services. If your application attempts to load this class and it’s not present in the classpath, you’ll get the ClassNotFoundException. The most common reasons for this are: Missing Dependency: The required Jersey servlet JAR file is not included in your project’s build path or deployed WAR file. Incorrect Version: You’re using a mix of Jersey 1.x and Jersey 2.x (or later) dependencies, or your configuration points to a Jersey 1.x class while you’re using Jersey 2.x. Build Tool Misconfiguration: Your build tool (Maven, Gradle) isn’t correctly packaging the dependency. Deployment Issue: The JAR file isn’t correctly placed in the application server’s classpath (e.g., in WEB-INF/lib for web applications).

Ankur in Spring Cloud

A Practical Guide to Monitoring Spring Boot Microservices with Prometheus & Grafana

Microservices are powerful. They allow us to build scalable, resilient, and independently deployable systems. But this power comes with a cost: complexity. When you have dozens or even hundreds of services interacting, figuring out what’s going on—especially when something goes wrong—can feel like searching for a needle in a haystack of haystacks. This is where observability comes in. It’s more than just “monitoring”; it’s about gaining deep, actionable insights into your system’s behavior. We can break observability down into three pillars: Logs: Structured, event-based records of what happened. “User X failed to log in at 10:05 PM.” Metrics: Aggregated, numerical data over time. “The average API response time over the last 5 minutes was 200ms.” Traces: The end-to-end journey of a request as it travels through multiple services. “Request ABC started at the API gateway, went to the user-service, then the auth-service, and took 350ms in total.” In this guide, we’ll focus on the cornerstone of observability: metrics. We’ll build a complete, production-grade monitoring stack for a Spring Boot microservice using an industry-standard toolkit. The Monitoring Dream Team We’ll use a combination of powerful tools that work seamlessly together: Spring Boot Actuator: Provides production-ready features for our app, including a wealth of internal metrics out-of-the-box. Micrometer: An application metrics facade that acts as a universal translator. Spring Boot uses it to format its metrics so that various monitoring systems can understand them. We’ll configure it to talk “Prometheus”. Prometheus: The powerhouse of our stack. It’s a time-series database that periodically “scrapes” (pulls) metrics from our application and stores them efficiently. Grafana: The visualization layer. Grafana connects to Prometheus, queries the stored metrics, and turns them into beautiful, insightful dashboards. Here’s the data flow we’re building: Spring Boot App → Actuator → Micrometer → a /prometheus endpoint → Prometheus Scraper → Grafana Dashboard Let’s get building!

Ankur in Java

A Developer’s Deep Dive into Java Memory Management and Garbage Collection

As Java developers, we are blessed with one of the most sophisticated features a programming platform can offer: automatic memory management. We don’t have to manually allocate and deallocate memory like our C++ brethren, which saves us from a whole class of painful bugs. This “magic” is handled by the Java Virtual Machine (JVM) and its Garbage Collector (GC). But here’s the thing: relying on magic without understanding it can lead to trouble. The dreaded OutOfMemoryError, mysterious performance slowdowns, and long application pauses can all be symptoms of memory management woes. To truly master Java, you need to peek behind the curtain. In this post, we’ll demystify how the JVM manages memory and how the Garbage Collector works its magic to keep our applications running smoothly. The JVM’s Memory Blueprint: Where Everything Lives When you start a Java application, the JVM carves out a chunk of memory from the operating system. This memory isn’t just one big, messy pile; it’s a highly organized space, divided into several key areas. While there are a few, we’ll focus on the two most relevant to our day-to-day coding: the Stack and the Heap. Simplified Memory Model https://jenkov.com/tutorials/java-concurrency/java-memory-model.html A simplified view of where our data goes.

Ankur in JS

Understanding Variable Hoisting in JavaScript

Let's dive into a fundamental concept in JavaScript that often trips up beginners (and even seasoned developers occasionally): variable hoisting. Understanding how hoisting works is crucial for writing predictable and bug-free JavaScript code. Let's break it down. What is Hoisting? In simple terms, "hoisting" is JavaScript's default behavior of moving declarations to the top of their current scope (either the global scope or the function scope) during the compilation phase, before the code is actually executed. It's important to note that only the declaration is hoisted, not the initialization. Think of it like this: before your JavaScript engine runs a single line of code, it scans through your script and pulls all variable and function declarations to the top. This means you can use a variable or call a function before it's "physically" declared in your code.

Ankur in Java

Exploring Java’s LinkedHashSet: Order-Preserving Uniqueness

In the vast and varied world of Java Collections, understanding the nuances of each data structure is crucial for writing efficient and robust code. Today, we're diving into a fascinating member of the Set family: the LinkedHashSet. While the standard HashSet offers blazing-fast O(1) average time complexity for most operations, it doesn't guarantee any order. Enter LinkedHashSet, which beautifully combines the best of both worlds: the uniqueness of a Set with the predictable, insertion-order iteration of a List. Think of it this way: a regular HashSet is like throwing items into a bag – you know they're all there, but when you pull them out, there's no telling which one will come first. A LinkedHashSet, on the other hand, is like placing items onto a conveyor belt – they maintain their original order as they were added, even though duplicates are still strictly rejected. What is LinkedHashSet? The LinkedHashSet class is a member of the Java Collections Framework, specifically implementing the Set interface and extending the HashSet class. It stores unique elements, just like a regular HashSet, but it also maintains a doubly-linked list running through its elements. This linked list defines the iteration order, which is the order in which elements were inserted into the set (insertion-order). Here are its key characteristics: Uniqueness: It does not allow duplicate elements. If you try to add an element that already exists, the operation will effectively do nothing, and the existing element's position will remain unchanged. Insertion Order: It maintains the order in which elements were inserted into the set. When you iterate over a LinkedHashSet, elements will be returned in the same sequence they were added. Null Elements: It can store one null element. Non-Synchronized: Like HashSet, LinkedHashSet is not synchronized. If multiple threads access a LinkedHashSet concurrently and at least one of the threads modifies the set, it must be synchronized externally. This is typically done by wrapping it with Collections.synchronizedSet(). Performance: It provides O(1) average-time performance for basic operations like add(), contains(), and remove(), assuming a good hash function. Due to the overhead of maintaining the linked list, it's generally slightly slower than HashSet but faster than TreeSet.

Ankur in Java

A Beginner’s Guide to Java HashSet

Let's dive into a fundamental and incredibly useful part of the Java Collections Framework: the HashSet. If you've ever needed to store a collection of unique items where order doesn't matter, then HashSet is your go-to data structure. Let's explore what it is, how it works, and when to use it. What is a Java HashSet? At its core, a HashSet in Java is an implementation of the Set interface, based on a hash table. This means it inherits the key property of all sets: it cannot contain duplicate elements. When you try to add an element that already exists in the set, the add operation will simply be ignored (it won't throw an error, but the set's state won't change). Think of it like a collection of unique, unordered items. If you put two identical postcards into a box that only allows one copy of each postcard, you'll still only have one postcard in the box. Key Characteristics of HashSet: No Duplicates: As mentioned, HashSet strictly enforces uniqueness. Unordered: There is no guarantee about the iteration order of elements in a HashSet. The order might even change over time due to operations like adding or removing elements. Null Elements: A HashSet can contain one (and only one) null element. Performance: It offers constant time performance (O(1)) for basic operations like add(), remove(), and contains(), assuming the hash function distributes elements properly. In the worst-case scenario (many hash collisions), performance can degrade to O(n). Non-Synchronized: HashSet is not thread-safe. If multiple threads access a hash set concurrently and at least one of the threads modifies the set, it must be synchronized externally.

Ankur in Java

Mastering TreeSet in Java: A Guide for Developers

Today, we're diving into an essential part of the Java Collections Framework: the TreeSet class. If you've been working with Java for a while, you've likely encountered HashSet for its blazing fast operations or LinkedHashSet for its predictable iteration order. But what if you need a set that not only stores unique elements but also keeps them in a sorted order? Enter TreeSet – your go-to for naturally ordered or custom-ordered sets. Let's explore its functionalities, advantages, and how to effectively use it in your Java applications. What is a Java TreeSet? In Java, a TreeSet is a concrete implementation of the Set interface, which in turn extends the SortedSet and NavigableSet interfaces. This means it provides all the capabilities of a standard Set (no duplicate elements) along with the power of ordering and navigation. Under the hood, TreeSet is backed by a TreeMap. This is a crucial detail, as TreeMap stores its elements in a Red-Black tree structure. This self-balancing binary search tree ensures that operations like adding, removing, and searching elements have a time complexity of O(log n) – making it very efficient for large datasets. Key Characteristics of TreeSet: Stores Unique Elements: Like all Set implementations, TreeSet does not allow duplicate elements. If you try to add an element that already exists, the operation will be ignored, and the set will remain unchanged. Maintains Sorted Order: This is its defining feature. Elements are stored in ascending order by default, either based on their natural ordering or a custom comparator you provide. No Null Elements: TreeSet does not permit null elements. Attempting to add a null will result in a NullPointerException. This is because null cannot be compared with other elements. Non-Synchronized: TreeSet is not thread-safe. If multiple threads access a TreeSet concurrently and at least one thread modifies it, external synchronization must be performed. You can use Collections.synchronizedSortedSet() for this purpose. Performance: Operations like add(), remove(), and contains() have an average time complexity of O(log n).