DEV Community: mirko

Serializing an enum in a Spring Boot web application

mirko — Wed, 08 Jan 2025 20:46:07 +0000

Enum is a good structure to define a set of limited and well defined values inside the domain of our application. They could help to prevent impossible states in our codebase.

The scenario

Let's use a note taking web application as an example to show the possible ways to serialize and deserialize an eum value.

We are going to implement it using Spring Boot 3.3.x and MongoDB.

We define a Type enum class to represent the permitted types of todos inside the application: events and activities.

public enum Type {
    EVENT("event"),
    ACTIVITY("activity");

    private Type(String value) {
       this.value = value;
    }

   public String getValue() {
       return value;
    }

}

Our Todo class

public class Todo {

    private String id;
    private String name;
    private boolean completed;

    private Type type;

    ...
    ...

}

We are going to analyze enum serialization in these scenarios:

Enum as query param.
Enum as part of a JSON body request.
Enum as a field of a MongoDB document.

Enum as query param

In this scenario we need only a deserialize method because we are interested in transforming from a string value to the enum.

Below a snippet of code representing the Controller method to read all todos by types, the type is passed as a query parameter.

 public Collection<Todo> read(@RequestParam(required = false) Type type) {
     ...
     ...
 }

The query parameter is a string so we have to define an appropriate Converter to transform it.
Inside the convert method we call Type.fromString, a static method created in the enum class, that will be used in other scenarios too. The code of fromString method is presented in the next scenario.

public class StringToType implements Converter<String, Type> {

    @Override
    public Type convert(String source) {
        return Type.fromString(source);
    }

}

The converter must be registered in the application.

@Configuration
public class Config implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new StringToType());
        WebMvcConfigurer.super.addFormatters(registry);
    }
}

Now when we will use Type as a RequestParam the StringToType converter will be used to try converting string values in our enum.

Enum as part of JSON body request

To manage correctly the enum as a field of the JSON body content we should add some code to the enum Type class.

We need to use the annotation @JsonValue to mark the field as the value to use for serializing the enum.
Then we should add a static map inside the enum to map the Type with the related string representation.

public enum Type {
    EVENT("event"),
    ACTIVITY("activity");

    @JsonValue
    private String value;

    private static Map<String, Type> enumMap;

    private Type(String value) {
        this.value = value;
    }

    static {
        enumMap = Stream.of(values()).collect(Collectors.toMap(t -> t.value, t -> t));
    }

    public static Type fromString(String value) {
        return enumMap.get(value);
    }

    public String getValue() {
        return value;
    }

}

Enum as a field of a MongoDB document.

To manage the serialization/deserialization of a enum in a MongoDB document we have to use the @ValueConverter annotation that binds a field of the document with a specific PropertyValueConverter class.

In the example the field Type type is bound with the MongoEnumConverter that provide read and write methods to manage the conversion.

@Document(collection = "todo")
@TypeAlias("todo")
public class Todo {

    @Id
    private String id;
    private String name;
    private boolean completed;

    @ValueConverter(MongoEnumConverter.class)
    private Type type;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isCompleted() {
        return completed;
    }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }

    public Type getType() {
        return type;
    }

    public void setType(Type type) {
        this.type = type;
    }

}

In detail in the read method we call Type.fromString from the enum class to try to convert the string in a valid Type instance.

public class MongoEnumConverter
        implements PropertyValueConverter<Type, String, ValueConversionContext<?>> {

    @Override
    public Type read(String value, ValueConversionContext<?> context) {
        return Type.fromString(value);
    }

    @Override
    public String write(Type value, ValueConversionContext<?> context) {
        return value.getValue();
    }

}

In conclusion

In this article I presented some ways to manage the serialization/deserializion of a enum class in a typical Web scenario. Spring and the Jackson library provide some facilities to simplify this work.

The code is publically available in this Gitlab repository.

The code presented in this article are under CC0 license.

Elm, an alternative to Javascript

mirko — Sat, 05 Nov 2022 10:41:54 +0000

What is Elm ?

Elm is a pure functional programming language with a strong type system. It is Open Source (released under BSD-3-Clause license) and this year is 10 years old.

The current version is 0.19.1 and it is surrounded by an active community.

Elm is "domain-specific", its goal is to help you building front-end web applications.
The compiler produces optimized Javascript code to run into the browser. It supports developer with a detailed and more clear as possible output to help resolve errors.

An example of compiler output:

naming error
Line 44, Column 12
I cannot find a `Timestamp` type:

44|       ts : Timestamp,
               ^^^^^^^^^
These names seem close though:

    Timstamp
    Time.Zone
    Task.Task
    Time.Month

Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`
declarations work in Elm.

There is an online editor, named Ellie, to play with the language without the need to install anything on your machine.
Ellie permits to install dependencies for your code, so you can prototype an entire project with it.

Applications in Elm follow the TEA (The Elm Architecture), an architectural pattern based on the following concepts:

Model: the state of the application.
View: transforms model into HTML code.
Update: updates the model intercepting messages which came from the user interaction with the view.

Why Elm ?

I started using Elm because I wanted to experience with the functional paradigm.
I tried it using Javascript, but its multi-paradigm nature didn't help me in having a focused functional experience, so I decided to try with an only-functional language and I discovered Elm, described as a good first step into the functional world.

To take practice with Elm I implemented a tiny project ts-converter: a browser extension to translate timestamps into human readable dates.
Ts-converter is released as a libre software under GPLv3 license.

My first experience with Vala

mirko — Wed, 19 Oct 2022 07:11:17 +0000

This article is a short resume of my first experience with Vala.

What is Vala

Vala is an object-oriented programming language with a syntax very similar to C#.
The compiler could produce a native binary or generate C code.

The current version is 0.56, meanwhile I used the 0.54.1.

The language was born in 2006 and although it hasn't reach the version 1.0 it's used in a lot of GNOME applications and it's the main choice for implementing application in Elementary OS.

Why Vala

I'm interested in the creation of GTK applications for Linux.
The possibilities I found to reach this goal are:

Use C, but I used it only for an exam in my first university years. I was afraid to not reach a concrete result in a short time.
Use Python, probably the simple solution, but I was interested in creating a native application.
Use Go, but my perception was that the GTK libraries for Go were immature and incomplete.
Use Rust, but I was intimidated by the steep learning curve.

So I decided to explore Vala because:

it's a language created by the GNOME Foundation with the scope to permit the implementation of native GNOME (so GTK) application at a high level.
it's well integrated with GTK libraries so it permits to be immediately operative.

First impressions

Some considerations after this short experience.

I have to admit that it has been not so easy to reach my goal. I think that a lot of problems and slowness has been caused by my inexperience in developing desktop applications in general.

The official Vala documentation is valadoc.org.
I found the ecosystem of libraries around the language still immature: it's not easy to found information or examples (and often when you find something it's pretty old). There isn't a standardization of the documentation of the libraries. This fact doesn't help a newbie.

Looking some examples implemented in Python, it helped me a lot to understand how to use notifications and how to implement an indicator (the main part of my little experiment).

In the next future I'm going to try again to implement other simple applications using Vala.

Pommy

Pommy is a simple timer to measure an activity duration. It's an indicator staying in the notification bar and it notifies you the end of the activity session.

It takes inspirations from gtk-pomo-indicator, a Python application I used for years to break my daily routine into work sessions, following some concepts from the pomodoro tecnique.

Pommy is released under GPLv3 and it is available here.

Four rules to maintain the motivation high working to your projects

mirko — Sat, 20 Nov 2021 16:17:13 +0000

Resting is the most long-lived side-project of mine.
I have been working on it since December 2017.

It's not easy to maintain the focus on the same project for such a long time: so many mermaids try to attract your attention in new wonderful projects 🧜‍♀️🧜‍♀️🧜‍♀️🧜‍♀️🧜‍♀️🧜‍♀️.

I think the main obstacle is to keep the motivation on the project.

These are four advises to maintain the motivation high.

Schedule a daily window

Schedule a moment to work to your project every day. I don't think it's important to invest a big amount of time, but to preserve this moment ongoing.

I believe that even 15/30 minutes per day are enough and the results will be visible after some time.

Discuss with a friend

It's important to have someone to speak with. It helps you to understand the evolution of the project.

If you haven't the lucky to speak to someone, think about enter in a focused online community like:

Indie Hackers,
LinkedIn Side-projects,
subreddit SideProject,

Spread your project

Take the courage of speaking publicly about your project. You have to move the project from your head to the real world.

Public speaking about it makes your project real and creates good expectations about it.

Take a short development iteration

Take a short development cycle of your project. This permits you to perceive the real progress of your project and to be more flexible about the future.
Your enthusiasm increases perceiving the effective progress of your project.

Don't be a perfectionist: it's better to release an idea of the feature and improve it in the next iterations.

Retrospective of an hackathon

mirko — Tue, 31 Aug 2021 12:18:07 +0000

Yesterday I found some notes written the past year about a personal retrospective after the participation to my first remote hackathon.

I want to share with you some hints I learned:

There are a lot of tools to organize and manage the work of a remote team without too much pains.
Well, but I think everybody learned it in these strange time.
Use every library, framework or everything else you know to prototype the result in a quick way. In this context: "the idea is better than the solidity of the solution".
Invest some time implementing a base build and deploy workflow will have great ROI in the last part of event.
Invest more time into the initial brainstorming and then plan some global checkpoints to fix the idea.
Do few quick video chat and maintain an active textual chat to align in real time the team about the progress of single tasks.
Simplify, simplify and simplify.
Be available and pro-active.
Work to unblock the work of other members of the team.

Italian 🇮🇹 speakers can found the article here

Port react tutorial in vuejs

mirko — Wed, 07 Jul 2021 09:38:07 +0000

To improve my vuejs skill I decided to take the tic-tac-toe game from the reactjs tutorial and re-implement it in vue 2.x + vuex

The result is available on Github under CC0 license, here
Every comment or suggestion to improve the code is welcome 🙏

An emulator of enigma machine

mirko — Sun, 18 Apr 2021 18:39:26 +0000

Hi, it's Mirko here.

During the last weeks I've worked on another funny project to improve my go knowledge.

What is it ?

Enigma is a emulator of the enigma M3 machine, become famous during the II world war and used by nazist army to crypt
their communications.

The project is published on Github and it is released under the Creative Commons Zero license.

Every feedback about the code or project features is very welcome 🙏🏻

A toy shell to play with go

mirko — Tue, 13 Apr 2021 13:33:17 +0000

Hi it's Mirko here.

My learning about go continues.

I have created another learning project to play with the language syntax.
Gosh is a simple toy shell.

Features

Builtin functions: ciao, bye
Suggestion of command options
Possibility to extend suggestions to other commands

The project is available on Github and it is released under Common Creative Zero lincense

Any feedback about the code or the features is welcome!! 🙏🏻

A tool to download attachments from Gmail

mirko — Fri, 09 Apr 2021 10:03:16 +0000

Hi I'm Mirko.
Some months ago I have started learning Go in my free time, because I'm very interesting about it.

The best way I know to learn a new programming language is to use it into a tiny but real and useful (at least for me) project.

This is the story behind gmail-downloader.

What is it ?

It's a cli tool that permits to download all email attachments selecting a particular label from Gmail.
It uses the official google go sdk for gmail.

It's my first experiment using Go and it is released on Github with GPLv3 license.
Every feedback about the code or the features is very welcome 🙏🏻

Event listeners in Elm

mirko — Thu, 28 May 2020 20:15:57 +0000

I am a beginner in Elm and to learn it I have started ts-converter, a tiny browser extension to convert timestamps in a readable format. This is one of my daily needs.
I want to use what I have learnt from it, sharing some notes on how to manage event listeners in a Elm application.
I'll use onEnter event in the examples.

Scenario 1: Listen for all application events

To capture a key pressed in the whole application we need to introduce a subscription

What's a subscription ?

A subscription is an operation allowing us to register to an external event.
Creating a subscription we say to Elm runtime that we want to do an action when a particular event is spawned. When the runtime captures an event, produces an update message.

subscriptions _ =
  onKeyPress keyDecoder

A subscription is created on event onKeyPress and when this event will be intercepted by the Elm runtime the function keyCoder will be invoked.

keyDecoder : Decode.Decoder Msg
keyDecoder =
    Decode.map toKey (Decode.field "key" Decode.string)

The event object is serialized as a JSON object and its field key contains the key pressed value, Decode.field "key" Decode.string extracts this number and puts it into a valid Elm value.
The extracted value is then passed to toKey function.

toKey : String -> Msg
toKey keyValue =
    case String.uncons keyValue of
        Just ( char, "" ) ->
            CharacterKey char
        _ ->
            ControlKey keyValue

String.uncons takes a string as a characters array and splits it into its head and tail.
Depending on whether the leading character is an alphanumeric value
or not, produces the related update message.

CharacterKey k ->
     YOUR CODE
ControlKey k ->
     YOUR CODE

The two messages will be managed into the update function.

Scenario 2: Listen for a event bound to a input field

At the moment (v0.19) Elm doesn't support natively onEnter event, but it offers a function on that permits to create a custom event listener.

onEnter: Msg -> Attribute Msg
onEnter msg =
  let 
    isEnter code = 
      if code == 13 then
        Decode.succeed msg
      else
        Decode.fail "not ENTER"
  in
on "keydown" (Decode.andThen isEnter keyCode)

With on "keydown" (Decode.andThen isEnter keyCode) we'll create a listener on keydown event and the Elm runtime will execute (Decode.andThen isEnter keyCode) on its capture.
keyCode is a bultin function of Html.Events module and it returns the value of pressed key as an integer.
isEnter checks if key enter has been pressed (enter value is 13) producing respectively a message for the update function or a failure.

onEnter is used into the input field we will listen for events.

input [ size 20, value (tsToString model.ts), onInput SetTs, onEnter Convert, autofocus True] []

My side project Resting

mirko — Wed, 13 Nov 2019 15:56:26 +0000

Hi,

in the last two years I have dedicated some my spare time to a side project called Resting.
Resting is a browser extension that permits to analyze and test HTTP and REST APIs.
The mission of Resting is to simplify daily work of developer in testing and analyzing HTTP/REST requests.

Resting takes inspiration from Postman with the goal to be light and focused on the management of saved requests.

It is a Open Source project hosted by Github and it is a community friendly project.
Here is the Github repository

I'm very interested in some feedback about the tool