Natuurlijk! Hier zijn enkele best practices en voorbeelden om je Java-toepassing met Spring effectiever te laten omgaan met uitzonderingen: 1. Gebruik specifieke try-catch-blokken voor belangrijke uitzonderingen Vermijd het vangen van alle uitzonderingen met een algemene catch (zoals catch (Exception e)). Richt je op specifieke uitzonderingen zoals NullPointerException om gerichte afhandeling mogelijk te maken. 2. Maak gebruik van @ControllerAdvice en @ExceptionHandler in Spring Spring biedt een elegante manier om globale foutafhandeling te implementeren via @ControllerAdvice. Hiermee kun je centrale foutbehandelingslogica definiëren. 3. Definieer custom exception classes Gebruik indien nodig je eigen exception classes voor duidelijkheid en betere controle. 4. Geef betekenisvolle foutberichten terug Voor API's is het belangrijk om duidelijke en bruikbare foutmeldingen te sturen naar de client. Voorbeeld 1: Specifieke try-catch in een service ```java public void verwerkData(Object data) { try { // Verwerking die NullPointerException kan veroorzaken data.toString(); } catch (NullPointerException e) { // Afhandeling van NullPointerException // Bijvoorbeeld loggen en een aangepaste foutmelding geven logger.error("Data is null", e); throw new CustomDataException("De data mag niet null zijn"); } } ``` Voorbeeld 2: Globale foutafhandeling met @ControllerAdvice ```java @RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(NullPointerException.class) public ResponseEntity<String> handleNullPointerException(NullPointerException ex) { // Log de fout log.error("NullPointerException opgetreden", ex); // Stuur een gepaste HTTP status en bericht return ResponseEntity.status(HttpStatus.BAD_REQUEST) .body("Er was een onverwachte fout: null referentie"); } @ExceptionHandler(CustomDataException.class) public ResponseEntity<String> handleCustomDataException(CustomDataException ex) { return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(ex.getMessage()); } @ExceptionHandler(Exception.class) public ResponseEntity<String> handleAlleOverigeFouten(Exception ex) { log.error("Onverwachte fout", ex); return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) .body("Er is een interne serverfout opgetreden"); } } ``` Voorbeeld 3: Custom exception class ```java public class CustomDataException extends RuntimeException { public CustomDataException(String message) { super(message); } } ``` Samenvatting: - Gebruik gerichte try-catch blokken voor kritieke code - Implementeer centrale foutbehandeling via @ControllerAdvice - Definieer zo nodig je eigen exception classes - Stuur duidelijke en bruikbare foutmeldingen naar de client Wil je meer details of voorbeelden voor specifieke scenario's?

Zeker, ik help je graag met het verbeteren van je uitzonderingafhandeling in Spring. Hier zijn de belangrijkste best practices met concrete voorbeelden: ## 1. Vermijd try-catch voor alle uitzonderingen **Niet aanbevolen:** ```java // ❌ Vermijd dit - te algemeen try { // je code hier } catch (Exception e) { // algemene afhandeling } ``` **Aanbevolen:** ```java // ✅ Specifieke uitzonderingen afhandelen try { userService.findUserById(userId); } catch (UserNotFoundException e) { logger.warn("Gebruiker niet gevonden: {}", userId); throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Gebruiker niet gevonden"); } catch (DataAccessException e) { logger.error("Database fout bij zoeken gebruiker", e); throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "Database fout"); } ``` ## 2. Gebruik Spring's @ControllerAdvice voor globale afhandeling ```java @ControllerAdvice public class GlobalExceptionHandler { private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class); // Afhandeling voor NullPointerException @ExceptionHandler(NullPointerException.class) public ResponseEntity<ErrorResponse> handleNullPointer(NullPointerException ex) { logger.error("NullPointerException opgetreden: ", ex); ErrorResponse error = ErrorResponse.builder() .timestamp(Instant.now()) .status(HttpStatus.BAD_REQUEST.value()) .error("Ongeldige aanvraag") .message("Verplichte gegevens ontbreken") .path(getCurrentRequestPath()) .build(); return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST); } // Afhandeling voor specifieke business uitzonderingen @ExceptionHandler(UserNotFoundException.class) public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException ex) { ErrorResponse error = ErrorResponse.builder() .timestamp(Instant.now()) .status(HttpStatus.NOT_FOUND.value()) .error("Niet gevonden") .message(ex.getMessage()) .path(getCurrentRequestPath()) .build(); return new ResponseEntity<>(error, HttpStatus.NOT_FOUND); } // Algemene afhandeling voor overige uitzonderingen @ExceptionHandler(Exception.class) public ResponseEntity<ErrorResponse> handleGenericException(Exception ex) { logger.error("Onverwachte fout opgetreden: ", ex); ErrorResponse error = ErrorResponse.builder() .timestamp(Instant.now()) .status(HttpStatus.INTERNAL_SERVER_ERROR.value()) .error("Interne serverfout") .message("Er is een onverwachte fout opgetreden") .path(getCurrentRequestPath()) .build(); return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR); } private String getCurrentRequestPath() { return ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()) .getRequest().getRequestURI(); } } ``` ## 3. Maak een gestructureerd ErrorResponse object ```java @Builder @Getter @JsonInclude(JsonInclude.Include.NON_NULL) public class ErrorResponse { private Instant timestamp; private int status; private String error; private String message; private String path; private List<ValidationError> validationErrors; @Getter @Builder public static class ValidationError { private String field; private String message; private Object rejectedValue; } } ``` ## 4. Voorkom NullPointerException met defensief programmeren ```java @Service public class UserService { // ✅ Gebruik Objects.requireNonNull voor validatie public User createUser(UserCreateRequest request) { Objects.requireNonNull(request, "User request mag niet null zijn"); Objects.requireNonNull(request.getEmail(), "Email is verplicht"); // Gebruik Optional om null te vermijden return userRepository.save(User.builder() .email(request.getEmail()) .name(Optional.ofNullable(request.getName()).orElse("")) .build()); } // ✅ Gebruik Optional voor method returns public Optional<User> findUserByEmail(String email) { return userRepository.findByEmail(email); } // ✅ Gebruik met streams public List<String> getUserNames(List<User> users) { return Optional.ofNullable(users) .orElse(Collections.emptyList()) .stream() .filter(Objects::nonNull) .map(User::getName) .filter(Objects::nonNull) .collect(Collectors.toList()); } } ``` ## 5. Valideer invoer met Spring Validation ```java @RestController @Validated public class UserController { @PostMapping("/users") public ResponseEntity<User> createUser(@Valid @RequestBody UserCreateRequest request) { User user = userService.createUser(request); return ResponseEntity.status(HttpStatus.CREATED).body(user); } @GetMapping("/users/{id}") public ResponseEntity<User> getUser(@PathVariable @Min(1) Long id) { User user = userService.findById(id) .orElseThrow(() -> new UserNotFoundException("Gebruiker niet gevonden met id: " + id)); return ResponseEntity.ok(user); } } // Validatie DTO @Data @Builder public class UserCreateRequest { @NotBlank(message = "Email is verplicht") @Email(message = "Ongeldig email formaat") private String email; @Size(min = 2, max = 50, message = "Naam moet tussen 2 en 50 karakters zijn") private String name; @Min(value = 18, message = "Leeftijd moet minimaal 18 zijn") private Integer age; } ``` ## 6. Gebruik custom exceptions voor business logic ```java // Custom business exception public class UserNotFoundException extends RuntimeException { public UserNotFoundException(String message) { super(message); } public UserNotFoundException(String message, Throwable cause) { super(message, cause); } } // Gebruik in service @Service @Transactional public class UserService { public User updateUser(Long userId, UserUpdateRequest request) { User user = userRepository.findById(userId) .orElseThrow(() -> new UserNotFoundException("Gebruiker niet gevonden: " + userId)); user.updateFrom(request); return userRepository.save(user); } } ``` ## 7. Logging best practices ```java @Service @Slf4j public class OrderService { public void processOrder(Order order) { try { log.info("Order verwerking gestart: {}", order.getId()); // business logic log.debug("Order details: {}", order); } catch (BusinessException e) { log.warn("Business fout bij order verwerking: {}", order.getId(), e); throw e; } catch (Exception e) { log.error("Onverwachte fout bij order verwerking: {}", order.getId(), e); throw new OrderProcessingException("Order verwerking mislukt", e); } } } ``` ## Belangrijkste voordelen van deze aanpak: - **Gestructureerde foutresponses** voor frontend - **Centrale foutafhandeling** via @ControllerAdvice - **Betere logging** en traceerbaarheid - **Voorkomen van NullPointerException** met defensief programmeren - **Duidelijke scheiding** tussen verschillende fouttypes Deze strategie zorgt voor consistente, onderhoudbare en gebruikersvriendelijke foutafhandeling in je Spring applicatie.