Horje
Optimizing Performance with Spring Data JPA

Optimizing Performance in Spring Data JPA is crucial for developing efficient, scalable, and responsive applications. Spring Data JPA simplifies database interactions in Java applications by providing a repository-based approach to data persistence.

Performance optimization with Spring Data JPA is crucial for ensuring that your application runs efficiently. This article will explore several strategies and best practices to optimize performance when using Spring Data JPA. For a more detailed introduction to this dependency, refer to What is Spring Data JPA.

Key Strategies for Performance Optimization in Spring Data JPA

Below are some approaches, which will help us to optimize the performance.

  1. Lazy Loading
  2. Pagination
  3. Caching
  4. Batch Processing
  5. Avoiding N+1 Select Problem

1. Lazy loading

Lazy loading essentially means loading some and not all of the results at a time, which saves time by not retrieving the possibly unnecessary data from the database.

@Entity
public class Author {
    @OneToMany(mappedBy = "author", fetch = FetchType.LAZY)
    private List<Book> books;
    // other fields and methods
}

2. Pagination

As explained in previous point, this dependency enables lazy loading. Hence it does a good job at pagination too, as user after scrolling through the few points on the page can desire to see more, which is only when the pagination algorithm shows more points, not more.

public interface BookRepository extends JpaRepository<Book, Long> {
    Page<Book> findAll(Pageable pageable);
}
Java 
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

@Service
public class BookService {   //BookService class
    private final BookRepository bookRepository;

    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    public Page<Book> getBooks(int page, int size) {
        PageRequest pageable = PageRequest.of(page, size);
        return bookRepository.findAll(pageable);  //returns all books by using findAll method
    }
}

3. Caching

Similar to how caching speeds up searches on our browsers, caching in Spring Data JPA fastens data retrieval from databases too using queries.

@SpringBootApplication
@EnableCaching
public class MyApplication {
    //...
}

Write below line in application.properties file to enable caching:

spring.cache.type=ehcache

4. Batch Processing

For operations involving multiple entities, batch processing can reduce the number of database calls.

@Modifying
@Query("UPDATE Customer c SET c.status = :status WHERE c.id IN :ids")
void updateCustomerStatus(@Param("status") String status, @Param("ids") List<Long> ids);


5. Avoiding N+1 Select Problem

The N+1 select problem occurs when an application executes one query to retrieve a list of entities (the “1” query) and then executes an additional query for each entity to retrieve related entities (the “N” queries). Use JOIN FETCH to solve this.

@Query("SELECT c FROM Customer c JOIN FETCH c.orders WHERE c.id = :id")
Customer findCustomerWithOrders(@Param("id") Long id);


Example of the numerous features offered by JpaRepository and CrudRepository

An object of any class extending JpaRepository offers more functions than its CrudRepository counterpart, with some of the functions listed below:

1. count(Example<S> example)

Java 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {     //BookService class
    private final BookRepository bookRepository;

    @Autowired              //Autowiring BookRepository
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    public long countBooks() {
        return bookRepository.count();
    }
}

2. exists(Example<S> example)

Java 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    public boolean doesBookExist(String title, String author) {
        Book exampleBook = new Book();     //new object created
        exampleBook.setTitle(title);       //calling the method parameter
        exampleBook.setAuthor(author);

        Example<Book> example = Example.of(exampleBook);

        return bookRepository.exists(example);
    }
}

3. flush(), return type: void

Java 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BookService {
    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Transactional
    public void saveAndFlushBook(Book book) {    //saveAndFlush method used
        bookRepository.save(book);
        bookRepository.flush();
    }
}

4. deleteInBatch(), return type: void

Java 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class BookService {
    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Transactional
    public void deleteBooksInBatch(List<Book> books) {
        bookRepository.deleteInBatch(books);       //for delete books using batch operation
    }
}

5. deleteAllInBatch(), return type: void

Java 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BookService {
    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Transactional
    public void deleteAllBooksInBatch() {
        bookRepository.deleteAllInBatch();   //delete all books using batch operation
    }
}

6. deleteAllByIdInBatch(Iterable<String> ids), return type: void

Java 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class BookService {
    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Transactional
    public void deleteBooksByIdInBatch(List<String> bookIds) {
        bookRepository.deleteAllByIdInBatch(bookIds);   //delete all books by Id
    }
}

7. saveAllAndFlush(Iterable<S> entities), return type: List<S>

Java 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class BookService {
    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Transactional
    public List<Book> saveAllAndFlushBooks(List<Book> books) {
        List<Book> savedBooks = bookRepository.saveAll(books);  //save all books by using saveAll
        bookRepository.flush();
        return savedBooks;
    }
}

8. saveAndFlush(S entity), return type: S

Java 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BookService {
    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Transactional             //to improve database performance @Transactional annotation is used
    public Book saveAndFlushBook(Book book) {
        return bookRepository.saveAndFlush(book);
    }
}

These functions help to considerably optimize the results and efficiency of the code, with more functionalities being inbuilt into the system thereby putting lesser pressure on the programmer.

Enable actuator endpoints in application.properties

management.endpoints.web.exposure.include=*

Conclusion

Optimizing performance with Spring Data JPA involves a combination of efficient data fetching strategies, query optimization, caching, batch processing, and avoiding common pitfalls like the N+1 select problem. Additionally, utilizing projections, ensuring proper indexing, and continuously monitoring and profiling your application are crucial steps to maintain optimal performance.

By implementing these strategies, you can significantly enhance the efficiency and responsiveness of your Spring Boot application.


 


Reffered: https://www.geeksforgeeks.org

Advance Java

Related
Spring Cloud Stream - Functional and Reactive Spring Cloud Stream - Functional and Reactive
Spring Data JPA vs Spring JDBC Template Spring Data JPA vs Spring JDBC Template
Struts 2 Custom Validation - Workflow Interceptor Struts 2 Custom Validation - Workflow Interceptor
Spring Boot - Handling Url Encoded Form Spring Boot - Handling Url Encoded Form
Hibernate Mapping Set using XML Hibernate Mapping Set using XML

Type:
 Geek
Category:
 Coding
Sub Category:
 Tutorial
Uploaded by:
 Admin
Views:
 13



 

Horje