Spring – 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

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));
    }

Grundlagen Datenbanken | als Entwickler | Datenbank Locks vs Write Ahead | Spring | JPA | Hibernate

Paul Sterl — Sat, 13 Jan 2024 10:03:48 +0000

Last uns zusammen ein State Persistence Anwendung auf eine Write Ahead Anwendung abändern und die Verbesserung in der Skalierbarkeit dieser betrachten.

Wie synchronisieren wir parallelle Objektzugriffe in Java und Spring Boot, um die Skalierbarkeit unseres Systems zu optimieren?
Praktische Lösungen: Wie verarbeitet ein Java Spring Boot System viele Updates auf einmal nach einer Downtime?
Strategien für Lastspitzen in der Praxis: Einsatz von DB Locks in Java und Spring Boot.
Praktische Tipps und Tricks: Vor- und Nachteile von Locks in der Java Spring Boot Anwendung.
Weitere Optimierungsmöglichkeiten in der Java Spring Boot Architektur:
- Umsetzung von Write Ahead Log in Java und Spring Boo, welche Modifikationen sind notwendig?
- Was bring das an mehr Skalierbarkeit?

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.

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;

Angular & Spring Boot

Paul Sterl — Sun, 17 Feb 2019 08:47:14 +0000

Problem

We want to combine Spring and Angular use the Angular developing features but also be able to use the Spring IDE, in the end, everything should be build using maven and nicely packed into a JAR.
Let’s get started.

Overview

Create a multi-module project
Pack the frontend into an own JAR
Include the frontend JAR into the Spring application
Add a caching configuration

Less text more code get me to the source.

Multi-Module project

Create a new simple Spring project using https://start.spring.io/
Generate a new angular project ng new frontend
Create a new pom and include frontend and backend


  frontend 
  backend

It may make sense to move the spring parent into the root-pom.

Why a multi-module?

You might think why the hack we don’t just pull everything into one maven artifact? Well, separation both may be considered good practice but the real reason is:
We can in that way use, during the development, the best tools for the job. Means use the angular dev server for the front-end and the Spring STS IDE for the backend. Means also just restart/ reload the UI or the Backend if the change that. Even more, build the UI and use the backend running somewhere else.

Build angular with maven

Overall we have here to choose, either we use the frontend-maven-plugin, assuming the CI server has no nodeJS installed or we go with the exec-maven-plugin. The last one is faster assuming the CI server has not to pull nodeJS first. What we want to run is:

npm install
ng build –prod

Build angular with exec-maven-plugin


    exec-maven-plugin
    org.codehaus.mojo
    
        
            npm install
            
                exec
            
            generate-resources
            
                npm
                
                    install
                
            
        

        
            angular-cli build
            
                exec
            
            compile
            
                ng
                
                    build
                  	
                    
                    --output-path
                    ${project.build.outputDirectory}/META-INF/resources/webjars/${project.artifactId}/${project.version}

This will not delete the node_modules folder; which is intended. As this takes usually some unnecessary time.

Note: We added here already the --output-path to emulate a kind of web-jar, we will use this later to configure the Spring resource handler. We could of course remove the version here.

Add node_modules to mvn clean


	org.apache.maven.plugins
	maven-clean-plugin
	
		
			
				node_modules

Include the Angular frontend in Spring

Again we have two ways to go, we could either include the JAR file and configure the resource handler, or just copy the files over into the static folder of spring during the build. The last one is very easy the first one has the advantage that we could include easily multiple angular JARs into our project.

Include the frontend as JAR


    ${project.groupId}
    frontend
    ${project.version}

In your Spring application add implements WebMvcConfigurer. This will allow you to extend

@Autowired private BuildProperties buildProperties;
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    final String jarResourcePath = "classpath:/META-INF/resources/webjars/frontend/" + buildProperties.getVersion() + "/";
        // no caching for HTML pages
        registry.addResourceHandler("/ui/*.html")
                .setCacheControl(CacheControl.noStore().sMaxAge(0, TimeUnit.SECONDS).mustRevalidate())
                .setCachePeriod(0)
                .addResourceLocations(jarResourcePath);

        // 365 days for JS and CSS files, which have a hash code in the file name 
        // generated by angular
        registry.addResourceHandler("/ui/*.js", "/ui/*.css")
                .addResourceLocations(jarResourcePath)
                .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS))
                .resourceChain(true);
        
        // apply custom config as needed to the remaining resources
        registry.addResourceHandler("/ui/**")
                .addResourceLocations(jarResourcePath)
                .setCacheControl(CacheControl.maxAge(7, TimeUnit.DAYS))
                .resourceChain(true);
	
}

Note: We added here already a caching configuration.

In addition we have to tell Spring that by default if anybody opens / we want to display the index.html. This is only needed if we include the angular app as JAR, as we can just delete the static folder.

public void addViewControllers(ViewControllerRegistry registry) {
    registry.addViewController("/").setViewName("forward:/index.html");
}

// in the addResourceHandlers we can also alternatively add the view ot the base e.g. 
// / or ui/
// handy in case of PathLocationStrategy
registry.addResourceHandler("/")
    .setCacheControl(CacheControl.noStore().sMaxAge(0, TimeUnit.SECONDS).mustRevalidate()).setCachePeriod(0)
    .addResourceLocations(jarResourcePath + "index.html");

Copy the Angular files

The most simple way to just include the angular into the build JAR is to copy them during the package phase into the static directory from Spring. From where it will just behave like a regular application.


    maven-resources-plugin
    
        
            copy frontend resources
            prepare-package
            
                copy-resources
            
            
                ${project.build.outputDirectory}/static
                
                    
                        ../frontend/target/classes/META-INF/resources/webjars/frontend/${project.version}

If we copy the resources, we can just set optional onto the frontend JAR or provided. The only reason we keep it in the pom.xml is just to ensure that it gets build first by maven; even if somebody re-sorts the modules in the root pom.

Note: If we copy the resources we can also remove the addResourceHandlers configuration from the app. As we don’t need to tell Spring to check the JAR file too.

Handling HTML 5 routes in Spring

Using a Regex (not recommended)

A common problem is to handle any HTML5 routes from angular, if why are directly opened in the browser. We don’t really want to add a view handler for each angular route. We have just to add a simple @Controller with the following code.

@RequestMapping(value = "/{[path:[^\\.]*}")
public String redirect() {
    return "forward:/index.html";
}

Using a fallback route

registry.addResourceHandler("/**").addResourceLocations(jarResourcePath)
        .setCacheControl(CacheControl.maxAge(1, TimeUnit.HOURS)).resourceChain(true)
        .addResolver(new PathResourceResolver() {
            // fall back to our index.html for any other stuff
            // to support angular PathLocationStrategy
            @Override
            protected Resource getResource(String resourcePath, Resource location) throws IOException {
                final Resource requestedResource = location.createRelative(resourcePath);
                Resource result = requestedResource;
                if (!requestedResource.exists()) {
                    result = new ClassPathResource("/META-INF/resources/index.html");
                }
                return result;
            }
        });

Custom UI base path

Another solution would be to publish the API and the UI with different prefixes e.g.:

/api/* or /rest/* for all REST services
/ui/* for the angular UI

This makes the controller match clearer and more predictable if also other services like the Swagger UI etc. are hosted too. But it requires some adjustments too:

base href for the HTML5 angular navigation has to be set --base-href /ui/
The resource handler above need have /ui/* prefix
We need a filter or a controller

// custom filter, which does the same as the controller
@Bean
public OncePerRequestFilter angularForwardFilter() {
    return new OncePerRequestFilter() {
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
            final String requestURI = request.getRequestURI();
            if (requestURI.startsWith("/ui") && !requestURI.endsWith("/ui/index.html") && !requestURI.contains(".")) {
                request.getRequestDispatcher("/ui/index.html").forward(request, response);
            } else {
                filterChain.doFilter(request, response);
            }
        }
    };
}
// custom controller class with a regex instead of the OncePerRequestFilter
@Controller
@RequestMapping("/ui")
public class AngularUiController {
    @GetMapping("{[path:[^\\.]*}")
    String index() {
        return "forward:/ui/index.html";
    }
}

Explicit match

Last but not least we can, of course, duplicate any angular route in our request mapping.

@RequestMapping({"/", "/home", "/home/*", "/person", "/person/list"})
public String redirect() {
    return "forward:/index.html";
}

Avoid reloading the backend on frontend changes

Including the dev-tools from Spring will unfortunately also reload the backend if we change the frontend. We could of course just remove the frontend JAR dependency but we could also tell Spring to stop. For this we have to create the spring-devtools.properties in the META-INF directory telling Spring not to do so:

restart.exclude.frontend=.*/frontend/.*

Proxy /api calls to the backend

Now we have to forward any calls going to /api to our backend otherwise we cannot get any data from any REST call during the usage of the angular dev web-server. For that, we have to add the proxy.conf.json to the project

{
    "/api": {
        "target": "http://localhost:8080",
        "secure": false
    }
}

and extend package.json to add a short cut add the proxy config if we run ng serve.

{
  "scripts": {
    "start": "ng serve --proxy-config proxy.conf.json",

Now we can run the Angular dev server with the proxy config using npm start.

Use Session and Request Scope Beans in Tests with Spring

Paul Sterl — Fri, 10 Jul 2015 18:00:25 +0000

Sometimes it is useful haven the Web Scopes in Unit Tests. Usually Spring just show this very useful error in the Unit Test:

Caused by: java.lang.IllegalStateException: No Scope registered for scope 'session'
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:334)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:194)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.findAutowireCandidates(DefaultListableBeanFactory.java:1120)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1044)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:942)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:533)
	... 28 common frames omitted

You can easily have all needed web scopes in your unit test by adding the following annotation to your Tests: @WebAppConfiguration.

Now Web Scopes like:

@Bean(name = "foo") @Scope("session")
public String getString()

will work.

Spring Boot Configuration – Properties not loaded

Paul Sterl — Fri, 10 Jul 2015 17:29:05 +0000

I had recently a very interesting problem using Spring Boot and the automagic concerning the configuration.

The Problem

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'demo.MyApplicationTests': Injection of autowired dependencies failed; 
	nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private java.lang.String demo.MyApplicationTests.url; 
	nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'my.url' in string value "${my.url}" at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:334)
		~[spring-beans-4.1.7.RELEASE.jar:4.1.7.RELEASE] 
	Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'my.url' in string value "${my.url}" at org.springframework.util.PropertyPlaceholderHelper.parseStringValue(PropertyPlaceholderHelper.java:174) 
		~[spring-core-4.1.7.RELEASE.jar:4.1.7.RELEASE]

Configuration was not available in my Unit tests but it was working fine in the normal application. I spend a lot of time searching but without real good post concerning this issue.

This code already wasn’t working:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = MyWebappApplication.class)
@WebAppConfiguration
public class MyApplicationTests {
    @Value("${my.url}")
    String url;

    @Test
    public void test() {
        System.out.println(url);
    }
}

Even if my application.yml / application.properties was looking good:

my:
   url: any kind of String we inject

The solution

Now here the working sample, do you see the difference?

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = MyWebappApplication.class)
@WebAppConfiguration
public class MyApplicationTests {
    @Value("${my.url}")
    String url;

    @Test
    public void test() {
        System.out.println(url);
    }
}

Yes it is just the @SpringApplicationConfiguration instead of the @ContextConfiguration annotation. (Even if the first is itself just a meta-annotation of the second.) If you look into this new annotation you will find that it uses a different loader class, which makes the difference.

@ContextConfiguration(loader = SpringApplicationContextLoader.class)
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface SpringApplicationConfiguration

That’s the trick. Having it in place the Spring Application configuration is successfully parsed an available in your unit test. Doesn’t matter if YAML or just property file.

Spring – Pauls Blog

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

Grundlagen Datenbanken | als Entwickler | Datenbank Locks vs Write Ahead | Spring | JPA | Hibernate

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

Datenbank Timeouts | Locks | Isonaltionlevel | Transaktionen

Disable @Scheduled timers for test in Spring

Problem

Solution 1

Own Meta annotation

Use the annotation

Disable the timers

Solution 2

Angular & Spring Boot

Problem

Overview

Multi-Module project

Why a multi-module?

Build angular with maven

Build angular with exec-maven-plugin

Add node_modules to mvn clean

Include the Angular frontend in Spring

Include the frontend as JAR

Copy the Angular files

Handling HTML 5 routes in Spring

Using a Regex (not recommended)

Using a fallback route

Custom UI base path

Explicit match

Avoid reloading the backend on frontend changes

Proxy /api calls to the backend

Links

Use Session and Request Scope Beans in Tests with Spring

Spring Boot Configuration – Properties not loaded

The Problem

The solution