Microservices on Micha Kops' Tech Notes

Message-Driven Architecture Across Multiple Teams

Fri, 05 Sep 2025 00:00:00 +0200

Whenever I start planning a new message-driven architecture that spans several software teams, I quickly realize how many moving parts there are.

To keep my head clear, I’ve put together a personal checklist of things I always try to cover.

It’s not meant to be a formal rulebook, but more of a practical reminder of what usually makes the difference between smooth collaboration and endless headaches.

Figure 1. Message Driven Architecture Article Cover Image

Messaging with NATS and Java

Tue, 26 Nov 2024 00:00:00 +0100

Figure 1. NATS Architecture Component Diagram

NATS is a high-performance messaging system that offers simplicity, speed, and scalability. It is particularly suited for building distributed systems and microservices.

This article demonstrates how to integrate NATS with Java, showcasing the essential steps to set up, connect, and publish/subscribe to messages.

Prerequisites

Before diving in, we should ensure to have the following installed:

Java Development Kit (JDK) 11 or later.
Maven or Gradle for dependency management.
Docker (optional).

Forwardings Requests to static content in Spring Boot Webflux

Tue, 16 Aug 2022 00:00:00 +0200

The following WebFilter redirects incoming requests for / to a static HTML file, index.html.

ToIndexPageRedirection.java

package com.hascode.tutorial;

import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;

@Component
public class ToIndexPageRedirection implements WebFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        if (exchange.getRequest().getURI().getPath().equals("/")) {
            return chain.filter(
                exchange.mutate().request(
                    exchange.getRequest().mutate().path("/index.html").build()
                ).build()
            );
        }

        return chain.filter(exchange);
    }
}

Ressources:

JavaDocs WebFilter

Package a Spring Boot App as RPM

Fri, 14 May 2021 00:00:00 +0200

Goals

Package a Spring Boot Service as RPM Package
Configure systemd integration
Add install/uninstall hooks to create users, directories etc.

Maven Setup

<?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.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.2</version>
    <relativePath/>
  </parent>
  <groupId>com.hascode</groupId>
  <artifactId>sample-app</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <name>sample-app</name>

  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin> (1)
        <groupId>de.dentrassi.maven</groupId>
        <artifactId>rpm</artifactId>
        <version>1.5.0</version>
        <executions>
          <execution>
            <goals>
              <goal>rpm</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <packageName>sample-app</packageName>
          <skipSigning>true</skipSigning>
          <group>Application/Misc</group>
          <requires>
            <require>java-11-openjdk-headless</require> (2)
          </requires>
          <entries>
            <entry> (3)
              <name>/opt/sample-app</name>
              <directory>true</directory>
              <user>root</user>
              <group>root</group>
              <mode>0755</mode>
            </entry>
            <entry> (4)
              <name>/opt/sample-app/log</name>
              <directory>true</directory>
              <user>sample-app</user>
              <group>sample-app</group>
              <mode>0750</mode>
            </entry>
            <entry> (5)
              <name>/opt/sample-app/sample-app.jar</name>
              <file>${project.build.directory}/${project.build.finalName}.jar</file>
              <user>root</user>
              <group>root</group>
              <mode>0644</mode>
            </entry>
            <entry> (6)
              <name>/usr/lib/systemd/system/sample-app.service</name>
              <file>${project.basedir}/src/main/dist/sample-app.service</file>
              <mode>0644</mode>
            </entry>
          </entries>
          <beforeInstallation> (7)
            <file>${project.basedir}/src/main/dist/preinstall.sh</file>
          </beforeInstallation>
          <afterInstallation>
            <file>${project.basedir}/src/main/dist/postinstall.sh</file>
          </afterInstallation>
          <beforeRemoval>
            <file>${project.basedir}/src/main/dist/preuninstall.sh</file>
          </beforeRemoval>
          <license>All rights reserved</license>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

Testing OpenAPI Swagger Schema Compliance with Java, JUnit and assertj-swagger

Fri, 31 Aug 2018 00:00:00 +0200

The OpenAPI and Swagger API description format are becoming important standards to specify API contracts for RESTful web services and the Microservices trend pushes the need for such contracts even further.

Therefore arises the need for software architects, testers and developers to write tests to verify if an exposed API follows such a specified contract.

In the following tutorial I will demonstrate a setup with Java, Maven, JUnit and the designated contract-testing-library, assertj-swagger that verifies the validity of such a contract exposed by a Spring Boot application against a local stored definition.

Resilient Architecture in Practice – Circuit Breakers for Java: Failsafe, Javaslang, Hystrix and Vert.x

Tue, 14 Feb 2017 00:00:00 +0100

When dealing with remote services or APIs there is always the risk of latency issues, failures or connection losses. The worst thing to happen is when the remote service is down and our application hangs until the underlying protocol’s (e.g. TCP) connection timeout is reached and we’re receiving an exception. Until this moment is reached, our application might hang, memory is allocated for threads or bound objects and at last, our continuous requests might prevent the remote system from recovering.

Creating Microservices with Bootique

Sun, 18 Sep 2016 00:00:00 +0200

When it comes to writing microservices in Java, plenty of tools and frameworks exist. In the following tutorial, I’d like to demonstrate another minimalistic framework called Bootique by implementing a simple microservice exposing its functions either as a RESTful web-service or as a runnable command executed using the command line.

Bootique Command Line

Dependencies

Using Maven here, we’re adding the following elements to our project’s pom.xml:

Bootiques Bill of Materials as dependency management: bootique-bom
Bootique Jersey for our REST service: bootique-jersey
Bootique Logback for logging: bootique-logback
Maven Shade Plugin to assemble our fat-jar

Integrating Swagger into a Spring Boot RESTful Webservice with Springfox

Wed, 01 Jul 2015 00:00:00 +0200

Spring Boot allows us to create RESTful web-services with ease, Swagger specifies a format to describe the capabilities and operations of these services and with Swagger UI it is possible to explore our REST API with a nice graphical user interface in our browser.

Springfox is a project that aims at creating automated JSON API documentation for API’s built with Spring and is used in the following tutorial to integrate Swagger into a sample application.

Documenting RESTful Webservices in Swagger, AsciiDoc and Plain Text with Maven and the JAX-RS Analyzer

Tue, 16 Jun 2015 00:00:00 +0200

A variety of different tools exists to help us analyze RESTful web-services and create documentations for their APIs in different formats.

In the following tutorial I’d like to demonstrate how to document an existing JAX-RS web-service in multiple formats like Swagger, AsciiDoc or Plain Text using Maven, the JAX-RS Analyzer and the JAX-RS Analyzer Maven Plugin.

The JAX-RS Analyzer gathers its information not only by reflection like most other tools but also by bytecode analysis and therefore does not require us to add special annotations for documentation to our code.

Marrying Java EE and BDD with Cucumber, Arquillian and Cukespace

Wed, 07 Jan 2015 00:00:00 +0100

Having written about the basics of using Cucumber in a Java project in my last blog article, I now would like to demonstrate how to use a similar setup in a Java EE web project with Arquillian and the Cukespace library.

In the following tutorial, we’re going to write a full Java EE web application and add BDD-style tests to the project so that we’re able to test our business layer on the one hand and the user interface on the other hand using Arquillian Drone and Selenium.

JAX-RS Server API Snippets

Sun, 28 Sep 2014 00:00:00 +0200

Because a lot of my current projects are using JAX-RS in different versions I’d like to write down and share some frequently used snippets for implementing RESTful web-services with the JAX-RS specification here.

Using RegEx in Path Expressions

Sometimes we need to extract multiple parameters from a path expression e.g. in the following example where year, month and day are fragments if the path.

@GET
@Path("/orders/{year:\\d{4}}-{month:\\d{2}}-{day:\\d{2}}")
@Produces(MediaType.TEXT_PLAIN)
public Response getOrders(@PathParam("year") final int year, @PathParam("month") final int month, @PathParam("day") final int day) {
	return Response.ok("Year: " + year + ", month: " + month + ", day: " + day).build();
}

Allocating available random Ports in a Maven Build

Wed, 07 May 2014 00:00:00 +0200

Recently in a project I encountered the following problem: The development team used Git with a branch-per-feature-like workflow and the integration server, Bamboo in this case, was configured not only to run the integration-tests for the master-branch but also for every change in a feature branch.

As the team developed a Java EE web application ports like 8080 occasionally were already bound and builds failed.

I knew a plug-in for Jenkins CI I to search for available ports and assign them to a build variable but I wanted to control such information directly within the Maven build life-cycle so I searched and finally found Sonatype’s Port Allocator Plug-in for Maven.

Handling Feature Flags in a Java EE Application using Togglz

Wed, 26 Jun 2013 00:00:00 +0200

Feature flags are a common technique, often combined with continuous deployment and delivery and they allow us to rollback a specific feature, to create A/B tests or to rollout a specific feature for a specific test group, a specific amount of users or dedicated systems.

In the following short examples I’d like you to demonstrate how easy it is to implement feature flags with the Togglz framework with a few steps in a Java EE environment.

Arquillian Tutorial: Writing Java EE 6 Integration Tests and more

Thu, 26 Apr 2012 00:00:00 +0200

Now that the long awaited stable version of the Arquillian framework is released I wanted to demonstrate some interesting features of this framework that really eases writing and running of integration tests for Java EE 6 applications in many different ways.

In the following tutorial we are going to create some real-world examples using Enterprise JavaBeans, Contexts and Dependency Injection, the Java Persistence API and we’re finally running Drone/Selenium tests against a JEE Web Application that is using Java Server Faces.

Testing RESTful Web Services made easy using the REST-assured Framework

Sun, 23 Oct 2011 00:00:00 +0200

Figure 1. REST-assured Integration Test Tutorial Logo

There are many frameworks out there to facilitate testing RESTful webservices but there is one framework I’d like to acquaint you with is my favourite framework named REST-assured.

REST-assured offers a bunch of nice features like a DSL-like syntax, XPath-Validation, Specification Reuse, easy file uploads and those features we’re going to explore in the following article.

With a few lines of code and Jersey I have written a RESTful web service that allows us to explore the features of the REST-assured framework and to run tests against this service.

REST-assured vs Jersey-Test-Framework: Testing your RESTful Web-Services

Mon, 05 Sep 2011 00:00:00 +0200

Today we’re going to take a look at two specific frameworks that enables you to efficiently test your REST-ful services: On the one side there is the framework REST-assured that offers a nice DSL-like syntax to create well readable tests – on the other side there is the Jersey-Test-Framework that offers a nice execution environment and is built upon the JAX-RS reference implementation, Jersey.

In the following tutorial we’re going to create a simple REST service first and then implement integration tests for this service using both frameworks.

Contract-First Web-Services using JAX-WS, JAX-B, Maven and Eclipse

Tue, 23 Aug 2011 00:00:00 +0200

Using the contract-first approach to define a web service offers some advantages in contrast to the code-first approach.

In the following tutorial we’re going to take a look at some details of this approach and we’re going to implement a real SOAP service using JAX-WS, Maven and the Eclipse IDE.

Finally we’re going to run our service implementation on an embedded Jetty instance and we’re going to take a look at soapUI and how to test our service using this neat tool.

Creating a sample Java EE 6 Blog Application with JPA, EJB, CDI, JSF and Primefaces on GlassFish

Tue, 08 Feb 2011 00:00:00 +0100

Java EE 6 is out and it indeed offers an interesting stack of technologies. So in today’s tutorial we are going to build a small sample web application that builds on this stack using Enterprise JavaBeans, Java Persistence API, Bean Validation, CDI and finally Java Server Faces and PrimeFaces.

The application we’re going to develop is a simple blog app that allows us to create new articles, list them and – finally delete them. We’re also covering some additional topics like JSF navigation, i18n, Ajax-enabled components and the deployment on the GlassFish application server.

Creating a SOAP Service using JAX-WS Annotations

Thu, 23 Sep 2010 00:00:00 +0200

It is possible to create SOAP webservices with only a few lines of code using the JAX-WS annotations. In a productivity environment you might prefer using contract-first instead of code-first to create your webservice but for now we’re going to use the fast method and that means code-first and annotations olé!

Creating the SOAP Service

Create a class SampleService with two public methods
Annotate this class with @WebService (javax.jws.WebService) – now all public methods of this class are exported for our SOAP service
To change the name of an exported method, annotate the method with @WebMethod(operationName = “theDesiredName”) (javax.jws.WebMethod)

Finally the service class could look like this

package com.hascode.tutorial.soap;

import javax.jws.WebMethod;
import javax.jws.WebService;

@WebService public class SampleService {
 @WebMethod(operationName = "getInfo") public String getInformation() {
 return "hasCode.com";
 }

 public String doubleString(String inString) {
 return inString + inString;
 }
}

Spring 3, Maven and Annotation Based Configuration

Sun, 22 Aug 2010 00:00:00 +0200

There is still the urban myth that using Spring IoC container without thousands lines of XML code isn’t possible – so today we’re taking a look at annotation based configuration with Spring 3 and of course we’re using Maven..

Setup your project

Create a simple Maven project using

mvn archetype:generate // or
mvn archetype:create

Add a lot of dependencies and reference them to the Spring version defined as a property in your pom.xml. A good reference on Spring 3 and Maven artifacts can be found at Springsource.com

<properties>
     <org.springframework.version>3.0.0.RELEASE</org.springframework.version>
 </properties>
 <dependencies>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-core</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-expression</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>

     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-beans</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context-support</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>com.springsource.org.aspectj.runtime</artifactId>
         <version>1.6.8.RELEASE</version>
     </dependency>
 </dependencies>

Spring Boot Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Define and Configure Log Groups

This allows to configure a group of loggers at the same time

Define a log group named myaspect with two packages
application.properties
```
logging.group.myaspect=com.hascode.package1,com.hascode.package2
```
Configure the log group and set all loggers to level TRACE
application.properties
```
logging.level.myaspect=TRACE
```

This is also possible as parameter on startup

java -Dlogging.level.myaspect=TRACE myapp.jar

Use JUnit 5 with Spring Boot

Use newer versions of Surefire and Failsafe plugins:

<properties>
[..]
  <maven-failsafe-plugin.version>2.22.0</maven-failsafe-plugin.version>
  <maven-surefire-plugin.version>2.22.0</maven-surefire-plugin.version>
</properties>