1. Classificação de anomalia
As exceções de Java são divididas em duas categorias: "Verifique" e "não-verificação". A palavra "verificação" significa que, quando o código é compilado, o compilador verificará se há algum manuseio de exceção (captura ou vomitando). Para exceções classificadas como precisando ser verificadas, se não forem processadas, a compilação não poderá ser aprovada.
Quando eu era iniciante, muitas vezes me pergunto por que exceções deveriam ser tratadas dessa maneira? Mais tarde, entendi um pouco, existem apenas dois tipos de anormalidades: subjetivo e objetivo. Um pode ser evitado na maioria dos casos e o outro não pode ser evitado na maioria dos casos.
Exceções como NullPointerException estão principalmente ligadas às qualidades dos programadores (bem desenvolvidas e testadas, elas basicamente não aparecem após a execução do sistema). Eles podem basicamente ser evitados. A sintaxe Java os usou para classificar como "exceções não verificações", que também salvaram programadores e compiladores de muitos problemas;
Exceções relacionadas a ambientes externos, como a IOException, são quase inevitáveis (a rede desligará um dia e a outra). No entanto, ao encontrar inesperadamente, o programa ainda precisa fazer a diferença, para que o compilador precise instar o programador a verificar e ver se essas possíveis exceções inesperadas foram tratadas. Quando o objeto de exceção é passado para um nó, o programa pode executar algumas medidas, como: retornar um prompt ao usuário ("O sistema está ocupado, tente novamente"), empurrando uma mensagem de exceção para a plataforma de monitoramento etc.
2. Processamento de retorno unificado de exceções
1. Processamento de contêiner
Os seguintes lista os métodos de processamento do Tomcat, configuram -os em web.xml e lidam com eles de acordo com o código de retorno HTTP ou o tipo de exceção:
<rorwerp-age> <rorw-code> 404 </rorwror-code> <ctatherion> /web-inf/views/error/404.jsp </location> </rorwror-page> <rorwerp-page> <rorwerp-page> <leror-code> 500 </rortcode> <catchod> /web-inf/Views/error/500.jsp </locature> <loration> /web-inf/Views/error/500.jsp </locature> <Cextion-Type> java.lang.THOWABLE </Cenction-Type> <Cationaling> /web-inf/views/error/throwable.jsp </location> </rorwror-page>
Desvantagens: não é possível lidar com solicitações que não precisam retornar HTML, como o Ajax;
2. Processamento da estrutura
O seguinte lista os métodos de processamento do MVC da primavera
(1) Use o SimpleMappingExceptionResolver, o manipulador de exceção simples incluído no MVC da primavera;
(2) implementar o interface HandleRexceptionResolver Custom Exception Manipulador; (Recomenda -se usá -lo e pode suportar Ajax e outras extensões)
(3) use a anotação @ExceptionHandler para implementar o manuseio de exceções;
Tipo (1), configure em Spring-mvc.xml
<!-Vá para a exceção lançada pelo controlador para uma visualização específica-> <Bean> <propriedade name = "ExceptionMappings"> <Dors> <!-Exceções diferentes saltam separadamente-> <!-você pode personalizar diferentes exceções-> <Prop Key = "com.test.myexception1">/error/e1 </prop> <proport = "Com." Com.test.myexception1 ">/Error/e1 </prop> <proport =" Com. "Com.Test.myexception1">/Error/e1 </prop> <proport = "Com. Se você não deseja personalizar exceções, basta configurar o seguinte -> <propra key = "java.lang.Throwable">/error/500 </sprily </sports> </propriedade> </bean>
Desvantagens: não é possível lidar com solicitações que não precisam retornar HTML;
Tipo (2), a classe de implementação da interface personalizada de HandlerexceptionResolver
/** * Manipulador de exceção personalizado: suporta ajax * @author wangxu * */public class MyExceptionHandler implementa HandleRexceptionResolver {public ModelAndView ResolveException (httpservleTrequest Solicy, httpperLexesponse, handler de objeto, exceção ex) {/ * request.getheader ("x-requestado-with")! = null && "xmlhttprequest" .equals (request .getheader ("x-requestado-with"). tostring ()); if (! isajax) {if (ex instância de com.test.myexception1) {return new ModelAndView ("/erro/e1"); } else if (ex instância de com.test.myexception1) {return new ModelAndView ("/error/e2"); } else {return new ModelAndView ("/error/500"); }} String jsonres = "{/" message/":/" "" + "System Exception" + "/"} "; // Estrutura personalizada e encaixe em primeiro plano PrintWriter Out = null; tente {out = Response.getWriter (); request.setcharacterencoding ("UTF-8"); Response.setContentType ("Text/Plain; charset = utf-8"); out.print (jsonres); out.flush (); } catch (ioexception e) {e.printStackTrace (); } finalmente {out.close (); } retornar nulo; }}E registre o processador em Spring-mvc.xml
<bean id = "ExceptionHandler"/>
Vantagens: ele pode lidar com solicitações de Ajax e também é conveniente para a codificação implementar extensões funcionais, como monitoramento de exceções, etc.
Tipo (3), @ExceptionHandler Anotation
@ControllerPublic Classe testExceptionHandlerController {@ExceptionHandler ({myException1.class}) Public String Exception (myException1 e) {return "/error/e1"; } @RequestMapping ("/Mary") public void test () {throw New MyException1 ("Sem dinheiro!"); }}Desvantagens: O método do @ExceptionHandler deve estar sob o mesmo controlador que o método de possíveis exceções de lançamento. (Não recomendado)
3. Combinação
Em projetos reais, ao lidar com retornos uniformes de exceções, algumas exceções ou extensões personalizadas serão entregues à estrutura, e o mapeamento do código de retorno HTTP será entregue ao contêiner, porque o código de retorno HTTP é mais externo, alguns não podem alcançar a estrutura e alguns não são uma exceção à estrutura (como 404 e primavera. A estrutura é executada no contêiner. Quando a estrutura pega a exceção primeiro e a devolve, o contêiner não será mais mapeado.
O exposto acima é tudo sobre este artigo, espero que seja útil para o aprendizado de todos.