Simplifying RESTful API Error Handling in Spring Boot with @ControllerAdvice

Sivalokesh — Thu, 10 Oct 2024 16:10:25 +0000

Hi everyone,

I wanted to share a quick tip for handling errors in a more structured way in Spring Boot applications using @ControllerAdvice and @ExceptionHandler.

Problem: In a typical Spring Boot REST API, we may have multiple exceptions thrown across different controllers. Manually handling them can lead to duplicated code and inconsistent responses.

Solution: @ControllerAdvice provides a global error handling mechanism, allowing you to centralize exception handling logic. Here's an example:

`@ControllerAdvice
public class GlobalExceptionHandler {

@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<ErrorResponse> handleResourceNotFoundException(ResourceNotFoundException ex) {
    ErrorResponse errorResponse = new ErrorResponse("RESOURCE_NOT_FOUND", ex.getMessage());
    return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleGenericException(Exception ex) {
    ErrorResponse errorResponse = new ErrorResponse("INTERNAL_SERVER_ERROR", "An unexpected error occurred");
    return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
}

}

ErrorResponse Class:
public class ErrorResponse {
private String code;
private String message;

public ErrorResponse(String code, String message) {
    this.code = code;
    this.message = message;
}

// Getters and Setters

Key Takeaway: By using @ControllerAdvice, we can centralize error handling, making the code cleaner, more maintainable, and ensuring consistent error responses across the application.

I’d love to know if anyone has other tips for simplifying error handling or improving best practices in Spring Boot!

Cheers!

Optimizing Stream API Usage in Java for Large Data Sets

Sivalokesh — Thu, 10 Oct 2024 16:04:05 +0000

Hi everyone,

I wanted to share a quick optimization tip for those working with large datasets in Java using the Stream API. I recently encountered a performance bottleneck in one of my projects and found that using parallelStream() made a significant difference.

Here's a basic example:

`**List data = getLargeDataSet();

// Before: Normal stream
List filteredData = data.stream()
.filter(s -> s.contains("keyword"))
.collect(Collectors.toList());

// After: Parallel stream for better performance on large datasets
List filteredData = data.parallelStream()
.filter(s -> s.contains("keyword"))
.collect(Collectors.toList());**`

By switching to parallelStream(), the processing time for filtering large datasets reduced significantly on multi-core processors. However, be cautious when using parallelStream() in scenarios where thread safety is a concern or when working with smaller data sets, as the overhead may not always justify the performance gain.

I'd love to hear your thoughts or other optimization suggestions when working with Java Streams!

Cheers!

DEV Community: Sivalokesh

Simplifying RESTful API Error Handling in Spring Boot with @ControllerAdvice

Optimizing Stream API Usage in Java for Large Data Sets