About Spring Boot Native Images

Chaitanya Chunduri — Sat, 29 Oct 2022 15:26:28 +0000

I was recently impressed by Spring Boot's native images feature. I considered sharing some information about native images.

I created two simple Spring Boot projects
1) spring-with-native-plugin
2) spring-without-native-plugin

Apart from the Main class, I used the same controller in both projects.

I used the following command to create docker images.

mvn spring-boot:build-image

(Both projects are based on maven)

When I ran both docker images, I was surprised by the application startup time.

There's also a significant difference in the sizes of the two Docker images.

So, What happened after we installed the native plugin?

Thanks to Spring AOT Process, it performed a code analysis to identify unnecessary code.
After the code analysis, all unnecessary code was removed, and a native image was created.

Now, This native image is no longer dependent on the JVM and can run without the JVM.

We must thank @graalvmfor making this all possible.

Handle Null like a pro using Optional

Chaitanya Chunduri — Mon, 16 Aug 2021 08:19:09 +0000

Many times we think that our code is perfect, works like a charm in the given scenarios and we proceed for deployment in production on a fine Friday. But when the code hits production due to unexpected data or due to some failure, when the code throws NullPointerExcpetion, the feeling comes like damn this weekend also ha...

But Thank God, we have a rescuer to fight with NPE(NullPointerException) who came into the existence since Java 8 which is Optional class.

In this article let us find out how we can use Optional in day to day jobs.

To create Optional object we have two methods,

using of method
using ofNullable

Here are the examples

Optional<String> optional = Optional.of("Chaitanya");
Optional<String> opNullable = Optional.ofNullable("Chaitanya");

If you think that there is a possibility of null coming because of the calling function then you can use ofNullable.

of method throws NPE if the value is null, so, if you're certain that you don't get a null value you can use of method.

IMO, for simple operations like variable initialization or you've simple values and you want to pass them then you can use of method, if you're calling some external function for the result then you can use ofNullable.

Optional is something like a container that holds a value. To get things out of the container we need to open it, same way to get the value out of the Optional, we've get method.

Optional<String> optional = Optional.of("Chaitanya");
System.out.println(optional.get());

Think that you got a big container, you opened it and found nothing, then you feel disappointed right? To save from these kinds of bad feelings, we have isPresent method, usage is like this.

Optional<String> nameOptional = getFirstName();
if(nameOptional.isPresent()) {
  System.out.println(nameOptional.get());
} else {
  System.out.println("No Name :( ");
}

If you want to handle in a functional style, here is the way

nameOptional.ifPresent(value -> {
  System.out.println(value);
});

or using method references

nameOptional.ifPresent(System.out::println);

Sometimes we don't want to do anything when an exception raises, without Optional one way is we return null in catch block, but from Optional we've one more method empty(), here is the usage:

try {
  return Optional.ofNullable(getEmpName());
} catch (Exception ex) {
 return Optional.empty();
}

Sometimes we may need to manipulate the results of certain operations, in such cases, we've map and flatMap methods

Optional<String> nameInUpperCaseOptional =                            
                       Optional.ofNullable(getEmpName())
                          .map(String::toUpperCase)
                          .get();

Here map returns one more Optional object with the transformed value. If you want to get direct value instead of Optional object, then you can use flatMap method.

String nameInUpperCase = Optional.ofNullable(getEmpName())
                          .flatMap(String::toUpperCase);

If you want to return a default value when there is no value present, you can use orElse

String EMPTY = "";
String name = Optional.ofNullable(getEmpName())
                  .orElse(EMPTY);

If you want to perform some action when there is no value present, you can use orElseGet

String name = Optional.ofNullable(getEmpName())
                  .orElseGet(_ -> System.out.println("There is no Value :( "));

If you want to throw an exception when there is no value present then we've orElseThrow

String name = Optional.ofNullable(getEmpName())
                  .orElseThrow(Exception::new);

In Java 11, There are some more enhancements in Optional class like ifPresentElse, or, stream, here is the link to documentation for further details. Java 11#Optional

That is it for this article :) If you use Optional properly you can pretty much avoid NPE and can avoid stressful weekends too.

Thanks for spending time. I appreciate your feedback.

Developing Fullstack Web Application Using Spring Boot, Kotlin and React JS

Chaitanya Chunduri — Sun, 24 May 2020 19:15:24 +0000

How to Build web applications using Kotlin/JS and React JS

Chaitanya Chunduri — Wed, 22 Apr 2020 07:19:36 +0000

ES 6: Using Object.entries() to iterate the keys in the Object

Chaitanya Chunduri — Thu, 25 Jul 2019 01:11:02 +0000

You can iterate keys in an object using ES 6 like below.

let employe = {
 name: 'Chaitanya',
 eno: '1'
};

for (let [key, value] of Object.entries(employe)) {
  console.log(`${key}: ${value}`);
}

or there is another way using forEach method

Object.entries(employe).forEach(([key, value]) => {
  console.log(`${key}: ${value}`); 
});

Object.enttries() got standardised in ECMAScript2017. Below is the browser support chart collected from MDN

DEV Community: Chaitanya Chunduri

About Spring Boot Native Images

Handle Null like a pro using Optional

Developing Fullstack Web Application Using Spring Boot, Kotlin and React JS

How to Build web applications using Kotlin/JS and React JS

ES 6: Using Object.entries() to iterate the keys in the Object