Java on tty4.dev

Hexagonal Architecture: The Good And The Hard Parts

Fri, 20 Dec 2024 19:34:11 +0100

There’s a lot of stuff written about Hexagonal Architecture. I also wrote some things about it, but covered just the basics.

Now with more experience of using the Hexagonal Architecture style in Java with Spring Boot, I thought it’s time to reflect what are the good and the hard parts of it.

Few Words For The Beginning

You may notice that I don’t write “The Good And The Bad Parts”. That’s because on one side I really like the application of Hexagonal Architecture in the context of professional work. On the other side I found that the “hard parts” are a challenge in nearly every architecture style and not just in Hexagonal Architecture.

Define An Extensible Or Generic JPA Repository

Sun, 20 Oct 2024 11:22:29 +0200

The @NoRepositoryBean annotation allows to define an extensible / generic JPA repository in Spring Boot:

@NoRepositoryBean
public interface BaseAnimalRepository<T> extends JpaRepository<T, Long>

From the documentation of the @NoRepositoryBean:

This will typically be used when providing an extended base interface for all repositories in combination with a custom repository base class to implement methods declared in that intermediate interface. In this case you typically derive your concrete repository interfaces from the intermediate one but don’t want to create a Spring bean for the intermediate interface.

Capture Logs In Spring Boot Tests

Fri, 11 Oct 2024 20:01:10 +0200

To assert that a specific message is logged in a Spring Boot application, the OutputCaptureExtension can be used.

Here’s an example test:

@ExtendWith(OutputCaptureExtension.class)
public class MyServiceTest {

    private MyService myService = new MyService();
    private static final String MESSAGE = "Hello World!";

    @Test
    public void testLogMessage(CapturedOutput output) {
        myService.logMessage(MESSAGE);
        assertThat(output.getOut()).contains(MESSAGE);
    }
}

The CapturedOutput API serves different methods to get the output.

About: How Netflix Really Uses Java

Fri, 01 Mar 2024 20:26:10 +0100

This talk about “How Netflix Really Uses Java” by Paul Bakker at QCon gives some interesting insights.

Especially the first ~20 minutes about the overall architecture and how it evolved is nice to see.

But, beside of that there were some other think pieces about using Java at higher scale:

Netflix tries to save resources and money, by leveraging configurable Java features like Garbage Collection.

Also, Netflix seemed to be trying to use RxJava, but found some downsides, as many devs did: It is really hard to understand and debug. Some people say it’s hard to develop, because you need to exactly think about what could happen in beforehand. But this can also slow down development.

How Spring MVC Handles Requests: A Detailed View

Sun, 04 Feb 2024 20:54:10 +0100

In my last post I already about the high-level view of how Spring MVC handles incoming requests.

Foreword

This post provides a more detailed view of how Spring handles requests like this:

@PostMapping(value = "login", consumes = MediaType.APPLICATION_JSON_VALUE)
public String login(@RequestBody User user)  {
    return "Logged in!";
}

However, please note: It pertains to version 6.1 of the Spring Framework and may change in the future. Furthermore, it only covers the request processing from the filter chain until the resolution of the request body.

The high-level view of how Spring MVC handles requests

Sat, 03 Feb 2024 19:01:10 +0100

In the recent days I tried to understand how Spring Boot handles requests like this:

@PostMapping(value = "login", consumes = MediaType.APPLICATION_JSON_VALUE)
public String login(@RequestBody User user)  {
    return "Logged in!";
}

Spring MVC is responsible for the handling.

The result is this high-level overview of it which separates its work in three blocks:

A post with a more detailed view follows, but the main block with the component which controls everything is shown in the image: The DispatcherServlet.

Spring: Bind values in x-www-form-urlencoded requests

Tue, 30 Jan 2024 19:59:10 +0100

In Spring Boot it’s not possible to map request field names to property fields with @JsonProperty when a request method is consuming application/x-www-form-urlencoded type of requests. The reason is that there’s no JSON payload in the body to consume.

To resolve this @BindParam has to be used.

Note This feature is available since Spring 6.1. and Spring Boot 3.2.0.

Check the following working example:

@RestController
@RequestMapping(path = "/user/")
public class UserController {

    @PostMapping(value = "login", consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
    public String login(User user)  {
        // user.username is not null
        return "Logged in!";
    }

    @Data
    @AllArgsConstructor
    public static class User {
        @BindParam("user_name")
        private String username;
        private String password;
    }
}

The username property will get the value of the user_name field passed in the request. That behaves the same as using the @JsonProperty in requests of the type application/json with Jackson.

Aggregate exceptions in Spring with ControllerAdvice

Sun, 21 Jan 2024 15:26:10 +0100

Exceptions can affect the readability of code in a negative way. One way to mitigate this is to handle exceptions in one central place.

In Spring Boot you can use @ControllerAdvice for this.

I’ll show an example, but keep in mind that there’s more than shown here. So, read up the Javadoc for ControllerAdvice to get more information on the features and ways to configure it.

The problem

Let’s say the following exception is thrown anywhere in the code:

Javadoc Generation Error: Bad HTML Entity

Sun, 07 Jan 2024 12:24:10 +0100

Recently when I tried to generate some Javadoc I got an error like this:

error: bad HTML entity
     * Get the current date & time.

The generation fails as Javadoc tries to get the character entity although an ampersand character (&) is no character entity.

I think of 3 different solutions for it.

Use the character entity

One solution for it can be to just use the character entity:

Suppressing unchecked cast warnings with Spring CastUtils

Sun, 17 Dec 2023 23:24:10 +0100

Let’s say there are classes which are types of Vehicle. For example:

public class Bike extends Vehicle {}
public class Car extends Vehicle {}

Now, when there’s a class with a method that returns a T it may look like this:

public T getVehicle(String type) {
    if (Objects.equals(type, "car")) {
        return carWorker.get();
    }

    return bikeWorker.get();
}

Note: That’s a simplified method to focus on the problem.

The IDE will show directly the error that Vehicle or Car is not of type T.

Clone before use: preventing TOCTOU attacks

Sun, 17 Dec 2023 17:24:10 +0100

Mutable variables can lead to vulnerabilities or unexpected behavior.

Consider the following piece of code as a demonstration:

public boolean checkDomain(HttpCookie httpCookie) {
    if (httpCookie == null) {
        throw new NullPointerException();
    }

    if (httpCookie.hasExpired()) {
        // throw exception
    }

    return isDomainValid(httpCookie.getDomain());
}

What could go wrong here? The problem with this code is that the method doesn’t has any control about what happens with the httpCookie.

So, the value of it could change between the check (if-clause) and the use (return statement). E.g. the cookie’s domain could be changed before it is checked.

Using VSCode as a Java IDE

Sat, 16 Dec 2023 10:30:00 +0100

Some unsorted thoughts about using VSCode as a Java development environment.

I tried more than once to use VSCode as my Java editor, but it didn’t give me the same experience as IntelliJ IDEA.

The UX was often really low and sometimes I just didn’t understand why I got error pop-ups or where I can find the settings for my use case.

There is a lot more to say like the low debugging-experience in VSCode while IntelliJ is outstanding in many matters or how tight the integration of Java into IntelliJ is.

Bring Java CRaC into your IDE (VSCode and a little bit about IntelliJ IDEA)

Fri, 15 Dec 2023 15:46:00 +0100

After looking at CRaC I thought it would be nice to create checkpoints from within an IDE. It’s more comfortable, to do it from within the IDE then using the CLI. Furthermore it may be easier to do it when you start your service every time with the -XX:CRaCCheckpointTo command.

The code is in this commit on GitHub.

Key takeaways

Before I show you how I did it for VSCode here are some takeaways:

Java CRaC

Thu, 14 Dec 2023 16:46:00 +0100

Java is not a language which is famous for its fast startup-time when using a framework like Spring. Sometimes you need this when running time-sensitive applications or for example functions as a service which build on top of fast start-up times.

Luckily there’s some work regarding this like GraalVM or CDS.

Another feature which promises to solve this problem is built on top of Linux’ CRIU and is called Coordinated Restore at Checkpoint or abbreviated CRaC.

Java Generics: Upper Bounded and Lower Bounded Wildcards

Thu, 16 Nov 2023 22:09:10 +0100

I already took a look at the difference between Wildcards and Types in Java.

Now it’s time to take a closer look at Wildcards. Specifically, bounded and unbounded wildcards.

You may sometimes came across this when seeing either this signature parameter or error message:

List<? super Animal> animals

capture of ? extends Animal

Let’s see what this means.

Bounded Wildcards

Generally, bounded wildcards can be used to relax or restrict wildcard variables.

There are two of them: Lower Bounded Wildcards and Upper Bounded Wildcards.

Java Generics: When to use Wildcards and when to use Types?

Thu, 16 Nov 2023 22:09:00 +0100

When reading Effective Java by Joshua Bloch I came across the chapter about Generics and the difference between using Wildcards and Types.

I did some further research to understand it more and this is the write up of it. Let it confuse you as much as me or let it be helpful.

When to use which

I found three statements which describe when to use what:

If a type parameter appears only once in the declaration, then replace it with a wildcard. (Effective Java by Joshua Bloch)

The crucial distinction between equals and compareTo in Java

Thu, 21 Sep 2023 20:35:00 +0200

… or: Why 1 is not equals 1.0 when using BigDecimal.

Languages have sometimes their own special behavior, which you need to know when you want to use it right.

Sometimes you forget about it and then you remember some specific behavior when you try to use it.Let’s take a look at the crucial difference between equals and compareTo in Java.

`equals` of `BigDecimal`

Look at this two BigDecimals:

final BigDecimal BIG_DECIMAL_1 = BigDecimal.valueOf(1);
final BigDecimal BIG_DECIMAL_1_0 = BigDecimal.valueOf(1.0);

Normally you’d say that they have two equal values, and should be equal, because 1 = 1.0.

How to get Spring STOMP to parse messages successfully

Sun, 10 Sep 2023 15:04:00 +0200

Recently I updated my article about STOMP in Spring Boot and faced some issues to get a running example with the latest Spring Boot and websocket version.

I tested the code with Spring Boot 3 and the version 3.2.0-SNAPSHOT of the websocket library. My problem was that the message which I received wasn’t parsed correct.

Here are some notes to attack and prevent some of the appeared problems. Maybe they’re helpful for someone (or me in the future).

All Java 21

Mon, 21 Aug 2023 02:00:00 -0100

Just few days left until Java 21 is generally available (September 19, 2023).

I’ve read and collected resources which discuss all the features which 21 will bring.

You can follow the schedule one the page of the OpenJDK project.

The four available JEPs

Namely, there are 4 JEPs which are final and can be used in production:

JEP 431: Sequenced collections

Enhances the Java collection framework with a Collection that contains elements in a particular order. The SequencedCollection interface has been introduced for this.

Testcontainers in Spring Boot 3.1

Fri, 18 Aug 2023 09:00:00 -0100

I already wrote two times about Testcontainers. Once I showed an example for the usage in Spring Boot. And the other time how to manage the lifecycle state and tear the connection down.

Spring Boot 3.1 changed the way how you can use Testcontainers. There are a lot ways to use Testcontainers and now there’s another, far easier way to do it.

Before Spring Boot 3.1

Before Spring Boot 3.1 you had two ways to connect to a Testcontainer.

JUnit 5: Annotations for @ParametrizedTest

Wed, 16 Aug 2023 02:00:00 -0100

I like the idea of parametrized tests in JUnit 5. Instead of writing 5 methods for one method and just changing the arguments, write the test case once and serve the arguments as a stream.

This makes refactoring and maintenance of test code far easier.

But, when you want to implement a ParametrizedTest you need to use the correct annotations and sources for the arguments.

Check the following example:

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {DeviceService.class})
public class DeviceServiceTest
{
   @Autowired
   private DeviceService deviceService;

   private static Stream<Arguments> deviceArgs() {
      return Stream.of(
            Arguments.of(Device.builder().deviceId(1).name("Raspberry Pi").build()),
            Arguments.of(Device.builder().deviceId(2).name("Banana Pi").build())
      );
   }

   @ParameterizedTest
   @MethodSource("deviceArgs")
   public void storeDeviceTest(Device device) {
      deviceService.storeDevice(device);
   }
}

streamDevices serves the Arguments. This method must be static.

Event sourcing in Java: First steps

Wed, 31 May 2023 10:00:00 -0100

This post belongs to a series about my DDD journey.

Check also: Concepts of Event Sourcing.

In this post I will write up my approach to implement event sourcing in a Java application. This sample application aims to give a feeling about the DDD building blocks and which challenges in event sourcing are coming up.

The service

Let’s assume that we shall build a service for a shop which contains clients and orders. As a first step we will build the service with the client model which applies event sourcing.

A static search for my blog

Sun, 30 Apr 2023 10:00:00 -0100

More than once I’ve been thinking about a static search for this blog.

This site is using Hugo as a site generator. There are some search solutions for Hugo sites, but I thought it would be a fun project to work on and create a solution for my own.

So I split the problem up in three parts:

Create a JSON-representation of my blog.
Create an index out of this json representation.
Search the index on the client-side.

flowchart LR subgraph js['Site generator'] direction TB Blog(Page content) Blog --> Hugo Hugo -->|generate| JSON1(page.json) end subgraph ig ['Index generator'] IG[Index Generator] JSON1 --> IG IG -->|generate| IDX(index.json) end subgraph se['Search engine'] IDX --> SE[Search Engine] Terms(Search terms) --> SE SE --> |output| Res(Results) end UI --> Terms

The following sections are about the implementation and give insight to my thoughts.

Experiencing functional programming in Java

Sun, 02 Apr 2023 01:00:00 -0100

In the recent days I’ve been working on my Functional Programming skills in Java.

Reading about it and implementing small functions makes it easy to understand the basics. But it’s always better to have hands-on experience.

So I gave myself the task to implement a service which creates a simple search index for this blog.

The idea

The core idea is to realize the following flow:

As you can see, this is already a pipe which can be realized through the chaining of functions:

Functional Programming in Java

Sun, 12 Mar 2023 02:00:00 -0100

Functional programming can be achieved in Java, though it needs a lot of discipline to not mix things up. This post discusses the different ways of doing things in a functional way in Java.

When you know the basics of functional programming and want to start with that style in Java, you should keep the following interfaces in your mind:

Supplier       ()    -> x
Consumer       x     -> ()
BiConsumer     x, y  -> ()
Callable       ()    -> x throws ex
Runnable       ()    -> ()
Function       x     -> y
BiFunction     x,y   -> z
Predicate      x     -> boolean
UnaryOperator  x1    -> x2
BinaryOperator x1,x2 -> x3

(List from stackoverflow.com)

The shift of thinking: Imperative vs. declarative programming

Sat, 04 Mar 2023 02:00:00 -0100

A key characteristic of functional programming is the declarative way of describing how software shall behave.

In contrast to that stands the imperative style, where you give step-by-step instructions what the program shall do.

Von Neumann Architecture

The reason why the imperative style lasts so long and is so old, lays in the way how computers work.

The basis of our computers til today is the von Neumann architecture.

In the von Neumann architecture the computer gets instructions which tell it how it should work. So the algorithm is imperative and tells which data should be loaded and which instruction shall be executed.

Java, Cloud, IoT Trends in 2023

Tue, 03 Jan 2023 02:00:00 -0100

I hope you all had a good start into the new year! 2023 is just a few days old and it is not only time to look at the things that happened in the past year. Here I want to give insights on to the trends which I think Cloud developers should keep an eye on. As my experience mainly lays in the cloud, java and IoT area, this is the part at which I’ll focus on here.

Testcontainers revisited: Managing the lifecycle of the database

Mon, 28 Nov 2022 02:00:00 -0100

I created a follow-up for Spring Boot 3.1. Check it here

Even when things changed, the concept of Testcontainers is the same and you can use it also in the way it is described here.

Few weeks ago I was taking a look at Testcontainers.

Two questions arrived:

How to keep the database connection open and reuse it.
Clean up the database between tests.

The post was Spring Boot specific, but here I’ll also have a look at plain Java projects.

Using Testcontainers in a Spring Boot application with MariaDB

Sun, 13 Nov 2022 09:00:00 -0100

I created a follow-up for Spring Boot 3.1. Check it here

Even when things changed, the concept of Testcontainers is the same and you can use it also in the way it is described here.

When writing integration tests for a service one of the problems which need to be attacked is the database: You want to assure that an entry is really stored in the database.

For that there are multiple ways, like using a test instance of a database, using a deployed database and use a prefix for all data for later deletion, a local database or an in-memory database like H2.

How to use Mockito to test the behavior of a Java application - in a nutshell

Mon, 24 Oct 2022 02:00:00 -0100

Mockito is a really powerful tool. And even more: It’s documentation and logs are so good, that you don’t need to look at the documentation if you’re misusing it! Here I’ll show some of the common functions I’m using with a small example.

Example application

I’ll show you an example application, which I’ll use within the next sections. The example may not to seem so logical, but it will show you the most important things.

Building and running a Docker container for a Java application

Sat, 24 Sep 2022 09:00:00 -0100

There are different ways to build a Docker image locally of your Java application and start a container.

This one is more of a step-by-step guide, which can also be automated by a local script. If you want you can also move the build steps into the Dockerfile, if it doesn’t give you any conflicts in a pipeline.

The Dockerfile

First, create a Dockerfile in the root of your project. Consider to choose the right JDK version for your project.

Using DBRider for a clean state between JUnit tests

Fri, 05 Aug 2022 09:00:00 -0100

Whenever you write Java/Spring Boot tests which are using database access (e.g. when running a @SpringBootTest), you should clean up the database to have a clean state between your tests.

In fact, this is not a trivial task as some of these problems can appear:

You may need to check that you don’t insert or delete data between tests and provoke Unique Key or Foreign Key exceptions.
You may tear down and set up the database between test runs.
You could tend to define an order of test runs which works. But this is not good as this creates a ‘happy path’ for your tests.
You may tend to insert data always with already set primary keys. These primary keys are not allowed to be used by other tests. That’s not good as you need the knowledge of all these primary keys.

But that’s not good! When you test the behavior of your application you should not implement extra database checks to make sure that before and after your test you have a good state of the database.

How to fix H2 error: 'Syntax error in SQL statement ... expected identifier'

Sun, 29 May 2022 02:00:00 -0100

I had an Entity User in my Spring Boot application and storing information with a Repository to my MariaDB database worked fine.

But when testing it with a H2 database, I got the following issue:

Syntax error in SQL statement "select user0_.user_id as col_0_0_ from [*]user user0_ where user0_.email=? limit ?"; expected "identifier"; SQL statement:
select user0_.user_id as col_0_0_ from user user0_ where user0_.email=? limit ? [42001-212]

Well I know that H2 behaves sometimes different than MySQL even if you set the mode to MySQL. So I dig deeper.

Looking forward to Kotlin and Wasm

Tue, 05 Apr 2022 08:00:00 -0100

Since 2018 I’m looking after the progress of WebAssembly as I think it is a quite interesting technology and can be the technology of the future.

On the official Wasm page you can see which languages do support the compilation to Wasm.

However one very interesting thing for me is the support of Kotlin.

The current state of Kotlin and Wasm

With the introduction of the new K2 compiler Kotlin also announced that there will be better and faster support for the compilation to Wasm.

Implementing a STOMP client in a Spring Boot application

Sun, 13 Mar 2022 19:00:00 -0100

STOMP is a good and easy protocol to communicate in realtime via WebSockets.

If you want to implement such a client in your Spring application, you can use Springs simp package, which provides all you need to start quickly.

Requirements

This article focuses on the STOMP client, so you need a server you can subscribe to and consume messages from. (See also: A simple STOMP server & producer application)

Also, you need the spring-boot-starter-websocket library as a dependency. E.g. in Gradle:

Output IntelliJ IDEA logs to a local file

Tue, 08 Mar 2022 16:00:00 -0100

If you want to store logs of a Gradle run to a file, just add the filepath (including the name) via the UI.

For this you need to follow these options:

RUN -> Edit configurations -> Application -> Save console output to file...

This file is overwritten on every rerun.

Message ordering with Java Semaphores

Sun, 06 Mar 2022 22:00:00 -0100

Semaphores are useful to limit the access of concurrent threads to a resource.

This can be: A class instance, a variable or a method.

You can use it to assert that in critical parts of your code no parallel requests are happening.

Example use-case: Ordered messages

I used Semaphores in the financial world to assure, that time-sensitive messages had been send to an external resource in a specific order.

Every message had an order number which was counted up on every send.

Spring @Scheduled annotation - fixedDelay vs. fixedRate

Sun, 27 Feb 2022 08:00:00 -0100

Once I had some fun to debug a scheduled method which executes a request every 1 second.

I got told, that it works fine, but the request seems to get missed now and then.

We have been using Spring Boots @Scheduled(fixedDelay = 1000) annotation:

2022-01-24 11:13:47,974  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:48,976  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:49,991  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:51,013  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:52,016  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:53,024  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!

You can see that the milliseconds counter rises. That is due the correct behavior of fixedDelay: It executes the method every second after the last execution got finished.

Spring Boot and Kubernetes Configmaps

Thu, 17 Feb 2022 00:00:00 +0000

This document was last revised on 2022-09-24 and updated for the usage with Spring Boot 3.

Check the Repository for an executable example.

Deploying your Spring Boot applications in a Kubernetes environment will bring you many benefits like for example the usage of Configmaps.

What are Configmaps

Configmaps are API objects which store data in key-value pairs. This data can be consumed by your application as environment variables or CLI arguments.

Debugging with Gradle: See what happens during gradle builds

Mon, 17 Jan 2022 19:09:00 -0100

Sometimes the normal gradlew clean build doesn’t really help in the understanding why a gradle build fails.

In my case this issue once occured when a build on a Jenkins server failed, but not on my local machine (classic).

So there are two things which can be really helpful when debugging failed gradle builds.

Being very verbose

The following command will print you information during the gradle build, which can help you during debugging.