İlkbaharda filtrelere eklenen istisnalar nasıl yönetilir?

119

5xx hata kodlarını yönetmek için genel bir yol kullanmak istiyorum, özellikle tüm yay uygulamamda db kapalı olduğunda durumu söyleyelim. Yığın izleme yerine güzel bir json hatası istiyorum.

Denetleyiciler @ControllerAdviceiçin farklı istisnalar için bir sınıfım var ve bu aynı zamanda db'nin isteğin ortasında durduğu durumunu da yakalıyor. Ama bu hepsi değil. Ayrıca özel bir CorsFilteruzantıya sahibim OncePerRequestFilterve orada aradığımda onu doFilteralırım CannotGetJdbcConnectionExceptionve tarafından yönetilmeyecek @ControllerAdvice. İnternette kafamı daha çok karıştıran birkaç şey okudum.

Bu yüzden çok sorum var:

  • Özel bir filtre uygulamam gerekiyor mu? Buldum ExceptionTranslationFilterama bu sadece kolları AuthenticationExceptionya AccessDeniedException.
  • Kendiminkini uygulamayı düşündüm HandlerExceptionResolver, ama bu beni şüpheye düşürdü, yönetmem gereken herhangi bir özel istisna yok, bundan daha açık bir yol olmalı. Ayrıca bir dene / yakala eklemeye ve bir uygulamasını çağırmaya çalıştım HandlerExceptionResolver(yeterince iyi olmalı, istisnam özel bir şey değil) ama bu yanıtta hiçbir şey döndürmüyor, 200 durumu ve boş bir gövde alıyorum.

Bununla başa çıkmanın iyi bir yolu var mı? Teşekkürler

java  spring  spring-security 
— Kopelitsa
kaynak
1
Spring Boot'un BasicErrorController'ını geçersiz kılabiliriz. Burada bununla ilgili blog yazdım: naturalprogrammer.com/blog/1685463/…
— Sanjay

Yanıtlar:

92

Ben de bunu yaptım:

Burada filtrelerle ilgili temel bilgileri okudum ve filtre zincirinde ilk sırada olacak ve orada meydana gelebilecek tüm çalışma zamanı istisnalarını yakalamak için bir deneme yakalamaya sahip olacak özel bir filtre oluşturmam gerektiğini anladım. Sonra json'u manuel olarak oluşturmam ve yanıta koymam gerekiyor.

İşte özel filtrem:

public class ExceptionHandlerFilter extends OncePerRequestFilter {

    @Override
    public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try {
            filterChain.doFilter(request, response);
        } catch (RuntimeException e) {

            // custom error response class used across my project
            ErrorResponse errorResponse = new ErrorResponse(e);

            response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
            response.getWriter().write(convertObjectToJson(errorResponse));
    }
}

    public String convertObjectToJson(Object object) throws JsonProcessingException {
        if (object == null) {
            return null;
        }
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(object);
    }
}

Ve sonra bunu web.xml dosyasında CorsFilter. Ve çalışıyor!

<filter> 
    <filter-name>exceptionHandlerFilter</filter-name> 
    <filter-class>xx.xxxxxx.xxxxx.api.controllers.filters.ExceptionHandlerFilter</filter-class> 
</filter> 


<filter-mapping> 
    <filter-name>exceptionHandlerFilter</filter-name> 
    <url-pattern>/*</url-pattern> 
</filter-mapping> 

<filter> 
    <filter-name>CorsFilter</filter-name> 
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> 
</filter> 

<filter-mapping>
    <filter-name>CorsFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
— Kopelitsa
kaynak
ErrorResponse Sınıfınızı gönderebilir misiniz?
— Shiva kumar
1
@Shivakumar ErrorResponse sınıfı muhtemelen basit kod / mesaj özelliklerine sahip basit bir DTO'dur.
— ratijas
35

@Kopelitsa cevabına göre bir çözüm sunmak istedim . Ana farklar şunlardır:

  1. Denetleyici istisna işlemesini HandlerExceptionResolver.
  2. XML yapılandırması üzerinden Java yapılandırmasını kullanma

Öncelikle, normal bir RestController / Controller'da meydana gelen istisnaları işleyen bir sınıfa sahip olduğunuzdan emin olmalısınız ( @RestControllerAdviceveya ile açıklamalı bir sınıf @ControllerAdviceve yöntem (ler) ile açıklama eklenmiştir @ExceptionHandler). Bu, bir denetleyicide meydana gelen istisnalarınızı ele alır. RestControllerAdvice kullanan bir örnek:

@RestControllerAdvice
public class ExceptionTranslator {

    @ExceptionHandler(RuntimeException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ErrorDTO processRuntimeException(RuntimeException e) {
        return createErrorDTO(HttpStatus.INTERNAL_SERVER_ERROR, "An internal server error occurred.", e);
    }

    private ErrorDTO createErrorDTO(HttpStatus status, String message, Exception e) {
        (...)
    }
}

Bu davranışı Spring Security filtre zincirinde yeniden kullanmak için, bir Filtre tanımlamanız ve bunu güvenlik yapılandırmanıza bağlamanız gerekir. Filtrenin istisnayı yukarıda tanımlanan istisna işlemeye yeniden yönlendirmesi gerekir. İşte bir örnek:

@Component
public class FilterChainExceptionHandler extends OncePerRequestFilter {

    private final Logger log = LoggerFactory.getLogger(getClass());

    @Autowired
    @Qualifier("handlerExceptionResolver")
    private HandlerExceptionResolver resolver;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        try {
            filterChain.doFilter(request, response);
        } catch (Exception e) {
            log.error("Spring Security Filter Chain Exception:", e);
            resolver.resolveException(request, response, null, e);
        }
    }
}

Oluşturulan filtrenin daha sonra Güvenlik Yapılandırmasına eklenmesi gerekir. Onu zincire çok erken bağlamanız gerekir, çünkü önceki filtrenin istisnaları yakalanmayacaktır. Benim durumumda LogoutFilter,. Resmi belgelerde varsayılan filtre zincirine ve sırasına bakın . İşte bir örnek:

@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Autowired
    private FilterChainExceptionHandler filterChainExceptionHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .addFilterBefore(filterChainExceptionHandler, LogoutFilter.class)
            (...)
    }

}
— ssc-hrep3
kaynak
Umut verici görünüyor ... Doğrulayıcılar tarafından atılan istisnaları işlemek için onu nasıl değiştirirsiniz ? Onlar da koşmak önceController .
— Honza Zídek
FilterChainExceptionHandleryalnızca Runtime istisnaları için çalışır. Gibi İşaretli İstisnalar için ne yapmalı MethodArgumentNotValidException, ServletRequestBindingException.vs
— Ayman Patel
1
Çok teşekkür ederim günümü yaptın, uğraşmak için çok zaman harcıyorum ama sonunda bunu gördüm ve harika çalışıyor
— Az.MaYo
19

Ben bu konuda kendimi karşıya gelip ben yeniden için aşağıdaki adımları gerçekleştirdikten benim ExceptionControllerile açıklamalı @ControllerAdviseiçin Exceptionskayıtlı Filtre atılmış.

Açıkça istisnayı ele almanın birçok yolu var, ancak benim durumumda istisnanın benim tarafımdan ele alınmasını istedim ExceptionControllerçünkü inatçıyım ve aynı kodu kopyalamak / yapıştırmak istemiyorum (yani bazı işleme / kayıt işlemim var kod girişi ExceptionController). JSONBir Filtreden değil atılan istisnaların geri kalanı gibi güzel yanıtı döndürmek istiyorum.

{
  "status": 400,
  "message": "some exception thrown when executing the request"
}

Her neyse, kendimden yararlanmayı başardım ExceptionHandlerve aşağıda adımlarda gösterildiği gibi biraz fazladan yapmak zorunda kaldım:

Adımlar

  1. Bir istisna atabilecek veya atmayacak özel bir filtreniz var
  2. @ControllerAdviseİe MyExceptionController'ı kullanarak istisnaları işleyen bir Spring denetleyiciniz var

Basit kod

//sample Filter, to be added in web.xml
public MyFilterThatThrowException implements Filter {
   //Spring Controller annotated with @ControllerAdvise which has handlers
   //for exceptions
   private MyExceptionController myExceptionController; 

   @Override
   public void destroy() {
        // TODO Auto-generated method stub
   }

   @Override
   public void init(FilterConfig arg0) throws ServletException {
       //Manually get an instance of MyExceptionController
       ApplicationContext ctx = WebApplicationContextUtils
                  .getRequiredWebApplicationContext(arg0.getServletContext());

       //MyExceptionHanlder is now accessible because I loaded it manually
       this.myExceptionController = ctx.getBean(MyExceptionController.class); 
   }

   @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;

        try {
           //code that throws exception
        } catch(Exception ex) {
          //MyObject is whatever the output of the below method
          MyObject errorDTO = myExceptionController.handleMyException(req, ex); 

          //set the response object
          res.setStatus(errorDTO .getStatus());
          res.setContentType("application/json");

          //pass down the actual obj that exception handler normally send
          ObjectMapper mapper = new ObjectMapper();
          PrintWriter out = res.getWriter(); 
          out.print(mapper.writeValueAsString(errorDTO ));
          out.flush();

          return; 
        }

        //proceed normally otherwise
        chain.doFilter(request, response); 
     }
}

Ve şimdi Exceptionnormal durumlarda işleyen örnek Yay Denetleyicisi (yani, genellikle Filtre düzeyinde atılmayan istisnalar, bir Filtrede atılan istisnalar için kullanmak istediğimiz istisnalar)

//sample SpringController 
@ControllerAdvice
public class ExceptionController extends ResponseEntityExceptionHandler {

    //sample handler
    @ResponseStatus(value = HttpStatus.BAD_REQUEST)
    @ExceptionHandler(SQLException.class)
    public @ResponseBody MyObject handleSQLException(HttpServletRequest request,
            Exception ex){
        ErrorDTO response = new ErrorDTO (400, "some exception thrown when "
                + "executing the request."); 
        return response;
    }
    //other handlers
}

Kullanmak isteyenler ile çözüm Paylaşım ExceptionControlleriçin Exceptionsbir Filtre atılmış.

— Raf
kaynak
10
Pekala, bunu yapmanın yolu gibi görünen kendi çözümünüzü paylaşabilirsiniz :)
— Raf
1
Filtrenize bir Denetleyicinin bağlanmasından kaçınmak istiyorsanız (@ Bato-BairTsyrenov'un kastettiği budur), ErrorDTO'yu oluşturduğunuz mantığı kendi @Componentsınıfına kolayca çıkarabilir ve bunu Filtrede ve içinde kullanabilirsiniz. kontrol eden, denetleyici.
— Rüdiger Schulz
1
Sizinle tamamen aynı fikirde değilim, çünkü bu, filtrenize belirli bir denetleyiciyi enjekte etmek için çok temiz değil.
— psv
Bahsedildiği gibi, answerbu yollardan biri! Bunun en iyi yol olduğunu iddia etmedim. Endişenizi paylaştığınız için teşekkür ederiz @psv Topluluğun aklınızdaki çözümü takdir edeceğinden eminim :)
— Raf
12

İşte yukarıdaki cevapların bir karışımına dayanarak yaptığım şey ... Zaten bir GlobalExceptionHandleraçıklama ekledik @ControllerAdviceve ayrıca filtrelerden gelen istisnaları ele almak için bu kodu yeniden kullanmanın bir yolunu bulmak istedim.

Bulabildiğim en basit çözüm, istisna işleyiciyi yalnız bırakmak ve aşağıdaki gibi bir hata denetleyicisi uygulamaktı:

@Controller
public class ErrorControllerImpl implements ErrorController {
  @RequestMapping("/error")
  public void handleError(HttpServletRequest request) throws Throwable {
    if (request.getAttribute("javax.servlet.error.exception") != null) {
      throw (Throwable) request.getAttribute("javax.servlet.error.exception");
    }
  }
}

Bu nedenle, istisnaların neden olduğu herhangi bir hata ilk önce ErrorControlleristisna işleyiciden geçer ve bunları bir @Controllerbağlam içinden yeniden atarak istisna işleyiciye yeniden yönlendirilirken , diğer hatalar (doğrudan bir istisnadan kaynaklanmayan) ErrorControllerdeğişiklik yapılmadan geçer .

Bunun gerçekten kötü bir fikir olmasının bir nedeni var mı?

— AndyB
kaynak
1
Şimdi bu çözümü test ederken teşekkürler ama benim durumumda mükemmel çalışıyor.
— Maciej
2.0+ bahar önyüklemesi için temiz ve basit bir ekleme @Override public String getErrorPath() { return null; }
— Fma
1
"javax.servlet.error.exception" yerine javax.servlet.RequestDispatcher.ERROR_EXCEPTION kullanabilirsiniz
— Marx
9

Genel bir yol istiyorsanız, web.xml'de bir hata sayfası tanımlayabilirsiniz:

<error-page>
  <exception-type>java.lang.Throwable</exception-type>
  <location>/500</location>
</error-page>

Ve Spring MVC'de eşleme ekleyin:

@Controller
public class ErrorController {

    @RequestMapping(value="/500")
    public @ResponseBody String handleException(HttpServletRequest req) {
        // you can get the exception thrown
        Throwable t = (Throwable)req.getAttribute("javax.servlet.error.exception");

        // customize response to what you want
        return "Internal server error.";
    }
}
— holmis83
kaynak
Ancak bir dinlenme durumunda, konumla yeniden yönlendiren api iyi bir çözüm değildir.
— jmattheis
@jmattheis Yukarıdakiler bir yönlendirme değildir.
— holmis83
Doğru, konumu gördüm ve http konumuyla bir ilgisi olduğunu düşündüm. O zaman ihtiyacım olan şey bu (:
— jmattheis
Varsa, web.xml ile eşdeğer Java yapılandırmasını ekleyebilir misiniz?
— k-den
1
@ k-den Mevcut spesifikasyonda Java yapılandırma eşdeğeri yok, ancak web.xml ve Java yapılandırmasını karıştırabilirsiniz.
— holmis83
5

Bu, varsayılan Spring Boot / hata işleyicisini geçersiz kılarak benim çözümüm

package com.mypackage;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.web.ErrorAttributes;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

/**
 * This controller is vital in order to handle exceptions thrown in Filters.
 */
@RestController
@RequestMapping("/error")
public class ErrorController implements org.springframework.boot.autoconfigure.web.ErrorController {

    private final static Logger LOGGER = LoggerFactory.getLogger(ErrorController.class);

    private final ErrorAttributes errorAttributes;

    @Autowired
    public ErrorController(ErrorAttributes errorAttributes) {
        Assert.notNull(errorAttributes, "ErrorAttributes must not be null");
        this.errorAttributes = errorAttributes;
    }

    @Override
    public String getErrorPath() {
        return "/error";
    }

    @RequestMapping
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest aRequest, HttpServletResponse response) {
        RequestAttributes requestAttributes = new ServletRequestAttributes(aRequest);
        Map<String, Object> result =     this.errorAttributes.getErrorAttributes(requestAttributes, false);

        Throwable error = this.errorAttributes.getError(requestAttributes);

        ResponseStatus annotation =     AnnotationUtils.getAnnotation(error.getClass(), ResponseStatus.class);
        HttpStatus statusCode = annotation != null ? annotation.value() : HttpStatus.INTERNAL_SERVER_ERROR;

        result.put("status", statusCode.value());
        result.put("error", statusCode.getReasonPhrase());

        LOGGER.error(result.toString());
        return new ResponseEntity<>(result, statusCode) ;
    }

}
— Walv
kaynak
herhangi bir otomatik yapılandırmayı etkiliyor mu?
— Samet Baskıcı
HandlerExceptionResolver'ın istisnayı işlemesi gerekmediğini unutmayın. Dolayısıyla, HTTP 200 olarak düşebilir. Yanıtlamadan önce response.setStatus (..) kullanılması daha güvenli görünür.
— ThomasRS
5

Sadece sağlanan diğer iyi yanıtları tamamlamak için, çok yakın zamanda basit bir SpringBoot uygulamasında istisnalar atabilecek filtreler içeren tek bir hata / istisna işleme bileşeni istediğimde , potansiyel olarak denetleyici yöntemlerinden atılan diğer istisnalarla.

Neyse ki, tutarlı yanıt yükleri sağlamak, mantığı paylaşmanıza, filtrelerden istisnaları incelemenize, hizmet tarafından atılan özel istisnaları yakalamanıza vb. İzin vermek için denetleyici tavsiyenizi Spring'in varsayılan hata işleyicisinin geçersiz kılma ile birleştirmenizi engelleyecek hiçbir şey yok gibi görünüyor.

Örneğin


@ControllerAdvice
@RestController
public class GlobalErrorHandler implements ErrorController {

  @ResponseStatus(HttpStatus.BAD_REQUEST)
  @ExceptionHandler(ValidationException.class)
  public Error handleValidationException(
      final ValidationException validationException) {
    return new Error("400", "Incorrect params"); // whatever
  }

  @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  @ExceptionHandler(Exception.class)
  public Error handleUnknownException(final Exception exception) {
    return new Error("500", "Unexpected error processing request");
  }

  @RequestMapping("/error")
  public ResponseEntity handleError(final HttpServletRequest request,
      final HttpServletResponse response) {

    Object exception = request.getAttribute("javax.servlet.error.exception");

    // TODO: Logic to inspect exception thrown from Filters...
    return ResponseEntity.badRequest().body(new Error(/* whatever */));
  }

  @Override
  public String getErrorPath() {
    return "/error";
  }

}
— Tom Bunting
kaynak
3

Bir uygulama durumunu test etmek istediğinizde ve bir sorun olması durumunda HTTP hatası döndürün, bir filtre öneririm. Aşağıdaki filtre tüm HTTP isteklerini işler. Spring Boot'ta javax filtreli en kısa çözüm.

Uygulamada çeşitli koşullar olabilir. Benim durumumda applicationManager uygulamanın hazır olup olmadığını test ediyor.

import ...ApplicationManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class SystemIsReadyFilter implements Filter {

    @Autowired
    private ApplicationManager applicationManager;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (!applicationManager.isApplicationReady()) {
            ((HttpServletResponse) response).sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, "The service is booting.");
        } else {
            chain.doFilter(request, response);
        }
    }

    @Override
    public void destroy() {}
}
— Cyva
kaynak
2

Yukarıdaki cevaplarda önerilen farklı yöntemleri okuduktan sonra, kimlik doğrulama istisnalarını özel bir filtre kullanarak ele almaya karar verdim. Aşağıdaki yöntemi kullanarak bir hata yanıt sınıfı kullanarak yanıt durumunu ve kodlarını işleyebildim.

AddFilterAfter yöntemini kullanarak ve CorsFilter sınıfından sonra ekleyerek özel bir filtre oluşturdum ve güvenlik yapılandırmamı değiştirdim.

@Component
public class AuthFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    //Cast the servlet request and response to HttpServletRequest and HttpServletResponse
    HttpServletResponse httpServletResponse = (HttpServletResponse) response;
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;

    // Grab the exception from the request attribute
    Exception exception = (Exception) request.getAttribute("javax.servlet.error.exception");
    //Set response content type to application/json
    httpServletResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);

    //check if exception is not null and determine the instance of the exception to further manipulate the status codes and messages of your exception
    if(exception!=null && exception instanceof AuthorizationParameterNotFoundException){
        ErrorResponse errorResponse = new ErrorResponse(exception.getMessage(),"Authetication Failed!");
        httpServletResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        PrintWriter writer = httpServletResponse.getWriter();
        writer.write(convertObjectToJson(errorResponse));
        writer.flush();
        return;
    }
    // If exception instance cannot be determined, then throw a nice exception and desired response code.
    else if(exception!=null){
            ErrorResponse errorResponse = new ErrorResponse(exception.getMessage(),"Authetication Failed!");
            PrintWriter writer = httpServletResponse.getWriter();
            writer.write(convertObjectToJson(errorResponse));
            writer.flush();
            return;
        }
        else {
        // proceed with the initial request if no exception is thrown.
            chain.doFilter(httpServletRequest,httpServletResponse);
        }
    }

public String convertObjectToJson(Object object) throws JsonProcessingException {
    if (object == null) {
        return null;
    }
    ObjectMapper mapper = new ObjectMapper();
    return mapper.writeValueAsString(object);
}
}

SecurityConfig sınıfı

    @Configuration
    public class JwtSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    AuthFilter authenticationFilter;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.addFilterAfter(authenticationFilter, CorsFilter.class).csrf().disable()
                .cors(); //........
        return http;
     }
   }

ErrorResponse sınıfı

public class ErrorResponse  {
private final String message;
private final String description;

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

public String getMessage() {
    return message;
}

public String getDescription() {
    return description;
}}
— Adewagold
kaynak
0

Catch bloğunun içinde aşağıdaki yöntemi kullanabilirsiniz:

response.sendError(HttpStatus.UNAUTHORIZED.value(), "Invalid token")

Herhangi bir HttpStatus kodunu ve özel bir mesajı kullanabileceğinizi unutmayın.

— Santiago Carrillo
kaynak
-1

Garip çünkü @ControllerAdvice çalışmalı, doğru İstisnayı mı yakalıyorsunuz?

@ControllerAdvice
public class GlobalDefaultExceptionHandler {

    @ResponseBody
    @ExceptionHandler(value = DataAccessException.class)
    public String defaultErrorHandler(HttpServletResponse response, DataAccessException e) throws Exception {
       response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
       //Json return
    }
}

Ayrıca CorsFilter'de bu istisnayı yakalamaya ve 500 hatası göndermeye çalışın, bunun gibi bir şey

@ExceptionHandler(DataAccessException.class)
@ResponseBody
public String handleDataException(DataAccessException ex, HttpServletResponse response) {
    response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
    //Json return
}
— kullanıcı2669657
kaynak
CorsFilter'deki istisnayı ele almak işe yarıyor, ancak çok temiz değil. Aslında gerçekten ihtiyacım olan şey tüm filtreler için istisnayı ele almak
— kopelitsa
35
İstisna atışı, Filteriçeri @ControllerAdviceulaşamayabileceği için yakalanamayabilir DispatcherServlet.
— Thanh Nguyen Van
-1

Bunun için özel bir Filtre oluşturmanıza gerek yoktur. Bunu, ServletException'ı genişleten (bildirimde gösterilen doFilter yönteminden atılan) özel istisnalar oluşturarak çözdük. Bunlar daha sonra global hata işleyicimiz tarafından yakalanır ve işlenir.

düzenleme: dilbilgisi

— beta-brad
kaynak
Genel hata işleyicinizin bir kod parçacığını paylaşır mısınız?
— Neeraj Vernekar
benim için çalışmıyor. ServletException'ı genişleten özel bir istisna yaptım, ExceptionHandler'da bu istisna için destek ekledim, ancak orada durdurulmadı.
— Marx
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.