Pauls Blog https://sterl.org Tue, 30 Dec 2025 15:18:26 +0000 de hourly 1 https://wordpress.org/?v=6.8.3 A Bounded, Thread-Safe In-Memory Store for Java https://sterl.org/2025/12/java-simple-bound-memory-store/ https://sterl.org/2025/12/java-simple-bound-memory-store/#respond Tue, 30 Dec 2025 14:55:43 +0000 https://sterl.org/?p=1149 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<T> {

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

    private final Map<String, T> data = new LinkedHashMap<>() {
        // called during put and ensures the map doesn't grow
        @Override
        protected boolean removeEldestEntry(Map.Entry<String, T> 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<String, T> data() {
        lock.lock();
        try {
            return new LinkedHashMap<>(this.data);
        } finally {
            lock.unlock();
        }
    }
}

]]> https://sterl.org/2025/12/java-simple-bound-memory-store/feed/ 0 REST SOAP API Client https://sterl.org/2025/08/rest-soap-api-client/ https://sterl.org/2025/08/rest-soap-api-client/#respond Tue, 05 Aug 2025 06:49:31 +0000 https://sterl.org/?p=1129 REST

SOAP

]]> https://sterl.org/2025/08/rest-soap-api-client/feed/ 0 Spring Persistent Tasks https://sterl.org/2025/04/spring-persistent-tasks/ https://sterl.org/2025/04/spring-persistent-tasks/#respond Sun, 20 Apr 2025 07:16:43 +0000 https://sterl.org/?p=1116 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

  1. JPA-Powered Persistence – Automatically persists tasks to your database
  2. Spring Boot Auto-Configuration – Simple setup with @EnableSpringPersistentTasks
  3. Clustering Support – Built-in lock management for distributed environments
  4. Type-Safe Tasks – Generic task definitions with state objects
  5. Retry Mechanisms – Automatic retry policies for failed executions
  6. Transactional Integration – Works with Spring’s transaction management
  7. Queue Management – Intelligent task queuing and prioritization
  8. Different DB Supports
    • MsSQL
    • MariaDB
    • Postgres
]]> https://sterl.org/2025/04/spring-persistent-tasks/feed/ 0 Propagation REQUIRES_NEW & NEVER | Transaktionsmanagement mit Spring Boot, JPA & Hibernate https://sterl.org/2025/01/propagation-requires_new-never-transaktionsmanagement-mit-spring-boot-jpa-hibernate/ https://sterl.org/2025/01/propagation-requires_new-never-transaktionsmanagement-mit-spring-boot-jpa-hibernate/#respond Sun, 19 Jan 2025 20:17:00 +0000 https://sterl.org/?p=1119 In diesem Video tauchen wir tiefer in die Welt des Transaktionsmanagements ein und erklären die Unterschiede zwischen den Propagation-Einstellungen REQUIRES_NEW und NEVER in Spring Boot. Erfahre, wie du mit Spring Boot, Spring Data, JPA und Hibernate effektive Transaktionen in modernen Datenbanken steuerst.

Lerne, wann und warum du REQUIRES_NEW nutzen solltest, um eine neue Transaktion zu starten, und warum NEVER nützlich ist, um sicherzustellen, dass kein bestehender Transaktionskontext verwendet wird. Dieses Tutorial ist ideal für Entwickler, die fortgeschrittene Techniken des Transaktionsmanagements verstehen und in ihren Anwendungen umsetzen möchten.

Github

]]> https://sterl.org/2025/01/propagation-requires_new-never-transaktionsmanagement-mit-spring-boot-jpa-hibernate/feed/ 0 React & Spring Boot https://sterl.org/2024/12/react-spring-boot/ https://sterl.org/2024/12/react-spring-boot/#respond Wed, 11 Dec 2024 18:36:41 +0000 https://sterl.org/?p=1095 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

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.foo.bar</groupId>
    <artifactId>project-root</artifactId>
    <version>0.1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <java.version>21</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

    <modules>
        <module>frontend</module>
        <module>backend</module>
    </modules>

  	<!-- feel free to use spring as root instead of this -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>3.3.6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

Backend pom.xml

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

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.foo.bar</groupId>
        <artifactId>project-root</artifactId>
        <version>0.1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>project-backend</artifactId>

    <dependencies>
      	<!-- thats the important part -->
        <dependency>
            <groupId>org.foo.bar</groupId>
            <artifactId>project-frontend</artifactId>
            <version>${project.version}</version>
        </dependency>
      	<!-- thats the important part end -->
      
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </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>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Frontend pom.xml

Now we have todo more stuff:

  1. Ensure the dist result is added to the JAR
  2. Generate during the generate-resources phase also the content for the dist folder
  3. Ensure that during a mvn clean all gets deleted
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.foo.bar</groupId>
        <artifactId>project-root</artifactId>
        <version>0.1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>project-frontend</artifactId>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    
    <build>
        <!-- Ensure the dist result is added to the JAR -->
        <resources>
            <resource>
                <directory>dist</directory>
            </resource>
        </resources>

        <plugins>
          	<!--
                Generate during the generate-resources phase 
                also the content for the dist folder 
            -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.0</version>
                <executions>
                    <execution>
                        <id>npm install</id>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <phase>generate-resources</phase>
                        <configuration>
                            <executable>npm</executable>
                            <arguments>
                                <argument>install</argument>
                                <argument>--prefer-offline</argument>
                                <argument>--no-audit</argument>
                                <argument>--progress=false</argument>
                            </arguments>
                        </configuration>
                    </execution>

                    <execution>
                        <id>npm build</id>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                        <phase>generate-resources</phase>
                        <configuration>
                            <executable>npm</executable>
                            <arguments>
                                <argument>run</argument>
                                <argument>build</argument>
                            </arguments>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <!-- Ensure that during a mvn clean all gets deleted -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-clean-plugin</artifactId>
                <version>3.4.0</version>
                <configuration>
                    <filesets>
                        <fileset>
                            <directory>node_modules</directory>
                        </fileset>
                        <fileset>
                            <directory>dist</directory>
                        </fileset>
                    </filesets>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

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));
    }
]]> https://sterl.org/2024/12/react-spring-boot/feed/ 0 Run Eclipse/STS on Windows WSL https://sterl.org/2024/09/run-eclipse-sts-on-windows-wsl/ https://sterl.org/2024/09/run-eclipse-sts-on-windows-wsl/#respond Thu, 26 Sep 2024 08:01:01 +0000 https://sterl.org/?p=1052 Problem

In some companies, App Defender/AppLocker makes the entire Windows OS practically unusable. EXEs are blocked, and the virus scan slows any build to a crawl. Nevertheless, we still need to work, and WSL is often the only feasible solution. But how can we start, for example, Eclipse or any other application in WSL that requires a screen?

Solution

We might wither build on x11 (steps 4 and 5) or use the build in WSLg which should run out of the box:

  1. Install eclipse or STS in Linux
  2. Export the DISPLAY env variable export DISPLAY=:0
  3. Run eclipse or any other application in Linux
  4. (optional) Install x11 in Linux sudo apt install x11-xserver-utils
  5. (optional) Install VcXsrv on windows

Install eclipse or Spring STS in Linux

We might either install eclipse with sudo apt install eclipse or as many other of us choose to install a different IDE here an example for spring sts (update the URL as needed to the current version):

wget https://cdn.spring.io/spring-tools/release/STS4/4.25.0.RELEASE/dist/e4.33/spring-tool-suite-4-4.25.0.RELEASE-e4.33.0-linux.gtk.x86_64.tar.gz
tar -xvf spring-tool-suite-4-4.25.0.RELEASE-e4.33.0-linux.gtk.x86_64.tar.gz
rm -rf spring-tool*
ln -s sts-4.25.0.RELEASE/SpringToolSuite4 sts

Export the DISPLAY env variable

In order to find our windows screen we have to define the DISPLAY destination with the same named environment variable. The simplest way is to extend the .profile that it is automatically exported on each shell start (or .zprofile if zsh is used).

export DISPLAY=:0

Run eclipse or any other application

Now we can either start eclipse using ./eclipse or the spring STS using ./sts.

In case of any issues the x11 app might help you e.g. using xeyes:

sudo apt install x11-apps
xeyes

Install x11 in Linux

x11 tools on Linux are responsible to send the screen information from our Linux system to windows and on the other hand receive mouse and keyboard commands. In ubuntu the tools can be installed by using:

sudo apt install x11-xserver-utils

This step is not need anymore on a newer WSL as by default windows support UI apps in the WSL using WSLg.

If x11 is used the DISPLAY variable has to be adjusted to point to the Windows Host machine.

Install VcXsrv on windows

In order to receive the screen information from Linux in Windows and to display the application started in Linux we need an x11 client here too. First we have to install VcXsrv and start it using XLaunch which will prompt us of the settings:

  1. Multiple windows in the display settings, which allows us to start more than one app
  2. Start no client which of course requires us to start the app in Linux manually later on

Everything else may stay in the default settings.

This step is not need anymore on a newer WSL as by default windows support UI apps in the WSL using WSLg.

Alternatives

]]> https://sterl.org/2024/09/run-eclipse-sts-on-windows-wsl/feed/ 0 Transaktionsmanagement mit Spring, JPA, Hibernate https://sterl.org/2024/08/transaktionsmanagement-mit-spring-jpa-hibernate/ https://sterl.org/2024/08/transaktionsmanagement-mit-spring-jpa-hibernate/#respond Sat, 31 Aug 2024 15:02:17 +0000 https://sterl.org/?p=1032 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.

]]> https://sterl.org/2024/08/transaktionsmanagement-mit-spring-jpa-hibernate/feed/ 0 Java Jobs and Trigger Frameworks https://sterl.org/2024/05/java-jobs-and-trigger-frameworks/ https://sterl.org/2024/05/java-jobs-and-trigger-frameworks/#respond Mon, 06 May 2024 07:45:53 +0000 https://sterl.org/?p=1026
  • Quartz
  • db-scheduler
  • jobrunr
    • ]]>     https://sterl.org/2024/05/java-jobs-and-trigger-frameworks/feed/ 0     Outbound-Pattern Microservices Architektur: Sichere Datenübergabe in verteilten Systemen https://sterl.org/2024/03/outbound-pattern-microservices-architektur-sichere-datenuebergabe-in-verteilten-systemen/ https://sterl.org/2024/03/outbound-pattern-microservices-architektur-sichere-datenuebergabe-in-verteilten-systemen/#respond Fri, 08 Mar 2024 12:08:51 +0000 https://sterl.org/?p=1020 In verteilten Systemen, wie Microservice-Architekturen, stellen sich unweigerlich folgende Fragen:

    1. Wie können wir Daten/Updates sicher bzw. transaktional zwischen den Services übergeben?
    2. Wie schaffen wir es, dass die unterschiedlichen Services nicht auseinanderlaufen?

    Das Outbound-Pattern kann uns hierbei helfen, dieses Problem zu lösen. Es handelt sich um eine bewährte Methode, um Datenkonsistenz und Transaktionen in verteilten Systemen zu gewährleisten.

    ]]>     https://sterl.org/2024/03/outbound-pattern-microservices-architektur-sichere-datenuebergabe-in-verteilten-systemen/feed/ 0     Setup Spring Boot Azure OAuth2 with CORS https://sterl.org/2024/02/setup-spring-boot-azure-oauth2-with-cors/ https://sterl.org/2024/02/setup-spring-boot-azure-oauth2-with-cors/#respond Thu, 01 Feb 2024 09:03:03 +0000 https://sterl.org/?p=993 What is needed
    1. Setup an Azure AAD Application
    2. Add the web URIs which are allowed to use the OAuth2 login
    3. Add a client secret for your application
    4. Add API Permission to read the profile
    5. Add needed Azure dependencies
    6. Setup Spring OAuth config
    7. Adjust the CORS settings in Spring to ensure token refreshes
    8. 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/<Directory (tenant) ID>/v2.0
            user-name-attribute: name
        registration:
          azure-dev:
            provider: azure
            client-id: <Application (client) ID>
            client-secret: <the secret value you created for your app>
            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<OidcUserRequest, OidcUser> 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;
  }

    Links

    • https://learn.microsoft.com/en-us/azure/developer/java/spring-framework/spring-boot-starter-for-azure-active-directory-developer-guide
    ]]>     https://sterl.org/2024/02/setup-spring-boot-azure-oauth2-with-cors/feed/ 0