Mahendra Rao B on foojay.io - Friends of OpenJDK

Getting Started with Exposed: Kotlin ORM Made Simple

Mon, 06 Jul 2026 03:39:00 +0000

Introduction

For quite some time, I have been a huge fan of and fascinated by JetBrains products, tools, and libraries because of their masterful craftsmanship in product creation and their pristine focus on building high-quality developer tools.

Even more excitingly, JetBrains Java Annotated Monthly newsletters have featured most of the technical articles I wrote for Foojay on topics such as Java, Spring, Spring Boot 4, and OpenRewrite.

Recently, one Kotlin Domain-Specific Language (DSL) library caught my attention. I immediately tried converting my existing Spring Boot 4 application from Java to Kotlin using Exposed, an ORM framework for Kotlin. Kotlin SQL Libary

Explore Spring AI SDK – Amazon Bedrock AgentCore – Part 3

Sun, 10 May 2026 09:09:00 +0000

In Part 1 and Part 2 , we explored the Spring AI SDK and Amazon Bedrock AgentCore features, including the agentcore runtime starter and integration of agentcore memory. In this article, we will explore the integration of AgentCore built-in tools, including the Browser and Code Interpreter features.

Repository containing the companion code for the tutorial. Go to GitHub {#https://github.com/bsmahi/simple-spring-boot-agent}. Built-In Tool Browser

The use case I am trying to build here is for the given URL; it navigates the entire website and retrieves the content and gives key points and the summary of the page using the AgentCore Browser tool.

Explore Spring AI SDK – Amazon Bedrock AgentCore – Part 2

Mon, 27 Apr 2026 09:09:00 +0000

If you’re joining us from Part 1 or need a quick refresher on the architecture, listen to this brief overview of how Spring AI and Amazon Bedrock work together. Generated using Notebook LLM for my previous article {#https://foojay.io/today/spring-ai-amazon-bedrock-sdk-guide/}

In this article, we explore one of the AgentCore capabilities i.e., memory Source: Amazon

To begin, enable AgentCore memory for the agent you built earlier.

Step 1: Add the Ai model and AgentCore memory dependencies

<dependency>
 <groupId>org.springframework.ai</groupId>
 <artifactId>spring-ai-model</artifactId>
</dependency>
<dependency>
 <groupId>org.springaicommunity</groupId>
 <artifactId>spring-ai-agentcore-memory</artifactId>
</dependency>

Step 2: Create Short/Long Term in AWS Management Console

Navigate to Amazon Bedrock AgentCore > Memory to create short/long-term memories. AgentCore Memory

Explore Spring AI SDK - Amazon Bedrock AgentCore - Part 1

Mon, 20 Apr 2026 13:44:54 +0000

Introduction

Artificial intelligence has rapidly expanded across every industry since the inception of ChatGPT. It represents a breakthrough in how we build and use software. Moreover, this breakthrough technology has driven major transformation. At the same time, it has created significant noise and hype.

Today, AI is no longer experimental. Instead, it has become essential, much like electricity and the internet. As a result, it now plays a key role in our daily lives. Overall, this shift reflects strong technological acceleration across industries.

Spring Boot 4 - OpenTelemetry Guide

Wed, 10 Dec 2025 09:09:58 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. In this second article, I will dive deep into integration of Observability framework i.e., OpenTelemetry with SpringBoot.

As an architect and developer, when I engage in system design—whether it involves monolithic architecture, microservices, or contemporary cloud-native applications—I have made the integration of observability patterns utilizing open-telemetry tools a standard practice. Through observability, we can monitor application behavior via metrics, logs, and traces that we trigger

Spring Framework 7 API Versioning Explained

Wed, 29 Oct 2025 06:45:53 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. To begin, I will deep dive into the API versioning feature introduced in Spring Framework 7.

Any architectural or feature change stems from evolving business requirements, and API versioning is no exception. In today’s app-driven ecosystem, APIs are central to product integration and user experience.

Preparing for Spring Boot 4 and Spring Framework 7: What’s New?

Mon, 11 Aug 2025 14:42:40 +0000

I’m a passionate Spring Framework and Spring Boot enthusiast, and I always look forward to exploring and experimenting with the latest features and improvements they introduce. With Spring Boot 4 and Spring Boot Framework 7 right around the corner, now’s the perfect time to dive into the key enhancements that will shape the future of modern Java and enterprise application development.

In this blog post, we will discuss some key features enhanced as part of Spring Framework 7 and Spring Boot 4.

Spring Cloud Stream for Real-Time Event-Driven Systems

Mon, 21 Jul 2025 13:33:34 +0000

Envision operating a successful e-commerce platform where every moment is crucial. Customers make purchases, adjust inventory levels, process payments, and dispatch shipping alerts—all in real time. In the background, microservices diligently function to guarantee seamless operations. However, how do these services interact effectively, particularly during peak traffic occurrences such as flash sales or holiday shopping events?

An efficient method to execute this use case involves utilizing Spring Cloud Stream (SCS) as the messaging infrastructure. SCS facilitates seamless interaction among microservices, enhancing the system’s responsiveness and scalability. A significant benefit of SCS is that it provides an abstraction layer, allowing developers to transition between messaging technologies such as Kafka or RabbitMQ or Pulsar or Amazon Kinesis without altering their fundamental business logic.

Spring Cloud Stream: Demystifying Event-Driven Architecture

Fri, 28 Feb 2025 08:34:32 +0000

Consider a bustling restaurant environment. The kitchen receives a flood of orders, waitstaff dart between tables, and patrons anxiously glance at their watches. Each time a waiter takes an order, he or she must verify it with the kitchen and wait for the kitchen to prepare the meal before attending to another table. This cumbersome method hampers efficiency, leaving the restaurant unable to meet customer demand.

Now envision an alternative situation. Instead of enduring delays, waitstaff enter orders into a centralized system, prompting the kitchen to begin meal preparation immediately upon receipt. As soon as the kitchen prepares the food, waiters receive instant notifications, enabling them to serve customers promptly without any delays. This exemplifies event-driven architecture: a fluid, real-time system where they exchange information asynchronously, promoting scalability and quick responsiveness.

Project Loom: Structured Concurrency - Java

Wed, 29 Jan 2025 12:12:38 +0000

In today’s era of cloud computing, where high-performance infrastructure is readily available, developers face a complex challenge in achieving efficient concurrency.

While modern technological advancements have brought us closer to solving these challenges, we must adopt a thoughtful, incremental approach to concurrency.

This principle holds especially true as we strive to design scalable, reliable, and easy-to-maintain systems.

One such advancement in this domain is structured concurrency, a paradigm that simplifies concurrent programming by bringing order and predictability to task management.

Spring Boot: Java Template Engine (JTE)

Wed, 13 Nov 2024 09:03:00 +0000

Hello to all Java and Spring enthusiasts. I am the Java Template Engine, a fresh newcomer to the Spring Initializer Ecosystem.

I have gained popularity as a template engine for developing user interface applications that use Java syntax within Spring Boot applications, alongside other engines such as Freemarker, Thymeleaf, Mustache, and Velocity. Many developers widely use Spring Boot, a framework that simplifies Java application development, and incorporating a template engine like mine streamlines the process of creating dynamic and responsive user interfaces.

Book Review: Mastering the Java Virtual Machine

Fri, 18 Oct 2024 13:54:49 +0000

Otávio Santana’s “Mastering the Java Virtual Machine” takes readers on an insightful journey through the inner workings of the JVM. As I read this book, I found myself reconnecting with the fundamentals of Java programming while also discovering new depths of understanding.

The book strikes a perfect balance between nostalgia and innovation. It reminded me of my early programming days, while also introducing cutting-edge concepts that are crucial for modern Java development. Santana uses clever technical metaphors to make complex JVM internals more accessible, bridging the gap between theory and practical application.

Spring: Internals of @ComponentScan

Tue, 20 Aug 2024 14:48:28 +0000

The @ComponentScan annotation, which is an interface located within the org.springframework.context.annotation package, facilitates component scanning in a Spring application. This allows the Spring Container to automatically detect beans.

Spring automatically identifies Java classes that developers mark with stereotypes like @Configuration, @Component, @Service, @Controller, and @Repository. Developers can annotate the component scan with or without parameters.

You can designate either basePackageClasses() or basePackages() (or its equivalent value()) to identify the specific packages that need to be scanned.

Java: Demystifying The Stream API

Fri, 05 Jul 2024 06:57:34 +0000

In our earlier articles part1 and part2 , we have previously explored the significance of functional programming, Lambda Calculus, as well as various features such as Functional Interfaces, Lambda Expressions, and Method References.

This article delves into a crucial aspect, namely the Stream API, which JDK1.8 incorporated. It also covers how to utilize Lambda Expressions, Method References, and Functional Interfaces within Stream API functions.

So,

Succinctly, In Java, a Stream is a collection of data that developers can process on in a declarative and functional approach.

Java: Functional Programming f(x) – Part2

Mon, 03 Jun 2024 17:05:56 +0000

In the preceding article , we explored the significance of Functional Programming, Lambda Calculus, and other related concepts.

In this article, we delve deeper into the essential aspects of Functional Programming, such as…

1. Lambda Expressions 2. Method References 3. Functional Interfaces

And we will discuss about the relationship between each of the features.

JSR 335 has greatly facilitated programming in a multicore environment by introducing Lambda Expressions/closures/anonymous method, and related features.

Functional Programming: Revolutionizing Software Development

Thu, 25 Apr 2024 17:43:17 +0000

Mathematics serves as the driving force behind significant advancements in computer science from my perspective. We deeply root the fundamental principles that we utilize in our daily programming tasks and application development in mathematical concepts. I am constantly intrigued by the opportunity to incorporate mathematical ideas into the programming languages I work with as a student of Mathematics.

Many other programming paradigms, like functional programming, take inspiration from Mathematics to address challenges related to concurrency and parallelism. Computing shifts towards utilizing multiple cores and distributed systems, which makes this increasingly important.

Spring Framework – Internals of RestClient

Mon, 25 Mar 2024 11:32:54 +0000

As a developer and architect, my constant pursuit is to achieve simplicity and elegance when constructing resilient and intricate enterprise applications. With my affinity for the Spring Framework, I have witnessed firsthand the simplicity and modernization it brings to the Spring Ecosystem.

This framework enables the creation of complex enterprise applications in a more streamlined and refined manner, boasting a sophisticated diffusion and transformer architecture.

Spring RestClient

Spring Boot 3.2 launched and introduced a range of captivating functionalities. Notably, the release includes the RestClient feature, which offers a contemporary approach to developing REST endpoints.

Migrate to Spring Boot 3.2 with OpenRewrite

Tue, 06 Feb 2024 08:17:07 +0000

As a developer, we frequently face the challenges of migrating to newer versions of frameworks and refactoring code. However, we can effortlessly achieve these tasks with the assistance of OpenRewrite . OpenRewrite provides a stack of recipes specifically designed for migration purposes. By utilizing the appropriate recipes and integrating with the rewrite plugin, we can effectively migrate our code.

Two months ago, the Spring Boot 3.2 version released, bringing numerous changes to the framework. If you are involved in multiple projects and require migrating to the latest version, developers may find manually updating all the code repositories with the necessary upgrade changes a challenging task.

Book Review : The Software Engineer's Guidebook

Fri, 15 Dec 2023 14:12:12 +0000

Gergely Orosz’s book, “The Software Engineer’s Guidebook,” takes readers on an enthralling exploration of the realm of software development, working in various companies, and startups.

A software engineer in a startup or Big Tech company traces the journey in this book, starting from a beginner developer to a principal engineer.

This book serves as a comprehensive guide, especially beneficial for new engineers and individuals with limited work experience in a few companies.

Patterns For The Design Of Microservices – Part 3

Thu, 16 Nov 2023 04:35:02 +0000

In part1 , part2 , we discussed several design patterns that aid in the development of microservices.

This blog post will cover the subsequent design patterns.

Observability Patterns
Cross-cutting Concern Patterns

Microservice Architecture Patterns

Undoubtedly, the logging mechanism benefits troubleshooting issues that arise when executing operations or transactions on multiple deployed microservices.

We can further categorize the observability patterns into six distinct patterns.

Log Aggregation
Application Metrics
Audit Logging
Distrubuted Tracing
Exception Tracking
Health Check API

In the subsequent segment, we will discuss each topic separately.

Patterns For The Design Of Microservices – Part 2

Mon, 30 Oct 2023 08:58:06 +0000

In the previous article , we discussed some of the design patterns employed in the creation of microservices. In this subsequent article, we will delve into the remaining patterns that are commonly utilized in the realm of microservices.

Database Patterns

There are seven distinct patterns that further categorize the data management.

Database per Service
Shared Database
Saga Pattern
Command-Query Responsiblity Segregation (CQRS)
API Composition
Domain Event
Event Sourcing

In the next section, let’s discuss each pattern individually.

Patterns For The Design of Microservices

Wed, 11 Oct 2023 06:11:03 +0000

Design patterns plays a pivotal role in designing and solving the commonly occurring problems in software application. It is guiding principle or template to the solve any designing problems.

It applies to the Microservices architectural style as well. These patterns provide a structured approach to designing and implementing Microservice architectures, ensuring scalability , maintainability , and reusability. By adhering to these design patterns, developers can proficiently tackle the common challenges encountered during Microservices development.

Book Review: Get Your Hands Dirty on Clean Architecture

Sat, 23 Sep 2023 12:00:31 +0000

I recently completed reading “Get Your Hands Dirty on Clean Architecture” authored by Tom Hombergs and I deem it an indispensable resource for developers aspiring to produce clean code and implement the Hexagonal Architecture. Consequently, I have resolved to compose a review to aid numerous individuals who harbor a fervent interest in technology!

Title: Get Your Hands Dirty on Clean Architecture
Author: Tom Hombergs
Genre: Technical, Software Architecture

In the constantly changing realm of software development, architectural principles hold a crucial position in determining the triumph and sustainability of a project. The book authored by Tom Hombergs, titled “Get Your Hands Dirty on Clean Architecture: A hands-on guide to creating clean web applications with code examples in Java,” is an exceptional guide that illuminates the importance of clean architecture, while also offering practical perspectives on its implementation through the Java programming language.

OpenRewrite: Automatic Code Refactoring and More - Part 2

Thu, 14 Sep 2023 06:56:36 +0000

In the previous article , we outlined the significance of the OpenRewrite Library and its integration at an elevated level.

This article explains how to improve, refactor, and move a Spring Boot application with OpenRewrite.

Source: OpenReWrite{#caption-attachment-102151}

Before proceeding, we shall understand the various goals in the Maven or Gradle plugin configuration.

The OpenRewrite Maven offers the following goals:

mvn rewrite:cyclonedx - This will generate a Cyclonedx bill of materials describing the application/project dependencies, including transitive dependencies .
mvn rewrite:discover - Generate a report detailing the recipes that are currently available within the classpath.
mvn rewrite:dryRun - This precautionary command will generate a set of differences solely for the modifications made within the /target/rewrite directory, which will be saved in the rewrite.patch.
mvn rewrite:dryRunNoFork - This precautionary command will generate a set of differences solely for the modifications made within the /target/rewrite directory, which will be saved in the rewrite.patch.
mvn rewrite:run- This command runs the configured recipes and applies the changes locally.
mvn rewrite:runNoFork -This command runs the configured recipes and applies the changes locally.
For runForFork: This different way of doing things doesn’t split up the Maven process and could work better when using Rewrite with other Maven tasks in a continuous integration (CI) system.

The OpenRewrite Gradle offers the following goals:

OpenRewrite: Automatic Code Refactoring and Maintenance

Tue, 05 Sep 2023 17:05:06 +0000

As software engineers and architects, we often face the challenge of upgrading dependencies, security patches, and framework upgrades to the latest versions. Enterprise organizations often have legacy code developed and maintained for a long time.

Updating dependency versions in the build file in many build files in the software projects, and implementing large framework upgrades can be a daunting task for developers, who must manually inspect and modify class files, properties, and the build files such as pom.xml or build.gradle or any other build files.