DEV Community: Carlos Chacin ☕👽

Crea una REST API sin usar ningún Framework con Java Servlets, JDBC, PostgreSQL y Jackson

Carlos Chacin ☕👽 — Sat, 01 Feb 2025 15:00:00 +0000

Crea una REST API sin usar ningún Framework con Java Servlets, JDBC, PostgreSQL y Jackson

En éste video, veremos como implementar una REST API sin usar ningún framework como Quarkus, Micronaut, Helidon o Spring Boot. Usaremos Servlets para exponer la API, JDBC para conectarnos a PostgreSQL y Jackson para la serialización a JSON, Integration Testing con Junit5, AssertJ y TestContainers.

Recursos:

Jetty: https://jetty.org/
HikariCP: https://github.com/brettwooldridge/HikariCP
12 Factor Apps: https://12factor.net/
Código: https://github.com/cchacin/frameworkless-rest-api

Parte 1

Parte 2

🚀 Auto-Switch iTerm2 Modes, Day & Night! 🌞🌚

Carlos Chacin ☕👽 — Mon, 27 May 2024 15:00:00 +0000

iTerm2 recently introduced a great feature: separate light and dark mode colors. This feature enhances the visual appeal of your terminal and keeps it in sync with your Mac’s mode.

This feature is not just about aesthetics; it’s about comfort. Imagine your terminal always matching your Mac’s light or dark mode, creating a seamless and visually pleasing experience. This enhances the visual appeal and reduces eye strain, making your terminal usage more comfortable.

🚀 Auto-Switch iTerm2 Modes: Day🌞 & Night🌚 - YouTube

🔧 Tired of tweaking your iTerm2 day and night?🔄 How often do you switch iTerm2 modes manually? The latest update will end that cycle forever!💻 What's Newi...

youtube.com

The Problem

In the image below, you can notice that the iTerm2 does not change by default when we switch between light and dark modes.

Ok, let’s discover this game-changer feature!

Step 1

Go to iTerm2 settings and click the Profiles tab.

Step 2

Click the Colors tab under Profiles.

Step 3

Enable the checkbox to Use different colors for light and dark mode.

Step 4

Select the desired dual theme. In this case, I’m selecting Solarized, which has light and dark versions.

Step 5

Click on Update Both Modes

The Result

Java 17 + AWS Lambda

Carlos Chacin ☕👽 — Tue, 06 Jun 2023 16:07:00 +0000

AWS recently announced Java 17 support for Lambdas, In this blog post, we’ll explore how to create a Java 17 AWS Lambda Function without IDE, build tool or any dependency.

youtube.com

Fist let’s create the lambda function code:

public class Function {

  public record Input(int x, int y) {}

  public record Output(long result) {}

  public Output add(Input input) {
    return new Output(input.x + input.y);
  }
}

In this example, we have an add method that takes an Input java record with 2 fields: x and y, and returns an Output java record with the sum of x and y assigned to the result field.

This is the only requirement for a AWS Lambda Function:

An instance method that takes one single parameter and returns something an object or Void.

That’s it. Now we can proceed to compile and package our AWS Lambda Function:

Compile:

$ javac Function.java

Package:

$ zip function.zip *.class

Next, let’s navigate to the AWS Lambda Console.

Click on the Create function button.

Assign a lambda name and select Java 17 as the runtime.

Click on the Upload from button.

Click Upload button.

Choose the function.zip file that we generated.

Click Edit on the Code properties section.

Change the Handler to Function::add and click Save.

Go to the Test tab.

Change the JSON payload to:

{
  "x": 123,
  "y": 333
}

Click the Test button, then expand the Details section to see the result.

That’s it! You have successfully created and tested your Java 17 AWS Lambda function. The output should be:

{
  "result": 456
}

This demonstrates the simplicity and power of using Java 17 with AWS Lambda. With just a few steps, you can leverage the latest Java version to build efficient and scalable serverless applications.

Feel free to explore further and unleash the full potential of Java 17 on AWS Lambda. Happy coding!

🏆 Default 🔗 Maven and ☕ Java settings per project

Carlos Chacin ☕👽 — Thu, 23 Sep 2021 06:00:00 +0000

I generally use many different options on maven projects to set up things like memory lower and upper limits, fail at the end, the process in batch, use x number of threads, etc. In addition to this, sometimes I need to pass flags to the JVM like add modules, garbage collector flags, etc., and it is difficult to remember and also error-prone to have something like this:

$ JAVA_OPTS="-Xms512m -Xmx1024m -Djava.awt.headless=true" \
  mvn -B -T 4 -fae -P ci verify

or even worst with the extended version of the flags:

$ JAVA_OPTS="-Xms512m -Xmx1024m -Djava.awt.headless=true" \
mvn --batch-mode --threads 4 -fail-at-end --activate-profiles ci verify

Fortunately for us, since maven 3.3.1, we now can setup this per project, including the flags in these two files relatives to the project directory:

.mvn/maven.config with:

-B -T 4 -fae -P ci

.mvn/jvm.config with:

-Xms512m -Xmx1024m -Djava.awt.headless=true

Now, all we need to do is run the maven command, and the settings in the files will be honored:

$ mvn verify

☕🚢 Maven Build in < 20 lines of yaml 🕟

Carlos Chacin ☕👽 — Wed, 22 Sep 2021 05:08:00 +0000

GitHub Actions makes it easy to automate all your software workflows, now with world-class CI/CD. Build, test, and deploy your code right from GitHub. Make code reviews, branch management, and issue triaging work the way you want.

Create the directory

$ mkdir -p .github/workflows

Create the yaml file

$ touch .github/workflows/maven.yml

Copy this content

name: Maven Build
on:
  push:
    branches:
      - main
jobs:
  build:
    name: "Maven Build"
    runs-on: ubuntu-latest
    steps:
      - name: "Checkout Sources"
        uses: actions/checkout@v2
        with:
          fetch-depth: 2
      - name: "Set up JDK"
        uses: actions/setup-java@v2
        with:
          distribution: "temurin"
          java-version: 11
          cache: "maven"
      - name: "Build with Maven"
        run: mvn verify

Commit and push to Github

$ git add .github && \
  git commit -m "maven build action"

Enjoy your builds

Go to the actions tab for your repository over github.com:

https://github.com/${USER}/${PROJECT}/actions/workflows/maven-build.yml

💾 Java Records 💿 with Jackson 2.12

Carlos Chacin ☕👽 — Thu, 04 Mar 2021 01:33:16 +0000

In the previous article about Java 14 Records, we saw how to start creating Records to avoid writing much boilerplate code that the compiler would generate for us.

Now the next steps are to see how we can serialize records to JSON and deserialize JSON to records to be able to use them as a request/response representation for microservices.

In this case, we would use the Jackson 2.12+.

Continuing with the same example that we used in the previous article, we would need to add Jackson Dependencies to our existing pom.xml file:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.0</version>
</dependency>

💾 Now let’s see our example Record:

record Person(
    @JsonProperty("first_name") String firstName,
    @JsonProperty("last_name") String lastName,
    String address,
    Date birthday,
    List<String> achievements) {
}

💡 Java 14+ compiler would generate all of the following:

$ javap -p Person.class


final class Person extends java.lang.Record {
  private final java.lang.String firstName;
  private final java.lang.String lastName;
  private final java.lang.String address;
  private final java.util.Date birthday;
  private final java.util.List<java.lang.String> achievements;
  public Person(
    java.lang.String,
    java.lang.String,
    java.lang.String,
    java.util.Date,
    java.util.List<java.lang.String>);
  public final java.lang.String toString();
  public final int hashCode();
  public final boolean equals(java.lang.Object);
  public java.lang.String firstName();
  public java.lang.String lastName();
  public java.lang.String address();
  public java.util.Date birthday();
  public java.util.List<java.lang.String> achievements();
}

🔨 Our test setup:

final ObjectMapper mapper = new ObjectMapper()
      .enable(SerializationFeature.INDENT_OUTPUT);

To serialize/deserialize a record like this:

var person = new Person(
    "John",
    "Doe",
    "USA",
    new Date(981291289182L),
    List.of("Speaker")
);

To/From a json string like this:

{
  "first_name" : "John",
  "last_name" : "Doe",
  "address" : "USA",
  "birthday" : 981291289182,
  "achievements" : ["Speaker"]
}

💊 Testing Serialization

@Test
void serializeRecord() throws Exception {
    // Given
    var person = new Person(
            "John",
            "Doe",
            "USA",
            new Date(981291289182L),
            List.of("Speaker")
    );

    var json = """
            {
              "first_name" : "John",
              "last_name" : "Doe",
              "address" : "USA",
              "birthday" : 981291289182,
              "achievements" : ["Speaker"]
            }""";

    // When
    var serialized = mapper.writeValueAsString(person);

    // Then
    assertThat(serialized).isEqualTo(json);
}

💊 Testing Deserialization

Let’s use the same record to try the deserialization using also the same configuration:

@Test
void deserializeRecord() throws Exception {
    // Given
    var person = new Person(
            "John",
            "Doe",
            "USA",
            new Date(981291289182L),
            List.of("Speaker")
    );

    var json = """
            {
              "first_name" : "John",
              "last_name" : "Doe",
              "address" : "USA",
              "birthday" : 981291289182,
              "achievements" : ["Speaker"]
            }""";

    // When
    var deserialized = mapper.readValue(json, Person.class);

    // Then
    assertThat(deserialized).isEqualTo(person);
}

🔆 Conclusions

✅ We can start using Jackson >= 2.12.0 to serialize/deserialize Java Records.
👷 This is a new feature, and there can be edge cases, try it out with caution.
🐞 Report issues here if you find any

🐚 Install all your Atom packages 📦 from a file

Carlos Chacin ☕👽 — Thu, 24 Sep 2020 05:40:59 +0000

Every time I have to set up a new computer, I have to remember the Atompackages that I was using before and start installing them one by one.

Recently, I discovered that Atom comes with the Atom Package Manager or apmthat allows you to install Atom Packages from the terminal:

$ apm install asciidoc-preview

But the same tool also allows us to list the currently installed packages:

$ apm list


Built-in Atom Packages (93)
├── atom-dark-syntax@0.29.1
├── atom-dark-ui@0.53.3
├── atom-light-syntax@0.29.1
├── atom-light-ui@0.46.3
├── base16-tomorrow-dark-theme@1.6.0
├── base16-tomorrow-light-theme@1.6.0
├── one-dark-ui@1.12.5
.
.
.
├── language-xml@0.35.3
└── language-yaml@0.32.0

Community Packages (10) ~/.atom/packages
├── asciidoc-assistant@0.2.3
├── asciidoc-image-helper@1.0.1
├── asciidoc-preview@2.13.1
├── atom-beautify@0.33.4
├── atom-runner@2.7.1
├── autocomplete-asciidoc@0.1.2
├── intellij-idea-keymap@0.2.3
├── jekyll@2.1.0
├── language-asciidoc@1.11.0
└── platformio-ide-terminal@2.10.0

The output is vast since it includes all the built-in packages plus theinstalled ones. Let’s filter only the installed:

$ apm list --installed


Community Packages (10) ~/.atom/packages
├── asciidoc-assistant@0.2.3
├── asciidoc-image-helper@1.0.1
├── asciidoc-preview@2.13.1
├── atom-beautify@0.33.4
├── atom-runner@2.7.1
├── autocomplete-asciidoc@0.1.2
├── intellij-idea-keymap@0.2.3
├── jekyll@2.1.0
├── language-asciidoc@1.11.0
└── platformio-ide-terminal@2.10.0

A lot better, but we will also need to remove the noise from the output:

$ apm list --installed --bare


asciidoc-assistant@0.2.3
asciidoc-image-helper@1.0.1
asciidoc-preview@2.13.1
atom-beautify@0.33.4
atom-runner@2.7.1
autocomplete-asciidoc@0.1.2
intellij-idea-keymap@0.2.3
jekyll@2.1.0
language-asciidoc@1.11.0
platformio-ide-terminal@2.10.0

If we want to remove the specific versions to tell apm that we want the latestversions instead, we can filter the output with grep:

$ apm list --installed --bare | grep '^[^@]\+' -o


asciidoc-assistant
asciidoc-image-helper
asciidoc-preview
atom-beautify
atom-runner
autocomplete-asciidoc
intellij-idea-keymap
jekyll
language-asciidoc
platformio-ide-terminal

Now that we have a clean list of our installed packages, we can store it in atext file:

$ apm list --installed --bare | grep '^[^@]\+' -o > atom-packages.txt

We can store this file in dotfiles, Github, Gists, Gitlab, Dropbox, or evenemail and then run the following command to install all the packages i.e., fornew installations:

$ apm install --packages-file atom-packages.txt

🌒 JakartaEE JSON-B 🐝 Retrofit2 Converter

Carlos Chacin ☕👽 — Wed, 23 Sep 2020 00:00:00 +0000

Retrofit is pluggable allowing different serialization formats and their libraries to be used for converting Java types to their HTTP representation and parsing HTTP entities back into Java types.

These are called converters, and Retrofit includes a few first-party modules for popular frameworks

Just for fun, I created a Retrofit2 Converter.Factory for JakartaEE Json-B.

Usage

Add the dependencies:

Retrofit2

<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>retrofit</artifactId>
  <version>2.9.0</version>
</dependency>

OkHttp3

<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>3.14.9</version>
</dependency>

JakartaEE Json Binding Reference Implementation

<dependency>
  <groupId>org.eclipse</groupId>
  <artifactId>yasson</artifactId>
  <version>1.0.8</version>
</dependency>

JsonB Retrofit2 Converter

<dependency>
  <groupId>io.github.cchacin</groupId>
  <artifactId>jsonb-retrofit-converter</artifactId>
  <version>1.0.2</version>
</dependency>

Add a converter factory when building your Retrofit instance using thecreate method:

var retrofit = new Retrofit.Builder()
    .baseUrl("https://example.com/")
    .addConverterFactory(JsonbConverterFactory.create())
    .build();

Alternatively, you can pass an instance of javax.json.bind.Jsonb:

var jsonb = JsonbBuilder.create(/* configure your jsonb instance here */ );
var retrofit = new Retrofit.Builder()
    .baseUrl("https://example.com/")
    .addConverterFactory(JsonbConverterFactory.create(jsonb))
    .build();

Now we are able to use JakartaEE JsonB to serialize and deserialize POJOs using Retrofit2

The code is available on Github:

cchacin / jsonb-retrofit-converter

JakartaEE Json-B Converter for Retrofit2

JakartaEE Json-B Retrofit2 Converter

A Retrofit 2 Converter.Factory for JakartaEE Json-B.

Usage

Add a converter factory when building your Retrofit instance using the create method:

var retrofit = new Retrofit.Builder()
    .baseUrl("https://example.com/")
    .addConverterFactory(JsonbConverterFactory.create())
    .build();

Alternatively, you can pass an instance of javax.json.bind.Jsonb:

var jsonb = JsonbBuilder.create(/* configure your jsonb instance here */ );
var retrofit = new Retrofit.Builder()
    .baseUrl("https://example.com/")
    .addConverterFactory(JsonbConverterFactory.create(jsonb))
    .build();

Download

Download the latest JAR or grab via Gradle:

implementation 'io.github.cchacin:jsonb-retrofit-converter:1.0.2'

or Maven:

<dependency>
  <groupId>io.github.cchacin</groupId>
  <artifactId>jsonb-retrofit-converter</artifactId>
  <version>1.0.2</version>
</dependency>

Snapshots of the development version are available in Sonatype's snapshots repository.

License

Copyright

…

View on GitHub

🔌 Restore IntelliJ Idea settings ⛽

Carlos Chacin ☕👽 — Fri, 01 May 2020 06:51:25 +0000

The article was originally published at carloschac.in

🔌 Restore IntelliJ Idea settings ⛽

After a long day trying to figure out how to reset all my IntelliJ settings, I decided to write this to document the obvious solution that was not that obvious to me.

I was using the 🔥 JetBrains Toolbox App 🔥 for a while to manage my IntelliJ Idea Ultimate installation along with other tools like Rider, WebStorm, and the Early Access Preview for IntelliJ Community Edition.

After several installations and reinstallations of IDEs and different Java/JDK versions (8, 9, 11, 14), the IDE was not able to import my maven projects. The IntelliJ IDEA was acting as a simple text editor at this time 😟.

💀 Failed attempt to solve it 🔇

1) Uninstall IntelliJ IDEA Ultimate using the Toolbox App
2) Uninstall the Toolbox App
3) Delete the following directories:



$ rm -rf ~/Library/Application\ Support/JetBrains/



$ rm -rf ~/Library/Caches/JetBrains/IntelliJIdea2020.1

4) Reinstall IntelliJ IDEA without using Toolbox



$ brew cask install intellij

💊 The obvious and simple solution 🍏

Go to:

Configure -> Restore Default Settings -> Restore and Restart

💾 Java 14 Records 🐞 with JakartaEE JSON-B

Carlos Chacin ☕👽 — Tue, 21 Apr 2020 05:07:41 +0000

The article was initially published at carloschac.in

💾 Java 14 Records 🐞 with JakartaEE JSON-B

In the previous article about Java 14 Records, we saw how to start creating Records to avoid writing much boilerplate code that the compiler would generate for us.

🚀 Java 14 Records 💾 (Preview)

Carlos Chacin ☕👽 ・ Apr 17 '20

#java #jdk #java14 #records

Now the next steps are to see how we can serialize records to JSON and deserialize JSON to records to be able to use them as a request/response representation for microservices.

In this case, we would use the JSON-B specification used by JakartaEE and MicroProfile implementations like GlashFish, TomEE, Wildfly, OpenLiberty, and Quarkus.

Continuing with the same example that we used in the previous article, we would need to add a JSON-B implementation, let's add the Eclipse Yasson dependency to our existing pom.xml file:

<dependency>
    <groupId>org.eclipse</groupId>
    <artifactId>yasson</artifactId>
    <version>1.0.6</version>
    <scope>test</scope>
</dependency>

💾 Now let's see our example Record:

record Person(
    String firstName,
    String lastName,
    String address,
    LocalDate birthday,
    List<String> achievements) {
}

💡 Java 14+ compiler would generate all of the following:

$ javap -p Person.class

public final class Person extends java.lang.Record {
  private final java.lang.String firstName;
  private final java.lang.String lastName;
  private final java.lang.String address;
  private final java.time.LocalDate birthday;
  private final java.util.List<java.lang.String> achievements;
  public Person(java.lang.String, java.lang.String, java.lang.String, java.time.LocalDate, java.util.List<java.lang.String>);
  public java.lang.String toString();
  public final int hashCode();
  public final boolean equals(java.lang.Object);
  public java.lang.String firstName();
  public java.lang.String lastName();
  public java.lang.String address();
  public java.time.LocalDate birthday();
  public java.util.List<java.lang.String> achievements();
}

🔨 Our test case would consist of using Yasson

To serialize a record like this:

var person = new Person(
    "John",
    "Doe",
    "USA",
    LocalDate.of(1990, 11, 11),
    List.of("Speaker")
);

To a json output like this:

{
    "achievements": [
        "Speaker"
    ],
    "address": "USA",
    "birthday": "1990-11-11",
    "firstName": "John",
    "lastName": "Doe"
}

🔎 Let's check the complete test code:

@Test
void serializeRecords() throws Exception {
    // Given
    var person = new Person(
            "John",
            "Doe",
            "USA",
            LocalDate.of(1990, 11, 11),
            List.of("Speaker")
    );

    var expected = """
            {
                "achievements": [
                    "Speaker"
                ],
                "address": "USA",
                "birthday": "1990-11-11",
                "firstName": "John",
                "lastName": "Doe"
            }""";

    // When
    var jsonb = JsonbBuilder.create(new JsonbConfig().withFormatting(true));
    var serialized = jsonb.toJson(person);

    // Then
    assertThat(serialized).isEqualTo(expected);
}

After running the test with maven or in the IDE, we get the following assertion's failure:

org.opentest4j.AssertionFailedError:
Expecting:
 <"
{
}">
to be equal to:
 <"
{
    "achievements": [
        "Speaker"
    ],
    "address": "USA",
    "birthday": "1990-11-11",
    "firstName": "John",
    "lastName": "Doe"
}">
but was not.

JSON-B is serializing the record as an empty object :(

Let's read the specification:

For a serialization operation, if a matching public getter method exists, the method is called to obtain the value of the property. If a matching getter method with private, protected or defaulted to package-only access exists, then this field is ignored. If no matching getter method exists and the field is public, then the value is obtained directly from the field.

Let's take a look at the field firstName on the record as an example:

$ javap -p Person.class

public final class Person extends java.lang.Record {
  private final java.lang.String firstName; // This field is private
  .
  .
  .
  public java.lang.String firstName(); // This property is not a getter, i.e. getFirstName()

We are not complaining with the specification, but we can solve this renaming the field defined in the record to use the JavaBean setters convention:

record Person(
    String getFirstName,
    String getLastName,
    String getAddress,
    LocalDate getBirthday,
    List<String> getAchievements) {
}

⚠️ The above example can be problematic if we forget about adding the get prefix. For primitive boolean properties, the prefix for getters is is instead of get, also easy to forget.

Another alternative is to specify to the JSON-B implementation to serialize using private fields instead of the getters, for that we need to implement the PropertyVisibilityStrategy interface.

Provides mechanism on how to define customized property visibility strategy.
This strategy can be set via JsonbConfig.

🔧 The interface has two methods:

boolean isVisible(Field field) Responds whether the given field should be considered as the JsonbProperty.
boolean isVisible(Method method) Responds whether the given method should be considered as the JsonbProperty.

To achieve our goal, we want to return true to serialize fields and false to serialize methods:

var visibilityStrategy = new PropertyVisibilityStrategy() {
    @Override
    public boolean isVisible(Field field) {
        return true;
    }

    @Override
    public boolean isVisible(Method method) {
        return false;
    }
};

And then we pass it to the JsonbConfig object:

var jsonb = JsonbBuilder.create(new JsonbConfig().withFormatting(true).withPropertyVisibilityStrategy(visibilityStrategy));

♻️ Now we have a passing test:

💊 Testing Deserialization

Let's use the same record to try the deserialization using also the same configuration, the only thing that we need to add to our test is the deserialization itself using the Jsonb object and the assertion to compare:

@Test
void serializeRecords() throws Exception {
    // Given
    var person = new Person(
            "John",
            "Doe",
            "USA",
            LocalDate.of(1990, 11, 11),
            List.of("Speaker")
    );

    var json = """

            {
                "achievements": [
                    "Speaker"
                ],
                "address": "USA",
                "birthday": "1990-11-11",
                "firstName": "John",
                "lastName": "Doe"
            }""";

    // When
    var visibilityStrategy = new PropertyVisibilityStrategy() {
        @Override
        public boolean isVisible(Field field) {
            return true;
        }

        @Override
        public boolean isVisible(Method method) {
            return false;
        }
    };
    var jsonb = JsonbBuilder.create(
            new JsonbConfig()
                    .withFormatting(true)
                    .withPropertyVisibilityStrategy(visibilityStrategy)
    );
    var serialized = jsonb.toJson(person);
    var deserialized = jsonb.fromJson(json, Person.class);

    // Then
    assertThat(deserialized).isEqualTo(person);
    assertThat(serialized).isEqualTo(json);
}

Our test case fails for deserialization with the following error:

javax.json.bind.JsonbException: Cannot create an instance of a class: class records.Person, No default constructor found.

📌 Per the specification, we need either to:

✅ Define an empty/null constructor
✅ Define a constructor or method annotated with @JsonbCreator

But how can we do that if the compiler generates the constructor for a record?

💾 Java Records 👷 Compact Constructor:

record Person(
    String firstName,
    String lastName,
    String address,
    LocalDate birthday,
    List<String> achievements) {

    public Person {
        if (birthday >= LocalDate.now()) {
            throw new IllegalArgumentException( "Birthday must be < today!");
        }
    }
}

This compact constructor is meant to be used only for validation purposes as in the example above and notice that we don't have to repeat the field parameters nor the field initializations, The remaining initialization code is supplied by the compiler.

But how this helps to our deserialization problem, well, as another regular constructor we can add annotations there, let's fix it:

record Person(
    String firstName,
    String lastName,
    String address,
    LocalDate birthday,
    List<String> achievements) {

    @JsonbCreator
    public Person {}
}

This is the decompiled bytecode generated by the compiler:

public final class Person extends java.lang.Record {
    private final java.lang.String firstName;
    private final java.lang.String lastName;
    private final java.lang.String address;
    private final java.time.LocalDate birthday;
    private final java.util.List<java.lang.String> achievements;

    @javax.json.bind.annotation.JsonbCreator
    public Person(java.lang.String firstName, java.lang.String lastName, java.lang.String address, java.time.LocalDate birthday, java.util.List<java.lang.String> achievements) { /* compiled code */ }

    public java.lang.String toString() { /* compiled code */ }

    public final int hashCode() { /* compiled code */ }

    public final boolean equals(java.lang.Object o) { /* compiled code */ }

    public java.lang.String firstName() { /* compiled code */ }

    public java.lang.String lastName() { /* compiled code */ }

    public java.lang.String address() { /* compiled code */ }

    public java.time.LocalDate birthday() { /* compiled code */ }

    public java.util.List<java.lang.String> achievements() { /* compiled code */ }
}

We can notice the @JsonbCreator annotation passed to the generated constructor. After that change, our test suite for serialization and deserialization of records with JSON-B passes.

🔆 Conclusions

✅ We can use records to serialize and deserialize JSON request/response objects.
✅ We described two ways of achieving serialization:
- ✅ Renaming the fields to use the getter convention.
- ✅ Adding a custom PropertyVisibilityStrategy to serialize using the private fields.
✅ We described how to achieve the deserialization using the @JsonbCreator annotation.
🔴 Most probably, in the following versions of the JSON-B API specification records would be taken in consideration and the strategies described in this article are not going to be required.

🚀 Java 14 Records 💾 (Preview)

Carlos Chacin ☕👽 — Fri, 17 Apr 2020 10:25:15 +0000

🏁 Records 💾

Record is a new kind of type declaration in the Java language. Like an enum, a record is a restricted form of class. It declares its representation and commits to an API that matches that representation. Records give up a freedom that classes usually enjoy: the ability to decouple API from representation. In return, records gain a significant degree of concision.

A record has a name and a state description. The state description declares the components of the record. Optionally, a record has a body. For example:

record Point(int x, int y) { }

Let's get started

⬇️ Download OpenJDK 14.0.1

🚥 Set the JAVA_HOME to point to the downloaded JDK 14

$ export JAVA_HOME=/path/to/jdk14
$ export PATH=$JAVA_HOME/bin:$PATH

🚀 Writing our first Java Record 💾

public record Person(
    String firstName,
    String lastName,
    String address,
    LocalDate birthday,
    List<String> achievements) {
}

💻 Compile it with `javac`

$ javac --enable-preview -source 14 Person.java

💻 Compile it with `maven`

Add the following configuration for the compiler plugin in your pom.xml

<plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.1</version>
    <configuration>
        <release>14</release>
        <compilerArgs>--enable-preview</compilerArgs>
    </configuration>
</plugin>

$ mvn compile

🚧 What's generated by the compiler?

$ javap -p Person.class

public final class Person extends java.lang.Record {
  private final java.lang.String firstName;
  private final java.lang.String lastName;
  private final java.lang.String address;
  private final java.time.LocalDate birthday;
  private final java.util.List<java.lang.String> achievements;
  public Person(java.lang.String, java.lang.String, java.lang.String, java.time.LocalDate, java.util.List<java.lang.String>);
  public java.lang.String toString();
  public final int hashCode();
  public final boolean equals(java.lang.Object);
  public java.lang.String firstName();
  public java.lang.String lastName();
  public java.lang.String address();
  public java.time.LocalDate birthday();
  public java.util.List<java.lang.String> achievements();
}

Because records make the semantic claim of being simple, transparent holders for their data, a record acquires many standard members automatically:

A private final field for each component of the state description;
A public read accessor method for each element of the state description, with the same name and type as the component;
A public constructor, whose signature is the same as the state description, which initializes each field from the corresponding argument;
Implementations of equals and hashCode that say two records are equal if they are of the same type and contain the same state; and
An implementation of toString that includes the string representation of all the record components, with their names.

⚠️ Shallowly Immutable Data

Similarly to the tests that we did in the article Immutables/AutoValue/Lombok Which One? where we check the default behavior in terms of immutability for those libraries, with the below test we demonstrate the statement mentioned in the JEP 359: Records:

Records provide a compact syntax for declaring classes, which are transparent holders for shallowly immutable data.

📐 Test Immutability

@Test
void immutability() {
    // Create a mutable list with 1 element
    var achievements1 = new ArrayList<String>();
    achievements1.add("Speaker");
    achievements1.add("Blogger");
    var achievements2 = List.of("Speaker", "Blogger");


    // Create person 1, assigning the list1
    var person1 = new Person(
            "John",
            "Doe",
            "USA",
            LocalDate.of(1990, 11, 11),
            achievements1
    );

    // Create person 2, assigning the list2
    var person2 = new Person(
            "John",
            "Doe",
            "USA",
            LocalDate.of(1990, 11, 11),
            achievements2
    );

    // Compare the 2 objects
    // Test passes since the fields contain the same values
    assertThat(person1).isEqualTo(person2);

    // Mutate the list used on Model 1
    achievements1.add("AnotherValue");

    // Compare the 2 objects:
    // - PASSES objects are NOT EQUAL for Records 😮 🔴
    assertThat(person1).isNotEqualTo(person2);
}

There are two ways of guaranteeing immutability when using records with mutable data types in their signature or when the data type is an interface, and we are not sure about the implementation, i.e., java.util.Date or java.util.List

1) Create a safe copy of the data type in the record's constructor.
2) Pass only immutable objects when creating the records.

🔆 Conclusions

✅ Records can reduce several lines of code to a one-liner.
✅ With JDK 14, we can prescind of using some code generation libraries to minimize boilerplate code.
✅ A great option for:
- 🔝 Tree nodes
- 🔝 DTOs
- 🔝 Compound map keys
- 🔝 Messages
- 🔝 Value wrappers
- 🔝 Discriminated Entities
⚠️ Records are only Shallowly Immutables, which means that we have to take into consideration the data types passed to them if we want to guarantee immutability.
⚠️ Records are a preview language feature, and it is not yet a standard in the JDK.

Carlos Chacin ☕👽 ・ Apr 13 '20

#java #bestpractices #immutability

☕️ Immutables/AutoValue/Lombok 🔥 Which One?

Carlos Chacin ☕👽 — Mon, 13 Apr 2020 03:42:53 +0000

The article was initially published at carloschac.in

🎩 Immutability in Java 🔥 Made Easy

Carlos Chacin ☕👽 ・ Apr 12 '20

#java #bestpractices #immutability

In this article, we are going to compare some of the features of the Immutables.org library, Google AutoValue and Project Lombok:

Generated the Builder pattern by default?
Generated helper methods for, i.e., Optional and List?
The number of lines of code to write?
Required IDE's plugins?
Are the objects immutable?

The three libraries are based on an annotation processor to generate/modify code for us:

Immutable classes
equals, hashCode and toString methods
other utilities

NOTE: Immutables and AutoValue generate new classes with the processor, and Lombok modifies the bytecode of the original class.

💡 Overview

Immutables Java annotation processors to generate simple, safe, and consistent value objects. Do not repeat yourself, try Immutables, the most comprehensive tool in this field!

AutoValue provides an easier way to create immutable value classes, with a lot less code and less room for error, while not restricting your freedom to code almost any aspect of your class exactly the way you want it.

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully-featured builder, Automate your logging variables, and much more.

📇 The Model

We are going to create a class using the three libraries to be able to create an object representation with the following fields.



Optional<Integer> myOptional;
String myString;
List<String> myList;

🔩 Creating the model with `AutoValue`



package autovalue;

import com.google.auto.value.AutoValue;

import java.util.List;
import java.util.Optional;

@AutoValue
public abstract class MyModel {
    public abstract Optional<Integer> myOptional();

    public abstract String myString();

    public abstract List<String> myList();

    // Builder not generated by default
    // We have to write this boilerplate code
    @AutoValue.Builder
    public abstract static class Builder {
        public abstract Builder setMyOptional(Optional<Integer> myOptional);

        public abstract Builder setMyString(String myString);

        public abstract Builder setMyList(List<String> myList);

        public abstract MyModel build();
    }
}

Generated the Builder pattern by default? 🔴
Generated helper methods for, i.e., Optional and List? 🔴 Let's see in the next section
The number of lines of code to write? 28 ✅
It requires IDE plugin 🔴
Are the objects immutable? 🔴 Let's see in the next section

🔩 Creating the model with `Lombok`



package lombok;

import java.util.List;
import java.util.Optional;

@Value
@Builder
public class MyModel {
    Optional<Integer> myOptional;

    String myString;

    List<String> myList;
}

Generated the Builder pattern by default? 🔴
Generated helper methods for, i.e., Optional and List? 🔴 Let's see in the next section
The number of lines of code to write? 14 ✅
It requires IDE plugins 🔴
Are the objects immutable? 🔴 Let's see in the next section

🔩 Creating the model with `Immutables`



package immutables;

import org.immutables.value.Value;

import java.util.List;
import java.util.Optional;

@Value.Immutable
public interface MyModel {
    Optional<Integer> myOptional();

    String myString();

    List<String> myList();
}

Generated the Builder pattern by default? ✅
Generated helper methods for, i.e., Optional and List? ✅, Let's see in the next section
The number of lines of code to write? 15 ✅
It doesn't require IDE plugin ✅
Are the objects immutable? ✅, Let's see in the next section

🌵Tests

Let's check some Pseudo-code:

We are going to create two identical lists with the same element inside:



list1=List.of("OneValue")
list2=List.of("OneValue")

We are going to create two identical value objects like this:



MyModel1: (
  myOptional=Optional.of(1)
  myString="Hello"
  myList=list1 // Using list 1
)

MyModel2: (
  myOptional=Optional.of(1)
  myString="Hello"
  myList=list2 // Using list 2
)

Even when using different references for the lists, the objects should be equal by value.



model1 == model2 // TRUE

After mutating one of the lists, the comparison of the objects should be the same



list1.add("AnotherValue")

model1 == model2 // TRUE

🍭 Testing `AutoValue`



@Test
void immutability() {
    // Create 2 lists containing the same element
    var myList1 = new ArrayList<String>();
    myList1.add("OneValue");
    var myList2 = List.of("OneValue");

    // Create model 1, assigning the list1
    var myModel1 = new AutoValue_MyModel.Builder()
            .setMyOptional(Optional.of(1)) // 😥 🔴 No helper for Optional
            .setMyString("Hello")
            .setMyList(myList1) // 😥 🔴 No helper for List
            .build();

    // Create model 2, assigning the list2
    var myModel2 = new AutoValue_MyModel.Builder() // 😥 🔴 No helper for copying
            .setMyOptional(Optional.of(1))
            .setMyString("Hello")
            .setMyList(myList2)
            .build();

    // Compare the 2 objects
    // Test passes since the fields contain the same values
    assertThat(myModel1).isEqualTo(myModel2);

    // Mutate the list used on Model 1
    myList1.add("AnotherValue");

    // Compare the 2 objects:
    // - PASSES objects are NOT equal for AutoValue 😮 🔴
    assertThat(myModel1).isNotEqualTo(myModel2);
}

🍭 Testing `Lombok`



@Test
void immutability() {
    // Create a mutable list with 1 element
    var myList1 = new ArrayList<String>();
    myList1.add("OneValue");
    var myList2 = List.of("OneValue");

    // Create model 1, assigning the list1
    var myModel1 = MyModel.builder()
            .myOptional(Optional.of(1)) // 😥 🔴 No helper for Optional
            .myString("Hello")
            .myList(myList1) // 😥 🔴 No helper for List
            .build();

    // Create model 2, assigning the list2
    var myModel2 = MyModel.builder() 😥 🔴 // No helper for copying
            .myOptional(Optional.of(1))
            .myString("Hello")
            .myList(myList2)
            .build();

    // Compare the 2 objects
    // Test passes since the fields contain the same values
    assertThat(myModel1).isEqualTo(myModel2);

    // Mutate the list used on Model 1
    myList1.add("AnotherValue");

    // Compare the 2 objects:
    // - PASSES objects are NOT equal for Lombok 😮 🔴
    assertThat(myModel1).isNotEqualTo(myModel2);
}

🍭 Testing `Immutables`



@Test
void immutability() {
   // Create a mutable list with 1 element
   var myList1 = new ArrayList<String>();
    myList1.add("OneValue");
    var myList2 = List.of("OneValue");

   // Create model 1, assigning the list1
   var myModel1 = ImmutableMyModel.builder()
           .myOptional(1) // 🎩 ✅ Helper for Optional
           .myString("Hello")
           .myList(myList1)
           .build();

   // Create model 2, assigning the list2
   var myModel2 = ImmutableMyModel.builder()
           .from(myModel1) // 🎩 ✅ Helper for copying
           .addMyList("OneValue") // 🎩 ✅ Helper for List
           .build();

   // Compare the 2 objects
   // Test passes since the fields contain the same values
   assertThat(myModel1).isEqualTo(myModel2);

   // Mutate the list used on Model 1
   myList1.add("AnotherValue");

   // Compare the 2 objects:
   // - Test PASSES objects ARE EQUAL for Immutables 🎩 ✅
   assertThat(myModel1).isEqualTo(myModel2);
}

📈 Results

	AutoValue	Lombok	Immutables
Line of Code to write/maintain	28	14	15
Builder (by default)	🔴	🔴	✅
Required IDE Plugin	✅	🔴	✅
Immutability	🔴	🔴	✅
Helper for Optional	🔴	🔴	✅
Helper for Collections	🔴	🔴	✅
Helper for Copying	🔴	🔴	✅

The code and the tests for the above examples are available on GitHub:

cchacin / immutables-autovalue-lombok

☕️ Immutables/AutoValue/Lombok 🔥 Which One?

Blog post: https://dev.to/cchacin/immutables-autovalue-lombok-which-one-2j33

View on GitHub

🔆 Conclusions

Even when the three libraries are doing a great job to avoid the boilerplate code, I personally use the Immutables library in most of the projects because of the safe defaults.
To be fair, both Lombok and AutoValue can achieve also immutability but it requires paying more attention when creating the classes and that can cause problems.
One main advantage of AutoValue is that it generates less code and that would be convenient if you are developing on/for Android.
The configuration options for AutoValue and Lombok are pretty limited compared with Immutables but that topic was not covered in this article.
Lombok requires a plugin if you want to be able to see all the modified/added methods to the bytecode.

DEV Community: Carlos Chacin ☕👽

Crea una REST API sin usar ningún Framework con Java Servlets, JDBC, PostgreSQL y Jackson

Crea una REST API sin usar ningún Framework con Java Servlets, JDBC, PostgreSQL y Jackson

Parte 1

Parte 2

🚀 Auto-Switch iTerm2 Modes, Day & Night! 🌞🌚

🚀 Auto-Switch iTerm2 Modes: Day🌞 & Night🌚 - YouTube

The Problem

Ok, let’s discover this game-changer feature!

Step 1

Step 2

Step 3

Step 4

Step 5

The Result

Java 17 + AWS Lambda

🏆 Default 🔗 Maven and ☕ Java settings per project

☕🚢 Maven Build in < 20 lines of yaml 🕟

Create the directory

Create the yaml file

Copy this content

Commit and push to Github

Enjoy your builds

💾 Java Records 💿 with Jackson 2.12

💾 Now let’s see our example Record:

💡 Java 14+ compiler would generate all of the following:

🔨 Our test setup:

💊 Testing Serialization

💊 Testing Deserialization

🔆 Conclusions

🐚 Install all your Atom packages 📦 from a file

🌒 JakartaEE JSON-B 🐝 Retrofit2 Converter

Usage

Add the dependencies:

Retrofit2

OkHttp3

JakartaEE Json Binding Reference Implementation

JsonB Retrofit2 Converter

cchacin / jsonb-retrofit-converter

JakartaEE Json-B Converter for Retrofit2

JakartaEE Json-B Retrofit2 Converter

Usage

Download

License

🔌 Restore IntelliJ Idea settings ⛽

🔌 Restore IntelliJ Idea settings ⛽

💀 Failed attempt to solve it 🔇

💊 The obvious and simple solution 🍏

💾 Java 14 Records 🐞 with JakartaEE JSON-B

💾 Java 14 Records 🐞 with JakartaEE JSON-B

🚀 Java 14 Records 💾 (Preview)

Carlos Chacin ☕👽 ・ Apr 17 '20

💾 Now let's see our example Record:

💡 Java 14+ compiler would generate all of the following:

🔨 Our test case would consist of using Yasson

🔎 Let's check the complete test code:

♻️ Now we have a passing test:

💊 Testing Deserialization

💾 Java Records 👷 Compact Constructor:

🔆 Conclusions

🚀 Java 14 Records 💾 (Preview)

🏁 Records 💾

Let's get started

⬇️ Download OpenJDK 14.0.1

🚥 Set the JAVA_HOME to point to the downloaded JDK 14

🚀 Writing our first Java Record 💾

💻 Compile it with javac

💻 Compile it with maven

🚧 What's generated by the compiler?

⚠️ Shallowly Immutable Data

📐 Test Immutability

🔆 Conclusions

☕️ Immutables/AutoValue/Lombok 🔥 Which One?

Carlos Chacin ☕👽 ・ Apr 13 '20

☕️ Immutables/AutoValue/Lombok 🔥 Which One?

🎩 Immutability in Java 🔥 Made Easy

Carlos Chacin ☕👽 ・ Apr 12 '20

💡 Overview

📇 The Model

🔩 Creating the model with AutoValue

💻 Compile it with `javac`

💻 Compile it with `maven`

🔩 Creating the model with `AutoValue`

🔩 Creating the model with `Lombok`

🔩 Creating the model with `Immutables`

🍭 Testing `AutoValue`

🍭 Testing `Lombok`

🍭 Testing `Immutables`