Spring uygulamaların exception handling yönetimi

1. handle with
spring

2. Spring kullanmak bir REST API veya
mikro service geliştirme sürecini
hızlandırır ve API geliştiricilerinin
yalnızca temel iş sürecini yazmaya
odaklanmasına ve tüm temel
yapılandırmalar ve kurulum için
endişelenmenize izin vermez.

3. Server side
SERVER SIDE
@RestController annotation ile bir class oluşturun. Annotation
nedeniyle, bu class classpath scanning ile otomatik olarak
algılanacak ve @RequestMapping annotationı ile yazılan
method HTTP bitiş noktaları olarak gösterilecektir. Gelen bir
istek @RequestMapping annotationı ile belirtilen
gereksinimlerle eşleştiğinde, method requesti sunmak için
yürütülür.

4. Bir developerın bakış açısından, bir kullanıcı
listenin veritabanından alma akışı aşağıdaki
şekilde görülür:

5.  Bununla birlikte, Spring sahnelerin arkasında bizler için çok fazla iş
yaparken, her iki XML / JSON biçiminde yanıtı geri göndermek için bir
kaynağa bir HTTP request yapmak için tüm sürecin yaşam döngüsü bir
çok adım içerir.
 Bir requestte bulunduğunda, örneğin:
 Request : http: // localhost: 8080 / users
 Accept: application/json
 Bu gelen request, Spring tarafından otomatik olarak yapılandırılan
DispatcherServlet tarafından gerçekleştirilir.

6. Tüm gelen istekler tek bir servletten geçer: DispatcherServlet
Yeşilin içindeki bloklar, developer tarafından geliştirilen bloklardır.
Maviler ise Spring 

7. REST Serviceler İçin Spring ile Error Handling
 Spring 3.2'den önce, Spring exceptionları handle etmek için iki ana yaklaşım
şunlardı: HandlerExceptionResolver veya @ExceptionHandler annotationları.
Bunların her ikisinin de bazı olumsuz yönleri vardı.
 3.2'den beri, Spring önceki iki çözümün sınırlamalarını aşmak ve tüm bir
uygulama boyunca birleşik bir excption handling önermek için
@ControllerAdvice anotasyonuna sahip.
 Şimdi Spring 5, ResponseStatusException classına sahip: REST API’larımızda
temel error handling için hızlı bir yol.

8. Solution 1 – The Controller
level @ExceptionHandler
 @ExceptionHandler tüm uygulama için genel olarak değil, yalnızca bu belirli
method için etkindir.
1
2
3
4
5
6
7
8
public class FooController{
//...
@ExceptionHandler({ CustomException1.class,
CustomException2.class })
public void handleException() {
//
}
}

9. Solution 2 – The HandlerExceptionResolver
 İkinci çözüm bir HandlerExceptionResolver tanımlamaktır - bu, uygulamanın
attığı herhangi bir exeptionı handle edecektir. Ayrıca, REST API’mizde tek tip
bir exception handling mekanizması uygulamamıza izin verecektir.
 1. ExceptionHandlerExceptionResolver
 Bu handler Spring 3.1'de tanıtıldı ve default. @ExceptionHandler annotationın
temel bileşenidir.
 2. DefaultHandlerExceptionResolver
 Spring 3.0'da tanıtıldı ve default olarak DispatcherServlet'te etkinleştirildi.
Standart Spring exceptionlarını ilgili HTTP Status Kodlarına Client error – 4xx
and Server error – 5xx status codes. Çözümler.
 Tüm Exceptionları handle edip, HTTP kodları çözümlemesine rağmen hala bir
responsebody dönemiyordu. ModelAndView

10. Solution 2 – The HandlerExceptionResolver
 3.3. ResponseStatusExceptionResolver
 Bu handler Spring 3.0'da tanıtıldı ve default olarak DispatcherServlet'te etkin.
@ ResponseStatus Response statuslerine göre Custom exceptionları
implemente edebilmek için geliştirildi.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException
{
public ResourceNotFoundException() {
super();
}
public ResourceNotFoundException(String message, Throwable
cause) {
super(message, cause);
}
public ResourceNotFoundException(String message) {
super(message);
}
public ResourceNotFoundException(Throwable cause) {
super(cause);
}
}

11. Solution 2 – The HandlerExceptionResolver
 3.3. ResponseStatusExceptionResolver
 Bu handler Spring 3.0'da tanıtıldı ve default olarak DispatcherServlet'te etkin.
@ ResponseStatus Response statuslerine göre Custom exceptionları
implemente edebilmek için geliştirildi.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException
{
public ResourceNotFoundException() {
super();
}
public ResourceNotFoundException(String message, Throwable
cause) {
super(message, cause);
}
public ResourceNotFoundException(String message) {
super(message);
}
public ResourceNotFoundException(Throwable cause) {
super(cause);
}
}

12. Solution 2 – The HandlerExceptionResolver
 3.4. Custom HandlerExceptionResolver
 Custom exceptionlarla birlikte body de response a eklendi.
Solution 3 – @ControllerAdvice
 a global @ExceptionHandler with the @ControllerAdvice annotation

13. Solution 4 –
ResponseStatusException (Spring 5 and Above)
1
2
3
4
5
6
7
8
9
10
11
12
13
@GetMapping(value = "/{id}")
public Foo findById(@PathVariable("id") Long id,
HttpServletResponse response) {
try {
Foo resourceById =
RestPreconditions.checkFound(service.findOne(id));
eventPublisher.publishEvent(new
SingleResourceRetrievedEvent(this, response));
return resourceById;
}
catch (MyResourceNotFoundException exc) {
throw new ResponseStatusException(
HttpStatus.NOT_FOUND, "Foo Not Found", exc);
}
}

14. Handle the Access Denied in Spring Security
 6.1. MVC – Custom Error Page
 customize an error page for Access Denied
<http>
<intercept-url pattern="/admin/*" access="hasAnyRole('ROLE_ADMIN')"/>
...
<access-denied-handler error-page="/my-error-page" />
</http>
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/admin/*").hasAnyRole("ROLE_ADMIN")
...
.and()
.exceptionHandling().accessDeniedPage("/my-error-page");
}

15. 6.2. Custom AccessDeniedHandler
@Component
public class CustomAccessDeniedHandler implements
AccessDeniedHandler {
@Override
public void handle
(HttpServletRequest request, HttpServletResponse response,
AccessDeniedException ex)
throws IOException, ServletException {
response.sendRedirect("/my-error-page");
}
}

16. 6.2. Custom AccessDeniedHandler
@Autowired
private CustomAccessDeniedHandler accessDeniedHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/admin/*").hasAnyRole("ROLE_ADMIN")
...
.and()
.exceptionHandling().accessDeniedHandler(accessDeniedHandler)
}

17. 6.3. REST and Method Level Security
1
2
3
4
5
6
7
8
9
10
11
12
13
@ControllerAdvice
public class RestResponseEntityExceptionHandler
extends ResponseEntityExceptionHandler {
@ExceptionHandler({ AccessDeniedException.class })
public ResponseEntity<Object> handleAccessDeniedException(
Exception ex, WebRequest request) {
return new ResponseEntity<Object>(
"Access denied message here", new HttpHeaders(),
HttpStatus.FORBIDDEN);
}
...
}

18. 7. Spring Boot Support
 Whitelabel Error Page with errors for browsers
 We can provide our own view-resolver mapping for /error, overriding the
Whitelabel Page
1
2
3
4
5
6
7
{
"timestamp": "2019-01-17T16:12:45.977+0000",
"status": 500,
"error": "Internal Server Error",
"message": "Error processing the request!",
"path": "/my-endpoint-with-exceptions"
}

19. @Component
public class MyErrorController extends BasicErrorController {
public MyErrorController(ErrorAttributes errorAttributes) {
super(errorAttributes, new ErrorProperties());
}
@RequestMapping(produces = MediaType.APPLICATION_XML_VALUE)
public ResponseEntity<Map<String, Object>> xmlError(HttpServletRequest
request) {
// ...
}
}

20. Spring Retry
 Spring Retry, başarısız bir işlemi otomatik olarak yeniden başlatma yeteneği
sağlar. Bu, hataların doğada geçici olabileceği durumlarda yardımcı olur (anlık
bir ağ arızası gibi).
1
2
3
4
5
6
7
8
9
@Service
public interface MyService {
@Retryable(
value = { SQLException.class },
maxAttempts = 2,
backoff = @Backoff(delay = 5000))
void retryService(String sql) throws SQLException;
...
}
@Retyable

21. @Recover
1
2
3
4
5
6
@Service
public interface MyService {
...
@Recover
void recover(SQLException e, String sql);
}

22. RetryTemplate
1
2
3
4
5
public interface RetryOperations {
<T> T execute(RetryCallback<T> retryCallback) throws Exception;
...
}
1
2
3
public interface RetryCallback<T> {
T doWithRetry(RetryContext context) throws Throwable;
}
Spring Retry provides RetryOperations interface which supplies a set
of execute() methods:
The RetryCallback which is a parameter of the execute() is an interface that allows
insertion of business logic that needs to be retried upon failure:

23. RestTemplate Handling
 1. Default Error Handling
 HttpClientErrorException – in case of HTTP status 4xx
 HttpServerErrorException – in case of HTTP status 5xx
 UnknownHttpStatusCodeException – in case of an unknown HTTP status
 2. Implementing a ResponseErrorHandler
 Throw an exception that is meaningful to our application
 Simply ignore the HTTP status and let the response flow continue without
interruption
 demo

24. @Scheduled
1
2
3
4
5
@Scheduled(fixedDelay = 1000)
public void scheduleFixedDelayTask() {
System.out.println(
"Fixed delay task - " + System.currentTimeMillis() / 1000);
}
@Scheduled(fixedRate = 1000)
public void scheduleFixedRateTask() {
System.out.println(
"Fixed rate task - " + System.currentTimeMillis() / 1000);
}
Be careful about “Out of Memory”.
For configuration: https://www.baeldung.com/spring-
scheduled-tasks