DEV Community: Jerome Ryan Villamor

Scaffold a Java spring boot application

Jerome Ryan Villamor — Wed, 22 May 2024 07:28:29 +0000

Trying to start a spring boot application nowadays is very easy. There are many ways on how to do it such as creating via your favorite IDE (IntelliJ, Eclipse, etc). My favorite is creating via start.spring.io. It is the simplest and the easiest to do.

First is go to https://start.spring.io/

On the left side are the configurations we required to specify

For the dependency manager, you may choose which one you want. I choose Maven as I am more familiar with it.
For the language, choose Java
For the spring boot version, the default is the latest stable version which is as of this writing, it’s 3.2.5.
Lastly for Project metadata, we will temporarily use the default metadata since this is just a demo. Just make sure you choose the Java version installed on your machine.

On the right side, if we click the add dependencies button, it will prompt all the dependencies we can add to our spring boot application. Since we are interested in creating a web application, I will add the spring web. Of course, there is a lot of dependency we need to build a web application, but for now this is more than enough to show you the basics of spring boot.

Let’s wrap this scaffolding and click the button Generate. It will download the code structure for our application. Unzip it and let’s open it in our IDE. In my case, I prefer to use IntelliJ.

This is the default folder structure of spring boot, same as the typical java application. If we go to the terminal and run mvn clean install & mvn spring-boot:run, it will prompt logs like the image below.

If you can see the same line of logs in your terminal, pat your back! That is a success. On next article, let’s create our first endpoint

Method Reference in Lambda

Jerome Ryan Villamor — Mon, 24 Apr 2023 05:32:43 +0000

Method reference is a good way to reduce the noise inside our Java streams.

Say that we have a list of names, and we want to map each of them to full name. We can achieve that by using the code below:

public void example() {
    List <String> names = Arrays.asList("Jerome", "Steve", "Cathy", "Lara");

    names.stream()
        .map((String name) -> {
            User user = repository.getUser(name);
            String fullname = user.firstname + " " + user.lastname;
            return fullname;
        })
        .forEach((String name) -> System.out.println(name));
}

Streams are not good for readability if your lambda methods contain many lines of codes. I prefer to have a rule of thumb that if it's 3 or more lines then we need to extract the code to its dedicated method.

public String getFullname(String name) {
    User user = repository.getUser(name);
    String fullName = user.firstname + " " + user.lastname;
    return fullname;
}

Then use method reference to make our stream more concise and shorter.

public void example() {
    List <String> names = Arrays.asList("Jerome", "Steve", "Cathy", "Lara");

    names.stream()
        .map(this::getFullname)
        .forEach((String name) - > System.out.println(name));
}

Note that a properly name method will make a difference. A code map(this::getFullname) can read as an English sentence. That's a sign of a cleaner and better code.

Lambda Expression

Jerome Ryan Villamor — Mon, 17 Apr 2023 13:46:08 +0000

Lambda expression is a new feature that created in Java 8. It provides a clean and concise way to implement one method interface aka @FunctionalInterface. You are maybe familiar on using Runnable or Comparator class. Implementing these classes, requires you to create a new class or anonymous class. Luckily lambda is existed thus removing the verbosity of the Java language.

Say we want to sort a list of names. We can use Collections.sort() method and implement an anonymous class of Comparator.

List<String> names = Arrays.asList("Jerome", "Steve", "Cathy", "Lara");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

We can shorten the code above using lambda expression.

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

Heck, we can even make it shorter. If it is just one liner method, we can omit the braces and return keyword.

Collections.sort(names, (a, b) -> b.compareTo(a));

Sweet! Lambda expression not only make our code readable but also removes the noise from it, giving us more focus in the behavior part of our code.

Behavior Parameterization

Jerome Ryan Villamor — Tue, 11 Apr 2023 07:37:57 +0000

One of the simplest ways to improve code is to pass behavior as a parameter to a method. Business requirements change every time and so our code needs to adapt. Take a look at the code below to see how we can introduce behavior parameterization to achieve maintainability and flexibility to our code.

Let’s say we have two requirements.

Filter green apples from the list of apples.
Filter apples by its weight.

public List<Apple> filterApplesByColor(List<Apple> inventory, String color){
    List<Apple> result = new ArrayList<>();
    for(Apple apple: inventory){
        if(apple.getColor().equals(color)){
            result.add(apple);
        }
    }
    return result;
}

public List<Apple> filterApplesByWeight(List<Apple> inventory, int weight){
    List<Apple> result = new ArrayList<>();
    for(Apple apple: inventory){
        if(apple.getWeight() > weight){
            result.add(apple);
        }
    }
    return result;
}


List<Apple> greenApples = filterApplesByColor(inventory, "green");
List<Apple> heavyApples = filterApplesByWeight(inventory, 150);

Notice how are we duplicating the code here. The two methods have the same code, only the difference is the condition statement inside of it. What happens if there are additional requirements such as filtering by size, shape or its origin? We will end up on a lot of duplicate codes which violate the DRY (Don’t repeat yourself) principle.

By using behavior parameterization, we instead focusing on the condition statement rather than creating their own dedicated method. Sounds complex but it is so easy to implement. To achieve it, first we need to create an interface.

public interface ApplePredicate{
    boolean isValid(Apple apple);
}

Then we will create a method that instead of hard coding the condition statement inside of it, we will rather pass the above interface as parameter.

public List<Apple> filterApples(List<Apple> inventory, ApplePredicate applePredicate){
    List<Apple> result = new ArrayList<>();
    for(Apple apple: inventory){
        if(applePredicate.isValid(apple)){
            result.add(apple);
        }
    }
    return result;
}

In order to use the filterApples method, we will use anonymous class. Of course, we can create a new class instead but that defeats the purpose of maintainability as creating one class per condition is too much for this kind of scenario.

List<Apple> greenApples = filterApples(inventory, new ApplePredicate() {
    public boolean isValid(Apple apple){
        return apple.getColor().equals("green"); 
    }
});

List<Apple> heavyApples = filterApples(inventory, new ApplePredicate() {
    public boolean isValid(Apple apple){
        return apple.getWeight() > 150; 
    }
});

Our code becomes simpler. We are reusing the same method whatever filter requirements we may want. Filter by shape or origin? Just pass the condition!

But we still have one problem. I don’t know about you but using anonymous class is too verbose for me. We can shorten our code using lambda. If you don’t know lambda yet, don’t worry I will create a separate article about it. For now, think of lambda as sweet syntax for anonymous class that contains only one method (which is applicable to our scenario).

The only changes that we need is to add an @FunctionalInterface annotation in our interface.

@FunctionalInterface
public interface ApplePredicate{
    boolean isValid(Apple apple);
}

public List<Apple> filterApples(List<Apple> inventory, ApplePredicate applePredicate){
    List<Apple> result = new ArrayList<>();
    for(Apple apple: inventory){
        if(applePredicate.isValid(apple)){
            result.add(apple);
        }
    }
    return result;
}

Then we can change the anonymous class into lambda.

List<Apple> greenApples = filterApples(inventory, () -> apple.getColor().equals("green"));

List<Apple> heavyApples = filterApples(inventory, () -> apple.getWeight() > weight; );

Now, we have created a more maintainable and flexible code using behavior parameterization. Next time we add another filter, we will not create a method or a class. Just pass the condition of what we want, and it will be given to us. Pretty cool, right?