1. Conclusão
O gerenciamento de transações do Spring reverte apenas exceções de tempo de execução (java.lang.RuntimeException e suas subclasses) por padrão.
Se um método lançar uma exceção Exception ou Checked, o gerenciamento de transações Spring não executa rollback por padrão.
Uma introdução detalhada à classificação de exceções:
1. Conceitos básicos <BR>Veja o diagrama da estrutura de exceções do java
Throwable é a raiz de todas as exceções, java.lang.Throwable
Erro é um erro, java.lang.Error
Exceção é uma exceção, java.lang.Exception
2. Exceção
Geralmente dividido em exceções verificadas e exceções de tempo de execução. Todas as instâncias da classe RuntimeException e suas subclasses são chamadas de exceções de tempo de execução, e as exceções que não se enquadram nesta categoria são chamadas de CheckedExceptions.
① Exceção verificada Apenas a linguagem Java fornece exceções verificadas. Java considera as exceções verificadas como exceções que podem ser tratadas, portanto, os programas Java devem manipular explicitamente as exceções verificadas. Se o programa não tratar a exceção Checked, ocorrerá um erro quando o programa for compilado e não poderá ser compilado. Isso reflete a filosofia de design do Java: código sem tratamento perfeito de erros não tem chance de ser executado. Existem duas maneiras de lidar com exceções verificadas
(1) Se o método atual souber como tratar a exceção, ele usará o bloco try...catch para tratar a exceção.
(2) Se o método atual não souber como lidar com isso, declare o lançamento da exceção ao definir o método.
Copie o código do código da seguinte forma:
pacote cn.xy.test;
importar java.io.IOException;
/**
* Método de teste de exceção verificado
* @autor xy
*
*/
classe pública CheckedExceptionMethods
{
//A classe de exceção total inclui checkException e RuntimeException, portanto acheckException deve ser processada
public void method1() lança exceção
{
System.out.println("Eu sou o método da classe geral que lança exceções");
}
//Captura e trata esta exceção
testMethod1_01() vazio público
{
tentar
{
método1();
}
pegar (Exceção e)
{
e.printStackTrace();
}
}
//Passa a exceção
public void testMethod1_02() lança exceção
{
método1();
}
public void testMethod1_03() lança exceção
{
lançar nova Exceção();
}
testMethod1_04() vazio público
{
tentar
{
lançar nova Exceção();
}
pegar (Exceção e)
{
e.printStackTrace();
}
}
//checkException normalmente representa IOException
public void method2() lança IOException
{
System.out.println("Eu sou o método que lança exceção IO");
}
testMethod2_01() vazio público
{
tentar
{
método2();
}
pegar (Exceção e)
{
e.printStackTrace();
}
}
public void testMethod2_02() lança exceção
{
método2();
}
}
As exceções verificadas com as quais estamos mais familiarizados incluem
Java.lang.ClassNotFoundException
Java.lang.NoSuchMetodException
java.io.IOException
②RuntimeException
Em tempo de execução, se o divisor for 0 ou o subscrito da matriz estiver fora dos limites, etc., eles ocorrem com frequência e são difíceis de lidar. A exibição de declarações ou capturas terá um grande impacto na legibilidade e na eficiência operacional do programa. Assim, o sistema os detecta automaticamente e os transfere para o manipulador de exceções padrão. Claro, você também pode capturá-los explicitamente se tiver requisitos de processamento.
Copie o código do código da seguinte forma:
pacote cn.xy.test;
/**
* Método de teste de exceção em tempo de execução
* @autor xy
*
*/
classe pública RuntimeExcetionMethods
{
public void method3() lança RuntimeException
{
System.out.println("Eu sou um método que lança exceções de tempo de execução");
}
testMethod3_01() vazio público
{
método3();
}
testMethod1_02() vazio público
{
lançar new RuntimeException();
}
}
As subclasses da classe RumtimeException com as quais estamos mais familiarizados incluem
Java.lang.ArithmeticException
Java.lang.ArrayStoreExcetpion
Java.lang.ClassCastException
Java.lang.IndexOutOfBoundsException
Java.lang.NullPointerException
3.Erro Quando ocorre um erro incontrolável em um programa, a abordagem usual é notificar o usuário e encerrar a execução do programa. Ao contrário das exceções, os objetos de Error e suas subclasses não devem ser lançados.
Error é uma subclasse de throwable que representa erros em tempo de compilação e de sistema e é usada para indicar problemas sérios que aplicativos razoáveis não deveriam tentar detectar.
Erros são gerados e lançados pela máquina virtual Java, incluindo falhas de link dinâmico, erros de máquina virtual, etc. O programa não o processa.
2. Altere o modo padrão <BR> Defina noRollbackFor e RollbackFor na anotação @Transaction para especificar se deseja reverter certas exceções.
@Transaction(noRollbackFor=RuntimeException.class)
@Transaction(RollbackFor=Exception.class)
Isso altera o método padrão de processamento de transações.
3. Iluminismo <BR>Isso exige que façamos a exceção customizada herdar de RuntimeException quando customizamos a exceção, para que quando ela for lançada, ela seja tratada com precisão pelo processamento de transação padrão do Spring.
