DEV Community: Tamer Ardal

Boost Your Java Back-End Performance: Essential Optimization Tips!

Tamer Ardal — Sat, 09 Nov 2024 10:15:02 +0000

Performance plays a critical role in the success of a software project. Optimizations applied during Java back-end development ensure efficient use of system resources and increase the scalability of your application.

In this article, I will share with you some optimization techniques that I consider important to avoid common mistakes.

Choose the Right Data Structure for Performance

Choosing an efficient data structure can significantly improve the performance of your application, especially when dealing with large datasets or time-critical operations. Using the correct data structure minimizes access time, optimizes memory usage, and reduces processing time.

For instance, when you need to search frequently in a list, using a HashSet instead of an ArrayList can yield faster results:

// Inefficient - O(n) complexity for contains() check
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
// Checking if "Alice" exists - time complexity O(n)
if (names.contains("Alice")) {
    System.out.println("Found Alice");
}

// Efficient - O(1) complexity for contains() check
Set<String> namesSet = new HashSet<>();
namesSet.add("Alice");
namesSet.add("Bob");
// Checking if "Alice" exists - time complexity O(1)
if (namesSet.contains("Alice")) {
    System.out.println("Found Alice");
}

In this example, HashSet provides an average time complexity of O(1) for contains() operations, while ArrayList requires O(n) as it must iterate through the list. Therefore, for frequent lookups, a HashSet is more efficient than an ArrayList.

By the way, if you want to know what time complexity is: Time Complexity refers to how the running time of an algorithm varies with the input size. This helps us understand how fast an algorithm runs and usually shows how it behaves in the worst case. Time complexity is commonly denoted by Big O Notation.

Check Exception Conditions at the Beginning

You can avoid unnecessary processing overhead by checking the fields to be used in the method that should not be null at the beginning of the method. It is more effective in terms of performance to check them at the beginning, instead of checking for null checks or illegal conditions in later steps in the method.

public void processOrder(Order order) {
    if (Objects.isNull(order))
        throw new IllegalArgumentException("Order cannot be null");
    if (order.getItems().isEmpty())
        throw new IllegalStateException("Order must contain items");

    ...

    // Process starts here.
    processItems(order.getItems());
}

As this example shows, the method may contain other processes before getting to the processItems method. In any case, the Items list in the Order object is needed for the processItems method to work. You can avoid unnecessary processing by checking conditions at the beginning of the process.

Avoid Creating Unnecessary Objects

Creating unnecessary objects in Java applications can negatively affect performance by increasing Garbage Collection time. The most important example of this is String usage.

This is because the String class in Java is immutable. This means that each new String modification creates a new object in memory. This can cause a serious performance loss, especially in loops or when multiple concatenations are performed.

The best way to solve this problem is to use StringBuilder. StringBuilder can modify the String it is working on and perform operations on the same object without creating a new object each time, resulting in a more efficient result.

For example, in the following code fragment, a new String object is created for each concatenation operation:

String result = "";
for (int i = 0; i < 1000; i++) 
    result += "number " + i;

In the loop above, a new String object is created with each result += operation. This increases both memory consumption and processing time.

We can avoid unnecessary object creation by doing the same with StringBuilder. StringBuilder improves performance by modifying the existing object:

StringBuilder result = new StringBuilder();

for (int i = 0; i < 1000; i++) 
    result.append("number ").append(i);

String finalResult = result.toString();

In this example, only one object is created using StringBuilder, and operations are performed on this object throughout the loop. As a result, the string manipulation is completed without creating new objects in memory.

Say Goodbye to Nested Loops: Use Flatmap

The flatMap function included with the Java Stream API are powerful tool for optimizing operations on collections. Nested loops can lead to performance loss and more complex code. By using this method, you can make your code more readable and gain performance.

flatMap Usage

map: Operates on each element and returns another element as a result.
flatMap: Operates on each element, converts the results into a flat structure, and provides a simpler data structure.

In the following example, operations are performed with lists using a nested loop. As the list expands, the operation will become more inefficient.

List<List<String>> listOfLists = new ArrayList<>();
for (List<String> list : listOfLists) {
    for (String item : list) {
        System.out.println(item);
    }
}

By using flatMap, we can get rid of nested loops and get a cleaner and more performant structure.

List<List<String>> listOfLists = new ArrayList<>();
listOfLists.stream()
           .flatMap(Collection::stream)
           .forEach(System.out::println);

In this example, we convert each list into a flat stream with flatMap and then process the elements with forEach. This method makes the code both shorter and more performance-efficient.

Prefer Lightweight DTOs Instead of Entities

Returning data pulled from the database directly as Entity classes can lead to unnecessary data transfer. This is a very faulty method both in terms of security and performance. Instead, using DTO to return only the data needed improves API performance and prevents unnecessary large data transfers.

@Getter
@Setter
public class UserDTO {
    private String name;
    private String email;
}

Speaking of databases; Use EntityGraph, Indexing, and Lazy Fetch Feature

Database performance directly affects the speed of the application. Performance optimization is especially important when retrieving data between related tables. At this point, you can avoid unnecessary data loading by using EntityGraph and Lazy Fetching. At the same time, proper indexing in database queries dramatically improves query performance.

Optimized Data Extraction with EntityGraph

EntityGraph allows you to control the associated data in database queries. You pull only the data you need, avoiding the costs of eager fetching.

Eager Fetching is when the data in the related table automatically comes with the query.

@EntityGraph(attributePaths = {"addresses"})
User findUserByUserId(@Param("userId") Long userId);

In this example, address-related data and user information are retrieved in the same query. Unnecessary additional queries are avoided.

Avoid Unnecessary Data with Lazy Fetch

Unlike Eager Fetch, Lazy Fetch fetches data from related tables only when needed.

@OneToMany(fetch = FetchType.LAZY)
private List<Address> addresses;

Improve Performance with Indexing

Indexing is one of the most effective methods to improve the performance of database queries. A table in a database consists of rows and columns, and when a query is made, it is often necessary to scan all rows. Indexing speeds up this process, allowing the database to search faster over a specific field.

Lighten the Query Load by Using Cache

Caching is the process of temporarily storing frequently accessed data or computational results in a fast storage area such as memory. Caching aims to provide this information more quickly when the data or computation result is needed again. Especially in database queries and transactions with high computational costs, the use of cache can significantly improve performance.

Spring Boot’s @Cacheable annotation makes cache usage very easy.

@Cacheable("users")
public User findUserById(Long userId) {
    return userRepository.findById(userId);
}

In this example, when the findUserById method is called for the first time, the user information is retrieved from the database and stored in the cache. When the same user information is needed again, it is retrieved from the cache without going to the database.

You can also use a top-rated caching solution such as Redis for the needs of your project.

Conclusion

You can develop faster, more efficient, and scalable applications using these optimization techniques, especially in your back-end projects developed with Java.

...

Thank you for reading my article! If you have any questions, feedback or thoughts you would like to share, I would love to hear them in the comments.

You can follow me on Dev.to for more information on this topic and my other posts. Don’t forget to like my posts to help them reach more people!

Thank you!👨‍💻🚀

To follow me on LinkedIn: tamerardal
Read and Follow me on Medium: Boost Your Java Back-End Performance: Essential Optimization Tips!

Resources:

Simplify Null Checks in Java: Writing Clean Code with Apache Commons Lang 3

Tamer Ardal — Fri, 18 Oct 2024 20:17:31 +0000

Cover Photo by Redaco on dribble

In Java, null checks are generally done using == or !=. In addition, if we want to do an empty check, our condition will look like the following.

if (myString != null || myString != ""){
  // Not null or empty
}

if(myList != null || myList.size() != 0){
  // Not null or empty
}

if (myObject != null) {
  // Not Null
}

Such controls make your code repetitive and difficult to manage as it grows.

This is where the Apache Commons Lang 3 library comes in. We will examine 3 classes to make null or empty checks in objects and lists more reliable and more readable. First, let’s see how to add this library to our project.

How to Add Apache Commons Lang3 to Your Project

If you are using Maven, you can add the following dependency to your pom.xml file:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version> <!-- Check the version -->
</dependency>

If you are using Gradle, you can add the following dependency to your build.gradle file:

implementation 'org.apache.commons:commons-lang3:3.17.0'  // Check the version

ObjectUtils for General Null Checks

ObjectUtils has several useful methods that you can use to check objects and assign default values. Two of them are the isEmpty and isNotEmpty methods. These methods check whether the object is null or empty.

if (ObjectUtils.isEmpty(myObject)) {
  // Null or empty
}

if (ObjectUtils.isNotEmpty(myObject)) {
  // Not null or empty
}

You can also use Java Util.

if (Objects.isNull(myObject)) {
  // Null or empty
}

if (Objects.nonNull(myObject)) {
  // Not null or empty
}

If you want to assign a default value to an object in case it is null, you can use the defaultIfNull method of the ObjectUtils class.

Integer age = ObjectUtils.defaultIfNull(inputAge, 18);

Checking Strings for Null or Empty with StringUtils

Especially when working with String values, we need to do a lot of null or empty checking. In this case, we can easily do this with the StringUtils class.

if (StringUtils.isBlank(myString)) {
  // String is null, empty or contains only spaces
}

if (StringUtils.isNotBlank(myString)) {
  // String contains a valid value
}

If you only want to check for null or empty;

if (StringUtils.isEmpty(myString)) {
  // String null or empty
}

if (StringUtils.isNotEmpty(myString)) {
  // String contains a valid value (Can contain only spaces)
}

If the string is null or empty and you want to assign a default value to it;

String name = StringUtils.defaultIfBlank(inputName, "John Doe");

This allows us to assign a safe default value if the Strings are null, empty or space.

Collection Checks with CollectionUtils

When working with collections, it is essential to check for lists that are empty. With the CollectionUtils class you can make such checks quite simple.

To check if a collection is empty;

if (CollectionUtils.isEmpty(myList)) {
    // List is empty
}

if (CollectionUtils.isNotEmpty(myList)) {
    // List is valid
}

In this way, we can do both checks at once and make the code cleaner.

With Apache Commons Lang 3, you can make your code cleaner, reliable and maintainable by performing null checks in Java more easily. With this library, which is very easy to include in the project, you can reduce code complexity in your Java projects and create a better quality software development process by minimizing errors.

...

Thank you for reading my article! If you have any questions, feedback or thoughts you would like to share, I would love to hear them in the comments.

Thank you! 👨‍💻🚀

To follow me on LinkedIn: https://www.linkedin.com/in/tamerardal/
Medium: Simplify Null Checks in Java: Writing Clean Code with Apache Commons Lang 3

Resources:

Don’t use if-else blocks anymore! Use Strategy and Factory Pattern Together

Tamer Ardal — Fri, 18 Oct 2024 20:07:29 +0000

As we move forward in a project, lost in if-else blocks, struggling with complex conditions and repetitive code, we look for a solution. But why should we be stuck in if-else blocks? In this article, let’s discover the way to get rid of if-else confusion together with Strategy and Factory patterns.

Problem: If-Else Confusion

Let’s say you are developing an e-commerce application and you need to support different payment methods like credit card, debit card and cryptocurrency. You start with if-else blocks to process payments:

public class PaymentService {

    public void processPayment(String paymentType) {
        if (paymentType.equals("CREDIT_CARD")) {
            System.out.println("Processing credit card payment...");
        } else if (paymentType.equals("DEBIT_CARD")) {
            System.out.println("Processing debit card payment...");
        } else if (paymentType.equals("CRYPTO")) {
            System.out.println("Processing crypto payment...");
        } else {
            throw new IllegalArgumentException("Invalid payment type");
        }
    }
}

While it may seem simple at first, as payment methods increase, so will the if-else complexity. A new payment method means adding a new condition. The result is a pile of code that is difficult to manage. And this method is contrary to the Open-Closed Principle.

But, we can use the both Strategy and Factory patterns to solve this problem.

First, let’s create an enum:

public enum PaymentType {
    CREDIT_CARD,
    DEBIT_CARD,
    CRYPTO
}

Solution: Cleaning with Strategy Pattern

public interface PaymentStrategy {
    void pay(PaymentRequest request);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(PaymentRequest request) {
        System.out.println("Processing $type payment".replace("$type", String.valueOf(request.getPaymentType())));
    }
}

public class DebitCardPayment implements PaymentStrategy {
    @Override
    public void pay(PaymentRequest request) {
        System.out.println("Processing $type payment".replace("$type", String.valueOf(request.getPaymentType())));
    }
}

public class CryptoPayment implements PaymentStrategy {
    @Override
    public void pay(PaymentRequest request) {
        System.out.println("Processing $type payment".replace("$type", String.valueOf(request.getPaymentType())));
    }
}

At this stage, a separate strategy for each payment method is implemented from a common interface. Now, with Factory Pattern, we will decide which strategy to choose.

Step 2: Choosing Strategy with Factory Pattern

In this step, we can make the Factory Pattern cleaner and optimized with EnumMap.

public class PaymentFactory {
    private static final Map<PaymentType, PaymentStrategy> strategies = new EnumMap<>(PaymentType.class);

    static {
        strategies.put(PaymentType.CREDIT_CARD, new CreditCardPayment());
        strategies.put(PaymentType.DEBIT_CARD, new DebitCardPayment());
        strategies.put(PaymentType.CRYPTO, new CryptoPayment());
    }

    public static PaymentStrategy getPaymentStrategy(PaymentType paymentType) {
        PaymentStrategy strategy = strategies.get(paymentType);

        if (Objects.isNull(strategy))
            throw new IllegalArgumentException("Strategy not found");

        return strategy;
    }
}

Last Step: Service Class Reorganization

Now, let’s use what we have done.

public class PaymentService {

    public void processPayment(PaymentRequest request) {
        // Don't forget to check objects if null!
        if (Objects.isNull(request) || Objects.isNull(request.getPaymentType())
            throw new IllegalArgumentException("Request can not be null!");
        PaymentStrategy strategy = PaymentFactory.getPaymentStrategy(request.getPaymentType());

        strategy.pay(request);
    }
}

As it is, we don’t need any if-else blocks for payment processing. Thanks to Strategy and Factory Patterns, our code is cleaner, modular and extensible.

Why Should We Use This Patterns?

1. Extensibility: Adding a new payment method only requires a new class and a few lines of code.
2. Readability: By using strategies and factory instead of if-else blocks, you make your code more understandable and manageable.
3. Maintainability: With the strategy and factory pattern, changes to the code can be made without affecting other pieces of code.

Conclusion: From Confusion to Clarity

If you are working on a growing project, you shouldn’t use if-else blocks. Strategy and Factory patterns are perfect solutions to make your code cleaner, modular and maintainable.

As you can see in this article, using design patterns instead of if-else blocks to manage payment transactions makes the project more developable and improves the readability of the code. Try these patterns in your next project instead of using if-else blocks.

...

Thank you for reading my article! If you have any questions, feedback or thoughts you would like to share, I would love to hear them in the comments.

You can follow me on dev.to for more information on this topic and my other posts.

Thank you!👨‍💻🚀

To follow me on LinkedIn: https://www.linkedin.com/in/tamerardal/
Medium: Don’t use if-else blocks anymore! Use Strategy and Factory Pattern Together