Spring on foojay.io - Friends of OpenJDK

How to Create a Spring Boot Fraud Scoring Service

Fri, 31 Jul 2026 08:45:43 +0000

Most Java teams who want a machine learning model in production end up standing up a Python service and calling it over HTTP. That works, but it buys you, as a Java developer, a second runtime, a second deployment pipeline, a network hop on every prediction, and a team boundary that turns retraining into someone else’s ticket.

Deep Netts removes that split: it’s a pure-Java deep learning library, so the model trains in Java, serializes to a file, and loads back into your Spring Boot application as an ordinary bean. Predictions become in-process method calls measured in microseconds, with nothing extra to deploy, secure, or monitor.

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

You’re invited to IntelliJ IDEA Conf 2026!

Mon, 29 Jun 2026 18:35:08 +0000

We are excited to invite you to IntelliJ IDEA Conf 2026, a free virtual event on September 8-9, 2026.

IntelliJ IDEA Conf is a celebration of the developer community, bringing together professionals who strive for excellence in software development. Join us for this free, live online conference and learn from industry leaders and experts on September 8-9, 2026.

You’ll be able to learn about a broad range of topics relevant to modern Java and Kotlin development, including language evolution, enterprise Java, Spring-based applications, build tooling, containerized workflows, JVM performance, and data access technologies. For more details, see the agenda below.

Jurassic JDK: Migrate or Extinct

Fri, 26 Jun 2026 07:28:00 +0000

65 million years ago, dinosaurs didn’t adapt. They’re gone. Your JDK 7 app is giving the same energy. 🫠

I spent a year and a half migrating more than 15 projects in production. Full time. Real teams, real deadlines, real 2am breakage. This is everything I wish someone had written before I started.

Why Are We Still Here? 👀

Walk into any company with a codebase older than 5 years and you’ll hear the same thing:

Foojay Podcast #99: Testing the Untestable: LLM Security for Java Developers with Tiberius

Mon, 22 Jun 2026 06:54:00 +0000

Your AI-powered Java application is live in production. But have you actually tested whether it can be jailbroken or manipulated into leaking data it should never reveal? In this episode, Iryna Dohndorf walks us through Tiberius, an open-source security testing library for LLM applications in Java, and explains why everything you know about unit testing needs a rethink when non-determinism is part of the design.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Ask a Lille Dev

Tue, 16 Jun 2026 00:35:19 +0000

During the DevLille 2026 conference in Lille, I interviewed several Java developers and tech professionals with one simple goal: collecting authentic and spontaneous insights from the Java ecosystem. ☕🎤

The result became “Ask a Lille Dev”, a mini podcast made of short interviews recorded directly during the conference. Instead of long talks or polished marketing speeches, the idea was simple: ask practical questions to people working in tech every day.

AI-Powered Code Review Assistant: Automated Code Analysis with Spring AI and MongoDB

Thu, 14 May 2026 17:09:39 +0000

Code reviews catch bugs before they ship, but they take time. Most teams rely on manual review or basic linters that flag syntax issues but miss deeper problems like subtle resource leaks, poor exception handling, or security anti-patterns. Static analysis tools help, but they work with rigid rules that cannot generalize across code variations. A rule that catches catch (Exception e) {} will miss catch (Throwable t) { return null; }, even though both are the same underlying problem.

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.

Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas — Part 1: RAG Foundation

Thu, 07 May 2026 19:22:11 +0000

This is the first article in a three-part series. Part 2 covers short-term and long-term memory; Part 3 introduces stateful workflow checkpointing with pause/resume.

The problem

It’s 2 a.m. Suddenly, an alert pops up indicating abnormal CPU usage on the payment services. The on-call engineer opens their laptop, logs into the monitoring dashboards, and begins the hunt. One by one, he searches the runbooks on Confluence, checks the Slack chats, and opens the GitHub wikis and documents shared during the design phase. By the time he finds any useful information, ten minutes have already passed.

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 3.5 EOL — The CVE Blind Spot Nobody Talks About

Sun, 19 Apr 2026 13:37:13 +0000

Tomorrow I start (o so early) for JCON Europe in Cologne and then, at the tail end of the week, go to Devoxx France to give more talks. If you’re at either, come say hi. Herodevs has a booth at both.

After digging into the CVE stories behind Tomcat 8.5’s end of life , I turned my attention to Spring Boot 3.5. Same question, different framework: what actually happens to your security posture when a project crosses the EOL line?

Spring I/O 2026: Field Notes from Barcelona

Fri, 17 Apr 2026 13:09:24 +0000

Spring I/O 2026 wrapped in Barcelona on Wednesday. Three days at the Palau de Congressos. A thousand-plus developers, five tracks, sixty sessions (or there abouts) Here are the things I’m still thinking about..

Agents everywhere

It was a Spring AI conference with a Spring Boot conference attached.

That’s not a complaint. Count the programme yourself. Across the two main days, roughly a third of the main-track sessions were about Spring AI, MCP, agents, or building on LLMs. Josh Long opened Day 2 at eleven with Bootiful Spring Boot 4 . By twelve, the Auditorium had moved on to The Spring AI Ecosystem in 2026: From Foundations to Agents.

Building a Kotlin App with Spring Boot and MongoDB Search

Thu, 09 Apr 2026 15:21:05 +0000

One of my favorite activities is traveling and exploring the world. You know that feeling of discovering a new place and thinking, “How have I not been here before?” It’s with that sensation that I’m always motivated to seek out new places to discover. Often, when searching for a place to stay, we’re not entirely sure what we’re looking for or what experiences we’d like to have. For example, we might want to rent a room in a city with a view of a castle. Finding something like that can seem difficult, right? However, there is a way to search for information accurately using MongoDB Search.

Manage HTTP Sessions with Spring Session MongoDB

Tue, 07 Apr 2026 15:19:10 +0000

Spring Session MongoDB is a library that enables Spring applications to store and manage HTTP session data in MongoDB rather than relying on container-specific session storage. In traditional deployments, session state is often tied to a single application instance, which makes scaling across multiple servers difficult. By integrating Spring Session with MongoDB, session data can be persisted beyond application restarts and shared across instances in a cluster, enabling scalable distributed applications with minimal configuration.

Grails Is Back: Inside the Apache Software Foundation Migration

Wed, 01 Apr 2026 08:48:56 +0000

In the companion article to this one, I looked at the revitalisation of Grails under the Apache Software Foundation: the 18-month migration, the technical modernisation, and the release of Grails 7 as a Top-Level ASF Project. That is the good-news story, and it is a genuinely impressive piece of community engineering.

This article is about the other side of the same coin.

While Grails moves forward, many of the applications built on it cannot move at the same pace. The result is a growing gap between where the framework is heading and where a significant number of production systems actually sit. Understanding that gap, and what options exist for managing it, is what this piece is about.

Spring Boot Actuator Health for MicroProfile Developers

Thu, 26 Mar 2026 09:30:00 +0000

If you worked with MicroProfile Health, you already understand the value of exposing application health information through standardized endpoints. You know about liveness, readiness and startup probes. You implemented the HealthCheck interface and annotated your procedures with @Liveness, @Readiness and @Startup. Spring Boot Actuator follows a similar philosophy but takes a different architectural approach. This post will help you map your MicroProfile Health knowledge to Spring’s world.

The Conceptual BridgeThe Conceptual Bridge

At its core, Spring Boot Actuator serves the same purpose as MicroProfile Health: it provides a mechanism for validating the availability and status of your application in containerized environments. Both specifications recognize that modern cloud platforms like Kubernetes need machine-readable health information to make decisions about pod lifecycle management.

Grails Is Back: Inside the Apache Software Foundation Migration

Wed, 25 Mar 2026 08:30:21 +0000

Steve Poole | With contributions from James Fredley, Apache Grails PMC Chair

For a technology that many people filed under “legacy,” Grails has been unusually active. While much of the industry’s attention has drifted toward newer frameworks and shinier stacks, something more deliberate has been happening in the background.

Grails has been moving into the Apache Software Foundation (ASF), modernising and positioning itself for the next chapter.

If you have not looked at Grails recently, your mental model is likely several years out of date. And that, in many ways, is exactly the problem.

Introducing the BoxLang Spring Boot Starter: Dynamic JVM Templating for Spring

Thu, 19 Mar 2026 14:20:02 +0000

Spring Boot developers know the pain of evaluating view technologies. Thymeleaf is great — until you need more expressiveness. FreeMarker is powerful — until the syntax fights you. What if you could write templates in a dynamic JVM language that gives you the full power of the platform, feels natural, and requires zero setup to integrate?

Meet the BoxLang Spring Boot Starter.

TL;DR: Drop one dependency into your Spring Boot 3 app and start writing dynamic .bxm templates powered by BoxLang — a modern, expressive JVM language. Zero configuration. Full web scopes. 100% Java interoperable. Not only that, you get full access to BoxLang’s framework capabilities so you can integrate tons of features into your Spring Boot applications:

No Keys, No LLM: Building a Wikidata Definition API with Embabel

Thu, 05 Mar 2026 08:00:25 +0000

TL;DR

I built a Spring Boot 4 API that defines terms via Wikidata.
The app is fully reproducible: no API keys and no model installation needed.
Embabel orchestrates the pipeline as a sequence of actions to achieve the goal DefinitionResult.
The logs show planning, execution, and typed object binding—the most useful part for teaching agentic flows.

I wanted a demo that is simple , reproducible , and still shows agentic orchestration in a way that’s easy to explain on video.

Tomcat TLSv1.3 cipher configuration

Thu, 26 Feb 2026 18:02:34 +0000

A recent update to Apache Tomcat introduced a subtle but significant change to how TLS cipher suites are configured. If your Spring Boot application explicitly configures TLS ciphers, particularly TLSv1.3 ciphers, and runs on Tomcat 9.0.115+ (Spring Boot 2.x), 10.1.52+ (Spring Boot 3.x), or 11.0.18+ (Spring Boot 4.x), your cipher configuration may be silently ignored.

Prior to the change, Tomcat used a single ciphers attribute on the SSL connector to configure cipher suites for all TLS versions. Starting with the versions of Tomcat listed above (Tomcat commit ), this attribute was split:

Machine Learning in Java - SPAM detection using ONNX

Tue, 10 Feb 2026 06:51:50 +0000

Believe it or not, it is possible to do Machine Learning in Java. In this article I go over how to implement a Spring Boot API for Spam Detection using an advanced anti-spam model from the Hugging Face onnx-community and Microsoft’s ONNX Runtime for Java .

We will package the API up as a Docker image which we can run a container from using docker or podman, and I guess in theory you could deploy on your Kubernetes cluster, if you (are) fancy.

Testing Emails with Testcontainers and Mailpit

Thu, 29 Jan 2026 08:38:10 +0000

Testing email functionality is often painful. SMTP servers are external, tests become slow or flaky, and local setups differ from CI environments. As a result, many teams either mock the mail sender or skip proper email tests completely.

Both approaches are unsatisfying. Mocking does not test real behavior, and shared SMTP servers introduce hidden dependencies. What we really want is a real SMTP server that runs locally and in CI, is fully isolated per test run, and allows us to inspect sent emails easily.

Introduction to Behavior Driving Development with Java and MongoDB

Tue, 27 Jan 2026 16:35:53 +0000

When we face software development, the biggest mistake is about delivering what the client wants. It sounds like a cliché, but after decades, we are still facing this problem. One good way to solve it is to start the test focusing on what the business needs.

Behavior-driven development (BDD) is a software development methodology where the focus is on behavior and the domain terminology or ubiquitous language. It utilizes a shared, natural language to define and test software behaviors from the user’s perspective. BDD builds upon test-driven development (TDD) by focusing on scenarios that are relevant to the business. These scenarios are written as plain-language specifications that can be automated as tests, simultaneously serving as living documentation.

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

From Spring Boot To Jakarta EE 11

Fri, 28 Nov 2025 08:11:53 +0000

If you’ve been living in the Spring ecosystem, you’re used to fast project setup. Spring Initializr gives you a sleek interface, some starter dependencies and a running project within minutes. Now you’re moving to Jakarta EE, where do you begin?

In this blog, you’ll see how Spring developers can create Jakarta EE applications with the same ease they’re used to from Spring Initializr.

Let’s be honest: Spring Boot abstracts away so much of the setup pain that you forget it’s even there. You don’t worry about the underlying servlet container, dependency versions or deployment descriptors, as Spring Boot handles it all.

Spring Framework 7.0 Jakarta EE 11 Compatibility

Fri, 21 Nov 2025 13:50:47 +0000

The recent releases ofSpring Framework 7.0 and Spring Data 2025.1.0 mark an important milestone for the Java ecosystem, with both now aligned with Jakarta EE 11 . This compatibility represents a continued convergence between the two major Enterprise Java Platforms.

Why This Matters

Compatibility with Jakarta EE 11 ensures that Spring applications can integrate more naturally with modern Jakarta runtimes, including Payara Platform. This leads to improvements such as:

Micrometer & Prometheus in Spring Boot: Kafka Burger Orders

Fri, 14 Nov 2025 10:13:03 +0000

👨‍💻 GitHub: https://github.com/vinny59200/dukeburger

🔵⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪

This guide shows how to use Micrometer and Prometheus in Spring Boot to track a custom metric for a Kafka-driven Burger Orders app. You’ll post a burger order to a REST endpoint, publish it to Kafka, consume the topic, and increment a counter for all “DukeBurger” orders. Copy the snippets, run, and you’ll see your metric on /actuator/prometheus.

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.

Transactions and ThreadLocal in Spring

Tue, 21 Oct 2025 13:27:00 +0000

Two years ago, my friend José Paumard held the talk “Concurrent and Asynchronous Programming : Loom” at the Geneva Java User Group.

In his talk, he mentioned that the Spring team would need to completely redesign their approach to transactions: his reasoning was that the transactions are implemented on top of ThreadLocal object and Loom’s virtual threads break this approach.

I was intrigued because though I used Spring transactions a lot via the @Transactional annotation, I never opened thought about looking at their implementation.

Beyond Keywords: Implementing Semantic Search in Java With Spring Data (Part 1)

Thu, 16 Oct 2025 13:39:59 +0000

Building a semantic movie search app with embeddings and vector queries

Have you ever tried to search for something such as a product, a song, or a movie but couldn’t quite remember its exact name? Maybe you recall only a clue—a desert pyramid, a short melody, or “that ship that hit an iceberg.” Keyword search struggles with that. Vector search doesn’t: It lets you search by meaning.

It works by turning text into embeddings, vectors (arrays of numbers) that capture semantic similarity, so results are ranked by what they mean, not just what they say.

Building REST APIs in Java with Spring Boot

Tue, 09 Sep 2025 14:51:10 +0000

REST has become the default choice for building web services, and for good reason. It’s straightforward to implement, easy for clients to consume, and built directly on top of the same principles of the web itself.

HTTP already gives us well-defined methods (GET, POST, PUT, DELETE), built-in caching, redirect support, secure transport via TLS, and widespread tooling support across platforms. REST doesn’t reinvent the web—it uses it.

REST is not a protocol or a rigid standard. It’s a lightweight architectural approach that encourages scalable, evolvable, and interoperable services. Its creator, Roy Fielding, helped define many of the specs that underpin the web today.

Copy of Queryable Encryption with Spring Data MongoDB: How to Query Encrypted Fields

Tue, 02 Sep 2025 19:00:24 +0000

Information is one of the most valuable assets in computing and keeping it protected is even more critical. When we talk about data protection, it’s not just about preventing breaches or leaks; it’s also about complying with privacy regulations and protecting user data.

MongoDB provides strong encryption capabilities, including in transit, at rest, and in use. The Queryable Encryption feature falls into the in use category. It allows data to be encrypted on the client side, so that even with access to the database and its credentials, no one can read the protected fields without the proper encryption key. At the same time, it supports querying over encrypted fields, making it possible to filter, match, or retrieve data without compromising confidentiality.

OpenTelemetry Tracing on the JVM

Sun, 17 Aug 2025 08:00:39 +0000

You may know I’m a big fan of OpenTelemetry. I recently finished developing a master class for the YOW! conference at the end of the year. During development, I noticed massive differences in configuration and results across programming languages. Even worse, differences exist across frameworks inside the same programming language.

In this post, I want to compare the different zero-code OpenTelemetry approaches on the JVM, covering the most widespread:

Spring Boot with Micrometer Tracing
Spring Boot with the OpenTelemetry Agent
OpenTelemetry Spring Boot Starter
Quarkus
Quarkus with the OpenTelemetry Agent

Commonalities

I keep the architecture pretty simple:

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.

Agent Memory with Spring AI & Redis

Wed, 23 Jul 2025 16:34:04 +0000

You’re building an AI agent with memory using Spring AI and Redis. Unlike traditional chatbots that forget previous interactions, memory-enabled agents can recall past conversations and facts. It works by storing two types of memory in Redis: short-term (conversation history) and long-term (facts and experiences as vectors), allowing agents to provide personalized, context-aware responses.

LLMs respond to each message in isolation, treating every interaction as if it’s the first time they’ve spoken with a user. They lack the ability to remember previous conversations, preferences, or important facts.

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 Boot documentation with Redocusaurus

Wed, 16 Jul 2025 06:45:38 +0000

Create clear and interactive API documentation quickly.

🔵⚪⚪⚪⚪⚪⚪⚪

📘 Introduction: Why Use Redocusaurus for Spring Boot?

Discover why clean API docs matter and how Redocusaurus makes it easy.

Firstly, clear API documentation is very important.

It helps users understand your API better. This is true whether your API is for coworkers or external users.

SpringBoot and Kafka Streams – Event Routing & Testing

Thu, 19 Jun 2025 08:37:11 +0000

Welcome to this hands-on guide to building a Spring Boot Kafka Streams application! (SpringBoot and Kafka Streams).

In this article, I’ll walk you through a project I built during the first day of a three-day Kafka Streams training. The goal? Validate sightseeing events in Lille based on predefined timetables and route the data accordingly.

Let’s explore how Kafka Streams powers a real-time city tour experience! 🧭

🔵⚪⚪⚪⚪⚪⚪⚪⚪⚪

How to send prompts in bulk with Spring AI and Virtual Threads

Wed, 21 May 2025 09:18:45 +0000

TL;DR: You’re building an AI-powered app that needs to send lots of prompts to OpenAI.

Instead of sending them one by one, you want to do it in bulk — efficiently and safely.

This is how you can use Spring AI with Java Virtual Threads to process hundreds of prompts in parallel.

When calling LLM APIs like OpenAI, you’re dealing with a high-latency, network-bound task. Normally, doing that in a loop slows you down and blocks threads. But with Spring AI and Java 21 Virtual Threads, you can fire off hundreds of requests in parallel without killing your app.

How to Deploy a Vaadin Application as a WAR on Tomcat 11

Mon, 19 May 2025 07:40:43 +0000

If you want to run a Vaadin application on an external servlet container like Apache Tomcat 11, you need to package your application as a WAR (Web Application Archive) instead of the usual executable JAR.

In this post, I’ll show you step-by-step how I did it.

Step 1: Download Tomcat 11

First, download Tomcat 11 from the official Apache Tomcat website . After extracting it to a local folder, you have a clean Tomcat installation ready to use.

GenAI blood, sweat, and tears: Loading data to Pinecone

Wed, 07 May 2025 22:10:37 +0000

As someone who is pretty familiar with relational and graph databases, I wanted to dig a little deeper into vector databases and understand the strengths and quirks they bring to the database table. I put together a conference abstract on vector RAG versus GraphRAG which got picked up, so I went to work building a demo and learning all I could.

I pivoted a few times along the way, but ended up with a Spring AI application that connects to both Pinecone (vector database) and Neo4j (graph database). There were a few surprises throughout, which I’ll be sure to mention. Let’s get started!

Building FormPilot

Tue, 06 May 2025 10:00:04 +0000

Disclaimer: This article details an experimental project built for learning and demonstration purposes. The implementation described is not intended as production-grade solution. Some parts of the code were generated using JetBrains’ AI Agent, Junie .

Have you ever found yourself filling out the same information on web forms over and over again? Name, email, address, phone number… it’s tedious and time-consuming. As a developer who values efficiency, I decided to tackle this problem head-on by building FormPilot, an intelligent form filler that leverages the power of Large Language Models (LLMs) to fill out forms with contextually appropriate information automatically.

Local AI with Spring: Building Privacy-First Agents Using Ollama

Tue, 06 May 2025 06:44:07 +0000

Introduction

Building local AI agents with Spring AI and Ollama has emerged as a game-changer for developers seeking to maintain complete control over their AI implementations and have access always at their fingertips, even offline.

This powerful combination allows you to create sophisticated AI agents that run entirely on your own machine, are perfect for experimenting and learning concepts, while, more importantly, eliminating the need to share sensitive data with third-party services. While cloud-based AI services dominate headlines, they come with significant trade-offs: sending your data to third parties, paying per-token fees, and suffering latency penalties.

Improving Maven's dependency:analyze... or not

Mon, 28 Apr 2025 08:28:32 +0000

Recently, my good friend Richard Fichtner advised using the mvn dependency:analyze command to get rid of declared but unused dependencies:

There is another use case for

mvn dependency:analyze

It can show you the dependencies you use in your code but have not declared in your pom.xml. This works because you have a transitive dependency on your classpath. Either don’t use the dependency or declare it.

— Richard Fichtner 💻☕ @richard.fichtner.dev
December 10, 2024 at 2:00 PM

Spring AI Debugging + How to Contribute to Open Source

Wed, 02 Apr 2025 05:56:01 +0000

In this episode, I continue my journey with vector databases, integrating Pinecone , Neo4J , and Spring AI . While making some progress, I also encountered hurdles, such as evolving APIs and the unique architecture of vector stores.

Next, I share insights from an article on contributing to open-source source projects , how it can accelerate your career and enhance both your technical and soft skills. From picking the right project to building credibility within the community, it’s a series of steps that gets better with time and practice!

Breaktime Tech Talks (Ep37): Vector Database Frustration + Microsoft LazyGraphRAG

Wed, 19 Mar 2025 12:54:36 +0000

This is episode 37 of the Breaktime Tech Talks .

You are listening to the Breaktime Tech Talks podcast, a bite-sized tech podcast for busy developers, where we’ll briefly cover technical topics, new snippets, and more in short time blocks. I’m your host, Jennifer Reif, an avid developer and problem solver with special interest in data, learning, and all things technology.

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.

Securing Vaadin Applications with Microsoft Entra

Wed, 26 Feb 2025 12:55:43 +0000

Many companies use Microsoft 365, so letting users log in with their Microsoft account is a good choice. This blog post shows how to secure your Vaadin applications using Microsoft Entra for authentication and authorization and explains how Karibu Testing must be configured.

Step 1: Create an Application in Entra

The first step is to create an application, configure roles, assign users, and set the redirect URI.

To create an application, log in to http://entra.microsoft.com and select “Applications” -> “Enterprise applications.” There, you can create a new application. Select “Register an application to integrate with Microsoft Entra ID (App you’re developing).”

Building a declarative API with Spring AOP and SpEL

Wed, 12 Feb 2025 15:57:11 +0000

In this article, we’ll implement a declarative API to perform tasks belonging to cross-cutting concerns, using auditing as an example. We’ll see how SpEL and Spring AOP allow us to easily intercept invocations throughout a code base and perform arbitrary logic in an expressive and non-invasive manner.

A story about legacy

Let’s pretend that we inherited a legacy system. The system is in a dismal state, with every change always at risk of bringing the whole thing down. One day, there is a business requirement to audit a few dozen methods scattered throughout the code base. After every invocation of these methods, we should notify an external system by sending a client id and an operation (1234, "CREATE_USER").

Foojay Podcast #66: Let's Talk About Java Code!

Tue, 11 Feb 2025 08:24:06 +0000

In this Foojay podcast, we dive into a few articles that were published recently and focus on code.

Igor Kulakov of JetBrains gives us his insights into the tool he created to find duplicate content in documentation.

Rijo Sam explains how you can generate real random values and how he created a train departure display.

Maxillian Arruda explains in a very detailed post the different ways to construct a complex Java object.

And we start with Wim De Troye about the code changes he had to do in a project that got upgraded from Spring Boot 2 to 3.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Spring Data Neo4j: How to update an entity

Wed, 05 Feb 2025 18:58:12 +0000

After working on a new online Spring Data Neo4j course , I learned a couple more things about updating an entity.

The course required a different set of scenarios than outlined in my previous SDN update blog post , so I wanted to cover those scenarios, as well.

Spring save() method

First up is the out-of-the-box save() method that is provided by Spring as a default. This method takes an input of the entity object you want to save to the database.

The proper way to define configuration properties in Spring

Tue, 07 Jan 2025 16:55:31 +0000

Introduction

I recently did a (long overdue) migration from Spring Boot 2 to 3 on one of our larger applications.

Something that surprised me was that classes marked with @ConfigurationProperties had properties that were properly bound when running in Spring Boot 2 but were no longer bound after the upgrade.

Luckily, the automated testing suite caught this issue at run time , but it’s obvious that such a thing silently failing can be quite problematic.

AI-powered Chat Application using watsonx.ai and Spring AI

Fri, 03 Jan 2025 08:31:51 +0000

Generative Artificial Intelligence (Gen AI) disrupted enterprises with the introduction of GPT-4 foundation model by Open AI in the late 2022 to early 2023 triggering big tech to release their own Gen AI platform and foundation models. Among them are Google, Microsoft, AWS and IBM. In this article, we will deal with the Gen AI platform and model of IBM called watsonx and integrate it with Spring AI to create a custom chat application using the IBM Granite Foundation Model.

Speed up your Spring Batch with Native Image and GraalVM

Tue, 10 Dec 2024 15:47:53 +0000

Spring Batch is often used for data processing jobs that don’t run continuously. Instead, they start, process, and stop,which makes them a perfect candidate for GraalVM Native Image. Unlike traditional Java applications that require a long JVM startup time, Native Images execute almost instantly, giving a significant performance boost.

In this article, you’ll learn how to build a Spring Batch application that reads a CSV file, logs its content, and writes it to a PostgreSQL database.We’ll see how to compile it into a Native Image using GraalVM , and most importantly**, we’ll benchmark the difference between** running it as a traditional JAR and as a native binary.

Prevent LDAP injection in #java 💥💉with #springboot

Wed, 04 Dec 2024 14:45:35 +0000

LDAP (Lightweight Directory Access Protocol) is essential for managing and accessing directory information in Java web applications. However, it’s crucial to understand and prevent LDAP Injection, a serious security vulnerability that can lead to unauthorized access and data breaches.

Following OWASP Recommendations , such as validating user inputs and using parameterized queries, is vital for securing your applications. In this article, we’ll dive into LDAP, explore LDAP Injection, share OWASP’s best practices, and demonstrate secure coding in Spring Boot.

Task schedulers in Java: modern alternatives to Quartz Scheduler

Thu, 28 Nov 2024 18:04:32 +0000

Quartz is often considered the standard job scheduling library in Java, which can lead developers to overlook more modern alternatives.

For a long time, Quartz, also known as Quartz Scheduler, was the only viable open-source task scheduler in Java. In fact, the official Quartz documentation still suggests that there is no real alternative . In this article, we will list a few different Quartz alternatives that offer a similar set of features while being easier and more enjoyable to use.

Langchain4J Musings

Sat, 23 Nov 2024 13:57:30 +0000

I’m coming relatively late to the LLM party, but I rarely come very early in the hype cycle.

For example, I never bought into blockchain, the solution still searching for problems to solve, nor in microservices, the latest in the cargo cult IT trends. Despite my late arrival at the LLM party, I have been a regular user of LLMs. I use OpenAI for non-controversial questions outside my cone of knowledge, e.g., linguistics or legal; I use GitHub Copilot in my IDE to improve my code.

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.

Augmenting the client with Alpine.js

Mon, 14 Oct 2024 10:59:44 +0000

This article is part of a series comparing different ways to implement asynchronous requests on the client, which is colloquially known as AJAX. I dedicated the previous post to Vue.js; I’ll dedicate this one to Alpine.js - not to be confused with Alpine Linux.

I’ll follow the same structure as previously.

Laying out the work

Here’s the setup, server- and client-side.

Server-side

Here is how I integrate Thymeleaf and Alpine.js in the POM:

Augmenting the client with Vue.js

Mon, 14 Oct 2024 10:53:42 +0000

In my previous article , I laid the ground to build upon; now is the time to start “for real”.

I heard a lot of Vue.js . Additionally, a friend who transitioned from developer to manager told me good things about Vue, which further piqued my interest. I decided to have a look at it: it will be the first “lightweight” JavaScript framework I’ll study - from the point of view of a newbie, which I am.

Server-Side Rendering with Spring Boot

Mon, 23 Sep 2024 06:58:41 +0000

Understanding the shared steps in the project setup is crucial before delving into the specifics of each client-augmenting technology. My requirements from the last post where quite straightforward:

I’ll assume the viewpoint of a backend developer

No front-end build step: no TypeScript, no minification, etc.

All dependencies are managed from the backend app, i.e., Maven

It’s important to note that the technology I’ll be detailing, except Vaadin, follows a similar approach. Vaadin, with its unique paradigm, really stands out among the approaches.

Health Check Response Format for HTTP APIs

Thu, 12 Sep 2024 10:02:32 +0000

I’m continuing my journey on getting more familiar with HTTP APIs by reading related . This time, I read the Health Check Response Format for HTTP APIs on the suggestion of Stefano Fago . In this article, I’d like to summarize my reading.

Note that it’s a draft. Moreover, it has been dormant for nearly two years and, thus, has been automatically expired. However, it’s the closest to a specification on health checks and thus deserves some love.

How to profile a performance issue using Spring Boot profiling tools

Mon, 02 Sep 2024 09:56:13 +0000

In today’s fast-paced development environment, ensuring the performance and reliability of your services is critical. Imagine you are part of a team responsible for several services essential to both internal teams and external customers. These services are the backbone of various business operations, and any downtime or performance degradation can have significant repercussions.{#c79c}

Now, picture this scenario: your team has not yet implemented a robust monitoring and observability system. One day, you start receiving emails and messages from frustrated clients reporting that your service is down. Panic sets in as your team tries to figure out what went wrong. Without proper monitoring tools, finding the root cause of issues in production is challenging. Persistent downtime increases pressure, affecting business operations and customer satisfaction.{#acf3}

OpenTelemetry Tracing on Spring Boot, Java Agent vs. Micrometer Tracing

Thu, 22 Aug 2024 08:34:57 +0000

My demo of OpenTelemetry Tracing features two Spring Boot components. One uses the Java agent, and I noticed a different behavior when I recently upgraded it from v1.x to v2.x. In the other one, I’m using Micrometer Tracing because I compile to GraalVM native, and it can’t process Java agents.

I want to compare these three different ways in this post: Java agent v1, Java agent v2, and Micrometer Tracing.

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.

Foojay Podcast #55: Embedded Java, Part 2

Mon, 01 Jul 2024 08:21:42 +0000

As a backend developer, you may not realize that Java was initially born on embedded devices like set-top boxes and gateways. We discussed this topic for the first time almost three years ago in Foojay Podcast #2 with James Gosling, Johan Vos, Erik Costlow, and Frank Delporte .

In this episode #55, we look into the history of the Java Micro Edition and how things evolved. Nowadays, with processors becoming increasingly powerful, we can run the exact same Java runtime on any Linux system, from the biggest cloud servers to the smallest Raspberry Pi Zero.

How to Run Neo4j on Kubernetes

Tue, 25 Jun 2024 19:34:00 +0000

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. In this post, we walk through how to run the Neo4j graph database on Kubernetes.

For an upcoming event, I was asked to give a demo of how to run Neo4j on Kubernetes. I had very little experience with Kubernetes, so I decided to document my journey for later reference.

What is Kubernetes?

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It was originally developed by Google and is now maintained by the Cloud Native Computing Foundation.

Who instruments the instrumenters?

Thu, 30 May 2024 16:25:45 +0000

Have you ever wondered how libraries like Spring and Mockito modify your code at run-time to implement all their advanced features?

Wouldn’t it be cool to get a peek behind the curtains?

This is the premise of my meta-agent , a Java agent to instrument instrumenters, to get these insights and what this blog post is about.

This article is a collaboration with Mikaël Francoeur , who had the idea for the meta-agent and wrote most of this post. So it’s my first ever post-collaboration. But I start with a short introduction to the agent itself before Mikaël takes over with real-world examples.

Exploring Cost-Effective Solutions for Stateful Rest Services

Mon, 27 May 2024 13:13:02 +0000

A Case Study with IBM Cloud Code Engine, EclipseStore, and IBM Cloud Object Storage

In the dynamic realm of cloud computing, finding cost-effective solutions for stateful rest services that don’t necessarily require scaling can be a nuanced challenge.

In this article, we’ll take a pragmatic look at a use case leveraging IBM Cloud Code Engine , EclipseStore , and IBM Cloud Object Storage (COS) . The goal is to shed light on how this can be a practical and economical alternative, particularly when scalability is not a primary concern.

Task scheduler in Java: background job processing with JobRunr

Wed, 22 May 2024 11:05:04 +0000

What is JobRunr

Task scheduler in Java

JobRunr is an open-source Java library for task scheduling and distributed background job processing. It offers an effortless way to perform background tasks using only Java 8 lambdas.

Whether it is a fire-and-forget , scheduled or recurring job , JobRunr analyzes the lambda and stores the metadata needed to process the job in a database. This simple architecture, with a few other mechanisms, allows a job to be executed on any available server running your application (👋 k8s).

Spring AI: How to Write GenAI Applications with Java

Thu, 09 May 2024 18:46:55 +0000

Generative AI (GenAI) is currently a hot topic in the tech world. It’s a subset of artificial intelligence that focuses on creating new content, such as text, images, or music. One popular type of GenAI component is the Large Language Model (LLM), which can generate human-like text based on a prompt.

Retrieval-Augmented Generation (RAG) is a technique that enhances the accuracy and reliability of generative AI models by grounding them in external knowledge sources. While most GenAI applications and related content are centered around Python and its ecosystem, what if you want to write a GenAI application in Java?

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.

Localize applications with AI

Wed, 20 Mar 2024 08:50:29 +0000

Read in other languages: 中文 Español Português

Ever wondered if AI can localize an entire project? In this article, we follow the process end-to-end using the Spring Petclinic as an example. We prepare the project for localization, automate the translation using Python and DeepL, and analyze the results

Whether you are thinking of localizing your project or just learning how to do that, AI might help you. It offers a cost-efficient entry point for experiments and automations.

Video: Spring Boot Testcontainers Support for Local Development

Fri, 16 Feb 2024 09:07:33 +0000

Spring Boot has supported TestsContainers for running services during tests for quite a while.

With Spring Boot 3.1, Testcontainers support for local development was added. This video will show you how this works and how to use it.

Minimize costs utilizing the cloud with Spring-Data-Eclipse-Store

Tue, 13 Feb 2024 15:26:37 +0000

Sooner or later any Spring application needs to store data. And of course, the first and easiest move is to utilize Spring Data JPA . You can set up your data storage without knowing which relational database you will use in production and simply start coding without worrying about that.

It is the easiest and most convenient way to store data (in a relational database like PostgreSQL), yet in the cloud environment it is also an expensive way. Pricing at AWS RDS starts at 30$/month with tiny-Instances and always have fixed monthly costs regardless of its usage.

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.

Video: Spring Boot Docker Compose Support

Wed, 31 Jan 2024 07:50:17 +0000

In Spring Boot 3.1, Docker Compose support was added to simplify local development with external resources.

In this video, I show you how this works and how to use it!

Building gdocweb with Java 21, Spring Boot 3.x and Beyond

Tue, 30 Jan 2024 12:40:00 +0000

Table of Contents

Introducing gdocweb
- Java 21 and Spring Boot 3.x: Innovation and Maturity
GraalVM Native Image for Efficiency
Deployment: VPS and Docker Compose
Front-End: Thymeleaf Over Modern Alternatives
Final Word

Starting a new project is always a mix of excitement and tough decisions, especially when you’re stitching together familiar tools like Google Docs with powerhouses like GitHub Pages.

Durable Subscription with JMS and Spring Boot

Thu, 28 Dec 2023 12:45:56 +0000

When using the publish-subscribe domain with JMS, we often want to use durable subscriptions. But how can this be done with Spring Boot?

What is JMS?

The Java Message Service (JMS) API is a standard for creating, sending, receiving, and reading messages. It enables distributed communication that is loosely coupled, reliable, and asynchronous.

JMS supports two message delivery modes: Point-to-Point and Publish/Subscribe

In the point-to-point domain, a producer can send a message to one consumer through a destination called “queue”. A given queue may have multiple receivers, but only one receiver may consume each message.

Book Review: Modern Frontends with htmx

Sun, 24 Dec 2023 10:07:20 +0000

People who follow me probably know I have a big love for user interface development with JavaFX (for desktop), and Vaadin (for browser). But as always, there are different solutions for every challenge, and building a web user interface with Java can be done with other frameworks.

htmx seems to be one of those hot new rising stars, and I already wanted to dive deeper into it, but didn’t find the time yet.

Handling security vulnerabilities in Spring Boot

Fri, 22 Dec 2023 14:59:10 +0000

In the world of software development, managing dependencies is a core part of creating strong and secure applications. Spring Boot, a favorite among Java developers, makes building applications easier, but there’s more to it than meets the eye. Keeping your dependencies in check is crucial to ensure that your Spring Boot projects run smoothly and remain resilient in the face of ever-evolving threats.

One critical aspect of Spring Boot dependency management is security. Software vulnerabilities are discovered frequently, and by keeping your project’s dependencies up to date, you’re essentially putting on your digital security armor. Outdated dependencies can be like unlocked doors, inviting trouble from potential threats, and that’s something we’d like to avoid.

Testing Spring Boot JMS with ActiveMQ Artemis and Testcontainers

Tue, 12 Dec 2023 07:55:03 +0000

Currently, I’m teaching JMS with Spring Boot at the University of Applied Science in Bern, Switzerland. We use Apache ActiveMQ Artemis as the JMS message broker. But how can we test our Spring Boot application?

Testcontainers to the Rescue

Currently, there is no Testcontainers Java module for ActiveMQ Artemis. As you can see in the Testcontainers GitHub repository , there is an active activemq branch that may be released soon. But in the meantime, we need another solution.

Couch to fully-observed code with Spring Boot 3.2, Micrometer Tracing, and Digma

Wed, 06 Dec 2023 10:42:46 +0000

Collecting important data about your code in dev and test has become trivial, it’s now also getting easier to put that data to use.

{#more-103351}

Tracing > Debugging

There are many benefits to being able to follow what your Spring Boot code is doing using tracing. When used effectively, traces can reveal a lot about the inner workings of complex systems, or provide early feedback when you make mistakes in introducing new code changes.

SpringBoot 3.2 + CRaC

Tue, 28 Nov 2023 13:04:41 +0000

Last week Spring 6.1 and SpringBoot 3.2 were released and they both came with full support for CRaC (Coordinated Restore at Checkpoint).

If you want to learn more about CRaC, feel free to read about it here .

CRaC is an OpenJDK project that can “snapshot” a running JVM (Java Virtual Machine) and store its state, including your application, to disk. Then, at another point in time, you can restore the JVM from the saved checkpoint back to memory. With this, one can start an application, warm it up, and create a checkpoint. Restoring from the saved checkpoint back to memory mainly relies on disk I/O, which means it is really fast (in the range of milliseconds).

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.

Spring Boot and React in Harmony

Tue, 03 Oct 2023 09:14:40 +0000

Develop clean and maintainable business apps on top of Spring Boot and React, and do it faster using the Hilla framework.

For many full-stack developers, the combination of Spring Boot and React has become a staple in building dynamic business applications. Yet, while powerful, this pairing has its set of challenges. From type-related errors to collaboration hurdles, developers often find themselves navigating a maze of everyday issues.

Enter Hilla , a framework that aims to simplify this landscape. If Hilla hasn’t crossed your radar yet, this article will provide an overview of what it offers and how it can potentially streamline your development process when working with Spring Boot and React.

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.

System Architecture: Move Authentication to the API Gateway

Fri, 15 Sep 2023 07:47:04 +0000

When exposing an application to the outside world, consider a Reverse-Proxy or an API Gateway to protect it from attacks. Rate Limiting comes to mind first, but it shouldn’t stop there. We can factor many features in the API Gateway and should be bold in moving them from our apps. In this post, I’ll show how to implement authentication at the Gateway API stage.

Overall authentication flow

The API Gateway doesn’t authenticate but delegates authentication to an authentication provider. After authentication, the Gateway forwards the request to the app. The app checks authentication and gets the associated identity and permissions.

Spring's new JdbcClient API for performing database operations

Fri, 08 Sep 2023 06:45:44 +0000

Spring framework 6.1 introduced a new JdbcClient API, which is a wrapper on top of JdbcTemplate, for performing database operations using a fluent API.

Spring Boot 3.2 is going to include Spring framework 6.1, so let’s take a quick look at

how we can use JdbcClient to implement various database operations in a simplified manner.

First, let’s go to https://start.spring.io/ and create a Spring Boot application by selecting
Spring JDBC , PostgreSQL Driver , Flyway Migration , and Testcontainers starters.

Spring 6.1 - RestClient

Wed, 30 Aug 2023 16:23:40 +0000

As you might have read in this blogpost , Spring is introducing a RestClient in Spring 6.1 to interact with HTTP backends.

Now some of you might be wondering as to the why, given we already have a plethora of other options such as RestTemplate, WebClient, HttpUrlConnection, …

As we can see on the javadoc page RestTemplate got quite massive over time.

The Spring team drew lessons from this, and the reactive WebClient was created with a fluent interface.

Spring Boot Configuration for Docker Images with Azul Zulu

Wed, 30 Aug 2023 16:14:52 +0000

The Spring Boot Maven Plugin makes creating a Docker image from your application very easy! In this article, we give you some extra tips and examples for configuring Spring Boot to define the Java runtime used in such a Spring Boot Docker image and explain how to add additional environmental options to ease debugging.

For this post, I got the help of DaShaun Carter , Spring Developer Advocate, who immediately jumped in when I raised some questions about these configuration options. Thanks, DaShaun!

Spring Boot Petclinic Project

To illustrate our approach, we’ll use the Spring Boot Petclinic project, a Spring Boot application built using Maven or Gradle, to demonstrate how a Spring Boot project is set up fully and how the code is structured and must be packaged.

Create a Spring Boot Application to Retrieve Data from Evernote

Mon, 28 Aug 2023 11:06:45 +0000

I recently started work on a joint project with my colleague, Jason Koo . For this project, we want to import data from second brain apps (such as Obsidian, Notion, Evernote, etc) to Neo4j.

Since I use Evernote, I was tasked with getting my notes out of Evernote.

In this article, I will show you how to use the Evernote API and SDK in a Spring Boot application to retrieve data from Evernote.

Spring Boot: local development enhancements, let's compose!

Fri, 25 Aug 2023 11:16:05 +0000

Quite often when we are developing an application we need external services such as rabbitMQ, Kafka, etc.

When you are developing locally, you are quite likely using a docker-compose file to start these up, and I am certainly (hopefully) not the only one that has forgotten at least once to start these instances up.

And maybe you are even already using Testcontainers for your testing.

Luckily, Spring Boot 3.1 introduced some nice improvements to make our lives a bit easier.

Exploring File Storage Solutions in Spring Boot

Wed, 23 Aug 2023 08:07:19 +0000

When building a web application, managing file uploads properly is a common requirement. After receiving, files can be stored in several places: in a file system, in a database or, more commonly, in a cloud storage service.

In this article, we will cover how to store files in a database using Spring Boot and discuss some alternatives.

Introduction

Recently, a fellow developer who I helped in past reached out to me on Slack seeking assistance with handling file uploads in a Spring Boot application. After providing some guidance, I decided to compile this article to assist others facing similar challenges.

Journeys in Java, Level 10: Service Discovery with Eureka

Thu, 13 Jul 2023 06:39:06 +0000

Gaining complexity in a microservices system certainly isn’t for the faint of heart (though neither is complexity in monoliths!).

When there are many services that need to communicate with one another, we might need to coordinate multiple services communicating with multiple other services.

We also might code for varying environments such as local, development server, or the cloud.

How do services know where to find one another?
How can we avoid problems when a service is unavailable?
How do we handle requests when we scale up or down certain parts of our system?

This is where something like Spring Cloud Netflix Eureka comes into play.

Sticky sessions with Apache APISIX - the demo

Fri, 07 Jul 2023 16:54:25 +0000

We’ve described the concept behind sticky sessions : you forward a request to the same upstream because there’s context data associated with the session on that node.

However, if necessary, you should replicate the data to other upstreams because this one might go down. In this post, we are going to illustrate it with a demo.

The overall design

Design options are limitless. I’ll keep myself to a familiar stack, the JVM. Also, as mentioned in the previous post, one should only implement sticky sessions with session replication.

Spring Boot Debugging with Aspect-Oriented Programming (AOP)

Fri, 05 May 2023 08:19:18 +0000

Aspect-Oriented Programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns.

In simple terms, it helps you keep your code clean, modular, and easy to maintain.

We can leverage AOP to debug Spring Boot applications more effectively and seamlessly.

In this post, we will explore how to use AOP to debug a Spring Boot application effectively.

AOP Concepts

Before diving into debugging with AOP, it is essential to understand the core concepts. AOP lets us write code that executes before or after a method. It includes the following common terms:

Developer vs. ChatGPT Part I: Writing a Spring Boot Microservice

Thu, 27 Apr 2023 15:25:12 +0000

We pit a seasoned Java developer against the all-knowing generative AI to find out once and for all: Can an AI generate a Java microservice end-to-end?

There’s a lot of buzz around Generative AI tools for code generation. It’s no secret that the future of developer productivity goes alongside tools such as GitHub Copilot and OpenAI’s ChatGPT to enable us, developers, to produce code better and faster. These tools can learn from our existing code and suggest new code based on the desired functionality, most importantly, they can even write documentation and tests!

Control your Arduino with Spring

Sat, 25 Mar 2023 07:21:04 +0000

Have you ever wanted to control your Arduino board from a Raspberry Pi, or your computer, using only Java and not the Arduino language?

In this article, I show how I created a web app to control my Arduino with a Raspberry PI using Spring. And so this is another article about Java on Raspberry PI or perhaps this time I can say Java and Arduino.

Idea

A simple Spring app where I can create a REST interface to control one of the Arduino GPIOs. I can plug a LED and build a simple blink LED example.

Is it Time to go Back to the Monolith?

Fri, 03 Mar 2023 15:58:20 +0000

History repeats itself. Everything old is new again and I’ve been around long enough to see ideas discarded, rediscovered and return triumphantly to overtake the fad.

In recent years SQL has made a tremendous comeback from the dead. We love relational databases all over again. I think the Monolith will have its space odyssey moment again. Microservices and serverless are trends pushed by the cloud vendors, designed to sell us more cloud computing resources.

Journeys in Java, Level 9: Docker compose all the things

Sun, 26 Feb 2023 10:02:15 +0000

Our microservices project contains quite a few pieces now.

We have two databases, three API services, a user-view service for books, and a service to host our configuration.

With so many pieces to manage, it would be nice to have something that orchestrates the individual services into a system, such as Docker Compose.

Back in our Level 5 rendition, we did exactly this for our smaller version of the project.

Now that we have expanded our services, we need to add those new pieces into the existing Docker Compose management umbrella.

Journeys in Java, Level 8: Add MongoDB to Spring Cloud Config

Thu, 09 Feb 2023 16:56:28 +0000

In our last article , we used Spring Cloud Config to provide database credentials to a microservice application connecting to a cloud-hosted Neo4j database. This post will backport this concept to our existing MongoDB database instance and its related microservices.

We will add our MongoDB credentials to the config server, so that it will be the central place for both our Neo4j and MongoDB database access. However, each service only has access to the credentials that it needs to operate, which provides some level of security through “separation of concerns” (versus universal access).

Journeys in Java, Level 7: Externalize Microservice Configuration

Mon, 30 Jan 2023 15:43:16 +0000

Our decided next step for this project takes us in a new direction by adding externalized configuration for our applications.

We already saw how to do something similar with MongoDB database credentials in Docker Compose to access a local database container, but what do we do when the database is hosted on public cloud or contains sensitive data?

We probably don’t want to publish our credentials anywhere or even prevent accidental publishing.

Modular Monolithic in Practice

Wed, 25 Jan 2023 08:01:08 +0000

With the usage of microservices in application modernization, we have seen both the advantages and disadvantages of maintaining such software development styles.

When we create applications mostly in enterprise organizations, the first thing that comes to our mind now is how to decouple our applications.

But there will be times when creating too many microservices is not the best way and may cost you time and money.

Because of that, one alternative is to leverage the use of modules.

Spring Boot Annotation Reference-01/b

Fri, 06 Jan 2023 09:54:05 +0000

In the second part of my article series on Spring Boot Annotations, we focus on REST and Spring Stereotype Annotations.

In continuation of part 01/a of this article , let’s continue our Spring Boot Annotations journey.

What percentage (depth and extent) of Spring Boot Annotations do you think you really know? This includes annotations in all their glory and the power that they bring via all of their options. I am sure whatever your answer may be, you will appreciate this quote from Albert Einstein: “The more I learn, the more I realize how much I don’t know.”

Spring Modulith: Have We Reached Modularity Maturity?

Thu, 29 Dec 2022 07:07:29 +0000

One of the main reasons to design microservices is that they enforce strong module boundaries .

However, the cons of microservices are so huge that it’s like chopping off your right hand to learn to write with the left one; there are more manageable (and less painful!) ways to achieve the same result.

Even since the microservices craze started, some cooler heads have prevailed.

In particular, Oliver Drotbohm , a developer on the Spring framework, has been a long-time proponent of the moduliths alternative.

Spring Boot Annotation Reference - 01/a

Thu, 22 Dec 2022 09:57:33 +0000

In 2018, I was introduced to the topic of Microservices and Spring Boot via a formal training, during my brief stint as a Senior Architect in Manila, Philippines.

Though I had worked on a ‘similar architecture’ way back in 2007-‘08 while working as a Software Engineer at Symantec - I found the idea of the Uber JAR really exciting. Also, since it will now be enforced via the most popular framework brings in more possibilities.

SpringOne TLV World Tour Trip Report

Fri, 09 Dec 2022 22:00:00 +0000

My talk was accepted by SpringOne in San Francisco. I never went to that conference and was really looking forward to it. This year would probably be amazing with the Spring 6.0 and Spring Boot 3.0 releases. So many groundbreaking changes. Unfortunately, my travel budget at Lightrun was cut, and I eventually left. This meant I had to cancel the trip, I would have paid for travel, but San Francisco is both far and prohibitively expensive. I’ll have to take a raincheck.

Clean Ways to Shutdown Spring Boot Applications

Fri, 04 Nov 2022 14:11:00 +0000

For the last three to four years, I have been working on Spring Boot and its associations, such as Spring Cloud, Spring Data, and Spring Security.

I have always been tempted to use the combination of Ctrl+C and task kill for the purpose of killing Spring Boot applications or processes. It can be automated by a batch script, but usually I was quite lazy to do this myself, as the combination of actions used to serve the purpose!

Starting Docker Desktop with Spring Boot

Fri, 30 Sep 2022 05:37:53 +0000

I came across Docker Desktop for the first time about three years ago, when I was working as a Principal Architect (Strategic R & D) on the Microservices Reference Architecture for a product development organization.

At that time, when I was working on my corporate laptop - It became a tedious task to configure virtualization and settings to get it to work. Once I got it running smoothly, I realized that the memory requirements required to run it is quite high. At times, I found it tough to use my laptop for daily development with it running. It was also because I was working on microservices and had almost 6+ spring boot applications running.

Baeldung Series Part 2: Build a Dashboard With Cassandra, Astra and CQL – Mapping Event Data

Tue, 13 Sep 2022 17:46:02 +0000

1. Introduction

In our previous article , we looked at augmenting our dashboard to store and display individual events from the Avengers using DataStax Astra , a serverless DBaaS powered by Apache Cassandra using Stargate to offer additional APIs for working with it.

In this article, we will be making use of the exact same data in a different way. We are going to allow the user to select which of the Avengers to display, the time period of interest, and then display these events on an interactive map. Unlike in the previous article, this will allow the user to see the data interacting with each other in both geography and time.

End-to-End Tracing with OpenTelemetry

Mon, 29 Aug 2022 14:24:00 +0000

Whether you implement microservices or not (and you probably shouldn’t), your system is most probably composed of multiple components.

The most straightforward system is probably made of a reverse proxy, an app, and a database.

In this case, monitoring is not only a good idea; it’s a requirement.

The higher the number of components through which a request may flow, the strongest the requirement.

However, monitoring is only the beginning of the journey.

When Disaster Strikes: Production Troubleshooting

Fri, 12 Aug 2022 11:03:08 +0000

Tom Granot and myself have had the privilege of Vlad Mihalcea’s online company for a while now. As a result we decided to do a workshop together talking about a lot of the things we learned in the process. This workshop would be pretty informal ad-hoc, just a bunch of guys chatting and showing off what we can do with tooling.

In celebration of that I thought I’d write about some of the tricks we discussed amongst ourselves in the past to give you a sense of what to expect when joining us for the workshop but also a useful tool in its own right.

Journeys in Java, Level 6: Build a Neo4j Microservice

Wed, 13 Jul 2022 15:13:43 +0000

For our next adventure in Java microservices, we want to expand our system for book review data.

While books and authors are well-suited for a document database such as MongoDB, once you add reviews to the mix, the importance of the relationships makes this project better suited for a graph database.

This way, we can utilize relationships between the different entities to improve analysis based on the structure of the connections.

Spring Boot Performance Workshop with Vlad Mihalcea

Fri, 24 Jun 2022 07:43:52 +0000

A couple of weeks ago, we had a great time hosting the workshop you can see below with Vlad Mihalcea. It was loads of fun and we hope to do this again soon!

In this workshop, we focused on Spring Boot performance but most importantly on Hibernate performance, which is a common issue in production environments.

It’s especially hard to track since issues related to data are often hard to perceive when debugging locally. When we have “real world” data at scale, they suddenly balloon and become major issues.

Spring Transaction Debugging in Production with Lightrun

Fri, 06 May 2022 15:00:53 +0000

Spring makes building a reliable application much easier thanks to its declarative transaction management.

It also supports programmatic transaction management, but that’s not as common.

In this article, I want to focus on the declarative transaction management angle, since it seems much harder to debug compared to the programmatic approach. This is partially true. We can’t put a breakpoint on a transactional annotation.

But I’m getting ahead of myself!

What is Spring’s Method Declarative Transaction Management?

When writing a spring method or class, we can use annotations to declare that a method or a bean (class) is transactional. This annotation lets us tune transactional semantics using attributes. This lets us define behavior such as:

Spring4Shell: The zero-day RCE in the Spring Framework explained

Fri, 08 Apr 2022 04:17:45 +0000

On March 30, 2022, a critical remote code execution (RCE) vulnerability was found in the Spring Framework. More specifically, it is part of the spring-beans package, a transitive dependency in both spring-webmvc and spring-webflux. This vulnerability is another example of why securing the software supply chain is important to open source.

Security resources like Lunasec , Rapid7 and Praetorian confirmed that the vulnerability is real, and in the meantime, Spring has already released a new version that mitigates this problem, so we recommend updating . While Spring4Shell does not appear to have the same impact as the recent Log4Shell vulnerability, it should still be evaluated and prioritized by every organization using the Spring Framework. In this post, we’ll explore how the RCE works.

Spring Remote Code Execution Vulnerability

Thu, 31 Mar 2022 14:54:49 +0000

I’d like to start by saying that I’m not a security expert. I also won’t link to the exploit. This is a very fresh take on a new vulnerability but there’s already confirmation from Sonatype . The current exploit seems to be limited to Spring on top of Tomcat but it probably can be adapted since the underlying vulnerability seems general enough.

The vulnerability only impacts Java 9 or newer so if you have an older version you should be safe from this specific exploit.

Blink a LED on Raspberry Pi with Vaadin

Fri, 25 Mar 2022 14:44:02 +0000

As I’m becoming a senior developer, at least in terms of age, I’ve transitioned from one language to another.

One of my main interests has always been clean, easy-to-understand UIs (User Interfaces). That journey started for me with Director (to create multimedia CD-ROMs), Flash website animation, and Flex Rich Internet Applications (= “Flash on steroids”).

When I started developing with Java over 10 years ago, we had some projects with the early versions of Vaadin and JavaFX.

Building Reactive Java Applications with Spring Framework

Tue, 15 Feb 2022 14:09:28 +0000

In one of our many free tutorials on DataStax Developers YouTube channel , we walked you through how to build a reactive implementation of Spring PetClinic in Apache Cassandra® using Spring WebFlux. The full series is available on YouTube .{#08a7}

If you’re a Java developer who uses the Spring ecosystem, you’ve probably seen the Spring Pet Clinic . In this workshop, we will walk you through a new reactive implementation of the Pet Clinic backend that uses Spring WebFlux and Apache Cassandra ® (via DataStax Astra DB ).{#47b5}

Statically Spilling Your (Spring) Beans

Mon, 24 Jan 2022 11:25:13 +0000

UPDATE - To make it abundantly clear:

You should always try to refactor your code so you do not need this approach (something I’ll dive into in a follow up blogpost I’m working on). There may be some edge cases where there truly is no other way but those situations are rare. Always try to refactor!

Using this method can lead to multiple unexpected and hard to debug issues as it does not follow the regular Spring Framework concepts. As such, this approach is considered A VERY BAD IDEA .

Build a Status Dashboard Using Spring Boot and Astra DB

Fri, 17 Dec 2021 09:28:19 +0000

In this article, we are going to build “Tony Stark’s Avengers Status Dashboard”, used by The Avengers to monitor the status of the members of the team.

This will be built using DataStax Astra , a DBaaS powered by Apache Cassandra using Stargate to offer additional APIs for working with it.

On top of this, we will be using a Spring Boot application to render the dashboard and show what’s going on.

Non-blocking with Spring WebFlux, Kotlin and Coroutines

Thu, 09 Dec 2021 14:03:28 +0000

When a HTTP request comes in, a ’normal’ web application would map the request to a specific thread from the thread pool. This assigned thread stays with the request until a response can be returned to the request socket. Along the way, we might need to fetch data from some web service or database, read or write to a file or do other I/O calls, during which the thread is blocked and has to wait until it gets a response. For applications with high request rates, the thread pool can at some point become exhausted and then no new requests can be handled anymore.

Multiple Spring Boot Applications in the Same Project

Wed, 08 Dec 2021 16:42:44 +0000

I frequently use the Spring Boot framework in my demos. The latest one is no different. It shows how to achieve using two different code paths:

the command part is implemented via Spring Data JPA
the query part via jOOQ

My use case is a banking application that offers a REST layer allowing clients to call any parts. Demoing the query part is easy enough with curl as the URL is not complex:

Native-image with Spring Boot

Fri, 19 Nov 2021 11:47:19 +0000

The Cloud has enabled a lot of new usages that were not possible before. Among them stands Serverless:

Serverless computing is a cloud computing execution model in which the cloud provider allocates machine resources on demand, taking care of the servers on behalf of their customers. Serverless computing does not hold resources in volatile memory; computing is rather done in short bursts with the results persisted to storage. When an app is not in use, there are no computing resources allocated to the app.

A Walk to Lazy Fetching With Hibernate and Spring Data JPA

Wed, 17 Nov 2021 11:47:30 +0000

Background

Using FetchType.EAGER is a very bad practice, since our services may not require all the data of the mapped entities in all cases. And moreover, it is a bad idea to fetch so much data in a single session and makes the session heavy.

Therefore we will refactor the code and use FetchType.LAZY.

Our old code for the entity was below:

After using FetchType.LAZY our new code will be like below:

Multiple Ways to Configure Spring

Wed, 06 Oct 2021 08:55:34 +0000

Two weeks ago, I wrote how you could write a Spring application with no annotations.

Many alternatives are available to configure your Spring app.

I’d like to list them in this post, leaving Spring Boot out of the picture on purpose.

Core concepts

A couple of concepts are central in Spring. The related documentation doesn’t describe most of them. Here is my understanding of them:

Bean : A bean is an object managed by the Spring container
Bean Factory : A bean factory is a component that manages the lifecycle of beans, especially regarding the instantiation of new objects
Bean Definition : A bean definition is the set of properties given to the Spring container and that the requested bean will have, e.g., class, name, scope, dependencies, etc.
Context: A context is a bean factory with additional capabilities (mainly internationalization and event publishing)

To configure a Spring application, one creates one or more contexts and registers the necessary bean definitions in the desired ones. In the following sections, we will configure the following simple model:

VS Code: SpringOne Updates, UX Improvements, Community Feedback

Mon, 20 Sep 2021 06:46:49 +0000

Hi everyone, welcome to the August edition of the Visual Studio Code Java update!

In this article, we are going to share some exciting updates from the SpringOne 2021 conference, as well as various user experience improvements.

When it comes to Java development, we always keep Spring developers in mind. In this year’s SpringOne conference , we shared an update on our Spring tooling support in Visual Studio Code, and showcased various Spring related features in two breakout sessions.

A Return to Annotation-Free Spring

Fri, 17 Sep 2021 12:03:24 +0000

Some, if not most, of our judgments regarding technology stacks come either from third-party opinions or previous experiences. Yet, we seem to be adamant about them. For a long time (and sometimes even now), I’ve seen posts that detailed how Spring is bad because it uses XML for its configuration. Unfortunately, they blissfully ignore the fact that annotation-based configuration has been available for ages.

And probably for of the same reason, I recently read that Spring is bad… because of annotations. If you belong to this crowd, I’ve news for you: you can get rid of most annotations and even more so if you’re using Kotlin.

Better Error Handling for Your Spring Boot REST APIs

Sat, 21 Aug 2021 07:41:59 +0000

One of the things that distinguishes a decent API from one that is a pleasure to work with is robust error handling. Nothing is more frustrating than using some API and getting back cryptic errors where you can only guess why the server is not accepting your request.

Spring Boot lets you customize the error handling for your application, but there is quite a lot of low-level coding involved if you want to do this correctly. What consititutes good error handling and good error responses in particular might be up for debate, but I think we can agree on a few general guidelines:

Creating a Simple Spring Boot Application in IntelliJ IDEA

Mon, 31 May 2021 17:06:51 +0000

This tutorial uses IntelliJ IDEA Ultimate because we want to create a new project using Spring Initializr. This functionality is only available with IntelliJ IDEA Ultimate. It is based off Building an Application with Spring Boot .

Creating your Spring Boot Project

If you’re in an IntelliJ IDEA project already, select File > Project . Alternatively click the New Project button on the Welcome screen.
Select Spring Initializr on the left-hand side and then enter the following options:

Building Microservices with Spring Boot Fat (Uber) Jar

Wed, 21 Apr 2021 09:28:43 +0000

In most minds,microservices is an approach to make a traditional monolithic system more structured, dividing it into logical components that correspond to different functional areas of application. Thus, acting as a microservice, each component becomes self-contained, easily scaled, maintained and even upgraded without affecting the overall system. Also, with microservice architecture, you can use a software written in different programming languages, including Java. Such freedom attracts but may frighten at the same time.

Running Spring Boot Applications on OpenShift

Thu, 04 Mar 2021 08:36:17 +0000

This article will demonstrate how to deploy a Spring Boot application on OpenShift (Minishift).

Introduction

Cloud platforms have dramatically changed the way we develop and deploy modern applications. Not so long ago, everything was on-premise infra. However, things have changed dramatically over the years. Now, there are a number of vendors offering solutions for different cloud computing models, i.e., Saas, Paas, and Iaas.

This article will cover Openshift developed by Redhat, which comes under the Paas cloud computing model.

Monitoring Across Frameworks: Spring Boot, Quarkus, Micronaut, Helidon

Tue, 02 Mar 2021 18:44:07 +0000

Gone are the times when developers’ jobs ended with the release of the application. Nowadays, developers care more and more about the operational side of IT: perhaps they operate applications themselves, but more probably, their organizations foster increased collaboration between Dev and Ops.

I started to become interested in the Ops side of software when I was still a consultant. When Spring Boot released the Actuator, I became excited. Via its convention-over-configuration nature, it was possible to add monitoring endpoints with just an additional dependency.

Containerizing Spring Boot Applications with Jib

Tue, 29 Dec 2020 19:29:08 +0000

In this post, we will learn about how to create docker or OCI compliant images, without installing any docker client and without using a Dockerfile, for a Spring Boot application.

We will be doing all of this with the help of Jib.

What Is Jib?

Jib is Java containerizer from Google that lets Java developers build containers using build tools like Maven and Gradle.

But that’s not all that is really interesting about Jib because you don’t need to know anything about installing docker, maintaining Dockerfiles, etc.

Spring Boot: Strategy Design Pattern - Convenience and Limitation

Fri, 30 Oct 2020 09:22:41 +0000

You might have already used the strategy pattern in relationship with Spring Boot where it is very convenient to use.

You simply define an interface for example (I use the prefixing I only in these examples for clarity):

public interface IOneStrategy {
 void executeTheThing();
}

Define some implementations like this:

@Service("FIRST")
public class OneStrategyFirst implements IOneStrategy {

 @Override
 public void executeTheThing() {
 System.out.println("OneStrategyFirst.executeTheThing");
 }
}

Now you can simply implement a service which will execute the appropriate strategy based on the given name which looks similar like this:

Getting Started with a Simple Service with Spring Boot

Tue, 22 Sep 2020 12:59:42 +0000

In this post, I will demonstrate how to create a simple Web Service using Spring Boot. This framework makes it almost effortless to develop web services, so long as the appropriate dependencies are in place.

In this example, I will create a Web Service that will read the current temperature from a file and make it available to clients via a RESTful endpoint.

1. Use the Spring Intializr

The Spring Initializr helps one to choose the dependencies that are required for production a particular solution.