Prise en charge de springMVC pour la gestion des exceptions

Quel que soit le projet que vous réalisez, la gestion des exceptions est très nécessaire et vous ne pouvez pas lancer certains codes d'erreur que seuls les programmeurs peuvent comprendre aux utilisateurs. Pour le moment, effectuez donc une gestion unifiée des exceptions pour afficher une comparaison. Des pages d'erreur conviviales sont nécessaires. . Comme les autres frameworks MVC, springMVC possède également son propre mécanisme de gestion des exceptions.
Il existe deux manières principales de gérer les exceptions fournies par springMVC. L'une consiste à implémenter directement votre propre HandlerExceptionResolver. Bien sûr, cela inclut également l'utilisation de SimpleMappingExceptionResolver et DefaultHandlerExceptionResolver que Spring nous a fournis. Contrôleur spécialisé pour la gestion des exceptions - ExceptionHandler.

1. Implémentez votre propre HandlerExceptionResolver. HandlerExceptionResolver est une interface qui a sa propre implémentation - DefaultHandlerExceptionResolver. sont interceptés, puis les codes d'erreur correspondants sont renvoyés. Bien entendu, vous pouvez également hériter de la classe DefaultHandlerExceptionResolver, puis réécrire certaines des méthodes de gestion des exceptions pour implémenter votre propre gestion des exceptions.

import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
  
import org.springframework.web.servlet.HandlerExceptionResolver;  
import org.springframework.web.servlet.ModelAndView;  
  
public class ExceptionHandler implements HandlerExceptionResolver {  
  
    @Override  public ModelAndView resolveException(HttpServletRequest request,  
            HttpServletResponse response, Object handler, Exception ex) {  // TODO Auto-generated method stub  return new ModelAndView("exception");  
    }  
  
}

L'exception de résolution ci-dessus Le 4 les paramètres indiquent quel type d’exception est géré. Étant donné que la classe Exception est la classe de base de toutes les classes d'exceptions, si vous souhaitez effectuer un traitement différent en fonction de différents types d'exception, vous pouvez effectuer un traitement différent en fonction de différents types d'exception dans la méthode solveException et renvoyer différentes vues d'exception. Par exemple :

public class ExceptionHandler implements HandlerExceptionResolver {  
  
    @Override  public ModelAndView resolveException(HttpServletRequest request,  
            HttpServletResponse response, Object handler, Exception ex) {  // TODO Auto-generated method stub  if (ex instanceof NumberFormatException) {  //doSomething...  return new ModelAndView("number");  
        } else if (ex instanceof NullPointerException) {  //doSomething...  return new ModelAndView("null");  
        }  return new ModelAndView("exception");  
    }  
  
}

Après avoir défini un tel gestionnaire d'exceptions, vous devez définir un tel objet bean dans applicationContext, tel que :

bean id="exceptionResolver" class="com.tiantian.xxx.web.handler.ExceptionHandler" />

En plus d'implémenter un DefaultHandlerExceptionResolver, Spring implémente également un SimpleMappingExceptionResolver , qui sont tous deux hérités de la classe abstraite AbstractHandlerExceptionResolver, et AbstractHandlerExceptionResolver implémente la méthode solveException de l'interface HandlerExceptionResolver et extrait ainsi deux méthodes abstraites, l'une est la méthode prepareResponse(exception, réponse) qui est exécutée avant la gestion des exceptions, l'autre est doResolveException. (demande, réponse, gestionnaire, exception) pour la résolution des exceptions. SimpleMappingExceptionResolver, comme son nom l'indique, utilise une relation de mappage simple pour déterminer quelle vue doit gérer le message d'erreur actuel. SimpleMappingExceptionResolver fournit la relation de mappage entre les exceptions et les vues via le type d'exception exceptionMappings, et fournit des statusCodes pour mapper le nom de la vue renvoyé par l'exception et le code retour HttpServletResponse correspondant lorsqu'une exception se produit. Et la valeur par défaut peut être spécifiée via defaultErrorView et defaultErrorCode. defaultErrorView signifie que lorsque le type d'exception correspondant n'est pas trouvé dans exceptionMappings, la vue définie par defaultErrorView sera renvoyée, ce qui signifie que lorsqu'une exception se produit, elle ne sera pas trouvée dans statusCodes. , la relation de mappage entre la vue et le code retour. Le mappage correspondant est le code retour renvoyé par défaut. Lors de l'utilisation de SimpleMappingExceptionResolver, lorsqu'une exception se produit, SimpleMappingExceptionResolver placera l'objet d'exception actuel dans son propre attribut exceptionAttribute. Lorsque exceptionAttribute n'est pas spécifié, exceptionAttribute utilise l'exception de valeur par défaut.

Ce qui suit est un exemple simple :

(1) Déclarez un bean SimpleMappingExceptionResolver dans le fichier de configuration du servlet de SpringMVC et configurez l'attribut exceptionMappings et defaultExceptionView pour spécifier la relation correspondante entre les exceptions et les vues

Xml代码

<bean>  
    <property>  
        <props>  
            <prop>number</prop><!-- 表示当抛出NumberFormatException的时候就返回名叫number的视图 -->  
            <prop>null</prop>  
        </props>  
    </property>  
    <property></property><!-- 表示当抛出异常但没有在exceptionMappings里面找到对应的异常时 返回名叫exception的视图-->  
    <property><!-- 定义在发生异常时视图跟返回码的对应关系 -->  
        <props>  
            <prop>500</prop><!-- 表示在发生NumberFormatException时返回视图number，然后这里定义发生异常时视图number对应的HttpServletResponse的返回码是500 -->  
            <prop>503</prop>  
        </props>  
    </property>  
    <property></property><!-- 表示在发生异常时默认的HttpServletResponse的返回码是多少，默认是200 -->  
</bean>

(2) Accédez comme suit :

@Controller  
@RequestMapping("/test")  
public class TestController {  
  
    @RequestMapping("/null")  public void testNullPointerException() {  
        Blog blog = null;  //这里就会发生空指针异常，然后就会返回定义在SpringMVC配置文件中的null视图          System.out.println(blog.getId());  
    }  
      
    @RequestMapping("/number")  public void testNumberFormatException() {  //这里就会发生NumberFormatException，然后就会返回定义在SpringMVC配置文件中的number视图  Integer.parseInt("abc");  
    }  
      
    @RequestMapping("/default")  public void testDefaultException() {  if (1==1)  //由于该异常类型在SpringMVC的配置文件中没有指定，所以就会返回默认的exception视图  throw new RuntimeException("Error!");  
    }  
      
}

(3) Objets d'exception accessibles dans les pages Jsp. Nous prenons ici la vue de retour number.jsp de NumberFormatException comme exemple :

Code Jsp

  
  
  
nbsp;HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
  
    
    <base>">  
      
    <title>My JSP 'number.jsp' starting page</title>  
      
    <meta>  
    <meta>  
    <meta>      
    <meta>  
    <meta>  
    <!--  
    <link rel="stylesheet" type="text/css" href="styles.css?1.1.11">  
    -->  
  
    
    
    
    NumberFormatException. <br>  
    <br>  
    <br><span><!-- 这是JSP中的内置对象exception --></span>  
  
  
  
    <br><span><!-- 这是SpringMVC放在返回的Model中的异常对象 --></span>  
  
  
  
    <span><!-- HttpServletResponse返回的错误码信息，因为前面已经配置了NumberFormatException的错误码返回值为888，所以这里应该显示888 --></span>  
  
  
  
    

(4)当请求/test/number.do的时候会返回定义好的number视图，返回结果如下：

 

2、使用@ExceptionHandler进行处理

 

使用@ExceptionHandler进行处理有一个不好的地方是进行异常处理的方法必须与出错的方法在同一个Controller里面

 

如：

Java代码  

 

import org.springframework.stereotype.Controller;  
import org.springframework.web.bind.annotation.ExceptionHandler;  
import org.springframework.web.bind.annotation.RequestMapping;  
  
import com.tiantian.blog.web.servlet.MyException;  
  
@Controller  
public class GlobalController {  
  
      /** 
     * 用于处理异常的 
     * @return 
     */  
    @ExceptionHandler({MyException.class})  public String exception(MyException e) {  
        System.out.println(e.getMessage());  
        e.printStackTrace();  return "exception";  
    }  
      
    @RequestMapping("test")  public void test() {  throw new MyException("出错了！");  
    }  
      
      
}

 

这里在页面上访问test方法的时候就会报错，而拥有该test方法的Controller又拥有一个处理该异常的方法，这个时候处理异常的方法就会被调用

 

 

优先级

既然在SpringMVC中有两种处理异常的方式，那么就存在一个优先级的问题：

 

当发生异常的时候，SpringMVC会如下处理：

（1）SpringMVC会先从配置文件找异常解析器HandlerExceptionResolver

（2）如果找到了异常异常解析器，那么接下来就会判断该异常解析器能否处理当前发生的异常

（3）如果可以处理的话，那么就进行处理，然后给前台返回对应的异常视图

（4）如果没有找到对应的异常解析器或者是找到的异常解析器不能处理当前的异常的时候，就看当前的Controller中有没有提供对应的异常处理器，如果提供了就由Controller自己进行处理并返回对应的视图

（5）如果配置文件里面没有定义对应的异常解析器，而当前Controller中也没有定义的话，那么该异常就会被抛出来。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!