Spring Boot – Pauls Blog

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

Propagation REQUIRES_NEW & NEVER | Transaktionsmanagement mit Spring Boot, JPA & Hibernate

Paul Sterl — Sun, 19 Jan 2025 20:17:00 +0000

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

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.

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.

Datenbank Timeouts | Locks | Isonaltionlevel | Transaktionen

Paul Sterl — Mon, 02 Oct 2023 11:15:27 +0000

Häufig vergessen, oder nur teilweise gemacht. Timeouts tragen einen wesentlichen Bestandteil zur Stabilität und dem Ressourcenmanagement von Software bei. Insbesondere bei Microservices sollten diese immer richtig eingestellt sein. Timeouts spielen auch eine wesentliche Rolle in Bezug auf Transaktionen, Locks und Isolationslevel. Sollte man zudem den Zugriff auf die Datenbank auch Dritten gewähren, also nicht nur den Services selbst, dann sind diese umso wichtiger, für alle Clients, die auf die Datenbank zugreifen.

Quartz integration in Spring

Paul Sterl — Fri, 01 Jul 2022 19:50:50 +0000

Why Quartz? motivation

Spring comes already with an own timer and this is fine if we have very simple requirements and we don’t really care about state or on which pod the timer is actually running. To be more precise the timer/ job is running in each of our spring containers independently.

Lets be honest, this is usually never really the case and so it is common to invite ShedLock to the party. Are we done then?

Usually no, honestly we want in the most cases just a bit more:

Run jobs in the cluster on different nodes simultaneous
Have a kind of state management
The ability to provide some kind of configuration to each run
Have some kind of way for easy retries etc.

Hey why don’t use Spring Batch then?

Because to have just a timer and not really a batch-job it is somehow the wrong tool. Furthermore Spring-Batch is build with a different goal in mind, where we start a container with one job inside to process mass of data. Quartz is more a timer, which we want to use to trigger either smaller task in our application or run kind of repeating small task and are more concerned to orchestrate and Monitor them.

Spring Batch = Batch Framework to handle large datasets which should be processed, usually in an own container / pod for the duration of the Job
Quartz = Timer which also supports a JDBC/ REDIS store for smaller timer jobs which should run in our app cluster

Steps for the integration

Setup the DB
Configure Quartz Scheduler
Configure CDI Job Factory
Register our timers
Set a thread priority for our job

Setup the DB

Overall quartz comes with SQL scripts and liquibase scripts you may just include. Read here. For unit test we can just simply use the build in feature:

spring:
  quartz:
    jdbc:
      initialize-schema: always

Configure Quartz Scheduler

We will use the CMT Store here, for more details because of the why please read the following tutorial.

		
			org.springframework.boot
			spring-boot-starter-quartz

After adding the dependency we have to configure Quartz, in this example we set the thread count to 2, adjust this value based on your needs. The following configuration will usually create a LocalDataSourceJobStore which is an JobStoreCMT.

spring:
  quartz:
    wait-for-jobs-to-complete-on-shutdown: false
    job-store-type: jdbc
    overwrite-existing-jobs: true
    jdbc:
      initialize-schema: always
    properties:
      org.quartz.jobStore.isClustered: true
      org.quartz.scheduler.instanceId: AUTO
      org.quartz.scheduler.skipUpdateCheck: true
      org.quartz.threadPool.threadCount: 2
  
  datasource:
    url: jdbc:h2:file:./quartz-db
    username: sa
    password:

Note: We init the DB just with quartz itself. But quartz contains in the core a liquibase and a SQL file which you may include into your DB update process.

Yes thats basically it, we will discuss details in further deep dives, but for now lets gets a job running.

Create a timer Job

To setup a timer we have to:

Add a job class
Configure the timer

Add a Spring configuration

// runs only one of these jobs in out cluster
// note we have no spring annotation here, but it contains spring beans
@DisallowConcurrentExecution 
public class QuatzTimerJob implements Job {
	// we can use spring beans, yes we cam
    @Autowired YourService yourService;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
		yourService.doSomething();
    }

}

Configure the timer

@Configuration
public class QuartzTimerConfiguration {
	// this registers our job itself
    @Bean
    public JobDetailFactoryBean quatzTimerJob() {
        final var jobDetailFactory = new JobDetailFactoryBean();
        jobDetailFactory.setJobClass(QuatzTimerJob.class);
        jobDetailFactory.setDescription("Simple timer like @Scheduled - but already like with ShedLock");
        jobDetailFactory.setDurability(true);
        return jobDetailFactory;
    }
    // here we add the timer, in this case every 30s, with a lower priority as normal for the job
    @Bean
    public SimpleTriggerFactoryBean trigger(JobDetail quatzTimerJob) {
        final var trigger = new SimpleTriggerFactoryBean();
        trigger.setJobDetail(quatzTimerJob);
        trigger.setRepeatInterval(30_000);
        trigger.setPriority(Thread.NORM_PRIORITY - 1);
        trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
        return trigger;
    }
}

Trigger a job

In difference to a normal Spring timer we may now fire triggers for Quartz Jobs, even add data to the triggers itself, at let Quartz handle the heavy work for us. Handy if we want QUEUE some work, or just distribute the load in our cluster to all available nodes. For this we have to:

Create a job instance we want to execute
Configure the job – but now without any default trigger
Create somewhere in our code the triggers, usually with some payload data

Create a job

Very simple thing here, just getting one value from the job context and calling out service.

public class TriggeredJob implements Job {

    @Autowired YourService yourService;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        long count = context.getMergedJobDataMap().getLong("count"));
        yourService.doSomething(count);
    }

}

Configure the job

The only special thing here is that we request a recovery on a different node, should this node for some reason die during the execution of the job.

@Configuration
public class QuartzJobConfiguration {
    @Bean
    public JobDetailFactoryBean createStoreItemsJob() {
        final var jobDetailFactory = new JobDetailFactoryBean();
        jobDetailFactory.setJobClass(CreateStoreItemsJob.class);
        jobDetailFactory.setDescription("Job we directly trigger if we want to run it");
        jobDetailFactory.setDurability(true);
        jobDetailFactory.setRequestsRecovery(true);
        return jobDetailFactory;
    }
}

Trigger the job

Note: The usage of @Transactional, this is by purpose, to ensure the trigger gets removed if we happen to rollback the transaction. If it is missing, quartz will silently create an own one.

    @Autowired Scheduler scheduler;
    @Autowired JobDetail createStoreItemsJob;

    @Transactional
    public void triggerStoreItemCreation() throws SchedulerException {
        Trigger t = TriggerBuilder.newTrigger()
            .forJob(createStoreItemsJob)
            .startNow() // run on this node if possible, means we have threads
            .usingJobData("count", count)
            .build();
        
        scheduler.scheduleJob(t);
    }

Testing it

You may wonder why we used a file DB in this configuration. Only with a DB which contains the trigger data after a restart you may play around and also kill the running Spring application. After a restart the jobs are triggered again.

Alternatives

We could also go for a command queue using e.g. JMS. This aproach would require additional infrastructure in form of a persistent broker. Which could be easy in the cloud but rather difficult if you have to operate and maintain it on your own. In the end a data store which have to join our DB transactions in case ACID is an issue and it always is.

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;

Spring Boot Redirect to SwaggerUI

Paul Sterl — Fri, 21 May 2021 13:13:33 +0000

Problem

Some services don’t have an UI and the OpenAPI/ Swagger UI should be used as default UI of the service. As so the root should be redirected directly to the SwaggerUI.

Solution

Just add a WebMvc redirect.

@Configuration
public class OpenApiConfig implements WebMvcConfigurer {
  @Override
  public void addViewControllers(final ViewControllerRegistry registry) {
    registry.addRedirectViewController("/", "/swagger-ui.html");
    // use setStatusCode(HttpStatus.XYZ) for any custom status code if required, e.g. MOVED_PERMANENTLY
    registry.addRedirectViewController("/swagger-ui", "/swagger-ui.html");
    // any other alias
  }
}

Swagger Open API dependencies

Spring Boot 2.x

Ensure you check the current version:

        
            org.springdoc
            springdoc-openapi-ui
            1.7.0
        
       
        
            org.springdoc
            springdoc-openapi-security
            1.7.0

Spring Boot 3.x

Ensure you check the current version:

        
            org.springdoc
            springdoc-openapi-starter-webmvc-ui
            2.1.0

With the new version you can also use the application.yml to configure the root directory as swagger ui:

springdoc:
  swagger-ui:
    use-root-path: true

Spring Boot – Pauls Blog

Spring Persistent Tasks

Key Features

Propagation REQUIRES_NEW & NEVER | Transaktionsmanagement mit Spring Boot, JPA & Hibernate

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

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

Datenbank Timeouts | Locks | Isonaltionlevel | Transaktionen

Quartz integration in Spring

Why Quartz? motivation

Steps for the integration

Configure Quartz Scheduler

Create a timer Job

Add a Spring configuration

Configure the timer

Trigger a job

Create a job

Configure the job

Trigger the job

Testing it

Alternatives

Links

Disable @Scheduled timers for test in Spring

Problem

Solution 1

Own Meta annotation

Use the annotation

Disable the timers

Solution 2

Spring Boot Redirect to SwaggerUI

Problem

Solution

Swagger Open API dependencies

Spring Boot 2.x

Spring Boot 3.x

Links