DEV Community: Milan Karajovic

Claude Code Reminder

Milan Karajovic — Mon, 06 Apr 2026 12:02:52 +0000

Claude Code

Claude Code offers developers a powerful agentic coding assistant that automates tasks, accelerates workflows, and improves code quality. Its biggest advantage is shifting from simple code suggestions to autonomous execution, helping teams ship faster and with fewer errors. (Claude Code Docs)

Here are 5 key advantages of Claude Code:

⚡ 1. Agentic Coding

Claude Code goes beyond autocomplete — it can autonomously execute coding tasks, not just suggest snippets. This means faster delivery of features and reduced manual effort.

🧠 2. Context-Aware Assistance

It understands the surrounding codebase and project context, offering smarter refactoring, debugging, and dependency fixes compared to traditional AI assistants.

🛠️ 3. Reduced Repetitive Work

Routine tasks like boilerplate generation, formatting, and dependency updates are handled automatically, freeing developers to focus on architecture and problem-solving.

📈 4. Improved Code Quality

By enforcing consistency and suggesting best practices, Claude Code helps maintain cleaner, more reliable code across teams.

Download the Medium App
🚀 5. Faster Debugging & Troubleshooting

It can analyze errors directly in the terminal and propose fixes, accelerating the debugging process and minimizing downtime.

There is file Reminder for Claude Code
https://github.com/Milan-Karajovic/Claude-Code-Reminder/blob/main/ClaudeCode-Reminder.pdf

𝐌𝐢𝐥𝐚𝐧 𝐊𝐚𝐫𝐚𝐣𝐨𝐯𝐢ć

𝐏𝐨𝐫𝐭𝐟𝐨𝐥𝐢𝐨: https://milan.karajovic.rs

𝐅𝐨𝐥𝐥𝐨𝐰 𝐦𝐞 on 𝐋𝐢𝐧𝐤𝐞𝐝𝐈𝐧: https://lnkd.in/e3cH854Q

𝗢𝗔𝘂𝘁𝗵𝟮.𝟬 — 𝗦𝗶𝗺𝗽𝗹𝗲, 𝗳𝘂𝗻𝗻𝘆 𝗲𝘅𝗽𝗹𝗮𝗻𝗮𝘁𝗶𝗼𝗻 𝗳𝗼𝗿 𝗲𝘃𝗲𝗿𝘆𝗯𝗼𝗱𝘆

Milan Karajovic — Mon, 26 Jan 2026 23:02:32 +0000

𝗢𝗔𝘂𝘁𝗵 𝟮.𝟬 𝗶𝘀 𝘁𝗵𝗲 𝗶𝗻𝗱𝘂𝘀𝘁𝗿𝘆-𝘀𝘁𝗮𝗻𝗱𝗮𝗿𝗱 𝗽𝗿𝗼𝘁𝗼𝗰𝗼𝗹 𝗳𝗼𝗿 𝗮𝘂𝘁𝗵𝗼𝗿𝗶𝘇𝗮𝘁𝗶𝗼𝗻, 𝗲𝗻𝗮𝗯𝗹𝗶𝗻𝗴 𝗮𝗽𝗽𝘀 𝘁𝗼 𝗮𝗰𝗰𝗲𝘀𝘀 𝘂𝘀𝗲𝗿 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀 𝘀𝗲𝗰𝘂𝗿𝗲𝗹𝘆 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝘀𝗵𝗮𝗿𝗶𝗻𝗴 𝗽𝗮𝘀𝘀𝘄𝗼𝗿𝗱𝘀. It’s what powers “Login with Google/Facebook” and similar flows, giving apps limited, consented access to your data.

Goal Implement Security OAuth2 for an application.

What is our point of the consideration?

· Resource Owner: User which uses our public client application

· Public Client: Public client application

· Resource Server: Server which hold protected data

· Resources: Protected data

· Authorization Server: Server which provides access tokens for security communication

Press enter or click to view image in full size

(1) I want to access my resources

(2) Tell the Authorization Server that you are fine to do this action

(3) (3.1) & (3.2) Hello Authorization Server, please allow the client to access my resources. Here are my credentials to prove my identity and code challenge generated by client application along with client id.

(4) Hey Client, User allowed you to access his resources. Here is AUTHORIZATIN CODE.

(5) Here is my client id, code verifier, AUTHORIZATION CODE. Please, provide me a token.

(6) Here is the toke from Authorization Server

(7) Hey Resource Server, I want to access the user resources. Here is the token from Authorization Server

(8) Resource server validate token on the Authorization Server

(9) Authorization server validate token

(10) Hey Client, your token is validated successfully. Here are the resources you requested.

Common formats of OAuth Tokens

An access token is a credential issued by the Authorization Server
after a client successfully authenticates and obtains authorization.
It represents the client’s permission to access protected resources on
a Resource Server (API)
Tokens are usually short lived to reduce risk if compromised.

Opaque and JWT token

Opaque Tokens (Random strings with no inherent meaning)
JWT (JSON Web Token) Tokens (Self contained, digitally signed tokens that carry claims)

Comparison JWT and Opaque Token

Which to use?

Use opaque tokens when revocation and centralized control
are critical (internal enterprise systems, sensitive data).
Use JWT tokens when performance and scalability matter
(public APIs, microservices)

𝐌𝐢𝐥𝐚𝐧 𝐊𝐚𝐫𝐚𝐣𝐨𝐯𝐢ć

𝐏𝐨𝐫𝐭𝐟𝐨𝐥𝐢𝐨: https://milan.karajovic.rs

𝐅𝐨𝐥𝐥𝐨𝐰 𝐦𝐞 on 𝐋𝐢𝐧𝐤𝐞𝐝𝐈𝐧: https://lnkd.in/e3cH854Q

Angular - Standalone Component - With Portfolio Example

Milan Karajovic — Thu, 11 Dec 2025 13:47:14 +0000

Angular standalone components are a way to build components without needing an NgModule, making applications simpler and more modular.

What is a Standalone Component?

Self-contained unit: A standalone component can operate independently without being declared inside an NgModule.

Introduced in Angular v14: This feature streamlines development by reducing boilerplate code.
Marked with standalone: true: When defining a component, directive, or pipe, you set this flag to make it standalone.
Direct imports: Instead of relying on NgModules, standalone components import other components, directives, and pipes directly.
Incremental adoption: Existing projects can gradually migrate to standalone style without breaking changes.

How to Create Standalone Component

import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';

@Component({
  selector: 'app-hello',
  standalone: true,
  imports: [CommonModule],
  template: `<h1>Hello Standalone!</h1>`
})
export class HelloComponent {}

Clarification

Standalone flag: standalone: true makes it independent.
Imports array: You directly import CommonModule or other standalone components.
No NgModule needed: You can bootstrap this component directly in main.ts.

Benefits

Simplified structure: Reduces reliance on NgModules.
Flexibility: Components can be reused more easily.
Cleaner codebase: Less boilerplate, more focus on functionality.
Gradual migration: Existing apps can adopt standalone components step by step.
Lazy Loading: possible and easy to implement.

Example

Example: Portfolio — Example Angular Standalone components.
GitHub with Source Code: https://github.com/Milan-Karajovic/Angular-Standalone-Components
LinkedIn: https://www.linkedin.com/in/milan-karajovic-java-angular-security-cloud-architect/

Home

Navigation

About

About - Details

Contact

Thanks

You are now ready to create your own modern and functional portfolio. Good luck.
Try example on GitHub. See you again!
GitHub with Source Code: https://github.com/Milan-Karajovic/Angular-Standalone-Components

Learn Java 21 in 9 minutes and 3 seconds

Milan Karajovic — Sat, 23 Aug 2025 15:43:39 +0000

This article is intended for experienced Java programmers who want to update their Java knowledge with the new features introduced in Java 21.

Java 21, released in September 2023, is a Long-Term Support (LTS), and today, in 2025 still is a recommended Java version for development applications based on Java.

Why to use new versions of Java? Why Java 21?

Java 21 introduces features that improve developer productivity, code readability, and application performance.

In my experience, many companies and developers just upgrade the Java version of a project, but don’t refactor the source code to take advantage of the new benefits that the new Java version brings.

Be proactive and refactor your code to make your application and source code perform better.

The Java 21 ride begins! Are you ready?

Java 21 brings several new features

The most important new features in Java 21 are:

Virtual Threads
Record Patterns
Pattern Matching for Switch
Generational ZGC
String Literal — String Templates
Sequenced Collections

Virtual Threads

Probably, the most important feature in Java 21 are Virtual Threads.

Using Virtual Threads, introduced in Java 21, the concurrent API has better performance. Today, we have microservices architecture, server application scales, and that will cause the number of threads to grow. A main goal of virtual threads is to enable scalability of server applications written in the simple thread-per-request style.

In Java 21 the basic concurrence model of Java is unchanged and the Stream API is still the preferred way to process large data sets in parallel.

For example, executor with a Virtual thread you can create like this:

ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

This means that refactoring and switching to using Virtual Threads is very easy.

In the picture bellow is shown comparison.

The difference is very obvious when we have 1_000_000 tasks.

FixedThreadPool (1_000_000 tasks) = 33 min 20 sec
CachedThreadPool (1_000_000 tasks) = 1 min 26 sec
VirtualThreadPerTask (1_000_000 tasks) = 14 sec

On this link is my Full Article from where you can read details about Virtual Threads in Java 21:
https://medium.com/@milan.karajovic.rs/virtual-threads-in-java-21-comparing-with-cached-thread-and-fixed-thread-726f81ec47fa

The Source Code is on my GitHub about Virtual Threads in Java 21:
https://github.com/Milan-Karajovic/comparing-threads-Java21-with-Virtual-Threads

Record Patterns

About the Record:

Records are a special type of class that save us a lot of boilerplate code. They are considered “data carriers” and are immutable.

These components become final instance variables and accessory methods having the same names as the components are provided automatically.

In addition, a (canonical) constructor, toString(), equals() and hashCode() methods are also generated.

Without Record before Java 16:

public final class Student{
private final String name;
private final Integer age;
public Student(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() {
return name;
}
public Integer age() {
return age;
}
// also toString(), equals() and hashCode() generated
}

With Record in Java 16:

public record Student(String name, Integer age) {}

About Patterns & Pattern Matching

Before Java 16:

if(obj instanceof String) {
String s = (String)obj;
System.out.println(s.toUpperCase());
}

After Java 16:

if(obj instanceof String s) {
System.out.println(s.toUpperCase());
}

From Java 16 Pattern Matching is done at runtime.

If the pattern matches, then the instance of expression is true and the pattern variable ‘s’ now refers to whatever ‘obj’ refers to.

Record Pattern in Java 21

A Record Pattern does two things for us:

Checks if an object passes the instance of test.
Disaggregates the record instance into its components Record patterns support nesting.

Student(String name, Integer age) is a record pattern which does two things:

Tests whether the object is of type Person (as usual)
Extract the records components by invoking the component accessor methods on our behalf.

public record Student (String name, Integer age) {}

Before Java 21:

if (obj instanceof Student s) {
String name = s.name();
Integer age = s.age();
System.out.println(name + "; " + age);
}

Now in Java 21:

if (obj instanceof Student(String name, Integer age)) {
System.out.println(name + "; " + age);
}

A Record Pattern does two things for us:

Checks if an object passes the instance of test.
Disaggregates the record instance into its components

Pattern Matching:

public static void patternMatching(Object obj){
if(obj instanceof Person person ){
System.out.println("Pattern Matching: "+person.name() + "; "+ person.age());
} else if(obj instanceof Pair pair){
System.out.println("Pattern Matching: "+pair.x() + "; "+ pair.y());
}
}

Non Nesting:

public static void nonNesting(Object obj){
if(obj instanceof Person(String s, Integer nAge)){
System.out.println(s + "; "+ nAge);
}
}

Nesting:

public static void nesting(CourseHolders cHolder){
if (cHolder instanceof CourseHolders(FacultyEmploees employ1, FacultyEmploees employ2)) {
System.out.println(employ1.person() + "; " + employ1.title());
System.out.println(employ2.person() + "; " + employ2.title());
}
if (cHolder instanceof CourseHolders(FacultyEmploees(Person p1, CollegeTitle title), var employ2)) {
System.out.println(p1.name() + "; "+p1.age() + "; "+title.name());
System.out.println(employ2.person());
}
}

Pattern Matching For Switch

Switch is a very natural fit for pattern matching. Recall that pattern matching removes the need for the instanceof and cast idiom.

Other changes, such as the when clause, were motivated by the desire to separate the case labels, patterns and conditional logic from the business logic.

From Java 14, yield is introduced to support switch expressions, allowing a case block to return a value (replaces the older break with value syntax)

Case label now can be:

null
byte
short
int
char
Byte
Short
Integer
Character
String
enum
reference type

Pattern Matching For Switch:

sealed class Vehicle permits Car, Truck, Motorcycle{}
final class Car extends Vehicle{}
final class Truck extends Vehicle{}
final class Motorcycle extends Vehicle {
private int numWheels;
Motorcycle(int numWheels){
this.numWheels = numWheels;
}
public int getNumWheels() {return numWheels;}
}
public class PatternMatchingForSwitch {
public static void patternMatchingSwitch(Vehicle v) {
System.out.println(
switch (v) {
case Car b -> "It's a Car";
case Truck t -> "It's a Truck";
case Motorcycle c when c.getNumWheels() == 2 -> "It's a Classic Motorcycle: ";
case Motorcycle c when c.getNumWheels() == 3 -> "It's a Trike Motorcycle: ";
case null, default -> "Invalid type";
}
);
}
}

Selector Expression Type Extended:

record R(){}
enum E{FIRST, THE_BEST}
public class SelectorExpressionTypeExtended {
public static void main(String[] args) {
selectorType("Milan Karajovic"); selectorType(new R());
selectorType(E.FIRST); selectorType(null);
selectorType(new double[]{2.1, 3.5}); selectorType(2);
}
public static void selectorType(Object obj){
System.out.println(
switch(obj){
case String s1 -> "String";
case R r -> "Record";
case E.FIRST -> "Enum First";
case E.THE_BEST -> "Enum The Best";
case null -> "null";
case double[] array -> "double array";
default -> "others";
}
);
}
}

Z Garbage Collector (ZGC)

Z Garbage Collector (ZGC) is introduced in Java 12 and made production-ready in Java 14. It is more improved in Java 21

In Java 21 ZGC is more improved and now is used for ultra-low-latency applications. ZGC enhances Java’s low-latency garbage collector by introducing generational memory management. It separates objects into young and old generations, optimizing memory allocation and collection for better performance.

Why it is practical?

Generational ZGC is ideal for latency-sensitive applications, such as real-time systems or microservices, where pauses during garbage collection must be minimized. It improves throughput and reduces memory overhead.

How to use?

We can enable Generational ZGC with the following JVM flags:

-XX:+UseZGC -XX:+ZGenerational

Benefits:

Low Latency: Sub-millisecond pause times for garbage collection.
Scalability: Handles large heaps efficiently.
Ease of Use: Minimal configuration required for most applications.

String Literal (String Template)

Java offers several mechanisms for composing strings with string literals and expressions. These are:

String concatenation
StringBuilder class,
String class format() method
MessageFormat class.

Java 21 introduces as preview feature (explicitly enable preview feature: — enable-preview)(regularly included from Java 22) String Templates. These complement Java’s existing string literals and text blocks by coupling literal text with template expressions and template processors to produce the desired results.

Example:

String firstName = "Milan";
String lastName = "Karajovic";
String person = STR."{ \"firstName\": \"\{firstName}\", \"lastName\": \{lastName} }";
System.out.println(person);

STR is Template processor

String templates reduce errors in string construction, such as SQL injection or formatting issues, and improve code readability. They’re ideal for generating dynamic content like JSON, HTML, or SQL queries.

Sequenced Collections

APIs are defined for accessing first/last elements and also for processing elements in reverse order.

New interfaces are defined for:

Sequenced Collections
Sequenced Sets
Sequenced Maps

Why Sequenced Collections?

This feature standardizes collection operations, making code more consistent across different collection types. It’s particularly useful for algorithms that rely on ordered data, such as queues or stacks.

Sequenced Collection:

public interface SequencedCollection<E> extends Collection<E> {
// new method
SequencedCollection<E> reversed();
// methods promoted from Deque
default void addFirst(E e);
default void addLast(E e);
default E getFirst();
default E getLast();
default E removeFirst();
default E removeLast();
}

Sequenced Set:

public interface SequencedSet<E> extends SequencedCollection<E>, Set<E> {
// new method
SequencedSet<E> reversed();
}

Sequenced Map:

public interface SequencedMap<K, V> extends Map<K, V> {
// new methods
SequencedMap<K, V> reversed();
default SequencedSet<K> sequencedKeySet();
default SequencedCollection<V> sequencedValues();
default SequencedSet<Map.Entry<K, V>> sequencedEntrySet();
default V putFirst(K k, V v);
default V putLast(K k, V v);
// methods promoted from NavigableMap
default Map.Entry<K,V> firstEntry();
default Map.Entry<K,V> lastEntry();
default Map.Entry<K,V> pollFirstEntry();
default Map.Entry<K,V> pollLastEntry();
}

Benefits:

Consistency: Uniform methods across ordered collections.
Simplicity: Intuitive methods for common operations like accessing the first or last element.
Flexibility: Works with existing collection implementations.

Contact and support

author: Milan Karajovic
Portfolio: milan.karajovic.rs

Follow me on LinkedIn: https://lnkd.in/e3cH854Q

Virtual Threads in Java 21 comparing with Cached Thread and Fixed Thread

Milan Karajovic — Mon, 28 Jul 2025 20:18:53 +0000

This example demonstrates the advantage of virtual threads introduced in Java 21 over other methods of executing tasks in threads.

Introduction

Starting from Java 8, concurrent programming is a lot of improved. Introduced two important parts of the Concurrent API: Atomic Variable and Concurrent Maps. Also, in Java 8 concurrent programming, are introduced lambda expression and functional programming. In short line, improvements in Java 8 are:
• Threads and Executors
• Synchronization and Locks
• Atomic Variables and ConcurrentMap

Java 21 brings several new features. Some of them are listed in the picture bellow:

Probably, the most important feature in Java 21 are Virtual Threads.

In Java 21 the basic concurrence model of Java is unchanged and the Stream API is still the preferred way to process large data sets in parallel.

Using Virtual Threads, introduced in Java 21, concurrent API has better performance. Today, we have microservices architecture and server application scales, and that will cause the number of threads must grow. A main goal of virtual threads is to enable scalability of server applications written in the simple thread-per-request style.

Virtual Threads

Before Java 21, the JDK’s current implementation of threads implements threads as thin wrappers around operating system (OS) threads. However, as OS threads are expensive:

if each request consumes an OS thread for its duration, then the number of threads often becomes the limiting factor when attempting to scale.
thus, an application's throughput is capped even when thread pooling is employed (given that pooling does not increase the actual number of threads). The goal is to break this 1:1 relationship between Java threads and OS threads. Virtual thread using the idea applied in Virtual Ram memory. Illusion of plentiful memory is applied mapping a large virtual address space to limited amount of the physical RAM. Similarly, the Java runtime can give the illusion of plentiful threads by mapping a large number of virtual threads to a small number of OS threads. Platform threads, implemented in the traditional way, are thin-wrapper around an OS thread. Virtual threads are not tied to any particular OS thread. A virtual thread can run any code that a platform thread can run. It is good, because existing Java code that processes requests will easily run in a virtual thread. Virtual threads exist on platform threads. These platform threads (“carriers”) are then scheduled by the OS as usual.

For example, executor with a Virtual thread you can create like this:

ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

Example with comparison

Virtual threads only consume OS threads while performing calculations on the CPU. A virtual thread can be mounted/unmounted on different carriers over the course of its lifetime. Typically, a virtual thread will unmount when it blocks (e.g. an I/O or database operation). When the blocking operation is completed, the virtual thread is mounted on any available carrier. The mounting and unmounting of virtual threads happens frequently and transparently without blocking any OS threads.

Example – Source code

Example01CachedThreadPool.java Executor is created using Cached Thread Pool:

var executor = Executors.newCachedThreadPool()

package threads;

import java.time.Duration;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;

/**
 *
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

public class Example01CachedThreadPool {

    public void executeTasks(final int NUMBER_OF_TASKS) {

        final int BLOCKING_CALL = 1;
        System.out.println("Number of tasks which executed using 'newCachedThreadPool()' " + NUMBER_OF_TASKS + " tasks each.");

        long startTime = System.currentTimeMillis();

        try (var executor = Executors.newCachedThreadPool()) {

            IntStream.range(0, NUMBER_OF_TASKS).forEach(i -> {
                executor.submit(() -> {
                    // simulate a blicking call (e.g. I/O or db operation)
                    Thread.sleep(Duration.ofSeconds(BLOCKING_CALL));
                    return i;
                });
            });

        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        long endTime = System.currentTimeMillis();
        System.out.println("For executing " + NUMBER_OF_TASKS + " tasks duration is: " + (endTime - startTime) + " ms");
    }

}

package threads;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;

/**
 *
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class Example01CachedThreadPoolTest {

    @Test
    @Order(1)
    public void test_1000_tasks() {
        Example01CachedThreadPool example01CachedThreadPool = new Example01CachedThreadPool();
        example01CachedThreadPool.executeTasks(1000);
    }

    @Test
    @Order(2)
    public void test_10_000_tasks() {
        Example01CachedThreadPool example01CachedThreadPool = new Example01CachedThreadPool();
        example01CachedThreadPool.executeTasks(10_000);
    }

    @Test
    @Order(3)
    public void test_100_000_tasks() {
        Example01CachedThreadPool example01CachedThreadPool = new Example01CachedThreadPool();
        example01CachedThreadPool.executeTasks(100_000);
    }

    @Test
    @Order(4)
    public void test_1_000_000_tasks() {
        Example01CachedThreadPool example01CachedThreadPool = new Example01CachedThreadPool();
        example01CachedThreadPool.executeTasks(1_000_000);
    }

}

Test results on my PC:

Example02FixedThreadPool.java Executor is created using Fixed Thread Pool:

var executor = Executors.newFixedThreadPool(500)

package threads;

import java.time.Duration;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;

/**
 *
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

public class Example02FixedThreadPool {

    public void executeTasks(final int NUMBER_OF_TASKS) {

        final int BLOCKING_CALL = 1;
        System.out.println("Number of tasks which executed using 'newFixedThreadPool(500)' " + NUMBER_OF_TASKS + " tasks each.");

        long startTime = System.currentTimeMillis();

        try (var executor = Executors.newFixedThreadPool(500)) {

            IntStream.range(0, NUMBER_OF_TASKS).forEach(i -> {
               executor.submit(() -> {
                   // simulate a blicking call (e.g. I/O or db operation)
                  Thread.sleep(Duration.ofSeconds(BLOCKING_CALL));
                  return i;
               });
            });

        }   catch (Exception e) {
            throw new RuntimeException(e);
        }

        long endTime = System.currentTimeMillis();
        System.out.println("For executing " + NUMBER_OF_TASKS + " tasks duration is: " + (endTime - startTime) + " ms");
    }

}

package threads;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;

/**
 *
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class Example02FixedThreadPoolTest {

    @Test
    @Order(1)
    public void test_1000_tasks() {
        Example02FixedThreadPool example02FixedThreadPool = new Example02FixedThreadPool();
        example02FixedThreadPool.executeTasks(1000);
    }

    @Test
    @Order(2)
    public void test_10_000_tasks() {
        Example02FixedThreadPool example02FixedThreadPool = new Example02FixedThreadPool();
        example02FixedThreadPool.executeTasks(10_000);
    }

    @Test
    @Order(3)
    public void test_100_000_tasks() {
        Example02FixedThreadPool example02FixedThreadPool = new Example02FixedThreadPool();
        example02FixedThreadPool.executeTasks(100_000);
    }

    @Test
    @Order(4)
    public void test_1_000_000_tasks() {
        Example02FixedThreadPool example02FixedThreadPool = new Example02FixedThreadPool();
        example02FixedThreadPool.executeTasks(1_000_000);
    }

}

Test results on my PC:

Example03VirtualThread.java Executor is created using Virtual Thread Per Task Executor:

var executor = Executors.newVirtualThreadPerTaskExecutor()

package threads;

import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;

/**
 *
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

public class Example03VirtualThread {

    public void executeTasks(final int NUMBER_OF_TASKS) {

        final int BLOCKING_CALL = 1;
        System.out.println("Number of tasks which executed using 'newVirtualThreadPerTaskExecutor()' " + NUMBER_OF_TASKS + " tasks each.");

        long startTime = System.currentTimeMillis();

        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {

            IntStream.range(0, NUMBER_OF_TASKS).forEach(i -> {
               executor.submit(() -> {
                   // simulate a blicking call (e.g. I/O or db operation)
                  Thread.sleep(Duration.ofSeconds(BLOCKING_CALL));
                  return i;
               });
            });

        }   catch (Exception e) {
            throw new RuntimeException(e);
        }

        long endTime = System.currentTimeMillis();
        System.out.println("For executing " + NUMBER_OF_TASKS + " tasks duration is: " + (endTime - startTime) + " ms");
    }

}

package threads;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;

/**
 *
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class Example03VirtualThreadTest {

    @Test
    @Order(1)
    public void test_1000_tasks() {
        Example03VirtualThread example03VirtualThread = new Example03VirtualThread();
        example03VirtualThread.executeTasks(1000);
    }

    @Test
    @Order(2)
    public void test_10_000_tasks() {
        Example03VirtualThread example03VirtualThread = new Example03VirtualThread();
        example03VirtualThread.executeTasks(10_000);
    }

    @Test
    @Order(3)
    public void test_100_000_tasks() {
        Example03VirtualThread example03VirtualThread = new Example03VirtualThread();
        example03VirtualThread.executeTasks(100_000);
    }

    @Test
    @Order(4)
    public void test_1_000_000_tasks() {
        Example03VirtualThread example03VirtualThread = new Example03VirtualThread();
        example03VirtualThread.executeTasks(1_000_000);
    }

    @Test
    @Order(5)
    public void test_2_000_000_tasks() {
        Example03VirtualThread example03VirtualThread = new Example03VirtualThread();
        example03VirtualThread.executeTasks(2_000_000);
    }

}

Test results on my PC:

You see clear difference between the duration time in ms which different implementation of the executor spent to process all NUMBER_OF_TASKS. Also, you can experiment with different values for NUMBER_OF_TASKS. _We can see clear difference when we have big value for the NUMBER_OF_TASKS, how faster virtual threads process big value of the number of the tasks. _
The difference is very obvious when we have 1_000_000 tasks. It is shown in the table below:

Conclusion

I am sure, after this clarification, if your application process a lot of tasks using concurrent API, you will definitely move on Java 21 and start to use virtual threads, which will in many ways improve performance of your application.

Source code: https://github.com/Milan-Karajovic/comparing-threads-Java21-with-Virtual-Threads

Contact and support

author: Milan Karajovic
Portfolio: milan.karajovic.rs

GitHub: https://github.com/Milan-Karajovic/comparing-threads-Java21-with-Virtual-Threads

Follow me on LinkedIn: https://lnkd.in/dYGUKR3C

How to improve Software Architecture in a Cloud Environment?

Milan Karajovic — Thu, 03 Apr 2025 14:28:33 +0000

About this article

The need for software architecture today has grown more critical due to the increasing complexity, scale, and expectations of modern software systems. Applications today aren't simple. They involve multiple layers: frontend, backend, databases, integrations, microservices, and sometimes even AI/ML components. A strong architecture provides a roadmap for organizing this complexity into manageable pieces, making it easier to develop, maintain, and scale.

This article explains how we can improve the existing architecture on a project to make it more robust and powerful for all of today's challenges.

Introduction

When creating an architecture for any application, the first step is to understand the requirements, formal description of what we need to build. Types of requirements are:

Functional requirements — Features of the system
Non-Functional requirements — Quality Attributes
System Constrains — Limitations and boundaries

For each of these requirements, there is a detailed procedure for developing the architecture, on which I will not focus now.

Also, regarding to the requirements of the app which you create, you can use one of the software architecture patterns:

Two — Tier Architecture (Mobile app, Desktop App)
Multi - Tier Architecture (Monolithic app with API Gateway or without API Gateway)
Microservices Architecture
Event - Driven Architecture

Existing application

Now, we can focus on an example of how we can improve the software architecture of an existing application, which is the goal of this text.

Let's assume we have an existing app similar to Instagram ( https://www.instagram.com/ ), Tripadwisor ( https://www.tripadvisor.com/ ) or Tik Tok ( https://www.tiktok.com/ ).

A user can sign up and login to post, vote, or comment( Title, Topic tags, Body (text and/or upload images and/or upload files))
A user should be able to comment on any existing post
Comments are ordered chronologically as a flat list
Logged-in user can up-vote/down-vote an existing post/comment.
Present the top most popular posts in the last 24 hours on the homepage.

Current implementation of the app looks like it is presented on the next architecture diagram:

Web App Service - A central service that provides web pages that cover part of the content presentation application
Users Service - Used for creating and login user
Post & Comments Service - Used for creation and storing posts and comment
Ranking Service - Efficient ranking of posts by popularity in the last 24 hours
Votes Service - Service which stores voting

We will consider non-functional requirements that relate to the quality of our application in a real-world application usage environment. These are Non-Functional Requirements for this application:

Scalability (app should support millions of daily users)
Performance (it will be expected to be less than 500ms Response time at 99%)
Fault Tolerance/ High Availability (99,9%)
Availability - Partition Tolerance (We gave priority for "Availability - Partition Tolerance" over "Consistency - Partition Tolerance"; It is not possible to have Availability and Consistency at the same time)
Durability

Question is: "How to improve current architecture and cover required Non-Functional Requirements?!"

It can be easy, if we go step by step and solve all requirements one by one.

Scalability

How can we improve scalability? We can place a Load Balancer in front of the web app service and each one of the other services. This will help us scale out our system, depending on the traffic to our system and each service independently.

Then we can place an API Gateway to decouple the frontend code from the system's internal structure. This will allow us to make changes internally and increase our organizational scalability.

On the posts and comments database side, as we store more posts and comments, our database instance may run out of space. It also may not be able to handle the traffic from so many users.
So the solution will be sharding our posts and comments collection across different database shards. Database sharding is the process of storing a large database across multiple machines. A single machine, or database server, can store and process only a limited amount of data. Database sharding overcomes this limitation by splitting data into smaller chunks, called shards, and storing them across several database servers. All database servers usually have the same underlying technologies, and they work together to store and process large volumes of data. This way we can scale to as many posts or comments as we want to, by adding more instances and distributing our data across all those instances.
We will use a range sharding strategy which many NoSQL databases support. Range-based sharding involves dividing data into contiguous ranges determined by the shard key values. In this model, documents with "close" shard key values are likely to be in the same chunk or shard. This allows for efficient queries where reads target documents within a contiguous range.
The best solution for range sharding strategy in our case is to use sharding on a compound index of a post ID and the comment ID.

In the worst case, the same post will be located in the two Shareds, like it is shown in the picture below:

Performance

One potential performance bottleneck is image blob store. Every time a user loads a post of a news feed with the most popular posts, we need to load images from our system. So, loading those images on the browser can definitely add a lot of latency.

To solve this problem, we can utilize a global network of CDN servers. A content delivery network (CDN) is a geographically distributed group of servers that caches content close to end users. A CDN allows for the quick transfer of assets needed for loading Internet content, including HTML pages, JavaScript files, stylesheets, images, and videos.

By using a pull model with long TTL (Time to live - refers to the amount of time or "hops" that a packet is set to exist inside a network before being discarded by a router.), images of popular posts will be distributed among those seed and edge servers, which are located very close to users in different geographical locations. A few popular CDN solutions are Cloudflare CDN, AWS Cloudfront, GCP Cloud CDN, Azure CDN and Oracle CDN. This reduces the traffic load on our system and also reduces the page load time for the users significantly.

On the API gateway level, we can introduce Cashing at peak times when a small group of posts is viewed by many users simultaneously, we can store those posts in a cache and update this cache every few minutes. We can store those posts in a cache and update this cache every few minutes. This will also reduce the response the response time to our users and goes hand in hand with our decision to prioritize availability over consistency.

For example, also we can add an Index on the post ID which will make searching for a particular post in a constant time instead of scanning through all our collection of posts.

Similarly, we can use the same compound index we created for Sharding the comments using the post ID and comments ID. This way, requesting a batch of comments for a given post will also be much faster. Of course, we can also use indexing for the other databases.

When a user comes to votes, we also have a performance problem here. As we recall, the votes are stored in the vote service database as individual records for each vote. However, when we show a post or a comment in the UI, we want to show the overall total number of up votes and down votes for each entity. So what we can do is introduce a Message Broker between the voting service and the post and comment. Additionally, we can add two fields in the post in comments collections. One for total up votes and one for total down votes. So any time a user up votes or down votes opposed, the voting service will add that entry to its own database and publish it as an event to the post and comments service. Then the Post and Comments Service can consume this event and update the total numbers of up votes for a given post which will store with the post record. This approach really helps if we have a short but sudden traffic spike when many people start voting on the same post or several post simultaneously, since we can buffer those votes in the message broker and we can make those updates slowly and complete them after that traffic spike is over. Of course, during this transition, users will not get the most up to date values for the total number of up votes or down votes, but that's okay because we prioritized availability over consistency when we gather our nonfunctional requirement.

Finally, now that we have the total number of up votes and down votes stored together with each post and comment, we can load that data easily and efficiently to the user.

Fault Tolerance/ High Availability (99.9%)

To ensure we don't lose any data, we can introduce database replication if a database instance or database shard crashes. Similarly, every message broker data store and micro service is replicated, adding to our overall system's full tolerance.

In addition, we can run our system across multiple data centers in different geographical locations and utilize a global load balancing service. This way, we can always fall over to another region if there is a natural disaster in one of those regions. Of course, as an added benefit, this also improves our performance as our system gets physically closer to our users on different continents.

The following image shows a situation where the closest server is unavailable to the user. In this situation, the user contacts the second closest server that is available.

Availability + Partition Tolerance (AP over CP)

In our architecture we prioritize availability over consistency when it comes to data.

Durability

Replication and Backups

Using database replication across multiple instances and data centers, as well as rolling backups, we guaranteed durability so our system never loses any data.

Additional - Possible implementation

Load Balancing Solutions

Open Source Software Load Balancing Solutions:

HAProxy
NGINX

Cloud Based Load Balancing Solutions:

AWS - Elastic Load Balancing (ELB):
Application (Layer 7) Load Balancer
Network (Layer 4) Load Balancer
Gateway Load Balancer
Classic Load Balancer
GCP - Cloud Load Balancing:
External HTTP(S) Load Balancer
Internal HTTP(S) Load Balancer
External TCP/UDP Network Load Balancer
Internal TCP/UDP Load Balancer
Microsoft Azure Load Balancer:
Standard Load Balancer
Gateway Load Balancer
Basic Load Balancer

Gateway

Open Source API Gateways

Netflix Zuul

Cloud - Base API Gateways

Amazon API Gateway
Google Cloud Platform API Gateway:
Google Cloud Platform API Gateway
Apigee
Microsoft Azure API Management

CDN

Cloudflare
Fastly
Akamai
Amazon CloudFront
Google Cloud Platform CDN
Microsoft Azure Content Delivery Network

Message Broker

Open Source Message Broker

Apache Kafka
RabbitMQ

Cloud Based Message Brokers

Amazon AWS:
Amazon Simple Queue Service (SQS)
Google Cloud:
GCP Pub/Sub and Cloud Tasks
Microsoft Azure:
Service Bus
Event Hubs
Event Grid

Contact and support

author: Milan Karajovic
Portfolio: milan.karajovic.rs
Follow me on LinkedIn: https://lnkd.in/dYGUKR3C

DGS GraphQL & Spring Boot

Milan Karajovic — Thu, 03 Apr 2025 14:27:59 +0000

Why GraphQL?

GraphQL provides a powerful layer to unify data from various backend sources, including databases, REST APIs, and microservices, into a single, consistent API. It enables the creation of flexible APIs that can evolve with changing client applications.

Introduction

This article will show you how to create an effective application that implements GraphQL using the Netflix DGS framework in the Spring Boot application.

Netflix DGS is an annotation-based GraphQL Java library built on top of Spring Boot. With Netflix DGS is allowed generating source code from GraphQL schemas. It simplifies writing unit tests and also supports websockets, file uploads, or GraphQL federation.

Tech Stack

Java 17
Spring Boot 3.4.3
Netflix DGS GraphQL 10.0.4
JPA
Maven
Lombok
JUnit
H2 Database

Application development and analysis

Create spring Boot applciation using Spring Initializr. Setup is shown on the picture below:

In this picture we can see all dependencies which we need to include in the graphql-spring-boot project. For the database we will use inmemory H2 Database. Here’s a list of required dependencies in Maven pom.xml:

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>com.netflix.graphql.dgs</groupId>
    <artifactId>graphql-dgs-spring-graphql-starter</artifactId>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
  </dependency>
  <dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
  </dependency>
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>com.netflix.graphql.dgs</groupId>
    <artifactId>graphql-dgs-spring-graphql-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

Grapql schema

A schema may be defined in multiple graphqls files, but all of them have to be placed inside the /src/main/resources/schemas directory. The Netflix DGS library detects and loads them automatically.

"""
Sample user account container class.
"""
type User {
    "Sequential identifier"
    id: ID!
    "User's first & last name"
    name: String!
    "User's email"
    email: String
}

"""
User creation input
"""
input CreateUserInput {
    "User's first & last name"
    name: String
    "User's email"
    email: String
}

"""
User modification input
"""
input UpdateUserInput {
    "User's first & last name"
    name: String
    "User's email"
    email: String
}

"""
User object queries
"""
type Query {
    user(id: ID!): User
    users: [User]!
}

"""
User object modifications
"""
type Mutation {
    createUser(input: CreateUserInput!): User!
    updateUser(id: ID!, input: UpdateUserInput!): User!
    deleteUser(id: ID!): User!
}

The DGS framework is designed for schema first development. The framework picks up any schema files in the src/main/resources/schema folder. We created schema file schema.graphql. In this file are defined types, queries and mutations. Regarding this class we create classes in specific packages in the application.

It is possible using DGS plugin to generated Java source code using previously defined GraphQL schemas. However, I prefer to use Lombok annotations, so I did that manually.

Application structure

This is application structure:

Implementation

The most important clases are:

Domain ( /graphql-spring-boot/src/main/java/rs/karajovic/milan/graphql_spring_boot/domain ):

Thera are defined domain object which exists in the above mentioned file src/main/resources/schema.

Repository ( /graphql-spring-boot/src/main/java/rs/karajovic/milan/graphql_spring_boot/repository ):

Thera are defined JPA repository which is used from the application to communicate with databse.

Service ( /graphql-spring-boot/src/main/java/rs/karajovic/milan/graphql_spring_boot/service ):

Service is layer which is between fatcher and repository.

Fetcher ( /graphql-spring-boot/src/main/java/rs/karajovic/milan/graphql_spring_boot/fetcher ):
(This is central part of the DGS GraphQL application. There are defined Queries and Mutations regarding to the declaration in the schema.graphql file)

Netflix DGS provides annotation-based support for Spring Boot.
The UserFetcher is responsible for defining queries related to the User object. We should annotate such a class with @DgsComponent . Then, we have to annotate every query method with @DgsData. The fields parentType and fields should match the names declared in GraphQL schemas for Queries. We can see that in the file schema.graphql are defined two queries, so we have two methods inside UserFetcher. To fetch data from the database are used methodes from the Service class. The last query method findUserById performs advanced filtering based on the user id field passed in the input. To pass an input parameter we should annotate the method argument with @InputArgument.

package rs.karajovic.milan.graphql_spring_boot.fetcher;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import com.netflix.graphql.dgs.DgsComponent;
import com.netflix.graphql.dgs.DgsData;
import com.netflix.graphql.dgs.InputArgument;

import rs.karajovic.milan.graphql_spring_boot.domain.User;
import rs.karajovic.milan.graphql_spring_boot.service.UserService;

/**
 * 
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

@DgsComponent
public class UserFetcher {

    @Autowired
    UserService userService;


    @DgsData(parentType = "Query", field = "users")
    public List<User> findAllUsers() {
        return userService.findAll();
    }

    @DgsData(parentType = "Query", field = "user")
    public User findUserById(@InputArgument("id") Integer id) {
        return userService.findUserById(id);
    }

}

In comparison to the UserFetcher, UserMutation implementation is similar. The fields parentType and fields should match the names declared in GraphQL schemas for Mutations. To pass an input parameter we should annotate the method argument with @InputArgument. To execute Muttaion methodes are used methodes from the Service class.

package rs.karajovic.milan.graphql_spring_boot.fetcher;

import org.springframework.beans.factory.annotation.Autowired;


import com.netflix.graphql.dgs.DgsComponent;
import com.netflix.graphql.dgs.DgsData;
import com.netflix.graphql.dgs.InputArgument;

import jakarta.validation.Valid;
import rs.karajovic.milan.graphql_spring_boot.domain.CreateUserInput;
import rs.karajovic.milan.graphql_spring_boot.domain.UpdateUserInput;
import rs.karajovic.milan.graphql_spring_boot.domain.User;
import rs.karajovic.milan.graphql_spring_boot.service.UserService;

/**
 * 
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

@DgsComponent
public class UserMutation {

    @Autowired
    UserService userService;

    @DgsData(parentType = "Mutation", field = "createUser")
    public User createUser(@InputArgument("input") CreateUserInput userInput) {
        return userService.save(new User(null, userInput.getName(), userInput.getEmail()));
    }

    @DgsData(parentType = "Mutation", field = "updateUser")
    public User updateUser(@InputArgument("id") Integer id, @Valid @InputArgument("input") UpdateUserInput userInput) {
        return userService.updateUser(id, userInput.getName(), userInput.getEmail());
    }

    @DgsData(parentType = "Mutation", field = "deleteUser")
    public User deleteUser(@InputArgument("id") Integer id) {
        return userService.deleteUserById(id);
    }

}

Database
For this demo application is used inmemory H2 database. Configuration for the database is in the application.properties file. data.sql script is used for initial filing database with data.

Tests
Tests are in the /graphql-spring-boot/src/test/java/rs/karajovic/milan/graphql_spring_boot/fetcher . There are tests for the Queries and Mutations.

Run application in your development environment

Run spring boot application in your development environment:

Access to the H2 database:

http://localhost:8080/h2-console

Access to the GraphiQL dashboard:

http://localhost:8080/graphiql

Build, and run application using Docker

Prerequisite is to have installed Docker on your machine.
Download source code for this exaple from the Github.
Build the application using Maven (For building I suggest to use STS or intelliJ IDEA development environment. However, you can do that also manually with maven command).

mvn clean install

The .jar file is created in the folder:

/graphql-spring-boot/target/graphql-spring-boot-0.0.1-SNAPSHOT.jar

Using Docker file, we create image graphql-spring-boot using next command in the console (It is necessary to open the console in the root folder of the project). The command is:

docker image build -t graphql-spring-boot .

Now, we can start appliciaton using docker-compose.yaml file. (It is necessary to open the console in the root folder of the project). The command is:

docker-compose up

Now we can access to the GraphiQL dashboard with:

http://localhost/graphiql

After application is success started, let’s just use the GraphiQL tool to run test queries. It is automatically included in the application by the Netflix DGS library. We may display it by invoking the URL

GraphiQL dashboard

GraphQL tool dashboard. There are all Queries and Mutations:

Show all users in database using Query:

Crete user using Mutation:

Show all users after created new user in the previous step:

Delete user by id:

You can check all Queries and Mutation yourself using this dashboard.

Source code: https://github.com/Milan-Karajovic/GraphQL-SpringBoot

Contact and support

author: Milan Karajovic
Portfolio: https://milan.karajovic.rs/
GitHub: https://github.com/Milan-Karajovic/GraphQL-SpringBoot
Follow me on LinkedIn: https://lnkd.in/dYGUKR3C

AWS SNS (Amazon Simple Notification Service) & Spring Boot with Email as subscriber

Milan Karajovic — Thu, 03 Apr 2025 14:27:32 +0000

Introduction

The concepts of "topic" and "subscribe" are often linked, especially in contexts like messaging systems, event-driven architectures, or content platforms.

Publisher: This is the source or entity that produces messages or events. The publisher doesn't need to know who will consume its messages.
Topic: This acts as a channel or intermediary that categorizes messages. Publishers post messages to specific topics, and subscribers listen to those topics. It's used in systems like message brokers (e.g., RabbitMQ, AWS SNS, Apache Kafka) to allow publishers to send messages without worrying about who will receive them.
Subscriber: These are the entities that consume the messages from the topics they're interested in. Subscribers can dynamically choose topics to receive only the information they need.

Amazon SNS (Simple Notification Service) topic

Amazon SNS provides message delivery from publishers to subscribers using the pub/sub pattern. Publishers send messages to an SNS topic, and subscribers receive those messages through their chosen endpoints.
Topic Types: SNS supports two types of topics:

Standard Topics: Allow high throughput and best-effort message ordering at least one message delivery
FIFO Topics: Ensure message order and exactly-once message delivery. Subscribers can be other applications, an Amazon SQS queue, AWS lambda function, or HTTPS endpoint… We can see that in the picture bellow:

Create Topic and Subscribe on the topic

Create User in IAM
On the AWS dashboard choose service IAM (Manage access to AWS resources)
Create user or use existed user

For created user add for Permission policies: AmazonSNSFullAccess
On the card Security credentials, you can see option Access Keyes (access key - go to the process where you will create user_accessKeys.csv. In this file, you can see Access key ID and Secret access key. These values you will use in the spring Boot application, in the file: AppListener.java(/spring-boot-aws-sns/src/main/java/rs/karajovic/milan/config/AppListener.java))

Create topic in Amazon SNS
On the AWS dashboard choose Amazon SNS (Simple Notification Service) -> Go to link Topics -> Create topic:

Standard
Give name for topic
Create topic

Subscribe on the topic
Go to link Topics -> Choose created topic -> Create subscription:

There you can see Topic ARN
Also, you can see different protocols: Amazon Kinesis Data Firehose, Amazon SQS, AWS Lambda, Email, Email-JSON, HTTP, HTTPS, Platform application endpoint, SMS. For our demo, we will choose: Email-JSON.

When you choose Topics, and click on your topic, you can see fields: Name and ARN. Content of these fields you will use in the project, in the file: application.properties (/spring-boot-aws-sns/src/main/resources/application.properties)

Tech Stack

Java 17
SNS Amazon-AWSSDK
JPA
Maven
Lombok
JUnit
IAM
SNS (Simple Notification Service) Create spring Boot application using Spring Initializr using specific dependencies which are shown in the pom.xml

<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

<dependency>
  <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
</dependency>

<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>sns</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
</dependency>

Allow the application to connect to AWS

Create application listener in which is need to set up an AWS access key and secret key in the Java system properties, so the app is able to connect to AWS. We got these properties in the step of creating a context in IAM, which was explained in the step before.

package rs.karajovic.milan.config;

import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;
import org.springframework.context.ApplicationListener;

/**
 * 
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

public class AppListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent applicationEnvironmentPreparedEvent) {

        // accessKeyId & for AWS user
        System.setProperty("aws.accessKeyId", "fill with accessKeyId & for AWS user");
        // secretAccessKey for AWS user
        System.setProperty("aws.secretAccessKey", "fill with secretAccessKey for AWS user");

    }
}

Application listener should be added to the application.

@SpringBootApplication
public class SpringBootAwsSns {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(SpringBootAwsSns.class);
        app.addListeners(new AppListener());
        app.run(args);
    }
}

Set up SNS properties

In application.properties set values for aws-sns region and topicArn. We got these properties in the step of creating topic in Amazon SNS, which was explained in the step before.

#### AWS ### -
aws.sns.region=fill with region where you crated sns
aws.sns.topicArn=fill with created arn for test-top-arn

management.endpoints.web.exposure.include=*

Configuration SNS Client

Now we need to configure the SNS Client that will publish messages to the topic. We created a class that reads the AWS SNS properties from the properties file. It is in the class /spring-boot-aws-sns/src/main/java/rs/karajovic/milan/config/AwsProperties.java.

package rs.karajovic.milan.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotNull;

/**
 * 
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

@Configuration
@ConfigurationProperties(prefix = "aws.sns")
public class AwsProperties {

    @Getter @Setter
    @NotNull
    private String region;

    @Getter @Setter
    @NotNull
    private String topicArn;


}

Then, configure an SNS Client with the appropriate region.

package rs.karajovic.milan.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;

/**
 * 
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

@Configuration
public class SnsConfig {

    @Autowired
    private AwsProperties awsProperties;

    @Bean
    public SnsClient snsClient() {
        return SnsClient.builder()
                .region(Region.of(awsProperties.getRegion()))
                .build();
    }
}

Build a message with a message attributes

In our scenario, subscribers to the topic wish to receive notifications about changes in temperature, whether it increases or decreases. Create the Message class to specify the attributes that are relevant to these subscribers.

package rs.karajovic.milan.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;

/**
 * 
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

@Configuration
public class SnsConfig {

    @Autowired
    private AwsProperties awsProperties;

    @Bean
    public SnsClient snsClient() {
        return SnsClient.builder()
                .region(Region.of(awsProperties.getRegion()))
                .build();
    }
}

package rs.karajovic.milan.model;

/**
 * 
 * @author Milan Karajovic <milan.karajovic.rs@gmail.com>
 *
 */

public enum EventType {
    DROP, INCREASE
}

Next, we create a builder that constructs an Amazon PublishRequest object from a given message. This message leverages Amazon SNS message attributes, which allow for greater flexibility. One key advantage of using these attributes is that they enable subscribers to filter their subscriptions based on specific attributes, ensuring they only receive the notifications that are relevant to their interests.

public class RequestBuilder {
  public static final String COUNTRY = "Country";
  public static final String REGION = "Region";
  public static final String EVENT_TYPE = "EventType";
  public static final String CITY = "City";
  public static final String NEW_TEMPERATURE = "NewTemperature";
  public static final String DEFAULT_MESSAGE_BODY = "Please see attributes.";


  public static PublishRequest build(String topicArn, Message message) {
      Map<String, MessageAttributeValue> attributes = new HashMap<>();
      attributes.put(COUNTRY, buildAttribute(message.getCountry(), "String"));
      attributes.put(REGION, buildAttribute(message.getRegion(), "String"));
      attributes.put(EVENT_TYPE, buildAttribute(message.getEventType().toString(), "String"));
      attributes.put(CITY, buildAttribute(message.getCity(), "String"));
      attributes.put(NEW_TEMPERATURE, buildAttribute(message.getNewTemperature().toString(), "Number"));

      PublishRequest request = PublishRequest.builder()
              .topicArn(topicArn)
              .message(DEFAULT_MESSAGE_BODY)
              .messageAttributes(attributes)
              .build();

      return request;
  }

  private static MessageAttributeValue buildAttribute(String value, String dataType) {
      return MessageAttributeValue.builder()
              .dataType(dataType)
              .stringValue(value)
              .build();
  }
}

Publish a message

Create an endpoint that publishes a message to the specified topic. Upon execution, the endpoint provides the status code, the response message, and the unique message ID generated by Amazon SNS for the published message. In the event of an exception, the endpoint will return the corresponding status code along with the error message as received from Amazon SNS. The next step involves transforming the message into an Amazon PublishRequest and proceeding to publish it.

@RestController
public class MessageController {

  private final MessagePublisher messagePublisher;

  public MessageController(MessagePublisher messagePublisher) {
      this.messagePublisher = messagePublisher;
  }

  @PostMapping(value = "/publish")
  @ResponseStatus(HttpStatus.CREATED)
  public SnsResponse publishMessage(@RequestBody Message message) {
      return messagePublisher.publish(message);
  }

  @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  @ExceptionHandler(RuntimeException.class)
  private String handleException(RuntimeException e) {
      return e.getMessage();
  }
}

Also, we will create model SNS response which will be used to receive the response from the publish endpoint:

@NoArgsConstructor
@AllArgsConstructor
@Getter
@EqualsAndHashCode
public class SnsResponse {
    private Integer statusCode;
    private String message;
    private String publishedMessageId;

    @Override
    public String toString() {
        return "SnsResponse{statusCode=" + statusCode + 
               ", message='" + message + ''' + 
               ", publishedMessageId='" + publishedMessageId + "'}";
    }

}

The code handles various exceptions that Amazon SNS might throw, with SdkException handling as a general catch-all for other potential exceptions.

Send a message in SNS using local environment development tool

Run created Spring Boot app and send a message to the publish endpoint using Postman like it is shown in the picture:

The response body indicates that Amazon SNS returned a 200 status code along with the message “OK” and a message ID, verifying that the message was successfully published.

Check the email address that was subscribed to the topic earlier; you should find a notification from AWS there.

Docker & docker-compose

This spring boot application we can also dockerize. Tor that we are using the Dockerfile and docker-compose.yml files whic are in the root of the project.
Dockerfile:

When image is created, we start the container using docker-compose.yml file:
docker-compose.yml:

When the container is started, we can send a message to the publish endpoint using Postman like it is shown in the picture:

Source code: https://github.com/Milan-Karajovic/AWS-SNS-Spring-Boot

Contact and support

author: Milan Karajovic
Portfolio: https://milan.karajovic.rs/
GitHub: https://github.com/Milan-Karajovic/AWS-SNS-Spring-Boot
Follow me on LinkedIn: https://lnkd.in/dYGUKR3C