Java – Pauls Blog

A Bounded, Thread-Safe In-Memory Store for Java

Paul Sterl — Tue, 30 Dec 2025 14:55:43 +0000

Problem

In test scenarios or lightweight application components, there is a need for a simple, thread-safe, in-memory data store that can temporarily hold a limited number of objects. The store should be easy to use, avoid external dependencies (e.g., databases), support generation and use of unique identifiers as keys, and automatically evict the oldest entries when a predefined capacity is exceeded. This enables predictable memory usage while providing fast access to recently stored data.

Solution

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MemoryStore {

    private final Lock lock = new ReentrantLock();
    private final int maxElements;

    private final Map data = new LinkedHashMap<>() {
        // called during put and ensures the map doesn't grow
        @Override
        protected boolean removeEldestEntry(Map.Entry eldest) {
            return size() > maxElements;
        }
    };

    public MemoryStore(int maxElements) {
        if (maxElements < 1) {
            throw new IllegalArgumentException("maxElements must be > 1");
        }
        this.maxElements = maxElements;
    }
    
    public void store(T value) {
        this.store(UUID.randomUUID().toString(), value);
    }

    public void store(String key, T value) {
        lock.lock();
        try {
            data.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    public T get(String key) {
        lock.lock();
        try {
            return data.get(key);
        } finally {
            lock.unlock();
        }
    }
    
    public int size() {
        lock.lock();
        try {
            return data.size();
        } finally {
            lock.unlock();
        }
    }
    
    public LinkedHashMap data() {
        lock.lock();
        try {
            return new LinkedHashMap<>(this.data);
        } finally {
            lock.unlock();
        }
    }
}

Spring Persistent Tasks

Paul Sterl — Sun, 20 Apr 2025 07:16:43 +0000

A simple task management framework designed to queue and execute asynchronous tasks with support for database persistence and a user-friendly interface. It can be used to implement scheduling patterns or outbound patterns.

Focus is the usage with spring boot and JPA.

https://github.com/sterlp/spring-persistent-tasks

Key Features

JPA-Powered Persistence – Automatically persists tasks to your database
Spring Boot Auto-Configuration – Simple setup with @EnableSpringPersistentTasks
Clustering Support – Built-in lock management for distributed environments
Type-Safe Tasks – Generic task definitions with state objects
Retry Mechanisms – Automatic retry policies for failed executions
Transactional Integration – Works with Spring’s transaction management
Queue Management – Intelligent task queuing and prioritization
Different DB Supports
- MsSQL
- MariaDB
- Postgres

React & Spring Boot

Paul Sterl — Wed, 11 Dec 2024 18:36:41 +0000

Problem

We want to combine Spring Boot with a simple React frontend. Use the React development features but also be able to use the Spring IDE. In the end, everything should be built using Maven and nicely packed into a JAR, just like any other Microservice. Let’s get started.

Multi-Module project

First we create a spring project here backend folder and a react project in the frontend folder. The root pom should help us to build both projects in one run:

Root pom.xml


    4.0.0

    org.foo.bar
    project-root
    0.1.0-SNAPSHOT
    pom

    
        21
        ${java.version}
        ${java.version}
        UTF-8
        UTF-8
    

    
        frontend
        backend
    

  	
    
        
            
                org.springframework.boot
                spring-boot-dependencies
                3.3.6
                pom
                import

Backend pom.xml

This is straight forward the generated pom from spring with just the dependency to the frontend project.



    4.0.0
    
        org.foo.bar
        project-root
        0.1.0-SNAPSHOT
        ../pom.xml
    

    project-backend

    
      	
        
            org.foo.bar
            project-frontend
            ${project.version}
        
      	
      
        
            org.springframework.boot
            spring-boot-starter-web
          
        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

Frontend pom.xml

Now we have todo more stuff:

Ensure the dist result is added to the JAR
Generate during the generate-resources phase also the content for the dist folder
Ensure that during a mvn clean all gets deleted



    4.0.0
    
        org.foo.bar
        project-root
        0.1.0-SNAPSHOT
        ../pom.xml
    

    project-frontend
    
    
        
            org.springframework.boot
            spring-boot-starter-web
            provided
        
    
    
    
        
        
            
                dist
            
        

        
          	
            
                org.codehaus.mojo
                exec-maven-plugin
                3.5.0
                
                    
                        npm install
                        
                            exec
                        
                        generate-resources
                        
                            npm
                            
                                install
                                --prefer-offline
                                --no-audit
                                --progress=false
                            
                        
                    

                    
                        npm build
                        
                            exec
                        
                        generate-resources
                        
                            npm
                            
                                run
                                build
                            
                        
                    
                
            
            
            
                org.apache.maven.plugins
                maven-clean-plugin
                3.4.0
                
                    
                        
                            node_modules
                        
                        
                            dist

Ensure the result in the dist folder is compatible to Spring

Spring will pick up automatically any static resources which are placed in the static folder. Here is an example for vite to do so in the vite.config.js:

export default defineConfig({
  plugins: [react()],
  build: {
    outDir: './dist/static',
    emptyOutDir: true, // also necessary
  }
})

Going beyond

Sometime it is useful to host the UI in a sub path lets say my-ui, so the url would be http://localhost:8080/my-ui

For that we have to adjust the vite.config.js:

export default defineConfig({
  plugins: [react()],
  base: 'my-ui',
  build: {
    outDir: './dist/static/my-ui',
    emptyOutDir: true,
  }
})

Now it would also be helpful if we don’t have to directly type the index.html but tell Spring always to re-route.

For that we have to add a Spring Configuration Class:

package org.foo.bar;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MyFrontedConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/my-ui").setViewName("/my-ui/index.html");
        registry.addRedirectViewController("/my-ui/", "/my-ui");
    }
}

Add cache control to static react assets

In the end int would also be nice that the generated static resources are cached by the client e.g. for a year. We will extend the MyFrontedConfig class with:

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/my-ui/assets/**") 
                .addResourceLocations("classpath:/static/my-ui/assets/") 
                .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS));
    }

Transaktionsmanagement mit Spring, JPA, Hibernate

Paul Sterl — Sat, 31 Aug 2024 15:02:17 +0000

Lerne die Grundlagen des Transaktionsmanagements in modernen Datenbanken kennen, und erfahre, wie du mit Spring Boot, Spring Data, JPA und Hibernate effektiv arbeitest.

In diesem Tutorial starten wir mit den Grundlagen der Datenbanktransaktionen in deiner Anwendung: – Transaktionen starten:

Transaktion starten: Verstehe, wie Du Transaktionen in Spring Boot richtig initialisierst.
Rollback-Strategien: Erlerne die wichtigsten Methoden, um Transaktionen bei Fehlern sicher zurückzusetzen.
Annotations: Setze Annotations gezielt ein, um Transaktionen zu steuern.
Programmatische Transaktionen: Implementiere Transaktionen programmatisch und gewinne maximale Kontrolle.
Read Only: Transaktionen für GET Operationen
Timeouts: Wie stelle ich bei einer Transaktion einen Timeout ein, was muss ich beachten?

Dieses Video ist perfekt für Entwickler, die ihre Fähigkeiten in Spring Framework erweitern und transaktionssichere Anwendungen erstellen möchten.

Java Jobs and Trigger Frameworks

Paul Sterl — Mon, 06 May 2024 07:45:53 +0000

Setup Spring Boot Azure OAuth2 with CORS

Paul Sterl — Thu, 01 Feb 2024 09:03:03 +0000

What is needed

Setup an Azure AAD Application
Add the web URIs which are allowed to use the OAuth2 login
Add a client secret for your application
Add API Permission to read the profile
Add needed Azure dependencies
Setup Spring OAuth config
Adjust the CORS settings in Spring to ensure token refreshes
Configure spring security

Setup an Azure AAD Application

First we need an Azure AAD application which gives us the access to our AD users. The important part are the client id and the tenant id here:

Add the web URIs which are allowed to use the OAuth2 login

In the next step we have to allow „applications“ based on their „DNS“ name to access and login through this AAD. Ensure to remember the yellow part, which is later needed in the configutation.

The URLs are basically the one you whitelist for a login. If you setup the „test“ AAD application you may want also add sometimes the localhost for testing. Ensure to remove it again later on.

Add a client secret for your application

Next we have to create a secret for our application, we only require later the value of it. Please make sure you provide a new one after the expiration period.

You can have multiple secrets for multiple apps here.

Setup Spring OAuth config

In this configuration we have to enter all the collected data azure-dev as name is here the suffix provided in the authentication section of the Azure AAD application. You can choose what ever name you like.

spring:
  security:
    oauth2:
      client:
        provider:
          azure:
            issuer-uri: https://login.microsoftonline.com//v2.0
            user-name-attribute: name
        registration:
          azure-dev:
            provider: azure
            client-id: 
            client-secret: 
            client-authentication-method: client_secret_post
            scope:
              - openid
              - email
              - profile

Spring Security

  @Bean
  SecurityFilterChain filterChain(HttpSecurity http, OptionalYourUserService userService) throws Exception {
    // @formatter:off
    http
      .authorizeHttpRequests(authorizeHttpRequests ->
        authorizeHttpRequests
          // public URLs
          .requestMatchers(antMatcher("/actuator/health/readiness")).permitAll()
          // secure actuator
          .requestMatchers(antMatcher("/actuator/**")).hasRole(UserGroup.ADMIN)
          // app urls
          .requestMatchers("/api/**").authenticated()
          // default; recommended to use .authenticated()
          .anyRequest().permitAll()
      ).headers(headers -> headers.frameOptions(FrameOptionsConfig::sameOrigin))
      .oauth2Login( oauth2 -> oauth2
          .userInfoEndpoint(userInfo -> userInfo
            .oidcUserService(oidcUserService(userService)))
      )
      .headers(headers -> headers.frameOptions(FrameOptionsConfig::sameOrigin));
    // @formatter:on
    return http.build();
  }

  private OAuth2UserService oidcUserService(
    OptionalYourUserService userService) {
    return userRequest -> {
      var oidcUser = new OidcUserService().loadUser(userRequest); // Delegate to the default
                                                                  // implementation
      
      // add any custom user service integration here, if required.

      return oidcUser;
    };
  }

Add CORS Config

To avoid any CORS error / strict-origin-when-cross-origin in your application we have to whitelist the OAuth2 provider for any redirect, in this example login.microsoft:

  @Bean
  protected CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration configuration = new CorsConfiguration();
    configuration.setAllowedOrigins(Arrays.asList("https://login.microsoftonline.com/**"));
    configuration.addAllowedHeader("*");
    configuration.addAllowedMethod("*");
    configuration.setAllowCredentials(true);
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", configuration);
    return source;
  }

Datenbank| Transaktionen | Isolationlevel | Locks | Hibernate | JPA | Spring Boot

Paul Sterl — Mon, 02 Oct 2023 11:40:50 +0000

Um weiterführende Konzepte besser nachvollziehen zu können, wollen wir uns in den Grundlagen Datenbanken mit Spring Boot, Isolation Level (Isolationsgrad) und Locks beschäftigen.

Disable @Scheduled timers for test in Spring

Paul Sterl — Mon, 02 May 2022 09:18:37 +0000

Problem

As soon we have timers in our project they may cause issues in our integration tests, as they start running in the most undesirable situation. E.g. during the trigger a specific function which would usually be triggered by the timer.

Solution 1

If we want to disable the timers even the construction of the beans we have to tell spring not event to lead the beans. To achieve that we require first some configuration. As we might have more than one timer it is easier to work with an own meta annotaton

Own Meta annotation

@ConditionalOnProperty(name = "my-project.timers-enabled", 
                       havingValue = "true", 
                       matchIfMissing = true)
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
public @interface TimersEnabled {

}

Use the annotation

@TimersEnabled
@Component
@RequiredArgsConstructor
public class MyTimer {
    
    private final MyService service;

    @Scheduled(fixedDelay = 30, timeUnit = TimeUnit.SECONDS)
    void scheduledMethod() {
        service.doStuff();
    }
}

Disable the timers

e.g. in the application.yml of your test resources:

my-project:
  timers-enabled: false

The timers will be disabled for any value other then true.

Solution 2

In the easiest scenario if it is a in memory Spring test we can just mock the ScheduledExecutorService and so stop any @Scheduled job executions.

    @MockBean
    private ScheduledExecutorService schedulerService;

JPA Model testing with Hibernate Statistics

Paul Sterl — Sun, 01 Aug 2021 11:25:00 +0000

Problem

Often we write JPA Entity classes an have to ensure in a larger team that refactoring doesn’t create performance problems or logical errors in the entity model usual problems are:

Missing fetch joins in Queries
- Which leads to slow fetch joins
Wrong direction of Entity relations
- which leads to updates after inserts
- or even to deletes and reinserts of data
Wrong transaction boundaries
- Which leads to multiple transactions for one logical business operation

@Component
public class HibernateAsserts {
  private final Statistics statistics;

  public HibernateAsserts(EntityManager entityManager) {
    try (Session session = entityManager.unwrap(org.hibernate.Session.class)) {
      @SuppressWarnings("resource")
      SessionFactory factory = session.getSessionFactory();
      factory.getStatistics().setStatisticsEnabled(true);
      statistics = factory.getStatistics();
    }
  }
  
  public HibernateAsserts assertTrxCount(int expected) {
    long value = statistics.getTransactionCount();
    if (value != expected) {
      logSummary();
      fail("Expected " + expected + " TransactionCount, but found " + value);
    }
    return this;
  }
  
  public HibernateAsserts assertInsertCount(int expected) {
    long value = statistics.getEntityInsertCount();
    if (value != expected) {
      logSummary();
      fail("Expected " + expected + " EntityInsertCount, but found " + value);
    }
    return this;
  }

  public void reset() {
    statistics.clear();
  }

  public void logSummary() {
    statistics.logSummary();
  }
}

In your test

@SpringBootTest
class MyTestClassTest {

  @Autowired private SubjectUnderTest subject;
  @Autowired private HibernateAsserts hibernateAsserts;
  
  @Test
  void textMyBusinessMethod() {
    // GIVEN
    // custom data setup for the test

    // WHEN
    hibernateAsserts.reset(); // ensure the setup is not in the stats
    subject.runBusinessMethod();
    
    // THEN
    // any business asserts
    hibernateAsserts
      .assertTrxCount(1)
      .assertInsertCount(1);
  }
}

Aspects with Annotations

Paul Sterl — Mon, 24 May 2021 09:28:46 +0000

Problem

Define a pointcut for annotated methods. The most example are based only on @within or @annotation which has the downside that the aspect is added to all methods and the check of the annotation is executed during runtime.

Solution

@Aspect
@Component
public class MethodAspect {
    /**
     * This ensures that the aspect is only woven into methods with the annotation.
     * Otherwise all methods are woven!
     */
    @Pointcut("execution(@MethodAnnotation * * (..))")
    private void isAnnotated() {};
    /**
     * (optional) Limit package scan to our project only
     */
    @Pointcut("execution(* your.project.package..*(..))")
    private void isInPackage() {};

    @Around("isAnnotated() && isInPackage() && @annotation(annotation)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint, 
                                   MethodAnnotation annotation) throws Throwable {
        return joinPoint.proceed();
    }
}

Git Repository

https://github.com/sterlp/training/tree/master/aspect

Java – Pauls Blog

A Bounded, Thread-Safe In-Memory Store for Java

Problem

Solution

Spring Persistent Tasks

Key Features

React & Spring Boot

Problem

Multi-Module project

Root pom.xml

Backend pom.xml

Frontend pom.xml

Ensure the result in the dist folder is compatible to Spring

Going beyond

Add cache control to static react assets

Transaktionsmanagement mit Spring, JPA, Hibernate

Java Jobs and Trigger Frameworks

Setup Spring Boot Azure OAuth2 with CORS

What is needed

Setup an Azure AAD Application

Add the web URIs which are allowed to use the OAuth2 login

Add a client secret for your application

Setup Spring OAuth config

Spring Security

Add CORS Config

Links

Datenbank| Transaktionen | Isolationlevel | Locks | Hibernate | JPA | Spring Boot

Disable @Scheduled timers for test in Spring

Problem

Solution 1

Own Meta annotation

Use the annotation

Disable the timers

Solution 2

JPA Model testing with Hibernate Statistics

Problem

In your test

Aspects with Annotations

Problem

Solution

Git Repository

Links